Update DragMusic/platforms/Youtube.py

DragMusic/platforms/Youtube.py

@@ -1,126 +1,37 @@
+
+# All rights reserved.
+#
 import asyncio
 import os
+import random
 import re
-import json
-from typing import Union
-import requests
-import yt_dlp
+
+from async_lru import alru_cache
+from py_yt import VideosSearch
 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
-import os
-import glob
-import random
-import logging
-import aiohttp
+from yt_dlp import YoutubeDL
+
 import config
-from config import API_URL, API_KEY
-
-
-def cookie_txt_file():
-    cookie_dir = f"{os.getcwd()}/cookies"
-    cookies_files = [f for f in os.listdir(cookie_dir) if f.endswith(".txt")]
-
-    cookie_file = os.path.join(cookie_dir, random.choice(cookies_files))
-    return cookie_file
-
-
-async def download_song(link: str):
-    video_id = link.split('v=')[-1].split('&')[0]
-
-    download_folder = "/tmp/downloads"
-    for ext in ["mp3", "m4a", "webm"]:
-        file_path = f"{download_folder}/{video_id}.{ext}"
-        if os.path.exists(file_path):
-            #print(f"File already exists: {file_path}")
-            return file_path
-        
-    song_url = f"{API_URL}/song/{video_id}?api={API_KEY}"
-    async with aiohttp.ClientSession() as session:
-        while True:
-            try:
-                async with session.get(song_url) as response:
-                    if response.status != 200:
-                        raise Exception(f"API request failed with status code {response.status}")
-                    data = await response.json()
-                    status = data.get("status", "").lower()
-                    if status == "downloading":
-                        await asyncio.sleep(2)
-                        continue
-                    elif status == "error":
-                        error_msg = data.get("error") or data.get("message") or "Unknown error"
-                        raise Exception(f"API error: {error_msg}")
-                    elif status == "done":
-                        download_url = data.get("link")
-                        if not download_url:
-                            raise Exception("API response did not provide a download URL.")
-                        break
-                    else:
-                        raise Exception(f"Unexpected status '{status}' from API.")
-            except Exception as e:
-                print(f"Error while checking API status: {e}")
-                return None
+from VenomX.utils.database import is_on_off
+from VenomX.utils.decorators import asyncify
+from VenomX.utils.formatters import seconds_to_min, time_to_seconds
 
-        try:
-            file_format = data.get("format", "mp3")
-            file_extension = file_format.lower()
-            file_name = f"{video_id}.{file_extension}"
-            download_folder = "/tmp/downloads"
-            os.makedirs(download_folder, exist_ok=True)
-            file_path = os.path.join(download_folder, file_name)
-
-            async with session.get(download_url) as file_response:
-                with open(file_path, 'wb') as f:
-                    while True:
-                        chunk = await file_response.content.read(8192)
-                        if not chunk:
-                            break
-                        f.write(chunk)
-                return file_path
-        except aiohttp.ClientError as e:
-            print(f"Network or client error occurred while downloading: {e}")
-            return None
-        except Exception as e:
-            print(f"Error occurred while downloading song: {e}")
-            return None
-    return None
+NOTHING = {"cookies_dead": None}
 
