async def ff_mpeg_trim_cmd(event):
if event.fwd_from:
return
if not os.path.exists(FF_MPEG_DOWN_LOAD_MEDIA_PATH):
reply_message = await event.get_reply_message()
if reply_message:
start = datetime.now()
media = media_type(reply_message)
if media not in ["Video", "Audio", "Voice", "Round Video", "Gif"]:
return await edit_delete(event, "`Only media files are supported`", 5)
REBELevent = await edit_or_reply(event, "`Saving the file...`")
try:
c_time = time.time()
downloaded_file_name = await event.client.download_media(
reply_message,
FF_MPEG_DOWN_LOAD_MEDIA_PATH,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, REBELevent, c_time, "trying to download")
),
)
except Exception as e:
await REBELevent.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await REBELevent.edit(
f"Saved file to `{downloaded_file_name}` in `{ms}` seconds."
)
else:
await edit_delete(event, "`Reply to a any media file`")
else:
await edit_delete(
event,
f"A media file already exists in path. Please remove the media and try again!\n`.ffmpegclear`",
)
async def ff_mpeg_trim_cmd(event):
if event.fwd_from:
return
if not os.path.exists(FF_MPEG_DOWN_LOAD_MEDIA_PATH):
await edit_delete(
event,
f"a media file needs to be download, and save to the following path: `{FF_MPEG_DOWN_LOAD_MEDIA_PATH}`",
)
return
reply_to_id = await reply_id(event)
REBELevent = await edit_or_reply(event, "`Triming the media...........`")
current_message_text = event.raw_text
cmt = current_message_text.split(" ")
start = datetime.now()
out_put_file_name = os.path.join(
Config.TMP_DOWNLOAD_DIRECTORY, f"{str(round(time.time()))}.mp3"
)
if len(cmt) == 3:
# output should be audio
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,
out_put_file_name,
)
if o is None:
return await edit_delete(
REBELevent, f"**Error : **`Can't complete the process`"
)
try:
c_time = time.time()
await event.client.send_file(
event.chat_id,
o,
caption=" ".join(cmt[1:]),
force_document=False,
supports_streaming=True,
allow_cache=False,
reply_to=reply_to_id,
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, REBELevent, c_time, "trying to upload")
),
)
os.remove(o)
except Exception as e:
return await edit_delete(REBELevent, f"**Error : **`{e}`")
else:
await edit_delete(REBELevent, "RTFM")
return
end = datetime.now()
ms = (end - start).seconds
await edit_delete(REBELevent, f"`Completed Process in {ms} seconds`", 3)
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 REBELBOT",
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 REBELBOT",
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 REBELBOT",
force_document=True,
allow_cache=False,
reply_to=event.message.id,
)
await event.edit("DONE!!!")
await asyncio.sleep(5)
await event.delete()
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 edit_or_reply(lazy, "Processing video song request....")
else:
rkp = await edit_or_reply(lazy, "Processing video song request....")
url = v_url.pattern_match.group(1)
if not url:
return await rkp.edit("**Error** \n__Usage:__ `vsong <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("Video Song Request Processed. **Downloading Now!!**")
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 Video Song")
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 video song 🎶 :-\
\n\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\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
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 edit_or_reply(event, "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())
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 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.")
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 edit_or_reply(
event,
"reply to a media to use the `nfc` operation.\nInspired by @FileConverterBot"
)
return
await edit_or_reply(event, "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 edit_or_reply(event, str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await edit_or_reply(
event,
"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 edit_or_reply(event, "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()
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 edit_or_reply(event, f"converted in {ms_two} seconds")
async def _(event):
if event.fwd_from:
return
mone = await edit_or_reply(event, "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"]
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 _(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
await edit_or_reply(event, "```Reply to any media file.```")
return
reply_message = await event.get_reply_message()
if not reply_message.media:
await edit_or_reply(event, "reply to media file")
return
input_str = event.pattern_match.group(1)
if input_str is None:
await edit_or_reply(event, "try `.nfc voice` or`.nfc mp3`")
return
if input_str in ["mp3", "voice"]:
event = await edit_or_reply(event, "converting...")
else:
await edit_or_reply(event, "try `.nfc voice` or`.nfc mp3`")
return
try:
start = datetime.now()
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, 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 = []
voice_note = False
supports_streaming = False
if input_str == "voice":
new_required_file_caption = "voice_" + 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 = "mp3_" + 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()
stderr.decode().strip()
stdout.decode().strip()
os.remove(downloaded_file_name)
if os.path.exists(new_required_file_name):
force_document = False
await event.client.send_file(
entity=event.chat_id,
file=new_required_file_name,
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")),
)
os.remove(new_required_file_name)
await event.delete()