async def _(event):
if event.fwd_from:
return
mone = await event.reply("Processing ...")
input_str = event.pattern_match.group(1)
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
if os.path.exists(input_str):
start = datetime.now()
c_time = time.time()
await borg.send_file(
event.chat_id,
input_str,
force_document=True,
supports_streaming=False,
allow_cache=False,
reply_to=event.message.id,
thumb=thumb,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, mone, c_time, "trying to upload")
)
)
end = datetime.now()
# os.remove(input_str)
ms = (end - start).seconds
await mone.edit("Uploaded in {} seconds.".format(ms))
else:
await mone.edit("6969: Sorry!! file Not Found, File Not Found")
async def ff_mpeg_trim_cmd(event):
if event.fwd_from:
return
if not os.path.exists(FF_MPEG_DOWN_LOAD_MEDIA_PATH):
await event.edit(
f"a media file needs to be downloaded, and saved to the following path: `{FF_MPEG_DOWN_LOAD_MEDIA_PATH}`"
)
return
current_message_text = event.raw_text
cmt = current_message_text.split(" ")
logger.info(cmt)
start = datetime.now()
if len(cmt) == 3:
# output should be video
cmd, start_time, end_time = cmt
o = await cult_small_video(FF_MPEG_DOWN_LOAD_MEDIA_PATH,
Config.TMP_DOWNLOAD_DIRECTORY, start_time,
end_time)
logger.info(o)
try:
c_time = time.time()
await borg.send_file(
event.chat_id,
o,
caption=" ".join(cmt[1:]),
force_document=False,
supports_streaming=True,
allow_cache=False,
# reply_to=event.message.id,
)
os.remove(o)
except Exception as e:
logger.info(str(e))
elif len(cmt) == 2:
# output should be image
cmd, start_time = cmt
o = await take_screen_shot(FF_MPEG_DOWN_LOAD_MEDIA_PATH,
Config.TMP_DOWNLOAD_DIRECTORY, start_time)
logger.info(o)
try:
c_time = time.time()
await borg.send_file(
event.chat_id,
o,
caption=" ".join(cmt[1:]),
force_document=True,
# supports_streaming=True,
allow_cache=False,
# reply_to=event.message.id,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, event, c_time, "trying to upload")))
os.remove(o)
except Exception as e:
logger.info(str(e))
else:
await event.edit("RTFM")
return
end = datetime.now()
ms = (end - start).seconds
await event.edit(f"Completed Process in {ms} seconds")
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
mone = await event.edit("Processing ...")
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, mone, c_time, "trying to download"))
)
directory_name = downloaded_file_name
await event.edit("Finish downloading to my local")
to_upload_file = directory_name
output = await create_archive(to_upload_file)
is_zip = False
if is_zip:
check_if_file = await create_archive(to_upload_file)
if check_if_file is not None:
to_upload_file = check_if_file
await borg.send_file(
event.chat_id,
output,
caption="TAR By LEGENDXBOT",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
try:
os.remove(output)
os.remove(output)
except:
pass
await event.edit("Task Completed")
await asyncio.sleep(3)
await event.delete()
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
elif input_str:
directory_name = input_str
await event.edit("Local file compressed to `{}`".format(output))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
mone = await event.edit("Processing ...")
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, mone, c_time, "trying to download"))
)
directory_name = downloaded_file_name
await event.edit("creating rar archive, please wait..")
# patoolib.create_archive(directory_name + '.7z',directory_name)
patoolib.create_archive(
directory_name + ".rar",
(directory_name, Config.TMP_DOWNLOAD_DIRECTORY))
# patoolib.create_archive("/content/21.yy Avrupa (1).pdf.zip",("/content/21.yy Avrupa (1).pdf","/content/"))
await borg.send_file(
event.chat_id,
directory_name + ".rar",
caption="rarred By LEGENDXBOT",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
try:
os.remove(directory_name + ".rar")
os.remove(directory_name)
except:
pass
await event.edit("Task Completed")
await asyncio.sleep(3)
await event.delete()
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
elif input_str:
directory_name = input_str
await event.edit(
"Local file compressed to `{}`".format(directory_name + ".rar"))
async def _(event):
if event.fwd_from:
return
if not event.is_reply:
await event.edit("Reply to a file to compress it.")
return
mone = await event.edit("Processing ...")
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, mone, c_time, "trying to download"))
)
directory_name = downloaded_file_name
await event.edit(downloaded_file_name)
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
zipfile.ZipFile(directory_name + '.zip', 'w',
zipfile.ZIP_DEFLATED).write(directory_name)
await borg.send_file(
event.chat_id,
directory_name + ".zip",
caption="Zipped By LEGENDXBOT",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
await event.edit("DONE!!!")
await asyncio.sleep(5)
await event.delete()
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
reply_message = await event.get_reply_message()
if reply_message is None:
await event.edit("reply to a media to use the `nfc` operation.\nInspired by @FileConverterBot")
return
await event.edit("trying to download media file, to my local")
try:
start = datetime.now()
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, event, c_time, "trying to download")
)
)
except Exception as e: # pylint:disable=C0103,W0703
await event.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await event.edit("Downloaded to `{}` in {} seconds.".format(downloaded_file_name, ms))
new_required_file_name = ""
new_required_file_caption = ""
command_to_run = []
force_document = False
voice_note = False
supports_streaming = False
if input_str == "voice":
new_required_file_caption = "AUDIO" + str(round(time.time())) + ".opus"
new_required_file_name = Config.TMP_DOWNLOAD_DIRECTORY + "/" + new_required_file_caption
command_to_run = [
"ffmpeg",
"-i",
downloaded_file_name,
"-map",
"0:a",
"-codec:a",
"libopus",
"-b:a",
"100k",
"-vbr",
"on",
new_required_file_name
]
voice_note = True
supports_streaming = True
elif input_str == "mp3":
new_required_file_caption = "AUDIO" + str(round(time.time())) + ".mp3"
new_required_file_name = Config.TMP_DOWNLOAD_DIRECTORY + "/" + new_required_file_caption
command_to_run = [
"ffmpeg",
"-i",
downloaded_file_name,
"-vn",
new_required_file_name
]
voice_note = False
supports_streaming = True
else:
await event.edit("not supported")
os.remove(downloaded_file_name)
return
logger.info(command_to_run)
# TODO: re-write create_subprocess_exec Γ°ΕΈΛβ°
process = await asyncio.create_subprocess_exec(
*command_to_run,
# 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()
os.remove(downloaded_file_name)
if os.path.exists(new_required_file_name):
end_two = datetime.now()
await borg.send_file(
entity=event.chat_id,
file=new_required_file_name,
caption=new_required_file_caption,
allow_cache=False,
silent=True,
force_document=force_document,
voice_note=voice_note,
supports_streaming=supports_streaming,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, event, c_time, "trying to upload")
)
)
ms_two = (end_two - end).seconds
os.remove(new_required_file_name)
await event.edit(f"converted in {ms_two} seconds")
async def _(event):
if event.fwd_from:
return
mone = await event.edit("Processing ...")
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
extracted = Config.TMP_DOWNLOAD_DIRECTORY + "extracted/"
thumb_image_path = Config.TMP_DOWNLOAD_DIRECTORY + "/thumb_image.jpg"
if not os.path.isdir(extracted):
os.makedirs(extracted)
if event.reply_to_msg_id:
start = datetime.now()
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, mone, c_time, "trying to download"))
)
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await mone.edit("Stored the tar to `{}` in {} seconds.".format(
downloaded_file_name, ms))
with tarfile.TarFile.open(downloaded_file_name, 'r') as tar_file:
tar_file.extractall(path=extracted)
# tf = tarfile.open(downloaded_file_name)
# tf.extractall(path=extracted)
# tf.close()
# with zipfile.ZipFile(downloaded_file_name, 'r') as zip_ref:
# zip_ref.extractall(extracted)
filename = sorted(get_lst_of_files(extracted, []))
#filename = filename + "/"
await event.edit("Untarring now")
# r=root, d=directories, f = files
for single_file in filename:
if os.path.exists(single_file):
# https://stackoverflow.com/a/678242/4723940
caption_rts = os.path.basename(single_file)
force_document = False
supports_streaming = True
document_attributes = []
if single_file.endswith((".mp4", ".mp3", ".flac", ".webm")):
metadata = extractMetadata(createParser(single_file))
duration = 0
width = 0
height = 0
if metadata.has("duration"):
duration = metadata.get('duration').seconds
if os.path.exists(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")
document_attributes = [
DocumentAttributeVideo(duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True)
]
try:
await borg.send_file(
event.chat_id,
single_file,
caption=f"Untared `{caption_rts}`",
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
reply_to=event.message.id,
attributes=document_attributes,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, event, c_time, "trying to upload")))
await event.edit("DONE!!!")
await asyncio.sleep(5)
await event.delete()
except Exception as e:
await borg.send_message(event.chat_id,
"{} caused `{}`".format(
caption_rts, str(e)),
reply_to=event.message.id)
# some media were having some issues
continue
os.remove(single_file)
os.remove(downloaded_file_name)
async def _(event):
if event.fwd_from:
return
mone = await event.reply("Processing ...")
input_str = event.pattern_match.group(1)
thumb = None
file_name = input_str
if os.path.exists(file_name):
if not file_name.endswith((".mkv", ".mp4", ".mp3", ".flac")):
await mone.edit(
"Sorry. But I don't think {} is a streamable file.".format(file_name) + \
" Please try again.\n" + \
"**Supported Formats**: MKV, MP4, MP3, FLAC"
)
return False
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
else:
thumb = get_video_thumb(file_name, thumb_image_path)
start = datetime.now()
metadata = extractMetadata(createParser(file_name))
duration = 0
width = 0
height = 0
if metadata.has("duration"):
duration = metadata.get('duration').seconds
if os.path.exists(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")
# Telegram only works with MP4 files
# this is good, since with MKV files sent as streamable Telegram responds,
# Bad Request: VIDEO_CONTENT_TYPE_INVALID
c_time = time.time()
try:
await borg.send_file(
event.chat_id,
file_name,
thumb=thumb,
caption=input_str,
force_document=False,
allow_cache=False,
reply_to=event.message.id,
attributes=[
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True
)
],
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, mone, c_time, "trying to upload")
)
)
except Exception as e:
await mone.edit(str(e))
else:
end = datetime.now()
os.remove(input_str)
ms = (end - start).seconds
await mone.edit("Uploaded in {} seconds.".format(ms))
else:
await mone.edit("404: File Not Found")
async def download_video(v_url):
lazy = v_url
sender = await lazy.get_sender()
me = await lazy.client.get_me()
if not sender.id == me.id:
rkp = await lazy.reply("`processing...`")
else:
rkp = await lazy.edit("`processing...`")
url = v_url.pattern_match.group(1)
if not url:
return await rkp.edit("`Error \nusage song <song name>`")
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get('search_result')
try:
url = q[0]['link']
except:
return await rkp.edit("`failed to find`")
type = "audio"
await rkp.edit("`Preparing to download...`")
if type == "audio":
opts = {
'format':
'best',
'addmetadata':
True,
'key':
'FFmpegMetadata',
'prefer_ffmpeg':
True,
'geo_bypass':
True,
'nocheckcertificate':
True,
'postprocessors': [{
'key': 'FFmpegVideoConvertor',
'preferedformat': 'mp4'
}],
'outtmpl':
'%(id)s.mp4',
'logtostderr':
False,
'quiet':
True
}
song = False
video = True
try:
await rkp.edit("`Fetching data, please wait..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await rkp.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await rkp.edit("`The download content was too short.`")
return
except GeoRestrictedError:
await rkp.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
return
except MaxDownloadsReached:
await rkp.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await rkp.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await rkp.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await rkp.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await rkp.edit("`There was an error during info extraction.`")
return
except Exception as e:
await rkp.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await rkp.edit(f"`Preparing to upload song `\
\n**{rip_data['title']}**\
\nby *{rip_data['uploader']}*")
await v_url.client.send_file(
v_url.chat_id,
f"{rip_data['id']}.mp3",
supports_streaming=True,
attributes=[
DocumentAttributeAudio(duration=int(rip_data['duration']),
title=str(rip_data['title']),
performer=str(rip_data['uploader']))
],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await rkp.edit(f"`Preparing to upload video song :`\
\n**{rip_data['title']}**\
\nby *{rip_data['uploader']}*")
await v_url.client.send_file(
v_url.chat_id,
f"{rip_data['id']}.mp4",
supports_streaming=True,
caption=rip_data['title'],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
await rkp.delete()
async def _(event):
if event.fwd_from:
return
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
dcevent = await event.edit(
"Rename & Upload in process ππββοΈπββοΈπββοΈ It might take some time if file size is big",
)
input_str = event.pattern_match.group(1)
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
start = datetime.now()
file_name = input_str
reply_message = await event.get_reply_message()
c_time = time.time()
to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY
downloaded_file_name = os.path.join(to_download_directory, file_name)
downloaded_file_name = await event.client.download_media(
reply_message,
downloaded_file_name,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(
progress(d, t, dcevent, c_time, "trying to download", file_name
)),
)
end = datetime.now()
ms_one = (end - start).seconds
try:
thumb = await reply_message.download_media(thumb=-1)
except Exception:
thumb = thumb
if os.path.exists(downloaded_file_name):
c_time = time.time()
hmm = await event.client.send_file(
event.chat_id,
downloaded_file_name,
force_document=False,
supports_streaming=True,
allow_cache=False,
reply_to=event.message.id,
thumb=thumb,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(
progress(d, t, event, c_time, "trying to upload",
downloaded_file_name)),
)
end_two = datetime.now()
os.remove(downloaded_file_name)
ms_two = (end_two - end).seconds
await dcevent.edit(
f"Downloaded file in {ms_one} seconds.\nUploaded in {ms_two} seconds."
)
await asyncio.sleep(2)
await dcevent.delete()
else:
await dcevent.edit("File Not Found {}".format(input_str))
else:
await dcevent.edit(
".rename file.name as reply to a Telegram media/file")
async def _(event):
if event.fwd_from:
return
mone = await event.reply("Processing The File ...")
if CLIENT_ID is None or CLIENT_SECRET is None:
await mone.edit("This module requires credentials from https://da.gd/so63O. Aborting!")
return
if Config.PLUGIN_CHANNEL is None:
await event.edit("Please set the required environment variable `PLUGIN_CHANNEL` for this plugin to work")
return
input_str = event.pattern_match.group(1)
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
required_file_name = None
start = datetime.now()
if event.reply_to_msg_id and not input_str:
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, mone, c_time, "trying to download")
)
)
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
return False
else:
end = datetime.now()
ms = (end - start).seconds
required_file_name = downloaded_file_name
await mone.edit("Downloaded to `{}` in {} seconds.".format(downloaded_file_name, ms))
elif input_str:
input_str = input_str.strip()
if os.path.exists(input_str):
end = datetime.now()
ms = (end - start).seconds
required_file_name = input_str
await mone.edit("Found `{}` in {} seconds.".format(input_str, ms))
else:
await mone.edit("File Not found in local server. Give me a file path :((")
return False
# logger.info(required_file_name)
if required_file_name:
#
if Config.AUTH_TOKEN_DATA is not None:
with open(G_DRIVE_TOKEN_FILE, "w") as t_file:
t_file.write(Config.AUTH_TOKEN_DATA)
# Check if token file exists, if not create it by requesting authorization code
storage = None
if not os.path.isfile(G_DRIVE_TOKEN_FILE):
storage = await create_token_file(G_DRIVE_TOKEN_FILE, event)
http = authorize(G_DRIVE_TOKEN_FILE, storage)
# Authorize, get file parameters, upload file and print out result URL for download
# http = authorize(G_DRIVE_TOKEN_FILE, None)
file_name, mime_type = file_ops(required_file_name)
# required_file_name will have the full path
# Sometimes API fails to retrieve starting URI, we wrap it.
try:
g_drive_link = await upload_file(http, required_file_name, file_name, mime_type, mone, G_DRIVE_F_PARENT_ID)
await mone.edit(f"Here is your Google Drive link: {g_drive_link}")
except Exception as e:
await mone.edit(f"Exception occurred while uploading to gDrive {e}")
else:
await mone.edit("File Not found in local server. Give me a file path :((")
async def _(event):
if event.fwd_from:
return
mone = await edit_or_reply(event, "`Processing ...`")
input_str = event.pattern_match.group(1)
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
start = datetime.now()
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await event.client.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, mone, c_time, "trying to download")
),
)
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await mone.edit(
f"** β’ Downloaded in {ms} seconds.**\n** β’ Downloaded to :- ** `{downloaded_file_name}`\n** β’ Downloaded by :-** {DEFAULTUSER}"
)
elif input_str:
start = datetime.now()
url = input_str
file_name = os.path.basename(url)
to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
file_name = file_name.strip()
downloaded_file_name = os.path.join(to_download_directory, file_name)
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
while not downloader.isFinished():
total_length = downloader.filesize or None
downloaded = downloader.get_dl_size()
display_message = ""
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
downloader.get_speed()
progress_str = "`{0}{1} {2}`%".format(
"".join(["β°" for i in range(math.floor(percentage / 5))]),
"".join(["β±" for i in range(20 - math.floor(percentage / 5))]),
round(percentage, 2),
)
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"Downloading the file\
\n\n**URL : **`{url}`\
\n**File Name :** `{file_name}`\
\n{progress_str}\
\n`{humanbytes(downloaded)} of {humanbytes(total_length)}`\
\n**ETA : **`{estimated_total_time}``"
if round(diff % 10.00) == 0 and current_message != display_message:
await mone.edit(current_message)
display_message = current_message
except Exception as e:
logger.info(str(e))
end = datetime.now()
ms = (end - start).seconds
if downloader.isSuccessful():
await mone.edit(
f"** β’ Downloaded in {ms} seconds.**\n** β’ Downloaded to :- ** `{downloaded_file_name}`"
)
else:
await mone.edit("Incorrect URL\n {}".format(input_str))
else:
await mone.edit("Reply to a message to download to my local server.")