refactor: Revert to simpler, direct yt-dlp implementation in Youtube.py

DragMusic/platforms/Youtube.py

@@ -1,7 +1,7 @@
 import asyncio
-import json
+import os
 import re
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Union
 
 import yt_dlp
 from pyrogram.enums import MessageEntityType
@@ -9,261 +9,345 @@ from pyrogram.types import Message
 from youtubesearchpython.__future__ import VideosSearch
 
 from DragMusic.utils.database import is_on_off
-from DragMusic.utils.downloader import yt_dlp_download, download_audio_concurrent
-from DragMusic.utils.errors import capture_err
 from DragMusic.utils.formatters import time_to_seconds
 
-cookies_file = "cookies.txt"
-_cache = {}
 
-
-@capture_err
-async def shell_cmd(cmd: str) -> str:
+async def shell_cmd(cmd):
     proc = await asyncio.create_subprocess_shell(
-        cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
     )
-    out, err = await proc.communicate()
-    return (out or err).decode()
-
-
-@capture_err
-async def cached_youtube_search(query: str) -> List[Dict]:
-    if query in _cache:
-        return _cache[query]
-    search = VideosSearch(query, limit=1)
-    results = await search.next()
-    result_data = results.get("result", [])
-    if result_data:
-        _cache[query] = result_data
-    return result_data
+    out, errorz = await proc.communicate()
+    if errorz:
+        if "unavailable videos are hidden" in (errorz.decode("utf-8")).lower():
+            return out.decode("utf-8")
+        else:
+            return errorz.decode("utf-8")
+    return out.decode("utf-8")
 
 
 class YouTubeAPI:
-    def __init__(self) -> None:
-        self.base_url = "https://www.youtube.com/watch?v="
-        self.playlist_url = "https://youtube.com/playlist?list="
-        self._url_pattern = re.compile(r"(?:youtube\.com|youtu\.be)")
-
-    def _prepare_link(self, link: str, videoid: Union[str, bool, None] = None) -> str:
-        if isinstance(videoid, str) and videoid.strip():
-            link = self.base_url + videoid.strip()
-        if "youtu.be" in link:
-            link = self.base_url + link.split("/")[-1].split("?")[0]
-        elif "youtube.com/shorts/" in link or "youtube.com/live/" in link:
-            link = self.base_url + link.split("/")[-1].split("?")[0]
-        return link.split("&")[0]
+    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-?]*[ -/]*[@-~])")
 
-    @capture_err
-    async def exists(self, link: str, videoid: Union[str, bool, None] = None) -> bool:
-        return bool(self._url_pattern.search(self._prepare_link(link, videoid)))
-
-    @capture_err
-    async def url(self, message: Message) -> Optional[str]:
-        msgs = [message] + ([message.reply_to_message] if message.reply_to_message else [])
-        for msg in msgs:
-            text = msg.text or msg.caption or ""
-            entities = msg.entities or msg.caption_entities or []
-            for ent in entities:
-                if ent.type == MessageEntityType.URL:
-                    return text[ent.offset : ent.offset + ent.length]
-                if ent.type == MessageEntityType.TEXT_LINK:
-                    return ent.url
-        return None
-
-    @capture_err
-    async def _fetch_video_info(self, query: str, *, use_cache: bool = True) -> Optional[Dict]:
-        if use_cache and not query.startswith("http"):
-            result = await cached_youtube_search(query)
+    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:
-            search = VideosSearch(query, limit=1)
-            result = (await search.next()).get("result", [])
-        return result[0] if result else None
-
-    @capture_err
-    async def is_live(self, link: str) -> bool:
-        prepared = self._prepare_link(link)
-        proc = await asyncio.create_subprocess_exec(
-            "yt-dlp", "--cookies", cookies_file, "--dump-json", prepared,
-            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-        )
-        stdout, _ = await proc.communicate()
-        if not stdout:
-            return False
-        try:
-            info = json.loads(stdout.decode())
-            return bool(info.get("is_live"))
-        except json.JSONDecodeError:
             return False
 
-    @capture_err
-    async def details(self, link: str, videoid: Union[str, bool, None] = None) -> Tuple[str, Optional[str], int, str, str]:
-        info = await self._fetch_video_info(self._prepare_link(link, videoid))
-        if not info:
-            raise ValueError("Video not found")
-        duration_text = info.get("duration")
-        duration_sec = int(time_to_seconds(duration_text)) if duration_text else 0
-        thumb = (info.get("thumbnail") or info.get("thumbnails", [{}])[0].get("url", "")).split("?")[0]
-        return (
-            info.get("title", ""),
-            duration_text,
-            duration_sec,
-            thumb,
-            info.get("id", ""),
-        )
+    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]
 
-    @capture_err
-    async def title(self, link: str, videoid: Union[str, bool, None] = None) -> str:
-        info = await self._fetch_video_info(self._prepare_link(link, videoid))
-        return info.get("title", "") if info else ""
+    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))
+        return title, duration_min, duration_sec, thumbnail, vidid
 
-    @capture_err
-    async def duration(self, link: str, videoid: Union[str, bool, None] = None) -> Optional[str]:
-        info = await self._fetch_video_info(self._prepare_link(link, videoid))
-        return info.get("duration") if info else None
+    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
 
-    @capture_err
-    async def thumbnail(self, link: str, videoid: Union[str, bool, None] = None) -> str:
-        info = await self._fetch_video_info(self._prepare_link(link, videoid))
-        return (info.get("thumbnail") or info.get("thumbnails", [{}])[0].get("url", "")).split("?")[0] if info else ""
+    async def duration(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"]:
+            duration = result["duration"]
+        return duration
 
-    @capture_err
-    async def video(self, link: str, videoid: Union[str, bool, None] = None) -> Tuple[int, str]:
-        link = self._prepare_link(link, videoid)
+    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_file, "-g", "-f", "best[height<=?720][width<=?1280]",
-            link, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            "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()
-        return (1, stdout.decode().split("\n")[0]) if stdout else (0, stderr.decode())
+        if stdout:
+            return 1, stdout.decode().split("\n")[0]
+        else:
+            return 0, stderr.decode()
 
-    @capture_err
-    async def playlist(self, link: str, limit: int, user_id, videoid: Union[str, bool, None] = None) -> List[str]:
+    async def playlist(self, link, limit, user_id, videoid: Union[bool, str] = None):
         if videoid:
-            link = self.playlist_url + str(videoid)
-        link = link.split("&")[0]
-        cmd = (
-            f"yt-dlp --cookies {cookies_file} -i --get-id --flat-playlist "
-            f"--playlist-end {limit} --skip-download {link}"
+            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}"
         )
