async def gdrive_upload_function(dryb):
""" For .gdrive command, upload files to google drive. """
await dryb.edit("Processing ...")
input_str = dryb.pattern_match.group(1)
if CLIENT_ID is None or CLIENT_SECRET is None:
return
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
required_file_name = None
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
# https://stackoverflow.com/a/761825/4723940
file_name = file_name.strip()
head, tail = os.path.split(file_name)
if head:
if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)):
os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head))
file_name = os.path.join(head, tail)
downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
display_message = None
while not downloader.isFinished():
status = downloader.get_status().capitalize()
total_length = downloader.filesize if downloader.filesize else None
downloaded = downloader.get_dl_size()
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
speed = downloader.get_speed()
elapsed_time = round(diff) * 1000
progress_str = "[{0}{1}] {2}%".format(
''.join(["▰" for i in range(math.floor(percentage / 10))]),
''.join(["▱"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"{status}...\
\nURL: {url}\
\nFile Name: {file_name}\
\n{progress_str}\
\n{humanbytes(downloaded)} of {humanbytes(total_length)}\
\nETA: {estimated_total_time}"
if round(diff %
10.00) == 0 and current_message != display_message:
await dryb.edit(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
pass
if downloader.isSuccessful():
await dryb.edit(
"Downloaded to `{}` successfully !!\nInitiating Upload to Google Drive.."
.format(downloaded_file_name))
required_file_name = downloaded_file_name
else:
await dryb.edit("Incorrect URL\n{}".format(url))
elif input_str:
input_str = input_str.strip()
if os.path.exists(input_str):
required_file_name = input_str
await dryb.edit(
"Found `{}` in local server, Initiating Upload to Google Drive.."
.format(input_str))
else:
await dryb.edit(
"File not found in local server. Give me a valid file path !")
return False
elif dryb.reply_to_msg_id:
try:
c_time = time.time()
downloaded_file_name = await dryb.client.download_media(
await dryb.get_reply_message(),
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(progress(d, t, dryb, c_time, "Downloading...")))
except Exception as e:
await dryb.edit(str(e))
else:
required_file_name = downloaded_file_name
await dryb.edit(
"Downloaded to `{}` Successfully !!\nInitiating Upload to Google Drive.."
.format(downloaded_file_name))
if required_file_name:
if G_DRIVE_AUTH_TOKEN_DATA is not None:
with open(G_DRIVE_TOKEN_FILE, "w") as t_file:
t_file.write(G_DRIVE_AUTH_TOKEN_DATA)
# Check if token file exists, if not create it by requesting
# authorization code
if not os.path.isfile(G_DRIVE_TOKEN_FILE):
storage = await create_token_file(G_DRIVE_TOKEN_FILE, dryb)
http = authorize(G_DRIVE_TOKEN_FILE, storage)
# Authorize, get file parameters, upload file and print out result URL
# for download
http = authorize(G_DRIVE_TOKEN_FILE, None)
file_name, mime_type = file_ops(required_file_name)
# required_file_name will have the full path
# Sometimes API fails to retrieve starting URI, we wrap it.
try:
g_drive_link = await upload_file(http, required_file_name,
file_name, mime_type, dryb,
parent_id)
await dryb.edit(
f"File:`{required_file_name}`\nwas Successfully Uploaded to [Google Drive]({g_drive_link})!"
)
except Exception as e:
await dryb.edit(
f"Error while Uploading to Google Drive\nError Code:\n`{e}`")
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']}**"
"\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 v_url.edit(
f"`Preparing to upload video:`\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 v_url.delete()
async def download_video(v_url):
""" .rip komutu ile YouTube ve birkaç farklı siteden medya çekebilirsin. """
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`İndirmeye hazırlanıyor...`")
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("`Veri çekiliyor, lütfen bekleyin...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`İndirilecek içerik fazla kısa.`")
return
except GeoRestrictedError:
await v_url.edit(
"`Maalesef coğrafi kısıtlamalar sebebiyle bu videoyla işlem yapamazsın.`"
)
return
except MaxDownloadsReached:
await v_url.edit("`Maksimum indirme limitini aştın.`")
return
except PostProcessingError:
await v_url.edit("`İstek işlenirken bir hata oluştu.`")
return
except UnavailableVideoError:
await v_url.edit("`Medya belirtilen dosya formatında mevcut değil.`")
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`Bilgi çıkarılırken bir hata gerçekleşti.`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await v_url.edit(f"`Şarkı yüklenmeye hazırlanıyor:`\
\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, "Karşıya yükleniyor...",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(f"`Şarkı yüklenmeye hazırlanıyor:`\
\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, "Karşıya yükleniyor...",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
await v_url.delete()
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("`Pobieram, zaczekaj..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`Dane były zbyt małe.`")
return
except GeoRestrictedError:
await v_url.edit("`Wideo ma Geoblokadę.`")
return
except MaxDownloadsReached:
await v_url.edit("`Maksymalny limit pobrań osiągnięty.`")
return
except PostProcessingError:
await v_url.edit("`Wystąpił błąd podczas przetwarzania.`")
return
except UnavailableVideoError:
await v_url.edit("`Brak mediów w podanym formacie.`")
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`Wystąpił błąd podczas ekstrackcji metadanych.`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await v_url.edit(f"`Przygotowywanie do wysłania piosenki:`\
\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, "Wysyłanie..",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(f"`Przygotowywanie do wysłania wideo:`\
\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, "Wysyłanie..",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
await v_url.delete()
async def gdrive_upload_function(dryb):
""" .gdrive komutu dosyalarınızı Google Drive'a uploadlar. """
await dryb.edit("İşleniyor ...")
input_str = dryb.pattern_match.group(1)
if CLIENT_ID is None or CLIENT_SECRET is None:
return
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
required_file_name = None
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
# https://stackoverflow.com/a/761825/4723940
file_name = file_name.strip()
head, tail = os.path.split(file_name)
if head:
if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)):
os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head))
file_name = os.path.join(head, tail)
downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
display_message = None
while not downloader.isFinished():
status = downloader.get_status().capitalize()
total_length = downloader.filesize if downloader.filesize else None
downloaded = downloader.get_dl_size()
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
speed = downloader.get_speed()
elapsed_time = round(diff) * 1000
progress_str = "[{0}{1}] {2}%".format(
''.join(["▰" for i in range(math.floor(percentage / 10))]),
''.join(["▱"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"{status}...\
\nURL: {url}\
\nDosya adı: {file_name}\
\n{progress_str}\
\n{humanbytes(downloaded)} of {humanbytes(total_length)}\
\nBitiş: {estimated_total_time}"
if round(diff %
10.00) == 0 and current_message != display_message:
await dryb.edit(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
pass
if downloader.isSuccessful():
await dryb.edit(
"`{}` dizinine indirme başarılı. \nGoogle Drive'a yükleme başlatılıyor.."
.format(downloaded_file_name))
required_file_name = downloaded_file_name
else:
await dryb.edit("Geçersiz URL\n{}".format(url))
elif input_str:
input_str = input_str.strip()
if os.path.exists(input_str):
required_file_name = input_str
await dryb.edit(
"`{}` dosyası sunucuda bulundu. Google Drive'a yükleme başlatılıyor.."
.format(input_str))
else:
await dryb.edit(
"Sunucuda dosya bulunamadı. Lütfen doğru dosya konumunu belirtin."
)
return False
elif dryb.reply_to_msg_id:
try:
c_time = time.time()
downloaded_file_name = await dryb.client.download_media(
await dryb.get_reply_message(),
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(progress(d, t, dryb, c_time, "İndiriliyor...")))
except Exception as e:
await dryb.edit(str(e))
else:
required_file_name = downloaded_file_name
await dryb.edit(
"`{}` dizinine indirme başarrılı. \nGoogle Drive'a yükleme başlatılıyor.."
.format(downloaded_file_name))
if required_file_name:
if G_DRIVE_AUTH_TOKEN_DATA is not None:
with open(G_DRIVE_TOKEN_FILE, "w") as t_file:
t_file.write(G_DRIVE_AUTH_TOKEN_DATA)
# Token dosyasının olup olmadığını kontrol eder, eğer yoksa yetkilendirme kodu ile oluşturur.
if not os.path.isfile(G_DRIVE_TOKEN_FILE):
storage = await create_token_file(G_DRIVE_TOKEN_FILE, dryb)
http = authorize(G_DRIVE_TOKEN_FILE, storage)
# Yetkilendirir, dosya parametrelerini edinir, dosyayı uploadlar ve URL'yi indirme için paylaşır.
http = authorize(G_DRIVE_TOKEN_FILE, None)
file_name, mime_type = file_ops(required_file_name)
# required_file_name tam dosya yoluna sahiptir.
# Bazen API başlangıç URI'sini geri alırken hatayla karşılaşır.
try:
g_drive_link = await upload_file(http, required_file_name,
file_name, mime_type, dryb,
parent_id)
await dryb.edit(
f"Dosya :`{required_file_name}`\nUpload başarılı! \nİndirme linki: [Google Drive]({g_drive_link})!"
)
except Exception as e:
await dryb.edit(
f"Google Drive'a yükleme başarısız.\nHata kodu:\n`{e}`")
async def gdrive_upload_function(dryb):
await dryb.edit("Qenerasiya olunur...")
input_str = dryb.pattern_match.group(1)
if CLIENT_ID is None or CLIENT_SECRET is None:
return
if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(TEMP_DOWNLOAD_DIRECTORY)
required_file_name = None
if "|" in input_str:
url, file_name = input_str.split("|")
url = url.strip()
file_name = file_name.strip()
head, tail = os.path.split(file_name)
if head:
if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)):
os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head))
file_name = os.path.join(head, tail)
downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name
downloader = SmartDL(url, downloaded_file_name, progress_bar=False)
downloader.start(blocking=False)
c_time = time.time()
display_message = None
while not downloader.isFinished():
status = downloader.get_status().capitalize()
total_length = downloader.filesize if downloader.filesize else None
downloaded = downloader.get_dl_size()
now = time.time()
diff = now - c_time
percentage = downloader.get_progress() * 100
speed = downloader.get_speed()
elapsed_time = round(diff) * 1000
progress_str = "[{0}{1}] {2}%".format(
''.join(["▰" for i in range(math.floor(percentage / 10))]),
''.join(["▱"
for i in range(10 - math.floor(percentage / 10))]),
round(percentage, 2))
estimated_total_time = downloader.get_eta(human=True)
try:
current_message = f"{status}...\
\nURL: {url}\
\nFayl adı: {file_name}\
\n{progress_str}\
\n{humanbytes(downloaded)} of {humanbytes(total_length)}\
\nBitdiyi zaman: {estimated_total_time}"
if round(diff %
10.00) == 0 and current_message != display_message:
await dryb.edit(current_message)
display_message = current_message
except Exception as e:
LOGS.info(str(e))
pass
if downloader.isSuccessful():
await dryb.edit(
"`{}` Kataloqu yükləmək müvəffəqdir.\nGoogle Diskə yükləmə başlayır.."
.format(downloaded_file_name))
required_file_name = downloaded_file_name
else:
await dryb.edit("Yanlış URL\n{}".format(url))
elif input_str:
input_str = input_str.strip()
if os.path.exists(input_str):
required_file_name = input_str
await dryb.edit(
"`{}` serverdə fayl tapıldı. Google Diskə yükləmə başlayır..".
format(input_str))
else:
await dryb.edit(
"Fayl serverdə tapılmadı. Xahiş edirəm düzgün fayl yerini göstərin."
)
return False
elif dryb.reply_to_msg_id:
try:
c_time = time.time()
downloaded_file_name = await dryb.client.download_media(
await dryb.get_reply_message(),
TEMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(progress(d, t, dryb, c_time, "Endirilir...")))
except Exception as e:
await dryb.edit(str(e))
else:
required_file_name = downloaded_file_name
await dryb.edit(
"`{}` Dizinə endirmə uğurlu oldu. \nGoogle Diskə yükləmə başlayır.."
.format(downloaded_file_name))
if required_file_name:
if G_DRIVE_AUTH_TOKEN_DATA is not None:
with open(G_DRIVE_TOKEN_FILE, "w") as t_file:
t_file.write(G_DRIVE_AUTH_TOKEN_DATA)
if not os.path.isfile(G_DRIVE_TOKEN_FILE):
storage = await create_token_file(G_DRIVE_TOKEN_FILE, dryb)
http = authorize(G_DRIVE_TOKEN_FILE, storage)
http = authorize(G_DRIVE_TOKEN_FILE, None)
file_name, mime_type = file_ops(required_file_name)
try:
g_drive_link = await upload_file(http, required_file_name,
file_name, mime_type, dryb,
parent_id)
await dryb.edit(
f"Fayl :`{required_file_name}`\nYükləmə uğurlu oldu! \nYükləmə linki: [Google Drive]({g_drive_link})!"
)
except Exception as e:
await dryb.edit(
f"Yükləmə Google Diskə yüklənmədi.\nXəta kodu:\n`{e}`")
async def download_video(v_url):
""" .rip """
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`Endirmə hazırlanır...`")
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("`Veri çəkilir, xaiş gözləyin...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`Endirləcək məzmun çox qısadır.`")
return
except GeoRestrictedError:
await v_url.edit(
"`Təəsüf coğrafi əngəlləmələr səbəbi ilə bu video ilə heçnə edə bilmərsiz.`")
return
except MaxDownloadsReached:
await v_url.edit("`Maksimum endirmə limitini aşdın.`")
return
except PostProcessingError:
await v_url.edit("`İstək işlənərkən bir xəta yarandı.`")
return
except UnavailableVideoError:
await v_url.edit("`Medya seçilən fayl formatında mövcud deyil.`")
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`Məlumat çıxarılarkən bir xəta həyata keçirildi.`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await v_url.edit(f"`Musiqi yüklənməyə hazırlanır:`\
\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, "Qarşıya yüklənir...",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(f"`Video yüklənməyə hazırlanır:`\
\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, "Qarşıya yüklənir...",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
await v_url.delete()
async def download_video(v_url):
""" For .ytdl command, download media from YouTube and many other sites. """
reply = await v_url.get_reply_message()
if v_url.pattern_match.group(2) != "":
url = v_url.pattern_match.group(2)
elif reply is not None:
url = reply.message
url = re.findall(r'\bhttps?://.*\.\S+', reply.message)[0]
else:
return
type = v_url.pattern_match.group(1).lower() if v_url.pattern_match.group(
1) is not None else "a"
await v_url.edit("`Preparing to download...`")
out_folder = TEMP_DOWNLOAD_DIRECTORY + "youtubedl/"
thumb_image_path = TEMP_DOWNLOAD_DIRECTORY + "/thumb_image.jpg"
if not os.path.isdir(out_folder):
os.makedirs(out_folder)
if type == "m":
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
flac = False
elif type == "f":
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': 'flac',
}],
'outtmpl':
out_folder + '%(title)s.%(ext)s',
'quiet':
True,
'logtostderr':
False
}
video = False
song = False
flac = True
elif type == "p":
opts = {
'format':
'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/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
flac = False
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",
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
thumb=thumb,
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)
return await v_url.delete()
shutil.rmtree(out_folder)
if flac:
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)
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",
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
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)
return 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",
force_document=force_document,
supports_streaming=supports_streaming,
# thumb = thumb,
allow_cache=False,
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)
return await v_url.delete()
shutil.rmtree(out_folder)
async def download_video(v_url):
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`Hazırlanır...`")
if type == "a":
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 == "v":
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("`Lazımlı fayllar yüklənir...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`Yükləmək istədiyiniz fayl çox kiçikdir`")
return
except GeoRestrictedError:
await v_url.edit(
"`Təsüf edirəmki məlumat verə bilməyəcəyəm. Səbəb: Ölkə qadağanı `")
return
except MaxDownloadsReached:
await v_url.edit("`Limitin doldu :(`")
return
except PostProcessingError:
await v_url.edit("`İstək sırasında 1 xəta əmələ gəldi.`")
return
except UnavailableVideoError:
await v_url.edit("`Error UnavialableVideoError |//\\| Bu mesajı görürsənsə, çox güman ki, istifadəçi botunda _youtube_ modulu sıradan çıxdı.")
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`Lazımlı məlumatlar yüklənərkən xəta baş verdi.`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await v_url.edit(f"`Musiqi yüklənir:`\
\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, "Son toxunuşlar...",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(f"`Musiqi yüklənməyə hazırlanır:`\
\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, "Son toxunuşlar...",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
await v_url.delete()
async def download_video(v_url):
""" .rip komutu ile YouTube ve birkaç farklı siteden medya çekebilirsin. """
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`Yüklənməyə hazırlanır...`")
if type == "a":
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 == "v":
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("`Lazımi məlumatlar yüklənir...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`Yüklənəcək video çox qısadır.`")
return
except GeoRestrictedError:
await v_url.edit(
"`Malesef coğrafi kısıtlamalar yüzünden işlem yapamazsın`")
return
except MaxDownloadsReached:
await v_url.edit("`Maksimum yüklenme limiti aşıldı.`")
return
except PostProcessingError:
await v_url.edit("`İstek sırasında bir hata baş verdi.`")
return
except UnavailableVideoError:
await v_url.edit(
"`Error UnavialableVideoError |//\\| Bu mesajı görürsen büyük ihtimal ile userbotunda _youtube_ modulu xəta verdi bu mesajı @TheCyberSupport qrupuna göndər`"
)
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`Bir xəta baş verdi.`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await v_url.edit(f"`Musiqi yüklənməyə hazırlanır:`\
\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, "Hazırlanır...",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(f"`Musiqi yüklənməyə hazırlanır:`\
\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, "Hazırlanır...",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
await v_url.delete()
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("`Siap Untuk Didownload...`")
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("`Mendapatkan data, Sabar Ya..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`Konten Yang Didownload Sangat Pendek.`")
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 Telah Tercapai.`")
return
except PostProcessingError:
await v_url.edit("`Sebuah Kesalahan Saat Memproses.`")
return
except UnavailableVideoError:
await v_url.edit("`Media Bukan Format Yang Didukung.`")
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`Ada Sebuah Kesalahan.`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await v_url.edit(f"`Bersiap Mengupload Lagu:`\
\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, "Mengupload..",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(f"`Bersiap Mengupload Video:`\
\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, "Mengupload..",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
await v_url.delete()
async def extract(zarchiver):
if zarchiver.fwd_from:
return
mone = await zarchiver.edit("Processing ...")
if not os.path.isdir(TMP_DOWNLOAD_DIRECTORY):
os.makedirs(TMP_DOWNLOAD_DIRECTORY)
if zarchiver.reply_to_msg_id:
start = datetime.now()
reply_message = await zarchiver.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await bot.download_media(
reply_message,
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 zarchiver.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 bot.send_file(
zarchiver.chat_id,
single_file,
caption=f"UnZipped `{caption_rts}`",
force_document=force_document,
supports_streaming=supports_streaming,
allow_cache=False,
reply_to=zarchiver.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 bot.send_message(zarchiver.chat_id,
"{} caused `{}`".format(
caption_rts, str(e)),
reply_to=zarchiver.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
input_str = event.pattern_match.group(1)
reply_message = await event.get_reply_message()
if reply_message is None:
await event.edit("`Çevirmək üçün bir mediaya cavab verin`")
return
await event.edit("__Media lokala yüklənilir...__")
try:
start = datetime.now()
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, event, c_time, "__Yüklənilir...__")),
)
except Exception as e: # pylint:disable=C0103,W0703
await event.edit(str(e))
else:
end = datetime.now()
ms = (end - start).seconds
await event.edit("`{}` 'a {} saniyədə yükləndi".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 == "ses":
new_required_file_caption = "AUDIO" + str(round(
time.time())) + ".ogg"
new_required_file_name = (TEMP_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 = (TEMP_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("`Dsətəklənməyən tip`")
os.remove(downloaded_file_name)
return
# TODO: re-write 😉
process = await asyncio.create_subprocess_exec(
*command_to_run,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
# subprocess sonlanır..
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 event.client.send_file(
entity=event.chat_id,
file=new_required_file_name,
caption=f"@UseratorOT",
allow_cache=False,
silent=True,
force_document=force_document,
voice_note=voice_note,
supports_streaming=supports_streaming,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, event, c_time, "__Yüklənilir...__")),
)
ms_two = (end_two - end).seconds
os.remove(new_required_file_name)
await event.edit(f"`{ms_two}` saniyədə mp3'ə çevrildi")
async def download_video(v_url):
""" .ripav """
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`Gözləyin...`")
if type == "a":
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 == "v":
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("`Məlumatlar oxunur...`")
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("`Yükləmək üçün video çox qısadır.`")
except GeoRestrictedError:
return await v_url.edit(
"`Video geoqrafiya səbəbləri ilə yüklənə bilməz`")
except MaxDownloadsReached:
return await v_url.edit("`Maks yüklənmə limiti.`")
except PostProcessingError:
return await v_url.edit("`Axtararkən xəta yarandı.`")
except UnavailableVideoError:
return await v_url.edit("`Media formatı tapılmadı.`")
except XAttrMetadataError as XAME:
return await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
except ExtractorError:
return await v_url.edit("`XƏTA! Səhv məlumat.`")
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"`Seçdiyiniz musiqi yüklənilir`\n**{rip_data['title']}**")
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, "Yüklənilir...",
f"{rip_data['title']}.mp3")),
)
os.remove(f"{rip_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(
f"`Seçdiyiniz video yüklənir`\n**{rip_data['title']}**")
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, "Yüklənilir..",
f"{rip_data['title']}.mp4")),
)
os.remove(f"{rip_data['id']}.mp4")
await v_url.delete()
async def download_video(v_url):
""" .yta , .ytv . """
url = v_url.pattern_match.group(2)
type = v_url.pattern_match.group(1).lower()
await v_url.edit("`Yüklənməyə hazırlanır...`")
if type == "a":
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 == "v":
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("`Məlumatlar oxunur, gözləyin...`")
with YoutubeDL(opts) as ytdl:
ytdl_data = ytdl.extract_info(url)
except DownloadError as DE:
await v_url.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await v_url.edit("`Yüklənəcək media çox qısadır`")
return
except GeoRestrictedError:
await v_url.edit("`coğrafi...`")
return
except MaxDownloadsReached:
await v_url.edit("`Max yükləmə limitini aşdınız`")
return
except PostProcessingError:
await v_url.edit("`Bir xəta baş verdi.`")
return
except UnavailableVideoError:
await v_url.edit("`Media bu formatı dəstəkləmir.`")
return
except XAttrMetadataError as XAME:
await v_url.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await v_url.edit("`Yükləmə zamanı bir xəta baş verdi`")
return
except Exception as e:
await v_url.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await v_url.edit(f"`Yüklənməyə hazırlanır:`\
\n**{ytdl_data['title']}**\
\nby *{ytdl_data['uploader']}*")
await v_url.client.send_file(
v_url.chat_id,
f"{ytdl_data['id']}.mp3",
supports_streaming=True,
attributes=[
DocumentAttributeAudio(duration=int(ytdl_data['duration']),
title=str(ytdl_data['title']),
performer=str(ytdl_data['uploader']))
],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, v_url, c_time, "Yüklənir...",
f"{ytdl_data['title']}.mp3")))
os.remove(f"{ytdl_data['id']}.mp3")
await v_url.delete()
elif video:
await v_url.edit(f"`Yüklənməyə hazırlanır:`\
\n**{ytdl_data['title']}**\
\nby *{ytdl_data['uploader']}*")
await v_url.client.send_file(
v_url.chat_id,
f"{ytdl_data['id']}.mp4",
supports_streaming=True,
caption=ytdl_data['title'],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, v_url, c_time, "Yüklənir...",
f"{ytdl_data['title']}.mp4")))
os.remove(f"{ytdl_data['id']}.mp4")
await v_url.delete()
