async def echo(bot, update):
# logger.info(update)
TRChatBase(update.from_user.id, update.text, "/echo")
# await bot.send_chat_action(
# chat_id=update.chat.id,
# action="typing"
# )
logger.info(update.from_user)
url = update.text
youtube_dl_username = None
youtube_dl_password = None
file_name = None
if "|" in url:
url_parts = url.split("|")
if len(url_parts) == 2:
url = url_parts[0]
file_name = url_parts[1]
elif len(url_parts) == 4:
url = url_parts[0]
file_name = url_parts[1]
youtube_dl_username = url_parts[2]
youtube_dl_password = url_parts[3]
else:
for entity in update.entities:
if entity.type == "text_link":
url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
url = url[o:o + l]
if url is not None:
url = url.strip()
if file_name is not None:
file_name = file_name.strip()
# https://stackoverflow.com/a/761825/4723940
if youtube_dl_username is not None:
youtube_dl_username = youtube_dl_username.strip()
if youtube_dl_password is not None:
youtube_dl_password = youtube_dl_password.strip()
logger.info(url)
logger.info(file_name)
else:
for entity in update.entities:
if entity.type == "text_link":
url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
url = url[o:o + l]
if Config.HTTP_PROXY != "":
command_to_exec = [
"youtube-dl", "--no-warnings", "--youtube-skip-dash-manifest",
"-j", url, "--proxy", Config.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)
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 and "nonnumeric port" not in 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.",
"")
if "This video is only available for registered users." in error_message:
error_message += Translation.SET_CUSTOM_USERNAME_PASSWORD
await bot.send_message(chat_id=update.chat.id,
text=Translation.NO_VOID_FORMAT_FOUND.format(
str(error_message)),
reply_to_message_id=update.message_id,
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 = Config.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 is not None and not "audio only" in format_string:
ikeyboard = [
pyrogram.InlineKeyboardButton(
"S " + format_string + " video " +
approx_file_size + " ",
callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"D " + format_ext + " " + approx_file_size + " ",
callback_data=(cb_string_file).encode("UTF-8"))
]
"""if duration is not None:
cb_string_video_message = "{}|{}|{}".format(
"vm", format_id, format_ext)
ikeyboard.append(
pyrogram.InlineKeyboardButton(
"VM",
callback_data=(
cb_string_video_message).encode("UTF-8")
)
)"""
else:
# special weird case :\
ikeyboard = [
pyrogram.InlineKeyboardButton(
"SVideo [" + "] ( " + approx_file_size + " )",
callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.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([
pyrogram.InlineKeyboardButton(
"MP3 " + "(" + "64 kbps" + ")",
callback_data=cb_string_64.encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"MP3 " + "(" + "128 kbps" + ")",
callback_data=cb_string_128.encode("UTF-8"))
])
inline_keyboard.append([
pyrogram.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([
pyrogram.InlineKeyboardButton(
"SVideo", callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.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([
pyrogram.InlineKeyboardButton(
"video", callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"file", callback_data=(cb_string_file).encode("UTF-8"))
])
reply_markup = pyrogram.InlineKeyboardMarkup(inline_keyboard)
# logger.info(reply_markup)
thumbnail = Config.DEF_THUMB_NAIL_VID_S
thumbnail_image = Config.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,
Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + ".jpg",
Config.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([
pyrogram.InlineKeyboardButton(
"SVideo", callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"DFile", callback_data=(cb_string_file).encode("UTF-8"))
])
reply_markup = pyrogram.InlineKeyboardMarkup(inline_keyboard)
await bot.send_message(chat_id=update.chat.id,
text=Translation.FORMAT_SELECTION.format(""),
reply_markup=reply_markup,
parse_mode="html",
reply_to_message_id=update.message_id)
async def zee5_capture(bot, update):
if update.from_user.id in Config.BANNED_USERS:
await bot.delete_messages(
chat_id=update.chat.id,
message_ids=update.message_id,
revoke=True
)
return
logger.info(update.from_user.id)
if "zee5" in update.text:
try:
w = update.text
req1 = requests.get("https://useraction.zee5.com/tokennd").json()
rgx = re.findall("([0-9]?\w+)", w)[-3:]
li = { "url":"zee5vodnd.akamaized.net", "token":"https://gwapi.zee5.com/content/details/" }
req2 = requests.get("https://useraction.zee5.com/token/platform_tokens.php?platform_name=web_app").json()["token"]
headers["X-Access-Token"] = req2
req3 = requests.get("https://useraction.zee5.com/token").json()
if "movies" in w:
r1 = requests.get(li["token"] + "-".join(rgx),
headers=headers,
params={"translation":"en", "country":"IN"}).json()
g1 = (r1["hls"][0].replace("drm", "hls") + req1["video_token"])
file_name = r1["title"]
url = "https://" + li["url"] + g1
elif "tvshows" or "originals" in w:
r2 = requests.get(li["token"] + "-".join(rgx),
headers=headers,
params={"translation":"en", "country":"IN"}).json()
g2 = (r2["hls"][0].replace("drm", "hls"))
if "netst" in g2:
file_name = r2["title"]
url = g2 + req3["video_token"]
else:
file_name = r2["title"]
url = "https://" + li["url"] + g2 + req1["video_token"]
logger.info(url)
except:
await update.reply_text("There's some issue with your URL ", quote=True)
return
else:
await update.reply_text("I can download from Zee5 links only! Go to @ARNextRobot for more Download bots 😇", quote=True)
return
try:
zee5_capture.url = url
command_to_exec = [
"youtube-dl",
"--no-warnings",
"--youtube-skip-dash-manifest",
"-j",
url,
"--geo-bypass-country",
"IN"
]
process = await asyncio.create_subprocess_exec(
*command_to_exec,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await process.communicate()
e_response = stderr.decode().strip()
t_response = stdout.decode().strip()
if e_response:
logger.info(e_response)
if 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 = Config.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)
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 is not None and not "audio only" in format_string:
ikeyboard = [
InlineKeyboardButton(
"🎞 (" + format_string + ") " + approx_file_size + " ",
callback_data=(cb_string_video).encode("UTF-8")
),
InlineKeyboardButton(
"📁 FILE " + format_ext + " " + approx_file_size + " ",
callback_data=(cb_string_file).encode("UTF-8")
)
]
inline_keyboard.append(ikeyboard)
inline_keyboard.append([
InlineKeyboardButton(
"✖️ CLOSE ✖️",
callback_data=(
"closeformat").encode("UTF-8")
)
])
reply_markup = InlineKeyboardMarkup(inline_keyboard)
thumbnail = Config.DEF_THUMB_NAIL_VID_S
thumbnail_image = Config.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,
Config.DOWNLOAD_LOCATION + "/" +
str(update.from_user.id) + ".jpg",
Config.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),
reply_markup=reply_markup,
parse_mode="html",
reply_to_message_id=update.message_id
)
else:
await update.reply_text("There's some issue with your URL 😕 Or may be DRM protected!", quote=True)
return
except:
await update.reply_text("Couldn't download your video!", quote=True)
logger.info('format send error')
return
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 = Config.DOWNLOAD_LOCATION + \
"/" + str(update.from_user.id) + ".jpg"
save_ytdl_json_path = Config.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) as e:
await bot.delete_messages(chat_id=update.message.chat.id,
message_ids=update.message.message_id,
revoke=True)
return False
youtube_dl_url = update.message.reply_to_message.text
custom_file_name = str(response_json.get("title")) + \
"_" + youtube_dl_format + "." + youtube_dl_ext
youtube_dl_username = None
youtube_dl_password = None
if "|" in youtube_dl_url:
url_parts = youtube_dl_url.split("|")
if len(url_parts) == 2:
youtube_dl_url = url_parts[0]
custom_file_name = url_parts[1]
elif len(url_parts) == 4:
youtube_dl_url = url_parts[0]
custom_file_name = url_parts[1]
youtube_dl_username = url_parts[2]
youtube_dl_password = url_parts[3]
else:
for entity in update.message.reply_to_message.entities:
if entity.type == "text_link":
youtube_dl_url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
youtube_dl_url = youtube_dl_url[o:o + l]
if youtube_dl_url is not None:
youtube_dl_url = youtube_dl_url.strip()
if custom_file_name is not None:
custom_file_name = custom_file_name.strip()
# https://stackoverflow.com/a/761825/4723940
if youtube_dl_username is not None:
youtube_dl_username = youtube_dl_username.strip()
if youtube_dl_password is not None:
youtube_dl_password = youtube_dl_password.strip()
logger.info(youtube_dl_url)
logger.info(custom_file_name)
else:
for entity in update.message.reply_to_message.entities:
if entity.type == "text_link":
youtube_dl_url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
youtube_dl_url = youtube_dl_url[o:o + l]
await bot.edit_message_text(text=Translation.DOWNLOAD_START,
chat_id=update.message.chat.id,
message_id=update.message.message_id)
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 = Config.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 = 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(Config.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:
# command_to_exec = ["youtube-dl", "-f", youtube_dl_format, "--hls-prefer-ffmpeg", "--recode-video", "mp4", "-k", youtube_dl_url, "-o", download_directory]
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(Config.TG_MAX_FILE_SIZE), "--embed-subs", "-f", minus_f_format,
"--hls-prefer-ffmpeg", youtube_dl_url, "-o", download_directory
]
if Config.HTTP_PROXY != "":
command_to_exec.append("--proxy")
command_to_exec.append(Config.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")
logger.info(command_to_exec)
start = datetime.now()
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()
t_response = stdout.decode().strip()
logger.info(e_response)
logger.info(t_response)
ad_string_to_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."
if e_response and ad_string_to_replace in e_response:
error_message = e_response.replace(ad_string_to_replace, "")
await bot.edit_message_text(chat_id=update.message.chat.id,
message_id=update.message.message_id,
text=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 = Config.TG_MAX_FILE_SIZE + 1
try:
file_size = os.stat(download_directory).st_size
except FileNotFoundError as exc:
download_directory = os.path.splitext(
download_directory)[0] + "." + "mkv"
# https://stackoverflow.com/a/678242/4723940
file_size = os.stat(download_directory).st_size
if file_size > Config.TG_MAX_FILE_SIZE:
await bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.RCHD_TG_API_LIMIT.format(
time_taken_for_download, humanbytes(file_size)),
message_id=update.message.message_id)
else:
is_w_f = False
images = await generate_screen_shots(download_directory,
tmp_directory_for_each_user,
is_w_f,
Config.DEF_WATER_MARK_FILE,
300, 9)
logger.info(images)
await bot.edit_message_text(text=Translation.UPLOAD_START,
chat_id=update.message.chat.id,
message_id=update.message.message_id)
# 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(download_directory))
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):
width = 0
height = 0
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
# resize image
# ref: https://t.me/PyrogramChat/44663
# https://stackoverflow.com/a/21669827/4723940
Image.open(thumb_image_path).convert("RGB").save(
thumb_image_path)
img = Image.open(thumb_image_path)
# https://stackoverflow.com/a/37631799/4723940
# img.thumbnail((90, 90))
if tg_send_type == "file":
img.resize((320, height))
else:
img.resize((90, height))
img.save(thumb_image_path, "JPEG")
# https://pillow.readthedocs.io/en/3.1.x/reference/Image.html#create-thumbnails
else:
thumb_image_path = None
start_time = time.time()
# try to upload file
if tg_send_type == "audio":
await bot.send_audio(
chat_id=update.message.chat.id,
audio=download_directory,
caption=description,
parse_mode="HTML",
duration=duration,
# performer=response_json["uploader"],
# title=response_json["title"],
# reply_markup=reply_markup,
thumb=thumb_image_path,
reply_to_message_id=update.message.reply_to_message.
message_id,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START, update.message,
start_time))
elif tg_send_type == "file":
await bot.send_document(
chat_id=update.message.chat.id,
document=download_directory,
thumb=thumb_image_path,
caption=description,
parse_mode="HTML",
# reply_markup=reply_markup,
reply_to_message_id=update.message.reply_to_message.
message_id,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START, update.message,
start_time))
elif tg_send_type == "vm":
await bot.send_video_note(
chat_id=update.message.chat.id,
video_note=download_directory,
duration=duration,
length=width,
thumb=thumb_image_path,
reply_to_message_id=update.message.reply_to_message.
message_id,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START, update.message,
start_time))
elif tg_send_type == "video":
await bot.send_video(
chat_id=update.message.chat.id,
video=download_directory,
caption=description,
parse_mode="HTML",
duration=duration,
width=width,
height=height,
supports_streaming=True,
# reply_markup=reply_markup,
thumb=thumb_image_path,
reply_to_message_id=update.message.reply_to_message.
message_id,
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 = "© @rsrmusic"
if is_w_f:
caption = "/upgrade to Plan D to remove the watermark\n© @rsrmusic"
for image in images:
if os.path.exists(image):
if i == 0:
media_album_p.append(
pyrogram.InputMediaPhoto(media=image,
caption=caption,
parse_mode="html"))
else:
media_album_p.append(
pyrogram.InputMediaPhoto(media=image))
i = i + 1
await bot.send_media_group(
chat_id=update.message.chat.id,
disable_notification=True,
reply_to_message_id=update.message.message_id,
media=media_album_p)
#
try:
shutil.rmtree(tmp_directory_for_each_user)
os.remove(thumb_image_path)
except:
pass
await bot.edit_message_text(
text=Translation.AFTER_SUCCESSFUL_UPLOAD_MSG_WITH_TS.format(
time_taken_for_download, time_taken_for_upload),
chat_id=update.message.chat.id,
message_id=update.message.message_id,
disable_web_page_preview=True)
async def zee5_execute(bot, update):
try:
cb_data = update.data
tg_send_type, youtube_dl_format, youtube_dl_ext = cb_data.split("|")
thumb_image_path = Config.DOWNLOAD_LOCATION + \
"/" + str(update.from_user.id) + ".jpg"
save_ytdl_json_path = Config.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) as e:
await bot.delete_messages(
chat_id=update.message.chat.id,
message_ids=update.message.message_id,
revoke=True
)
return False
youtube_dl_url = zee5_capture.url
linksplit = update.message.reply_to_message.text.split("/")
videoname = linksplit[+5]
logger.info(videoname)
custom_file_name = videoname + ".mp4"
await bot.edit_message_text(
text=Translation.DOWNLOAD_START,
chat_id=update.message.chat.id,
message_id=update.message.message_id
)
description = Translation.CUSTOM_CAPTION_UL_FILE.format(newname=custom_file_name)
tmp_directory_for_each_user = Config.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 = tmp_directory_for_each_user + "/" + custom_file_name
command_to_exec = []
minus_f_format = youtube_dl_format + "+bestaudio"
command_to_exec = [
"youtube-dl",
"-c",
"--max-filesize", str(Config.TG_MAX_FILE_SIZE),
"-f", minus_f_format,
"--hls-prefer-ffmpeg", youtube_dl_url,
"-o", download_directory
]
command_to_exec.append("--no-warnings")
command_to_exec.append("--geo-bypass-country")
command_to_exec.append("IN")
start = datetime.now()
process = await asyncio.create_subprocess_exec(
*command_to_exec,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await process.communicate()
e_response = stderr.decode().strip()
t_response = stdout.decode().strip()
if os.path.isfile(download_directory):
logger.info("no issues")
else:
logger.info("issues found, passing to sub process")
command_to_exec.clear()
minus_f_format = youtube_dl_format
command_to_exec = [
"youtube-dl",
"-c",
"--max-filesize", str(Config.TG_MAX_FILE_SIZE),
"-f", minus_f_format,
"--hls-prefer-ffmpeg", youtube_dl_url,
"-o", download_directory
]
command_to_exec.append("--no-warnings")
command_to_exec.append("--geo-bypass-country")
command_to_exec.append("IN")
start = datetime.now()
process = await asyncio.create_subprocess_exec(
*command_to_exec,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await process.communicate()
e_response = stderr.decode().strip()
t_response = stdout.decode().strip()
ad_string_to_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."
if e_response and ad_string_to_replace in e_response:
error_message = e_response.replace(ad_string_to_replace, "")
await bot.edit_message_text(
chat_id=update.message.chat.id,
message_id=update.message.message_id,
text=error_message
)
return False
if t_response:
os.remove(save_ytdl_json_path)
end_one = datetime.now()
time_taken_for_download = (end_one -start).seconds
file_size = Config.TG_MAX_FILE_SIZE + 1
try:
file_size = os.stat(download_directory).st_size
except FileNotFoundError as exc:
download_directory = os.path.splitext(download_directory)[0] + "." + "mp4"
file_size = os.stat(download_directory).st_size
if file_size > Config.TG_MAX_FILE_SIZE:
await bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.RCHD_TG_API_LIMIT.format(time_taken_for_download, humanbytes(file_size)),
message_id=update.message.message_id
)
else:
await bot.edit_message_text(
text=Translation.UPLOAD_START,
chat_id=update.message.chat.id,
message_id=update.message.message_id
)
# get the correct width, height, and duration for videos greater than 10MB
width = 0
height = 0
duration = 0
if tg_send_type != "file":
metadata = extractMetadata(createParser(download_directory))
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 not os.path.exists(thumb_image_path):
mes = await thumb(update.from_user.id)
if mes != None:
m = await bot.get_messages(update.chat.id, mes.msg_id)
await m.download(file_name=thumb_image_path)
thumb_image_path = thumb_image_path
else:
try:
thumb_image_path = await take_screen_shot(
download_directory,
os.path.dirname(download_directory),
random.randint(
0,
duration - 1
)
)
except:
thumb_image_path = None
pass
else:
width = 0
height = 0
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
Image.open(thumb_image_path).convert(
"RGB").save(thumb_image_path)
img = Image.open(thumb_image_path)
img.thumbnail((90, 90))
if tg_send_type == "file":
img.resize((320, height))
else:
img.resize((90, height))
img.save(thumb_image_path, "JPEG")
start_time = time.time()
if tg_send_type == "file":
await bot.send_document(
chat_id=update.message.chat.id,
document=download_directory,
thumb=thumb_image_path,
caption=description,
parse_mode="HTML",
# reply_markup=reply_markup,
reply_to_message_id=update.message.reply_to_message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message,
start_time
)
)
elif tg_send_type == "video":
await bot.send_video(
chat_id=update.message.chat.id,
video=download_directory,
caption=description,
parse_mode="HTML",
duration=duration,
width=width,
height=height,
supports_streaming=True,
# reply_markup=reply_markup,
thumb=thumb_image_path,
reply_to_message_id=update.message.reply_to_message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message,
start_time
)
)
else:
logger.info("Did this happen? :\\")
try:
shutil.rmtree(tmp_directory_for_each_user)
except:
pass
try:
os.remove(thumb_image_path)
except:
pass
await bot.edit_message_text(
text=Translation.AFTER_SUCCESSFUL_UPLOAD_MSG_WITH_TS,
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(text="Support Channel", url="https://t.me/ARNextRobot")]]),
chat_id=update.message.chat.id,
message_id=update.message.message_id,
disable_web_page_preview=True
)
except:
await update.reply_text("Couldn't download your video!", quote=True)
logger.info('error in process')
async def echo(bot, update):
# logger.info(update)
TRChatBase(update.from_user.id, update.text, "/echo")
# bot.send_chat_action(
# chat_id=update.chat.id,
# action="typing"
# )
logger.info(update.from_user)
if str(update.from_user.id) in Config.BANNED_USERS:
await bot.send_message(
chat_id=update.chat.id,
text=Translation.ABUSIVE_USERS,
reply_to_message_id=update.message_id,
disable_web_page_preview=True,
parse_mode=pyrogram.ParseMode.HTML
)
return
url = update.text
if "http" in url:
if "|" in url:
url, file_name = url.split("|")
url = url.strip()
# https://stackoverflow.com/a/761825/4723940
file_name = file_name.strip()
logger.info(url)
logger.info(file_name)
else:
for entity in update.entities:
if entity.type == "text_link":
url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
url = url[o:o + l]
try:
if ("hotstar.com" in url) and (Config.HTTP_PROXY != ""):
command_to_exec = [
"youtube-dl",
"--no-warnings",
"--youtube-skip-dash-manifest",
"-j",
url,
"--proxy", Config.HTTP_PROXY
]
else:
command_to_exec = [
"youtube-dl",
"--no-warnings",
"--youtube-skip-dash-manifest",
"-j",
url
]
logger.info(command_to_exec)
t_response = subprocess.check_output(
command_to_exec, stderr=subprocess.STDOUT)
# https://github.com/rg3/youtube-dl/issues/2630#issuecomment-38635239
except subprocess.CalledProcessError as exc:
# print("Status : FAIL", exc.returncode, exc.output)
await bot.send_message(
chat_id=update.chat.id,
text=exc.output.decode("UTF-8"),
reply_to_message_id=update.message_id
)
else:
# logger.info(t_response)
x_reponse = t_response.decode("UTF-8")
response_json = json.loads(x_reponse)
save_ytdl_json_path = Config.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 is not None and not "audio only" in format_string:
ikeyboard = [
pyrogram.InlineKeyboardButton(
"S" + format_ext + "Video [" + format_string +
"] ( " +
approx_file_size + " )",
callback_data=(cb_string_video).encode("UTF-8")
),
pyrogram.InlineKeyboardButton(
"D" + format_ext + "File [" + format_string +
"] ( " +
approx_file_size + " )",
callback_data=(cb_string_file).encode("UTF-8")
)
]
if duration is not None and duration <= 30:
cb_string_video_message = "{}|{}|{}".format(
"vm", format_id, format_ext)
ikeyboard.append(
pyrogram.InlineKeyboardButton(
"VMessage [" + format_string +
"] ( " +
approx_file_size + " )",
callback_data=(
cb_string_video_message).encode("UTF-8")
)
)
else:
# special weird case :\
ikeyboard = [
pyrogram.InlineKeyboardButton(
"SVideo [" +
"] ( " +
approx_file_size + " )",
callback_data=(cb_string_video).encode("UTF-8")
),
pyrogram.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([
pyrogram.InlineKeyboardButton(
"MP3 " + "(" + "64 kbps" + ")", callback_data=cb_string_64.encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"MP3 " + "(" + "128 kbps" + ")", callback_data=cb_string_128.encode("UTF-8"))
])
inline_keyboard.append([
pyrogram.InlineKeyboardButton(
"MP3 " + "(" + "320 kbps" + ")", callback_data=cb_string.encode("UTF-8"))
])
else:
format_id = response_json["format_id"]
format_ext = response_json["ext"]
tg_send_type = "file"
if duration is not None:
tg_send_type = "video"
cb_string = "{}|{}|{}".format(
tg_send_type, format_id, format_ext)
inline_keyboard.append([
pyrogram.InlineKeyboardButton(
"Download", callback_data=cb_string.encode("UTF-8"))
])
reply_markup = pyrogram.InlineKeyboardMarkup(inline_keyboard)
# logger.info(reply_markup)
thumbnail = Config.DEF_THUMB_NAIL_VID_S
thumbnail_image = Config.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,
Config.DOWNLOAD_LOCATION + "/" +
str(update.from_user.id) + ".jpg",
Config.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),
reply_markup=reply_markup,
parse_mode=pyrogram.ParseMode.HTML,
reply_to_message_id=update.message_id
)
else:
await bot.send_message(
chat_id=update.chat.id,
text=Translation.INVALID_UPLOAD_BOT_URL_FORMAT,
reply_to_message_id=update.message_id
)
def button(bot, update):
# logger.info(update)
if str(update.from_user.id) in Config.BANNED_USERS:
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.ABUSIVE_USERS,
message_id=update.message.message_id,
disable_web_page_preview=True,
parse_mode=pyrogram.ParseMode.HTML
)
return
cb_data = update.data.decode("UTF-8")
if ":" in cb_data:
# unzip formats
extract_dir_path = Config.DOWNLOAD_LOCATION + \
"/" + str(update.from_user.id) + "zipped" + "/"
if not os.path.isdir(extract_dir_path):
bot.delete_messages(
chat_id=update.message.chat.id,
message_ids=update.message.message_id,
revoke=True
)
return False
zip_file_contents = os.listdir(extract_dir_path)
type_of_extract, index_extractor, undefined_tcartxe = cb_data.split(":")
if index_extractor == "NONE":
try:
shutil.rmtree(extract_dir_path)
except:
pass
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.CANCEL_STR,
message_id=update.message.message_id
)
elif index_extractor == "ALL":
i = 0
for file_content in zip_file_contents:
current_file_name = os.path.join(extract_dir_path, file_content)
start_time = time.time()
bot.send_document(
chat_id=update.message.chat.id,
document=current_file_name,
# thumb=thumb_image_path,
caption=file_content,
# reply_markup=reply_markup,
reply_to_message_id=update.message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message.message_id,
update.message.chat.id,
start_time
)
)
i = i + 1
os.remove(current_file_name)
try:
shutil.rmtree(extract_dir_path)
except:
pass
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.ZIP_UPLOADED_STR.format(i, "0"),
message_id=update.message.message_id
)
else:
file_content = zip_file_contents[int(index_extractor)]
current_file_name = os.path.join(extract_dir_path, file_content)
start_time = time.time()
bot.send_document(
chat_id=update.message.chat.id,
document=current_file_name,
# thumb=thumb_image_path,
caption=file_content,
# reply_markup=reply_markup,
reply_to_message_id=update.message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message.message_id,
update.message.chat.id,
start_time
)
)
try:
shutil.rmtree(extract_dir_path)
except:
pass
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.ZIP_UPLOADED_STR.format("1", "0"),
message_id=update.message.message_id
)
elif "|" in cb_data:
# youtube_dl extractors
tg_send_type, youtube_dl_format, youtube_dl_ext = cb_data.split("|")
thumb_image_path = Config.DOWNLOAD_LOCATION + \
"/" + str(update.from_user.id) + ".jpg"
save_ytdl_json_path = Config.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) as e:
bot.delete_messages(
chat_id=update.message.chat.id,
message_ids=update.message.message_id,
revoke=True
)
return False
youtube_dl_url = update.message.reply_to_message.text
custom_file_name = str(response_json.get("title")) + \
"_" + youtube_dl_format + "." + youtube_dl_ext
youtube_dl_username = None
youtube_dl_password = None
if "|" in youtube_dl_url:
url_parts = youtube_dl_url.split("|")
if len(url_parts) == 2:
youtube_dl_url = url_parts[0]
custom_file_name = url_parts[1]
elif len(url_parts) == 4:
youtube_dl_url = url_parts[0]
custom_file_name = url_parts[1]
youtube_dl_username = url_parts[2]
youtube_dl_password = url_parts[3]
else:
for entity in update.message.reply_to_message.entities:
if entity.type == "text_link":
youtube_dl_url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
youtube_dl_url = youtube_dl_url[o:o + l]
if youtube_dl_url is not None:
youtube_dl_url = youtube_dl_url.strip()
if custom_file_name is not None:
custom_file_name = custom_file_name.strip()
# https://stackoverflow.com/a/761825/4723940
if youtube_dl_username is not None:
youtube_dl_username = youtube_dl_username.strip()
if youtube_dl_password is not None:
youtube_dl_password = youtube_dl_password.strip()
logger.info(youtube_dl_url)
logger.info(custom_file_name)
else:
for entity in update.message.reply_to_message.entities:
if entity.type == "text_link":
youtube_dl_url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
youtube_dl_url = youtube_dl_url[o:o + l]
if (str(update.from_user.id) not in Config.UTUBE_BOT_USERS) and (("hls" in youtube_dl_format) or ("hotstar.com" in youtube_dl_url)):
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.NOT_AUTH_USER_TEXT,
message_id=update.message.message_id
)
return
if "noyes.in" in youtube_dl_url:
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.NOYES_URL,
message_id=update.message.message_id
)
return
bot.edit_message_text(
text=Translation.DOWNLOAD_START,
chat_id=update.message.chat.id,
message_id=update.message.message_id
)
description = Translation.CUSTOM_CAPTION_UL_FILE
if "fulltitle" in response_json:
description = response_json["fulltitle"][0:1021]
if ("@" in custom_file_name) and (str(update.from_user.id) not in Config.UTUBE_BOT_USERS):
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.NOT_AUTH_USER_TEXT,
message_id=update.message.message_id
)
return
download_directory = Config.DOWNLOAD_LOCATION + "/" + custom_file_name
command_to_exec = []
if tg_send_type == "audio":
command_to_exec = [
"youtube-dl",
"-c",
"--prefer-ffmpeg",
"--extract-audio",
"--audio-format", youtube_dl_ext,
"--audio-quality", youtube_dl_format,
youtube_dl_url,
"-o", download_directory
]
else:
# command_to_exec = ["youtube-dl", "-f", youtube_dl_format, "--hls-prefer-ffmpeg", "--recode-video", "mp4", "-k", youtube_dl_url, "-o", download_directory]
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",
"--embed-subs",
"-f", minus_f_format,
"--hls-prefer-ffmpeg", youtube_dl_url,
"-o", download_directory
]
if "hotstar.com" in youtube_dl_url and Config.HTTP_PROXY != "":
command_to_exec.append("--proxy")
command_to_exec.append(Config.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)
logger.info(command_to_exec)
start = datetime.now()
try:
t_response = subprocess.check_output(command_to_exec, stderr = subprocess.STDOUT, timeout = Config.PROCESS_MAX_TIMEOUT)
except subprocess.CalledProcessError as exc:
logger.warn("Status : FAIL", exc.returncode, exc.output)
error_message = exc.output.decode("UTF-8").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.", "")
bot.edit_message_text(
chat_id=update.message.chat.id,
message_id=update.message.message_id,
text=error_message
)
except subprocess.TimeoutExpired as exc:
error_message = Translation.SLOW_URL_DECED
bot.edit_message_text(
chat_id=update.message.chat.id,
message_id=update.message.message_id,
text=error_message
)
else:
# logger.info(t_response)
os.remove(save_ytdl_json_path)
end_one = datetime.now()
bot.edit_message_text(
text=Translation.UPLOAD_START,
chat_id=update.message.chat.id,
message_id=update.message.message_id
)
file_size = Config.TG_MAX_FILE_SIZE + 1
try:
file_size = os.stat(download_directory).st_size
except FileNotFoundError as exc:
download_directory = os.path.splitext(download_directory)[0] + "." + "mkv"
# https://stackoverflow.com/a/678242/4723940
file_size = os.stat(download_directory).st_size
if file_size > Config.TG_MAX_FILE_SIZE:
time_taken_for_download = (end_one -start).seconds
if str(update.from_user.id) in Config.G_DRIVE_AUTH_DRQ:
gauth = Config.G_DRIVE_AUTH_DRQ[str(update.from_user.id)]
# Create GoogleDrive instance with authenticated GoogleAuth instance.
drive = GoogleDrive(gauth)
file_inance = drive.CreateFile()
# Read file and set it as a content of this instance.
file_inance.SetContentFile(download_directory)
file_inance.Upload() # Upload the file.
end_two = datetime.now()
time_taken_for_upload = (end_two - end_one).seconds
bot.edit_message_text(
text=Translation.AFTER_SUCCESSFUL_UPLOAD_MSG_WITH_TS.format(time_taken_for_download, time_taken_for_upload),
chat_id=update.message.chat.id,
message_id=update.message.message_id,
disable_web_page_preview=True
)
else:
bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.RCHD_TG_API_LIMIT.format(time_taken_for_download, humanbytes(file_size)),
message_id=update.message.message_id
)
else:
# 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(download_directory))
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):
width = 0
height = 0
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
# resize image
# ref: https://t.me/PyrogramChat/44663
# https://stackoverflow.com/a/21669827/4723940
Image.open(thumb_image_path).convert(
"RGB").save(thumb_image_path)
img = Image.open(thumb_image_path)
# https://stackoverflow.com/a/37631799/4723940
# img.thumbnail((90, 90))
img.resize((90, height))
img.save(thumb_image_path, "JPEG")
# https://pillow.readthedocs.io/en/3.1.x/reference/Image.html#create-thumbnails
else:
thumb_image_path = None
start_time = time.time()
# try to upload file
if tg_send_type == "audio":
bot.send_audio(
chat_id=update.message.chat.id,
audio=download_directory,
caption=description,
duration=duration,
# performer=response_json["uploader"],
# title=response_json["title"],
# reply_markup=reply_markup,
thumb=thumb_image_path,
reply_to_message_id=update.message.reply_to_message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message.message_id,
update.message.chat.id,
start_time
)
)
elif tg_send_type == "file":
bot.send_document(
chat_id=update.message.chat.id,
document=download_directory,
thumb=thumb_image_path,
caption=description,
# reply_markup=reply_markup,
reply_to_message_id=update.message.reply_to_message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message.message_id,
update.message.chat.id,
start_time
)
)
elif tg_send_type == "vm":
bot.send_video_note(
chat_id=update.message.chat.id,
video_note=download_directory,
duration=duration,
length=width,
thumb=thumb_image_path,
reply_to_message_id=update.message.reply_to_message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message.message_id,
update.message.chat.id,
start_time
)
)
elif tg_send_type == "video":
bot.send_video(
chat_id=update.message.chat.id,
video=download_directory,
caption=description,
duration=duration,
width=width,
height=height,
supports_streaming=True,
# reply_markup=reply_markup,
thumb=thumb_image_path,
reply_to_message_id=update.message.reply_to_message.message_id,
progress=progress_for_pyrogram,
progress_args=(
Translation.UPLOAD_START,
update.message.message_id,
update.message.chat.id,
start_time
)
)
else:
logger.info("Did this happen? :\\")
end_two = datetime.now()
try:
os.remove(download_directory)
os.remove(thumb_image_path)
except:
pass
time_taken_for_download = (end_one -start).seconds
time_taken_for_upload = (end_two - end_one).seconds
bot.edit_message_text(
text=Translation.AFTER_SUCCESSFUL_UPLOAD_MSG_WITH_TS.format(time_taken_for_download, time_taken_for_upload),
chat_id=update.message.chat.id,
message_id=update.message.message_id,
disable_web_page_preview=True
)
async def echo(bot, update):
if update.from_user.id in Config.BANNED_USERS:
await bot.delete_messages(
chat_id=update.chat.id,
message_ids=update.message_id,
revoke=True
)
return
fmsg = await update.reply_text("🧐 checking the given link 🥱", quote=True)
url = update.text
youtube_dl_username = None
youtube_dl_password = None
file_name = None
if "|" in url:
url_parts = url.split("|")
if len(url_parts) == 2:
url = url_parts[0]
file_name = url_parts[1]
elif len(url_parts) == 4:
url = url_parts[0]
file_name = url_parts[1]
youtube_dl_username = url_parts[2]
youtube_dl_password = url_parts[3]
else:
for entity in update.entities:
if entity.type == "text_link":
url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
url = url[o:o + l]
if url is not None:
url = url.strip()
if file_name is not None:
file_name = file_name.strip()
if youtube_dl_username is not None:
youtube_dl_username = youtube_dl_username.strip()
if youtube_dl_password is not None:
youtube_dl_password = youtube_dl_password.strip()
logger.info(url)
logger.info(file_name)
else:
for entity in update.entities:
if entity.type == "text_link":
url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
url = url[o:o + l]
if Config.HTTP_PROXY != "":
command_to_exec = [
"youtube-dl",
"--no-warnings",
"--youtube-skip-dash-manifest",
"-j",
url,
"--proxy", Config.HTTP_PROXY
]
else:
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 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)
process = await asyncio.create_subprocess_exec(
*command_to_exec,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await process.communicate()
e_response = stderr.decode().strip()
# logger.info(e_response)
t_response = stdout.decode().strip()
# logger.info(t_response)
if e_response and "nonnumeric port" not in 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.", "")
if "This video is only available for registered users." in error_message:
error_message += Translation.SET_CUSTOM_USERNAME_PASSWORD
await bot.send_message(
chat_id=update.chat.id,
text=Translation.NO_VOID_FORMAT_FOUND.format(str(error_message)),
reply_to_message_id=update.message_id,
parse_mode="html",
disable_web_page_preview=True
)
return False
if 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 = Config.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 is not None and not "audio only" in format_string:
ikeyboard = [
InlineKeyboardButton(
"S " + format_string + " video " + approx_file_size + " ",
callback_data=(cb_string_video).encode("UTF-8")
),
InlineKeyboardButton(
"D " + format_ext + " " + approx_file_size + " ",
callback_data=(cb_string_file).encode("UTF-8")
)
]
"""if duration is not None:
cb_string_video_message = "{}|{}|{}".format(
"vm", format_id, format_ext)
ikeyboard.append(
InlineKeyboardButton(
"VM",
callback_data=(
cb_string_video_message).encode("UTF-8")
)
)"""
else:
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)
thumbnail = Config.DEF_THUMB_NAIL_VID_S
thumbnail_image = Config.DEF_THUMB_NAIL_VID_S
thumb_image_path = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + ".jpg"
if not os.path.exists(thumb_image_path):
mes = await thumb(update.from_user.id)
if mes != None:
m = await bot.get_messages(update.chat.id, mes.msg_id)
await m.download(file_name=thumb_image_path)
thumb_image_path = thumb_image_path
else:
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,
Config.DOWNLOAD_LOCATION + "/" +
str(update.from_user.id) + ".jpg",
Config.CHUNK_SIZE,
None, # bot,
Translation.DOWNLOAD_START,
update.message_id,
update.chat.id
)
await fmsg.delete()
await bot.send_message(
chat_id=update.chat.id,
text=Translation.FORMAT_SELECTION.format(thumbnail) + "\n\n" + Translation.SET_CUSTOM_USERNAME_PASSWORD,
reply_markup=reply_markup,
parse_mode="html",
reply_to_message_id=update.message_id
)
else:
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 intmsg.delete()
await bot.send_message(
chat_id=update.chat.id,
text=Translation.FORMAT_SELECTION.format(""),
reply_markup=reply_markup,
parse_mode="html",
reply_to_message_id=update.message_id
)
async def echo(bot, update):
if update.from_user.id not in Config.AUTH_USERS:
await bot.delete_messages(chat_id=update.chat.id,
message_ids=update.message_id,
revoke=True)
return
# logger.info(update)
TRChatBase(update.from_user.id, update.text, "/echo")
# await bot.send_chat_action(
# chat_id=update.chat.id,
# action="typing"
# )
logger.info(update.from_user)
url = update.text
if url.count("|") == 2:
shomar = random.randint(1, 10000)
# youtube_dl extractors
youtube_dl_url, custom_file_name, youtube_dl_format = url.split("|")
if ") FullHD" in custom_file_name:
await bot.send_message(
text=Translation.DOWNLOAD_START,
chat_id=update.chat.id,
reply_to_message_id=update.message_id,
)
description = "@BachehayeManoto FullHD"
custom_file_name = custom_file_name + ".mp4"
tmp_directory_for_each_user = Config.DOWNLOAD_LOCATION + "/" + str(
shomar)
if not os.path.isdir(tmp_directory_for_each_user):
os.makedirs(tmp_directory_for_each_user)
download_directory = tmp_directory_for_each_user + "/" + custom_file_name
command_to_exec = []
# command_to_exec = ["youtube-dl", "-f", youtube_dl_format, "--hls-prefer-ffmpeg", "--recode-video", "mp4", "-k", youtube_dl_url, "-o", download_directory]
command_to_exec = [
"youtube-dl", "-c", "--max-filesize",
str(Config.TG_MAX_FILE_SIZE), "--embed-subs", "-f",
youtube_dl_format, "--hls-prefer-ffmpeg", youtube_dl_url, "-o",
download_directory
]
command_to_exec.append("--no-warnings")
# command_to_exec.append("--quiet")
logger.info(command_to_exec)
start = datetime.now()
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()
t_response = stdout.decode().strip()
logger.info(e_response)
logger.info(t_response)
ad_string_to_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."
if e_response and ad_string_to_replace in e_response:
error_message = e_response.replace(ad_string_to_replace, "")
await bot.edit_message_text(chat_id=update.chat.id,
message_id=update.message_id + 1,
text=error_message)
return False
if t_response:
# logger.info(t_response)
end_one = datetime.now()
time_taken_for_download = (end_one - start).seconds
file_size = Config.TG_MAX_FILE_SIZE + 1
try:
file_size = os.stat(download_directory).st_size
except FileNotFoundError as exc:
download_directory = os.path.splitext(
download_directory)[0] + "." + "mkv"
# https://stackoverflow.com/a/678242/4723940
file_size = os.stat(download_directory).st_size
if file_size > Config.TG_MAX_FILE_SIZE:
await bot.edit_message_text(
chat_id=update.chat.id,
text=Translation.RCHD_TG_API_LIMIT.format(
time_taken_for_download, humanbytes(file_size)),
message_id=update.message_id + 1)
else:
is_w_f = False
images = await generate_screen_shots(
download_directory, tmp_directory_for_each_user,
is_w_f, Config.DEF_WATER_MARK_FILE, 300, 9)
logger.info(images)
await bot.edit_message_text(text=Translation.UPLOAD_START,
chat_id=update.chat.id,
message_id=update.message_id +
1)
# get the correct width, height, and duration for videos greater than 10MB
width = 0
height = 0
duration = 0
start_time = time.time()
# try to upload file
await bot.send_document(
chat_id=update.chat.id,
document=download_directory,
# thumb=thumb_image_path,
caption=description,
parse_mode="HTML",
# reply_markup=reply_markup,
reply_to_message_id=update.message_id + 1,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START, update,
start_time))
end_two = datetime.now()
time_taken_for_upload = (end_two - end_one).seconds
#
media_album_p = []
if images is not None:
i = 0
# caption = "© @AnyDLBot"
if is_w_f:
caption = "/upgrade to Plan D to remove the watermark\n© @AnyDLBot"
for image in images:
if os.path.exists(image):
if i == 0:
media_album_p.append(
pyrogram.InputMediaPhoto(
media=image,
# caption=caption,
parse_mode="html"))
else:
media_album_p.append(
pyrogram.InputMediaPhoto(media=image))
i = i + 1
await bot.send_media_group(
chat_id=update.chat.id,
disable_notification=True,
reply_to_message_id=update.message_id + 1,
media=media_album_p)
#
try:
shutil.rmtree(tmp_directory_for_each_user)
except:
pass
await bot.edit_message_text(
text=
"Downloaded in {} seconds. \nUploaded in {} seconds.".
format(time_taken_for_download, time_taken_for_upload),
chat_id=update.chat.id,
message_id=update.message_id + 1,
disable_web_page_preview=True)
if ") HD" in custom_file_name:
await bot.send_message(
text=Translation.DOWNLOAD_START,
chat_id=update.chat.id,
reply_to_message_id=update.message_id,
)
description = "@BachehayeManoto HD"
custom_file_name = custom_file_name + ".mp4"
tmp_directory_for_each_user = Config.DOWNLOAD_LOCATION + "/" + str(
shomar)
if not os.path.isdir(tmp_directory_for_each_user):
os.makedirs(tmp_directory_for_each_user)
download_directory = tmp_directory_for_each_user + "/" + custom_file_name
command_to_exec = []
# command_to_exec = ["youtube-dl", "-f", youtube_dl_format, "--hls-prefer-ffmpeg", "--recode-video", "mp4", "-k", youtube_dl_url, "-o", download_directory]
command_to_exec = [
"youtube-dl", "-c", "--max-filesize",
str(Config.TG_MAX_FILE_SIZE), "--embed-subs", "-f",
youtube_dl_format, "--hls-prefer-ffmpeg", youtube_dl_url, "-o",
download_directory
]
command_to_exec.append("--no-warnings")
# command_to_exec.append("--quiet")
logger.info(command_to_exec)
start = datetime.now()
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()
t_response = stdout.decode().strip()
logger.info(e_response)
logger.info(t_response)
ad_string_to_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."
if e_response and ad_string_to_replace in e_response:
error_message = e_response.replace(ad_string_to_replace, "")
await bot.edit_message_text(chat_id=update.chat.id,
message_id=update.message_id + 1,
text=error_message)
return False
if t_response:
# logger.info(t_response)
end_one = datetime.now()
time_taken_for_download = (end_one - start).seconds
file_size = Config.TG_MAX_FILE_SIZE + 1
try:
file_size = os.stat(download_directory).st_size
except FileNotFoundError as exc:
download_directory = os.path.splitext(
download_directory)[0] + "." + "mkv"
# https://stackoverflow.com/a/678242/4723940
file_size = os.stat(download_directory).st_size
if file_size > Config.TG_MAX_FILE_SIZE:
await bot.edit_message_text(
chat_id=update.chat.id,
text=Translation.RCHD_TG_API_LIMIT.format(
time_taken_for_download, humanbytes(file_size)),
message_id=update.message_id + 1)
else:
is_w_f = False
images = await generate_screen_shots(
download_directory, tmp_directory_for_each_user,
is_w_f, Config.DEF_WATER_MARK_FILE, 300, 9)
logger.info(images)
await bot.edit_message_text(text=Translation.UPLOAD_START,
chat_id=update.chat.id,
message_id=update.message_id +
1)
# get the correct width, height, and duration for videos greater than 10MB
width = 0
height = 0
duration = 0
start_time = time.time()
# try to upload file
await bot.send_document(
chat_id=update.chat.id,
document=download_directory,
# thumb=thumb_image_path,
caption=description,
parse_mode="HTML",
# reply_markup=reply_markup,
reply_to_message_id=update.message_id + 1,
progress=progress_for_pyrogram,
progress_args=(Translation.UPLOAD_START, update,
start_time))
end_two = datetime.now()
time_taken_for_upload = (end_two - end_one).seconds
#
media_album_p = []
if images is not None:
i = 0
# caption = "© @AnyDLBot"
if is_w_f:
caption = "/upgrade to Plan D to remove the watermark\n© @AnyDLBot"
for image in images:
if os.path.exists(image):
if i == 0:
media_album_p.append(
pyrogram.InputMediaPhoto(
media=image,
# caption=caption,
parse_mode="html"))
else:
media_album_p.append(
pyrogram.InputMediaPhoto(media=image))
i = i + 1
await bot.send_media_group(
chat_id=update.chat.id,
disable_notification=True,
reply_to_message_id=update.message_id + 1,
media=media_album_p)
#
try:
shutil.rmtree(tmp_directory_for_each_user)
except:
pass
await bot.edit_message_text(
text=
"Downloaded in {} seconds. \nUploaded in {} seconds.".
format(time_taken_for_download, time_taken_for_upload),
chat_id=update.chat.id,
message_id=update.message_id + 1,
disable_web_page_preview=True)
else:
youtube_dl_username = None
youtube_dl_password = None
file_name = None
if "|" in url:
url_parts = url.split("|")
if len(url_parts) == 2:
url = url_parts[0]
file_name = url_parts[1]
elif len(url_parts) == 4:
url = url_parts[0]
file_name = url_parts[1]
youtube_dl_username = url_parts[2]
youtube_dl_password = url_parts[3]
else:
for entity in update.entities:
if entity.type == "text_link":
url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
url = url[o:o + l]
if url is not None:
url = url.strip()
if file_name is not None:
file_name = file_name.strip()
# https://stackoverflow.com/a/761825/4723940
if youtube_dl_username is not None:
youtube_dl_username = youtube_dl_username.strip()
if youtube_dl_password is not None:
youtube_dl_password = youtube_dl_password.strip()
logger.info(url)
logger.info(file_name)
else:
for entity in update.entities:
if entity.type == "text_link":
url = entity.url
elif entity.type == "url":
o = entity.offset
l = entity.length
url = url[o:o + l]
if Config.HTTP_PROXY != "":
command_to_exec = [
"youtube-dl", "--no-warnings", "--youtube-skip-dash-manifest",
"-j", url, "--proxy", Config.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)
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 and "nonnumeric port" not in 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.",
"")
if "This video is only available for registered users." in error_message:
error_message += Translation.SET_CUSTOM_USERNAME_PASSWORD
await bot.send_message(
chat_id=update.chat.id,
text=Translation.NO_VOID_FORMAT_FOUND.format(
str(error_message)),
reply_to_message_id=update.message_id,
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 = Config.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 is not None and not "audio only" in format_string:
ikeyboard = [
pyrogram.InlineKeyboardButton(
"S " + format_string + " video " +
approx_file_size + " ",
callback_data=(
cb_string_video).encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"D " + format_ext + " " + approx_file_size +
" ",
callback_data=(cb_string_file).encode("UTF-8"))
]
"""if duration is not None:
cb_string_video_message = "{}-{}-{}".format(
"vm", format_id, format_ext)
ikeyboard.append(
pyrogram.InlineKeyboardButton(
"VM",
callback_data=(
cb_string_video_message).encode("UTF-8")
)
)"""
else:
# special weird case :\
ikeyboard = [
pyrogram.InlineKeyboardButton(
"SVideo [" + "] ( " + approx_file_size + " )",
callback_data=(
cb_string_video).encode("UTF-8")),
pyrogram.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([
pyrogram.InlineKeyboardButton(
"MP3 " + "(" + "64 kbps" + ")",
callback_data=cb_string_64.encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"MP3 " + "(" + "128 kbps" + ")",
callback_data=cb_string_128.encode("UTF-8"))
])
inline_keyboard.append([
pyrogram.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([
pyrogram.InlineKeyboardButton(
"SVideo",
callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.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([
pyrogram.InlineKeyboardButton(
"video",
callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"file", callback_data=(cb_string_file).encode("UTF-8"))
])
reply_markup = pyrogram.InlineKeyboardMarkup(inline_keyboard)
# logger.info(reply_markup)
thumbnail = Config.DEF_THUMB_NAIL_VID_S
thumbnail_image = Config.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,
Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) +
".jpg",
Config.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([
pyrogram.InlineKeyboardButton(
"SVideo", callback_data=(cb_string_video).encode("UTF-8")),
pyrogram.InlineKeyboardButton(
"DFile", callback_data=(cb_string_file).encode("UTF-8"))
])
reply_markup = pyrogram.InlineKeyboardMarkup(inline_keyboard)
await bot.send_message(
chat_id=update.chat.id,
text=Translation.FORMAT_SELECTION.format(""),
reply_markup=reply_markup,
parse_mode="html",
reply_to_message_id=update.message_id)