async def status_message_f(client, message):
aria_i_p = await aria_start()
# Show All Downloads
downloads = aria_i_p.get_downloads()
#
DOWNLOAD_ICON = "📥"
UPLOAD_ICON = "📤"
#
msg = ""
for download in downloads:
downloading_dir_name = "NA"
try:
downloading_dir_name = str(download.name)
except:
pass
total_length_size = str(download.total_length_string())
progress_percent_string = str(download.progress_string())
down_speed_string = str(download.download_speed_string())
up_speed_string = str(download.upload_speed_string())
download_current_status = str(download.status)
e_t_a = str(download.eta_string())
current_gid = str(download.gid)
#
msg += f"<u>{downloading_dir_name}</u>"
msg += " | "
msg += f"{total_length_size}"
msg += " | "
msg += f"{progress_percent_string}"
msg += " | "
msg += f"{DOWNLOAD_ICON} {down_speed_string}"
msg += " | "
msg += f"{UPLOAD_ICON} {up_speed_string}"
msg += " | "
msg += f"{e_t_a}"
msg += " | "
msg += f"{download_current_status}"
msg += " | "
msg += f"<code>{Commandi.CANCEL} {current_gid}</code>"
msg += " | "
msg += "\n\n"
LOGGER.info(msg)
if msg == "":
msg = Loilacaztion.NO_TOR_STATUS
currentTime = time_formatter((time.time() - BOT_START_TIME))
total, used, free = shutil.disk_usage(".")
total = humanbytes(total)
used = humanbytes(used)
free = humanbytes(free)
ms_g = f"<b>Bot Uptime</b>: <code>{currentTime}</code>\n" \
f"<b>Total disk space</b>: <code>{total}</code>\n" \
f"<b>Used</b>: <code>{used}</code>\n" \
f"<b>Free</b>: <code>{free}</code>\n"
msg = ms_g + "\n" + msg
await message.reply_text(msg, quote=True)
async def extract_youtube_dl_formats(url, yt_dl_user_name, yt_dl_pass_word,
user_working_dir):
command_to_exec = [
"youtube-dl", "--no-warnings", "--youtube-skip-dash-manifest", "-j",
url
]
if "hotstar" in url:
command_to_exec.append("--geo-bypass-country")
command_to_exec.append("IN")
#
if yt_dl_user_name is not None:
command_to_exec.append("--username")
command_to_exec.append(yt_dl_user_name)
if yt_dl_pass_word is not None:
command_to_exec.append("--password")
command_to_exec.append(yt_dl_pass_word)
LOGGER.info(command_to_exec)
process = await asyncio.create_subprocess_exec(
*command_to_exec,
# stdout must a pipe to be accessible as process.stdout
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
# Wait for the subprocess to finish
stdout, stderr = await process.communicate()
e_response = stderr.decode().strip()
# LOGGER.info(e_response)
t_response = stdout.decode().strip()
# LOGGER.info(t_response)
# https://github.com/rg3/youtube-dl/issues/2630#issuecomment-38635239
if e_response:
# logger.warn("Status : FAIL", exc.returncode, exc.output)
error_message = e_response.replace(
"please report this issue on https://yt-dl.org/bug . Make sure you are using the latest version; see https://yt-dl.org/update on how to update. Be sure to call youtube-dl with the --verbose flag and include its complete output.",
"")
return None, error_message, None
if t_response:
# logger.info(t_response)
x_reponse = t_response
response_json = []
if "\n" in x_reponse:
for yu_r in x_reponse.split("\n"):
response_json.append(json.loads(yu_r))
else:
response_json.append(json.loads(x_reponse))
# response_json = json.loads(x_reponse)
save_ytdl_json_path = user_working_dir + \
"/" + str("ytdleech") + ".json"
with open(save_ytdl_json_path, "w", encoding="utf8") as outfile:
json.dump(response_json, outfile, ensure_ascii=False)
# logger.info(response_json)
inline_keyboard = []
#
thumb_image = DEF_THUMB_NAIL_VID_S
#
for current_r_json in response_json:
# LOGGER.info(current_r_json)
#
thumb_image = current_r_json.get("thumbnails", None)
# LOGGER.info(thumb_image)
if thumb_image is not None:
# YouTube acts weirdly,
# and not in the same way as Telegram
thumb_image = thumb_image[-1]["url"]
if thumb_image is None:
thumb_image = DEF_THUMB_NAIL_VID_S
duration = None
if "duration" in current_r_json:
duration = current_r_json["duration"]
if "formats" in current_r_json:
for formats in current_r_json["formats"]:
format_id = formats.get("format_id")
format_string = formats.get("format_note")
if format_string is None:
format_string = formats.get("format")
# don't display formats, without audio
# https://t.me/c/1434259219/269937
if "DASH" in format_string.upper():
continue
format_ext = formats.get("ext")
approx_file_size = ""
if "filesize" in formats:
approx_file_size = humanbytes(formats["filesize"])
n_ue_sc = bool("video only" in format_string)
scneu = "DL" if not n_ue_sc else "XM"
dipslay_str_uon = " " + format_string + " (" + format_ext.upper(
) + ") " + approx_file_size + " "
cb_string_video = "{}|{}|{}|{}".format(
"video", format_id, format_ext, scneu)
ikeyboard = []
if "drive.google.com" in url:
if format_id == "source":
ikeyboard = [
InlineKeyboardButton(
dipslay_str_uon,
callback_data=(
cb_string_video).encode("UTF-8"))
]
else:
if format_string is not None and not "audio only" in format_string:
ikeyboard = [
InlineKeyboardButton(
dipslay_str_uon,
callback_data=(
cb_string_video).encode("UTF-8"))
]
else:
# special weird case :\
ikeyboard = [
InlineKeyboardButton(
"SVideo [" + "] ( " + approx_file_size +
" )",
callback_data=(
cb_string_video).encode("UTF-8"))
]
inline_keyboard.append(ikeyboard)
if duration is not None:
inline_keyboard.append([
InlineKeyboardButton("MP3 (64 kbps)",
callback_data="audio|64k|mp3|_"),
InlineKeyboardButton("MP3 (128 kbps)",
callback_data="audio|128k|mp3|_")
])
inline_keyboard.append([
InlineKeyboardButton("MP3 (320 kbps)",
callback_data="audio|320k|mp3|_")
])
else:
format_id = current_r_json["format_id"]
format_ext = current_r_json["ext"]
cb_string_video = "{}|{}|{}|{}".format("video", format_id,
format_ext, "DL")
inline_keyboard.append([
InlineKeyboardButton(
"SVideo",
callback_data=(cb_string_video).encode("UTF-8"))
])
# TODO: :\
break
reply_markup = InlineKeyboardMarkup(inline_keyboard)
# LOGGER.info(reply_markup)
succss_mesg = (
"Select the desired format: 👇\n"
"<u>mentioned</u> <i>file size might be approximate</i>")
return thumb_image, succss_mesg, reply_markup
async def upload_to_tg(
message,
local_file_name,
from_user,
dict_contatining_uploaded_files,
edit_media=False,
custom_caption=None,
force_doc=False,
cfn=None
):
LOGGER.info(local_file_name)
base_file_name = os.path.basename(local_file_name)
caption_str = custom_caption
if not (caption_str or edit_media):
LOGGER.info("fall-back to default file_name")
caption_str = "<code>"
caption_str += base_file_name
caption_str += "</code>"
# caption_str += "\n\n"
# caption_str += "<a href='tg://user?id="
# caption_str += str(from_user)
# caption_str += "'>"
# caption_str += "Here is the file to the link you sent"
# caption_str += "</a>"
if os.path.isdir(local_file_name):
directory_contents = os.listdir(local_file_name)
directory_contents.sort()
# number_of_files = len(directory_contents)
LOGGER.info(directory_contents)
new_m_esg = message
if not message.photo:
new_m_esg = await message.reply_text(
"Found {} files".format(len(directory_contents)),
quote=True
# reply_to_message_id=message.message_id
)
for single_file in directory_contents:
# recursion: will this FAIL somewhere?
await upload_to_tg(
new_m_esg,
os.path.join(local_file_name, single_file),
from_user,
dict_contatining_uploaded_files,
edit_media,
caption_str,
force_doc=force_doc,
cfn=cfn
)
else:
if os.path.getsize(local_file_name) > TG_MAX_FILE_SIZE:
LOGGER.info("TODO")
d_f_s = humanbytes(os.path.getsize(local_file_name))
i_m_s_g = await message.reply_text(
"Telegram does not support uploading this file.\n"
f"Detected File Size: {d_f_s} 😡\n"
"\n🤖 trying to split the files 🌝🌝🌚"
)
splitted_dir = await split_large_files(local_file_name)
totlaa_sleif = os.listdir(splitted_dir)
totlaa_sleif.sort()
number_of_files = len(totlaa_sleif)
LOGGER.info(totlaa_sleif)
ba_se_file_name = os.path.basename(local_file_name)
await i_m_s_g.edit_text(
f"Detected File Size: {d_f_s} 😡\n"
f"<code>{ba_se_file_name}</code> splitted into {number_of_files} files.\n"
"trying to upload to Telegram, now ..."
)
for le_file in totlaa_sleif:
# recursion: will this FAIL somewhere?
await upload_to_tg(
message,
os.path.join(splitted_dir, le_file),
from_user,
dict_contatining_uploaded_files,
force_doc=force_doc,
cfn=cfn
)
else:
sent_message = await upload_single_file(
message,
local_file_name,
caption_str,
from_user,
edit_media,
force_doc,
cfn
)
if sent_message is not None:
dict_contatining_uploaded_files[os.path.basename(local_file_name)] = sent_message.message_id
# await message.delete()
return dict_contatining_uploaded_files