-        data = await shell_cmd(cmd)
-        return [item for item in data.strip().split("\n") if item]
-
-    @capture_err
-    async def track(self, link: str, videoid: Union[str, bool, None] = None) -> Tuple[Dict, str]:
         try:
-            info = await self._fetch_video_info(self._prepare_link(link, videoid))
-            if not info:
-                raise ValueError("Track not found via API")
-        except Exception:
-            prepared = self._prepare_link(link, videoid)
-            proc = await asyncio.create_subprocess_exec(
-                "yt-dlp", "--cookies", cookies_file, "--dump-json", prepared,
-                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-            )
-            stdout, _ = await proc.communicate()
-            if not stdout:
-                raise ValueError("Track not found (yt-dlp fallback)")
-            try:
-                info = json.loads(stdout.decode())
-            except json.JSONDecodeError:
-                raise ValueError("Failed to parse yt-dlp output")
+            result = playlist.split("\n")
+            for key in result:
+                if key == "":
+                    result.remove(key)
+        except:
+            result = []
+        return result
 
-        thumb = (info.get("thumbnail") or info.get("thumbnails", [{}])[0].get("url", "")).split("?")[0]
-        details = {
-            "title": info.get("title", ""),
-            "link": info.get("webpage_url", self._prepare_link(link, videoid)),
-            "vidid": info.get("id", ""),
-            "duration_min": info.get("duration") if isinstance(info.get("duration"), str) else None,
-            "thumb": thumb,
+    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]
+        track_details = {
+            "title": title,
+            "link": yturl,
+            "vidid": vidid,
+            "duration_min": duration_min,
+            "thumb": thumbnail,
         }
-        return details, info.get("id", "")
+        return track_details, vidid
 
-    @capture_err
-    async def formats(self, link: str, videoid: Union[str, bool, None] = None) -> Tuple[List[Dict], str]:
-        link = self._prepare_link(link, videoid)
-        opts = {"quiet": True, "cookiefile": cookies_file}
-        formats: List[Dict] = []
-        try:
-            with yt_dlp.YoutubeDL(opts) as ydl:
-                info = ydl.extract_info(link, download=False)
-                for fmt in info.get("formats", []):
-                    if "dash" in fmt.get("format", "").lower():
+    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
-                    if all(k in fmt for k in ("format", "filesize", "format_id", "ext", "format_note")):
-                        formats.append({
-                            "format": fmt["format"],
-                            "filesize": fmt["filesize"],
-                            "format_id": fmt["format_id"],
-                            "ext": fmt["ext"],
-                            "format_note": fmt["format_note"],
+                    formats_available.append(
+                        {
+                            "format": format["format"],
+                            "filesize": format["filesize"],
+                            "format_id": format["format_id"],
+                            "ext": format["ext"],
+                            "format_note": format["format_note"],
                             "yturl": link,
-                        })
-        except Exception as e:
-            print(f"[formats()] yt-dlp error: {e}")
-        return formats, link
+                        }
+                    )
+        return formats_available, link
 
-    @capture_err
-    async def slider(self, link: str, query_type: int, videoid: Union[str, bool, None] = None) -> Tuple[str, Optional[str], str, str]:
-        search = VideosSearch(self._prepare_link(link, videoid), limit=10)
-        results = (await search.next()).get("result", [])
-        if not results or query_type >= len(results):
-            raise IndexError(f"Query type index {query_type} out of range (found {len(results)} results)")
-        res = results[query_type]
-        return (
-            res.get("title", ""),
-            res.get("duration"),
-            res.get("thumbnails", [{}])[0].get("url", "").split("?")[0],
-            res.get("id", ""),
-        )
+    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
 
-    @capture_err
     async def download(
         self,
         link: str,
         mystic,
-        *,
-        video: Union[bool, str, None] = None,
-        videoid: Union[str, bool, None] = None,
-        songaudio: Union[bool, str, None] = None,
-        songvideo: Union[bool, str, None] = None,
-        format_id: Union[bool, str, None] = None,
-        title: Union[bool, str, None] = None,
-    ) -> Union[Tuple[str, Optional[bool]], Tuple[None, None]]:
-        link = self._prepare_link(link, videoid)
+        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()
 
-        if songvideo:
-            path = await yt_dlp_download(link, type="song_video", format_id=format_id, title=title)
-            return (path, True) if path else (None, None)
+        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
 
-        if songaudio:
-            path = await yt_dlp_download(link, type="song_audio", format_id=format_id, title=title)
-            return (path, True) if path else (None, None)
+        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])
 
