feat: Overhaul play command with advanced features

DragMusic/platforms/Youtube.py

@@ -1,15 +1,18 @@
 import asyncio
 import os
 import re
-from typing import Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import yt_dlp
 from pyrogram.enums import MessageEntityType
 from pyrogram.types import Message
+from youtubesearchpython.__future__ import VideosSearch
 
 from DragMusic.utils.database import is_on_off
+from DragMusic.utils.errors import capture_internal_err
 from DragMusic.utils.formatters import time_to_seconds
 
+_cache = {}
 
 async def shell_cmd(cmd):
     proc = await asyncio.create_subprocess_shell(
@@ -35,6 +38,43 @@ class YouTubeAPI:
         if os.path.exists(cookie_file):
             self.opts["cookiefile"] = cookie_file
 
+    @capture_internal_err
+    async def exists(self, url: str):
+        return bool(re.search(r"youtube\.com|youtu\.be", url))
+
+    @capture_internal_err
+    async def slider(self, query: str, query_type: int):
+        search = VideosSearch(query, limit=10)
+        results = await search.next()
+        result_list = results.get("result", [])
+        if not result_list:
+            return None, None, None, None
+        
+        if query_type >= len(result_list):
+            query_type = 0
+            
+        info = result_list[query_type]
+        title = info.get("title", "Unknown Title")
+        duration_min = info.get("duration", "0:00")
+        thumbnail = info.get("thumbnails", [{}])[0].get("url", "").split("?")[0]
+        vidid = info.get("id", "")
+        return title, duration_min, thumbnail, vidid
+
+    @capture_internal_err
+    async def _fetch_info(self, query: str, use_cache: bool = True):
+        if use_cache and 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[0]
+            return result_data[0]
+        return None
+
+    @capture_internal_err
     async def get_info(self, link: str):
         """Fetches all video information using yt-dlp."""
         full_url = self.base + link if not link.startswith("http") else link
@@ -42,16 +82,56 @@ class YouTubeAPI:
             info = ydl.extract_info(full_url, download=False)
         return info
 
-    async def details(self, link: str):
+    @capture_internal_err
+    async def details(self, link: str, videoid: bool = False):
         """Gets essential video details."""
-        info = await self.get_info(link)
+        if videoid:
+            link = self.base + link
+        
+        info = await self._fetch_info(link, use_cache=False)
+        if not info:
+            info = await self.get_info(link)
+
         title = info.get("title", "Unknown Title")
-        duration_min = info.get("duration_string", "0:00")
-        duration_sec = info.get("duration", 0)
-        thumbnail = info.get("thumbnail", "")
+        duration_min = info.get("duration", "0:00")
+        duration_sec = time_to_seconds(duration_min) if duration_min else 0
+        thumbnail = info.get("thumbnails", [{}])[0].get("url", "").split("?")[0] or info.get("thumbnail", "")
         vidid = info.get("id", "")
         return title, duration_min, duration_sec, thumbnail, vidid
 
+    @capture_internal_err
+    async def search(self, query: str):
+        """Searches for a video and returns its details."""
+        info = await self._fetch_info(query)
+        if not info:
+            return None, None
+            
+        details = {
+            "title": info.get("title", "Unknown Title"),
+            "link": info.get("link", ""),
+            "vidid": info.get("id", ""),
+            "duration_min": info.get("duration", "0:00"),
+            "thumb": info.get("thumbnails", [{}])[0].get("url", "").split("?")[0],
+        }
+        track_id = info.get("id", "")
+        return details, track_id
+
+    @capture_internal_err
+    async def track(self, link: str, videoid: bool = False):
+        """Gets track details for a single video."""
+        if videoid:
+            link = self.base + link
+        info = await self.get_info(link)
+        track_details = {
+            "title": info.get("title", "Unknown Title"),
+            "link": info.get("webpage_url", ""),
+            "vidid": info.get("id", ""),
+            "duration_min": info.get("duration_string", "0:00"),
+            "thumb": info.get("thumbnail", ""),
+        }
+        return track_details, info.get("id", "")
+
+    @capture_internal_err
     async def url(self, message: "Message") -> Union[str, None]:
         """Extracts a URL from a Pyrogram message."""
         for entity in message.entities or message.caption_entities or []:
@@ -59,37 +139,22 @@ class YouTubeAPI:
                 return entity.url or message.text[entity.offset:entity.offset + entity.length]
         return None
 
+    @capture_internal_err
     async def title(self, link: str):
         info = await self.get_info(link)
         return info.get("title", "Unknown Title")
 
+    @capture_internal_err
     async def duration(self, link: str):
         info = await self.get_info(link)
         return info.get("duration_string", "0:00")
 
+    @capture_internal_err
     async def thumbnail(self, link: str):
         info = await self.get_info(link)
         return info.get("thumbnail", "")
 
-    async def search(self, query: str):
-        """Searches for a video and returns its details."""
-        search_opts = self.opts.copy()
-        try:
-            with yt_dlp.YoutubeDL(search_opts) as ydl:
-                info = ydl.extract_info(f"ytsearch:{query}", download=False)['entries'][0]
-            
-            details = {
-                "title": info.get("title", "Unknown Title"),
-                "link": info.get("webpage_url", ""),
-                "vidid": info.get("id", ""),
-                "duration_min": info.get("duration_string", "0:00"),
-                "thumb": info.get("thumbnail", ""),
-            }
-            track_id = info.get("id", "")
-            return details, track_id
-        except Exception:
-            return None, None
-
+    @capture_internal_err
     async def get_best_audio_url(self, link: str):
         """Gets the URL of the best quality audio stream."""
         info = await self.get_info(link)
@@ -100,6 +165,7 @@ class YouTubeAPI:
                     best_audio = f
         return best_audio["url"] if best_audio else None
 
+    @capture_internal_err
     async def get_best_video_url(self, link: str, quality: str = "720"):
         """Gets the URL of the best video stream for a given quality."""
         info = await self.get_info(link)
@@ -110,7 +176,7 @@ class YouTubeAPI:
                      best_video = f
         return best_video["url"] if best_video else None
 
-
+    @capture_internal_err
     async def playlist(self, link: str, limit: int, user_id, videoid: bool = False):
         """Fetches video IDs from a playlist."""
         if videoid:
@@ -124,18 +190,7 @@ class YouTubeAPI:
             info = ydl.extract_info(link, download=False)
             return [entry["id"] for entry in info.get("entries", []) if entry]
 
-    async def track(self, link: str):
-        """Gets track details for a single video."""
-        info = await self.get_info(link)
-        track_details = {
-            "title": info.get("title", "Unknown Title"),
-            "link": info.get("webpage_url", ""),
-            "vidid": info.get("id", ""),
-            "duration_min": info.get("duration_string", "0:00"),
-            "thumb": info.get("thumbnail", ""),
-        }
-        return track_details, info.get("id", "")
-
+    @capture_internal_err
     async def formats(self, link: str):
         """Gets available formats for a video."""
         info = await self.get_info(link)
@@ -152,6 +207,7 @@ class YouTubeAPI:
                  })
         return formats_available, info.get("webpage_url", "")
     
