Update DragMusic/platforms/Youtube.py

DragMusic/platforms/Youtube.py

@@ -1,16 +1,27 @@
+import  httpx
+from youtubesearchpython.__future__ import VideosSearch
 import asyncio
 import os
 import re
 import json
-import httpx  # Make sure to import httpx
 from typing import Union
+import requests
 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
-import tempfile
+from AnonXMusic.utils.database import is_on_off
+from AnonXMusic.utils.formatters import time_to_seconds
+import os
+import glob
+import random
+import logging
+import aiohttp
+
+def time_to_seconds(time):
+    stringt = str(time)
+    return sum(int(x) * 60**i for i, x in enumerate(reversed(stringt.split(":"))))
+
 
 async def shell_cmd(cmd):
     proc = await asyncio.create_subprocess_shell(
@@ -26,6 +37,22 @@ 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="
@@ -118,20 +145,9 @@ class YouTubeAPI:
             link = self.base + link
         if "&" in link:
             link = link.split("&")[0]
-        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()
+            
+        return await get_stream_url(link, True)
+        
 
     async def playlist(self, link, limit, user_id, videoid: Union[bool, str] = None):
         if videoid:
@@ -225,22 +241,6 @@ 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,
@@ -254,64 +254,45 @@ class YouTubeAPI:
     ) -> str:
         if videoid:
             link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
         loop = asyncio.get_running_loop()
-        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
+
+        def audio_dl():
             ydl_optssx = {
                 "format": "bestaudio/best",
-                "outtmpl": xyz,
+                "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([url])
+            x.download([link])
             return xyz
-        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
+
+        def video_dl():
             ydl_optssx = {
                 "format": "(bestvideo[height<=?720][width<=?1280][ext=mp4])+(bestaudio[ext=m4a])",
-                "outtmpl": xyz,
+                "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([url])
+            x.download([link])
             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,
@@ -324,9 +305,9 @@ class YouTubeAPI:
             }
             x = yt_dlp.YoutubeDL(ydl_optssx)
             x.download([link])
+
         def song_audio_dl():
-            temp_dir = tempfile.gettempdir()
-            fpath = os.path.join(temp_dir, f"{title}.%(ext)s")
+            fpath = f"downloads/{title}.%(ext)s"
             ydl_optssx = {
                 "format": format_id,
                 "outtmpl": fpath,
@@ -345,20 +326,19 @@ class YouTubeAPI:
             }
             x = yt_dlp.YoutubeDL(ydl_optssx)
             x.download([link])
+
         if songvideo:
             await loop.run_in_executor(None, song_video_dl)
-            temp_dir = tempfile.gettempdir()
-            fpath = os.path.join(temp_dir, f"{title}.mp4")
+            fpath = f"downloads/{title}.mp4"
             return fpath
         elif songaudio:
             await loop.run_in_executor(None, song_audio_dl)
-            temp_dir = tempfile.gettempdir()
-            fpath = os.path.join(temp_dir, f"{title}.mp3")
+            fpath = f"downloads/{title}.mp3"
             return fpath
         elif video:
-            direct = True
-            downloaded_file = await loop.run_in_executor(None, video_dl, bitflow_info)
+            downloaded_file = await get_stream_url(link, True)
+            direct = None
         else:
-            direct = True
-            downloaded_file = await loop.run_in_executor(None, audio_dl, bitflow_info)
+            direct = None
+            downloaded_file = await get_stream_url(link, False)
         return downloaded_file, direct