feat: implement join requests and restructure plugins

DragMusic/plugins/bot/approve.text

@@ -1,28 +0,0 @@
-from DragMusic import app
-from os import environ
-from pyrogram import Client, filters
-from pyrogram.types import ChatJoinRequest
-from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
-
-EVAA = [
-    [
-        InlineKeyboardButton(text="ᴀᴅᴅ ᴍᴇ ʙᴀʙʏ", url=f"https://t.me/DragMusicBot?startgroup=true"),
-    ],
-]
-
-# Extract environment variables or provide default values
-chat_id_env = environ.get("CHAT_ID")
-CHAT_ID = [int(app) for app in chat_id_env.split(",")] if chat_id_env else []
-
-TEXT = environ.get("APPROVED_WELCOME_TEXT", "❅ ʜᴇʟʟᴏ ʙᴀʙʏ {mention}\n\n❅ ᴡᴇʟᴄᴏᴍᴇ ᴛᴏ {title}\n\n")
-APPROVED = environ.get("APPROVED_WELCOME", "on").lower()
-
-# Define an event handler for chat join requests
-@app.on_chat_join_request((filters.group | filters.channel) & filters.chat(CHAT_ID) if CHAT_ID else (filters.group | filters.channel))
-async def autoapprove(client: app, message: ChatJoinRequest):
-    chat = message.chat  # Chat
-    user = message.from_user  # User
-    print(f"๏ {user.first_name} ᴊᴏɪɴᴇᴅ 🤝")  # Logs
-    await client.approve_chat_join_request(chat_id=chat.id, user_id=user.id)
-    if APPROVED == "on":
-        await client.send_message(chat_id=chat.id, text=TEXT.format(mention=user.mention, title=chat.title),reply_markup=InlineKeyboardMarkup(EVAA),)

DragMusic/plugins/bot/fakeinfo.py

@@ -1,47 +0,0 @@
-import requests
-from DragMusic import app as Checker
-from pyrogram import filters
-
-
-@Checker.on_message(filters.command("fake"))
-async def address(_, message):
-    message_text = message.text.strip()
-    words = message_text.split()
-    
-    if len(words) > 1:
-        query = words[1].strip()
-        url = f"https://randomuser.me/api/?nat={query}"
-    response = requests.get(url)
-    data = response.json()
-
-    if "results" in data:
-        user_data = data["results"][0]
-
-        
-        name = f"{user_data['name']['title']} {user_data['name']['first']} {user_data['name']['last']}"
-        address = f"{user_data['location']['street']['number']} {user_data['location']['street']['name']}" 
-        city = user_data['location']['city']
-        state = user_data['location']['state']
-        country = user_data['location']['country'] 
-        postal = user_data['location']['postcode']
-        email = user_data['email']
-        phone = user_data['phone']
-        picture_url = user_data['picture']['large']
-
-        
-        caption = f"""
-﹝⌬﹞**ɴᴀᴍᴇ** ⇢ {name}
-﹝⌬﹞**ᴀᴅᴅʀᴇss** ⇢ {address}
-﹝⌬﹞**ᴄᴏᴜɴᴛʀʏ** ⇢ {country}
-﹝⌬﹞**ᴄɪᴛʏ** ⇢ {city}
-﹝⌬﹞**sᴛᴀᴛᴇ** ⇢ {state}
-﹝⌬﹞**ᴘᴏsᴛᴀʟ** ⇢ {postal}
-﹝⌬﹞**ᴇᴍᴀɪʟ** ⇢ {email}
-﹝⌬﹞**ᴘʜᴏɴᴇ** ⇢ {phone}
-
-        """
-
-        
-        await message.reply_photo(photo=picture_url, caption=caption)
-    else:
-        await message.reply_text("ᴏᴏᴘs ɴᴏᴛ ғᴏᴜɴᴅ ᴀɴʏ ᴀᴅᴅʀᴇss.")

DragMusic/plugins/bot/join_requests.py

