fix(youtube): implement search and fix callback

DragMusic/platforms/Youtube.py

@@ -67,6 +67,25 @@ class YouTubeAPI:
         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
+
     async def get_best_audio_url(self, link: str):
         """Gets the URL of the best quality audio stream."""
         info = await self.get_info(link)

DragMusic/plugins/play/play.py

@@ -157,35 +157,23 @@ async def play_commnd(
             return await mystic.delete()
         return
     elif url:
-        if await YouTube.exists(url):
-            if "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]
-                else:
-                    plist_id = url.split("=")[1]
-                img = config.PLAYLIST_IMG_URL
-                cap = _["play_9"]
-            else:
-                try:
-                    details, track_id = await YouTube.track(url)
-                except:
-                    return await mystic.edit_text(_["play_3"])
-                streamtype = "youtube"
-                img = details["thumb"]
-                cap = _["play_10"].format(
-                    details["title"],
-                    details["duration_min"],
+        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]
+            else:
+                plist_id = url.split("=")[1]
+            img = config.PLAYLIST_IMG_URL
+            cap = _["play_9"]
         elif await Spotify.valid(url):
             spotify = True
             if not config.SPOTIFY_CLIENT_ID and not config.SPOTIFY_CLIENT_SECRET:
@@ -249,7 +237,7 @@ async def play_commnd(
                 cap = _["play_12"].format(app.mention, message.from_user.mention)
                 img = url
             else:
-                return await mystic.edit_text(_["play_3"])
+                return await mystic.edit_text(_["play_15"])
         elif await Resso.valid(url):
             try:
                 details, track_id = await Resso.track(url)
@@ -260,104 +248,48 @@ async def play_commnd(
             cap = _["play_10"].format(details["title"], details["duration_min"])
         elif await SoundCloud.valid(url):
             try:
-                details, track_path = await SoundCloud.download(url)
+                details, track_id = await SoundCloud.track(url)
             except:
                 return await mystic.edit_text(_["play_3"])
-            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,
-                    )
-                )
-            try:
-                await stream(
-                    _,
-                    mystic,
-                    user_id,
-                    details,
-                    chat_id,
-                    user_name,
-                    message.chat.id,
-                    streamtype="soundcloud",
-                    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()
+            streamtype = "youtube"
+            img = details["thumb"]
+            cap = _["play_10"].format(details["title"], details["duration_min"])
         else:
             try:
-                await Aviax.stream_call(url)
-            except NoActiveGroupCall:
-                await mystic.edit_text(_["black_9"])
-                return await app.send_message(
-                    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,
-                    message.from_user.id,
-                    url,
-                    chat_id,
-                    message.from_user.first_name,
-                    message.chat.id,
-                    video=video,
-                    streamtype="index",
-                    forceplay=fplay,
+                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"],
                 )
             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 play_logs(message, streamtype="M3u8 or Index Link")
+                print(e)
+                return await mystic.edit_text(_["play_3"])
     else:
         if len(message.command) < 2:
-            buttons = botplaylist_markup(_)
-            return await mystic.edit_text(
-                _["play_18"],
-                reply_markup=InlineKeyboardMarkup(buttons),
-            )
-        slider = True
+            return await mystic.edit_text(_["play_16"])
+        await mystic.edit_text(_["play_18"])
         query = message.text.split(None, 1)[1]
-        if "-v" in query:
-            query = query.replace("-v", "")
         try:
-            details, track_id = await YouTube.track(query)
+            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"
-    if str(playmode) == "Direct":
-        if not plist_type:
-            if details["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,
-                    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),
-                )
+        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")
         try:
             await stream(
                 _,
@@ -368,8 +300,9 @@ async def play_commnd(
                 user_name,
                 message.chat.id,
                 video=video,
-                streamtype=streamtype,
-                spotify=spotify,
+                streamtype="playlist",
+                playlist_id=plist_id,
+                playlist_type=plist_type,
                 forceplay=fplay,
             )
         except Exception as e:
@@ -377,65 +310,44 @@ async def play_commnd(
             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)
+        return await mystic.delete()
     else:
-        if plist_type:
-            ran_hash = "".join(
-                random.choices(string.ascii_uppercase + string.digits, k=10)
+        if slider:
+            buttons = slider_markup(
+                _,
+                track_id,
+                user_id,
+                query,
+                0,
+                "play",
+                video,
+                fplay,
             )
-            lyrical[ran_hash] = plist_id
-            buttons = playlist_markup(
+            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(
                 _,
-                ran_hash,
-                message.from_user.id,
-                plist_type,
-                "c" if channel else "g",
-                "f" if fplay else "d",
+                track_id,
+                user_id,
+                chat_id,
+                video,
+                fplay,
             )
             await mystic.delete()
-            await message.reply_photo(
+            await app.send_photo(
+                chat_id=message.chat.id,
                 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,
-                    message.from_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=f"Searched on Youtube")
-            else:
-                buttons = track_markup(
-                    _,
-                    track_id,
-                    message.from_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=f"URL Searched Inline")
+            return
 
 
 @app.on_callback_query(filters.regex("MusicStream") & ~BANNED_USERS)
@@ -443,27 +355,32 @@ async def play_commnd(
 async def play_music(client, CallbackQuery, _):
     callback_data = CallbackQuery.data.strip()
     callback_request = callback_data.split(None, 1)[1]
-    vidid, user_id, mode, cplay, fplay = callback_request.split("|")
+    (
+        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(_, cplay, CallbackQuery)
+        chat_id, channel = await get_channeplayCB(_, what, ch)
     except:
-        return
+        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:
-        await CallbackQuery.message.delete()
         await CallbackQuery.answer()
     except:
         pass
-    mystic = await CallbackQuery.message.reply_text(
-        _["play_2"].format(channel) if channel else _["play_1"]
-    )
+    mystic = await app.send_message(chat_id, _["play_2"].format(channel))
     try:
-        details, track_id = await YouTube.track(vidid, True)
+        details, track_id = await YouTube.track(videoid)
     except:
         return await mystic.edit_text(_["play_3"])
     if details["duration_min"]:
@@ -475,18 +392,19 @@ async def play_music(client, CallbackQuery, _):
     else:
         buttons = livestream_markup(
             _,
-            track_id,
-            CallbackQuery.from_user.id,
-            mode,
-            "c" if cplay == "c" else "g",
-            "f" if fplay else "d",
+            videoid,
+            user_id,
+            "play",
+            chat_id,
+            video,
         )
         return await mystic.edit_text(
             _["play_13"],
             reply_markup=InlineKeyboardMarkup(buttons),
         )
-    video = True if mode == "v" else None
+    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:
         await stream(
             _,
@@ -551,4 +469,4 @@ async def play_playlists_command(client, CallbackQuery, _):
         _["play_2"].format(channel) if channel else _["play_1"]
     )
     videoid = lyrical.get(videoid)
-    video = Tr
+    video = True if mode == "v" else None