def get_video(message, n=2):
search = SearchVideos(message.content, offset=1, mode="dict", max_results=2)
search = search.result()
for i in range(n):
await message.author.send(str(search['search_result'][i]['link']))
async def stub_input(self, msg):
if not self.troubleshooting:
confidence = 100
looping = False
while confidence >= self.MATCH_CONFIDENCE_THRESHOLD:
match = process.extract(msg, self.layer.keys())
subcat = match[0][0]
confidence = match[0][1]
confidence_difference = match[0][1] - match[1][1]
print("Not troubleshooting: {}".format(subcat))
if confidence < self.MATCH_CONFIDENCE_THRESHOLD:
print("Low confidence {}".format(confidence))
if not looping:
await self.stub_output("Sorry, didnt get that.")
self.retry_counter += 1
if self.retry_counter > self.RETRY_LIMIT:
print("Too many tries")
await self.print_help(self.layer)
return
print("{} Reset retries, confidence {}".format(
subcat, confidence))
if confidence_difference < 5:
print("Confidence difference only {}, asking user".format(
confidence_difference))
await self.stub_output(
random.choice(sorry_messages).format(self.prevcat))
return
self.retry_counter = 0
self.layer = self.layer[subcat]
if not isinstance(self.layer, dict):
self.troubleshooting = True
print(subcat)
await self.stub_output("Hmm.. lets try a few things")
return
elif not looping:
await self.stub_output(
random.choice(sorry_messages).format(subcat))
self.prevcat = subcat
looping = True
else: # provide troubleshooting help
print("Troubleshooting")
if msg == "yes":
await self.stub_output("", img_name="happy.gif")
await self.stub_output("Bye!")
await self.reset()
return
self.current_advice_index += 1
if self.current_advice_index < len(self.layer):
await self.stub_output(self.layer[self.current_advice_index])
await self.stub_output("Did that work?")
else:
await self.stub_output("", img_name="sad.gif")
await self.stub_output(
"Sorry I'm not too sure how to help :( You can connect to a technician if the "
"videos below don't help.")
search = SearchVideos(self.prevcat,
offset=1,
mode="dict",
max_results=2)
search = search.result()
for i in range(2):
await self.stub_output(
str(search['search_result'][i]['link']))
async def download_video(v_url):
lazy = v_url
sender = await lazy.get_sender()
me = await lazy.client.get_me()
if not sender.id == me.id:
rkp = await lazy.reply("`processing...`")
else:
rkp = await lazy.edit("`processing...`")
url = v_url.pattern_match.group(1)
if not url:
return await rkp.edit("`Error \nusage song <song name>`")
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get("search_result")
try:
url = q[0]["link"]
except:
return await rkp.edit("`failed to find`")
type = "audio"
await rkp.edit("`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
try:
await rkp.edit("`Fetching data, please wait..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await rkp.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await rkp.edit("`The download content was too short.`")
return
except GeoRestrictedError:
await rkp.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
return
except MaxDownloadsReached:
await rkp.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await rkp.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await rkp.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await rkp.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await rkp.edit("`There was an error during info extraction.`")
return
except Exception as e:
await rkp.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await rkp.edit(f"`Preparing to upload 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")
elif video:
await rkp.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']}.mp4",
supports_streaming=True,
caption=url,
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")
async def play(self, ctx, *, search):
""" !play "search" then pick number (ex: 1) or !play 'url' """
if "youtube.com" in search:
# Play from URL
async with ctx.typing():
result = ytdl.extract_info(search, download=False)
duration = get_duration(result['duration'])
search_list = [
{"link": search,
"title": result['title'],
"duration": duration
}]
choice = 0
else:
# Search youtube
search_list = []
async with ctx.typing():
query = SearchVideos(search, offset = 1, mode = "dict", max_results = 5)
query_string = "```Choose a video:"
for i in query.result()['search_result']:
query_string += "\n["
query_string += str(i['index'] + 1)
query_string += "] - "
query_string += i['title']
query_string += " ("
query_string += i['duration']
query_string += ")"
info = {
"link": i['link'],
"title": i['title'],
"duration": i['duration']
}
search_list.append(info)
sent_queue = await ctx.send(query_string + "```")
# waiting for user response
def check(m):
return m.author.id == ctx.author.id and int(m.content) <= 5 and int(m.content) >= 1
try:
response = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
await ctx.send("**No song chosen!**")
await sent_queue.delete()
if response:
await response.delete()
return
choice = int(response.content) - 1
await sent_queue.delete()
await response.delete()
# Queue and playing songs
vc = ctx.voice_client
if not vc.is_playing():
async with ctx.typing():
player = await YTDLSource.from_url(search_list[choice]['link'], loop=self.bot.loop, stream=True)
vc.play(player, after=lambda e: print('Player error: %s' % e) if e else play_next(ctx))
await ctx.send('**Now Playing:** {} ({})'.format(player.title, player.duration))
self.now_playing = search_list[choice].copy()
else:
self.song_queue.append(search_list[choice])
# To make sure that the original list has members in it so that both queues function normally.
self.original_list.append(search_list[choice])
await ctx.send('**Song Queued:** {} ({})'.format(search_list[choice]['title'], search_list[choice]['duration']))
def play_next(ctx):
# Check if queue is not empty
if len(self.song_queue) >= 1:
# See if there is nothing in queue
if len(self.song_queue) <= 0:
asyncio.run_coroutine_threadsafe(ctx.send("**No more songs in queue.**"), self.bot.loop)
return
result = asyncio.run_coroutine_threadsafe(YTDLSource.from_url(self.song_queue[0]['link'], loop=self.bot.loop, stream=True), self.bot.loop)
player = result.result()
try:
vc.play(player, after=lambda e: play_next(ctx))
asyncio.run_coroutine_threadsafe(ctx.send('**Now Playing:** {} ({})'.format(player.title, player.duration)), self.bot.loop)
self.now_playing = self.song_queue[0].copy()
#To make sure that songs that are removed from queue are also removed from original list.
for i in range(len(self.original_list)):
if self.original_list[i]['link'] == self.now_playing['link']:
self.original_list.pop(i)
break
del self.song_queue[0]
except:
print("Something Bad Happened!")
pass
async def yt_vid(client, message):
input_str = get_text(message)
engine = message.Engine
type_ = "video"
pablo = await edit_or_reply(message, engine.get_string("PROCESSING"))
if not input_str:
await pablo.edit(
engine.get_string("INPUT_REQ").format("Query")
)
return
_m = ('http://', 'https://')
if "|" in input_str:
input_str = input_str.strip()
input_str, type_ = input_str.split("|")
if type_ not in ['audio', 'video']:
return await pablo.edit(engine.get_string("NEEDS_C_INPUT"))
if input_str.startswith(_m):
url = input_str
else:
await pablo.edit(engine.get_string("GETTING_RESULTS").format(input_str))
search = SearchVideos(str(input_str), offset=1, mode="dict", max_results=1)
if not search:
return await pablo.edit(engine.get_string("NO_RESULTS").format(input_str))
rt = search.result()
result_s = rt["search_result"]
url = result_s[0]["link"]
try:
yt_file, yt_data = await yt_dl(url, client, message, type_)
except Exception as e:
return await pablo.edit(engine.get_string("YTDL_FAILED").format(e))
vid_title = yt_data['title']
uploade_r = yt_data['uploader']
yt_id = yt_data['id']
msg = message.reply_to_message or message
thumb_url = f"https://img.youtube.com/vi/{yt_id}/hqdefault.jpg"
thumb = await _dl(thumb_url)
caption = f"**{type_.title()} Name ➠** `{vid_title}` \n**Requested For ➠** `{input_str}` \n**Channel ➠** `{uploade_r}` \n**Link ➠** `{url}`"
c_time = time.time()
if type_ == "video":
await msg.reply_video(
yt_file,
duration=int(yt_data["duration"]),
thumb=thumb,
caption=caption,
supports_streaming=True,
progress=progress,
progress_args=(
pablo,
c_time,
f"`Uploading Downloaded Youtube File.`",
str(yt_file),
),
)
else:
await msg.reply_audio(
yt_file,
duration=int(yt_data["duration"]),
title=str(yt_data["title"]),
performer=uploade_r,
thumb=thumb,
caption=caption,
progress=progress,
progress_args=(
pablo,
c_time,
f"`Uploading Downloaded Youtube File.`",
str(yt_file),
),
)
await pablo.delete()
for files in (thumb, yt_file):
if files and os.path.exists(files):
os.remove(files)
async def download_video(ult):
x = await eor(ult, "Processing..")
url = ult.pattern_match.group(1)
if not url:
return await x.edit("**Error**\nUsage - `.vsong <song name>`")
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get("search_result")
try:
url = q[0]["link"]
except BaseException:
return await x.edit("`No matching songs found...`")
type = "audio"
await x.edit("`Preparing to download...`")
if type == "audio":
opts = {
"format":
"best",
"addmetadata":
True,
"key":
"FFmpegMetadata",
"prefer_ffmpeg":
True,
"geo_bypass":
True,
"nocheckcertificate":
True,
"postprocessors": [{
"key": "FFmpegVideoConvertor",
"preferedformat": "mp4"
}],
"outtmpl":
"%(id)s.mp4",
"logtostderr":
False,
"quiet":
True,
}
try:
await x.edit("`Fetching data, please wait..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
return await x.edit(f"`{str(DE)}`")
except ContentTooShortError:
return await x.edit("`The download content was too short.`")
except GeoRestrictedError:
return await x.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
except MaxDownloadsReached:
return await x.edit("`Max-downloads limit has been reached.`")
except PostProcessingError:
return await x.edit("`There was an error during post processing.`")
except UnavailableVideoError:
return await x.edit("`Media is not available in the requested format.`"
)
except XAttrMetadataError as XAME:
return await x.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
except ExtractorError:
return await x.edit("`There was an error during info extraction.`")
except Exception as e:
return await x.edit(f"{str(type(e)): {str(e)}}")
upteload = """
Uploading...
Song name - {}
By - {}
""".format(rip_data["title"], rip_data["uploader"])
await x.edit(f"`{upteload}`")
await ultroid_bot.send_file(
ult.chat_id,
f"{rip_data['id']}.mp4",
supports_streaming=True,
caption=
f"⫸ Song - {rip_data['title']}\n⫸ By - {rip_data['uploader']}\n",
)
os.remove(f"{rip_data['id']}.mp4")
await x.delete()
async def play_m(client, message):
group_call = GPC.get((message.chat.id, client.me.id))
u_s = await edit_or_reply(message, "`Processing..`")
input_str = get_text(message)
if not input_str:
if not message.reply_to_message:
return await u_s.edit_text("`Reply To A File To PLay It.`")
if not message.reply_to_message.audio:
return await u_s.edit("`Reply To A File To PLay It.`")
await u_s.edit_text("`Please Wait, Let Me Download This File!`")
audio = message.reply_to_message.audio
audio_original = await message.reply_to_message.download()
vid_title = audio.title or audio.file_name
uploade_r = message.reply_to_message.audio.performer or "Unknown Artist."
dura_ = message.reply_to_message.audio.duration
dur = datetime.timedelta(seconds=dura_)
raw_file_name = (
''.join(random.choice(string.ascii_lowercase) for i in range(5))
+ ".raw"
)
url = message.reply_to_message.link
else:
search = SearchVideos(str(input_str), offset=1, mode="dict", max_results=1)
rt = search.result()
result_s = rt.get("search_result")
if not result_s:
return await u_s.edit(f"`No Song Found Matching With Query - {input_str}, Please Try Giving Some Other Name.`")
url = result_s[0]["link"]
dur = result_s[0]["duration"]
vid_title = result_s[0]["title"]
yt_id = result_s[0]["id"]
uploade_r = result_s[0]["channel"]
start = time.time()
try:
audio_original = await yt_dl(url, client, message, start)
except BaseException as e:
return await u_s.edit(f"**Failed To Download** \n**Error :** `{str(e)}`")
raw_file_name = (
''.join(random.choice(string.ascii_lowercase) for i in range(5))
+ ".raw"
)
try:
raw_file_name = await convert_to_raw(audio_original, raw_file_name)
except BaseException as e:
return await u_s.edit(f"`FFmpeg Failed To Convert Song To raw Format.` \n**Error :** `{e}`")
if os.path.exists(audio_original):
os.remove(audio_original)
if not group_call:
group_call = GroupCallFactory(client).get_file_group_call()
group_call.song_name = vid_title
GPC[(message.chat.id, client.me.id)] = group_call
try:
await group_call.start(message.chat.id)
except BaseException as e:
return await u_s.edit(f"**Error While Joining VC:** `{e}`")
group_call.add_handler(playout_ended_handler, GroupCallFileAction.PLAYOUT_ENDED)
group_call.input_filename = raw_file_name
return await u_s.edit(f"Playing `{vid_title}` in `{message.chat.title}`!")
elif not group_call.is_connected:
try:
await group_call.start(message.chat.id)
except BaseException as e:
return await u_s.edit(f"**Error While Joining VC:** `{e}`")
group_call.add_handler(playout_ended_handler, GroupCallFileAction.PLAYOUT_ENDED)
group_call.input_filename = raw_file_name
group_call.song_name = vid_title
return await u_s.edit(f"Playing `{vid_title}` in `{message.chat.title}`!")
else:
s_d = s_dict.get((message.chat.id, client.me.id))
f_info = {"song_name": vid_title,
"raw": raw_file_name,
"singer": uploade_r,
"dur": dur,
"url": url
}
if s_d:
s_d.append(f_info)
else:
s_dict[(message.chat.id, client.me.id)] = [f_info]
s_d = s_dict.get((message.chat.id, client.me.id))
return await u_s.edit(f"Added `{vid_title}` To Position `#{len(s_d)+1}`!")
async def download_video(v_url):
lazy = v_url ; sender = await lazy.get_sender() ; me = await lazy.client.get_me()
if not sender.id == me.id:
rkp = await lazy.reply("`memproses...`")
else:
rkp = await lazy.edit("`memproses...`")
url = v_url.pattern_match.group(1)
if not url:
return await rkp.edit("`Error \n Ketik /lagu <judul laguny bro>`")
search = SearchVideos(url, offset = 1, mode = "json", max_results = 1)
test = search.result()
p = json.loads(test)
q = p.get('search_result')
try:
url = q[0]['link']
except:
return await rkp.edit("`gagal mencari`")
type = "audio"
await rkp.edit("`Mencoba untuk mendownload..`")
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': '128',
}],
'outtmpl':
'%(id)s.mp3',
'quiet':
True,
'logtostderr':
False
}
video = False
song = True
try:
await rkp.edit("`Lagi ngambil data, tunggu bentar..`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await rkp.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await rkp.edit("`Error! Konten downloadnya kependekan.`")
return
except GeoRestrictedError:
await rkp.edit(
"`Videonya ga tersedia dinegara kita bro.`"
)
return
except MaxDownloadsReached:
await rkp.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await rkp.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await rkp.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await rkp.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await rkp.edit("`There was an error during info extraction.`")
return
except Exception as e:
await rkp.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await rkp.edit(f"`Mencoba 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, "Lagi diupload..",
f"{rip_data['title']}.mp3")))
os.remove(f"{rip_data['id']}.mp3")
elif video:
await rkp.edit(f"`Mencoba mengupload lagu:`\
\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=url,
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, v_url, c_time, "Lagi diupload..",
f"{rip_data['title']}.mp4")))
os.remove(f"{rip_data['id']}.mp4")
def get_video_details(id):
search = SearchVideos(str(id), offset=1, mode="json", max_results=1)
ytresults = search.result()
result_dict = json.loads(ytresults)
return result_dict
posts_len = 0
os.remove(save_news)
f = open(save_news, "w")
f.close()
try:
if tesla_youtue:
live_news = getreq(urls)
news_titles = live_news.select('.list_news li a[title]')
for i in reversed(news_titles):
links.append(i.attrs['href'])
else:
search = SearchVideos(keywords,
offset=1,
mode="dict",
max_results=20)
result = search.result()
for key in result['search_result']:
links.append(key['link'])
title.append(key['title'])
img.append(key['thumbnails'][1])
read_save_news = open(save_news, "r") # 저장된 갤번호 읽어오기
read_data = []
for data in read_save_news:
read_data.append(data.rstrip())
read_save_news.close()
same_gall = all(elem in read_data for elem in links)
if same_gall:
print("전체복사")
if keywords == "테슬라":
def search(arg):
res = SearchVideos(arg, offset=1, mode="list", max_results=5)
return res.result()
def get(self, name):
try:
search = SearchVideos(name, offset=1, mode="json", max_results=20)
return json.loads(search.result())
except:
return "Fail"
async def song(event):
a = event.text
if a[5] == "s":
return
x = await event.edit(LANG['SEARCHING'])
url = event.pattern_match.group(1)
if not url:
return await x.edit(LANG['USAGE'])
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get("search_result")
try:
url = q[0]["link"]
except BaseException:
return await x.edit(LANG['NOT_FOUND'])
type = "audio"
await x.edit(f"`{url} Yüklənməyə hazırlanır...`")
if type == "audio":
opts = {
"format":
"bestaudio",
"addmetadata":
True,
"key":
"FFmpegMetadata",
"writethumbnail":
True,
"prefer_ffmpeg":
True,
"nocheckcertificate":
True,
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "mp3",
"preferredquality": "320",
}],
"outtmpl":
"%(id)s.mp3",
"quiet":
True,
"logtostderr":
False,
}
try:
await x.edit(LANG['UPLOADİNG'])
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await x.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await x.edit("`Yüklənəcək media çox qısadır`")
return
except GeoRestrictedError:
await x.edit("`Coğrafi səbəblərdən yüklənə bilmədi`")
return
except MaxDownloadsReached:
await x.edit("`Max yükləmə limitini aşdınız`")
return
except PostProcessingError:
await x.edit("`Bir xəta baş verdi`")
return
except UnavailableVideoError:
await x.edit("`Dəstəklənməyən media tipi`")
return
except XAttrMetadataError as XAME:
return await x.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
except ExtractorError:
return await x.edit("`Məlumatlar gətirilən zaman bir xəta baş verdu6`")
except Exception as e:
return await x.edit(f"{str(type(e)): {str(e)}}")
dir = os.listdir()
if f"{rip_data['id']}.mp3.jpg" in dir:
thumb = f"{rip_data['id']}.mp3.jpg"
elif f"{rip_data['id']}.mp3.webp" in dir:
thumb = f"{rip_data['id']}.mp3.webp"
else:
thumb = None
upteload = """
» {}
» {}
""".format(rip_data["title"], rip_data["uploader"])
await x.edit(f"`{upteload}`")
CAPT = f"» **{rip_data['title']}**\n" + LANG['UPLOADED_WITH']
await bot.send_file(
event.chat_id,
f"{rip_data['id']}.mp3",
thumb=thumb,
supports_streaming=True,
caption=CAPT,
attributes=[
DocumentAttributeAudio(
duration=int(rip_data["duration"]),
title=str(rip_data["title"]),
performer=str(rip_data["uploader"]),
)
],
)
await x.delete()
os.remove(f"{rip_data['id']}.mp3")
try:
os.remove(thumb)
except BaseException:
pass
async def download_video(v_url):
approved_userss = approved_users.find({})
for ch in approved_userss:
iid = ch["id"]
userss = ch["user"]
if v_url.is_group:
if await is_register_admin(v_url.input_chat, v_url.message.sender_id):
pass
elif v_url.chat_id == iid and v_url.sender_id == userss:
pass
else:
return
url = v_url.pattern_match.group(1)
rkp = await v_url.reply("`Processing ...`")
if not url:
await rkp.edit("`Error \nusage video <song name>`")
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get("search_result")
try:
url = q[0]["link"]
except BaseException:
return await rkp.edit("`Failed to find that video song`")
type = "video"
await rkp.edit("`Preparing to download ...`")
if 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 rkp.edit("`Fetching data, please wait ...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await rkp.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await rkp.edit("`The download content was too short.`")
return
except GeoRestrictedError:
await rkp.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
return
except MaxDownloadsReached:
await rkp.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await rkp.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await rkp.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await rkp.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await rkp.edit("`There was an error during info extraction.`")
return
except Exception as e:
await rkp.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if video:
await rkp.edit(f"`Sending the video song ...`")
y = await v_url.client.send_file(
v_url.chat_id,
f"{rip_data['id']}.mp4",
supports_streaming=True,
caption=rip_data["title"],
)
await y.forward_to(JULIAVSONG)
os.system("rm -rf *.mp4")
os.system("rm -rf *.webp")
async def vid(client, message):
input_str = get_text(message)
pablo = await edit_or_reply(message, f"`Processing...`")
if not input_str:
await pablo.edit(
"`Please Give Me A Valid Input. You Can Check Help Menu To Know More!`"
)
return
await pablo.edit(
f"`Getting {input_str} From Youtube Servers. Please Wait.`")
search = SearchVideos(str(input_str), offset=1, mode="dict", max_results=1)
rt = search.result()
result_s = rt["search_result"]
url = result_s[0]["link"]
vid_title = result_s[0]["title"]
yt_id = result_s[0]["id"]
uploade_r = result_s[0]["channel"]
thumb_url = f"https://img.youtube.com/vi/{yt_id}/hqdefault.jpg"
await asyncio.sleep(0.6)
downloaded_thumb = wget.download(thumb_url)
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,
}
try:
with YoutubeDL(opts) as ytdl:
ytdl_data = ytdl.extract_info(url, download=True)
except Exception as e:
await pablo.edit(event,
f"**Failed To Download** \n**Error :** `{str(e)}`")
return
c_time = time.time()
file_stark = f"{ytdl_data['id']}.mp4"
capy = f"**Video Name ➠** `{vid_title}` \n**Requested For ➠** `{input_str}` \n**Channel ➠** `{uploade_r}` \n**Link ➠** `{url}`"
await client.send_video(
message.chat.id,
video=open(file_stark, "rb"),
duration=int(ytdl_data["duration"]),
file_name=str(ytdl_data["title"]),
thumb=downloaded_thumb,
caption=capy,
supports_streaming=True,
progress=progress,
progress_args=(
pablo,
c_time,
f"`Uploading {input_str} Song From YouTube Music!`",
file_stark,
),
)
await pablo.delete()
for files in (downloaded_thumb, file_stark):
if files and os.path.exists(files):
os.remove(files)
author = track.user["username"]
title = track.title
i = tracks.index(track) + 1
name = ""
#making full name
if author in title:
name = f"{title}"
else:
name = f"{author} - {title}"
search_name = name.replace(" ", "_").replace("&", "and")
#check if it's already downloaded
print("_" * 100)
if f"{search_name}.mp3" not in downloaded:
#search on youtube to get a link
search = SearchVideos(name, offset=1, mode="json", max_results=20)
results = json.loads(search.result())
if len(results["search_result"]) > 0:
link = results["search_result"][0]["link"]
print(f"{i}. {name} - {link}")
urls.append(link)
try:
#get worse video quality xd
print(
" Finding the worst video quality (for quick download)..."
)
quality_data = os.popen(f"you-get -i {link}").read()
num_of_types = round((len(quality_data.splitlines()) - 12) / 6)
best = None
for i in range(num_of_types):
async def ytmusic(client, message: Message):
global is_downloading
if is_downloading:
await message.reply_text(
"Download yang lain sedang berlangsung, coba lagi nanti")
return
urlissed = get_text(message)
pablo = await client.send_message(
message.chat.id,
f"`Mendapatkan {urlissed} dari YouTube. Mohon tunggu.`")
if not urlissed:
await pablo.edit(
"Cmd perintah tidak valid, silahkan tekan /help kalo masih ga ngerti !"
)
return
search = SearchVideos(f"{urlissed}", offset=1, mode="dict", max_results=1)
mi = search.result()
mio = mi["search_result"]
mo = mio[0]["link"]
thum = mio[0]["title"]
fridayz = mio[0]["id"]
thums = mio[0]["channel"]
kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
await asyncio.sleep(0.6)
url = mo
sedlyf = wget.download(kekme)
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,
}
try:
is_downloading = True
with youtube_dl.YoutubeDL(opts) as ytdl:
infoo = ytdl.extract_info(url, False)
duration = round(infoo["duration"] / 60)
if duration > 10:
await pablo.edit(
f"❌ Durasi vidio lagu yg lu minta {duration} menit , lu cuma bisa play vidio lagu paling lama {DURATION_LIMIT} menit... ngotak lah ajg 😁"
)
is_downloading = False
return
ytdl_data = ytdl.extract_info(url, download=True)
except Exception as e:
#await pablo.edit(event, f"**Failed To Download** \n**Error :** `{str(e)}`")
is_downloading = False
return
c_time = time.time()
file_stark = f"{ytdl_data['id']}.mp4"
capy = f"**Nama Video ➠** `{thum}` \n**Requested For :** `{urlissed}` \n**Channel :** `{thums}` \n**Link :** `{mo}`"
await client.send_video(
message.chat.id,
video=open(file_stark, "rb"),
duration=int(ytdl_data["duration"]),
file_name=str(ytdl_data["title"]),
thumb=sedlyf,
caption=capy,
supports_streaming=True,
progress=progress,
progress_args=(pablo, c_time,
f'`Uploading {urlissed} lagu dari YouTube !`',
file_stark))
await pablo.delete()
is_downloading = False
for files in (sedlyf, file_stark):
if files and os.path.exists(files):
os.remove(files)
async def download_song(v_url):
try:
approved_userss = approved_users.find({})
for ch in approved_userss:
iid = ch["id"]
userss = ch["user"]
if v_url.is_group:
if await is_register_admin(v_url.input_chat, v_url.message.sender_id):
pass
elif v_url.chat_id == iid and v_url.sender_id == userss:
pass
else:
return
url = v_url.pattern_match.group(1)
rkp = await v_url.reply("`Processing ...`")
if not url:
await rkp.edit("`Error \nusage song <song name>`")
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get("search_result")
try:
url = q[0]["link"]
except BaseException:
return await rkp.edit("`Failed to find that song`")
type = "audio"
await rkp.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
try:
await rkp.edit("`Fetching data, please wait ...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await rkp.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await rkp.edit("`The download content was too short.`")
return
except GeoRestrictedError:
await rkp.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
return
except MaxDownloadsReached:
await rkp.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await rkp.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await rkp.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await rkp.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await rkp.edit("`There was an error during info extraction.`")
return
except Exception as e:
await rkp.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await rkp.edit(f"`Sending the song ...`")
y = await v_url.client.send_file(
v_url.chat_id,
f"{rip_data['id']}.mp3",
supports_streaming=False,
force_document=False,
allow_cache=False,
attributes=[
DocumentAttributeAudio(
duration=int(rip_data["duration"]),
title=str(rip_data["title"]),
performer=str(rip_data["uploader"]),
)
],
)
songname = str(rip_data["title"])
if JULIASONG:
pass
else:
os.system("rm -rf *.mp3")
os.system("rm -rf *.webp")
os.system("rm -rf *.jpg")
return
suck = await ubot.get_messages(JULIASONG, limit=None)
for c in suck:
if not isinstance(c.message, types.MessageService):
if c.media != None:
name = c.media.document.attributes[0].title
if str(name) == songname:
os.system("rm -rf *.mp3")
os.system("rm -rf *.webp")
return
await y.forward_to(JULIASONG)
os.system("rm -rf *.mp3")
os.system("rm -rf *.webp")
os.system("rm -rf *.jpg")
except Exception as e:
print(e)
async def download_video(ult):
x = await eor(ult, "Searching...")
url = ult.pattern_match.group(1)
if not url:
return await x.edit("**Error**\nUsage - `.song <song name>`")
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get("search_result")
try:
url = q[0]["link"]
except BaseException:
return await x.edit("`No matching song found...`")
type = "audio"
await x.edit(f"`Preparing to download {url}...`")
if type == "audio":
opts = {
"format":
"bestaudio",
"addmetadata":
True,
"key":
"FFmpegMetadata",
"writethumbnail":
True,
"prefer_ffmpeg":
True,
"nocheckcertificate":
True,
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "mp3",
"preferredquality": "320",
}],
"outtmpl":
"%(id)s.mp3",
"quiet":
True,
"logtostderr":
False,
}
try:
await x.edit("`Getting info...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await x.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await x.edit("`The download content was too short.`")
return
except GeoRestrictedError:
await x.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
return
except MaxDownloadsReached:
await x.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await x.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await x.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
return await x.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
except ExtractorError:
return await x.edit("`There was an error during info extraction.`")
except Exception as e:
return await x.edit(f"{str(type(e)): {str(e)}}")
dir = os.listdir()
if f"{rip_data['id']}.mp3.jpg" in dir:
thumb = f"{rip_data['id']}.mp3.jpg"
elif f"{rip_data['id']}.mp3.webp" in dir:
thumb = f"{rip_data['id']}.mp3.webp"
else:
thumb = None
upteload = """
Uploading...
Song name - {}
By - {}
""".format(rip_data["title"], rip_data["uploader"])
await x.edit(f"`{upteload}`")
await ultroid_bot.send_file(
ult.chat_id,
f"{rip_data['id']}.mp3",
thumb=thumb,
supports_streaming=True,
caption=
f"⫸ Song - {rip_data['title']}\n⫸ By - {rip_data['uploader']}\n",
attributes=[
DocumentAttributeAudio(
duration=int(rip_data["duration"]),
title=str(rip_data["title"]),
performer=str(rip_data["uploader"]),
)
],
)
await x.delete()
os.remove(f"{rip_data['id']}.mp3")
try:
os.remove(thumb)
except:
pass
def main(spotify_bearer, pid, out_dir, offset, use_min_dist):
out_dir = out_dir.rstrip('/')
if not os.path.exists(out_dir):
os.makedirs(out_dir)
with open(f'{out_dir}/songs', 'a+') as f:
f.seek(0, 0)
m = set({})
for line in f.readlines():
m.add(line.rstrip())
headers1 = {'Authorization': f'Bearer {spotify_bearer}', 'Content-type': 'application/json'}
cont = True
offset1 = 0
if offset:
offset1 = offset
while cont:
s = http.client.HTTPSConnection("api.spotify.com")
path = f'/v1/playlists/{pid}/tracks?market=ES&offset={offset1}'
s.request("GET", path , headers=headers1)
r1 = s.getresponse()
code = r1.getcode()
if code != 200:
print(f'Got {code}. Probably a 401. Get a new bearer token and try again...madafaaaaka')
return
x1 = json.loads(r1.read().decode())
if len(x1["items"]) < 100:
cont = False
for i in x1["items"]:
try:
artists = " ".join([a["name"] for a in i["track"]["artists"]])
search = f'{artists} {i["track"]["name"]}'#.replace(" ", "%20")
if search in m:
print(f'Already downloaded {search}. Skipping')
continue
print(f'Searching for {search}')
r = SearchVideos(search, offset = 1, mode = "json", max_results = 20)
x = json.loads(r.result())
if len(x["search_result"]) == 0:
print(f'no search results for {search}')
continue
res_i = 0
if use_min_dist:
num_res = 10
min_dist = sys.maxsize
title = x["search_result"][0]["title"]
for i, res in enumerate(x["search_result"][:num_res]):
dist = editdistance.eval(search, res["title"])
if dist < min_dist:
min_dist = dist
res_i = i
title = res["title"]
print(f'min dist title of first {num_res} results: {title} idx {min_i}')
id1 = x["search_result"][res_i]["id"]
res = os.system(f'youtube-dlc -o \"{out_dir}/%(title)s.%(ext)s\" https://www.youtube.com/watch?v={id1} -x --audio-format \"mp3\"')
if res == 0 :
m.add(search)
f.write(f'{search}\n')
except Exception as e:
print(f'caught exception: {e}')
offset1 += 100
p = subprocess.Popen(['m3ugen'], cwd=out_dir)
p.wait()
async def download_song(v_url):
if v_url.is_group:
if (await is_register_admin(v_url.input_chat,
v_url.message.sender_id)):
pass
elif v_url.chat_id == iid and v_url.sender_id == userss:
pass
else:
return
url = v_url.pattern_match.group(1)
rkp = await v_url.reply("`Processing ...`")
if not url:
await rkp.edit("`Error \nusage song <song name>`")
search = SearchVideos(url, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get('search_result')
try:
url = q[0]['link']
except BaseException:
return await rkp.edit("`Failed to find that song`")
type = "audio"
await rkp.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
try:
await rkp.edit("`Fetching data, please wait ...`")
with YoutubeDL(opts) as rip:
rip_data = rip.extract_info(url)
except DownloadError as DE:
await rkp.edit(f"`{str(DE)}`")
return
except ContentTooShortError:
await rkp.edit("`The download content was too short.`")
return
except GeoRestrictedError:
await rkp.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website.`"
)
return
except MaxDownloadsReached:
await rkp.edit("`Max-downloads limit has been reached.`")
return
except PostProcessingError:
await rkp.edit("`There was an error during post processing.`")
return
except UnavailableVideoError:
await rkp.edit("`Media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await rkp.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await rkp.edit("`There was an error during info extraction.`")
return
except Exception as e:
await rkp.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await rkp.edit(f"`Sending the song ...`")
y = await v_url.client.send_file(
v_url.chat_id,
f"{rip_data['id']}.mp3",
supports_streaming=False,
force_document=False,
allow_cache=False,
attributes=[
DocumentAttributeAudio(duration=int(rip_data['duration']),
title=str(rip_data['title']),
performer=str(rip_data['uploader']))
])
await y.forward_to(JULIASONG)
os.system("rm -rf *.mp3")
os.system("rm -rf *.webp")
from youtubesearchpython import SearchVideos, SearchPlaylists
videos = SearchVideos("NoCopyrightSounds",
offset=1,
mode="json",
max_results=20)
videosResult = videos.result()
print(videosResult)
playlists = SearchPlaylists("NoCopyrightSounds",
offset=1,
mode="json",
max_results=20)
playlistsResult = playlists.result()
print(playlistsResult)
async def youtube(msg):
if msg.get('text'):
if msg['text'].startswith('/yt '):
pesquisar = msg['text'][4:]
search = SearchVideos(pesquisar,
offset=1,
mode="dict",
max_results=10)
resultado = search.result()
#titulo = []
#link = []
dic_youtube = []
for resultado in resultado['search_result']:
titulo_captado = resultado['title']
link_captado = resultado['link']
#titulo.append(titulo_captado)
#link.append(link_captado)
dic = {'titulo': titulo_captado, 'url': link_captado}
dic_youtube.append(dic)
vids = [
'[{}] {} {}'.format(num + 1, i['titulo'], i['url'])
for num, i in enumerate(dic_youtube)
]
await bot.sendMessage(
msg['chat']['id'],
'\n'.join(vids) if vids else "Nenhum resultado foi encontrado",
'HTML',
reply_to_message_id=msg['message_id'],
disable_web_page_preview=True)
#return True
if msg['text'].startswith('youtube '):
pesquisar = msg['text'][8:]
search = SearchVideos(pesquisar,
offset=1,
mode="dict",
max_results=10)
resultado = search.result()
# titulo = []
# link = []
dic_youtube = []
for resultado in resultado['search_result']:
titulo_captado = resultado['title']
link_captado = resultado['link']
# titulo.append(titulo_captado)
# link.append(link_captado)
dic = {'titulo': titulo_captado, 'url': link_captado}
dic_youtube.append(dic)
vids = [
'[{}] {} {}'.format(num + 1, i['titulo'], i['url'])
for num, i in enumerate(dic_youtube)
]
await bot.sendMessage(
msg['chat']['id'],
'\n'.join(vids) if vids else "Nenhum resultado foi encontrado",
'HTML',
reply_to_message_id=msg['message_id'],
disable_web_page_preview=True)
#----------------------------------------------------------------------------------------------------------------------------------------------
elif msg['text'].split(
)[0] == '/ytdl': #aqui era /ytdl tirei pra nao pesar o server
text = msg['text'][6:]
if text:
sent_id = (await bot.sendMessage(
msg['chat']['id'],
'Obtendo informações do vídeo...',
'Markdown',
reply_to_message_id=msg['message_id']))['message_id']
try:
if re.match(
r'^(https?://)?(youtu\.be/|(m\.|www\.)?youtube\.com/watch\?v=).+',
text):
yt = ydl.extract_info(text, download=False)
else:
yt = ydl.extract_info('ytsearch:' + text,
download=False)['entries'][0]
for f in yt['formats']:
if f['format_id'] == '140':
fsize = f['filesize'] or 0
name = yt['title']
except Exception as e:
return await bot.editMessageText(
(msg['chat']['id'], sent_id),
'Ocorreu um erro.\n\n' + str(e))
if not fsize > 52428800:
if ' - ' in name:
performer, title = name.rsplit(' - ', 1)
else:
performer = yt.get('creator') or yt.get('uploader')
title = name
await bot.editMessageText(
(msg['chat']['id'], sent_id),
'Baixando <code>{}</code> do YouTube...\n({})'.format(
name, pretty_size(fsize)), 'HTML')
ydl.download(
['https://www.youtube.com/watch?v=' + yt['id']])
await bot.editMessageText((msg['chat']['id'], sent_id),
'Enviando áudio...')
await bot.sendChatAction(msg['chat']['id'],
'upload_document')
await bot.sendAudio(msg['chat']['id'],
open(ydl.prepare_filename(yt), 'rb'),
performer=performer,
title=title,
duration=yt['duration'],
reply_to_message_id=msg['message_id'])
os.remove(ydl.prepare_filename(yt))
await bot.deleteMessage((msg['chat']['id'], sent_id))
else:
await bot.editMessageText((
msg['chat']['id'], sent_id
), f'Ow, o arquivo resultante ({pretty_size(fsize)}) ultrapassa o meu limite de 50 MB'
)
else:
await bot.sendMessage(msg['chat']['id'],
'*Uso:* /ytdl URL do vídeo ou nome',
'Markdown',
reply_to_message_id=msg['message_id'])
return True
elif msg['text'].split()[0] == '': #aqui era ytldl gorpo tirei tb
text = msg['text'][17:]
if text:
sent_id = (await bot.sendMessage(
msg['chat']['id'],
'Obtendo informações do vídeo...',
'Markdown',
reply_to_message_id=msg['message_id']))['message_id']
try:
if re.match(
r'^(https?://)?(youtu\.be/|(m\.|www\.)?youtube\.com/watch\?v=).+',
text):
yt = ydl.extract_info(text, download=False)
else:
yt = ydl.extract_info('ytsearch:' + text,
download=False)['entries'][0]
for f in yt['formats']:
if f['format_id'] == '140':
fsize = f['filesize'] or 0
name = yt['title']
except Exception as e:
return await bot.editMessageText(
(msg['chat']['id'], sent_id),
'Ocorreu um erro.\n\n' + str(e))
if not fsize > 52428800:
if ' - ' in name:
performer, title = name.rsplit(' - ', 1)
else:
performer = yt.get('creator') or yt.get('uploader')
title = name
await bot.editMessageText(
(msg['chat']['id'], sent_id),
'Baixando <code>{}</code> do YouTube...\n({})'.format(
name, pretty_size(fsize)), 'HTML')
ydl.download(
['https://www.youtube.com/watch?v=' + yt['id']])
await bot.editMessageText((msg['chat']['id'], sent_id),
'Enviando áudio...')
await bot.sendChatAction(msg['chat']['id'],
'upload_document')
await bot.sendAudio(msg['chat']['id'],
open(ydl.prepare_filename(yt), 'rb'),
performer=performer,
title=title,
duration=yt['duration'],
reply_to_message_id=msg['message_id'])
os.remove(ydl.prepare_filename(yt))
await bot.deleteMessage((msg['chat']['id'], sent_id))
else:
await bot.editMessageText((
msg['chat']['id'], sent_id
), f'Ow, o arquivo resultante ({pretty_size(fsize)}) ultrapassa o meu limite de 50 MB'
)
else:
await bot.sendMessage(msg['chat']['id'],
'*Uso:* /ytdl URL do vídeo ou nome',
'Markdown',
reply_to_message_id=msg['message_id'])
return True
elif msg['text'].startswith('download youtube'):
text = msg['text'][17:]
if text:
sent_id = (await bot.sendMessage(
msg['chat']['id'],
'Obtendo informações do vídeo...',
'Markdown',
reply_to_message_id=msg['message_id']))['message_id']
try:
if re.match(
r'^(https?://)?(youtu\.be/|(m\.|www\.)?youtube\.com/watch\?v=).+',
text):
yt = ydl.extract_info(text, download=False)
else:
yt = ydl.extract_info('ytsearch:' + text,
download=False)['entries'][0]
for f in yt['formats']:
if f['format_id'] == '140':
fsize = f['filesize'] or 0
name = yt['title']
except Exception as e:
return await bot.editMessageText(
(msg['chat']['id'], sent_id),
'Ocorreu um erro.\n\n' + str(e))
if not fsize > 52428800:
if ' - ' in name:
performer, title = name.rsplit(' - ', 1)
else:
performer = yt.get('creator') or yt.get('uploader')
title = name
await bot.editMessageText(
(msg['chat']['id'], sent_id),
'Baixando <code>{}</code> do YouTube...\n({})'.format(
name, pretty_size(fsize)), 'HTML')
ydl.download(
['https://www.youtube.com/watch?v=' + yt['id']])
await bot.editMessageText((msg['chat']['id'], sent_id),
'Enviando áudio...')
await bot.sendChatAction(msg['chat']['id'],
'upload_document')
await bot.sendAudio(msg['chat']['id'],
open(ydl.prepare_filename(yt), 'rb'),
performer=performer,
title=title,
duration=yt['duration'],
reply_to_message_id=msg['message_id'])
os.remove(ydl.prepare_filename(yt))
await bot.deleteMessage((msg['chat']['id'], sent_id))
else:
await bot.editMessageText((
msg['chat']['id'], sent_id
), f'Ow, o arquivo resultante ({pretty_size(fsize)}) ultrapassa o meu limite de 50 MB'
)
else:
await bot.sendMessage(msg['chat']['id'],
'*Uso:* /ytdl URL do vídeo ou nome',
'Markdown',
reply_to_message_id=msg['message_id'])
return True
async def owo(client, inline_query):
string_given = inline_query.query.lower()
if string_given.startswith("not4u"):
if not ";" in string_given:
return
ok = string_given.split(" ", maxsplit=1)[1]
user, msg = ok.split(";")
fu = int(user) if user.isdigit() else user
try:
ui = await Friday.get_users(fu)
except BaseException as e:
logging.error(traceback.format_exc)
return
chars = string.hexdigits
randomc = "".join(choice(chars) for _ in range(4))
stark_data = {"secret_code": randomc, "id": ui.id, "msg": msg}
db_s.insert(stark_data)
texts = f"Everyone except {user.mention(style='md')} can read this message. \nClick below to check the message! \n**Note :** `Only He/She Can't open it!`"
ok_s = [(results.append(
title="OwO! Not For You",
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text="Show Message !",
callback_data=f"nu_{randomc}")
]]),
input_message_content=InputTextMessageContent(texts),
))]
await client.answer_inline_query(inline_query.id,
cache_time=0,
results=ok_s)
elif string_given.startswith("yt"):
results = []
try:
input = string_given.split(" ", maxsplit=1)[1]
except:
return
search = SearchVideos(str(input),
offset=1,
mode="dict",
max_results=50)
rt = search.result()
result_s = rt["search_result"]
for i in result_s:
url = i["link"]
vid_title = i["title"]
yt_id = i["id"]
uploade_r = i["channel"]
views = i["views"]
thumb = f"https://img.youtube.com/vi/{yt_id}/hqdefault.jpg"
capt = f"""
**Video Title :** `{vid_title}`
**Link :** `{url}`
**Uploader :** `{uploade_r}`
**Views :** `{views}`
"""
results.append(
InlineQueryResultPhoto(
photo_url=thumb,
title=vid_title,
caption=capt,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text="Download - Audio",
callback_data=f"ytdl_{url}_audio"),
InlineKeyboardButton(text="Download - Video",
callback_data=f"ytdl_{url}_video")
]]),
))
await client.answer_inline_query(inline_query.id,
cache_time=0,
results=results)
elif string_given.startswith("git"):
try:
input_ = string_given.split(" ", maxsplit=1)[1]
except:
return
results = []
r = requests.get("https://api.github.com/search/repositories",
params={"q": input_})
lool = r.json()
if lool.get("total_count") == 0:
return
lol = lool.get("items")
for X in lol:
qw = X
txt = f"""
<b>Name :</b> <i>{qw.get("name")}</i>
<b>Full Name :</b> <i>{qw.get("full_name")}</i>
<b>Link :</b> {qw.get("html_url")}
<b>Fork Count :</b> <i>{qw.get("forks_count")}</i>
<b>Open Issues :</b> <i>{qw.get("open_issues")}</i>
"""
if qw.get("description"):
txt += f'\n<b>Description :</b> <code>{qw.get("description")}</code>'
if qw.get("language"):
txt += f'\n<b>Language :</b> <code>{qw.get("language")}</code>'
if qw.get("size"):
txt += f'\n<b>Size :</b> <code>{qw.get("size")}</code>'
if qw.get("score"):
txt += f'\n<b>Score :</b> <code>{qw.get("score")}</code>'
if qw.get("created_at"):
txt += f'\n<b>Created At :</b> <code>{qw.get("created_at")}</code>'
if qw.get("archived") == True:
txt += f"\n<b>This Project is Archived</b>"
results.append(
InlineQueryResultArticle(
thumb_url="https://simpleicons.org/icons/github.svg",
url=qw.get("html_url"),
description=qw.get("description", "No Description"),
title=qw.get("name"),
input_message_content=InputTextMessageContent(
txt, disable_web_page_preview=True)))
await client.answer_inline_query(inline_query.id,
cache_time=0,
results=results)
elif string_given.startswith("whisper"):
if not ";" in string_given:
return
ok = string_given.split(" ", maxsplit=1)[1]
user, msg = ok.split(";")
fu = int(user) if user.isdigit() else user
try:
ui = await Friday.get_users(fu)
except BaseException as e:
logging.error(str(e))
return
owo = (f"@{ui.username}"
if ui.username else f"[{ui.first_name}](tg://user?id={ui.id})")
chars = string.hexdigits
randomc = "".join(choice(chars) for _ in range(4))
stark_data = {"secret_code": randomc, "id": ui.id, "msg": msg}
db_m.insert(stark_data)
texts = f"A Whisper Has Been Sent For {owo} . \nClick Below To Check Message! \n**Note :** `Only He/She Can Open It!`"
ok_s = [(InlineQueryResultArticle(
title="Ssh! This is A Secret Message",
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text="Show Message !",
callback_data=f"sc_{randomc}")
]]),
input_message_content=InputTextMessageContent(texts),
))]
await client.answer_inline_query(inline_query.id,
cache_time=0,
results=ok_s)
elif string_given.startswith("help"):
total_ = len(CMD_LIST)
if Config.LOAD_UNOFFICIAL_PLUGINS:
total_ = len(XTRA_CMD_LIST) + len(CMD_LIST)
nice_text = f"**FridayUserBot Commands** \n**Friday Version :** __{friday_version}__ \n**PyroGram Version :** __{__version__}__ \n**Total Plugins Loaded :** __{total_}__"
await inline_query.answer(
cache_time=0,
results=[(InlineQueryResultArticle(
title="Help Article!",
reply_markup=InlineKeyboardMarkup(HELP_BUTTONS),
input_message_content=InputTextMessageContent(nice_text),
))],
)
async def ytmusic(client, message: Message):
global is_downloading
if is_downloading:
await message.reply_text(
"Another download is in progress, try again after sometime.")
return
urlissed = get_text(message)
pablo = await client.send_message(
message.chat.id,
f"`Getting {urlissed} From Youtube Servers. Please Wait.`")
if not urlissed:
await pablo.edit(
"Invalid Command Syntax, Please Check Help Menu To Know More!")
return
search = SearchVideos(f"{urlissed}", offset=1, mode="dict", max_results=1)
mi = search.result()
mio = mi["search_result"]
mo = mio[0]["link"]
thum = mio[0]["title"]
fridayz = mio[0]["id"]
thums = mio[0]["channel"]
kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
await asyncio.sleep(0.6)
url = mo
sedlyf = wget.download(kekme)
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,
}
try:
is_downloading = True
with youtube_dl.YoutubeDL(opts) as ytdl:
infoo = ytdl.extract_info(url, False)
duration = round(infoo["duration"] / 60)
if duration > 8:
await pablo.edit(
f"❌ Videos longer than 8 minute(s) aren't allowed, the provided video is {duration} minute(s)"
)
is_downloading = False
return
ytdl_data = ytdl.extract_info(url, download=True)
except Exception as e:
#await pablo.edit(event, f"**Failed To Download** \n**Error :** `{str(e)}`")
is_downloading = False
return
c_time = time.time()
file_stark = f"{ytdl_data['id']}.mp4"
capy = f"**Video Name ➠** `{thum}` \n**Requested For :** `{urlissed}` \n**Channel :** `{thums}` \n**Link :** `{mo}`"
await client.send_video(
message.chat.id,
video=open(file_stark, "rb"),
duration=int(ytdl_data["duration"]),
file_name=str(ytdl_data["title"]),
thumb=sedlyf,
caption=capy,
supports_streaming=True,
progress=progress,
progress_args=(pablo, c_time,
f'`Uploading {urlissed} Song From YouTube Music!`',
file_stark))
await pablo.delete()
is_downloading = False
for files in (sedlyf, file_stark):
if files and os.path.exists(files):
os.remove(files)
async def download_video(v_url):
pro = v_url
sender = await pro.get_sender()
me = await pro.client.get_me()
pro1 = v_url.text
if not sender.id == me.id:
dc = await pro.reply("`processing, please weit...`")
else:
dc = await pro.edit("`processing, please weit...😍`")
teamcobra = pro1[8:]
if not teamcobra:
return await dc.edit("`Error \nusage vsong <song name>`")
search = SearchVideos(teamcobra, offset=1, mode="json", max_results=1)
test = search.result()
p = json.loads(test)
q = p.get('search_result')
try:
teamcobra = q[0]['link']
except:
return await dc.edit("`failed to find your desired song`")
type = "audio"
await dc.edit("`Ok downloading your song🤓...`")
if type == "audio":
opts = {
'format':
'best',
'addmetadata':
True,
'key':
'FFmpegMetadata',
'prefer_ffmpeg':
True,
'geo_bypass':
True,
'nocheckcertificate':
True,
'postprocessors': [{
'key': 'FFmpegVideoConvertor',
'preferedformat': 'mp4'
}],
'outtmpl':
'%(id)s.mp4',
'logtostderr':
False,
'quiet':
True
}
song = False
video = True
try:
await dc.edit("`Fetching data, please wait..😋😍😎`")
with YoutubeDL(opts) as darkcobra:
darkcobra_data = darkcobra.extract_info(teamcobra)
except DownloadError as error:
await dc.edit(f"`{str(error)}`")
return
except ContentTooShortError:
await dc.edit("`Oof the download content was too short😮🤐.`")
return
except GeoRestrictedError:
await dc.edit(
"`Video is not available from your geographic location due to geographic restrictions imposed by a website🤔.`"
)
return
except MaxDownloadsReached:
await dc.edit("`Max-downloads limit has been reached😶.`")
return
except PostProcessingError:
await dc.edit("`There was an error during post processing😐.`")
return
except UnavailableVideoError:
await dc.edit(
"`sorry, media is not available in the requested format.`")
return
except XAttrMetadataError as XAME:
await dc.edit(f"`{XAME.code}: {XAME.msg}\n{XAME.reason}`")
return
except ExtractorError:
await dc.edit("`There was an error while fetching your query...`")
return
except Exception as e:
await dc.edit(f"{str(type(e)): {str(e)}}")
return
c_time = time.time()
if song:
await dc.edit(f"`Preparing to upload your video song😎 `\
\n**{darkcobra_data['title']}**\
\nby *{darkcobra_data['uploader']}*")
await v_url.client.send_file(
v_url.chat_id,
f"{darkcobra_data['id']}.mp3",
supports_streaming=True,
attributes=[
DocumentAttributeAudio(
duration=int(darkcobra_data['duration']),
title=str(darkcobra_data['title']),
performer=str(darkcobra_data['uploader']))
],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, v_url, c_time, "Uploading your video song😍..",
f"{darkcobra_data['title']}.mp3")))
os.remove(f"{darkcobra_data['id']}.mp3")
await v_url.delete()
elif video:
await dc.edit(f"`Preparing to upload your video song🤗❤ :`\
\n**{darkcobra_data['title']}**\
\nby *{darkcobra_data['uploader']}*")
await v_url.client.send_file(
v_url.chat_id,
f"{darkcobra_data['id']}.mp4",
supports_streaming=True,
caption=darkcobra_data['title'],
progress_callback=lambda d, t: asyncio.get_event_loop(
).create_task(
progress(d, t, v_url, c_time, "Uploading..",
f"{darkcobra_data['title']}.mp4")))
os.remove(f"{darkcobra_data['id']}.mp4")
await dc.delete()
query = query.replace("wikipedia", "")
print(query)
results = wikipedia.summary(query, sentences=2)
speak("According to Wikipedia")
print(results)
speak(results)
elif "open youtube" in query:
webbrowser.open("youtube.com")
elif "open stackoverflow" in query:
webbrowser.open("stackoverflow.com")
elif "play" and "in youtube" in query:
speak("Please Wait")
query = query.replace("in youtube", "")
print(query)
search1 = SearchVideos(query, offset=1, mode="json", max_results=5)
results = search1.result()
results = json.loads(results)
link = results["search_result"][0]["link"]
webbrowser.open(link)
elif "open google" in query:
webbrowser.open("google.com")
elif 'the time' in query:
strTime = datetime.datetime.now().strftime("%H:%M:%S")
speak(f"Sir, the time is {strTime}")
elif "mail" in query:
try:
speak("Please tell me the receipent")
to = takeCommand()
speak("What should I write in mail?")
content = takeCommand()
sendEmail(to, content)
async def _(event):
if event.fwd_from:
return
urlissed = event.pattern_match.group(1)
myself_stark = await edit_or_reply(
event, f"`Getting {urlissed} From Youtube Servers. Please Wait.`")
search = SearchVideos(f"{urlissed}", offset=1, mode="dict", max_results=1)
mi = search.result()
mio = mi["search_result"]
mo = mio[0]["link"]
thum = mio[0]["title"]
fridayz = mio[0]["id"]
thums = mio[0]["channel"]
kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
await asyncio.sleep(0.6)
if not os.path.isdir("./music/"):
os.makedirs("./music/")
path = Config.TMP_DOWNLOAD_DIRECTORY
url = mo
sedlyf = wget.download(kekme, out=path)
opts = {
"format":
"bestaudio",
"addmetadata":
True,
"key":
"FFmpegMetadata",
"writethumbnail":
True,
"prefer_ffmpeg":
True,
"geo_bypass":
True,
"nocheckcertificate":
True,
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "mp3",
"preferredquality": "480",
}],
"outtmpl":
"%(title)s.mp3",
"quiet":
True,
"logtostderr":
False,
}
try:
with YoutubeDL(opts) as ytdl:
ytdl_data = ytdl.extract_info(url)
except Exception as e:
await event.edit(f"**Failed To Download** \n**Error :** `{str(e)}`")
return
await asyncio.sleep(20)
c_time = time.time()
file_stark = f"{ytdl_data['title']}.mp3"
lol_m = await upload_file(
file_name=file_stark,
client=borg,
file=open(file_stark, "rb"),
progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
progress(d, t, event, c_time, "Uploading Your Song!", file_stark)),
)
capy = f"**Song Name ➠** `{thum}` \n**Requested For ➠** `{urlissed}` \n**Channel ➠** `{thums}` \n**Link ➠** `{mo}`"
await event.delete()
await borg.send_file(
event.chat_id,
lol_m,
force_document=False,
allow_cache=False,
caption=capy,
thumb=sedlyf,
attributes=[
DocumentAttributeAudio(
duration=int(ytdl_data["duration"]),
title=str(ytdl_data["title"]),
performer=str(ytdl_data["uploader"]),
)
],
supports_streaming=True,
)
for files in (sedlyf, file_stark):
if files and os.path.exists(files):
os.remove(files)
async def ytmusic(client, message: Message):
urlissed = get_text(message)
if not urlissed:
await client.send_message(
message.chat.id,
"Invalid Command Syntax, Please Check Help Menu To Know More!",
)
return
pablo = await client.send_message(
message.chat.id,
f"`Getting {urlissed} From Youtube Servers. Please Wait.`")
search = SearchVideos(f"{urlissed}", offset=1, mode="dict", max_results=1)
mi = search.result()
mio = mi["search_result"]
mo = mio[0]["link"]
mio[0]["duration"]
thum = mio[0]["title"]
fridayz = mio[0]["id"]
thums = mio[0]["channel"]
kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
await asyncio.sleep(0.6)
sedlyf = wget.download(kekme)
opts = {
"format":
"bestaudio",
"addmetadata":
True,
"key":
"FFmpegMetadata",
"writethumbnail":
True,
"prefer_ffmpeg":
True,
"geo_bypass":
True,
"nocheckcertificate":
True,
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "mp3",
"preferredquality": "720",
}],
"outtmpl":
"%(id)s.mp3",
"quiet":
True,
"logtostderr":
False,
}
try:
with YoutubeDL(opts) as ytdl:
ytdl_data = ytdl.extract_info(mo, download=True)
except Exception as e:
await pablo.edit(f"**Failed To Download** \n**Error :** `{str(e)}`")
return
c_time = time.time()
capy = f"**🎼 Uploaded by ➠ 𝙉𝙪𝙧𝙖 𝙙𝙖𝙧𝙡𝙞𝙣𝙜 🖤**"
file_stark = f"{ytdl_data['id']}.mp3"
await client.send_audio(
message.chat.id,
audio=open(file_stark, "rb"),
duration=int(ytdl_data["duration"]),
title=str(ytdl_data["title"]),
performer=str(ytdl_data["uploader"]),
thumb=sedlyf,
caption=capy,
progress=progress,
progress_args=(
pablo,
c_time,
f"`Uploading {urlissed} Song From YouTube Music!`",
file_stark,
),
)
await pablo.delete()
for files in (sedlyf, file_stark):
if files and os.path.exists(files):
os.remove(files)
async def ytmusic(client, message: Message):
global is_downloading
if is_downloading:
await message.reply_text(
"Unduhan yang lain sedang berlangsung, coba lagi nanti.")
return
urlissed = get_text(message)
pablo = await client.send_message(
message.chat.id,
f"`Mendownload {urlissed} dari youtube, tunggu sebentar!`")
if not urlissed:
await pablo.edit(
"Sintax, Perintah tidak valid. Silahkan periksa menu help untuk mengetahui lebih lanjut!"
)
return
search = SearchVideos(f"{urlissed}", offset=1, mode="dict", max_results=1)
mi = search.result()
mio = mi["search_result"]
mo = mio[0]["link"]
thum = mio[0]["title"]
fridayz = mio[0]["id"]
thums = mio[0]["channel"]
kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
await asyncio.sleep(0.6)
url = mo
sedlyf = wget.download(kekme)
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,
}
try:
is_downloading = True
with youtube_dl.YoutubeDL(opts) as ytdl:
infoo = ytdl.extract_info(url, False)
duration = round(infoo["duration"] / 60)
if duration > 8:
await pablo.edit(
f"❌ Video berdurasi lebih dari 8 menit tidak diperbolehkan, video yang diperbolehkan berdurasi {duration} minute(s)"
)
is_downloading = False
return
ytdl_data = ytdl.extract_info(url, download=True)
except Exception as e:
#await pablo.edit(event, f"**Gagal mengunduh** \n**Terjadi kesalahan :** `{str(e)}`")
is_downloading = False
return
c_time = time.time()
file_stark = f"{ytdl_data['id']}.mp4"
capy = f"**Judul video :** `{thum}` \n**Requested For :** `{urlissed}` \n**Channel :** `{thums}` \n**Link :** `{mo}`"
await client.send_video(
message.chat.id,
video=open(file_stark, "rb"),
duration=int(ytdl_data["duration"]),
file_name=str(ytdl_data["title"]),
thumb=sedlyf,
caption=capy,
supports_streaming=True,
progress=progress,
progress_args=(pablo, c_time,
f'`Uploading {urlissed}.. Song from YouTube Music!`',
file_stark))
await pablo.delete()
is_downloading = False
for files in (sedlyf, file_stark):
if files and os.path.exists(files):
os.remove(files)