+    @capture_internal_err
     async def download(self, link: str, mystic, video: bool = None, format_id: str = None) -> Union[str, None]:
         """Downloads a video or audio file and returns the path."""
         file_path = f"downloads/{link}.%(ext)s"

DragMusic/plugins/play/play.py

@@ -1,8 +1,10 @@
 import random
 import string
+import asyncio
 
 from pyrogram import filters
 from pyrogram.types import InlineKeyboardMarkup, InputMediaPhoto, Message
+from pyrogram.errors import FloodWait, RandomIdDuplicate
 from pytgcalls.exceptions import NoActiveGroupCall
 
 import config
@@ -12,6 +14,7 @@ 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_internal_err
 from DragMusic.utils.formatters import formats
 from DragMusic.utils.inline import (
     botplaylist_markup,
@@ -22,69 +25,59 @@ from DragMusic.utils.inline import (
 )
 from DragMusic.utils.logger import play_logs
 from DragMusic.utils.stream.stream import stream
-from config import BANNED_USERS, lyrical
+from config import BANNED_USERS, lyrical, AYU
 
 
 @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
-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
+@capture_internal_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
     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
-    )
-    video_telegram = (
-        (message.reply_to_message.video or message.reply_to_message.document)
-        if message.reply_to_message
-        else None
+        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)
-        if await Telegram.download(_, message, mystic, file_path):
+        downloaded = await Telegram.download(_, message, mystic, file_path)
+        if downloaded:
             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,
