Update DragMusic/platforms/Youtube.py

DragMusic/platforms/Youtube.py

@@ -3,24 +3,14 @@ import os
 import re
 import json
 import httpx  # Make sure to import httpx
-import tempfile
+from typing import Union
 import yt_dlp
-from typing import Union 
 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
-from typing import Union
-from pyrogram.types import Message
-from pyrogram.enums import MessageEntityType
-from youtubesearchpython.__future__ import VideosSearch
-
-
-def time_to_seconds(time):
-    stringt = str(time)
-    return sum(int(x) * 60**i for i, x in enumerate(reversed(stringt.split(":"))))
-
+import tempfile
 
 async def shell_cmd(cmd):
     proc = await asyncio.create_subprocess_shell(
@@ -36,22 +26,6 @@ async def shell_cmd(cmd):
             return errorz.decode("utf-8")
     return out.decode("utf-8")
 
-
-
-async def get_stream_url(query, video=False):
-    api_url = "http://46.250.243.87:1470/youtube"
-    api_key = "1a873582a7c83342f961cc0a177b2b26"
-    
-    async with httpx.AsyncClient(timeout=60) as client:
-        params = {"query": query, "video": video, "api_key": api_key}
-        response = await client.get(api_url, params=params)
-        if response.status_code != 200:
-            return ""
-        info = response.json()
-        return info.get("stream_url")
-
-
-
 class YouTubeAPI:
     def __init__(self):
         self.base = "https://www.youtube.com/watch?v="
@@ -144,9 +118,20 @@ class YouTubeAPI:
             link = self.base + link
         if "&" in link:
             link = link.split("&")[0]
-            
-        return await get_stream_url(link, True)
-        
+        proc = await asyncio.create_subprocess_exec(
+            "yt-dlp",
+            "-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:
@@ -240,6 +225,22 @@ class YouTubeAPI:
         thumbnail = result[query_type]["thumbnails"][0]["url"].split("?")[0]
         return title, duration_min, thumbnail, vidid
 
+    async def get_video_info_from_bitflow(self, url: str, video: bool):
+        api_url = "https://bitflow.in/api/youtube"
+        params = {
+            "query": url,
+            "format": "video" if video else "audio",
+            "download": True,
+            "api_key": "1spiderkey2"
+        }
+        
+        async with httpx.AsyncClient() as client:
+            response = await client.get(api_url, params=params, timeout=150)
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return {"status": "error", "message": "Failed to fetch data from Bitflow API."}
+
     async def download(
         self,
         link: str,
@@ -253,45 +254,64 @@ class YouTubeAPI:
     ) -> str:
         if videoid:
             link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
         loop = asyncio.get_running_loop()
-
-        def audio_dl():
+        bitflow_info = await self.get_video_info_from_bitflow(link, video)
+        def audio_dl(bitflow_info):
+            temp_dir = tempfile.gettempdir()
+            xyz = os.path.join(temp_dir, f"{bitflow_info['videoid']}.{bitflow_info['ext']}")
+            url = bitflow_info['url']
+            # If the url is not a YouTube link, download directly
+            if not (url.startswith('http') and ('youtube.com' in url or 'youtu.be' in url)):
+                import httpx
+                with httpx.Client() as client:
+                    r = client.get(url)
+                    with open(xyz, "wb") as f:
+                        f.write(r.content)
+                return xyz
             ydl_optssx = {
                 "format": "bestaudio/best",
-                "outtmpl": "downloads/%(id)s.%(ext)s",
+                "outtmpl": xyz,
                 "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])
+            x.download([url])
             return xyz
-
-        def video_dl():
+        def video_dl(bitflow_info):
+            temp_dir = tempfile.gettempdir()
+            xyz = os.path.join(temp_dir, f"{bitflow_info['videoid']}.{bitflow_info['ext']}")
+            url = bitflow_info['url']
+            # If the url is not a YouTube link, download directly
+            if not (url.startswith('http') and ('youtube.com' in url or 'youtu.be' in url)):
+                import httpx
+                with httpx.Client() as client:
+                    r = client.get(url)
+                    with open(xyz, "wb") as f:
+                        f.write(r.content)
+                return xyz
             ydl_optssx = {
                 "format": "(bestvideo[height<=?720][width<=?1280][ext=mp4])+(bestaudio[ext=m4a])",
-                "outtmpl": "downloads/%(id)s.%(ext)s",
+                "outtmpl": xyz,
                 "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])
+            x.download([url])
             return xyz
-
         def song_video_dl():
+            temp_dir = tempfile.gettempdir()
+            fpath = os.path.join(temp_dir, f"{title}")
             formats = f"{format_id}+140"
-            fpath = f"downloads/{title}"
             ydl_optssx = {
                 "format": formats,
                 "outtmpl": fpath,
@@ -304,9 +324,9 @@ class YouTubeAPI:
             }
             x = yt_dlp.YoutubeDL(ydl_optssx)
             x.download([link])
-
         def song_audio_dl():
-            fpath = f"downloads/{title}.%(ext)s"
+            temp_dir = tempfile.gettempdir()
+            fpath = os.path.join(temp_dir, f"{title}.%(ext)s")
             ydl_optssx = {
                 "format": format_id,
                 "outtmpl": fpath,
@@ -325,19 +345,20 @@ class YouTubeAPI:
             }
             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"
+            temp_dir = tempfile.gettempdir()
+            fpath = os.path.join(temp_dir, f"{title}.mp4")
             return fpath
         elif songaudio:
             await loop.run_in_executor(None, song_audio_dl)
-            fpath = f"downloads/{title}.mp3"
+            temp_dir = tempfile.gettempdir()
+            fpath = os.path.join(temp_dir, f"{title}.mp3")
             return fpath
         elif video:
-            downloaded_file = await get_stream_url(link, True)
-            direct = None
+            direct = True
+            downloaded_file = await loop.run_in_executor(None, video_dl, bitflow_info)
         else:
-            direct = None
-            downloaded_file = await get_stream_url(link, False)
+            direct = True
+            downloaded_file = await loop.run_in_executor(None, audio_dl, bitflow_info)
         return downloaded_file, direct