managementbot / Powers /utils /web_helpers.py
Captain Ezio
...
aee3bb4
raw
history blame
7.8 kB
import json
import os
from urllib import parse
import yt_dlp
from pyrogram.types import InlineKeyboardButton as IKB
from pyrogram.types import InlineKeyboardMarkup as IKM
from pyrogram.types import Message
from Powers.bot_class import Gojo
from Powers.utils.http_helper import *
async def get_file_size(file: Message):
if file.photo:
size = file.photo.file_size/1024
elif file.document:
size = file.document.file_size/1024
elif file.video:
size = file.video.file_size/1024
elif file.audio:
size = file.audio.file_size/1024
elif file.sticker:
size = file.sticker.file_size/1024
if size <= 1024:
return f"{round(size)} kb"
elif size > 1024:
size = size/1024
if size <= 1024:
return f"{round(size)} mb"
elif size > 1024:
size = size/1024
return f"{round(size)} gb"
class GOJO_YTS:
"""
A class to fetch link of from youtube using the name provided
Creadit: Hellbot
"""
def __init__(self, search_terms: str, max_results=None):
self.search_terms = search_terms
self.max_results = max_results
self.videos = self._search()
def _search(self):
encoded_search = parse.quote_plus(self.search_terms)
BASE_URL = "https://youtube.com"
url = f"{BASE_URL}/results?search_query={encoded_search}"
response = requests.get(url).text
while "ytInitialData" not in response:
response = requests.get(url).text
results = self._parse_html(response)
if self.max_results is not None and len(results) > self.max_results:
return results[: self.max_results]
return results
def _parse_html(self, response):
results = []
start = response.index("ytInitialData") + len("ytInitialData") + 3
end = response.index("};", start) + 1
json_str = response[start:end]
data = json.loads(json_str)
videos = data["contents"]["twoColumnSearchResultsRenderer"]["primaryContents"][
"sectionListRenderer"
]["contents"][0]["itemSectionRenderer"]["contents"]
for video in videos:
res = {}
if "videoRenderer" in video.keys():
video_data = video.get("videoRenderer", {})
res["id"] = video_data.get("videoId", None)
res["thumbnails"] = [
thumb.get("url", None)
for thumb in video_data.get("thumbnail", {}).get("thumbnails", [{}])
]
res["title"] = (
video_data.get("title", {}).get("runs", [[{}]])[0].get("text", None)
)
res["long_desc"] = (
video_data.get("descriptionSnippet", {})
.get("runs", [{}])[0]
.get("text", None)
)
res["channel"] = (
video_data.get("longBylineText", {})
.get("runs", [[{}]])[0]
.get("text", None)
)
res["duration"] = video_data.get("lengthText", {}).get("simpleText", 0)
res["views"] = video_data.get("viewCountText", {}).get("simpleText", 0)
res["publish_time"] = video_data.get("publishedTimeText", {}).get(
"simpleText", 0
)
res["url_suffix"] = (
video_data.get("navigationEndpoint", {})
.get("commandMetadata", {})
.get("webCommandMetadata", {})
.get("url", None)
)
results.append(res)
return results
def to_dict(self, clear_cache=True):
result = self.videos
if clear_cache:
self.videos = ""
return result
def to_json(self, clear_cache=True):
result = json.dumps({"videos": self.videos})
if clear_cache:
self.videos = ""
return result
# Gets yt result of given query.
async def song_search(query, max_results=1):
try:
results = json.loads(GOJO_YTS(query, max_results=max_results).to_json())
except KeyError:
return
yt_dict = {}
nums = 1
for i in results["videos"]:
durr = i['duration'].split(":")
if len(durr) == 3:
hour_to_sec = int(durr[0])*60*60
minutes_to_sec = int(durr[1])*60
total = hour_to_sec + minutes_to_sec + int(durr[2])
if len(durr) == 2:
minutes_to_sec = int(durr[0])*60
total = minutes_to_sec + int(durr[1])
if not (total > 600):
dict_form = {
"link": f"https://www.youtube.com{i['url_suffix']}",
"title": i['title'],
"views": i['views'],
"channel": i['channel'],
"duration": i['duration'],
"thumbnail": i['thumbnails'][0]
}
yt_dict.update({nums: dict_form})
nums += 1
else:
pass
return yt_dict
song_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": "%(id)s.mp3",
"quiet": True,
"logtostderr": False,
}
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,
}
async def youtube_downloader(c:Gojo,m:Message,query:str,is_direct:bool,type_:str):
if type_ == "a":
opts = song_opts
video = False
song = True
elif type_ == "v":
opts = video_opts
video = True
song = False
ydl = yt_dlp.YoutubeDL(opts)
if is_direct:
query = query
else:
dicti = await song_search(query, 1)
if not dicti:
await m.reply_text("File with duration less than or equals to 5 minutes is allowed only")
try:
query = dicti[1]['link']
except KeyError:
z = "KeyError"
return z
FILE = ydl.extract_info(query,download=video)
if int(FILE['duration']) > 600:
await m.reply_text("File with duration less than or equals to 5 minutes is allowed only")
return
f_name = FILE['title']
uploader = FILE['uploader']
up_url = FILE['uploader_url']
views = FILE['view_count']
url = query
if song:
f_down = ydl.prepare_filename(FILE)
f_path = f"{f_down}.mp3"
thumb = f"{f_down}.webp"
ydl.download([query])
elif video:
f_path = open(f"{FILE['id']}.mp4","rb")
cap = f"""
✘ Name: `{f_name}`
✘ Views: `{views}`
"""
kb = IKM(
[
[
IKB(f"✘ {uploader.capitalize()} ✘",url=f"{up_url}"),
IKB(f"✘ Youtube url ✘", url=f"{url}")
]
]
)
if video:
await m.reply_video(f_path,caption=cap,reply_markup=kb,duration=int(FILE['duration']))
os.remove(f"./{FILE['id']}.mp4")
return
elif song:
await m.reply_audio(f_path,caption=cap,reply_markup=kb,duration=int(FILE['duration']),thumb=thumb,title=f_name)
os.remove(f_path)
os.remove(thumb)
return