refactor(youtube): integrate yt-dlp and remove OWNERR_ID

DragMusic/platforms/Youtube.py

@@ -6,7 +6,6 @@ from typing import Union
 import yt_dlp
 from pyrogram.enums import MessageEntityType
 from pyrogram.types import Message
-from youtubesearchpython.__future__ import VideosSearch
 
 from DragMusic.utils.database import is_on_off
 from DragMusic.utils.formatters import time_to_seconds
@@ -30,324 +29,132 @@ async def shell_cmd(cmd):
 class YouTubeAPI:
     def __init__(self):
         self.base = "https://www.youtube.com/watch?v="
-        self.regex = r"(?:youtube\.com|youtu\.be)"
-        self.status = "https://www.youtube.com/oembed?url="
-        self.listbase = "https://youtube.com/playlist?list="
-        self.reg = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
-
-    async def exists(self, link: str, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.base + link
-        if re.search(self.regex, link):
-            return True
-        else:
-            return False
-
-    async def url(self, message_1: Message) -> Union[str, None]:
-        messages = [message_1]
-        if message_1.reply_to_message:
-            messages.append(message_1.reply_to_message)
-        text = ""
-        offset = None
-        length = None
-        for message in messages:
-            if offset:
-                break
-            if message.entities:
-                for entity in message.entities:
-                    if entity.type == MessageEntityType.URL:
-                        text = message.text or message.caption
-                        offset, length = entity.offset, entity.length
-                        break
-            elif message.caption_entities:
-                for entity in message.caption_entities:
-                    if entity.type == MessageEntityType.TEXT_LINK:
-                        return entity.url
-        if offset in (None,):
-            return None
-        return text[offset : offset + length]
-
-    async def details(self, link: str, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        results = VideosSearch(link, limit=1)
-        for result in (await results.next())["result"]:
-            title = result["title"]
-            duration_min = result["duration"]
-            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
-            vidid = result["id"]
-            if str(duration_min) == "None":
-                duration_sec = 0
-            else:
-                duration_sec = int(time_to_seconds(duration_min))
+        self.opts = {"nocheckcertificate": True, "quiet": True, "no_warnings": True}
+
+    async def get_info(self, link: str):
+        """Fetches all video information using yt-dlp."""
+        full_url = self.base + link if not link.startswith("http") else link
+        with yt_dlp.YoutubeDL(self.opts) as ydl:
+            info = ydl.extract_info(full_url, download=False)
+        return info
+
+    async def details(self, link: str):
+        """Gets essential video details."""
+        info = await self.get_info(link)
+        title = info.get("title", "Unknown Title")
+        duration_min = info.get("duration_string", "0:00")
+        duration_sec = info.get("duration", 0)
+        thumbnail = info.get("thumbnail", "")
+        vidid = info.get("id", "")
         return title, duration_min, duration_sec, thumbnail, vidid
 
-    async def title(self, link: str, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        results = VideosSearch(link, limit=1)
-        for result in (await results.next())["result"]:
-            title = result["title"]
-        return title
-
-    async def duration(self, link: str, videoid: Union[bool, str] = None):
+    async def url(self, message: "Message") -> Union[str, None]:
+        """Extracts a URL from a Pyrogram message."""
+        for entity in message.entities or message.caption_entities or []:
+            if entity.type in ["url", "text_link"]:
+                return entity.url or message.text[entity.offset:entity.offset + entity.length]
+        return None
+
+    async def title(self, link: str):
+        info = await self.get_info(link)
+        return info.get("title", "Unknown Title")
+
+    async def duration(self, link: str):
+        info = await self.get_info(link)
+        return info.get("duration_string", "0:00")
+
+    async def thumbnail(self, link: str):
+        info = await self.get_info(link)
+        return info.get("thumbnail", "")
+
+    async def get_best_audio_url(self, link: str):
+        """Gets the URL of the best quality audio stream."""
+        info = await self.get_info(link)
+        best_audio = None
+        for f in info.get("formats", []):
+            if f.get("acodec") != "none" and f.get("vcodec") == "none":
+                if best_audio is None or f.get("abr", 0) > best_audio.get("abr", 0):
+                    best_audio = f
+        return best_audio["url"] if best_audio else None
+
+    async def get_best_video_url(self, link: str, quality: str = "720"):
+        """Gets the URL of the best video stream for a given quality."""
+        info = await self.get_info(link)
+        best_video = None
+        for f in info.get("formats", []):
+            if f.get("height") and f.get("height") <= int(quality) and f.get("vcodec") != "none":
+                 if best_video is None or f.get("height") > best_video.get("height"):
+                     best_video = f
+        return best_video["url"] if best_video else None
+
+
+    async def playlist(self, link: str, limit: int, user_id, videoid: bool = False):
+        """Fetches video IDs from a playlist."""
         if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        results = VideosSearch(link, limit=1)
-        for result in (await results.next())["result"]:
-            duration = result["duration"]
-        return duration
-
-    async def thumbnail(self, link: str, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        results = VideosSearch(link, limit=1)
-        for result in (await results.next())["result"]:
-            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
-        return thumbnail
-
-    async def video(self, link: str, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        proc = await asyncio.create_subprocess_exec(
-            "yt-dlp",
-            "--cookies",
-            "cookies.txt",
-            "-g",
-            "-f",
-            "best[height<=?720][width<=?1280]",
-            f"{link}",
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout, stderr = await proc.communicate()
-        if stdout:
-            return 1, stdout.decode().split("\n")[0]
-        else:
-            return 0, stderr.decode()
-
-    async def playlist(self, link, limit, user_id, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.listbase + link
-        if "&" in link:
-            link = link.split("&")[0]
-        playlist = await shell_cmd(
-            f"yt-dlp --cookies cookies.txt -i --get-id --flat-playlist --playlist-end {limit} --skip-download {link}"
-        )
-        try:
-            result = playlist.split("\n")
-            for key in result:
-                if key == "":
-                    result.remove(key)
-        except:
-            result = []
-        return result
-
-    async def track(self, link: str, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        results = VideosSearch(link, limit=1)
-        for result in (await results.next())["result"]:
-            title = result["title"]
-            duration_min = result["duration"]
-            vidid = result["id"]
-            yturl = result["link"]
-            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+            link = f"https://www.youtube.com/playlist?list={link}"
+        
+        playlist_opts = self.opts.copy()
+        playlist_opts["extract_flat"] = "in_playlist"
+        playlist_opts["playlistend"] = limit
+        
+        with yt_dlp.YoutubeDL(playlist_opts) as ydl:
+            info = ydl.extract_info(link, download=False)
+            return [entry["id"] for entry in info.get("entries", []) if entry]
+
+    async def track(self, link: str):
+        """Gets track details for a single video."""
+        info = await self.get_info(link)
         track_details = {
-            "title": title,
-            "link": yturl,
-            "vidid": vidid,
-            "duration_min": duration_min,
-            "thumb": thumbnail,
+            "title": info.get("title", "Unknown Title"),
+            "link": info.get("webpage_url", ""),
+            "vidid": info.get("id", ""),
+            "duration_min": info.get("duration_string", "0:00"),
+            "thumb": info.get("thumbnail", ""),
         }
-        return track_details, vidid
-
-    async def formats(self, link: str, videoid: Union[bool, str] = None):
-        if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        ytdl_opts = {"cookiefile": "cookies.txt", "quiet": True}
-        ydl = yt_dlp.YoutubeDL(ytdl_opts)
-        with ydl:
-            formats_available = []
-            r = ydl.extract_info(link, download=False)
-            for format in r["formats"]:
-                try:
-                    str(format["format"])
-                except:
-                    continue
-                if not "dash" in str(format["format"]).lower():
-                    try:
-                        format["format"]
-                        format["filesize"]
-                        format["format_id"]
-                        format["ext"]
-                        format["format_note"]
-                    except:
-                        continue
-                    formats_available.append(
-                        {
-                            "format": format["format"],
-                            "filesize": format["filesize"],
-                            "format_id": format["format_id"],
-                            "ext": format["ext"],
-                            "format_note": format["format_note"],
-                            "yturl": link,
-                        }
-                    )
-        return formats_available, link
-
-    async def slider(
-        self,
-        link: str,
-        query_type: int,
-        videoid: Union[bool, str] = None,
-    ):
-        if videoid:
-            link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        a = VideosSearch(link, limit=10)
-        result = (await a.next()).get("result")
-        title = result[query_type]["title"]
-        duration_min = result[query_type]["duration"]
-        vidid = result[query_type]["id"]
-        thumbnail = result[query_type]["thumbnails"][0]["url"].split("?")[0]
-        return title, duration_min, thumbnail, vidid
-
-    async def download(
-        self,
-        link: str,
-        mystic,
-        video: Union[bool, str] = None,
-        videoid: Union[bool, str] = None,
-        songaudio: Union[bool, str] = None,
-        songvideo: Union[bool, str] = None,
-        format_id: Union[bool, str] = None,
-        title: Union[bool, str] = None,
-    ) -> str:
-        if videoid:
-            link = self.base + link
-        loop = asyncio.get_running_loop()
-
-        def audio_dl():
-            ydl_optssx = {
-                "cookiefile": "cookies.txt",
-                "format": "bestaudio/best",
-                "outtmpl": "downloads/%(id)s.%(ext)s",
-                "geo_bypass": True,
-                "nocheckcertificate": True,
-                "quiet": True,
-                "no_warnings": True,
-            }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            info = x.extract_info(link, False)
-            xyz = os.path.join("downloads", f"{info['id']}.{info['ext']}")
-            if os.path.exists(xyz):
-                return xyz
-            x.download([link])
-            return xyz
-
-        def video_dl():
-            ydl_optssx = {
-                "format": "(bestvideo[height<=?720][width<=?1280][ext=mp4])+(bestaudio[ext=m4a])",
-                "outtmpl": "downloads/%(id)s.%(ext)s",
-                "geo_bypass": True,
-                "nocheckcertificate": True,
-                "quiet": True,
-                "no_warnings": True,
-            }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            info = x.extract_info(link, False)
-            xyz = os.path.join("downloads", f"{info['id']}.{info['ext']}")
-            if os.path.exists(xyz):
-                return xyz
-            x.download([link])
-            return xyz
-
-        def song_video_dl():
-            formats = f"{format_id}+140"
-            fpath = f"downloads/{title}"
-            ydl_optssx = {
-                "cookiefile": "cookies.txt",
-                "format": formats,
-                "outtmpl": fpath,
-                "geo_bypass": True,
-                "nocheckcertificate": True,
-                "quiet": True,
-                "no_warnings": True,
-                "prefer_ffmpeg": True,
-                "merge_output_format": "mp4",
-            }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            x.download([link])
-
-        def song_audio_dl():
-            fpath = f"downloads/{title}.%(ext)s"
-            ydl_optssx = {
-                "cookiefile": "cookies.txt",
-                "format": format_id,
-                "outtmpl": fpath,
-                "geo_bypass": True,
-                "nocheckcertificate": True,
-                "quiet": True,
-                "no_warnings": True,
-                "prefer_ffmpeg": True,
-                "postprocessors": [
-                    {
-                        "key": "FFmpegExtractAudio",
-                        "preferredcodec": "mp3",
-                        "preferredquality": "192",
-                    }
-                ],
-            }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            x.download([link])
-
-        if songvideo:
-            await loop.run_in_executor(None, song_video_dl)
-            fpath = f"downloads/{title}.mp4"
-            return fpath
-        elif songaudio:
-            await loop.run_in_executor(None, song_audio_dl)
-            fpath = f"downloads/{title}.mp3"
-            return fpath
-        elif video:
-            if await is_on_off(1):
-                direct = True
-                downloaded_file = await loop.run_in_executor(None, video_dl)
-            else:
-                proc = await asyncio.create_subprocess_exec(
-                    "yt-dlp",
-                    "--cookies",
-                    "cookies.txt",
-                    "-g",
-                    "-f",
-                    "best[height<=?720][width<=?1280]",
-                    f"{link}",
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                )
-                stdout, stderr = await proc.communicate()
-                if stdout:
-                    downloaded_file = stdout.decode().split("\n")[0]
-                    direct = None
-                else:
-                    return
-        else:
-            direct = True
-            downloaded_file = await loop.run_in_executor(None, audio_dl)
-        return downloaded_file, direct
+        return track_details, info.get("id", "")
+
+    async def formats(self, link: str):
+        """Gets available formats for a video."""
+        info = await self.get_info(link)
+        formats_available = []
+        for f in info.get("formats", []):
+            if not "dash" in str(f.get("format_note", "")).lower():
+                 formats_available.append({
+                     "format": f.get("format", ""),
+                     "filesize": f.get("filesize"),
+                     "format_id": f.get("format_id", ""),
+                     "ext": f.get("ext", ""),
+                     "format_note": f.get("format_note", ""),
+                     "yturl": info.get("webpage_url", ""),
+                 })
+        return formats_available, info.get("webpage_url", "")
+    
+    async def download(self, link: str, mystic, video: bool = None, format_id: str = None) -> Union[str, None]:
+        """Downloads a video or audio file and returns the path."""
+        file_path = f"downloads/{link}.%(ext)s"
+        
+        dl_opts = self.opts.copy()
+        dl_opts["outtmpl"] = file_path
+
+        if video:
+            dl_opts["format"] = format_id if format_id else "best[height<=?720][width<=?1280]/best"
+        else: # audio
+            dl_opts["format"] = "bestaudio/best"
+            dl_opts["postprocessors"] = [{
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": "192",
+            }]
+        
+        try:
+            with yt_dlp.YoutubeDL(dl_opts) as ydl:
+                ydl.download([link])
+            
+            # Find the downloaded file since the extension is dynamic
+            for file in os.listdir("downloads"):
+                if link in file:
+                    return os.path.join("downloads", file)
+            return None
+        except Exception as e:
+            print(str(e))
+            return None

DragMusic/plugins/bot/mustjoin.py

@@ -21,12 +21,12 @@ async def must_join_channel(app: Client, msg: Message):
                 chat_info = await app.get_chat(MUST_JOIN)
                 link = chat_info.invite_link
             try:
-                await msg.reply_text(f"❅ ʜᴇʏ ᴛʜᴇʀᴇ, ɴɪᴄᴇ ᴛᴏ ᴍᴇᴇᴛ ᴜʜʜ !\n\n❅ ɪғ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴜsᴇ ˹ʙᴜɢ ✘ ϻʊsɪx ˼, ᴛʜᴇɴ ᴄʟɪᴄᴋ ᴏɴ ᴛʜᴇ ʙᴇʟᴏᴡ ʙᴜᴛᴛᴏɴ ᴀɴᴅ ʏᴏᴜ ᴊᴏɪɴᴇᴅ, ᴛʜᴇɴ ʏᴏᴜ ᴄᴀɴ ᴜsᴇ ᴀʟʟ ᴍʏ ᴄᴏᴍᴍᴀɴᴅs ",
+                await msg.reply_text(f"❅ ʜᴇʏ ᴛʜᴇʀᴇ, ɴɪᴄᴇ ᴛᴏ ᴍᴇᴇᴛ ᴜʜʜ !\n\n❅ ɪғ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴜsᴇ ˹˼, ᴛʜᴇɴ ᴄʟɪᴄᴋ ᴏɴ ᴛʜᴇ ʙᴇʟᴏᴡ ʙᴜᴛᴛᴏɴ ᴀɴᴅ ʏᴏᴜ ᴊᴏɪɴᴇᴅ, ᴛʜᴇɴ ʏᴏᴜ ᴄᴀɴ ᴜsᴇ ᴀʟʟ ᴍʏ ᴄᴏᴍᴍᴀɴᴅs ",
                     reply_markup=InlineKeyboardMarkup(
                         [
                             [
-                                InlineKeyboardButton("ᴜᴘᴅᴀᴛᴇ", url="https://t.me/haatsoja"),
-                                InlineKeyboardButton("sᴜᴘᴘᴏʀᴛ", url="https://t.me/dragbackup"),
+                                InlineKeyboardButton("ᴜᴘᴅᴀᴛᴇ", url="https://t.me/draagbots"),
+                                InlineKeyboardButton("sᴜᴘᴘᴏʀᴛ", url="https://t.me/dragbotsupport"),
                             ]
                         ]
                     )

DragMusic/plugins/bot/start.py

@@ -20,7 +20,7 @@ from DragMusic.utils.database import (
 from DragMusic.utils.decorators.language import LanguageStart
 from DragMusic.utils.formatters import get_readable_time
 from DragMusic.utils.inline import help_pannel, private_panel, start_panel
-from config import BANNED_USERS, OWNER_ID, OWNERR_ID
+from config import BANNED_USERS, OWNER_ID
 from strings import get_string
 
 
@@ -50,9 +50,6 @@ async def start_pm(client, message: Message, _):
         name = message.text.split(None, 1)[1]
         if name.startswith("help"):
             keyboard = help_pannel(_)
-            keyboard.inline_keyboard.append([
-                InlineKeyboardButton("👑 Owner", url=f"tg://user?id={OWNERR_ID}")
-            ])
             await message.reply_text(
                 text=(
                     f"<b>ʏᴏᴏ {message.from_user.mention}, <a href='https://files.catbox.moe/w8m75t.jpg' target='_blank'>🫧</a></b>\n\n"
@@ -117,9 +114,6 @@ async def start_pm(client, message: Message, _):
                 return
     else:
         out = private_panel(_)
-        out.append([
-            InlineKeyboardButton("👑 Owner", url=f"tg://user?id={OWNERR_ID}")
-        ])
         await message.reply_text(
             text=(
                  f"<b>ʏᴏᴏ {message.from_user.mention}, <a href='https://files.catbox.moe/w8m75t.jpg' target='_blank'>🫧</a></b>\n\n"

config.py

@@ -30,7 +30,7 @@ LOGGER_ID = int(getenv("LOGGER_ID", ))
 
 # Get this value from @FallenxBot on Telegram by /id
 OWNER_ID = int(getenv("OWNER_ID", ))
-OWNERR_ID = 7361622601
+
 ## Fill these variables if you're deploying on heroku.
 # Your heroku app name
 HEROKU_APP_NAME = getenv("HEROKU_APP_NAME")

requirements.txt

@@ -30,7 +30,7 @@ lyricsgenius
 spotipy
 SafoneAPI
 youtube_search
-youtube-search-python
+youtube-search-python==1.6.6
 googlesearch-python
 unidecode
 #git+https://github.com/joetats/youtube_search@master