def list_drive(update, context):
if update.message.text == f'/{BotCommands.ListCommand}':
sendMessage(
f'Send a search key along with {BotCommands.ListCommand} command',
context.bot, update)
else:
search = update.message.text.split(' ', maxsplit=1)[1]
LOGGER.info(f"Searching: '{search}'...")
reply = sendMessage('Searching.....\nPlease Wait!', context.bot,
update)
gdrive = GoogleDriveHelper(None)
msg, button = gdrive.drive_list(search)
if msg:
if button:
editMessage(msg, reply, button)
else:
editMessage(msg, reply)
else:
editMessage('No results found', reply)
# if not USE_TELEGRAPH:
# threading.Thread(target=auto_delete_message, args=(context.bot, update.message, reply)).start()
list_handler = CommandHandler(BotCommands.ListCommand,
list_drive,
filters=CustomFilters.authorized_chat
| CustomFilters.authorized_user,
run_async=True)
dispatcher.add_handler(list_handler)
else:
dl.download().cancel_download()
sleep(1) # Wait a Second For Aria2 To free Resources.
clean_download(f'{DOWNLOAD_DIR}{mirror_message.message_id}/')
def cancel_all(update, context):
with download_dict_lock:
count = 0
for dlDetails in list(download_dict.values()):
if dlDetails.status() == MirrorStatus.STATUS_DOWNLOADING \
or dlDetails.status() == MirrorStatus.STATUS_WAITING:
dlDetails.download().cancel_download()
count += 1
delete_all_messages()
sendMessage(f'Cancelled {count} downloads!', context.bot, update)
cancel_mirror_handler = CommandHandler(
BotCommands.CancelMirrorCommand,
cancel_mirror,
filters=(CustomFilters.authorized_chat | CustomFilters.authorized_user)
& CustomFilters.mirror_owner_filter,
run_async=True)
cancel_all_handler = CommandHandler(BotCommands.CancelAllCommand,
cancel_all,
filters=CustomFilters.owner_filter,
run_async=True)
dispatcher.add_handler(cancel_all_handler)
dispatcher.add_handler(cancel_mirror_handler)
from tgchizu.helper.ext_utils.bot_utils import get_readable_message
from telegram.error import BadRequest
from tgchizu.helper.telegram_helper.filters import CustomFilters
from tgchizu.helper.telegram_helper.bot_commands import BotCommands
import threading
def mirror_status(update, context):
message = get_readable_message()
if len(message) == 0:
message = "No active downloads"
reply_message = sendMessage(message, context.bot, update)
threading.Thread(target=auto_delete_message,
args=(bot, update.message, reply_message)).start()
return
index = update.effective_chat.id
with status_reply_dict_lock:
if index in status_reply_dict.keys():
deleteMessage(bot, status_reply_dict[index])
del status_reply_dict[index]
sendStatusMessage(update, context.bot)
deleteMessage(context.bot, update.message)
mirror_status_handler = CommandHandler(BotCommands.StatusCommand,
mirror_status,
filters=CustomFilters.authorized_chat
| CustomFilters.authorized_user,
run_async=True)
dispatcher.add_handler(mirror_status_handler)
"""App Quota."""
Apps = result["apps"]
for apps in Apps:
if apps.get("app_uuid") == app.id:
AppQuotaUsed = apps.get("quota_used") / 60
AppPercent = math.floor(apps.get("quota_used") * 100 / quota)
break
else:
AppQuotaUsed = 0
AppPercent = 0
AppHours = math.floor(AppQuotaUsed / 60)
AppMinutes = math.floor(AppQuotaUsed % 60)
sendMessage(
f"<b>Dyno Usage for</b> <code>{app.name}</code> :\n"
f"• <code>{AppHours}</code> <b>Hours and</b> <code>{AppMinutes}</code> <b>Minutes - {AppPercent}%</b>\n\n"
"<b>Dyno Remaining this month :</b>\n"
f"• <code>{hours}</code> <b>Hours and</b> <code>{minutes}</code> <b>Minutes - {quota_percent}%</b>",
context.bot,
update
)
return True
dyno_usage_handler = CommandHandler(command=BotCommands.UsageCommand, callback=dyno_usage,
filters=CustomFilters.owner_filter)
dispatcher.add_handler(dyno_usage_handler)
from telegram.ext import CommandHandler
from tgchizu.helper.mirror_utils.upload_utils.gdriveTools import GoogleDriveHelper
from tgchizu.helper.telegram_helper.message_utils import *
from tgchizu.helper.telegram_helper.filters import CustomFilters
from tgchizu.helper.telegram_helper.bot_commands import BotCommands
from tgchizu import dispatcher
def cloneNode(update, context):
args = update.message.text.split(" ", maxsplit=1)
if len(args) > 1:
link = args[1]
msg = sendMessage(f"Cloning: <code>{link}</code>", context.bot, update)
gd = GoogleDriveHelper()
result, button = gd.clone(link)
deleteMessage(context.bot, msg)
if button == "":
sendMessage(result, context.bot, update)
else:
sendMarkup(result, context.bot, update, button)
else:
sendMessage("Provide G-Drive Shareable Link to Clone.", context.bot, update)
clone_handler = CommandHandler(BotCommands.CloneCommand, cloneNode,
filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
dispatcher.add_handler(clone_handler)
buttons = [InlineKeyboardButton('Search Expired', 'nyaa_nop')]
else:
if current_page == 1:
buttons.pop(0)
if current_page == pages:
buttons.pop()
if ttl_ended or current_page != og_current_page:
await callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup([
buttons
]))
message_info[message_identifier] = user_id, ttl, query, current_page, pages, sukebei
if ttl_ended:
ignore.add(message_identifier)
await callback_query.answer()
def searchhelp(update, context):
help_string = '''
• /ts <i>[search query]</i>
• /nyaa <i>[search query]</i>
• /nyaasi <i>[search query]</i>
• /sts <i>[search query]</i>
• /sukebei <i>[search query]</i>
'''
sendMessage(help_string, context.bot, update)
SEARCHHELP_HANDLER = CommandHandler("tshelp", searchhelp)
dispatcher.add_handler(SEARCHHELP_HANDLER)
setInterval(DOWNLOAD_STATUS_UPDATE_INTERVAL, update_all_messages))
def mirror(update, context):
_mirror(context.bot, update)
def tar_mirror(update, context):
_mirror(context.bot, update, True)
def unzip_mirror(update, context):
_mirror(context.bot, update, extract=True)
mirror_handler = CommandHandler(BotCommands.MirrorCommand,
mirror,
filters=CustomFilters.authorized_chat
| CustomFilters.authorized_user)
tar_mirror_handler = CommandHandler(BotCommands.TarMirrorCommand,
tar_mirror,
filters=CustomFilters.authorized_chat
| CustomFilters.authorized_user)
unzip_mirror_handler = CommandHandler(BotCommands.UnzipMirrorCommand,
unzip_mirror,
filters=CustomFilters.authorized_chat
| CustomFilters.authorized_user)
dispatcher.add_handler(mirror_handler)
dispatcher.add_handler(tar_mirror_handler)
dispatcher.add_handler(unzip_mirror_handler)
from telegram import Update
from tgchizu import dispatcher, LOGGER
from tgchizu.helper.telegram_helper.message_utils import auto_delete_message, sendMessage
from tgchizu.helper.telegram_helper.filters import CustomFilters
from tgchizu.helper.telegram_helper.bot_commands import BotCommands
from tgchizu.helper.mirror_utils.upload_utils import gdriveTools
def deletefile(update, context):
msg_args = update.message.text.split(None, 1)
msg = ''
try:
link = msg_args[1]
LOGGER.info(msg_args[1])
except IndexError:
msg = 'send a link along with command'
if msg == '':
drive = gdriveTools.GoogleDriveHelper()
msg = drive.deletefile(link)
LOGGER.info(f"this is msg : {msg}")
reply_message = sendMessage(msg, context.bot, update)
threading.Thread(target=auto_delete_message, args=(context.bot, update.message, reply_message)).start()
delete_handler = CommandHandler(command=BotCommands.DeleteCommand, callback=deletefile,
filters=CustomFilters.owner_filter)
dispatcher.add_handler(delete_handler)
msg += f" [〽️]({image})"
update.effective_message.reply_text(
msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(buttons))
else:
update.effective_message.reply_text(
msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(buttons))
def weebhelp(update, context):
help_string = '''
• /anime: search anime
• /character: search character
• /manga: search manga
'''
sendMessage(help_string, context.bot, update)
ANIME_HANDLER = CommandHandler("anime", anime)
CHARACTER_HANDLER = CommandHandler("character", character)
MANGA_HANDLER = CommandHandler("manga", manga)
WEEBHELP_HANDLER = CommandHandler("weebhelp", weebhelp)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(WEEBHELP_HANDLER)
else:
try:
result = f'{repr(eval(body, env))}'
except:
pass
else:
result = f'{value}{func_return}'
if result:
return result
@dev_plus
def clear(update: Update, context: CallbackContext):
bot = context.bot
log_input(update)
global namespaces
if update.message.chat_id in namespaces:
del namespaces[update.message.chat_id]
send("Cleared locals.", bot, update)
EVAL_HANDLER = CommandHandler(('e', 'ev', 'eva', 'eval'), evaluate)
EXEC_HANDLER = CommandHandler(('x', 'ex', 'exe', 'exec', 'py'), execute)
CLEAR_HANDLER = CommandHandler('clearlocals', clear)
dispatcher.add_handler(EVAL_HANDLER)
dispatcher.add_handler(EXEC_HANDLER)
dispatcher.add_handler(CLEAR_HANDLER)
)
else:
msg.reply_text(
"Failed to create sticker pack. Possibly due to blek mejik.")
def stickhelp(update, context):
help_string = '''
• /stickerid: Reply to a sticker to me to tell you its file ID.
• /getsticker: Reply to a sticker to me to upload its raw PNG file.
• /kang: Reply to a sticker to add it to your pack.
• /remove: Replay to a sticker to remove sticker from an existing pack.
• /stickers: Find stickers for given term on combot sticker catalogue.
'''
sendMessage(help_string, context.bot, update)
STICKERID_HANDLER = CommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = CommandHandler("getsticker", getsticker)
KANG_HANDLER = CommandHandler("kang", kang)
DEL_HANDLER = CommandHandler("remove", delsticker)
STICKERS_HANDLER = CommandHandler("stickers", cb_sticker)
STICKHELP_HANDLER = CommandHandler("stickerhelp", stickhelp)
dispatcher.add_handler(STICKERS_HANDLER)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
dispatcher.add_handler(DEL_HANDLER)
dispatcher.add_handler(STICKHELP_HANDLER)
msg = 'Chat unauthorized'
else:
msg = 'Already unauthorized chat'
else:
# Trying to authorize someone in specific
user_id = reply_message.from_user.id
if user_id in AUTHORIZED_CHATS:
AUTHORIZED_CHATS.remove(user_id)
msg = 'Person unauthorized to use the bot!'
else:
msg = 'Person already unauthorized!'
with open('authorized_chats.txt', 'a') as file:
file.truncate(0)
for i in AUTHORIZED_CHATS:
file.write(f'{i}\n')
sendMessage(msg, context.bot, update)
authorize_handler = CommandHandler(command=BotCommands.AuthorizeCommand,
callback=authorize,
filters=CustomFilters.owner_filter
& Filters.group,
run_async=True)
unauthorize_handler = CommandHandler(command=BotCommands.UnAuthorizeCommand,
callback=unauthorize,
filters=CustomFilters.owner_filter
& Filters.group,
run_async=True)
dispatcher.add_handler(authorize_handler)
dispatcher.add_handler(unauthorize_handler)
return
cmd = cmd[1]
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
stdout, stderr = process.communicate()
reply = ''
stderr = stderr.decode()
stdout = stdout.decode()
if stdout:
reply += f"*Stdout*\n`{stdout}`\n"
LOGGER.info(f"Shell - {cmd} - {stdout}")
if stderr:
reply += f"*Stderr*\n`{stderr}`\n"
LOGGER.error(f"Shell - {cmd} - {stderr}")
if len(reply) > 3000:
with open('shell_output.txt', 'w') as file:
file.write(reply)
with open('shell_output.txt', 'rb') as doc:
context.bot.send_document(document=doc,
filename=doc.name,
reply_to_message_id=message.message_id,
chat_id=message.chat_id)
else:
message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
SHELL_HANDLER = CommandHandler(['sh', 'shell', 'term', 'terminal'], shell)
dispatcher.add_handler(SHELL_HANDLER)
<b>Country:</b> <code>{result['server']['country']}, {result['server']['cc']}</code>
<b>Sponsor:</b> <code>{result['server']['sponsor']}</code>
<b>SpeedTest Results</b>
<b>Upload:</b> <code>{speed_convert(result['upload'] / 8)}</code>
<b>Download:</b> <code>{speed_convert(result['download'] / 8)}</code>
<b>Ping:</b> <code>{result['ping']} ms</code>
<b>ISP:</b> <code>{result['client']['isp']}</code>
'''
ed_msg.delete()
try:
update.effective_message.reply_photo(path, string_speed, parse_mode=ParseMode.HTML)
except:
update.effective_message.reply_text(string_speed, parse_mode=ParseMode.HTML)
def speed_convert(size):
"""Hi human, you can't read bytes?"""
power = 2 ** 10
zero = 0
units = {0: "", 1: "Kb/s", 2: "MB/s", 3: "Gb/s", 4: "Tb/s"}
while size > power:
size /= power
zero += 1
return f"{round(size, 2)} {units[zero]}"
SPEED_HANDLER = CommandHandler(BotCommands.SpeedCommand, speedtest,
filters=CustomFilters.authorized_chat | CustomFilters.authorized_user)
dispatcher.add_handler(SPEED_HANDLER)
