async def song(client, message):
chat_id = message.chat.id
user_id = message.from_user["id"]
args = get_arg(message) + " " + "song"
if args.startswith(" "):
await message.reply("Enter a song name. Check /help")
return ""
status = await message.reply("Processing...")
video_link = yt_search(args)
if not video_link:
await status.edit("Song not found.")
return ""
yt = YouTube(video_link)
audio = yt.streams.filter(only_audio=True).first()
try:
download = audio.download(filename=f"{str(user_id)}")
except Exception as ex:
await status.edit("Failed to download song")
LOGGER.error(ex)
return ""
rename = os.rename(download, f"{str(user_id)}.mp3")
await pbot.send_chat_action(message.chat.id, "upload_audio")
await pbot.send_audio(
chat_id=message.chat.id,
audio=f"{str(user_id)}.mp3",
duration=int(yt.length),
title=str(yt.title),
performer=str(yt.author),
reply_to_message_id=message.message_id,
)
await status.delete()
os.remove(f"{str(user_id)}.mp3")
def __list_all_modules():
import glob
from os.path import basename, dirname, isfile
# This generates a list of modules in this folder for the * in __main__ to work.
mod_paths = glob.glob(dirname(__file__) + "/*.py")
all_modules = [
basename(f)[:-3] for f in mod_paths
if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
]
if LOAD or NO_LOAD:
to_load = LOAD
if to_load:
if not all(
any(mod == module_name for module_name in all_modules)
for mod in to_load):
LOGGER.error("Invalid loadorder names. Quitting.")
quit(1)
all_modules = sorted(set(all_modules) - set(to_load))
to_load = list(all_modules) + to_load
else:
to_load = all_modules
if NO_LOAD:
LOGGER.info("Not loading: {}".format(NO_LOAD))
return [item for item in to_load if item not in NO_LOAD]
return to_load
return all_modules
def error_handler(update, context):
"""Log the error and send a telegram message to notify the developer."""
# Log the error before we do anything else, so we can see it even if something breaks.
LOGGER.error(msg="Exception while handling an update:", exc_info=context.error)
# traceback.format_exception returns the usual python message about an exception, but as a
# list of strings rather than a single string, so we have to join them together.
tb_list = traceback.format_exception(
None, context.error, context.error.__traceback__
)
tb = "".join(tb_list)
# Build the message with some markup and additional information about what happened.
message = (
"An exception was raised while handling an update\n"
"<pre>update = {}</pre>\n\n"
"<pre>{}</pre>"
).format(
html.escape(json.dumps(update.to_dict(), indent=2, ensure_ascii=False)),
html.escape(tb),
)
if len(message) >= 4096:
message = message[:4096]
# Finally, send the message
context.bot.send_message(chat_id=OWNER_ID, text=message, parse_mode=ParseMode.HTML)
def shell(update: Update, context: CallbackContext):
message = update.effective_message
cmd = message.text.split(" ", 1)
if len(cmd) == 1:
message.reply_text("No command to execute was given.")
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)
def shell(bot: Bot, update: Update):
message = update.effective_message
cmd = message.text.split(' ', 1)
if len(cmd) == 1:
message.reply_text('Yürütme komutu verilmedi.')
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:
bot.send_document(
document = doc,
filename = f.name,
reply_to_message_id = message.message_id,
chat_id = message.chat_id
)
else:
message.reply_text(reply, parse_mode = ParseMode.MARKDOWN)