async def handler(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
if os.path.exists(input_str):
start = datetime.now()
lst_of_files = sorted(get_lst_of_files(input_str, []))
logger.info(lst_of_files)
u = 0
await event.edit("Found {} files. ".format(len(lst_of_files)) +
"Uploading will start soon. " + "Please wait!")
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
for single_file in lst_of_files:
if os.path.exists(single_file):
caption_rts = os.path.basename(single_file)
force_document = True
supports_streaming = False
document_attributes = []
width = 0
height = 0
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")
if single_file.endswith((".mkv", ".mp4", ".webm")):
metadata = extractMetadata(createParser(single_file))
duration = 0
if metadata.has("duration"):
duration = metadata.get('duration').seconds
document_attributes = [
DocumentAttributeVideo(duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True)
]
supports_streaming = True
force_document = False
if single_file.endswith((".mp3", ".flac", ".wav")):
metadata = extractMetadata(createParser(single_file))
duration = 0
title = ""
artist = ""
if metadata.has("duration"):
duration = metadata.get('duration').seconds
if metadata.has("title"):
title = metadata.get("title")
if metadata.has("artist"):
artist = metadata.get("artist")
document_attributes = [
DocumentAttributeAudio(duration=duration,
voice=False,
title=title,
performer=artist,
waveform=None)
]
supports_streaming = True
force_document = False
try:
await client.send_file(
event.chat_id,
single_file,
caption=caption_rts,
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
reply_to=event.message.id,
thumb=thumb,
attributes=document_attributes,
)
except Exception as e:
await client.send_message(event.chat_id,
"{} caused `{}`".format(
caption_rts, str(e)),
reply_to=event.message.id)
continue
os.remove(single_file)
u = u + 1
await asyncio.sleep(5)
end = datetime.now()
ms = (end - start).seconds
await event.edit("Uploaded {} files in {} seconds.".format(u, ms))
else:
await event.edit("404: Directory not found.")
async def uploadir(event):
input_str = event.pattern_match.group(1)
hmm = event.message.id
udir_event = await edit_or_reply(event, "Uploading....")
if os.path.exists(input_str):
await udir_event.edit(
f"Gathering file details in directory `{input_str}`")
lst_of_files = []
lst_of_files = await catlst_of_files(input_str)
uploaded = 0
await udir_event.edit(
"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 borg.send_file(
udir_event.chat_id,
single_file,
caption=caption_rts,
force_document=False,
allow_cache=False,
reply_to=hmm,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, 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 borg.send_file(
event.chat_id,
single_file,
caption=caption_rts,
thumb=thumb_image,
force_document=False,
allow_cache=False,
reply_to=hmm,
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)),
)
uploaded = uploaded + 1
await udir_event.edit(
"Uploaded {} files successfully !!".format(uploaded))
else:
await udir_event.edit("404: Directory Not Found")
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.edit("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.edit(
"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.edit(
"Uploaded {} files successfully !!".format(uploaded))
else:
await udir_event.edit("404: Directory Not Found")
async def _(event):
if event.fwd_from:
return
mone = await event.reply("Processing ...")
input_str = event.pattern_match.group(1)
thumb = None
file_name = input_str
if os.path.exists(file_name):
if not file_name.endswith((".mkv", ".mp4", ".mp3", ".flac")):
await mone.edit(
"Sorry. But I don't think {} is a streamable file.".format(file_name) + \
" Please try again.\n" + \
"**Supported Formats**: MKV, MP4, MP3, FLAC"
)
return False
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
else:
thumb = get_video_thumb(file_name, thumb_image_path)
start = datetime.now()
metadata = extractMetadata(createParser(file_name))
duration = 0
width = 0
height = 0
if metadata.has("duration"):
duration = metadata.get('duration').seconds
if os.path.exists(thumb_image_path):
metadata = extractMetadata(createParser(thumb_image_path))
if metadata.has("width"):
width = metadata.get("width")
if metadata.has("height"):
height = metadata.get("height")
# Telegram only works with MP4 files
# this is good, since with MKV files sent as streamable Telegram responds,
# Bad Request: VIDEO_CONTENT_TYPE_INVALID
c_time = time.time()
try:
await borg.send_file(
event.chat_id,
file_name,
thumb=thumb,
caption=input_str,
force_document=False,
allow_cache=False,
reply_to=event.message.id,
attributes=[
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True
)
],
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, mone, c_time, "trying to upload")
)
)
except Exception as e:
await mone.edit(str(e))
else:
end = datetime.now()
os.remove(input_str)
ms = (end - start).seconds
await mone.edit("Uploaded in {} seconds.".format(ms))
else:
await mone.edit("404: File Not Found")
async def _(event):
if event.fwd_from:
return
textx = await event.get_reply_message()
message = event.pattern_match.group(1)
input_str = event.pattern_match.group(1)
if message:
pass
elif textx:
message = textx.text
else:
await event.edit("`Usage: .direct <url>`")
return
mone = await event.edit("Processing ...")
if not os.path.isdir(filedir):
os.makedirs(filedir)
reply = ''
links = message
if not links:
reply = "`No links found!`"
await event.edit(reply)
if links:
with RemoteZip(message) as zip:
zip.extractall(filedir)
x = zip.extractall(filedir)
filename = sorted(get_lst_of_files(x, []))
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 = True
supports_streaming = False
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"remote unzip `{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)
async def uploadir(udir_event):
""" For .uploadir command, allows you to upload everything from a folder in the server"""
if not udir_event.text[0].isalpha() and udir_event.text[0] not in (
"/", "#", "@", "!"):
if udir_event.fwd_from:
return
input_str = udir_event.pattern_match.group(1)
if os.path.exists(input_str):
start = datetime.now()
await udir_event.edit("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.edit(
"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)
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=progress,
)
else:
thumb_image = os.path.join(input_str, "thumb.jpg")
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=progress,
)
os.remove(single_file)
uploaded = uploaded + 1
end = datetime.now()
duration = (end - start).seconds
await udir_event.edit("Uploaded {} files in {} seconds.".format(
uploaded, duration))
else:
await udir_event.edit("404: Directory Not Found")
async def video_catfile(event):
reply = await event.get_reply_message()
input_str = "".join(event.text.split(maxsplit=1)[1:])
if input_str:
path = Path(input_str)
if not os.path.exists(path):
await edit_or_reply(
event,
f"`there is no such directory/file with the name {path} to upload`",
)
return
catevent = await edit_or_reply(event,
"`Converting to video note..........`")
filename = os.path.basename(path)
catfile = os.path.join("./temp", filename)
copyfile(path, catfile)
else:
if not reply:
await edit_delete(event, "`Reply to supported media`", 5)
return
if not (reply and (reply.media)):
await edit_delete(event, "`Reply to supported Media...`", 5)
return
catevent = await edit_or_reply(event,
"`Converting to video note..........`")
catfile = await reply.download_media(file="./temp/")
if not catfile.endswith((".mp4", ".tgs", ".mp3", ".mov", ".gif", ".opus")):
os.remove(catfile)
await edit_delete(catevent, "```Supported Media not found...```", 5)
return
if catfile.endswith((".mp4", ".tgs", ".mov", ".gif")):
if catfile.endswith((".tgs")):
hmm = await make_gif(catevent, catfile)
if hmm.endswith(("@tgstogifbot")):
os.remove(catfile)
return await catevent.edit(hmm)
os.rename(hmm, "./temp/circle.mp4")
catfile = "./temp/circle.mp4"
media_info = MediaInfo.parse(catfile)
aspect_ratio = 1
for track in media_info.tracks:
if track.track_type == "Video":
aspect_ratio = track.display_aspect_ratio
height = track.height
width = track.width
if aspect_ratio != 1:
crop_by = width if (height > width) else height
await runcmd(
f'ffmpeg -i {catfile} -vf "crop={crop_by}:{crop_by}" {PATH}')
else:
copyfile(catfile, PATH)
if str(catfile) != str(PATH):
os.remove(catfile)
else:
thumb_loc = os.path.join(Config.TMP_DOWNLOAD_DIRECTORY,
"thumb_image.jpg")
catthumb = None
try:
catthumb = await reply.download_media(thumb=-1)
except:
catthumb = os.path.join("./temp", "thumb.jpg")
await thumb_from_audio(catfile, catthumb)
if catthumb is None:
catthumb = os.path.join("./temp", "thumb.jpg")
copyfile(thumb_loc, catthumb)
if (catthumb is not None and not os.path.exists(catthumb)
and os.path.exists(thumb_loc)):
catthumb = os.path.join("./temp", "thumb.jpg")
copyfile(thumb_loc, catthumb)
if catthumb is not None and os.path.exists(catthumb):
await runcmd(
f"ffmpeg -loop 1 -i {catthumb} -i {catfile} -c:v libx264 -tune stillimage -c:a aac -b:a 192k -vf \"scale='iw-mod (iw,2)':'ih-mod(ih,2)',format=yuv420p\" -shortest -movflags +faststart {PATH}"
)
os.remove(catfile)
else:
os.remove(catfile)
return await edit_delete(catevent,
"`No thumb found to make it video note`",
5)
if os.path.exists(PATH):
catid = event.reply_to_msg_id
c_time = time.time()
await event.client.send_file(
event.chat_id,
PATH,
allow_cache=False,
reply_to=catid,
video_note=True,
attributes=[
DocumentAttributeVideo(
duration=60,
w=1,
h=1,
round_message=True,
supports_streaming=True,
)
],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, catevent, c_time, "Uploading...", PATH)),
)
os.remove(PATH)
await catevent.delete()
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()
time.time()
to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY
downloaded_file_name = os.path.join(to_download_directory, file_name)
downloaded_file_name = await event.client.download_media(
reply_message, downloaded_file_name
)
end_one = datetime.now()
ms_one = (end_one - start).seconds
if os.path.exists(downloaded_file_name):
thumb = None
if not downloaded_file_name.endswith((".mkv", ".mp4", ".mp3", ".flac")):
await event.edit(
"Sorry. But I don't think {} is a streamable file. Please try again.\n**Supported Formats**: MKV, MP4, MP3, FLAC".format(
downloaded_file_name
)
)
return False
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
else:
thumb = get_video_thumb(downloaded_file_name, 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 event.client.send_file(
event.chat_id,
downloaded_file_name,
thumb=thumb,
caption="reuploaded by [PikaBot](https://www.github.com/ItzSjDude/PikachuUserbot",
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,
)
],
)
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.edit("Processing ...")
input_str = event.pattern_match.group(1)
thumb = None
thumb_image_path = Config.TMP_DOWNLOAD_DIRECTORY + "thumb_image.jpg"
logger.info(thumb_image_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,
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 now preparing to streaming upload")
# if os.path.exists(input_str):
if os.path.exists(Config.TMP_DOWNLOAD_DIRECTORY):
if not downloaded_file_name.endswith(
(".mkv", ".mp4", ".mp3", ".flac", ".webm", ".ts", ".mov")):
await mone.edit(
"**Supported Formats**: MKV, MP4, MP3, FLAC")
return False
if downloaded_file_name.upper().endswith(
("MKV", "MP4", "WEBM")):
metadata = extractMetadata(
createParser(downloaded_file_name))
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(
downloaded_file_name,
os.path.dirname(os.path.abspath(downloaded_file_name)),
(duration / 2))
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")
c_time = time.time()
try:
await borg.send_file(
event.chat_id,
downloaded_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))
os.remove(thumb)
await asyncio.sleep(5)
os.remove(downloaded_file_name)
else:
await mone.edit("404: File Not Found")
async def download_video(v_url):
""" For .rip command, download media from YouTube and many other sites. """
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`Preparing to download...`")
if type == "audio":
opts = {
"format":
"bestaudio",
"addmetadata":
True,
"key":
"FFmpegMetadata",
"writethumbnail":
True,
"prefer_ffmpeg":
True,
"geo_bypass":
True,
"nocheckcertificate":
True,
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "mp3",
"preferredquality": "320",
}],
"outtmpl":
"%(id)s.mp3",
"quiet":
True,
"logtostderr":
False,
}
video = False
song = True
elif type == "video":
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 v_url.edit("`Fetching data, please wait..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
return await v_url.edit(f"`{str(DE)}`")
except ContentTooShortError:
return await v_url.edit("`The download content was too short.`")
except GeoRestrictedError:
return await v_url.edit(
"`Video is not available from your geographic location "
"due to geographic restrictions imposed by a website.`")
except MaxDownloadsReached:
return await v_url.edit("`Max-downloads limit has been reached.`")
except PostProcessingError:
return await v_url.edit("`There was an error during post processing.`")
except UnavailableVideoError:
return await v_url.edit(
"`Media is not available in the requested format.`")
except XAttrMetadataError as XAME:
return await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
except ExtractorError:
return await v_url.edit("`There was an error during info extraction.`")
except Exception as e:
return await v_url.edit(f"{str(type(e)): {str(e)}}")
c_time = time.time()
if song:
await v_url.edit(
f"`Preparing to upload song:`\n**{rip_data['title']}**"
f"\nby **{rip_data['uploader']}**")
with open(rip_data["id"] + ".mp3", "rb") as f:
result = await upload_file(
client=v_url.client,
file=f,
name=f"{rip_data['id']}.mp3",
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{rip_data['title']}.mp3")),
)
img_extensions = ["jpg", "jpeg", "webp"]
img_filenames = [
fn_img for fn_img in os.listdir() if any(
fn_img.endswith(ext_img) for ext_img in img_extensions)
]
thumb_image = img_filenames[0]
await v_url.client.send_file(
v_url.chat_id,
result,
supports_streaming=True,
attributes=[
DocumentAttributeAudio(
duration=int(rip_data["duration"]),
title=str(rip_data["title"]),
performer=str(rip_data["uploader"]),
)
],
thumb=thumb_image,
)
os.remove(thumb_image)
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(
f"`Preparing to upload video:`\n**{rip_data['title']}**"
f"\nby **{rip_data['uploader']}**")
thumb_image = await get_video_thumb(rip_data["id"] + ".mp4",
"thumb.png")
with open(rip_data["id"] + ".mp4", "rb") as f:
result = await upload_file(
client=v_url.client,
file=f,
name=f"{rip_data['id']}.mp4",
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{rip_data['title']}.mp4")),
)
await v_url.client.send_file(
v_url.chat_id,
result,
thumb=thumb_image,
attributes=[
DocumentAttributeVideo(
duration=rip_data["duration"],
w=rip_data["width"],
h=rip_data["height"],
supports_streaming=True,
)
],
caption=rip_data["title"],
)
os.remove(f"{rip_data['id']}.mp4")
os.remove(thumb_image)
await v_url.delete()
async def gen_sample(e):
sec = e.pattern_match.group(1)
stime = 35
if sec and sec.isdigit():
stime = int(sec)
vido = await e.get_reply_message()
if vido and vido.media and "video" in mediainfo(vido.media):
if hasattr(vido.media, "document"):
vfile = vido.media.document
name = vido.file.name
else:
vfile = vido.media
name = ""
if not name:
name = "video_" + dt.now().isoformat("_", "seconds") + ".mp4"
xxx = await eor(e, get_string("audiotools_5"))
c_time = time.time()
file = await downloader(
"resources/downloads/" + name,
vfile,
xxx,
c_time,
"Downloading " + name + "...",
)
o_size = os.path.getsize(file.name)
d_time = time.time()
diff = time_formatter((d_time - c_time) * 1000)
file_name = (file.name).split("/")[-1]
out = file_name.replace(file_name.split(".")[-1], "_sample.mkv")
xxx = await xxx.edit(
f"Downloaded `{file.name}` of `{humanbytes(o_size)}` in `{diff}`.\n\nNow Generating Sample of `{stime}` seconds..."
)
ss, dd = duration_s(file.name, stime)
cmd = f'ffmpeg -i "{file.name}" -preset ultrafast -ss {ss} -to {dd} -codec copy -map 0 "{out}" -y'
await bash(cmd)
os.remove(file.name)
f_time = time.time()
mmmm = await uploader(
out,
out,
f_time,
xxx,
"Uploading " + out + "...",
)
data = await metadata(out)
width = data["width"]
height = data["height"]
duration = data["duration"]
attributes = [
DocumentAttributeVideo(
duration=duration, w=width, h=height, supports_streaming=True
)
]
caption = f"A Sample Video Of `{stime}` seconds"
await e.client.send_file(
e.chat_id,
mmmm,
thumb="resources/extras/ultroid.jpg",
caption=caption,
attributes=attributes,
force_document=False,
reply_to=e.reply_to_msg_id,
)
await xxx.delete()
else:
await eor(e, "`Reply To Video File Only`", time=5)
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):
reply_to_id = event.message.id
if event.reply_to_msg_id:
reply_to_id = event.reply_to_msg_id
reply = await event.get_reply_message()
if event.pattern_match.group(1):
query = event.pattern_match.group(1)
await event.edit("`searching for your videosong...`")
elif reply:
query = str(reply.message)
await event.edit("`searching for your song...`")
else:
await event.edit("`error 404`")
return
await getmusicvideo(query)
l = glob.glob(("*.mp4")) + glob.glob(("*.mkv")) + glob.glob(("*.webm"))
if l:
await event.edit("`search finished, uploading...`")
else:
await event.edit(f"`Sorry..! i can't find anything with` **{query}**")
return
try:
loa = l[0]
metadata = extractMetadata(createParser(loa))
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")
os.system("cp *mp4 thumb.mp4")
os.system("ffmpeg -i thumb.mp4 -vframes 1 -an -s 480x360 -ss 5 thumb.jpg")
thumb_image = "thumb.jpg"
c_time = time.time()
await event.client.send_file(
event.chat_id,
loa,
force_document=False,
thumb=thumb_image,
allow_cache=False,
caption=query,
supports_streaming=True,
reply_to=reply_to_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, "[UPLOAD]", loa)
),
)
await event.edit(f"**{query}** `Uploaded Successfully..!`")
os.remove(thumb_image)
os.system("rm -rf *.mkv")
os.system("rm -rf *.mp4")
os.system("rm -rf *.webm")
except BaseException:
os.remove(thumb_image)
os.system("rm -rf *.mkv")
os.system("rm -rf *.mp4")
os.system("rm -rf *.webm")
return
async def _(e):
cr = e.pattern_match.group(1)
crf = 27
to_stream = False
if cr:
k = e.text.split()
if len(k) == 2:
crf = int(k[1]) if k[1].isdigit() else 27
elif len(k) > 2:
crf = int(k[1]) if k[1].isdigit() else 27
to_stream = True if "stream" in k[2] else False
vido = await e.get_reply_message()
if vido and vido.media:
if "video" in mediainfo(vido.media):
if hasattr(vido.media, "document"):
vfile = vido.media.document
name = vido.file.name
else:
vfile = vido.media
name = ""
if not name:
name = "video_" + dt.now().isoformat("_", "seconds") + ".mp4"
xxx = await eor(e, "`Trying To Download...`")
c_time = time.time()
file = await downloader(
"resources/downloads/" + name,
vfile,
xxx,
c_time,
"Downloading " + name + "...",
)
o_size = os.path.getsize(file.name)
d_time = time.time()
diff = time_formatter((d_time - c_time) * 1000)
file_name = (file.name).split("/")[-1]
out = file_name.replace(file_name.split(".")[-1], "compressed.mkv")
await xxx.edit(
f"`Downloaded {file.name} of {humanbytes(o_size)} in {diff}.\nNow Compressing...`"
)
x, y = await bash(
f'mediainfo --fullscan """{file.name}""" | grep "Frame count"')
total_frames = x.split(":")[1].split("\n")[0]
progress = "progress.txt"
with open(progress, "w") as fk:
pass
proce = await asyncio.create_subprocess_shell(
f'ffmpeg -hide_banner -loglevel quiet -progress {progress} -i """{file.name}""" -preset ultrafast -vcodec libx265 -crf {crf} """{out}""" -y',
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
while proce.returncode != 0:
await asyncio.sleep(3)
with open(progress, "r+") as fil:
text = fil.read()
frames = re.findall("frame=(\\d+)", text)
size = re.findall("total_size=(\\d+)", text)
if len(frames):
elapse = int(frames[-1])
if len(size):
size = int(size[-1])
per = elapse * 100 / int(total_frames)
time_diff = time.time() - int(d_time)
speed = round(elapse / time_diff, 2)
some_eta = (
(int(total_frames) - elapse) / speed) * 1000
text = f"`Compressing {file_name} at {crf} CRF.\n`"
progress_str = "`[{0}{1}] {2}%\n\n`".format(
"".join(["●" for i in range(math.floor(per / 5))]),
"".join(
["" for i in range(20 - math.floor(per / 5))]),
round(per, 2),
)
e_size = (humanbytes(size) + " of ~" + humanbytes(
(size / per) * 100))
eta = "~" + time_formatter(some_eta)
try:
await xxx.edit(text + progress_str + "`" + e_size +
"`" + "\n\n`" + eta + "`")
except MessageNotModifiedError:
pass
os.remove(file.name)
c_size = os.path.getsize(out)
f_time = time.time()
difff = time_formatter((f_time - d_time) * 1000)
await xxx.edit(
f"`Compressed {humanbytes(o_size)} to {humanbytes(c_size)} in {difff}\nTrying to Upload...`"
)
differ = 100 - ((c_size / o_size) * 100)
caption = f"**Original Size: **`{humanbytes(o_size)}`\n"
caption += f"**Compressed Size: **`{humanbytes(c_size)}`\n"
caption += f"**Compression Ratio: **`{differ:.2f}%`\n"
caption += f"\n**Time Taken To Compress: **`{difff}`"
mmmm = await uploader(
out,
out,
f_time,
xxx,
"Uploading " + out + "...",
)
if to_stream:
metadata = extractMetadata(createParser(out))
duration = metadata.get("duration").seconds
hi, _ = await bash(f'mediainfo "{out}" | grep "Height"')
wi, _ = await bash(f'mediainfo "{out}" | grep "Width"')
height = int(hi.split(":")[1].split()[0])
width = int(wi.split(":")[1].split()[0])
attributes = [
DocumentAttributeVideo(duration=duration,
w=width,
h=height,
supports_streaming=True)
]
await e.client.send_file(
e.chat_id,
mmmm,
thumb="resources/extras/ultroid.jpg",
caption=caption,
attributes=attributes,
force_document=False,
reply_to=e.reply_to_msg_id,
)
else:
await e.client.send_file(
e.chat_id,
mmmm,
thumb="resources/extras/ultroid.jpg",
caption=caption,
force_document=True,
reply_to=e.reply_to_msg_id,
)
await xxx.delete()
os.remove(out)
else:
await eod(e, "`Reply To Video File Only`")
else:
await eod(e, "`Reply To Video File Only`")
async def _(event):
if event.fwd_from:
return
if not event.is_reply:
await event.reply("🙄Reply to a zip file.")
return
if event.is_group:
if not (await is_register_admin(event.input_chat,
event.message.sender_id)):
await event.reply(
"😜 Hai.. You are not admin..🤭 You can't use this command.. But you can use in my pm🙈"
)
return
mone = await event.reply("Processing ...")
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_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 client.download_media(
reply_message, TEMP_DOWNLOAD_DIRECTORY)
except Exception as e:
await mone.reply(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
with zipfile.ZipFile(downloaded_file_name, "r") as zip_ref:
zip_ref.extractall(extracted)
filename = sorted(get_lst_of_files(extracted, []))
await event.reply("Unzipping now")
for single_file in filename:
if os.path.exists(single_file):
caption_rts = os.path.basename(single_file)
force_document = True
supports_streaming = False
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 client.send_file(
event.chat_id,
single_file,
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
reply_to=event.message.id,
attributes=document_attributes)
except Exception as e:
await client.send_message(
event.chat_id,
"{} caused `{}`".format(caption_rts, str(e)),
reply_to=event.message.id,
)
continue
os.remove(single_file)
os.remove(downloaded_file_name)
async def _(event):
reply_to_id = event.message.id
if event.reply_to_msg_id:
reply_to_id = event.reply_to_msg_id
reply = await event.get_reply_message()
if event.pattern_match.group(1):
query = event.pattern_match.group(1)
await event.edit("`Wait..! I am finding your videosong..`")
elif reply.message:
query = reply.message
await event.edit("`Wait..! I am finding your videosong..`")
else:
await event.edit("`What I am Supposed to find?`")
return
getmusicvideo(query)
l = glob.glob(("*.mp4")) + glob.glob(("*.mkv")) + glob.glob(("*.webm"))
if l:
await event.edit("`Yeah..! i found something..`")
else:
await event.edit(f"Sorry..! i can't find anything with `{query}`")
loa = l[0]
metadata = extractMetadata(createParser(loa))
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 event.edit("`Uploading video.. Please wait..`")
os.system("cp *mp4 thumb.mp4")
os.system("ffmpeg -i thumb.mp4 -vframes 1 -an -s 480x360 -ss 5 thumb.jpg")
thumb_image = "thumb.jpg"
c_time = time.time()
await event.client.send_file(
event.chat_id,
loa,
force_document=False,
thumb=thumb_image,
allow_cache=False,
caption=query,
supports_streaming=True,
reply_to=reply_to_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, "[UPLOAD]", loa)),
)
await event.delete()
os.remove(thumb_image)
os.system("rm -rf *.mkv")
os.system("rm -rf *.mp4")
os.system("rm -rf *.webm")
async def download_video(v_url):
"""For .rip command, download media from YouTube and many other sites."""
dl_type = v_url.pattern_match.group(1).lower()
reso = v_url.pattern_match.group(2)
reso = reso.strip() if reso else None
url = v_url.pattern_match.group(3)
await v_url.edit("`Preparing to download...`")
s_time = time.time()
video = False
audio = False
if "audio" in dl_type:
opts = {
"format":
"bestaudio",
"addmetadata":
True,
"key":
"FFmpegMetadata",
"writethumbnail":
True,
"prefer_ffmpeg":
True,
"geo_bypass":
True,
"nocheckcertificate":
True,
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "mp3",
"preferredquality": "320",
}],
"outtmpl":
os.path.join(TEMP_DOWNLOAD_DIRECTORY, str(s_time),
"%(title)s.%(ext)s"),
"quiet":
True,
"logtostderr":
False,
}
audio = True
elif "video" in dl_type:
quality = (f"bestvideo[height<={reso}]+bestaudio/best[height<={reso}]"
if reso else "bestvideo+bestaudio/best")
opts = {
"format":
quality,
"addmetadata":
True,
"key":
"FFmpegMetadata",
"prefer_ffmpeg":
True,
"geo_bypass":
True,
"nocheckcertificate":
True,
"outtmpl":
os.path.join(TEMP_DOWNLOAD_DIRECTORY, str(s_time),
"%(title)s.%(ext)s"),
"logtostderr":
False,
"quiet":
True,
}
video = True
try:
await v_url.edit("`Fetching data, please wait..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
return await v_url.edit(f"`{str(DE)}`")
except ContentTooShortError:
return await v_url.edit("`The download content was too short.`")
except GeoRestrictedError:
return await v_url.edit(
"`Video is not available from your geographic location "
"due to geographic restrictions imposed by a website.`")
except MaxDownloadsReached:
return await v_url.edit("`Max-downloads limit has been reached.`")
except PostProcessingError:
return await v_url.edit("`There was an error during post processing.`")
except UnavailableVideoError:
return await v_url.edit(
"`Media is not available in the requested format.`")
except XAttrMetadataError as XAME:
return await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
except ExtractorError:
return await v_url.edit("`There was an error during info extraction.`")
except Exception as e:
return await v_url.edit(f"{str(type(e)): {str(e)}}")
c_time = time.time()
if audio:
await v_url.edit(
f"`Preparing to upload song:`\n**{rip_data.get('title')}**"
f"\nby **{rip_data.get('uploader')}**")
f_name = glob(
os.path.join(TEMP_DOWNLOAD_DIRECTORY, str(s_time), "*.mp3"))[0]
with open(f_name, "rb") as f:
result = await upload_file(
client=v_url.client,
file=f,
name=f_name,
progress_callback=lambda d, t: get_event_loop().create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{rip_data['title']}.mp3")),
)
thumb_image = [
x for x in glob(
os.path.join(TEMP_DOWNLOAD_DIRECTORY, str(s_time), "*"))
if not x.endswith(".mp3")
][0]
metadata = extractMetadata(createParser(f_name))
duration = 0
if metadata and metadata.has("duration"):
duration = metadata.get("duration").seconds
await v_url.client.send_file(
v_url.chat_id,
result,
supports_streaming=True,
attributes=[
DocumentAttributeAudio(
duration=duration,
title=rip_data.get("title"),
performer=rip_data.get("uploader"),
)
],
thumb=thumb_image,
)
await v_url.delete()
elif video:
await v_url.edit(
f"`Preparing to upload video:`\n**{rip_data.get('title')}**"
f"\nby **{rip_data.get('uploader')}**")
f_path = glob(os.path.join(TEMP_DOWNLOAD_DIRECTORY, str(s_time),
"*"))[0]
# Noob way to convert from .mkv to .mp4
if f_path.endswith(".mkv"):
base = os.path.splitext(f_path)[0]
os.rename(f_path, base + ".mp4")
f_path = glob(
os.path.join(TEMP_DOWNLOAD_DIRECTORY, str(s_time), "*"))[0]
f_name = os.path.basename(f_path)
with open(f_path, "rb") as f:
result = await upload_file(
client=v_url.client,
file=f,
name=f_name,
progress_callback=lambda d, t: get_event_loop().create_task(
progress(d, t, v_url, c_time, "Uploading..", f_name)),
)
thumb_image = await get_video_thumb(f_path, "thumb.png")
metadata = extractMetadata(createParser(f_path))
duration = 0
width = 0
height = 0
if metadata:
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 v_url.client.send_file(
v_url.chat_id,
result,
thumb=thumb_image,
attributes=[
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
supports_streaming=True,
)
],
caption=f"[{rip_data.get('title')}]({url})",
)
os.remove(thumb_image)
await v_url.delete()
async def uploadir(udir_event):
""" .uploadir komutu bir klasördeki tüm dosyaları uploadlamanıza yarar """
input_str = udir_event.pattern_match.group(1)
if os.path.exists(input_str):
await udir_event.edit(LANG['TRYING'])
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.edit(LANG['FOUND_FILES'].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, LANG[
'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, LANG[
'UPLOADING'], single_file)))
os.remove(single_file)
uploaded = uploaded + 1
await udir_event.edit(
LANG['SUCCESSFULLY_MULTI_UPLOADED'].format(uploaded))
else:
await udir_event.edit("404: Directory Not Found")
async def uploadas(uas_event):
""" For .uploadas command, allows you to specify some arguments for upload. """
if not uas_event.text[0].isalpha() and uas_event.text[0] not in ("/", "#",
"@", "!"):
if uas_event.fwd_from:
return
await uas_event.edit("Processing ...")
type_of_upload = uas_event.pattern_match.group(1)
supports_streaming = False
round_message = False
spam_big_messages = False
if type_of_upload == "stream":
supports_streaming = True
if type_of_upload == "vn":
round_message = True
if type_of_upload == "all":
spam_big_messages = True
input_str = uas_event.pattern_match.group(2)
thumb = None
file_name = None
if "|" in input_str:
file_name, thumb = input_str.split("|")
file_name = file_name.strip()
thumb = thumb.strip()
else:
file_name = input_str
thumb_path = "a_random_f_file_name" + ".jpg"
thumb = get_video_thumb(file_name, output=thumb_path)
if os.path.exists(file_name):
start = datetime.now()
metadata = extractMetadata(createParser(file_name))
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")
try:
if supports_streaming:
await uas_event.client.send_file(
uas_event.chat_id,
file_name,
thumb=thumb,
caption=input_str,
force_document=False,
allow_cache=False,
reply_to=uas_event.message.id,
attributes=[
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True,
)
],
progress_callback=progress,
)
elif round_message:
await uas_event.client.send_file(
uas_event.chat_id,
file_name,
thumb=thumb,
allow_cache=False,
reply_to=uas_event.message.id,
video_note=True,
attributes=[
DocumentAttributeVideo(
duration=0,
w=1,
h=1,
round_message=True,
supports_streaming=True,
)
],
progress_callback=progress,
)
elif spam_big_messages:
await uas_event.edit("TBD: Not (yet) Implemented")
return
end = datetime.now()
duration = (end - start).seconds
os.remove(thumb)
await uas_event.edit("Uploaded in {} seconds.".format(duration)
)
except FileNotFoundError as err:
await uas_event.edit(str(err))
else:
await uas_event.edit("404: File Not Found")
async def zip(event):
if event.fwd_from:
return
mone = await event.edit(LANG['DOWNLOADING'])
extracted = TEMP_DOWNLOAD_DIRECTORY + "extracted/"
thumb_image_path = TEMP_DOWNLOAD_DIRECTORY + "/thumb_image.jpg"
if not os.path.isdir(extracted):
os.makedirs(extracted)
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
start = time.time()
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await event.client.download_media(
reply_message,
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, mone, c_time, LANG['DOWNLOADING'])))
except Exception as e: # pylint:disable=C0103,W0703
await mone.edit(str(e))
else:
end = time.time()
ms = end - start
await mone.edit(LANG['DOWNLOADED'].format(downloaded_file_name,
ms))
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(LANG['UNZIPPING'])
# 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)
]
await event.client.send_file(
event.chat_id,
single_file,
caption=f"`{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, LANG['UPLOADING'])))
os.remove(single_file)
os.remove(downloaded_file_name)
else:
await event.edit(LANG['REPLY_TO_ZIP'])
async def upload(path, event, udir_event):
global uploaded
if os.path.isdir(path):
await event.client.send_message(
event.chat_id,
f"**Folder : **`{str(path)}`",
)
Files = os.listdir(path)
Files = sortthings(Files, path)
for file in Files:
catpath = os.path.join(path, file)
await upload(catpath, event, udir_event)
elif os.path.isfile(path):
caption_rts = os.path.basename(path)
c_time = time.time()
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
if not caption_rts.lower().endswith(".mp4"):
await event.client.send_file(
event.chat_id,
path,
caption=f"**File Name : **`{caption_rts}`",
force_document=False,
thumb=thumb,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(
progress(d, t, udir_event, c_time, "Uploading...",
caption_rts)),
)
else:
metadata = extractMetadata(createParser(str(path)))
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 event.client.send_file(
event.chat_id,
path,
caption=f"**File Name : **`{caption_rts}`",
thumb=thumb,
force_document=False,
supports_streaming=True,
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...",
caption_rts)),
)
uploaded += 1
async def uploadas(uas_event):
""" .uploadas komutu size upload yaparken bazı argümanlar belirtmenizi sağlar. """
await uas_event.edit("Lütfen bekleyin...")
type_of_upload = uas_event.pattern_match.group(1)
supports_streaming = False
round_message = False
spam_big_messages = False
if type_of_upload == "stream":
supports_streaming = True
if type_of_upload == "vn":
round_message = True
if type_of_upload == "all":
spam_big_messages = True
input_str = uas_event.pattern_match.group(2)
thumb = None
file_name = None
if "|" in input_str:
file_name, thumb = input_str.split("|")
file_name = file_name.strip()
thumb = thumb.strip()
else:
file_name = input_str
thumb_path = "a_random_f_file_name" + ".jpg"
thumb = get_video_thumb(file_name, output=thumb_path)
if os.path.exists(file_name):
metadata = extractMetadata(createParser(file_name))
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")
try:
if supports_streaming:
c_time = time.time()
await uas_event.client.send_file(
uas_event.chat_id,
file_name,
thumb=thumb,
caption=input_str,
force_document=False,
allow_cache=False,
reply_to=uas_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, uas_event, c_time, "Uploadlanıyor...",
file_name)))
elif round_message:
c_time = time.time()
await uas_event.client.send_file(
uas_event.chat_id,
file_name,
thumb=thumb,
allow_cache=False,
reply_to=uas_event.message.id,
video_note=True,
attributes=[
DocumentAttributeVideo(
duration=0,
w=1,
h=1,
round_message=True,
supports_streaming=True,
)
],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, uas_event, c_time, "Uploadlanıyor...",
file_name)))
elif spam_big_messages:
await uas_event.edit("TBD: Halihazırda uygulanamadı.")
return
os.remove(thumb)
await uas_event.edit("Upload başarılı !!")
except FileNotFoundError as err:
await uas_event.edit(str(err))
else:
await uas_event.edit("404: Dosya bulunamadı.")
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
if os.path.exists(input_str):
start = datetime.now()
# await event.edit("Processing ...")
lst_of_files = sorted(get_lst_of_files(input_str, []))
logger.info(lst_of_files)
u = 0
await event.edit(
"Found {} files. ".format(len(lst_of_files)) + \
"Uploading will start soon. " + \
"Please wait!"
)
thumb = None
if os.path.exists(thumb_image_path):
thumb = thumb_image_path
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)
force_document = True
supports_streaming = False
document_attributes = []
width = 0
height = 0
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")
if single_file.upper().endswith(Config.TL_VID_STREAM_TYPES):
metadata = extractMetadata(createParser(single_file))
duration = 0
if metadata.has("duration"):
duration = metadata.get('duration').seconds
document_attributes = [
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True
)
]
supports_streaming = True
force_document = False
if single_file.upper().endswith(Config.TL_MUS_STREAM_TYPES):
metadata = extractMetadata(createParser(single_file))
duration = 0
title = ""
artist = ""
if metadata.has("duration"):
duration = metadata.get('duration').seconds
if metadata.has("title"):
title = metadata.get("title")
if metadata.has("artist"):
artist = metadata.get("artist")
document_attributes = [
DocumentAttributeAudio(
duration=duration,
voice=False,
title=title,
performer=artist,
waveform=None
)
]
supports_streaming = True
force_document = False
try:
await borg.send_file(
event.chat_id,
single_file,
caption=caption_rts,
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
reply_to=event.message.id,
thumb=thumb,
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)
u = u + 1
# await event.edit("Uploaded {} / {} files.".format(u, len(lst_of_files)))
# @ControllerBot was having issues,
# if both edited_updates and update events come simultaneously.
await asyncio.sleep(5)
end = datetime.now()
ms = (end - start).seconds
await event.edit("Uploaded {} files in {} seconds.".format(u, ms))
else:
await event.edit("404: Directory Not Found")
async def download_video(v_url):
""" For .ytdl command, download media from YouTube and many other sites. """
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`Preparing to download...`")
out_folder = Config.TMP_DOWNLOAD_DIRECTORY + "youtubedl/"
thumb_image_path = Config.TMP_DOWNLOAD_DIRECTORY + "/thumb_image.jpg"
if not os.path.isdir(out_folder):
os.makedirs(out_folder)
if type == "a":
opts = {
'format':
'bestaudio',
'addmetadata':
True,
'noplaylist':
False,
'key':
'FFmpegMetadata',
'writethumbnail':
True,
'embedthumbnail':
True,
'prefer_ffmpeg':
True,
'geo_bypass':
True,
'nocheckcertificate':
True,
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': '320',
}],
'outtmpl':
out_folder + '%(title)s.%(ext)s',
'quiet':
True,
'logtostderr':
False
}
video = False
song = True
elif type == "v":
opts = {
'format':
'best',
'addmetadata':
True,
'noplaylist':
False,
'getthumbnail':
True,
'embedthumbnail':
True,
'xattrs':
True,
'writethumbnail':
True,
'key':
'FFmpegMetadata',
'prefer_ffmpeg':
True,
'geo_bypass':
True,
'nocheckcertificate':
True,
'postprocessors': [
{
'key': 'FFmpegVideoConvertor',
'preferedformat': 'mp4'
},
],
'outtmpl':
out_folder + '%(title)s.%(ext)s',
'logtostderr':
False,
'quiet':
True
}
song = False
video = True
try:
await v_url.edit("`Fetching playlist data, please wait..`")
with YoutubeDL(opts) as ytdl:
ytdl_data = ytdl.extract_info(url)
# print(ytdl_data['thumbnail'])
filename = sorted(get_lst_of_files(out_folder, []))
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`The download content was too short.`")
return
except GeoRestrictedError:
await v_url.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
return
except MaxDownloadsReached:
await v_url.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await v_url.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await v_url.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`There was an error during info extraction.`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
await v_url.edit(
"`YouTube Playlist Downloading Processing Now.\nPlease Wait!`")
if song:
for single_file in filename:
if os.path.exists(single_file):
caption_rts = os.path.basename(single_file)
force_document = True
supports_streaming = False
document_attributes = []
if single_file.endswith((".mp4", ".mp3", ".flac", ".webm")):
metadata = extractMetadata(createParser(single_file))
duration = 0
width = 0
height = 180
if metadata.has("duration"):
duration = metadata.get('duration').seconds
document_attributes = [
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True,
)
]
try:
ytdl_data_name_audio = os.path.basename(single_file)
thumb = out_folder + ytdl_data_name_audio[:(
len(ytdl_data_name_audio) - 4)] + ".jpg"
print(ytdl_data_name_audio)
file_path = single_file
song_size = file_size(file_path)
await v_url.client.send_file(
v_url.chat_id,
single_file,
caption=f"`{ytdl_data_name_audio}`" + "\n" +
f"{song_size}",
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
thumb=thumb,
reply_to=v_url.message.id,
attributes=document_attributes,
progress_callback=lambda d, t: asyncio.
get_event_loop().create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{ytdl_data_name_audio}")))
# os.remove(thumb)
except Exception as e:
await v_url.client.send_message(
v_url.chat_id,
"{} caused `{}`".format(caption_rts, str(e)),
)
continue
os.remove(single_file)
await asyncio.sleep(DELETE_TIMEOUT)
# await v_url.delete()
shutil.rmtree(out_folder)
if video:
for single_file in filename:
if os.path.exists(single_file):
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
document_attributes = [
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True,
)
]
# print(ytdl_data)
# for file in os.listdir("./DOWNLOADS/youtubedl/"):
# if file.endswith(".jpg"):
# thumb = "./DOWNLOADS/youtubedl/" + file
# print(os.path.join("./DOWNLOADS/youtubedl/", file))
# image_link = ytdl_data['thumbnail']
# downloaded_image = wget.download(image_link,out_folder)
# thumb = ytdl_data_name_video + ".jpg"
file_path = single_file
video_size = file_size(file_path)
try:
ytdl_data_name_video = os.path.basename(single_file)
thumb = out_folder + ytdl_data_name_video[:(
len(ytdl_data_name_video) - 4)] + ".jpg"
await v_url.client.send_file(
v_url.chat_id,
single_file,
caption=f"`{ytdl_data_name_video}`" + "\n" +
f"{video_size}",
force_document=force_document,
supports_streaming=supports_streaming,
thumb=thumb,
allow_cache=False,
reply_to=v_url.message.id,
attributes=document_attributes,
progress_callback=lambda d, t: asyncio.
get_event_loop().create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{ytdl_data_name_video}")))
# os.remove(thumb)
except Exception as e:
await v_url.client.send_message(
v_url.chat_id,
"{} caused `{}`".format(caption_rts, str(e)),
)
continue
os.remove(single_file)
await asyncio.sleep(DELETE_TIMEOUT)
# await v_url.delete()
shutil.rmtree(out_folder)
async def upload(event):
if event.fwd_from:
return
await event.edit("`Processing...`")
input_str = event.pattern_match.group(1)
if os.path.exists(input_str):
if os.path.isfile(input_str):
c_time = time.time()
start_time = datetime.now()
file_name = os.path.basename(input_str)
thumb = None
attributes = []
with open(input_str, "rb") as f:
result = await upload_file(
client=event.client,
file=f,
name=file_name,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(
progress(d, t, event, c_time, "[FILE - UPLOAD]",
input_str)),
)
up_time = (datetime.now() - start_time).seconds
if input_str.lower().endswith(("mp4", "mkv", "webm")):
thumb = await get_video_thumb(input_str, "thumb_image.jpg")
metadata = extractMetadata(createParser(input_str))
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")
attributes = [
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True,
)
]
elif input_str.lower().endswith(("mp3", "flac", "wav")):
metadata = extractMetadata(createParser(input_str))
duration = 0
artist = ""
title = ""
if metadata.has("duration"):
duration = metadata.get("duration").seconds
if metadata.has("title"):
title = metadata.get("title")
if metadata.has("artist"):
artist = metadata.get("artist")
attributes = [
DocumentAttributeAudio(
duration=duration,
title=title,
performer=artist,
)
]
await event.client.send_file(
event.chat_id,
result,
thumb=thumb,
caption=file_name,
force_document=False,
allow_cache=False,
reply_to=event.message.id,
attributes=attributes,
)
if thumb is not None:
os.remove(thumb)
await event.edit(f"Uploaded successfully in `{up_time}` seconds.")
elif os.path.isdir(input_str):
start_time = datetime.now()
lst_files = []
for root, dirs, files in os.walk(input_str):
for file in files:
lst_files.append(os.path.join(root, file))
if len(lst_files) == 0:
return await event.edit(f"`{input_str}` is empty.")
await event.edit(
f"Found `{len(lst_files)}` files. Now uploading...")
for files in os_sorted(lst_files):
file_name = os.path.basename(files)
thumb = None
attributes = []
msg = await event.reply(f"Uploading `{files}`")
with open(files, "rb") as f:
result = await upload_file(
client=event.client,
file=f,
name=file_name,
)
if file_name.lower().endswith(("mp4", "mkv", "webm")):
thumb = await get_video_thumb(files, "thumb_image.jpg")
metadata = extractMetadata(createParser(files))
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")
attributes = [
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True,
)
]
elif file_name.lower().endswith(("mp3", "flac", "wav")):
metadata = extractMetadata(createParser(files))
duration = 0
title = ""
artist = ""
if metadata.has("duration"):
duration = metadata.get("duration").seconds
if metadata.has("title"):
title = metadata.get("title")
if metadata.has("artist"):
artist = metadata.get("artist")
attributes = [
DocumentAttributeAudio(
duration=duration,
title=title,
performer=artist,
)
]
await event.client.send_file(
event.chat_id,
result,
thumb=thumb,
caption=file_name,
force_document=False,
allow_cache=False,
attributes=attributes,
)
await msg.delete()
if thumb is not None:
os.remove(thumb)
await event.delete()
up_time = (datetime.now() - start_time).seconds
await event.respond(
f"Uploaded `{len(lst_files)}` files in `{input_str}` folder "
f"in `{up_time}` seconds.")
else:
await event.edit("`404: File/Folder Not Found`")
async def _(e):
if not e.text[0].isalpha() and e.text[0] not in ("/", "#", "@", "!"):
if e.fwd_from:
return
input_str = e.pattern_match.group(1)
if os.path.exists(input_str):
start = datetime.now()
await e.edit("Processing ...")
lst_of_files = lst_of_files(input_str, [])
LOGS.info(lst_of_files)
u = 0
await e.edit(
"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)
if not caption_rts.lower().endswith(".mp4"):
await e.client.send_file(
e.chat_id,
single_file,
caption=caption_rts,
force_document=False,
allow_cache=False,
reply_to=e.message.id,
progress_callback=progress,
)
else:
thumb_image = os.path.join(input_str, "thumb.jpg")
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 e.client.send_file(
e.chat_id,
single_file,
caption=caption_rts,
thumb=thumb_image,
force_document=False,
allow_cache=False,
reply_to=e.message.id,
attributes=[
DocumentAttributeVideo(
duration=duration,
w=width,
h=height,
round_message=False,
supports_streaming=True,
)
],
progress_callback=progress,
)
os.remove(single_file)
u = u + 1
end = datetime.now()
ms = (end - start).seconds
await e.edit("Uploaded {} files in {} seconds.".format(u, ms))
else:
await e.edit("404: Directory 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)
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 zip to `{}` in {} seconds.".format(
downloaded_file_name, ms))
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("Unzipping 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 = True
supports_streaming = False
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"UnZipped `{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)
async def _(event):
if event.fwd_from:
return
mone = await edit_or_reply(event, "Processing ...")
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:
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, []))
await mone.edit("Unraring now")
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 = True
supports_streaming = False
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 event.client.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 event.client.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 mone.edit("DONE!!!")
await asyncio.sleep(5)
await mone.delete()
async def uploadas(uas_event):
""" For .uploadas command, allows you to specify some arguments for upload. """
await uas_event.edit("Processing ...")
type_of_upload = uas_event.pattern_match.group(1)
supports_streaming = False
round_message = False
spam_big_messages = False
if type_of_upload == "stream":
supports_streaming = True
if type_of_upload == "vn":
round_message = True
if type_of_upload == "all":
spam_big_messages = True
input_str = uas_event.pattern_match.group(2)
thumb = None
file_name = None
if "|" in input_str:
file_name, thumb = input_str.split("|")
file_name = file_name.strip()
thumb = thumb.strip()
else:
file_name = input_str
thumb_path = "a_random_f_file_name" + ".jpg"
thumb = get_video_thumb(file_name, output=thumb_path)
if os.path.exists(file_name):
metadata = extractMetadata(createParser(file_name))
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")
try:
if supports_streaming:
c_time = time.time()
await uas_event.client.send_file(
uas_event.chat_id,
file_name,
thumb=thumb,
caption=input_str,
force_document=False,
allow_cache=False,
reply_to=uas_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, uas_event, c_time, "Uploading...",
file_name)))
elif round_message:
c_time = time.time()
await uas_event.client.send_file(
uas_event.chat_id,
file_name,
thumb=thumb,
allow_cache=False,
reply_to=uas_event.message.id,
video_note=True,
attributes=[
DocumentAttributeVideo(
duration=0,
w=1,
h=1,
round_message=True,
supports_streaming=True,
)
],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, uas_event, c_time, "Uploading...",
file_name)))
elif spam_big_messages:
await uas_event.edit("TBD: Not (yet) Implemented")
return
os.remove(thumb)
await uas_event.edit("Uploaded successfully !!")
except FileNotFoundError as err:
await uas_event.edit(str(err))
else:
await uas_event.edit("404: File Not Found")
async def download(event):
xx = await eor(event, get_string("com_1"))
hmm = event.pattern_match.group(1)
try:
kk = hmm.split(" | ")[0]
except BaseException:
pass
try:
title = kk.split("/")[-1]
except BaseException:
title = hmm
s = dt.now()
tt = time.time()
if not kk:
return await eod(xx, get_string("udl_3"))
elif os.path.isdir(kk):
if not os.listdir(kk):
return await eod(xx, "`This Directory is Empty.`")
ok = glob.glob(f"{kk}/*")
kk = [*sorted(ok)]
for kk in kk:
try:
try:
res = await uploader(kk, kk, tt, xx, "Uploading...")
except MessageNotModifiedError as err:
return await xx.edit(str(err))
title = kk.split("/")[-1]
if title.endswith((".mp3", ".m4a", ".opus", ".ogg")):
hmm = " | stream"
if " | stream" in hmm:
metadata = extractMetadata(createParser(res.name))
if not metadata:
return await event.reply(file=res,
supports_streaming=True)
wi = 512
hi = 512
duration = 0
if metadata.has("width"):
wi = metadata.get("width")
if metadata.has("height"):
hi = metadata.get("height")
if metadata.has("duration"):
duration = metadata.get("duration").seconds
if metadata.has("artist"):
artist = metadata.get("artist")
else:
if udB.get("artist"):
artist = udB.get("artist")
else:
artist = ultroid_bot.first_name
if res.name.endswith(tuple([".mkv", ".mp4", ".avi"])):
attributes = [
DocumentAttributeVideo(w=wi,
h=hi,
duration=duration,
supports_streaming=True)
]
elif res.name.endswith(
tuple([".mp3", ".m4a", ".opus", ".ogg"])):
attributes = [
DocumentAttributeAudio(
duration=duration,
title=title.split(".")[0],
performer=artist,
)
]
else:
attributes = None
try:
x = await event.client.send_file(
event.chat_id,
res,
caption=f"`{title}`",
attributes=attributes,
supports_streaming=True,
thumb="resources/extras/ultroid.jpg",
)
except BaseException:
x = await event.client.send_file(
event.chat_id,
res,
caption=f"`{title}`",
thumb="resources/extras/ultroid.jpg",
)
else:
x = await event.client.send_file(
event.chat_id,
res,
caption=f"`{title}`",
force_document=True,
thumb="resources/extras/ultroid.jpg",
)
except Exception as ve:
return await eor(xx, str(ve))
else:
try:
try:
res = await uploader(kk, kk, tt, xx, "Uploading...")
except MessageNotModifiedError as err:
return await xx.edit(str(err))
if title.endswith((".mp3", ".m4a", ".opus", ".ogg")):
hmm = " | stream"
if " | stream" in hmm:
metadata = extractMetadata(createParser(res.name))
wi = 512
hi = 512
duration = 0
if metadata.has("width"):
wi = metadata.get("width")
if metadata.has("height"):
hi = metadata.get("height")
if metadata.has("duration"):
duration = metadata.get("duration").seconds
if metadata.has("artist"):
artist = metadata.get("artist")
else:
if udB.get("artist"):
artist = udB.get("artist")
else:
artist = ultroid_bot.first_name
if res.name.endswith(tuple([".mkv", ".mp4", ".avi"])):
attributes = [
DocumentAttributeVideo(w=wi,
h=hi,
duration=duration,
supports_streaming=True)
]
elif res.name.endswith(tuple([".mp3", ".m4a", ".opus",
".ogg"])):
attributes = [
DocumentAttributeAudio(
duration=duration,
title=title.split(".")[0],
performer=artist,
)
]
else:
attributes = None
try:
x = await event.client.send_file(
event.chat_id,
res,
caption=f"`{title}`",
attributes=attributes,
supports_streaming=True,
thumb="resources/extras/ultroid.jpg",
)
except BaseException:
x = await event.client.send_file(
event.chat_id,
res,
caption=f"`{title}`",
force_document=True,
thumb="resources/extras/ultroid.jpg",
)
else:
x = await event.client.send_file(
event.chat_id,
res,
caption=f"`{title}`",
force_document=True,
thumb="resources/extras/ultroid.jpg",
)
except Exception as ve:
return await eor(xx, str(ve))
e = dt.now()
t = time_formatter(((e - s).seconds) * 1000)
if t != "":
if os.path.isdir(kk):
size = 0
for path, dirs, files in os.walk(kk):
for f in files:
fp = os.path.join(path, f)
size += os.path.getsize(fp)
c = len(os.listdir(kk))
await xx.delete()
await ultroid_bot.send_message(
event.chat_id,
f"Uploaded Total - `{c}` files of `{humanbytes(size)}` in `{t}`",
)
else:
await eor(xx, f"Uploaded `{kk}` in `{t}`")
else:
await eor(xx, f"Uploaded `{kk}` in `0 second(s)`")
