def DownLoadFile(url, file_name, chunk_size, client, ud_type, message_id,
chat_id):
if os.path.exists(file_name):
os.remove(file_name)
if not url:
return file_name
r = requests.get(url, allow_redirects=True, stream=True)
# https://stackoverflow.com/a/47342052/4723940
total_size = int(r.headers.get("content-length", 0))
downloaded_size = 0
with open(file_name, 'wb') as fd:
for chunk in r.iter_content(chunk_size=chunk_size):
if chunk:
fd.write(chunk)
downloaded_size += chunk_size
if client is not None:
if ((total_size // downloaded_size) % 5) == 0:
time.sleep(0.3)
try:
client.edit_message_text(
chat_id,
message_id,
text="{}: {} of {}".format(
ud_type, humanbytes(downloaded_size),
humanbytes(total_size)))
except:
pass
return file_name
async def download_coroutine(bot, session, url, file_name, chat_id, message_id,
start):
downloaded = 0
display_message = ""
async with session.get(url, timeout=PROCESS_MAX_TIMEOUT) as response:
total_length = int(response.headers["Content-Length"])
content_type = response.headers["Content-Type"]
if "text" in content_type and total_length < 500:
return await response.release()
await bot.edit_message_text(chat_id,
message_id,
text="""Initiating Download
URL: {}
File Size: {}""".format(url, humanbytes(total_length)))
with open(file_name, "wb") as f_handle:
while True:
chunk = await response.content.read(CHUNK_SIZE)
if not chunk:
break
f_handle.write(chunk)
downloaded += CHUNK_SIZE
now = time.time()
diff = now - start
if round(diff % 5.00) == 0 or downloaded == total_length:
# percentage = downloaded * 100 / total_length
speed = downloaded / diff
elapsed_time = round(diff) * 1000
time_to_completion = round(
(total_length - downloaded) / speed) * 1000
estimated_total_time = elapsed_time + time_to_completion
try:
current_message = """**Download Status**
URL: {}
File Size: {}
Downloaded: {}
ETA: {}
@M3U8ConverterBOT""".format(url, humanbytes(total_length),
humanbytes(downloaded),
TimeFormatter(estimated_total_time))
if current_message != display_message:
await bot.edit_message_text(chat_id,
message_id,
text=current_message)
display_message = current_message
except Exception as e:
LOGGER.info(str(e))
pass
return await response.release()
async def youtube_dl_call_back(bot, update):
cb_data = update.data
# youtube_dl extractors
tg_send_type, youtube_dl_format, youtube_dl_ext = cb_data.split("|")
thumb_image_path = DOWNLOAD_LOCATION + \
"/" + str(update.from_user.id) + ".jpg"
save_ytdl_json_path = DOWNLOAD_LOCATION + \
"/" + str(update.from_user.id) + ".json"
try:
with open(save_ytdl_json_path, "r", encoding="utf8") as f:
response_json = json.load(f)
except FileNotFoundError:
await update.message.delete()
return False
youtube_dl_url, \
custom_file_name, \
youtube_dl_username, \
youtube_dl_password = get_link(
update.message.reply_to_message
)
if not custom_file_name:
custom_file_name = str(response_json.get("title")) + \
"_" + youtube_dl_format + "." + youtube_dl_ext
await update.message.edit_caption(caption=Translation.DOWNLOAD_START)
description = Translation.CUSTOM_CAPTION_UL_FILE
if "fulltitle" in response_json:
description = response_json["fulltitle"][0:1021]
# escape Markdown and special characters
tmp_directory_for_each_user = os.path.join(DOWNLOAD_LOCATION,
str(update.from_user.id))
if not os.path.isdir(tmp_directory_for_each_user):
os.makedirs(tmp_directory_for_each_user)
download_directory = os.path.join(tmp_directory_for_each_user,
custom_file_name)
command_to_exec = []
if tg_send_type == "audio":
command_to_exec = [
"youtube-dl", "-c", "--max-filesize",
str(TG_MAX_FILE_SIZE), "--prefer-ffmpeg", "--extract-audio",
"--audio-format", youtube_dl_ext, "--audio-quality",
youtube_dl_format, youtube_dl_url, "-o", download_directory
]
else:
minus_f_format = youtube_dl_format
if "youtu" in youtube_dl_url:
minus_f_format = youtube_dl_format + "+bestaudio"
command_to_exec = [
"youtube-dl", "-c", "--max-filesize",
str(TG_MAX_FILE_SIZE), "--embed-subs", "-f", minus_f_format,
"--hls-prefer-ffmpeg", youtube_dl_url, "-o", download_directory
]
if HTTP_PROXY is not None:
command_to_exec.append("--proxy")
command_to_exec.append(HTTP_PROXY)
if youtube_dl_username is not None:
command_to_exec.append("--username")
command_to_exec.append(youtube_dl_username)
if youtube_dl_password is not None:
command_to_exec.append("--password")
command_to_exec.append(youtube_dl_password)
command_to_exec.append("--no-warnings")
# command_to_exec.append("--quiet")
command_to_exec.append("--restrict-filenames")
LOGGER.info(command_to_exec)
start = datetime.now()
t_response, e_response = await run_shell_command(command_to_exec)
LOGGER.info(e_response)
LOGGER.info(t_response)
if e_response and Translation.YTDL_ERROR_MESSAGE in e_response:
error_message = e_response.replace(Translation.YTDL_ERROR_MESSAGE, "")
await update.message.edit_caption(caption=error_message)
return False
if t_response:
# LOGGER.info(t_response)
os.remove(save_ytdl_json_path)
end_one = datetime.now()
time_taken_for_download = (end_one - start).seconds
file_size = TG_MAX_FILE_SIZE + 1
download_directory_dirname = os.path.dirname(download_directory)
download_directory_contents = os.listdir(download_directory_dirname)
for download_directory_c in download_directory_contents:
current_file_name = os.path.join(download_directory_dirname,
download_directory_c)
file_size = os.stat(current_file_name).st_size
if file_size > TG_MAX_FILE_SIZE:
await update.message.edit_caption(
caption=Translation.RCHD_TG_API_LIMIT.format(
time_taken_for_download, humanbytes(file_size)))
else:
is_w_f = False
images = await generate_screen_shots(
current_file_name, tmp_directory_for_each_user, is_w_f, "",
300, 9)
LOGGER.info(images)
await update.message.edit_caption(
caption=Translation.UPLOAD_START)
# get the correct width, height, and duration
# for videos greater than 10MB
# ref: message from @BotSupport
width = 0
height = 0
duration = 0
if tg_send_type != "file":
metadata = extractMetadata(createParser(current_file_name))
if metadata is not None:
if metadata.has("duration"):
duration = metadata.get('duration').seconds
# get the correct width, height, and duration
# for videos greater than 10MB
if os.path.exists(thumb_image_path):
# https://stackoverflow.com/a/21669827/4723940
Image.open(thumb_image_path).convert("RGB").save(
thumb_image_path)
metadata = extractMetadata(createParser(thumb_image_path))
if metadata.has("width"):
width = metadata.get("width")
if metadata.has("height"):
height = metadata.get("height")
if tg_send_type == "vm":
height = width
else:
thumb_image_path = None
start_time = time.time()
# try to upload file
if tg_send_type == "audio":
await update.message.reply_audio(
audio=current_file_name,
caption=description,
parse_mode="HTML",
duration=duration,
# performer=response_json["uploader"],
# title=response_json["title"],
# reply_markup=reply_markup,
thumb=thumb_image_path,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START,
update.message, start_time))
elif tg_send_type == "file":
await update.message.reply_document(
document=current_file_name,
thumb=thumb_image_path,
caption=description,
parse_mode="HTML",
# reply_markup=reply_markup,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START,
update.message, start_time))
elif tg_send_type == "vm":
await update.message.reply_video_note(
video_note=current_file_name,
duration=duration,
length=width,
thumb=thumb_image_path,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START,
update.message, start_time))
elif tg_send_type == "video":
await update.message.reply_video(
video=current_file_name,
caption=description,
parse_mode="HTML",
duration=duration,
width=width,
height=height,
supports_streaming=True,
# reply_markup=reply_markup,
thumb=thumb_image_path,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START,
update.message, start_time))
else:
LOGGER.info("Did this happen? :\\")
end_two = datetime.now()
time_taken_for_upload = (end_two - end_one).seconds
#
media_album_p = []
if images is not None:
i = 0
caption = "Thank You for Using @M3U8ConverterBOT"
for image in images:
if os.path.exists(image):
if i == 0:
media_album_p.append(
InputMediaPhoto(media=image,
caption=caption,
parse_mode="html"))
else:
media_album_p.append(
InputMediaPhoto(media=image))
i = i + 1
await update.message.reply_media_group(
media=media_album_p, disable_notification=True)
#
shutil.rmtree(tmp_directory_for_each_user, ignore_errors=True)
os.remove(thumb_image_path)
await update.message.delete()
async def echo(bot, update: Message):
if update.from_user.id in BLACKLIST_USERS:
await update.delete()
await bot.send_message(
chat_id=update.chat.id,
text=Translation.FISHY.format(update.chat.id),
parse_mode="markdown",
reply_to_message_id=update.message_id,
disable_web_page_preview=True
)
return
# LOGGER.info(update)
# await bot.send_chat_action(
# chat_id=update.chat.id,
# action="typing"
# )
LOGGER.info(update.from_user)
url, _, youtube_dl_username, youtube_dl_password = get_link(update)
if HTTP_PROXY is not None:
command_to_exec = [
"youtube-dl",
"--no-warnings",
"--youtube-skip-dash-manifest",
"-j",
url,
"--proxy", HTTP_PROXY
]
else:
command_to_exec = [
"youtube-dl",
"--no-warnings",
"--youtube-skip-dash-manifest",
"-j",
url
]
if youtube_dl_username is not None:
command_to_exec.append("--username")
command_to_exec.append(youtube_dl_username)
if youtube_dl_password is not None:
command_to_exec.append("--password")
command_to_exec.append(youtube_dl_password)
# logger.info(command_to_exec)
t_response, e_response = await run_shell_command(command_to_exec)
# https://github.com/rg3/youtube-dl/issues/2630#issuecomment-38635239
if e_response and "nonnumeric port" not in e_response:
# logger.warn("Status : FAIL", exc.returncode, exc.output)
error_message = e_response.replace(
Translation.YTDL_ERROR_MESSAGE,
""
)
if Translation.ISOAYD_PREMIUM_VIDEOS in error_message:
error_message += Translation.SET_CUSTOM_USERNAME_PASSWORD
await update.reply_text(
text=Translation.NO_VOID_FORMAT_FOUND.format(str(error_message)),
quote=True,
parse_mode="html",
disable_web_page_preview=True
)
return False
if t_response:
# logger.info(t_response)
x_reponse = t_response
if "\n" in x_reponse:
x_reponse, _ = x_reponse.split("\n")
response_json = json.loads(x_reponse)
save_ytdl_json_path = DOWNLOAD_LOCATION + \
"/" + str(update.from_user.id) + ".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 = []
duration = None
if "duration" in response_json:
duration = response_json["duration"]
if "formats" in response_json:
for formats in response_json["formats"]:
format_id = formats.get("format_id")
format_string = formats.get("format_note")
if format_string is None:
format_string = formats.get("format")
format_ext = formats.get("ext")
approx_file_size = ""
if "filesize" in formats:
approx_file_size = humanbytes(formats["filesize"])
cb_string_video = "{}|{}|{}".format(
"video", format_id, format_ext)
cb_string_file = "{}|{}|{}".format(
"file", format_id, format_ext)
if format_string and "audio only" not in format_string:
ikeyboard = [
InlineKeyboardButton(
f"S {format_string} video {format_ext} ",
callback_data=(cb_string_video).encode("UTF-8")
),
InlineKeyboardButton(
f"D {format_string} video {approx_file_size} ",
callback_data=(cb_string_file).encode("UTF-8")
)
]
else:
# special weird case :\
ikeyboard = [
InlineKeyboardButton(
"SVideo [" +
"] ( " +
approx_file_size + " )",
callback_data=(cb_string_video).encode("UTF-8")
),
InlineKeyboardButton(
"DFile [" +
"] ( " +
approx_file_size + " )",
callback_data=(cb_string_file).encode("UTF-8")
)
]
inline_keyboard.append(ikeyboard)
if duration is not None:
cb_string_64 = "{}|{}|{}".format("audio", "64k", "mp3")
cb_string_128 = "{}|{}|{}".format("audio", "128k", "mp3")
cb_string = "{}|{}|{}".format("audio", "320k", "mp3")
inline_keyboard.append([
InlineKeyboardButton(
"MP3 " + "(" + "64 kbps" + ")",
callback_data=cb_string_64.encode("UTF-8")
),
InlineKeyboardButton(
"MP3 " + "(" + "128 kbps" + ")",
callback_data=cb_string_128.encode("UTF-8")
)
])
inline_keyboard.append([
InlineKeyboardButton(
"MP3 " + "(" + "320 kbps" + ")",
callback_data=cb_string.encode("UTF-8")
)
])
else:
format_id = response_json["format_id"]
format_ext = response_json["ext"]
cb_string_file = "{}|{}|{}".format(
"file", format_id, format_ext)
cb_string_video = "{}|{}|{}".format(
"video", format_id, format_ext)
inline_keyboard.append([
InlineKeyboardButton(
"SVideo",
callback_data=(cb_string_video).encode("UTF-8")
),
InlineKeyboardButton(
"DFile",
callback_data=(cb_string_file).encode("UTF-8")
)
])
cb_string_file = "{}={}={}".format(
"file", format_id, format_ext)
cb_string_video = "{}={}={}".format(
"video", format_id, format_ext)
inline_keyboard.append([
InlineKeyboardButton(
"video",
callback_data=(cb_string_video).encode("UTF-8")
),
InlineKeyboardButton(
"file",
callback_data=(cb_string_file).encode("UTF-8")
)
])
reply_markup = InlineKeyboardMarkup(inline_keyboard)
# logger.info(reply_markup)
thumbnail = DEF_THUMB_NAIL_VID_S
thumbnail_image = DEF_THUMB_NAIL_VID_S
if "thumbnail" in response_json:
if response_json["thumbnail"] is not None:
thumbnail = response_json["thumbnail"]
thumbnail_image = response_json["thumbnail"]
thumb_image_path = DownLoadFile(
thumbnail_image,
DOWNLOAD_LOCATION + "/" +
str(update.from_user.id) + ".jpg",
CHUNK_SIZE,
None, # bot,
Translation.DOWNLOAD_START,
update.message_id,
update.chat.id
)
await bot.send_message(
chat_id=update.chat.id,
text=Translation.FORMAT_SELECTION.format(thumbnail) + "\n" + Translation.SET_CUSTOM_USERNAME_PASSWORD,
reply_markup=reply_markup,
parse_mode="html",
reply_to_message_id=update.message_id
)
else:
# fallback for nonnumeric port a.k.a seedbox.io
inline_keyboard = []
cb_string_file = "{}={}={}".format(
"file", "LFO", "NONE")
cb_string_video = "{}={}={}".format(
"video", "OFL", "ENON")
inline_keyboard.append([
InlineKeyboardButton(
"SVideo",
callback_data=(cb_string_video).encode("UTF-8")
),
InlineKeyboardButton(
"DFile",
callback_data=(cb_string_file).encode("UTF-8")
)
])
reply_markup = InlineKeyboardMarkup(inline_keyboard)
await update.reply_photo(
photo=DEF_THUMB_NAIL_VID_S,
quote=True,
caption=Translation.FORMAT_SELECTION.format(""),
reply_markup=reply_markup,
parse_mode="html",
reply_to_message_id=update.message_id
)