-        if video:
-            if await self.is_live(link):
-                status, stream_url = await self.video(link)
-                if status == 1:
-                    return stream_url, None
-                raise ValueError("Unable to fetch live stream 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):
-                path = await yt_dlp_download(link, type="video")
-                return (path, True) if path else (None, None)
+                direct = True
+                downloaded_file = await loop.run_in_executor(None, video_dl)
             else:
                 proc = await asyncio.create_subprocess_exec(
                     "yt-dlp",
                     "--cookies",
-                    cookies_file,
+                    "cookies.txt",
                     "-g",
                     "-f",
                     "best[height<=?720][width<=?1280]",
-                    link,
+                    f"{link}",
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
                 )
-                stdout, _ = await proc.communicate()
+                stdout, stderr = await proc.communicate()
                 if stdout:
-                    return stdout.decode().split("\n")[0], None
-                return None, None
-
-        path = await download_audio_concurrent(link)
-        return (path, True) if path else (None, None)
+                    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

DragMusic/plugins/play/play.py

@@ -1,83 +1,90 @@
 import random
 import string
-import asyncio
 
 from pyrogram import filters
-from pyrogram.errors import FloodWait, RandomIdDuplicate
 from pyrogram.types import InlineKeyboardMarkup, InputMediaPhoto, Message
 from pytgcalls.exceptions import NoActiveGroupCall
 
 import config
-from config import BANNED_USERS, lyrical, AYU
-from DragMusic import Apple, Resso, SoundCloud, Spotify, Telegram, YouTube, app
-from DragMusic.core.call import Drag
-from DragMusic.utils import seconds_to_min, time_to_seconds
-from DragMusic.utils.channelplay import get_channeplayCB
-from DragMusic.utils.decorators.language import languageCB
-from DragMusic.utils.decorators.play import PlayWrapper
-from DragMusic.utils.errors import capture_err, capture_callback_err
-from DragMusic.utils.formatters import formats
-from DragMusic.utils.inline import (
+from AnonXMusic import Apple, Resso, SoundCloud, Spotify, Telegram, YouTube, app
+from AnonXMusic.core.call import Anony
+from AnonXMusic.utils import seconds_to_min, time_to_seconds
+from AnonXMusic.utils.channelplay import get_channeplayCB
+from AnonXMusic.utils.decorators.language import languageCB
+from AnonXMusic.utils.decorators.play import PlayWrapper
+from AnonXMusic.utils.formatters import formats
+from AnonXMusic.utils.inline import (
     botplaylist_markup,
     livestream_markup,
     playlist_markup,
     slider_markup,
     track_markup,
 )
-from DragMusic.utils.logger import play_logs
-from DragMusic.utils.stream.stream import stream
+from AnonXMusic.utils.logger import play_logs
+from AnonXMusic.utils.stream.stream import stream
+from config import BANNED_USERS, lyrical
 
 
 @app.on_message(
-    filters.command([
-        "play", "vplay", "cplay", "cvplay",
-        "playforce", "vplayforce", "cplayforce", "cvplayforce"
-    ]) & filters.group & ~BANNED_USERS
+    filters.command(
+        [
+            "play",
+            "vplay",
+            "cplay",
+            "cvplay",
+            "playforce",
+            "vplayforce",
+            "cplayforce",
+            "cvplayforce",
+        ]
+    )
+    & filters.group
+    & ~BANNED_USERS
 )
 @PlayWrapper
-@capture_err
-async def play_command(client, message: Message, _, chat_id, video, channel, playmode, url, fplay):
-    try:
-        mystic = await message.reply_text(
-            _["play_2"].format(channel) if channel else random.choice(AYU)
-        )
-    except FloodWait as e:
-        await asyncio.sleep(e.value)
-        mystic = await message.reply_text(
-            _["play_2"].format(channel) if channel else random.choice(AYU)
-        )
-    except RandomIdDuplicate:
-        mystic = await app.send_message(
-            message.chat.id,
-            _["play_2"].format(channel) if channel else random.choice(AYU)
-        )
-
-    plist_id, plist_type, spotify, slider = None, None, None, None
+async def play_commnd(
+    client,
+    message: Message,
+    _,
+    chat_id,
+    video,
+    channel,
+    playmode,
+    url,
+    fplay,
+):
+    mystic = await message.reply_text(
+        _["play_2"].format(channel) if channel else _["play_1"]
+    )
+    plist_id = None
+    slider = None
+    plist_type = None
+    spotify = None
     user_id = message.from_user.id
     user_name = message.from_user.first_name
-
     audio_telegram = (
         (message.reply_to_message.audio or message.reply_to_message.voice)
-        if message.reply_to_message else None
+        if message.reply_to_message
+        else None
+    )
+    video_telegram = (
+        (message.reply_to_message.video or message.reply_to_message.document)
+        if message.reply_to_message
+        else None
     )
-
     if audio_telegram:
         if audio_telegram.file_size > 104857600:
             return await mystic.edit_text(_["play_5"])
-
         duration_min = seconds_to_min(audio_telegram.duration)
-        if audio_telegram.duration > config.DURATION_LIMIT:
+        if (audio_telegram.duration) > config.DURATION_LIMIT:
             return await mystic.edit_text(
                 _["play_6"].format(config.DURATION_LIMIT_MIN, app.mention)
             )
-
         file_path = await Telegram.get_filepath(audio=audio_telegram)
-        downloaded = await Telegram.download(_, message, mystic, file_path)
-        if downloaded:
+        if await Telegram.download(_, message, mystic, file_path):
             message_link = await Telegram.get_link(message)
             file_name = await Telegram.get_filename(audio_telegram, audio=True)
             dur = await Telegram.get_duration(audio_telegram, file_path)
-
             details = {
                 "title": file_name,
                 "link": message_link,
@@ -98,47 +105,37 @@ async def play_command(client, message: Message, _, chat_id, video, channel, pla
                     forceplay=fplay,
                 )
             except Exception as e:
-                err = e if type(e).__name__ == "AssistantErr" else _["general_2"].format(type(e).__name__)
+                print(f"Error: {e}")
+                ex_type = type(e).__name__
+                err = e if ex_type == "AssistantErr" else _["general_2"].format(ex_type)
                 return await mystic.edit_text(err)
-
             return await mystic.delete()
         return
-
-    video_telegram = (
-        (message.reply_to_message.video or message.reply_to_message.document)
-        if message.reply_to_message else None
-    )
-
-    if video_telegram:
+    elif video_telegram:
         if message.reply_to_message.document:
             try:
                 ext = video_telegram.file_name.split(".")[-1]
                 if ext.lower() not in formats:
                     return await mystic.edit_text(
-                        _["play_7"].format(" | ".join(formats))
+                        _["play_7"].format(f"{' | '.join(formats)}")
                     )
             except:
                 return await mystic.edit_text(
-                    _["play_7"].format(" | ".join(formats))
+                    _["play_7"].format(f"{' | '.join(formats)}")
                 )
-
         if video_telegram.file_size > config.TG_VIDEO_FILESIZE_LIMIT:
             return await mystic.edit_text(_["play_8"])
-
         file_path = await Telegram.get_filepath(video=video_telegram)
-        downloaded = await Telegram.download(_, message, mystic, file_path)
-        if downloaded:
+        if await Telegram.download(_, message, mystic, file_path):
             message_link = await Telegram.get_link(message)
             file_name = await Telegram.get_filename(video_telegram)
             dur = await Telegram.get_duration(video_telegram, file_path)
-
             details = {
                 "title": file_name,
                 "link": message_link,
                 "path": file_path,
                 "dur": dur,
             }
-
             try:
                 await stream(
                     _,
@@ -153,136 +150,127 @@ async def play_command(client, message: Message, _, chat_id, video, channel, pla
                     forceplay=fplay,
                 )
             except Exception as e:
-                err = e if type(e).__name__ == "AssistantErr" else _["general_2"].format(type(e).__name__)
+                print(f"Error: {e}")
+                ex_type = type(e).__name__
+                err = e if ex_type == "AssistantErr" else _["general_2"].format(ex_type)
                 return await mystic.edit_text(err)
-
             return await mystic.delete()
         return
-
-    if url:
+    elif url:
         if await YouTube.exists(url):
             if "playlist" in url:
                 try:
-                    details = await YouTube.playlist(url, config.PLAYLIST_FETCH_LIMIT, user_id)
+                    details = await YouTube.playlist(
+                        url,
+                        config.PLAYLIST_FETCH_LIMIT,
+                        message.from_user.id,
+                    )
                 except:
                     return await mystic.edit_text(_["play_3"])
-
+                streamtype = "playlist"
                 plist_type = "yt"
-                plist_id = (url.split("="))[1].split("&")[0] if "&" in url else (url.split("="))[1]
+                if "&" in url:
+                    plist_id = (url.split("=")[1]).split("&")[0]
+                else:
+                    plist_id = url.split("=")[1]
                 img = config.PLAYLIST_IMG_URL
                 cap = _["play_9"]
-                streamtype = "playlist"
-
             else:
                 try:
                     details, track_id = await YouTube.track(url)
                 except:
                     return await mystic.edit_text(_["play_3"])
-
-                img = details["thumb"]
-                cap = _["play_10"].format(details["title"], details["duration_min"])
                 streamtype = "youtube"
-
+                img = details["thumb"]
+                cap = _["play_10"].format(
+                    details["title"],
+                    details["duration_min"],
+                )
         elif await Spotify.valid(url):
             spotify = True
-            if not config.SPOTIFY_CLIENT_ID or not config.SPOTIFY_CLIENT_SECRET:
+            if not config.SPOTIFY_CLIENT_ID and not config.SPOTIFY_CLIENT_SECRET:
                 return await mystic.edit_text(
-                    "»  sᴘᴏᴛɪғʏ ɪs ɴᴏᴛ sᴜᴘᴘᴏʀᴛᴇᴅ ʏᴇᴛ.\n\nᴘʟᴇᴀsᴇ ᴛʀʏ ᴀɢᴀɪɴ ʟᴀᴛᴇʀ."
+                    "» sᴘᴏᴛɪғʏ ɪs ɴᴏᴛ sᴜᴘᴘᴏʀᴛᴇᴅ ʏᴇᴛ.\n\nᴘʟᴇᴀsᴇ ᴛʀʏ ᴀɢᴀɪɴ ʟᴀᴛᴇʀ."
                 )
-
             if "track" in url:
                 try:
                     details, track_id = await Spotify.track(url)
                 except:
                     return await mystic.edit_text(_["play_3"])
-
+                streamtype = "youtube"
                 img = details["thumb"]
                 cap = _["play_10"].format(details["title"], details["duration_min"])
-                streamtype = "youtube"
-
             elif "playlist" in url:
                 try:
                     details, plist_id = await Spotify.playlist(url)
-                except:
+                except Exception:
                     return await mystic.edit_text(_["play_3"])
-
+                streamtype = "playlist"
                 plist_type = "spplay"
                 img = config.SPOTIFY_PLAYLIST_IMG_URL
                 cap = _["play_11"].format(app.mention, message.from_user.mention)
-                streamtype = "playlist"
-
             elif "album" in url:
                 try:
                     details, plist_id = await Spotify.album(url)
                 except:
                     return await mystic.edit_text(_["play_3"])
-
+                streamtype = "playlist"
                 plist_type = "spalbum"
                 img = config.SPOTIFY_ALBUM_IMG_URL
                 cap = _["play_11"].format(app.mention, message.from_user.mention)
-                streamtype = "playlist"
-
             elif "artist" in url:
                 try:
                     details, plist_id = await Spotify.artist(url)
                 except:
                     return await mystic.edit_text(_["play_3"])
-
+                streamtype = "playlist"
                 plist_type = "spartist"
                 img = config.SPOTIFY_ARTIST_IMG_URL
                 cap = _["play_11"].format(message.from_user.first_name)
-                streamtype = "playlist"
-
             else:
                 return await mystic.edit_text(_["play_15"])
-
         elif await Apple.valid(url):
             if "album" in url:
                 try:
                     details, track_id = await Apple.track(url)
                 except:
                     return await mystic.edit_text(_["play_3"])
-
+                streamtype = "youtube"
                 img = details["thumb"]
                 cap = _["play_10"].format(details["title"], details["duration_min"])
-                streamtype = "youtube"
-
             elif "playlist" in url:
                 spotify = True
                 try:
                     details, plist_id = await Apple.playlist(url)
                 except:
                     return await mystic.edit_text(_["play_3"])
-
+                streamtype = "playlist"
                 plist_type = "apple"
-                img = url
                 cap = _["play_12"].format(app.mention, message.from_user.mention)
-                streamtype = "playlist"
-
+                img = url
             else:
                 return await mystic.edit_text(_["play_3"])
-
         elif await Resso.valid(url):
             try:
                 details, track_id = await Resso.track(url)
             except:
                 return await mystic.edit_text(_["play_3"])
-
+            streamtype = "youtube"
             img = details["thumb"]
             cap = _["play_10"].format(details["title"], details["duration_min"])
-            streamtype = "youtube"
-
         elif await SoundCloud.valid(url):
             try:
                 details, track_path = await SoundCloud.download(url)
             except:
                 return await mystic.edit_text(_["play_3"])
-
-            if details["duration_sec"] > config.DURATION_LIMIT:
+            duration_sec = details["duration_sec"]
+            if duration_sec > config.DURATION_LIMIT:
                 return await mystic.edit_text(
-                    _["play_6"].format(config.DURATION_LIMIT_MIN, app.mention)
+                    _["play_6"].format(
+                        config.DURATION_LIMIT_MIN,
+                        app.mention,
+                    )
                 )
-
             try:
                 await stream(
                     _,
@@ -296,43 +284,43 @@ async def play_command(client, message: Message, _, chat_id, video, channel, pla
                     forceplay=fplay,
                 )
             except Exception as e:
-                err = e if type(e).__name__ == "AssistantErr" else _["general_2"].format(type(e).__name__)
+                print(f"Error: {e}")
+                ex_type = type(e).__name__
+                err = e if ex_type == "AssistantErr" else _["general_2"].format(ex_type)
                 return await mystic.edit_text(err)
-
             return await mystic.delete()
-
         else:
             try:
-                await Drag.stream_call(url)
+                await Aviax.stream_call(url)
             except NoActiveGroupCall:
                 await mystic.edit_text(_["black_9"])
                 return await app.send_message(
-                    chat_id=config.LOGGER_ID,
+                    chat_id=config.LOG_GROUP_ID,
                     text=_["play_17"],
                 )
             except Exception as e:
+                print(f"Error: {e}")
                 return await mystic.edit_text(_["general_2"].format(type(e).__name__))
-
             await mystic.edit_text(_["str_2"])
             try:
                 await stream(
                     _,
                     mystic,
-                    user_id,
+                    message.from_user.id,
                     url,
                     chat_id,
-                    user_name,
+                    message.from_user.first_name,
                     message.chat.id,
                     video=video,
                     streamtype="index",
                     forceplay=fplay,
                 )
             except Exception as e:
-                err = e if type(e).__name__ == "AssistantErr" else _["general_2"].format(type(e).__name__)
+                print(f"Error: {e}")
+                ex_type = type(e).__name__
+                err = e if ex_type == "AssistantErr" else _["general_2"].format(ex_type)
                 return await mystic.edit_text(err)
-
-            return await play_logs(message, streamtype="M3U8 or Index Link")
-
+            return await play_logs(message, streamtype="M3u8 or Index Link")
     else:
         if len(message.command) < 2:
             buttons = botplaylist_markup(_)
@@ -340,24 +328,20 @@ async def play_command(client, message: Message, _, chat_id, video, channel, pla
                 _["play_18"],
                 reply_markup=InlineKeyboardMarkup(buttons),
             )
-
         slider = True
         query = message.text.split(None, 1)[1]
         if "-v" in query:
             query = query.replace("-v", "")
-
         try:
             details, track_id = await YouTube.track(query)
         except:
             return await mystic.edit_text(_["play_3"])
-
         streamtype = "youtube"
-
     if str(playmode) == "Direct":
         if not plist_type:
-            if details.get("duration_min"):
+            if details["duration_min"]:
                 duration_sec = time_to_seconds(details["duration_min"])
-                if duration_sec and duration_sec > config.DURATION_LIMIT:
+                if duration_sec > config.DURATION_LIMIT:
                     return await mystic.edit_text(
                         _["play_6"].format(config.DURATION_LIMIT_MIN, app.mention)
                     )
@@ -374,7 +358,6 @@ async def play_command(client, message: Message, _, chat_id, video, channel, pla
                     _["play_13"],
                     reply_markup=InlineKeyboardMarkup(buttons),
                 )
-
         try:
             await stream(
                 _,
@@ -390,38 +373,39 @@ async def play_command(client, message: Message, _, chat_id, video, channel, pla
                 forceplay=fplay,
             )
         except Exception as e:
-            err = e if type(e).__name__ == "AssistantErr" else _["general_2"].format(type(e).__name__)
+            print(f"Error: {e}")
+            ex_type = type(e).__name__
+            err = e if ex_type == "AssistantErr" else _["general_2"].format(ex_type)
             return await mystic.edit_text(err)
-
         await mystic.delete()
         return await play_logs(message, streamtype=streamtype)
-
     else:
         if plist_type:
-            ran_hash = "".join(random.choices(string.ascii_uppercase + string.digits, k=10))
+            ran_hash = "".join(
+                random.choices(string.ascii_uppercase + string.digits, k=10)
+            )
             lyrical[ran_hash] = plist_id
             buttons = playlist_markup(
                 _,
                 ran_hash,
-                user_id,
+                message.from_user.id,
                 plist_type,
                 "c" if channel else "g",
                 "f" if fplay else "d",
             )
             await mystic.delete()
             await message.reply_photo(
-                photo=(details["thumb"] if plist_type == "yt" else (details if plist_type == "apple" else img)),
+                photo=img,
                 caption=cap,
                 reply_markup=InlineKeyboardMarkup(buttons),
             )
             return await play_logs(message, streamtype=f"Playlist : {plist_type}")
-
         else:
             if slider:
                 buttons = slider_markup(
                     _,
                     track_id,
-                    user_id,
+                    message.from_user.id,
                     query,
                     0,
                     "c" if channel else "g",
@@ -436,83 +420,74 @@ async def play_command(client, message: Message, _, chat_id, video, channel, pla
                     ),
                     reply_markup=InlineKeyboardMarkup(buttons),
                 )
-                return await play_logs(message, streamtype="Searched on YouTube")
-
+                return await play_logs(message, streamtype=f"Searched on Youtube")
             else:
                 buttons = track_markup(
                     _,
                     track_id,
-                    user_id,
+                    message.from_user.id,
                     "c" if channel else "g",
                     "f" if fplay else "d",
                 )
                 await mystic.delete()
                 await message.reply_photo(
-                    photo=details["thumb"],
-                    caption=_["play_10"].format(
-                        details["title"],
-                        details["duration_min"],
-                    ),
+                    photo=img,
+                    caption=cap,
                     reply_markup=InlineKeyboardMarkup(buttons),
                 )
-                return await play_logs(message, streamtype="URL Search Inline")
+                return await play_logs(message, streamtype=f"URL Searched Inline")
+
 
 @app.on_callback_query(filters.regex("MusicStream") & ~BANNED_USERS)
 @languageCB
-@capture_callback_err
 async def play_music(client, CallbackQuery, _):
-    try:
-        callback_data = CallbackQuery.data.split(None, 1)[1]
-        vidid, user_id, mode, cplay, fplay = callback_data.split("|")
-
-        if CallbackQuery.from_user.id != int(user_id):
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    vidid, user_id, mode, cplay, fplay = callback_request.split("|")
+    if CallbackQuery.from_user.id != int(user_id):
+        try:
             return await CallbackQuery.answer(_["playcb_1"], show_alert=True)
-
+        except:
+            return
+    try:
         chat_id, channel = await get_channeplayCB(_, cplay, CallbackQuery)
-
-        user_name = CallbackQuery.from_user.first_name
+    except:
+        return
+    user_name = CallbackQuery.from_user.first_name
+    try:
         await CallbackQuery.message.delete()
         await CallbackQuery.answer()
-
-        try:
-            mystic = await CallbackQuery.message.reply_text(
-                _["play_2"].format(channel) if channel else random.choice(AYU)
-            )
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            mystic = await CallbackQuery.message.reply_text(
-                _["play_2"].format(channel) if channel else random.choice(AYU)
-            )
-        except RandomIdDuplicate:
-            mystic = await app.send_message(
-                CallbackQuery.message.chat.id,
-                _["play_2"].format(channel) if channel else random.choice(AYU)
-            )
-
-        details, track_id = await YouTube.track(vidid, videoid=vidid)
-
-        if details.get("duration_min"):
-            duration_sec = time_to_seconds(details["duration_min"])
-            if duration_sec and duration_sec > config.DURATION_LIMIT:
-                return await mystic.edit_text(
-                    _["play_6"].format(config.DURATION_LIMIT_MIN, app.mention)
-                )
-        else:
-            buttons = livestream_markup(
-                _,
-                track_id,
-                CallbackQuery.from_user.id,
-                mode,
-                "c" if cplay == "c" else "g",
-                "f" if fplay else "d",
-            )
+    except:
+        pass
+    mystic = await CallbackQuery.message.reply_text(
+        _["play_2"].format(channel) if channel else _["play_1"]
+    )
+    try:
+        details, track_id = await YouTube.track(vidid, True)
+    except:
+        return await mystic.edit_text(_["play_3"])
+    if details["duration_min"]:
+        duration_sec = time_to_seconds(details["duration_min"])
+        if duration_sec > config.DURATION_LIMIT:
             return await mystic.edit_text(
-                _["play_13"], reply_markup=InlineKeyboardMarkup(buttons)
+                _["play_6"].format(config.DURATION_LIMIT_MIN, app.mention)
             )
-
-        video = mode == "v"
-        forceplay = fplay == "f"
-
+    else:
+        buttons = livestream_markup(
+            _,
+            track_id,
+            CallbackQuery.from_user.id,
+            mode,
+            "c" if cplay == "c" else "g",
+            "f" if fplay else "d",
+        )
+        return await mystic.edit_text(
+            _["play_13"],
+            reply_markup=InlineKeyboardMarkup(buttons),
+        )
+    video = True if mode == "v" else None
+    ffplay = True if fplay == "f" else None
+    try:
         await stream(
             _,
             mystic,
@@ -523,136 +498,57 @@ async def play_music(client, CallbackQuery, _):
             CallbackQuery.message.chat.id,
             video,
             streamtype="youtube",
-            forceplay=forceplay,
+            forceplay=ffplay,
         )
-
-        await mystic.delete()
-
     except Exception as e:
-        err = e if type(e).__name__ == "AssistantErr" else _["general_2"].format(type(e).__name__)
-        return await CallbackQuery.message.reply_text(err)
+        print(f"Error: {e}")
+        ex_type = type(e).__name__
+        err = e if ex_type == "AssistantErr" else _["general_2"].format(ex_type)
+        return await mystic.edit_text(err)
+    return await mystic.delete()
 
 
 @app.on_callback_query(filters.regex("AnonymousAdmin") & ~BANNED_USERS)
-@capture_callback_err
 async def anonymous_check(client, CallbackQuery):
     try:
         await CallbackQuery.answer(
-            "» ʀᴇᴠᴇʀᴛ ʙᴀᴄᴋ ᴛᴏ ᴜsᴇʀ ᴀᴄᴄᴏᴜɴᴛ :\n\n"
-            "ᴏᴘᴇɴ ʏᴏᴜʀ ɢʀᴏᴜᴘ sᴇᴛᴛɪɴɢs.\n"
-            "-> ᴀᴅᴍɪɴɪsᴛʀᴀᴛᴏʀs\n-> ᴄʟɪᴄᴋ ᴏɴ ʏᴏᴜʀ ɴᴀᴍᴇ\n"
-            "-> ᴜɴᴄʜᴇᴄᴋ ᴀɴᴏɴʏᴍᴏᴜs ᴀᴅᴍɪɴ ᴘᴇʀᴍɪssɪᴏɴs.",
+            "» ʀᴇᴠᴇʀᴛ ʙᴀᴄᴋ ᴛᴏ ᴜsᴇʀ ᴀᴄᴄᴏᴜɴᴛ :\n\nᴏᴘᴇɴ ʏᴏᴜʀ ɢʀᴏᴜ�� sᴇᴛᴛɪɴɢs.\n-> ᴀᴅᴍɪɴɪsᴛʀᴀᴛᴏʀs\n-> ᴄʟɪᴄᴋ ᴏɴ ʏᴏᴜʀ ɴᴀᴍᴇ\n-> ᴜɴᴄʜᴇᴄᴋ ᴀɴᴏɴʏᴍᴏᴜs ᴀᴅᴍɪɴ ᴘᴇʀᴍɪssɪᴏɴs.",
             show_alert=True,
         )
     except:
         pass
 
 
-@app.on_callback_query(filters.regex("AnniePlaylists") & ~BANNED_USERS)
+@app.on_callback_query(filters.regex("AviaxPlaylists") & ~BANNED_USERS)
 @languageCB
-@capture_callback_err
 async def play_playlists_command(client, CallbackQuery, _):
-    try:
-        callback_data = CallbackQuery.data.split(None, 1)[1]
-        videoid, user_id, ptype, mode, cplay, fplay = callback_data.split("|")
-
-        if CallbackQuery.from_user.id != int(user_id):
-            return await CallbackQuery.answer(_["playcb_1"], show_alert=True)
-
-        chat_id, channel = await get_channeplayCB(_, cplay, CallbackQuery)
-        user_name = CallbackQuery.from_user.first_name
-        await CallbackQuery.message.delete()
-        await CallbackQuery.answer()
-
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    (
+        videoid,
+        user_id,
+        ptype,
+        mode,
+        cplay,
+        fplay,
+    ) = callback_request.split("|")
+    if CallbackQuery.from_user.id != int(user_id):
         try:
-            mystic = await CallbackQuery.message.reply_text(
-                _["play_2"].format(channel) if channel else random.choice(AYU)
-            )
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            mystic = await CallbackQuery.message.reply_text(
-                _["play_2"].format(channel) if channel else random.choice(AYU)
-            )
-        except RandomIdDuplicate:
-            mystic = await app.send_message(
-                CallbackQuery.message.chat.id,
-                _["play_2"].format(channel) if channel else random.choice(AYU)
-            )
-
-        videoid = lyrical.get(videoid)
-        video = mode == "v"
-        forceplay = fplay == "f"
-        spotify = True
-
-        if ptype == "yt":
-            spotify = False
-            result = await YouTube.playlist(videoid, config.PLAYLIST_FETCH_LIMIT, CallbackQuery.from_user.id, True)
-        elif ptype == "spplay":
-            result, _ = await Spotify.playlist(videoid)
-        elif ptype == "spalbum":
-            result, _ = await Spotify.album(videoid)
-        elif ptype == "spartist":
-            result, _ = await Spotify.artist(videoid)
-        elif ptype == "apple":
-            result, _ = await Apple.playlist(videoid, True)
-        else:
+            return await CallbackQuery.answer(_["playcb_1"], show_alert=True)
+        except:
             return
-
-        await stream(
-            _,
-            mystic,
-            CallbackQuery.from_user.id,
-            result,
-            chat_id,
-            user_name,
-            CallbackQuery.message.chat.id,
-            video,
-            streamtype="playlist",
-            spotify=spotify,
-            forceplay=forceplay,
-        )
-
-        await mystic.delete()
-
-    except Exception as e:
-        err = e if type(e).__name__ == "AssistantErr" else _["general_2"].format(type(e).__name__)
-        return await CallbackQuery.message.reply_text(err)
-
-
-@app.on_callback_query(filters.regex("slider") & ~BANNED_USERS)
-@languageCB
-@capture_callback_err
-async def slider_queries(client, CallbackQuery, _):
     try:
-        callback_data = CallbackQuery.data.split(None, 1)[1]
-        what, rtype, query, user_id, cplay, fplay = callback_data.split("|")
-
-        if CallbackQuery.from_user.id != int(user_id):
-            return await CallbackQuery.answer(_["playcb_1"], show_alert=True)
-
-        rtype = int(rtype)
-        query_type = (rtype + 1) if what == "F" else (rtype - 1)
-
-        if query_type > 9:
-            query_type = 0
-        if query_type < 0:
-            query_type = 9
-
-        title, duration_min, thumbnail, vidid = await YouTube.slider(query, query_type)
-
-        buttons = slider_markup(_, vidid, user_id, query, query_type, cplay, fplay)
-        med = InputMediaPhoto(
-            media=thumbnail,
-            caption=_["play_10"].format(
-                title.title(),
-                duration_min,
-            ),
-        )
-
-        await CallbackQuery.edit_message_media(
-            media=med, reply_markup=InlineKeyboardMarkup(buttons)
-        )
-        await CallbackQuery.answer(_["playcb_2"])
-
-    except Exception:
-        pass
+        chat_id, channel = await get_channeplayCB(_, cplay, CallbackQuery)
+    except:
+        return
+    user_name = CallbackQuery.from_user.first_name
+    await CallbackQuery.message.delete()
+    try:
+        await CallbackQuery.answer()
+    except:
+        pass
+    mystic = await CallbackQuery.message.reply_text(
+        _["play_2"].format(channel) if channel else _["play_1"]
+    )
+    videoid = lyrical.get(videoid)
+    video = Tr

DragMusic/utils/downloader.py

@@ -1,201 +0,0 @@
-import asyncio
-import aiohttp
-import aiofiles
-import os
-import re
-from typing import Optional, Union, Dict
-from yt_dlp import YoutubeDL
-from config import API_URL, API_KEY
-
-USE_API = bool(API_URL and API_KEY)
-_logged_api_skip = False
-CHUNK_SIZE = 8192
-RETRY_DELAY = 2
-cookies_file = "cookies.txt"
-download_folder = "/tmp/downloads"
-os.makedirs(download_folder, exist_ok=True)
-
-
-def extract_video_id(link: str) -> str:
-    if "v=" in link:
-        return link.split("v=")[-1].split("&")[0]
-    return link.split("/")[-1].split("?")[0]
-
-
-def safe_filename(name: str) -> str:
-    return re.sub(r"[\\/*?\"<>|]", "_", name).strip()[:100]
-
-
-def file_exists(video_id: str) -> Optional[str]:
-    for ext in ["mp3", "m4a", "webm"]:
-        path = f"{download_folder}/{video_id}.{ext}"
-        if os.path.exists(path):
-            print(f"[CACHED] Using existing file: {path}")
-            return path
-    return None
-
-
-async def api_download_song(link: str) -> Optional[str]:
-    global _logged_api_skip
-
-    if not USE_API:
-        if not _logged_api_skip:
-            print("[SKIPPED] API config missing — using yt-dlp only.")
-            _logged_api_skip = True
-        return None
-
-    video_id = extract_video_id(link)
-    song_url = f"{API_URL}/song/{video_id}?api={API_KEY}"
-
-    try:
-        async with aiohttp.ClientSession() as session:
-            while True:
-                async with session.get(song_url) as response:
-                    if response.status != 200:
-                        print(f"[API ERROR] Status {response.status}")
-                        return None
-
-                    data = await response.json()
-                    status = data.get("status", "").lower()
-
-                    if status == "downloading":
-                        await asyncio.sleep(RETRY_DELAY)
-                        continue
-                    elif status == "error":
-                        print(f"[API ERROR] Status=error for {video_id}")
-                        return None
-                    elif status == "done":
-                        download_url = data.get("link")
-                        break
-                    else:
-                        print(f"[API ERROR] Unknown status: {status}")
-                        return None
-
-            fmt = data.get("format", "mp3").lower()
-            path = f"{download_folder}/{video_id}.{fmt}"
-
-            async with session.get(download_url) as file_response:
-                async with aiofiles.open(path, "wb") as f:
-                    while True:
-                        chunk = await file_response.content.read(CHUNK_SIZE)
-                        if not chunk:
-                            break
-                        await f.write(chunk)
-
-            return path
-    except Exception as e:
-        print(f"[API Download Error] {e}")
-        return None
-
-
-def _download_ytdlp(link: str, opts: Dict) -> Optional[str]:
-    try:
-        with YoutubeDL(opts) as ydl:
-            info = ydl.extract_info(link, download=False)
-            ext = info.get("ext", "webm")
-            vid = info.get("id")
-            path = f"{download_folder}/{vid}.{ext}"
-            if os.path.exists(path):
-                return path
-            ydl.download([link])
-            return path
-    except Exception as e:
-        print(f"[yt-dlp Error] {e}")
-        return None
-
-
-async def yt_dlp_download(link: str, type: str, format_id: str = None, title: str = None) -> Optional[str]:
-    loop = asyncio.get_running_loop()
-
-    if type == "audio":
-        opts = {
-            "format": "bestaudio/best",
-            "outtmpl": f"{download_folder}/%(id)s.%(ext)s",
-            "quiet": True,
-            "no_warnings": True,
-            "cookiefile": cookies_file,
-            "noplaylist": True,
-            "concurrent_fragment_downloads": 5,
-        }
-        return await loop.run_in_executor(None, _download_ytdlp, link, opts)
-
-    elif type == "video":
-        opts = {
-            "format": "best[height<=?720][width<=?1280]",
-            "outtmpl": f"{download_folder}/%(id)s.%(ext)s",
-            "quiet": True,
-            "no_warnings": True,
-            "cookiefile": cookies_file,
-            "noplaylist": True,
-            "concurrent_fragment_downloads": 5,
-        }
-        return await loop.run_in_executor(None, _download_ytdlp, link, opts)
-
-    elif type == "song_video" and format_id and title:
-        safe_title = safe_filename(title)
-        opts = {
-            "format": f"{format_id}+140",
-            "outtmpl": f"{download_folder}/{safe_title}.mp4",
-            "quiet": True,
-            "no_warnings": True,
-            "prefer_ffmpeg": True,
-            "merge_output_format": "mp4",
-            "cookiefile": cookies_file,
-        }
-        await loop.run_in_executor(None, lambda: YoutubeDL(opts).download([link]))
-        return f"{download_folder}/{safe_title}.mp4"
-
-    elif type == "song_audio" and format_id and title:
-        safe_title = safe_filename(title)
-        opts = {
-            "format": format_id,
-            "outtmpl": f"{download_folder}/{safe_title}.%(ext)s",
-            "quiet": True,
-            "no_warnings": True,
-            "prefer_ffmpeg": True,
-            "cookiefile": cookies_file,
-            "postprocessors": [{
-                "key": "FFmpegExtractAudio",
-                "preferredcodec": "mp3",
-                "preferredquality": "192",
-            }],
-        }
-        await loop.run_in_executor(None, lambda: YoutubeDL(opts).download([link]))
-        return f"{download_folder}/{safe_title}.mp3"
-
-    return None
-
-
-async def download_audio_concurrent(link: str) -> Optional[str]:
-    video_id = extract_video_id(link)
-
-    existing = file_exists(video_id)
-    if existing:
-        return existing
-
-    if not USE_API:
-        return await yt_dlp_download(link, type="audio")
-
-    yt_task = asyncio.create_task(yt_dlp_download(link, type="audio"))
-    api_task = asyncio.create_task(api_download_song(link))
-
-    done, _ = await asyncio.wait([yt_task, api_task], return_when=asyncio.FIRST_COMPLETED)
-
-    for task in done:
-        try:
-            result = task.result()
-            if result:
-                return result
-        except Exception as e:
-            print(f"[Download Task Error] {e}")
-
-    for task in [yt_task, api_task]:
-        if not task.done():
-            try:
-                result = await task
-                if result:
-                    return result
-            except Exception as e:
-                print(f"[Fallback Task Error] {e}")
-
-    return None 

DragMusic/utils/stream/stream.py

@@ -75,7 +75,7 @@ async def stream(
                 status = True if video else None
                 try:
                     file_path, direct = await YouTube.download(
-                        vidid, mystic, video=status
+                        vidid, mystic, video=status, videoid=True
                     )
                 except:
                     raise AssistantErr(_["play_14"])
@@ -139,7 +139,7 @@ async def stream(
         status = True if video else None
         try:
             file_path, direct = await YouTube.download(
-                vidid, mystic, video=status
+                vidid, mystic, videoid=True, video=status
             )
         except:
             raise AssistantErr(_["play_14"])
@@ -417,4 +417,4 @@ async def stream(
             )
             db[chat_id][0]["mystic"] = run
             db[chat_id][0]["markup"] = "tg"
-            await mystic.delete()
+            await mystic.delete()

config.py

@@ -117,14 +117,3 @@ if SUPPORT_CHAT:
         raise SystemExit(
             "[ERROR] - Your SUPPORT_CHAT url is wrong. Please ensure that it starts with https://"
 )
-
-# Miscellaneous
-REPLY_MESSAGE = getenv("REPLY_MESSAGE", None)
-F_SUB_URL = getenv("F_SUB_URL", None)
-WELCOME_DELAY_KICK_SEC = getenv("WELCOME_DELAY_KICK_SEC", None)
-
-# Add these new variables
-AYU = [
-    "❤️", "✨", "🔥", "🎵", "🎶",
-    "🎉", "😊", "👍", "🚀", "🌟"
-]

requirements.txt

@@ -35,7 +35,7 @@ googlesearch-python
 unidecode
 #git+https://github.com/joetats/youtube_search@master
 #git+https://github.com/alexmercerind/youtube-search-python@main
-https://github.com/KurimuzonAkuma/pyrogram/archive/v2.1.23.zip
+https://github.com/KurimuzonAkuma/pyrogram/archive/v2.2.6.zip
 git+https://github.com/AsmSafone/SafoneAPI
 bing_image_downloader
 openai==0.28