@@ -0,0 +1,103 @@
+from DragMusic import app
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, ChatPermissions
+
+# A dictionary to store the message ID of the join request notification
+join_request_message = {}
+
+@app.on_chat_join_request()
+async def D_A_X_X(_, message):
+    try:
+        chat = message.chat
+        user = message.from_user
+        
+        # Check if the bot is an admin in the chat
+        bot_member = await app.get_chat_member(chat.id, (await app.get_me()).id)
+        if not bot_member.privileges.can_invite_users:
+            # Silently ignore if the bot can't manage join requests
+            return
+
+        # Send join request notification to the group
+        msg = await app.send_message(
+            chat.id,
+            f"""
+ɴᴇᴡ ᴊᴏɪɴ ʀᴇǫᴜᴇsᴛ
+            
+ᴜsᴇʀ : {user.mention}
+ᴜsᴇʀɴᴀᴍᴇ : @{user.username}
+ᴜsᴇʀ ɪᴅ : {user.id}
+            """,
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            "ᴀᴘᴘʀᴏᴠᴇ", callback_data=f"j_approve_{chat.id}_{user.id}"
+                        ),
+                        InlineKeyboardButton(
+                            "ʀᴇᴊᴇᴄᴛ", callback_data=f"j_reject_{chat.id}_{user.id}"
+                        ),
+                    ]
+                ]
+            ),
+        )
+        join_request_message[user.id] = msg.id
+
+    except Exception as e:
+        print(f"Error in chat_join_request handler: {e}")
+
+async def is_admin(chat_id, user_id):
+    try:
+        member = await app.get_chat_member(chat_id, user_id)
+        return member.privileges is not None
+    except Exception:
+        return False
+
+@app.on_callback_query(filters.regex("j_approve_(.*)"))
+async def approve_request(_, query):
+    try:
+        chat_id, user_id = query.data.split("_")[2:]
+        chat_id = int(chat_id)
+        user_id = int(user_id)
+
+        user_who_pressed = query.from_user
+
+        if not await is_admin(chat_id, user_who_pressed.id):
+            await query.answer("ᴛʜɪs ɪs ɴᴏᴛ ғᴏʀ ʏᴏᴜ.", show_alert=True)
+            return
+
+        await app.approve_chat_join_request(chat_id, user_id)
+        
+        original_message_id = join_request_message.pop(user_id, None)
+        if original_message_id:
+            original_message = await app.get_messages(chat_id, original_message_id)
+            await original_message.edit_text(
+                f"{original_message.text}\n\n**sᴛᴀᴛᴜs :** ᴀᴘᴘʀᴏᴠᴇᴅ ✅\n**ʙʏ :** {user_who_pressed.mention}"
+            )
+    except Exception as e:
+        await query.answer(f"An error occurred: {e}", show_alert=True)
+        print(f"Error in approve_request handler: {e}")
+
+@app.on_callback_query(filters.regex("j_reject_(.*)"))
+async def reject_request(_, query):
+    try:
+        chat_id, user_id = query.data.split("_")[2:]
+        chat_id = int(chat_id)
+        user_id = int(user_id)
+        
+        user_who_pressed = query.from_user
+
+        if not await is_admin(chat_id, user_who_pressed.id):
+            await query.answer("ᴛʜɪs ɪs ɴᴏᴛ ғᴏʀ ʏᴏᴜ.", show_alert=True)
+            return
+
+        await app.decline_chat_join_request(chat_id, user_id)
+
+        original_message_id = join_request_message.pop(user_id, None)
+        if original_message_id:
+            original_message = await app.get_messages(chat_id, original_message_id)
+            await original_message.edit_text(
+                f"{original_message.text}\n\n**sᴛᴀᴛᴜs :** ʀᴇᴊᴇᴄᴛᴇᴅ ❌\n**ʙʏ :** {user_who_pressed.mention}"
+            )
+    except Exception as e:
+        await query.answer(f"An error occurred: {e}", show_alert=True)
+        print(f"Error in reject_request handler: {e}") 

DragMusic/plugins/bot/mustjoin.py

@@ -1,30 +1,8 @@
-import random 
 from pyrogram import Client, filters
 from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, Message
 from pyrogram.errors import ChatAdminRequired, UserNotParticipant, ChatWriteForbidden
 from DragMusic import app
 
-MISHI = [
-    "https://graph.org/file/f86b71018196c5cfe7344.jpg",
-    "https://graph.org/file/a3db9af88f25bb1b99325.jpg",
-    "https://graph.org/file/5b344a55f3d5199b63fa5.jpg",
-    "https://graph.org/file/84de4b440300297a8ecb3.jpg",
-    "https://graph.org/file/84e84ff778b045879d24f.jpg",
-    "https://graph.org/file/a4a8f0e5c0e6b18249ffc.jpg",
-    "https://graph.org/file/ed92cada78099c9c3a4f7.jpg",
-    "https://graph.org/file/d6360613d0fa7a9d2f90b.jpg"
-    "https://graph.org/file/37248e7bdff70c662a702.jpg",
-    "https://graph.org/file/0bfe29d15e918917d1305.jpg",
-    "https://graph.org/file/16b1a2828cc507f8048bd.jpg",
-    "https://graph.org/file/e6b01f23f2871e128dad8.jpg",
-    "https://graph.org/file/cacbdddee77784d9ed2b7.jpg",
-    "https://graph.org/file/ddc5d6ec1c33276507b19.jpg",
-    "https://graph.org/file/39d7277189360d2c85b62.jpg",
-    "https://graph.org/file/5846b9214eaf12c3ed100.jpg",
-    "https://graph.org/file/ad4f9beb4d526e6615e18.jpg",
-    "https://graph.org/file/3514efaabe774e4f181f2.jpg",
-]
-
 #--------------------------
 
 MUST_JOIN = "ERROR_RESPON_TIMEOUT"