@@ -105,37 +98,48 @@ async def play_commnd(
                     forceplay=fplay,
                 )
             except Exception as e:
-                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
-    elif video_telegram:
+
+    video_telegram = (
+        (message.reply_to_message.video or message.reply_to_message.document)
+        if message.reply_to_message else None
+    )
+
+    if 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(f"{' | '.join(formats)}")
+                        _["play_7"].format(" | ".join(formats))
                     )
             except:
                 return await mystic.edit_text(
-                    _["play_7"].format(f"{' | '.join(formats)}")
+                    _["play_7"].format(" | ".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)
-        if await Telegram.download(_, message, mystic, file_path):
+        downloaded = await Telegram.download(_, message, mystic, file_path)
+        if downloaded:
             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(
                     _,
@@ -150,36 +154,44 @@ async def play_commnd(
                     forceplay=fplay,
                 )
             except Exception as e:
-                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
-    elif url:
-        if "youtube.com/playlist" in url:
-            try:
-                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"
-            if "&" in url:
-                plist_id = (url.split("=")[1]).split("&")[0]
+
+    if url:
+        if await YouTube.exists(url):
+            if "playlist" in url:
+                try:
+                    details = await YouTube.playlist(url, config.PLAYLIST_FETCH_LIMIT, user_id)
+                except:
+                    return await mystic.edit_text(_["play_3"])
+
+                streamtype = "playlist"
+                plist_type = "yt"
+                if "&" in url:
+                    plist_id = (url.split("=")[1]).split("&")[0]
+                else:
+                    plist_id = url.split("=")[1]
+                img = config.PLAYLIST_IMG_URL
+                cap = _["play_9"]
             else:
-                plist_id = url.split("=")[1]
-            img = config.PLAYLIST_IMG_URL
-            cap = _["play_9"]
+                try:
+                    details, track_id = await YouTube.track(url)
+                except Exception:
+                    return await mystic.edit_text(_["play_3"])
+                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 and not config.SPOTIFY_CLIENT_SECRET:
+            if not config.SPOTIFY_CLIENT_ID or not config.SPOTIFY_CLIENT_SECRET:
                 return await mystic.edit_text(
                     "» sᴘᴏᴛɪғʏ ɪs ɴᴏᴛ sᴜᴘᴘᴏʀᴛᴇᴅ ʏᴇᴛ.\n\nᴘʟᴇᴀsᴇ ᴛʀʏ ᴀɢᴀɪɴ ʟᴀᴛᴇʀ."
                 )
+
             if "track" in url:
                 try:
                     details, track_id = await Spotify.track(url)
@@ -191,7 +203,7 @@ async def play_commnd(
             elif "playlist" in url:
                 try:
                     details, plist_id = await Spotify.playlist(url)
-                except Exception:
+                except:
                     return await mystic.edit_text(_["play_3"])
                 streamtype = "playlist"
                 plist_type = "spplay"
@@ -234,10 +246,10 @@ async def play_commnd(
                     return await mystic.edit_text(_["play_3"])
                 streamtype = "playlist"
                 plist_type = "apple"
-                cap = _["play_12"].format(app.mention, message.from_user.mention)
                 img = url
+                cap = _["play_12"].format(app.mention, message.from_user.mention)
             else:
-                return await mystic.edit_text(_["play_15"])
+                return await mystic.edit_text(_["play_3"])
         elif await Resso.valid(url):
             try:
                 details, track_id = await Resso.track(url)
@@ -248,48 +260,97 @@ async def play_commnd(
             cap = _["play_10"].format(details["title"], details["duration_min"])
         elif await SoundCloud.valid(url):
             try:
-                details, track_id = await SoundCloud.track(url)
-            except:
-                return await mystic.edit_text(_["play_3"])
-            streamtype = "youtube"
-            img = details["thumb"]
-            cap = _["play_10"].format(details["title"], details["duration_min"])
+                details, track_path = await SoundCloud.download(url)
+                if details["duration_sec"] > config.DURATION_LIMIT:
+                    return await mystic.edit_text(
+                        _["play_6"].format(config.DURATION_LIMIT_MIN, app.mention)
+                    )
+                await stream(
+                    _,
+                    mystic,
+                    user_id,
+                    details,
+                    chat_id,
+                    user_name,
+                    message.chat.id,
+                    streamtype="soundcloud",
+                    forceplay=fplay,
+                )
+            except Exception as 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:
-                title, duration_min, duration_sec, thumbnail, vidid = await YouTube.details(url)
-                details = {
-                    "title": title,
-                    "link": url,
-                    "vidid": vidid,
-                    "duration_min": duration_min,
-                    "thumb": thumbnail,
-                }
-                streamtype = "youtube"
-                img = details["thumb"]
-                cap = _["play_10"].format(
-                    details["title"],
-                    details["duration_min"],
+                await Drag.stream_call(url)
+            except NoActiveGroupCall:
+                await mystic.edit_text(_["black_9"])
+                return await app.send_message(
+                    chat_id=config.LOGGER_ID,
+                    text=_["play_17"],
                 )
             except Exception as e:
-                print(e)
-                return await mystic.edit_text(_["play_3"])
+                return await mystic.edit_text(_["general_2"].format(type(e).__name__))
+
+            await mystic.edit_text(_["str_2"])
+            try:
+                await stream(
+                    _,
+                    mystic,
+                    user_id,
+                    url,
+                    chat_id,
+                    user_name,
+                    message.chat.id,
+                    video=video,
+                    streamtype="index",
+                    forceplay=fplay,
+                )
+            except Exception as 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")
     else:
         if len(message.command) < 2:
-            return await mystic.edit_text(_["play_16"])
-        await mystic.edit_text(_["play_18"])
+            buttons = botplaylist_markup(_)
+            return await mystic.edit_text(
+                _["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.search(query)
-            if details is None:
-                return await mystic.edit_text(_["play_3"])
         except:
             return await mystic.edit_text(_["play_3"])
         streamtype = "youtube"
-        img = details["thumb"]
-        cap = _["play_10"].format(details["title"], details["duration_min"])
-    if streamtype == "playlist":
-        await mystic.edit_text(_["play_19"])
-        await play_logs(message, streamtype="Playlist")
+
+    if str(playmode) == "Direct":
+        if not plist_type:
+            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,
+                    user_id,
+                    "v" if video else "a",
+                    "c" if channel else "g",
+                    "f" if fplay else "d",
+                )
+                return await mystic.edit_text(
+                    _["play_13"],
+                    reply_markup=InlineKeyboardMarkup(buttons),
+                )
+
         try:
             await stream(
                 _,
@@ -300,112 +361,118 @@ async def play_commnd(
                 user_name,
                 message.chat.id,
                 video=video,
-                streamtype="playlist",
-                playlist_id=plist_id,
-                playlist_type=plist_type,
+                streamtype=streamtype,
+                spotify=spotify,
                 forceplay=fplay,
             )
         except Exception as e:
-            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()
+        await mystic.delete()
+        return await play_logs(message, streamtype=streamtype)
     else:
-        if slider:
-            buttons = slider_markup(
+        if plist_type:
+            ran_hash = "".join(random.choices(string.ascii_uppercase + string.digits, k=10))
+            lyrical[ran_hash] = plist_id
+            buttons = playlist_markup(
                 _,
-                track_id,
+                ran_hash,
                 user_id,
-                query,
-                0,
-                "play",
-                video,
-                fplay,
+                plist_type,
+                "c" if channel else "g",
+                "f" if fplay else "d",
             )
             await mystic.delete()
-            await app.send_photo(
-                chat_id=message.chat.id,
-                photo=img,
-                caption=_["play_20"].format(app.mention),
-                reply_markup=InlineKeyboardMarkup(buttons),
-            )
-            return
-        else:
-            buttons = track_markup(
-                _,
-                track_id,
-                user_id,
-                chat_id,
-                video,
-                fplay,
-            )
-            await mystic.delete()
-            await app.send_photo(
-                chat_id=message.chat.id,
-                photo=img,
+            await message.reply_photo(
+                photo=(details["thumb"] if plist_type == "yt" else img),
                 caption=cap,
                 reply_markup=InlineKeyboardMarkup(buttons),
             )
-            return
+            return await play_logs(message, streamtype=f"Playlist : {plist_type}")
+        else:
+            if slider:
+                buttons = slider_markup(
+                    _,
+                    track_id,
+                    user_id,
+                    query,
+                    0,
+                    "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"].title(),
+                        details["duration_min"],
+                    ),
+                    reply_markup=InlineKeyboardMarkup(buttons),
+                )
+                return await play_logs(message, streamtype="Searched on YouTube")
+            else:
+                buttons = track_markup(
+                    _,
+                    track_id,
+                    user_id,
+                    "c" if channel else "g",
+                    "f" if fplay else "d",
+                )
+                await mystic.delete()
+                await message.reply_photo(
+                    photo=img,
+                    caption=cap,
+                    reply_markup=InlineKeyboardMarkup(buttons),
+                )
+                return await play_logs(message, streamtype="URL Search Inline")
 
 
 @app.on_callback_query(filters.regex("MusicStream") & ~BANNED_USERS)
 @languageCB
+@capture_internal_err
 async def play_music(client, CallbackQuery, _):
-    callback_data = CallbackQuery.data.strip()
-    callback_request = callback_data.split(None, 1)[1]
-    (
-        videoid,
-        user_id,
-        what,
-        chattype,
-        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(_, what, ch)
-    except:
-        return await CallbackQuery.edit_message_text(_["play_14"])
-    video = True if what == "v" else None
-    user_name = CallbackQuery.from_user.first_name
-    await CallbackQuery.message.delete()
     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):
+            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()
-    except:
-        pass
-    mystic = await app.send_message(chat_id, _["play_2"].format(channel))
-    try:
-        details, track_id = await YouTube.track(videoid)
-    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:
+
+        try:
+            mystic = await app.send_message(chat_id, random.choice(AYU))
+        except (FloodWait, RandomIdDuplicate):
+            pass
+
+        details, track_id = await YouTube.track(vidid, videoid=True)
+
+        if details.get("duration_min"):
+            duration_sec = time_to_seconds(details["duration_min"])
+            if 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",
+            )
             return await mystic.edit_text(
-                _["play_6"].format(config.DURATION_LIMIT_MIN, app.mention)
+                _["play_13"], reply_markup=InlineKeyboardMarkup(buttons)
             )
-    else:
-        buttons = livestream_markup(
-            _,
-            videoid,
-            user_id,
-            "play",
-            chat_id,
-            video,
-        )
-        return await mystic.edit_text(
-            _["play_13"],
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    video = True if what == "v" else None
-    ffplay = True if fplay == "f" else None
-    await play_logs(CallbackQuery, streamtype="Video" if video else "Audio")
-    try:
+
+        video = mode == "v"
+        forceplay = fplay == "f"
+
         await stream(
             _,
             mystic,
@@ -416,57 +483,118 @@ async def play_music(client, CallbackQuery, _):
             CallbackQuery.message.chat.id,
             video,
             streamtype="youtube",
-            forceplay=ffplay,
+            forceplay=forceplay,
         )
+        await mystic.delete()
     except Exception as e:
-        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 await CallbackQuery.message.reply_text(err)
 
 
 @app.on_callback_query(filters.regex("DragmousAdmin") & ~BANNED_USERS)
-async def Dragmous_check(client, CallbackQuery):
-    try:
-        await CallbackQuery.answer(
-            "» ʀᴇᴠᴇʀᴛ ʙᴀᴄᴋ ᴛᴏ ᴜsᴇʀ ᴀᴄᴄᴏᴜɴᴛ :\n\nᴏᴘᴇɴ ʏᴏᴜʀ ɢʀᴏᴜᴘ sᴇᴛᴛɪɴɢs.\n-> ᴀᴅᴍɪɴɪsᴛʀᴀᴛᴏʀs\n-> ᴄʟɪᴄᴋ ᴏɴ ʏᴏᴜʀ ɴᴀᴍᴇ\n-> ᴜɴᴄʜᴇᴄᴋ ᴀɴᴏɴʏᴍᴏᴜs ᴀᴅᴍɪɴ ᴘᴇʀᴍɪssɪᴏɴs.",
-            show_alert=True,
-        )
-    except:
-        pass
+@capture_internal_err
+async def anonymous_check(client, CallbackQuery):
+    await CallbackQuery.answer(
+        "» ʀᴇᴠᴇʀᴛ ʙᴀᴄᴋ ᴛᴏ ᴜsᴇʀ ᴀᴄᴄᴏᴜɴᴛ :\n\n"
+        "ᴏᴘᴇɴ ʏᴏᴜʀ ɢʀᴏᴜᴘ sᴇᴛᴛɪɴɢs.\n"
+        "-> ᴀᴅᴍɪɴɪsᴛʀᴀᴛᴏʀs\n-> ᴄʟɪᴄᴋ ᴏɴ ʏᴏᴜʀ ɴᴀᴍᴇ\n"
+        "-> ᴜɴᴄʜᴇᴄᴋ ᴀɴᴏɴʏᴍᴏᴜs ᴀᴅᴍɪɴ ᴘᴇʀᴍɪssɪᴏɴs.",
+        show_alert=True,
+    )
 
 
 @app.on_callback_query(filters.regex("AviaxPlaylists") & ~BANNED_USERS)
 @languageCB
+@capture_internal_err
 async def play_playlists_command(client, CallbackQuery, _):
-    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:
-            return await CallbackQuery.answer(_["playcb_1"], show_alert=True)
-        except:
-            return
     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)
-    except:
-        return
-    user_name = CallbackQuery.from_user.first_name
-    await CallbackQuery.message.delete()
-    try:
+        user_name = CallbackQuery.from_user.first_name
+        await CallbackQuery.message.delete()
         await CallbackQuery.answer()
+
+        try:
+            mystic = await app.send_message(chat_id, random.choice(AYU))
+        except (FloodWait, RandomIdDuplicate):
+            pass
+
+        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 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:
+        ex_type = type(e).__name__
+        err = e if ex_type == "AssistantErr" else _["general_2"].format(ex_type)
+        return await CallbackQuery.message.reply_text(err)
+
+
+@app.on_callback_query(filters.regex("slider") & ~BANNED_USERS)
+@languageCB
+@capture_internal_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:
         pass
-    mystic = await CallbackQuery.message.reply_text(
-        _["play_2"].format(channel) if channel else _["play_1"]
-    )
-    videoid = lyrical.get(videoid)
-    video = True if mode == "v" else None

DragMusic/utils/errors.py

@@ -0,0 +1,13 @@
+from functools import wraps
+import traceback
+
+def capture_internal_err(func):
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except Exception as e:
+            print(f"An internal error occurred in {func.__name__}:")
+            traceback.print_exc()
+            return None
+    return wrapper 

config.py

@@ -117,3 +117,14 @@ 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 = [
+    "❤️", "✨", "🔥", "🎵", "🎶",
+    "🎉", "😊", "👍", "🚀", "🌟"
+]

cookies.txt

@@ -1,17 +0,0 @@
-# Netscape HTTP Cookie File
-# http://curl.haxx.se/rfc/cookie_spec.html
-# This file was generated by Cookie-Editor
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1742921152	YTSESSION-1b	ANPz9Kij0V5aPjAttfZnRD4suOkGNjcz71q/xU0sngZqCq6hloIsSWAFbPEQs27oatdAAu+UOnVdqHYpAHAX/sazeOPD+W6qV1UK1w4=
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1777481033	__Secure-3PSID	g.a000vAg8Bwo4A5fv1NfvT2I_Xqfi4q1nb9NAILFCge0h-2Cy7HusWTyvvIa4FO4BSmdbR6CFxwACgYKAaISARYSFQHGX2MijMXK3BV7jH8exWDuhU97choVAUF8yKobdzO11tjJBgWksmpx0h9L0076
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1742922832	GPS	1
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1774457033	__Secure-1PSIDTS	sidts-CjEB7pHptSAYHEZy5rb_OuZ_7NBWl8AzZVFx7tIFEB4aNPNKlP715S5LMgfhdD5n2_MtEAA
-.youtube.com	TRUE	/	TRUE	1777481033	SAPISID	3GQv2sj-2w3zrw2J/AvZHeLBzSCg3geUBk
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1774457132	__Secure-1PSIDCC	AKEyXzUwvFFY1fEphh9h5DcjJ_qi4A81tMwebn_aCgQ8FAyahMtFeczYZvw7wMv5e4tlO9W9Sw
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1777481033	SSID	ALdDq3hPOhryHiBTk
-.youtube.com	TRUE	/	TRUE	1777481033	__Secure-1PAPISID	3GQv2sj-2w3zrw2J/AvZHeLBzSCg3geUBk
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1777481033	__Secure-1PSID	g.a000vAg8Bwo4A5fv1NfvT2I_Xqfi4q1nb9NAILFCge0h-2Cy7HusUywUecfgnF11rqmsMWsLsQACgYKAb0SARYSFQHGX2MiwbMAvy-q6FczWi2M0wMoQhoVAUF8yKrzvMeeJByv6o9DZGxhhH4n0076
-.youtube.com	TRUE	/	TRUE	1777481033	__Secure-3PAPISID	3GQv2sj-2w3zrw2J/AvZHeLBzSCg3geUBk
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1774457132	__Secure-3PSIDCC	AKEyXzXj1GiFMV5Umszk5kRXg8j6dmUEDJdjkv_ty12JJm5zood-XieGGKljVfqEVo5Xncd0Pw
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1774457033	__Secure-3PSIDTS	sidts-CjEB7pHptSAYHEZy5rb_OuZ_7NBWl8AzZVFx7tIFEB4aNPNKlP715S5LMgfhdD5n2_MtEAA
-#HttpOnly_.youtube.com	TRUE	/	TRUE	1777481033	LOGIN_INFO	AFmmF2swRQIgdcJU8AlPASy-JQuMIAgtjaemwSB4uvrzaeU9T-xHuqgCIQCov2OFYIGh9LQtaoKwDe6g3_ByZU_YtmBIQTRCNsSEBw:QUQ3MjNmejlhUTh1bkNYMkRod2t6akFMVHNaV0M5UEFGSkZXbEQ5Qy01Rkp0X25wTkw3NU5ra1lSdTZDZ0h1akxJdlpQU2wtaEo4Y3NCVk9kV1VkYm9Lblp5RmFfQXYzcUE5UGdfbm1jdXM2TEc5U3Q5OV94NXE3N05GYXBTVDVOMzdIcmFEckVzQmN0cl9OSzhDemJPb1lIT2lkZkk0MUln
-.youtube.com	TRUE	/	TRUE	1777481036	PREF	tz=Asia.Calcutta

cookies/cookies.txt

@@ -1 +0,0 @@
-