-async def check_file_size(link):
-    async def get_format_info(link):
-        proc = await asyncio.create_subprocess_exec(
-            "yt-dlp",
-            "--cookies", cookie_txt_file(),
-            "-J",
-            link,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
+
+def cookies():
+    folder_path = f"{os.getcwd()}/cookies"
+    txt_files = [file for file in os.listdir(folder_path) if file.endswith(".txt")]
+    if not txt_files:
+        raise FileNotFoundError(
+            "No Cookies found in cookies directory make sure your cookies file written  .txt file"
         )
-        stdout, stderr = await proc.communicate()
-        if proc.returncode != 0:
-            print(f'Error:\n{stderr.decode()}')
-            return None
-        return json.loads(stdout.decode())
-
-    def parse_size(formats):
-        total_size = 0
-        for format in formats:
-            if 'filesize' in format:
-                total_size += format['filesize']
-        return total_size
-
-    info = await get_format_info(link)
-    if info is None:
-        return None
-    
-    formats = info.get('formats', [])
-    if not formats:
-        print("No formats found.")
-        return None
-    
-    total_size = parse_size(formats)
-    return total_size
+    cookie_txt_file = random.choice(txt_files)
+    cookie_txt_file = os.path.join(folder_path, cookie_txt_file)
+    return cookie_txt_file
+    # return f"""cookies/{str(cookie_txt_file).split("/")[-1]}"""
+
 
 async def shell_cmd(cmd):
     proc = await asyncio.create_subprocess_shell(
@@ -137,7 +48,7 @@ async def shell_cmd(cmd):
     return out.decode("utf-8")
 
 
-class YouTubeAPI:
+class YouTube:
     def __init__(self):
         self.base = "https://www.youtube.com/watch?v="
         self.regex = r"(?:youtube\.com|youtu\.be)"
@@ -145,7 +56,7 @@ class YouTubeAPI:
         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):
+    async def exists(self, link: str, videoid: bool | str = None):
         if videoid:
             link = self.base + link
         if re.search(self.regex, link):
@@ -153,7 +64,17 @@ class YouTubeAPI:
         else:
             return False
 
-    async def url(self, message_1: Message) -> Union[str, None]:
+    @property
+    def use_fallback(self):
+        return NOTHING["cookies_dead"] is True
+
+    @use_fallback.setter
+    def use_fallback(self, value):
+        if NOTHING["cookies_dead"] is None:
+            NOTHING["cookies_dead"] = value
+
+    @asyncify
+    def url(self, message_1: Message) -> str | None:
         messages = [message_1]
         if message_1.reply_to_message:
             messages.append(message_1.reply_to_message)
@@ -177,7 +98,8 @@ class YouTubeAPI:
             return None
         return text[offset : offset + length]
 
-    async def details(self, link: str, videoid: Union[bool, str] = None):
+    @alru_cache(maxsize=None)
+    async def details(self, link: str, videoid: bool | str = None):
         if videoid:
             link = self.base + link
         if "&" in link:
@@ -194,7 +116,8 @@ class YouTubeAPI:
                 duration_sec = int(time_to_seconds(duration_min))
         return title, duration_min, duration_sec, thumbnail, vidid
 
-    async def title(self, link: str, videoid: Union[bool, str] = None):
+    @alru_cache(maxsize=None)
+    async def title(self, link: str, videoid: bool | str = None):
         if videoid:
             link = self.base + link
         if "&" in link:
@@ -204,7 +127,8 @@ class YouTubeAPI:
             title = result["title"]
         return title
 
-    async def duration(self, link: str, videoid: Union[bool, str] = None):
+    @alru_cache(maxsize=None)
+    async def duration(self, link: str, videoid: bool | str = None):
         if videoid:
             link = self.base + link
         if "&" in link:
@@ -214,7 +138,8 @@ class YouTubeAPI:
             duration = result["duration"]
         return duration
 
-    async def thumbnail(self, link: str, videoid: Union[bool, str] = None):
+    @alru_cache(maxsize=None)
+    async def thumbnail(self, link: str, videoid: bool | str = None):
         if videoid:
             link = self.base + link
         if "&" in link:
@@ -224,18 +149,22 @@ class YouTubeAPI:
             thumbnail = result["thumbnails"][0]["url"].split("?")[0]
         return thumbnail
 
-    async def video(self, link: str, videoid: Union[bool, str] = None):
+    async def video(self, link: str, videoid: bool | str = None):
         if videoid:
             link = self.base + link
         if "&" in link:
             link = link.split("&")[0]
-        proc = await asyncio.create_subprocess_exec(
+        cmd = [
             "yt-dlp",
-            "--cookies",cookie_txt_file(),
+            f"--cookies",
+            cookies(),
             "-g",
             "-f",
             "best[height<=?720][width<=?1280]",
             f"{link}",
+        ]
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
@@ -245,164 +174,284 @@ class YouTubeAPI:
         else:
             return 0, stderr.decode()
 
-    async def playlist(self, link, limit, user_id, videoid: Union[bool, str] = None):
+    @alru_cache(maxsize=None)
+    async def playlist(self, link, limit, videoid: bool | str = None):
         if videoid:
             link = self.listbase + link
         if "&" in link:
             link = link.split("&")[0]
-        
-        ydl_opts = {"ignoreerrors": True, "quiet": True, "dump_single_json": True, "flat_playlist": True, "playlist_items": f"1-{limit}"}
-        
-        proc = await asyncio.create_subprocess_exec(
-            "yt-dlp",
-            "--cookies", cookie_txt_file(),
-            *yt_dlp.utils.shell_quote(ydl_opts),
-            link,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
+
+        cmd = (
+            f"yt-dlp -i --compat-options no-youtube-unavailable-videos "
+            f'--get-id --flat-playlist --playlist-end {limit} --skip-download "{link}" '
+            f"2>/dev/null"
         )
-        stdout, stderr = await proc.communicate()
-        
-        if stderr and "ERROR" in stderr.decode():
-            return 0, f"Error fetching playlist: {stderr.decode()}"
-        
+
+        playlist = await shell_cmd(cmd)
+
         try:
-            playlist_data = json.loads(stdout)
-            entries = playlist_data.get("entries", [])
-            if not entries:
-                return 0, "No videos found in the playlist."
-        except json.JSONDecodeError:
-            return 0, "Failed to parse playlist data."
-        
-        return 1, entries
-
-    async def track(self, link: str, videoid: Union[bool, str] = None):
+            result = [key for key in playlist.split("\n") if key]
+        except Exception:
+            result = []
+        return result
+
+    @alru_cache(maxsize=None)
+    async def track(self, link: str, videoid: 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 = result["duration"]
-            vidid = result["id"]
-        return title, duration, vidid
+        if link.startswith("http://") or link.startswith("https://"):
+            return await self._track(link)
+        try:
+            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]
+            track_details = {
+                "title": title,
+                "link": yturl,
+                "vidid": vidid,
+                "duration_min": duration_min,
+                "thumb": thumbnail,
+            }
+            return track_details, vidid
+        except Exception:
+            return await self._track(link)
 
-    async def formats(self, link: str, videoid: Union[bool, str] = None):
+    @asyncify
+    def _track(self, q):
+        options = {
+            "format": "best",
+            "noplaylist": True,
+            "quiet": True,
+            "extract_flat": "in_playlist",
+            "cookiefile": f"{cookies()}",
+        }
+        with YoutubeDL(options) as ydl:
+            info_dict = ydl.extract_info(f"ytsearch: {q}", download=False)
+            details = info_dict.get("entries")[0]
+            info = {
+                "title": details["title"],
+                "link": details["url"],
+                "vidid": details["id"],
+                "duration_min": (
+                    seconds_to_min(details["duration"])
+                    if details["duration"] != 0
+                    else None
+                ),
+                "thumb": details["thumbnails"][0]["url"],
+            }
+            return info, details["id"]
+
+    @alru_cache(maxsize=None)
+    @asyncify
+    def formats(self, link: str, videoid: bool | str = None):
         if videoid:
             link = self.base + link
         if "&" in link:
             link = link.split("&")[0]
-        cmd = f'yt-dlp -F "{link}"'
-        out = await shell_cmd(cmd)
-        return out
 
+        ytdl_opts = {
+            "quiet": True,
+            "cookiefile": f"{cookies()}",
+        }
+
+        ydl = YoutubeDL(ytdl_opts)
+        with ydl:
+            formats_available = []
+            r = ydl.extract_info(link, download=False)
+            for format in r["formats"]:
+                try:
+                    str(format["format"])
+                except Exception:
+                    continue
+                if "dash" not in str(format["format"]).lower():
+                    try:
+                        format["format"]
+                        format["filesize"]
+                        format["format_id"]
+                        format["ext"]
+                        format["format_note"]
+                    except KeyError:
+                        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
+
+    @alru_cache(maxsize=None)
     async def slider(
         self,
         link: str,
         query_type: int,
-        videoid: Union[bool, str] = None,
+        videoid: bool | str = None,
     ):
         if videoid:
             link = self.base + link
-        if query_type == 1:
-            cmd = f'yt-dlp -F "{link}"'
-        else:
-            cmd = f'yt-dlp -F "ytsearch:{link}"'
-        out = await shell_cmd(cmd)
-        return out
+        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,
+        video: bool | str = None,
+        videoid: bool | str = None,
+        songaudio: bool | str = None,
+        songvideo: bool | str = None,
+        format_id: bool | str = None,
+        title: bool | str = None,
     ) -> str:
         if videoid:
             link = self.base + link
 
+        @asyncify
         def audio_dl():
-            opts = {
-                "format": "bestaudio",
-                "addmetadata": True,
+            ydl_optssx = {
+                "format": "bestaudio/best",
+                "outtmpl": "downloads/%(id)s.%(ext)s",
                 "geo_bypass": True,
+                "noplaylist": True,
                 "nocheckcertificate": True,
-                "outtmpl": f"/tmp/downloads/%(id)s.%(ext)s",
-                "quiet": False,
-                "logtostderr": False,
+                "quiet": True,
+                "no_warnings": True,
+                "cookiefile": f"{cookies()}",
+                "prefer_ffmpeg": True,
             }
-            return opts
 
+            with YoutubeDL(ydl_optssx) as x:
+                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
+
+        @asyncify
         def video_dl():
-            opts = {
-                "format": "best",
-                "addmetadata": True,
+            ydl_optssx = {
+                "format": "(bestvideo[height<=?720][width<=?1280][ext=mp4])+(bestaudio[ext=m4a])",
+                "outtmpl": "downloads/%(id)s.%(ext)s",
                 "geo_bypass": True,
+                "noplaylist": True,
                 "nocheckcertificate": True,
-                "outtmpl": f"/tmp/downloads/%(id)s.%(ext)s",
-                "quiet": False,
-                "logtostderr": False,
+                "quiet": True,
+                "no_warnings": True,
+                "prefer_ffmpeg": True,
+                "cookiefile": f"{cookies()}",
             }
-            return opts
 
+            with YoutubeDL(ydl_optssx) as x:
+                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
+
+        @asyncify
         def song_video_dl():
-            opts = {
-                "format": "best",
-                "addmetadata": True,
+            formats = f"{format_id}+140"
+            fpath = f"downloads/{title}"
+            ydl_optssx = {
+                "format": formats,
+                "outtmpl": fpath,
                 "geo_bypass": True,
+                "noplaylist": True,
                 "nocheckcertificate": True,
-                "outtmpl": f"/tmp/downloads/{title}.%(ext)s",
-                "quiet": False,
-                "logtostderr": False,
+                "quiet": True,
+                "no_warnings": True,
+                "prefer_ffmpeg": True,
+                "merge_output_format": "mp4",
+                "cookiefile": f"{cookies()}",
             }
-            return opts
 
+            with YoutubeDL(ydl_optssx) as x:
+                info = x.extract_info(link)
+                file_path = x.prepare_filename(info)
+                return file_path
+
+        @asyncify
         def song_audio_dl():
-            opts = {
-                "format": "bestaudio",
-                "addmetadata": True,
+            fpath = f"downloads/{title}.%(ext)s"
+            ydl_optssx = {
+                "format": format_id,
+                "outtmpl": fpath,
                 "geo_bypass": True,
+                "noplaylist": True,
                 "nocheckcertificate": True,
-                "outtmpl": f"/tmp/downloads/{title}.%(ext)s",
-                "quiet": False,
-                "logtostderr": False,
+                "quiet": True,
+                "no_warnings": True,
+                "prefer_ffmpeg": True,
+                "postprocessors": [
+                    {
+                        "key": "FFmpegExtractAudio",
+                        "preferredcodec": "mp3",
+                        "preferredquality": "192",
+                    }
+                ],
+                "cookiefile": f"{cookies()}",
             }
-            return opts
+
+            with YoutubeDL(ydl_optssx) as x:
+                info = x.extract_info(link)
+                file_path = x.prepare_filename(info)
+                return file_path
 
         if songvideo:
-            opts = song_video_dl()
+            return await song_video_dl()
+
         elif songaudio:
-            opts = song_audio_dl()
+            return await song_audio_dl()
+
         elif video:
-            opts = video_dl()
-        else:
-            opts = audio_dl()
-        if format_id:
-            opts["format"] = format_id
-        with yt_dlp.YoutubeDL(opts) as ydl:
-            try:
-                await mystic.edit("📥 **downloading...**")
-                ydl.download([link])
-            except Exception as y:
-                return await mystic.edit(f"**Failed to download this video.**\n\n**Reason:** {y}")
-        if songvideo:
-            for file in os.listdir("/tmp/downloads"):
-                if file.startswith(title):
-                    return f"/tmp/downloads/{file}"
-        elif songaudio:
-            for file in os.listdir("/tmp/downloads"):
-                if file.startswith(title):
-                    return f"/tmp/downloads/{file}"
+            if await is_on_off(config.YTDOWNLOADER):
+                direct = True
+                downloaded_file = await video_dl()
+            else:
+                command = [
+                    "yt-dlp",
+                    f"--cookies",
+                    cookies(),
+                    "-g",
+                    "-f",
+                    "best",
+                    link,
+                ]
+
+                proc = await asyncio.create_subprocess_exec(
+                    *command,
+                    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:
+                    downloaded_file = await video_dl()
+                    direct = True
         else:
-            for file in os.listdir("/tmp/downloads"):
-                if file.endswith(".webm"):
-                    return f"/tmp/downloads/{file}"
-                elif file.endswith(".m4a"):
-                    return f"/tmp/downloads/{file}"
-                elif file.endswith(".mp3"):
-                    return f"/tmp/downloads/{file}"
+            direct = True
+            downloaded_file = await audio_dl()
+
+        return downloaded_file, direct