async def _(event):
if event.fwd_from:
return
mone = await event.reply("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 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,
"Downloading This File Onto Your Xiaomi Redmi 7 Device..."
)))
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await mone.edit("Downloaded to `{}` in {} seconds.".format(
downloaded_file_name, ms))
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)
async with aiohttp.ClientSession() as session:
c_time = time.time()
await download_coroutine(session, url, downloaded_file_name, mone,
c_time)
end = datetime.now()
ms = (end - start).seconds
if os.path.exists(downloaded_file_name):
await mone.edit("Downloaded to `{}` in {} seconds.".format(
downloaded_file_name, ms))
else:
await mone.edit("Incorrect URL\n {}".format(input_str))
else:
await mone.edit("Reply to a message to download to my local server.")
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
replied = event.reply_to_msg_id
if not replied:
await event.edit("LMAO no one's gonna help you, if u use .help now then u **Gey**")
await borg.send_file(event.chat_id, "CAADAQADhAAD3gkwRviGxMVn5813FgQ")
return
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
await event.edit("He he, let me use my skills")
c_time = time.time()
reply_message = await event.get_reply_message()
dls = 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")
)
)
dls_loc = os.path.join(Config.TMP_DOWNLOAD_DIRECTORY, os.path.basename(dls))
if dls.endswith(".tgs"):
await event.edit("OMG, an Animated sticker ⊙_⊙, lemme do my bleck megik...")
png_file = os.path.join(Config.TMP_DOWNLOAD_DIRECTORY, "meme.png")
cmd = f"lottie_convert.py --frame 0 -if lottie -of PNG {dls_loc} {png_file}"
stdout, stderr = (await runcmd(cmd))[:2]
os.remove(dls_loc)
if not os.path.lexists(png_file):
await event.edit("This sticker is Gey, i won't memify it ≧ω≦")
raise Exception(stdout + stderr)
dls_loc = png_file
if dls.endswith(".mp4"):
await event.edit("Look it's GF. Oh, no it's just a Gif ")
jpg_file = os.path.join(Config.TMP_DOWNLOAD_DIRECTORY, "meme.jpg")
await take_screen_shot(dls_loc, 0, jpg_file)
os.remove(dls_loc)
if not os.path.lexists(jpg_file):
await event.edit("This Gif is Gey (｡ì _ í｡), won't memify it.")
return
dls_loc = jpg_file
await event.edit("Decoration Time ≧∇≦, I'm an Artist")
webp_file = await draw_meme_text(dls_loc, input_str)
await borg.send_file(event.chat_id, webp_file, reply_to=event.reply_to_msg_id)
await event.delete()
os.remove(webp_file)
async def _(event):
if event.fwd_from:
return
thumb = None
await event.edit(f"Downloading file to local machine..\nThis may take a while depending on the file size.")
time.sleep(1)
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()
to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY
await event.edit(f"Download complete!\nRenaming downloaded file to {input_str}..")
time.sleep(0.25)
downloaded_file_name = os.path.join(to_download_directory, file_name)
downloaded_file_name = await borg.download_media(
reply_message,
downloaded_file_name
)
end = datetime.now()
ms_one = (end - start).seconds
await event.edit("File renamed successfully!\nUploading renamed file..\nThis may take a while depending on the file size.")
time.sleep(.35)
if os.path.exists(downloaded_file_name):
c_time = time.time()
await borg.send_file(
event.chat_id,
downloaded_file_name,
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, event, c_time, "trying to upload")
)
)
end_two = datetime.now()
os.remove(downloaded_file_name)
ms_two = (end_two - end).seconds
total_ms = int(ms_one) + int(ms_two)
await event.edit(f"Uploaded renamed file ```{input_str}``` in {ms_two} seconds!")
else:
await event.edit("File {} not found.".format(input_str))
else:
await event.edit("Syntax // .rnupload file.name as reply to a Telegram media")
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 @By_Azade",
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("Finish downloading to my local")
command_to_exec = [
"7z",
"e",
"-o" + extracted,
directory_name]
sp = subprocess.Popen(
command_to_exec, stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
await borg.send_file(
event.chat_id,
directory_name + ".zip",
caption="Zipped By @By_Azade",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
try:
os.remove(directory_name + ".zip")
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 + ".zip"))
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 7z archive, please wait..")
# patoolib.create_archive(directory_name + '.7z',directory_name)
patoolib.create_archive(
directory_name + ".7z",
(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 + ".7z",
caption="7z archived By @By_Azade",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
try:
os.remove(directory_name + ".7z")
os.remove(directory_name)
except BaseException:
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 + ".7z"))
async def pinterst_vid_img(event):
x = await event.edit("`Progressing...`")
url = event.pattern_match.group(1)
get_url = get_download_url(url)
j = download_video(get_url)
thumb_image_path = Config.TMP_DOWNLOAD_DIRECTORY + "thumb_image.jpg"
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
metadata = extractMetadata(createParser(j))
duration = 0
if metadata.has("duration"):
duration = metadata.get('duration').seconds
width = 0
height = 0
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
else:
thumb = await take_screen_shot(j, os.path.dirname(os.path.abspath(j)),
(duration / 2))
c_time = time.time()
await event.client.send_file(
event.chat_id,
j,
thumb=thumb,
caption="`pinterest video uploaded by` @By_Azade",
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, event, c_time, "trying to upload")))
await event.delete()
await x.delete()
os.remove(Config.TMP_DOWNLOAD_DIRECTORY + 'pinterest_video.mp4')
os.remove(thumb_image_path)
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")
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 SnapDragon",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
try:
os.remove(directory_name + ".zip")
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
zipfile.ZipFile(directory_name + '.zip', 'w',
zipfile.ZIP_DEFLATED).write(directory_name)
await event.edit(
"Local file compressed to `{}`".format(directory_name + ".zip"))
async def _(event):
if event.fwd_from:
return
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
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()
to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY
downloaded_file_name = os.path.join(to_download_directory, file_name)
downloaded_file_name = await borg.download_media(
reply_message, downloaded_file_name)
end = datetime.now()
ms_one = (end - start).seconds
if os.path.exists(downloaded_file_name):
c_time = time.time()
await borg.send_file(
event.chat_id,
downloaded_file_name,
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, event, c_time, "trying to upload")))
end_two = datetime.now()
os.remove(downloaded_file_name)
ms_two = (end_two - end).seconds
await event.edit(
"Downloaded in {} seconds. Uploaded in {} seconds.".format(
ms_one, ms_two))
else:
await event.edit("File Not Found {}".format(input_str))
else:
await event.edit(
"Syntax // .rnupload file.name as reply to a Telegram media")
async def _(event):
if event.fwd_from:
return
mone = await event.edit("`Unzipping...`")
input_str = event.pattern_match.group(1)
if input_str:
if os.path.exists(input_str):
downloaded_file_name = input_str
start = datetime.now()
with zipfile.ZipFile(downloaded_file_name, "r") as zip_ref:
zip_ref.extractall(Config.TMP_DOWNLOAD_DIRECTORY)
end = datetime.now()
ms = (end - start).seconds
await event.edit(
f"unzipped and stored to `{downloaded_file_name[:-4]}` \n**Time Taken :** `{ms} seconds`"
)
else:
await event.edit(f"I can't find that path `{input_str}`")
else:
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 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))
await event.edit("Unzipping now")
with zipfile.ZipFile(downloaded_file_name, "r") as zip_ref:
zip_ref.extractall(Config.TMP_DOWNLOAD_DIRECTORY)
end = datetime.now()
ms = (end - start).seconds
await event.edit(
f"unzipped and stored to `{downloaded_file_name[:-4]}` \n**Time Taken :** `{ms} seconds`"
)
os.remove(downloaded_file_name)
async def download(event):
global reponame
reponame = Config.GIT_REPO_NAME
if reponame is None:
reponame = event.pattern_match.group(1)
if not reponame and Config.GIT_REPO_NAME is None:
await event.edit(
"`Please ADD a proper repo name from Vars or specify your repo name as in the example: .commit <reponame>`"
)
return
if event.fwd_from:
return
if Config.GITHUB_ACCESS_TOKEN is None:
await event.edit("`Please ADD a proper access token from github.com`")
return
if Config.GIT_USER_NAME is None:
await event.edit("`Please ADD a proper github username from vars`")
return
mone = await event.reply("**__Processing...__**")
if not os.path.isdir(GIT_TEMP_DIR):
os.makedirs(GIT_TEMP_DIR)
start = datetime.now()
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
GIT_TEMP_DIR,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, mone, c_time, "**__trying to download__**")))
except Exception as e:
await mone.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await event.delete()
await mone.edit("**__Downloaded to `{}` in {} seconds.__**".format(
downloaded_file_name, ms))
await mone.edit("**__Committing to Github....__**")
await git_commit(downloaded_file_name, mone)
async def pinterst_img_vid(event):
x = await event.edit("`Progressing...`")
url = event.pattern_match.group(1)
get_url = get_download_url(url)
j = download_image(get_url)
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
c_time = time.time()
await event.client.send_file(
event.chat_id,
j,
caption="`pinterest image uploaded by` @By_Azade",
force_document=False,
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")))
await event.delete()
await x.delete()
os.remove(Config.TMP_DOWNLOAD_DIRECTORY + 'pinterest_iamge.jpg')
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
mone = await event.edit("Zipping in progress....")
if event.reply_to_msg_id:
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
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")
zipfile.ZipFile(directory_name + ".zip", "w",
zipfile.ZIP_DEFLATED).write(directory_name)
os.remove(directory_name)
cat = directory_name + ".zip"
await event.edit(f"compressed successfully into `{cat}`")
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
elif input_str:
if not os.path.exists(input_str):
await event.edit(
f"There is no such directory or file with the name `{input_str}` check again"
)
return
filePaths = zipdir(input_str)
zip_file = zipfile.ZipFile(input_str + ".zip", "w")
with zip_file:
for file in filePaths:
zip_file.write(file)
await event.edit("Local file compressed to `{}`".format(input_str +
".zip"))
async def ff_mpeg_save_cmd(event):
if event.fwd_from:
return
if not os.path.exists(FF_MPEG_DOWN_LOAD_MEDIA_PATH):
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 borg.download_media(
reply_message,
FF_MPEG_DOWN_LOAD_MEDIA_PATH,
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
event.client.send_message(event.chat_id, str(e))
else:
end = datetime.now()
ms = (end - start).seconds
h = await event.client.send_message(
event.chat_id, "Downloaded to `{}` in {} seconds.".format(
downloaded_file_name, ms))
await asyncio.sleep(4)
await h.delete()
else:
f = await event.client.send_message(
event.chat_id, "Reply to a Telegram media file")
await asyncio.sleep(4)
await f.delete()
else:
g = await event.client.send_message(
event.chat_id,
"a media file already exists in path. Please remove the media and try again! use `.exec rm -rf uniborg.media.ffmpeg`"
)
await asyncio.sleep(8)
await g.delete()
async def download(url, msg, id):
idnum = id
args = url
event = msg
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,
"/app/",
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, event, c_time, "Downloading IPA.."))
)
except Exception as e:
await event.edit(str(e))
else:
await event.edit(f"Downloaded IPA to `{downloaded_file_name}`.")
ipa_split = downloaded_file_name.split("/")
ipa_full = ipa_split[-1]
ipa_noext = ipa_full[:-4]
ipa = f"{ipa_noext}_{idnum}.ipa"
os.rename(ipa_full, ipa)
return ipa
elif args.startswith("http"):
if not args.endswith(".ipa"):
return await event.edit(
"Unsupported link!\nPlease provide a direct link to the IPA file."
)
ipa_split = args.split("/")
ipa = ipa_split[-1]
ipa_noext = ipa[:-4]
ipa = f"{ipa_noext}_{idnum}.ipa"
await event.edit(f"Downloading IPA: `{ipa}`")
request = requests.get(args)
with open(ipa, "wb") as f:
f.write(request.content)
return ipa
async def upload_zip(up):
if not os.path.isdir(ZIP_DOWNLOAD_DIRECTORY):
await up.edit("`Files not found`")
return
mone = await up.edit("`Zipping File...`")
input_str = up.pattern_match.group(1)
curdate = today.strftime("%m%d%y")
title = str(input_str) if input_str else "zipfile" + f"{curdate}"
zipf = zipfile.ZipFile(title + '.zip', 'w', zipfile.ZIP_DEFLATED)
zipdir(ZIP_DOWNLOAD_DIRECTORY, zipf)
zipf.close()
c_time = time.time()
await bot.send_file(
up.chat_id,
title + ".zip",
force_document=True,
allow_cache=False,
reply_to=up.message.id,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, mone, c_time, "[UPLOADING]", input_str)),
)
os.rmdir(ZIP_DOWNLOAD_DIRECTORY)
await up.delete()
async def download(event):
if event.fwd_from:
return
if Config.GITHUB_ACCESS_TOKEN is None:
await event.edit("`Please ADD Proper Access Token from github.com`")
return
if Config.GIT_REPO_NAME is None:
await event.edit("`Please ADD Proper Github Repo Name of your userbot`"
)
return
mone = await event.reply("Processing ...")
input_str = event.pattern_match.group(1)
if not os.path.isdir(GIT_TEMP_DIR):
os.makedirs(GIT_TEMP_DIR)
start = datetime.now()
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
GIT_TEMP_DIR,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(progress(d, t, mone, c_time, "trying to download")))
except Exception as e:
await mone.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await event.delete()
await mone.edit("Downloaded to `{}` in {} seconds.".format(
downloaded_file_name, ms))
await mone.edit("Committing to Github....")
try:
await git_commit(downloaded_file_name, mone)
except:
await mone.edit("`Please reply to a python module`")
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 SnapDragon",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
await event.edit("DONE!!!")
await asyncio.sleep(7)
await event.delete()
async def _(event):
if event.fwd_from:
return
mone = await event.edit("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 _(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 rar to `{}` in {} seconds.".format(
downloaded_file_name, ms))
patoolib.extract_archive(downloaded_file_name, outdir=extracted)
filename = sorted(get_lst_of_files(extracted, []))
#filename = filename + "/"
await event.edit("Unraring 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"UnRarred `{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")
# )
)
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)
await asyncio.sleep(2)
shutil.rmtree(Config.TMP_DOWNLOAD_DIRECTORY)
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.")
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, "indiriliyor")))
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 = downloaded_file_name[12:-4] + ".opus"
new_required_file_name = 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 = downloaded_file_name[12:-4] + ".mp3"
new_required_file_name = 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()
stderr.decode().strip()
stdout.decode().strip()
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, "yükleniyor..")))
ms_two = (end_two - end).seconds
os.remove(new_required_file_name)
await asyncio.sleep(5)
os.remove(downloaded_file_name)
a = await event.edit(f"converted in {ms_two} seconds")
await asyncio.sleep(5)
await a.delete()
async def _(event):
if event.fwd_from:
return
mone = await event.reply("Processing ...")
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.PRIVATE_GROUP_BOT_API_ID is None:
await event.edit(
"Please set the required environment variable `PRIVATE_GROUP_BOT_API_ID` 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.G_DRIVE_AUTH_TOKEN_DATA is not None:
with open(G_DRIVE_TOKEN_FILE, "w") as t_file:
t_file.write(Config.G_DRIVE_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 event.edit("Processing ...")
if Config.VERY_STREAM_LOGIN is None or Config.VERY_STREAM_KEY is None:
await mone.edit("This module requires API key from https://verystream.com. Aborting!")
return False
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:
# required_file_name will have the full path
file_name = os.path.basename(required_file_name)
if "." in file_name:
file_name = file_name.rsplit(".", maxsplit=1)[0]
file_name = file_name + str(time.time())
file_size = os.stat(required_file_name).st_size
# https://stackoverflow.com/a/22058673/4723940
sha_one_file_hash = get_sha_one_hash(required_file_name, 65536)
# /* STEP 1: get upload_key */
login = Config.VERY_STREAM_LOGIN
key = Config.VERY_STREAM_KEY
sha1 = sha_one_file_hash
mime = magic.Magic(mime=True)
step_zero_url = f"https://api.verystream.com/file/createfolder?login={login}&key={key}&name={file_name}"
async with aiohttp.ClientSession() as session:
resp_zero = await session.get(step_zero_url)
step_zero_response_text = json.loads(await resp_zero.text())
# logger.info(step_zero_response_text)
if step_zero_response_text["status"] == 200:
folder_id_e = step_zero_response_text["result"]["folderid"]
await mone.edit(f"Created Folder with ID: {folder_id_e}")
step_one_url = f"https://api.verystream.com/file/ul?login={login}&key={key}&sha1={sha1}&folder={folder_id_e}"
resp = await session.get(step_one_url)
# logger.info(resp.status)
step_one_response_text = json.loads(await resp.text())
# logger.info(step_one_response_text)
if step_one_response_text["status"] == 200:
url = step_one_response_text["result"]["url"]
await mone.edit(f"Start Uploading to {url}")
start = datetime.now()
files = {"file1": (file_name, open(
required_file_name, "rb"))}
resp = requests.post(url, files=files)
step_two_response_text = resp.json()
# logger.info(step_two_response_text)
if step_two_response_text["status"] == 200:
output_str = json.dumps(
step_two_response_text["result"], sort_keys=True, indent=4)
stream_url = step_two_response_text["result"]["url"]
end = datetime.now()
ms = (end - start).seconds
await mone.edit(f"Obtained {stream_url} in {ms} seconds.\n{output_str}")
# cleanup
await event.delete()
try:
os.remove(required_file_name)
except:
pass
else:
await mone.edit(f"VeryStream returned {step_two_response_text['status']} => {step_two_response_text['msg']}, after STEP ONE")
else:
await mone.edit(f"VeryStream returned {step_one_response_text['status']} => {step_one_response_text['msg']}, after STEP ONE")
else:
await mone.edit(f"VeryStream returned {step_zero_response_text['status']} => {step_zero_response_text['msg']}, after STEP INIT")
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 event.edit("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 download_file(
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"))
)
# 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("Downloaded to `{}` in {} seconds.".format(
downloaded_file_name, ms))
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)
display_message = ""
c_time = time.time()
while not downloader.isFinished():
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}]\nProgress: {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"trying to download\n"
current_message += f"URL: {url}\n"
current_message += f"File Name: {file_name}\n"
current_message += f"{progress_str}\n"
current_message += f"{humanbytes(downloaded)} of {humanbytes(total_length)}\n"
current_message += f"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 os.path.exists(downloaded_file_name):
await mone.edit("Downloaded to `{}` in {} seconds.".format(
downloaded_file_name, ms))
else:
await mone.edit("Incorrect URL\n {}".format(input_str))
else:
await mone.edit("Reply to a message to download to my local server.")
async def download(dryb):
""" For .gdrive command, upload files to google drive. """
if not dryb.text[0].isalpha() and dryb.text[0] not in ("/", "#", "@", "!"):
if dryb.fwd_from:
return
await dryb.edit("Processing ...")
input_str = dryb.pattern_match.group(1)
if CLIENT_ID is None or CLIENT_SECRET is None:
return false
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
required_file_name = None
elif input_str:
start = datetime.now()
url = input_str
file_name = os.path.basename(url)
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
file_name = file_name.strip()
downloaded_file_name = Config.TMP_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
downloader.get_speed()
round(diff) * 1000
progress_str = "[{0}{1}]\nProgress: {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"{status}...\nURL: {url}\nFile Name: {file_name}\n{progress_str}\n{humanbytes(downloaded)} of {humanbytes(total_length)}\nETA: {estimated_total_time}"
if current_message != display_message:
await dryb.edit(current_message)
display_message = current_message
await asyncio.sleep(3)
except Exception as e:
logger.info(str(e))
end = datetime.now()
ms = (end - start).seconds
if downloader.isSuccessful():
await dryb.edit(
"Downloaded to `{}` in {} seconds.\nNow Uploading to Google Drive..."
.format(downloaded_file_name, ms))
required_file_name = downloaded_file_name
else:
await dryb.edit("Incorrect URL\n{}".format(url))
elif dryb.reply_to_msg_id:
start = datetime.now()
try:
c_time = time.time()
downloaded_file_name = await dryb.client.download_media(
await dryb.get_reply_message(),
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, dryb, c_time, "Downloading...")),
)
except Exception as e: # pylint:disable=C0103,W0703
await dryb.edit(str(e))
else:
end = datetime.now()
required_file_name = downloaded_file_name
ms = (end - start).seconds
await dryb.edit(
"Downloaded to `{}` in {} seconds.\nNow Uploading to GDrive..."
.format(required_file_name, ms))
if required_file_name:
#
if Config.G_DRIVE_AUTH_TOKEN_DATA is not None:
with open(G_DRIVE_TOKEN_FILE, "w") as t_file:
t_file.write(Config.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)
await dryb.edit(
f"File:`{required_file_name}`\nHas 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}`")
async def _(event):
if event.fwd_from:
return
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
start = datetime.now()
input_str = event.pattern_match.group(1)
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)
display_message = ""
c_time = time.time()
while not downloader.isFinished():
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}]\nProgress: {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......\n"
current_message += f"URL: {url}\n"
current_message += f"File Name: {file_name}\n"
current_message += f"{progress_str}\n"
current_message += f"{humanbytes(downloaded)} of {humanbytes(total_length)}\n"
current_message += f"ETA: {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:
logger.info(str(e))
end = datetime.now()
ms_dl = (end - start).seconds
if downloader.isSuccessful():
await event.edit("Downloaded to `{}` in {} seconds.".format(downloaded_file_name, ms_dl))
if os.path.exists(downloaded_file_name):
c_time = time.time()
await borg.send_file(
event.chat_id,
downloaded_file_name,
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, event, c_time, "trying to upload")
)
)
end_two = datetime.now()
os.remove(downloaded_file_name)
ms_two = (end_two - end).seconds
await event.edit("Downloaded in {} seconds. Uploaded in {} seconds.".format(ms_dl, ms_two))
else:
await event.edit("File Not Found {}".format(input_str))
else:
await mone.edit("Incorrect URL\n {}".format(input_str))
async def _(event):
if event.fwd_from:
return
await event.edit("Rename & Upload as Streamable 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 borg.download_media(
reply_message,
downloaded_file_name,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, event, c_time, "trying to download")
)
)
end_one = datetime.now()
ms_one = (end_one - start).seconds
if os.path.exists(downloaded_file_name):
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
start = datetime.now()
metadata = extractMetadata(createParser(downloaded_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,
downloaded_file_name,
thumb=thumb,
caption=downloaded_file_name,
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, event, c_time, "trying to upload")
)
)
except Exception as e:
await event.edit(str(e))
else:
end = datetime.now()
os.remove(downloaded_file_name)
ms_two = (end - end_one).seconds
await event.edit("Downloaded in {} seconds. Uploaded in {} seconds.".format(ms_one, ms_two))
else:
await event.edit("File Not Found {}".format(input_str))
else:
await event.edit("Syntax // .rnstreamupload file.name as reply to a Telegram media")
async def _(event):
if event.fwd_from:
return
mone = await event.reply("Processing ...")
if Config.MIRROR_ACE_API_KEY is None or Config.MIRROR_ACE_API_TOKEN is None:
await mone.edit(
"This module requires API key from https://ouo.io/My1jdU. Aborting!"
)
return False
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:
# required_file_name will have the full path
file_name = os.path.basename(required_file_name)
file_size = os.stat(required_file_name).st_size
# /* STEP 1: get upload_key */
step_one_url = "https://mirrorace.com/api/v1/file/upload"
step_one_auth_params = {
"api_key": Config.MIRROR_ACE_API_KEY,
"api_token": Config.MIRROR_ACE_API_TOKEN
}
async with aiohttp.ClientSession() as session:
resp = await session.post(step_one_url, data=step_one_auth_params)
# logger.info(resp.status)
if resp.status == 200:
step_one_response_json = await resp.json()
logger.info(step_one_response_json)
if step_one_response_json["status"] == "success":
await mone.edit("Received Upload URL from MirrorAce. ...")
start = datetime.now()
# /* STEP 2: Upload file */
# step one: response vars
step_two_upload_url = step_one_response_json["result"][
"server_file"]
cTracker = step_one_response_json["result"]["cTracker"]
upload_key = step_one_response_json["result"]["upload_key"]
default_mirrors = step_one_response_json["result"][
"default_mirrors"]
max_chunk_size = step_one_response_json["result"][
"max_chunk_size"]
max_file_size = step_one_response_json["result"][
"max_file_size"]
max_mirrors = step_one_response_json["result"][
"max_mirrors"]
# check file size limit
if int(file_size) >= int(max_file_size):
await mone.edit(
f"File exceeds maximum file size allowed: {max_file_size}"
)
return False
# step two: setup
mirrors = default_mirrors
chunk_size = int(max_chunk_size)
step_two_params = {
"api_key": Config.MIRROR_ACE_API_KEY,
"api_token": Config.MIRROR_ACE_API_TOKEN,
"cTracker": cTracker,
"upload_key": upload_key,
"mirrors[]": mirrors,
# //these required vars will be added by buildMultiPartRequest function
# //'files' => $file,
# //'mirrors[1]' => 1,
# //'mirrors[2]' => 2,
}
# //range vars //for multi chunk upload
response = False
with open(required_file_name, "rb") as f_handle:
# start chunk upload
for chunk in iter((lambda: f_handle.read(chunk_size)),
""):
# for chunk in f_handle.read(chunk_size):
# print(chunk)
# while (i < chunks) and not while_error:
# chunk = f_handle.read(chunk_size)
if not chunk:
break
headers = {
"Content-Range":
str(len(chunk)),
"Content-Length":
str(len(step_two_params) + len(chunk)),
# "Content-Type": "multipart/form-data"
}
# https://github.com/aio-libs/aiohttp/issues/3571#issuecomment-456528924
response = requests.post(
step_two_upload_url,
files=[("files", (file_name, chunk))],
data=step_two_params,
# headers=headers
)
logger.info(response.content)
logger.info(response)
final_response = response.json()
if final_response["status"] == "success":
end = datetime.now()
ms = (end - start).seconds
final_url = final_response["result"]["url"]
await mone.edit(f"Added to {final_url} in {ms} seconds"
)
else:
await mone.edit(
f"MirrorAce returned {final_response['status']} => {final_response['result']}"
)
else:
await mone.edit(
f"MirrorAce returned {step_one_response_json['status']} => {step_one_response_json['result']}, after STEP TWO"
)
else:
await mone.edit(
f"MirrorAce returned {resp['status']} => {resp['result']}, after STEP ONE"
)
else:
await mone.edit(
"File Not found in local server. Give me a file path :((")
async def magnet_download(event):
if event.fwd_from:
return
if not os.path.exists(Config.FF_MPEG_DOWN_LOAD_MEDIA_PATH):
await event.edit(
f"a media file needs to be downloaded, and saved to the following path: `{Config.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(Config.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,
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))
elif len(cmt) == 2:
# output should be image
cmd, start_time = cmt
o = await take_screen_shot(Config.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 upload_google_photos(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(2)
logger.info(input_str)
if not event.reply_to_msg_id and not input_str:
await event.edit(
"©️ <b>[Forwarded from utubebot]</b>\nno one gonna help you 🤣🤣🤣🤣",
parse_mode="html"
)
return
token_file = TOKEN_FILE_NAME
is_cred_exists, creds = await check_creds(
token_file,
event
)
if not is_cred_exists:
await event.edit(
"😏 <code>gphoto setup</code> first 😡😒😒",
parse_mode="html"
)
service = build(
"photoslibrary",
"v1",
http=creds.authorize(Http())
)
# create directory if not exists
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
file_path = None
if input_str and os.path.exists(input_str):
file_path = input_str
elif not input_str:
media_message = await event.client.get_messages(
entity=event.chat_id,
ids=event.reply_to_msg_id
)
c_time = time.time()
file_path = await media_message.download_media(
file=Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, event, c_time, "trying to download")
)
)
logger.info(file_path)
if not file_path:
await event.edit(
"<b>[stop spamming]</b>",
parse_mode="html"
)
return
file_name, mime_type, file_size = file_ops(file_path)
await event.edit(
"file downloaded, "
"gathering upload informations "
)
async with aiohttp.ClientSession() as session:
headers = {
"Content-Length": "0",
"X-Goog-Upload-Command": "start",
"X-Goog-Upload-Content-Type": mime_type,
"X-Goog-Upload-File-Name": file_name,
"X-Goog-Upload-Protocol": "resumable",
"X-Goog-Upload-Raw-Size": str(file_size),
"Authorization": "Bearer " + creds.access_token,
}
# Step 1: Initiating an upload session
step_one_response = await session.post(
f"{PHOTOS_BASE_URI}/v1/uploads",
headers=headers,
)
if step_one_response.status != 200:
await event.edit(
(await step_one_response.text())
)
return
step_one_resp_headers = step_one_response.headers
logger.info(step_one_resp_headers)
# Step 2: Saving the session URL
real_upload_url = step_one_resp_headers.get(
"X-Goog-Upload-URL"
)
logger.info(real_upload_url)
upload_granularity = int(step_one_resp_headers.get(
"X-Goog-Upload-Chunk-Granularity"
))
logger.info(upload_granularity)
# https://t.me/c/1279877202/74
number_of_req_s = int((
file_size / upload_granularity
))
logger.info(number_of_req_s)
async with aiofiles.open(
file_path,
mode="rb"
) as f_d:
for i in range(number_of_req_s):
current_chunk = await f_d.read(upload_granularity)
headers = {
"Content-Length": str(len(current_chunk)),
"X-Goog-Upload-Command": "upload",
"X-Goog-Upload-Offset": str(i * upload_granularity),
"Authorization": "Bearer " + creds.access_token,
}
logger.info(i)
logger.info(headers)
response = await session.post(
real_upload_url,
headers=headers,
data=current_chunk
)
logger.info(response.headers)
await f_d.seek(upload_granularity)
# await f_d.seek(upload_granularity)
current_chunk = await f_d.read(upload_granularity)
# https://t.me/c/1279877202/74
logger.info(number_of_req_s)
headers = {
"Content-Length": str(len(current_chunk)),
"X-Goog-Upload-Command": "upload, finalize",
"X-Goog-Upload-Offset": str(number_of_req_s * upload_granularity),
"Authorization": "Bearer " + creds.access_token,
}
logger.info(headers)
response = await session.post(
real_upload_url,
headers=headers,
data=current_chunk
)
logger.info(response.headers)
final_response_text = await response.text()
logger.info(final_response_text)
await event.edit(
"uploaded to Google Photos, "
"getting FILE URI 🤔🤔"
)
response_create_album = service.mediaItems().batchCreate(
body={
"newMediaItems": [{
"description": "uploaded using @UniBorg v7",
"simpleMediaItem": {
"fileName": file_name,
"uploadToken": final_response_text
}
}]
}
).execute()
logger.info(response_create_album)
try:
photo_url = response_create_album.get(
"newMediaItemResults"
)[0].get("mediaItem").get("productUrl")
await event.edit(
photo_url
)
except Exception as e:
await event.edit(str(e))