@@ -43,7 +21,7 @@ async def must_join_channel(app: Client, msg: Message):
                 chat_info = await app.get_chat(MUST_JOIN)
                 link = chat_info.invite_link
             try:
-                await msg.reply_photo(random.choice(MISHI), caption=f"❅ ʜᴇʏ ᴛʜᴇʀᴇ, ɴɪᴄᴇ ᴛᴏ ᴍᴇᴇᴛ ᴜʜʜ !\n\n❅ ɪғ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴜsᴇ ˹ʙᴜɢ ✘ ϻʊsɪx ˼, ᴛʜᴇɴ ᴄʟɪᴄᴋ ᴏɴ ᴛʜᴇ ʙᴇʟᴏᴡ ʙᴜᴛᴛᴏɴ ᴀɴᴅ ʏᴏᴜ ᴊᴏɪɴᴇᴅ, ᴛʜᴇɴ ʏᴏᴜ ᴄᴀɴ ᴜsᴇ ᴀʟʟ ᴍʏ ᴄᴏᴍᴍᴀɴᴅs ",
+                await msg.reply_text(f"❅ ʜᴇʏ ᴛʜᴇʀᴇ, ɴɪᴄᴇ ᴛᴏ ᴍᴇᴇᴛ ᴜʜʜ !\n\n❅ ɪғ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴜsᴇ ˹ʙᴜɢ ✘ ϻʊsɪx ˼, ᴛʜᴇɴ ᴄʟɪᴄᴋ ᴏɴ ᴛʜᴇ ʙᴇʟᴏᴡ ʙᴜᴛᴛᴏɴ ᴀɴᴅ ʏᴏᴜ ᴊᴏɪɴᴇᴅ, ᴛʜᴇɴ ʏᴏᴜ ᴄᴀɴ ᴜsᴇ ᴀʟʟ ᴍʏ ᴄᴏᴍᴍᴀɴᴅs ",
                     reply_markup=InlineKeyboardMarkup(
                         [
                             [

DragMusic/plugins/bot/start.py

@@ -1,3 +1,4 @@
+import asyncio
 import time
 from pyrogram import filters
 from pyrogram.enums import ChatType
@@ -16,154 +17,134 @@ from DragMusic.utils.database import (
     is_banned_user,
     is_on_off,
 )
+from DragMusic.utils.decorators.language import LanguageStart
 from DragMusic.utils.formatters import get_readable_time
 from DragMusic.utils.inline import help_pannel, private_panel, start_panel
-from config import BANNED_USERS, LOGGER_ID 
-from strings import get_string  # Import get_string at the top
+from config import BANNED_USERS, OWNER_ID, OWNERR_ID
+from strings import get_string
+
 
 @app.on_message(filters.command(["start"]) & filters.private & ~BANNED_USERS)
-async def start_pm(client, message: Message):
+@LanguageStart
+async def start_pm(client, message: Message, _):
     await add_served_user(message.from_user.id)
 
-    language = await get_lang(message.chat.id)  # Get language inside the function
-    _ = get_string(language)  # Get the translation object
+    loading_1 = await message.reply_text("🔥")
+    await asyncio.sleep(0.3)
+    
+    await loading_1.edit_text("<b>ʟᴏᴀᴅɪɴɢ</b>")
+    await asyncio.sleep(0.2)
+    await loading_1.edit_text("<b>ʟᴏᴀᴅɪɴɢ.</b>")
+    await asyncio.sleep(0.1)
+    await loading_1.edit_text("<b>ʟᴏᴀᴅɪɴɢ..</b>")
+    await asyncio.sleep(0.1)
+    await loading_1.edit_text("<b>ʟᴏᴀᴅɪɴɢ...</b>")
+    await asyncio.sleep(0.1)
+    await loading_1.delete()
+
+    started_msg = await message.reply_text(text="<b>sᴛᴀʀᴛᴇᴅ...</b>")
+    await asyncio.sleep(0.2)
+    await started_msg.delete()
 
     if len(message.text.split()) > 1:
         name = message.text.split(None, 1)[1]
-        if name[0:4] == "help":
+        if name.startswith("help"):
             keyboard = help_pannel(_)
-            await message.reply_sticker("CAACAgEAAxkBAAJYdWZLJQqyG4fMdFFHFbTZDZPczqfnAAJUAgACODjZR-6jaMt58aQENQQ")
-            return await message.reply_video(
-                video="https://files.catbox.moe/l372oy.mp4",
-                caption=_["help_1"].format(config.SUPPORT_CHAT),
+            keyboard.inline_keyboard.append([
+                InlineKeyboardButton("👑 Owner", url=f"tg://user?id={OWNERR_ID}")
+            ])
+            await message.reply_text(
+                text=(
+                    f"<b>ʏᴏᴏ {message.from_user.mention}, <a href='https://files.catbox.moe/w8m75t.jpg' target='_blank'>🫧</a></b>\n\n"
+                    f"<b>ɪ'ᴍ {app.mention}</b>\n"
+                    f"<b>ɪ ᴄᴀɴ sᴛʀᴇᴀᴍ ʜɪɢʜ-ǫᴜᴀʟɪᴛʏ ᴍᴜsɪᴄ ᴀɴᴅ ᴠɪᴅᴇᴏs ᴇғғᴏʀᴛʟᴇssʟʏ ᴡɪᴛʜ ᴛʜɪs ᴀᴅᴠᴀɴᴄᴇᴅ ᴛᴇʟᴇɢʀᴀᴍ ʙᴏᴛ.</b>\n\n"
+                    f"<b>sʜᴀʀᴇ ᴛʀᴀᴄᴋs ᴀɴᴅ ᴄʀᴇᴀᴛᴇ ᴛʜᴇ ᴘᴇʀғᴇᴄᴛ ᴀᴛᴍᴏsᴘʜᴇʀᴇ ғᴏʀ ᴇᴠᴇʀʏ ᴄʜᴀᴛ.</b>"
+                ),
                 reply_markup=keyboard,
             )
-        elif name[0:3] == "sud":  # Example: Handling sudo
+        if name.startswith("sud"):
             await sudoers_list(client=client, message=message, _=_)
             if await is_on_off(2):
                 await app.send_message(
-                    chat_id=LOGGER_ID,
-                    text=f"{message.from_user.mention} ᴊᴜsᴛ sᴛᴀʀᴛᴇᴅ ᴛʜᴇ ʙᴏᴛ ᴛᴏ ᴄʜᴇᴄᴋ <b>sᴜᴅᴏʟɪsᴛ</b>.\n\n<b>ᴜsᴇʀ ɪᴅ :</b> <code>{message.from_user.id}</code>\n<b>ᴜsᴇʀɴᴀᴍᴇ :</b> @{message.from_user.username}",
-                    message_thread_id=12327  # Send to the specific thread
+                    chat_id=config.LOGGER_ID,
+                    text=f"{message.from_user.mention} ᴄʜᴇᴄᴋᴇᴅ <b>sᴜᴅᴏʟɪsᴛ</b>.\n\n"
+                         f"<b>• ɪᴅᴇɴᴛɪғɪᴇʀ ⌯</b> <code>{message.from_user.id}</code>\n"
+                         f"<b>• ʜᴀɴᴅʟᴇ ⌯</b> @{message.from_user.username}",
                 )
             return
-        elif name[0:3] == "inf":  # Example: Handling info
-            m = await message.reply_text("🔎")
-            query = (str(name)).replace("info_", "", 1)
+
+        if name.startswith("inf"):
+            m = await message.reply_text("⚡️")
+            query = name.replace("info_", "", 1)
             query = f"https://www.youtube.com/watch?v={query}"
             results = VideosSearch(query, limit=1)
-            for result in (await results.next())["result"]:
-                title = result["title"]
-                duration = result["duration"]
-                views = result["viewCount"]["short"]
-                thumbnail = result["thumbnails"][0]["url"].split("?")[0]
-                channellink = result["channel"]["link"]
-                channel = result["channel"]["name"]
-                link = result["link"]
-                published = result["publishedTime"]
-            searched_text = _["start_6"].format(
-                title, duration, views, published, channellink, channel, app.mention
-            )
-            key = InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(text=_["S_B_8"], url=link),
-                        InlineKeyboardButton(text=_["S_B_9"], url=config.SUPPORT_CHAT),
-                    ],
-                ]
-            )
-            await m.delete()
-            await app.send_photo(
-                chat_id=message.chat.id,
-                photo=thumbnail,
-                caption=searched_text,
-                reply_markup=key,
-            )
-            if await is_on_off(2):
-                await app.send_message(
-                    chat_id=LOGGER_ID,
-                    text=f"{message.from_user.mention} ᴊᴜsᴛ sᴛᴀʀᴛᴇᴅ ᴛʜᴇ ʙᴏᴛ ᴛᴏ ᴄʜᴇᴄᴋ <b>ᴛʀᴀᴄᴋ ɪɴғᴏʀᴍᴀᴛɪᴏɴ</b>.\n\n<b>ᴜsᴇʀ ɪᴅ :</b> <code>{message.from_user.id}</code>\n<b>ᴜsᴇʀɴᴀᴍᴇ :</b> @{message.from_user.username}",
-                    message_thread_id=12327  # Send to the specific thread
-                )
-            return
 
+            next_result = await results.next()
+
+            if isinstance(next_result, dict) and "result" in next_result:
+                for result in next_result["result"]:
+                    title = result["title"]
+                    duration = result["duration"]
+                    views = result["viewCount"]["short"]
+                    thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+                    channellink = result["channel"]["link"]
+                    channel = result["channel"]["name"]
+                    link = result["link"]
+                    published = result["publishedTime"]
+                    searched_text = _["start_6"].format(
+                        title, duration, views, published, channellink, channel
+                    )
+                    key = InlineKeyboardMarkup(
+                        [[InlineKeyboardButton(text="ʏᴏᴜᴛᴜʙᴇ", url=link)]]
+                    )
+                await m.delete()
+
+                await app.send_photo(
+                    chat_id=message.chat.id,
+                    photo=thumbnail,
+                    caption=searched_text,
+                    reply_markup=key,
+                )
+                if await is_on_off(2):
+                    await app.send_message(
+                        chat_id=config.LOGGER_ID,
+                        text=f"<b>{message.from_user.mention} ᴄʜᴇᴄᴋᴇᴅ ᴛʀᴀᴄᴋ ɪɴғᴏ.</b>\n\n"
+                             f"<b>• ɪᴅᴇɴᴛɪғɪᴇʀ ⌯</b> <code>{message.from_user.id}</code>\n"
+                             f"<b>• ʜᴀɴᴅʟᴇ ⌯</b> @{message.from_user.username}",
+                    )
+            else:
+                await m.edit_text("ғᴀɪʟᴇᴅ ᴛᴏ ʀᴇᴛʀɪᴇᴠᴇ ɪɴғᴏʀᴍᴀᴛɪᴏɴ.")
+                return
     else:
         out = private_panel(_)
-        await message.reply_sticker("CAACAgEAAxkBAAJYdWZLJQqyG4fMdFFHFbTZDZPczqfnAAJUAgACODjZR-6jaMt58aQENQQ")
-        await message.reply_video(
-            video="https://telegra.ph/file/d2532972423ce5c4b632e.mp4",
-            caption=_["start_2"].format(message.from_user.mention, app.mention),
+        out.append([
+            InlineKeyboardButton("👑 Owner", url=f"tg://user?id={OWNERR_ID}")
+        ])
+        await message.reply_text(
+            text=(
+                 f"<b>ʏᴏᴏ {message.from_user.mention}, <a href='https://files.catbox.moe/w8m75t.jpg' target='_blank'>🫧</a></b>\n\n"
+                 f"<b>ɪ'ᴍ {app.mention}</b>\n"
+                 f"<b>ɪ ᴄᴀɴ sᴛʀᴇᴀᴍ ʜɪɢʜ-ǫᴜᴀʟɪᴛʏ ᴍᴜsɪᴄ ᴀɴᴅ ᴠɪᴅᴇᴏs ᴇғғᴏʀᴛʟᴇssʟʏ ᴡɪᴛʜ ᴛʜɪs ᴀᴅᴠᴀɴᴄᴇᴅ ᴛᴇʟᴇɢʀᴀᴍ ʙᴏᴛ.</b>\n\n"
+                 f"<b>sʜᴀʀᴇ ᴛʀᴀᴄᴋs ᴀɴᴅ ᴄʀᴇᴀᴛᴇ ᴛʜᴇ ᴘᴇʀғᴇᴄᴛ ᴀᴛᴍᴏsᴘʜᴇʀᴇ ғᴏʀ ᴇᴠᴇʀʏ ᴄʜᴀᴛ.</b>"
+            ),
             reply_markup=InlineKeyboardMarkup(out),
         )
         if await is_on_off(2):
             await app.send_message(
-                chat_id=LOGGER_ID,
-                text=f"{message.from_user.mention} ᴊᴜsᴛ sᴛᴀʀᴛᴇᴅ ᴛʜᴇ ʙᴏᴛ.\n\n<b>ᴜsᴇʀ ɪᴅ :</b> <code>{message.from_user.id}</code>\n<b>ᴜsᴇʀɴᴀᴍᴇ :</b> @{message.from_user.username}",
-                message_thread_id=12327  # Send to the specific thread
+                chat_id=config.LOGGER_ID,
+                text=f"<b>{message.from_user.mention} sᴛᴀʀᴛᴇᴅ ᴛʜᴇ ʙᴏᴛ.</b>\n\n"
+                     f"<b>• ɪᴅᴇɴᴛɪғɪᴇʀ ⌯</b> <code>{message.from_user.id}</code>\n"
+                     f"<b>• ʜᴀɴᴅʟᴇ ⌯</b> @{message.from_user.username}",
             )
 
-@app.on_message(filters.command(["start"]) & filters.group & ~BANNED_USERS)
-async def start_gp(client, message: Message):
-    language = await get_lang(message.chat.id)  # Get language inside the function
-    _ = get_string(language)  # Get the translation object
 
+@app.on_message(filters.command(["start"]) & filters.group & ~BANNED_USERS)
+@LanguageStart
+async def start_gp(client, message: Message, _):
     out = start_panel(_)
     uptime = int(time.time() - _boot_)
-    await message.reply_video(
-        video="https://telegra.ph/file/d2532972423ce5c4b632e.mp4",
-        caption=_["start_1"].format(app.mention, get_readable_time(uptime)),
+    await message.reply_text(
+        text=_["start_1"].format(app.mention, get_readable_time(uptime)),
         reply_markup=InlineKeyboardMarkup(out),
     )
-    await add_served_chat(message.chat.id)
-    if await is_on_off(2):
-        await app.send_message(
-            chat_id=LOGGER_ID,
-            text=f"{message.from_user.mention} ᴊᴜsᴛ sᴛᴀʀᴛᴇᴅ ᴛʜᴇ ʙᴏᴛ ɪɴ ᴀ ɢʀᴏᴜᴘ.\n\n<b>ᴜsᴇʀ ɪᴅ :</b> <code>{message.from_user.id}</code>\n<b>ᴜsᴇʀɴᴀᴍᴇ :</b> @{message.from_user.username}",
-            message_thread_id=12327  # Send to the specific thread
-        )
-
-@app.on_message(filters.new_chat_members, group=-1)
-async def welcome(client, message: Message):
-    for member in message.new_chat_members:
-        try:
-            language = await get_lang(message.chat.id)
-            _ = get_string(language)
-            if await is_banned_user(member.id):
-                await message.chat.ban_member(member.id)
-                continue
-            if member.id == app.id:
-                if message.chat.type != ChatType.SUPERGROUP:
-                    await message.reply_text(_["start_4"])
-                    return await app.leave_chat(message.chat.id)
-                if message.chat.id in await blacklisted_chats():
-                    await message.reply_text(
-                        _["start_5"].format(
-                            app.mention,
-                            f"https://t.me/{app.username}?start=sudolist",
-                            config.SUPPORT_CHAT,
-                        ),
-                        disable_web_page_preview=True,
-                    )
-                    return await app.leave_chat(message.chat.id)
-
-                out = start_panel(_)
-                await message.reply_video(
-                    video="https://telegra.ph/file/d2532972423ce5c4b632e.mp4",
-                    caption=_["start_3"].format(
-                        message.from_user.first_name,
-                        app.mention,
-                        message.chat.title,
-                        app.mention,
-                    ),
-                    reply_markup=InlineKeyboardMarkup(out),
-                )
-                await add_served_chat(message.chat.id)
-                if await is_on_off(2):
-                    await app.send_message(
-                        chat_id=LOGGER_ID,
-                        text=f"{member.mention} ᴊᴜsᴛ ᴊᴏɪɴᴇᴅ ᴛʜᴇ ᴄʜᴀᴛ.\n\n<b>ᴜsᴇʀ ɪᴅ :</b> <code>{member.id}</code>\n<b>ᴜsᴇʀɴᴀᴍᴇ :</b> @{member.username}",
-                        message_thread_id=12327  # Send to the specific thread
-                    )
-                await message.stop_propagation()
-        except Exception as ex:
-            print(ex)
+    await add_served_chat(message.chat.id)

DragMusic/plugins/plugins/Gemini.txt

@@ -1,35 +0,0 @@
-import requests
-from MukeshAPI import api
-from pyrogram import filters
-from pyrogram.enums import ChatAction
-from DragMusic import app
-
-
-@app.on_message(filters.command(["gemini"]))
-async def gemini_handler(client, message):
-    await app.send_chat_action(message.chat.id, ChatAction.TYPING)
-    if (
-        message.text.startswith(f"/gemini@{app.username}")
-        and len(message.text.split(" ", 1)) > 1
-    ):
-        user_input = message.text.split(" ", 1)[1]
-    elif message.reply_to_message and message.reply_to_message.text:
-        user_input = message.reply_to_message.text
-    else:
-        if len(message.command) > 1:
-            user_input = " ".join(message.command[1:])
-        else:
-            await message.reply_text("ᴇxᴀᴍᴘʟᴇ :- `/gemini hi?`")
-            return
-
-    try:
-        response = api.gemini(user_input)
-        await app.send_chat_action(message.chat.id, ChatAction.TYPING)
-        x = response["results"]
-        if x:
-            await message.reply_text(x, quote=True)
-        else:
-            await message.reply_text("sᴏʀʀʏ sɪʀ! ᴘʟᴇᴀsᴇ Tʀʏ ᴀɢᴀɪɴ")
-    except requests.exceptions.RequestException as e:
-        pass
-          

DragMusic/plugins/plugins/ask.py

@@ -1,34 +0,0 @@
-from pyrogram import filters
-from pyrogram.enums import ChatAction, ParseMode
-from DragMusic import app
-import aiohttp
-
-# Function to fetch data from Akeno API
-async def fetch_data_from_akeno(question):
-    url = "https://web-3ypd.onrender.com/api/cohere"  # API endpoint
-    params = {"query": question}  # Pass query as a parameter
-    
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url, params=params) as response:
-            data = await response.json()
-            return data.get("results", "No response received.")  # Extract the answer
-
-# Command handler for /ask
-@app.on_message(filters.command("ask"))
-async def ask_command(client, message):
-    chat_id = message.chat.id
-    user_id = message.from_user.id
-
-    # Indicate typing action
-    await app.send_chat_action(chat_id, ChatAction.TYPING)
-    
-    if len(message.command) < 2:
-        await message.reply_text("Exᴀᴍᴘʟᴇ ᴜsᴀɢᴇ: /ask [your question]")
-        return
-    
-    question = " ".join(message.command[1:])  # Get the question from command arguments
-    response = await fetch_data_from_akeno(question)
-    
-    formatted_response = f"<blockquote>{response}</blockquote>"
-    
-    await message.reply_text(formatted_response, parse_mode=ParseMode.HTML)

DragMusic/plugins/plugins/brave.py

@@ -1,42 +0,0 @@
-import requests
-from pyrogram import filters
-from pyrogram.enums import ChatAction
-from DragMusic import app
-
-# Add your Brave Search API key (if required)
-BRAVE_SEARCH_API_KEY = "your_brave_api_key"  # Leave empty if no key is needed
-
-@app.on_message(filters.command(["search", "brave"]))
-async def brave_search_handler(client, message):
-    chat_id = message.chat.id
-
-    # Indicate typing action
-    await app.send_chat_action(chat_id, ChatAction.TYPING)
-
-    # Retrieve the search query from the message
-    if len(message.command) > 1:
-        search_query = " ".join(message.command[1:])
-    else:
-        await message.reply_text("Exᴀᴍᴘʟᴇ ᴜsᴀɢᴇ: /sᴇᴀʀᴄʜ Qᴜᴇsᴛɪᴏɴ ᴏʀ Tᴏᴘɪᴄ.")
-        return
-
-    try:
-        # Brave Search API Endpoint
-        search_url = f"https://search.brave.com/api/v1/search?q={search_query}&source=web"
-        
-        # Make the request to Brave's API
-        response = requests.get(search_url, headers={"Authorization": f"Bearer {BRAVE_SEARCH_API_KEY}"})
-        response.raise_for_status()
-        results = response.json()
-
-        # Extract and format the results
-        if "web" in results and len(results["web"]["results"]) > 0:
-            reply_text = "**Top Search Results:**\n"
-            for index, result in enumerate(results["web"]["results"][:5], 1):  # Limit to 5 results
-                reply_text += f"{index}. [{result['title']}]({result['url']})\n"
-            await message.reply_text(reply_text, disable_web_page_preview=True)
-        else:
-            await message.reply_text("No results found for your query. Please try with a different keyword.")
-
-    except Exception as e:
-        await message.reply_text(f"» Error: {str(e)}. Please try again later.")

DragMusic/plugins/plugins/getimg.py

@@ -1,59 +0,0 @@
-import requests
-from pyrogram import filters
-from pyrogram.enums import ChatAction
-from DragMusic import app
-
-# Getimg API key (replace with your actual key)
-GETIMG_API_KEY = "key-ICLT6PNtwcDA5PKI7DmuKMXrueoKcDybWuHrXX1o9V8eszHCAOabBpvq2d7ZWewTa5A50ntiXEkDcMo1ewE5exp6LxuOAAr"
-GETIMG_API_URL = "https://api.getimg.ai/v1/essential-v2/text-to-image"
-
-# Function to generate an image using Getimg API
-def generate_image(prompt):
-    headers = {
-        "Authorization": f"Bearer {GETIMG_API_KEY}",
-        "Content-Type": "application/json"
-    }
-
-    # Request payload to send to Getimg API
-    data = {
-        "prompt": prompt,
-        "style": "artistic",  # You can change the style based on the available options
-        "width": 512,
-        "height": 512
-    }
-
-    # Make the API request
-    response = requests.post(GETIMG_API_URL, json=data, headers=headers)
-
-    if response.status_code == 200:
-        # Extract image URL from the response
-        image_url = response.json().get("image_url")
-        return image_url
-    else:
-        return None
-
-# Command handler to generate an image
-@app.on_message(filters.command("generate_image"))
-async def generate_image_handler(client, message):
-    chat_id = message.chat.id
-    await app.send_chat_action(chat_id, ChatAction.TYPING)
-
-    # Get the prompt from the user input
-    if len(message.command) > 1:
-        prompt = " ".join(message.command[1:])
-    else:
-        await message.reply_text("Usage: /generate_image <your prompt>")
-        return
-
-    try:
-        # Call the function to generate the image via Getimg API
-        image_url = generate_image(prompt)
-
-        if image_url:
-            # Send the generated image URL back to the user
-            await message.reply_photo(photo=image_url, caption=f"Generated image for prompt: {prompt}")
-        else:
-            await message.reply_text("Sorry, I couldn't generate the image. Please try again later.")
-    except Exception as e:
-        await message.reply_text(f"Error: {str(e)}. Please try again later.")
-

DragMusic/plugins/plugins/gpt.py

@@ -1,74 +0,0 @@
-import openai
-from pyrogram import filters
-from pyrogram.enums import ChatAction
-from DragMusic import app
-
-# Set your OpenAI API key
-openai.api_key = "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"
-# To store conversations (per user basis, using a dictionary for simplicity)
-user_conversations = {}
-
-@app.on_message(filters.command(["chatgpt", "gpt"]))  # Add support for "gpt"
-async def ask_handler(client, message):
-    user_id = message.from_user.id
-    chat_id = message.chat.id
-
-    # Indicate typing action
-    await app.send_chat_action(chat_id, ChatAction.TYPING)
-
-    # Retrieve the user's input
-    if len(message.command) > 1:
-        user_input = " ".join(message.command[1:])
-    elif message.reply_to_message and message.reply_to_message.text:
-        user_input = message.reply_to_message.text
-    else:
-        await message.reply_text("Exᴀᴍᴘʟᴇ ᴜsᴀɢᴇ: /ᴄʜᴀᴛɢᴘᴛ Hᴏᴡ ᴅᴏᴇs ʀᴇᴄᴜʀsɪᴏɴ ᴡᴏʀᴋ?")
-        return
-
-    # Initialize the conversation history if it's a new user
-    if user_id not in user_conversations:
-        user_conversations[user_id] = [
-            {"role": "system", "content": "You are a helpful assistant who can answer any questions."}
-        ]
-
-    # Append the user's input to the conversation
-    user_conversations[user_id].append({"role": "user", "content": user_input})
-
-    try:
-        # Call the OpenAI API with the full conversation history
-        response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",  # Use "gpt-4" if needed
-            messages=user_conversations[user_id]
-        )
-
-        # Get the assistant's response
-        assistant_response = response["choices"][0]["message"]["content"].strip()
-
-        # Append the assistant's response to the conversation history
-        user_conversations[user_id].append({"role": "assistant", "content": assistant_response})
-
-        # Send the assistant's response to the user
-        await message.reply_text(assistant_response, quote=True)
-
-    except Exception as e:
-        await message.reply_text(f"**» Error:** {str(e)}. Please try again later.")
-
-@app.on_message(filters.command(["reset"]))
-async def reset_handler(client, message):
-    user_id = message.from_user.id
-    if user_id in user_conversations:
-        user_conversations.pop(user_id)
-    await message.reply_text("Cᴏɴᴠᴇʀsᴀᴛɪᴏɴ ᴄᴏɴᴛᴇxᴛ ʜᴀs ʙᴇᴇɴ ʀᴇsᴇᴛ.")
-
-@app.on_message(filters.command(["setrole"]))
-async def set_role_handler(client, message):
-    user_id = message.from_user.id
-    if len(message.command) > 1:
-        role_content = " ".join(message.command[1:])
-        user_conversations[user_id] = [
-            {"role": "system", "content": role_content}
-        ]
-        await message.reply_text(f"Sʏsᴛᴇᴍ ʀᴏʟᴇ sᴇᴛ ᴛᴏ: {role_content}")
-    else:
-        await message.reply_text("Exᴀᴍᴘʟᴇ ᴜsᴀɢᴇ: /sᴇᴛʀᴏʟᴇ Yᴏᴜ ᴀʀᴇ ᴀ ғʀɪᴇɴᴅʟʏ AI.")
-