MusicV2

.dockerignore

@@ -0,0 +1,10 @@
+.env
+.cache
+log.txt
+.DS_Store
+*.session
+raw_files/
+cache/
+downloads/
+__pycache__/
+*.session-journal

.gitattributes

@@ -0,0 +1 @@
+*.ttf filter=lfs diff=lfs merge=lfs -text

.github/README.md

@@ -0,0 +1,29 @@
+- Upgrade and Update by :
+ `sudo apt-get update && sudo apt-get upgrade -y`
+- Install Ffmpeg by :
+  `sudo apt-get install python3-pip ffmpeg -y`
+- Install required packages by :
+ `sudo apt-get install python3 python3-pip -y`
+- Install pip by :
+ `sudo pip3 install -U pip`
+- Install Node js by :
+ `curl -fssL https://deb.nodesource.com/setup_19.x | sudo -E bash - && sudo apt-get install nodejs -y && npm i -g npm`
+- Clone the repository by :
+ `git clone https://github.com/xteam-cloner/Wleowleo && cd Wleowleo`
+- Install requirements by :
+ `pip3 install -U -r requirements.txt`
+- Fill your variables in the env by :
+ `vi sample.env`<br>
+Press `I` on the keyboard for editing env<br>
+Press `Ctrl+C` when you're done with editing env and `:wq` to save the env<br>
+- Rename the env file by :
+ `mv sample.env .env`
+- Install tmux to keep running your bot when you close the terminal by :
+ `sudo apt install tmux && tmux`
+- Finally run the bot by :
+ `bash start`
+- For getting out from tmux session : Press `Ctrl+b` and then `d`<br> 
+
+
+
+

.gitignore

@@ -0,0 +1,10 @@
+.env
+.cache
+log.txt
+.DS_Store
+*.session
+raw_files/
+cache/
+downloads/
+__pycache__/
+*.session-journal

Dockerfile

@@ -0,0 +1,12 @@
+FROM nikolaik/python-nodejs:python3.10-nodejs19
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends ffmpeg \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY . /app/
+WORKDIR /app/
+RUN pip3 install --no-cache-dir -U -r requirements.txt
+
+CMD bash start

DragMusic/Mongo/afkdb.py

@@ -0,0 +1,33 @@
+from DragMusic.core.mongo import mongodb
+
+afkdb = mongodb.afk
+
+
+async def is_afk(user_id: int) -> bool:
+    user = await afkdb.find_one({"user_id": user_id})
+    if not user:
+        return False, {}
+    return True, user["reason"]
+
+
+async def add_afk(user_id: int, mode):
+    await afkdb.update_one(
+        {"user_id": user_id}, {"$set": {"reason": mode}}, upsert=True
+    )
+
+
+async def remove_afk(user_id: int):
+    user = await afkdb.find_one({"user_id": user_id})
+    if user:
+        return await afkdb.delete_one({"user_id": user_id})
+
+
+async def get_afk_users() -> list:
+    users = afkdb.find({"user_id": {"$gt": 0}})
+    if not users:
+        return []
+    users_list = []
+    for user in await users.to_list(length=1000000000):
+        users_list.append(user)
+    return users_list
+    

DragMusic/Mongo/nightmodedb.py

@@ -0,0 +1,24 @@
+from typing import Dict, List, Union
+from config import MONGO_DB_URI
+from motor.motor_asyncio import AsyncIOMotorClient as MongoCli
+
+
+mongo = MongoCli(MONGO_DB_URI).Rankings
+
+nightdb = mongo.nightmode
+
+
+async def nightmode_on(chat_id : int) :
+    return nightdb.insert_one({"chat_id" : chat_id})     
+    
+async def nightmode_off(chat_id : int):
+    return nightdb.delete_one({"chat_id" : chat_id})
+
+async def get_nightchats() -> list:
+    chats = nightdb.find({"chat_id": {"$lt": 0}})
+    if not chats:
+        return []
+    chats_list = []
+    for chat in await chats.to_list(length=1000000000):
+        chats_list.append(chat)
+    return chats_list

DragMusic/Mongo/readable_time.py

@@ -0,0 +1,23 @@
+def get_readable_time(seconds: int) -> str:
+    count = 0
+    readable_time = ""
+    time_list = []
+    time_suffix_list = ["s", "ᴍ", "ʜ", "ᴅᴀʏs"]
+
+    while count < 4:
+        count += 1
+        remainder, result = divmod(seconds, 60) if count < 3 else divmod(seconds, 24)
+        if seconds == 0 and remainder == 0:
+            break
+        time_list.append(int(result))
+        seconds = int(remainder)
+
+    for x in range(len(time_list)):
+        time_list[x] = str(time_list[x]) + time_suffix_list[x]
+    if len(time_list) == 4:
+        readable_time += time_list.pop() + ", "
+
+    time_list.reverse()
+    readable_time += ":".join(time_list)
+
+    return readable_time

DragMusic/__init__.py

@@ -0,0 +1,27 @@
+from DragMusic.core.bot import Drag
+from DragMusic.core.dir import dirr
+from DragMusic.core.git import git
+from DragMusic.core.userbot import Userbot
+from DragMusic.misc import dbb, heroku
+
+from .logging import LOGGER
+
+dirr()
+#git()
+dbb()
+heroku()
+
+app = Drag()
+userbot = Userbot()
+
+
+from .platforms import *
+
+Apple = AppleAPI()
+Carbon = CarbonAPI()
+SoundCloud = SoundAPI()
+Spotify = SpotifyAPI()
+Resso = RessoAPI()
+Telegram = TeleAPI()
+YouTube = YouTubeAPI()
+

DragMusic/__main__.py

@@ -0,0 +1,61 @@
+import asyncio
+import importlib
+
+from pyrogram import idle
+from pytgcalls.exceptions import NoActiveGroupCall
+
+import config
+from DragMusic import LOGGER, app, userbot
+from DragMusic.core.call import Drag
+from DragMusic.misc import sudo
+from DragMusic.plugins import ALL_MODULES
+from DragMusic.utils.database import get_banned_users, get_gbanned
+from config import BANNED_USERS
+
+
+async def init():
+    if (
+        not config.STRING1
+        and not config.STRING2
+        and not config.STRING3
+        and not config.STRING4
+        and not config.STRING5
+    ):
+        LOGGER(__name__).error("Assɪsᴛᴀɴᴛ ᴄʟɪᴇɴᴛ ᴠᴀʀɪᴀʙʟᴇs ɴᴏᴛ ᴅᴇғɪɴᴇᴅ, ᴇxɪᴛɪɴɢ...")
+        exit()
+    await sudo()
+    try:
+        users = await get_gbanned()
+        for user_id in users:
+            BANNED_USERS.add(user_id)
+        users = await get_banned_users()
+        for user_id in users:
+            BANNED_USERS.add(user_id)
+    except:
+        pass
+    await app.start()
+    for all_module in ALL_MODULES:
+        importlib.import_module("DragMusic.plugins" + all_module)
+    LOGGER("DragMusic.plugins").info("Sᴜᴄᴄᴇssғᴜʟʟʏ Iᴍᴘᴏʀᴛᴇᴅ Mᴏᴅᴜʟᴇs...")
+    await userbot.start()
+    await Drag.start()
+    try:
+        await Drag.stream_call("https://telegra.ph/file/cba632240b79207bf8a9c.mp4")
+    except NoActiveGroupCall:
+        LOGGER("DragMusic").error(
+            "Pʟᴇᴀsᴇ ᴛᴜʀɴ ᴏɴ ᴛʜᴇ ᴠɪᴅᴇᴏᴄʜᴀᴛ ᴏғ ʏᴏᴜʀ ʟᴏɢ ɢʀᴏᴜᴘ\ᴄʜᴀɴɴᴇʟ\n\nsᴛᴏᴘᴘɪɴɢ Bᴏᴛ..."
+        )
+        exit()
+    except:
+        pass
+    await Drag.decorators()
+    LOGGER("DragMusic").info("\n  𝑴𝑨𝑫𝑬 𝑩𝒀 𝑫𝑹𝑨𝑮𝑮𝑮 \n")
+        
+    await idle()
+    await app.stop()
+    await userbot.stop()
+    LOGGER("DragMusic").info("\n  𝑴𝑨𝑫𝑬 𝑩𝒀 𝑫𝑹𝑨𝑮𝑮𝑮 \n")
+
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(init())

DragMusic/assets/font.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cb35ce1a08cfbff367f8f4d7960fe7754abc0460f0f4d7ac46d3af924a9d0f3
+size 128248

DragMusic/assets/font2.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5d5b5672d46b4482346a6695121cae0110372568cb30ba723808886ecda4c12
+size 22020

DragMusic/core/bot.py

@@ -0,0 +1,54 @@
+from pyrogram import Client, errors
+from pyrogram.enums import ChatMemberStatus, ParseMode
+
+import config
+
+from ..logging import LOGGER
+
+
+class Drag(Client):
+    def __init__(self):
+        LOGGER(__name__).info(f"Starting Bot...")
+        super().__init__(
+            name="DragMusic",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            bot_token=config.BOT_TOKEN,
+            in_memory=True,
+            parse_mode=ParseMode.HTML,
+            max_concurrent_transmissions=7,
+        )
+
+    async def start(self):
+        await super().start()
+        self.id = self.me.id
+        self.name = self.me.first_name + " " + (self.me.last_name or "")
+        self.username = self.me.username
+        self.mention = self.me.mention
+
+        try:
+            await self.send_message(
+                chat_id=config.LOGGER_ID,
+                text=f"<u><b>» {self.mention} ʙᴏᴛ sᴛᴀʀᴛᴇᴅ :</b><u>\n\nɪᴅ : <code>{self.id}</code>\nɴᴀᴍᴇ : {self.name}\nᴜsᴇʀɴᴀᴍᴇ : @{self.username}",
+            )
+        except (errors.ChannelInvalid, errors.PeerIdInvalid):
+            LOGGER(__name__).error(
+                "Bot has failed to access the log group/channel. Make sure that you have added your bot to your log group/channel."
+            )
+            exit()
+        except Exception as ex:
+            LOGGER(__name__).error(
+                f"Bot has failed to access the log group/channel.\n  Reason : {type(ex).__name__}."
+            )
+            exit()
+
+        a = await self.get_chat_member(config.LOGGER_ID, self.id)
+        if a.status != ChatMemberStatus.ADMINISTRATOR:
+            LOGGER(__name__).error(
+                "Please promote your bot as an admin in your log group/channel."
+            )
+            exit()
+        LOGGER(__name__).info(f"Music Bot Started as {self.name}")
+
+    async def stop(self):
+        await super().stop()

DragMusic/core/call.py

@@ -0,0 +1,635 @@
+import asyncio
+import os
+from datetime import datetime, timedelta
+from typing import Union
+
+from pyrogram import Client
+from pyrogram.types import InlineKeyboardMarkup
+from ntgcalls import TelegramServerError
+from pytgcalls import PyTgCalls
+from pytgcalls.exceptions import (
+    AlreadyJoinedError,
+    NoActiveGroupCall,
+)
+from pytgcalls.types import (
+    MediaStream,
+    AudioQuality,
+    VideoQuality,
+    Update,
+)
+from pytgcalls.types.stream import StreamAudioEnded
+
+import config
+from DragMusic import LOGGER, YouTube, app
+from DragMusic.misc import db
+from DragMusic.utils.database import (
+    add_active_chat,
+    add_active_video_chat,
+    get_lang,
+    get_loop,
+    group_assistant,
+    is_autoend,
+    music_on,
+    remove_active_chat,
+    remove_active_video_chat,
+    set_loop,
+)
+from DragMusic.utils.exceptions import AssistantErr
+from DragMusic.utils.formatters import check_duration, seconds_to_min, speed_converter
+from DragMusic.utils.inline.play import stream_markup
+from DragMusic.utils.stream.autoclear import auto_clean
+from DragMusic.utils.thumbnails import get_thumb
+from strings import get_string
+
+autoend = {}
+counter = {}
+loop = asyncio.get_event_loop_policy().get_event_loop()
+
+
+async def _clear_(chat_id):
+    db[chat_id] = []
+    await remove_active_video_chat(chat_id)
+    await remove_active_chat(chat_id)
+
+
+class Call(PyTgCalls):
+    def __init__(self):
+        self.userbot1 = Client(
+            name="AnonXAss1",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING1),
+        )
+        self.one = PyTgCalls(
+            self.userbot1,
+            cache_duration=100,
+        )
+        self.userbot2 = Client(
+            name="AnonXAss2",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING2),
+        )
+        self.two = PyTgCalls(
+            self.userbot2,
+            cache_duration=100,
+        )
+        self.userbot3 = Client(
+            name="AnonXAss3",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING3),
+        )
+        self.three = PyTgCalls(
+            self.userbot3,
+            cache_duration=100,
+        )
+        self.userbot4 = Client(
+            name="AnonXAss4",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING4),
+        )
+        self.four = PyTgCalls(
+            self.userbot4,
+            cache_duration=100,
+        )
+        self.userbot5 = Client(
+            name="AnonXAss5",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING5),
+        )
+        self.five = PyTgCalls(
+            self.userbot5,
+            cache_duration=100,
+        )
+
+    async def pause_stream(self, chat_id: int):
+        assistant = await group_assistant(self, chat_id)
+        await assistant.pause_stream(chat_id)
+
+    async def mute_stream(self, chat_id: int):
+        assistant = await group_assistant(self, chat_id)
+        await assistant.mute_stream(chat_id)
+
+    async def unmute_stream(self, chat_id: int):
+        assistant = await group_assistant(self, chat_id)
+        await assistant.unmute_stream(chat_id)
+
+    async def get_participant(self, chat_id: int):
+        assistant = await group_assistant(self, chat_id)
+        participant = await assistant.get_participants(chat_id)
+        return participant
+
+    async def resume_stream(self, chat_id: int):
+        assistant = await group_assistant(self, chat_id)
+        await assistant.resume_stream(chat_id)
+
+    async def stop_stream(self, chat_id: int):
+        assistant = await group_assistant(self, chat_id)
+        try:
+            await _clear_(chat_id)
+            await assistant.leave_group_call(chat_id)
+        except:
+            pass
+
+    async def stop_stream_force(self, chat_id: int):
+        try:
+            if config.STRING1:
+                await self.one.leave_group_call(chat_id)
+        except:
+            pass
+        try:
+            if config.STRING2:
+                await self.two.leave_group_call(chat_id)
+        except:
+            pass
+        try:
+            if config.STRING3:
+                await self.three.leave_group_call(chat_id)
+        except:
+            pass
+        try:
+            if config.STRING4:
+                await self.four.leave_group_call(chat_id)
+        except:
+            pass
+        try:
+            if config.STRING5:
+                await self.five.leave_group_call(chat_id)
+        except:
+            pass
+        try:
+            await _clear_(chat_id)
+        except:
+            pass
+
+    async def speedup_stream(self, chat_id: int, file_path, speed, playing):
+        assistant = await group_assistant(self, chat_id)
+        if str(speed) != "1.0":
+            base = os.path.basename(file_path)
+            chatdir = os.path.join(os.getcwd(), "playback", str(speed))
+            if not os.path.isdir(chatdir):
+                os.makedirs(chatdir)
+            out = os.path.join(chatdir, base)
+            if not os.path.isfile(out):
+                if str(speed) == "0.5":
+                    vs = 2.0
+                if str(speed) == "0.75":
+                    vs = 1.35
+                if str(speed) == "1.5":
+                    vs = 0.68
+                if str(speed) == "2.0":
+                    vs = 0.5
+                proc = await asyncio.create_subprocess_shell(
+                    cmd=(
+                        "ffmpeg "
+                        "-i "
+                        f"{file_path} "
+                        "-filter:v "
+                        f"setpts={vs}*PTS "
+                        "-filter:a "
+                        f"atempo={speed} "
+                        f"{out}"
+                    ),
+                    stdin=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                await proc.communicate()
+        else:
+            out = file_path
+        dur = await loop.run_in_executor(None, check_duration, out)
+        dur = int(dur)
+        played, con_seconds = speed_converter(playing[0]["played"], speed)
+        duration = seconds_to_min(dur)
+        stream = (
+            MediaStream(
+                out,
+                audio_parameters=AudioQuality.HIGH,
+                video_parameters=VideoQuality.SD_480p,
+                ffmpeg_parameters=f"-ss {played} -to {duration}",
+            )
+            if playing[0]["streamtype"] == "video"
+            else MediaStream(
+                out,
+                audio_parameters=AudioQuality.HIGH,
+                ffmpeg_parameters=f"-ss {played} -to {duration}",
+                video_flags=MediaStream.IGNORE,
+            )
+        )
+        if str(db[chat_id][0]["file"]) == str(file_path):
+            await assistant.change_stream(chat_id, stream)
+        else:
+            raise AssistantErr("Umm")
+        if str(db[chat_id][0]["file"]) == str(file_path):
+            exis = (playing[0]).get("old_dur")
+            if not exis:
+                db[chat_id][0]["old_dur"] = db[chat_id][0]["dur"]
+                db[chat_id][0]["old_second"] = db[chat_id][0]["seconds"]
+            db[chat_id][0]["played"] = con_seconds
+            db[chat_id][0]["dur"] = duration
+            db[chat_id][0]["seconds"] = dur
+            db[chat_id][0]["speed_path"] = out
+            db[chat_id][0]["speed"] = speed
+
+    async def force_stop_stream(self, chat_id: int):
+        assistant = await group_assistant(self, chat_id)
+        try:
+            check = db.get(chat_id)
+            check.pop(0)
+        except:
+            pass
+        await remove_active_video_chat(chat_id)
+        await remove_active_chat(chat_id)
+        try:
+            await assistant.leave_group_call(chat_id)
+        except:
+            pass
+
+    async def skip_stream(
+        self,
+        chat_id: int,
+        link: str,
+        video: Union[bool, str] = None,
+        image: Union[bool, str] = None,
+    ):
+        assistant = await group_assistant(self, chat_id)
+        if video:
+            stream = MediaStream(
+                link,
+                audio_parameters=AudioQuality.HIGH,
+                video_parameters=VideoQuality.SD_480p,
+            )
+        else:
+            stream = MediaStream(
+                link,
+                audio_parameters=AudioQuality.HIGH,
+                video_flags=MediaStream.IGNORE,
+            )
+        await assistant.change_stream(
+            chat_id,
+            stream,
+        )
+
+    async def seek_stream(self, chat_id, file_path, to_seek, duration, mode):
+        assistant = await group_assistant(self, chat_id)
+        stream = (
+            MediaStream(
+                file_path,
+                audio_parameters=AudioQuality.HIGH,
+                video_parameters=VideoQuality.SD_480p,
+                ffmpeg_parameters=f"-ss {to_seek} -to {duration}",
+            )
+            if mode == "video"
+            else MediaStream(
+                file_path,
+                audio_parameters=AudioQuality.HIGH,
+                ffmpeg_parameters=f"-ss {to_seek} -to {duration}",
+                video_flags=MediaStream.IGNORE,
+            )
+        )
+        await assistant.change_stream(chat_id, stream)
+
+    async def stream_call(self, link):
+        assistant = await group_assistant(self, config.LOGGER_ID)
+        await assistant.join_group_call(
+            config.LOGGER_ID,
+            MediaStream(link),
+        )
+        await asyncio.sleep(0.2)
+        await assistant.leave_group_call(config.LOGGER_ID)
+
+    async def join_call(
+        self,
+        chat_id: int,
+        original_chat_id: int,
+        link,
+        video: Union[bool, str] = None,
+        image: Union[bool, str] = None,
+    ):
+        assistant = await group_assistant(self, chat_id)
+        language = await get_lang(chat_id)
+        _ = get_string(language)
+        if video:
+            stream = MediaStream(
+                link,
+                audio_parameters=AudioQuality.HIGH,
+                video_parameters=VideoQuality.SD_480p,
+            )
+        else:
+            stream = (
+                MediaStream(
+                    link,
+                    audio_parameters=AudioQuality.HIGH,
+                    video_parameters=VideoQuality.SD_480p,
+                )
+                if video
+                else MediaStream(
+                    link,
+                    audio_parameters=AudioQuality.HIGH,
+                    video_flags=MediaStream.IGNORE,
+                )
+            )
+        try:
+            await assistant.join_group_call(
+                chat_id,
+                stream,
+            )
+        except NoActiveGroupCall:
+            raise AssistantErr(_["call_8"])
+        except AlreadyJoinedError:
+            raise AssistantErr(_["call_9"])
+        except TelegramServerError:
+            raise AssistantErr(_["call_10"])
+        except Exception as e:
+            if "phone.CreateGroupCall" in str(e):
+                raise AssistantErr(_["call_8"])
+        await add_active_chat(chat_id)
+        await music_on(chat_id)
+        if video:
+            await add_active_video_chat(chat_id)
+        if await is_autoend():
+            counter[chat_id] = {}
+            users = len(await assistant.get_participants(chat_id))
+            if users == 1:
+                autoend[chat_id] = datetime.now() + timedelta(minutes=1)
+
+    async def change_stream(self, client, chat_id):
+        check = db.get(chat_id)
+        popped = None
+        loop = await get_loop(chat_id)
+        try:
+            if loop == 0:
+                popped = check.pop(0)
+            else:
+                loop = loop - 1
+                await set_loop(chat_id, loop)
+            await auto_clean(popped)
+            if not check:
+                await _clear_(chat_id)
+                return await client.leave_group_call(chat_id)
+        except:
+            try:
+                await _clear_(chat_id)
+                return await client.leave_group_call(chat_id)
+            except:
+                return
+        else:
+            queued = check[0]["file"]
+            language = await get_lang(chat_id)
+            _ = get_string(language)
+            title = (check[0]["title"]).title()
+            user = check[0]["by"]
+            original_chat_id = check[0]["chat_id"]
+            streamtype = check[0]["streamtype"]
+            videoid = check[0]["vidid"]
+            db[chat_id][0]["played"] = 0
+            if exis := (check[0]).get("old_dur"):
+                db[chat_id][0]["dur"] = exis
+                db[chat_id][0]["seconds"] = check[0]["old_second"]
+                db[chat_id][0]["speed_path"] = None
+                db[chat_id][0]["speed"] = 1.0
+            video = str(streamtype) == "video"
+            if "live_" in queued:
+                n, link = await YouTube.video(videoid, True)
+                if n == 0:
+                    return await app.send_message(
+                        original_chat_id,
+                        text=_["call_6"],
+                    )
+                if video:
+                    stream = MediaStream(
+                        link,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_parameters=VideoQuality.SD_480p,
+                    )
+                else:
+                    stream = MediaStream(
+                        link,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_flags=MediaStream.IGNORE,
+                    )
+                try:
+                    await client.change_stream(chat_id, stream)
+                except Exception:
+                    return await app.send_message(
+                        original_chat_id,
+                        text=_["call_6"],
+                    )
+                img = await get_thumb(videoid)
+                button = stream_markup2(_, chat_id)
+                run = await app.send_photo(
+                    chat_id=original_chat_id,
+                    photo=img,
+                    caption=_["stream_1"].format(
+                        f"https://t.me/{app.username}?start=info_{videoid}",
+                        title[:23],
+                        check[0]["dur"],
+                        user,
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "tg"
+            elif "vid_" in queued:
+                mystic = await app.send_message(original_chat_id, _["call_7"])
+                try:
+                    file_path, direct = await YouTube.download(
+                        videoid,
+                        mystic,
+                        videoid=True,
+                        video=str(streamtype) == "video",
+                    )
+                except:
+                    return await mystic.edit_text(
+                        _["call_6"], disable_web_page_preview=True
+                    )
+                if video:
+                    stream = MediaStream(
+                        file_path,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_parameters=VideoQuality.SD_480p,
+                    )
+                else:
+                    stream = MediaStream(
+                        file_path,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_flags=MediaStream.IGNORE,
+                    )
+                try:
+                    await client.change_stream(chat_id, stream)
+                except:
+                    return await app.send_message(
+                        original_chat_id,
+                        text=_["call_6"],
+                    )
+                img = await get_thumb(videoid)
+                button = stream_markup(_, videoid, chat_id)
+                await mystic.delete()
+                run = await app.send_photo(
+                    chat_id=original_chat_id,
+                    photo=img,
+                    caption=_["stream_1"].format(
+                        f"https://t.me/{app.username}?start=info_{videoid}",
+                        title[:23],
+                        check[0]["dur"],
+                        user,
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "stream"
+            elif "index_" in queued:
+                stream = (
+                    MediaStream(
+                        videoid,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_parameters=VideoQuality.SD_480p,
+                    )
+                    if str(streamtype) == "video"
+                    else MediaStream(
+                        videoid,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_flags=MediaStream.IGNORE,
+                    )
+                )
+                try:
+                    await client.change_stream(chat_id, stream)
+                except:
+                    return await app.send_message(
+                        original_chat_id,
+                        text=_["call_6"],
+                    )
+                button = stream_markup2(_, chat_id)
+                run = await app.send_photo(
+                    chat_id=original_chat_id,
+                    photo=config.STREAM_IMG_URL,
+                    caption=_["stream_2"].format(user),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "tg"
+            else:
+                if video:
+                    stream = MediaStream(
+                        queued,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_parameters=VideoQuality.SD_480p,
+                    )
+                else:
+                    stream = MediaStream(
+                        queued,
+                        audio_parameters=AudioQuality.HIGH,
+                        video_flags=MediaStream.IGNORE,
+                    )
+                try:
+                    await client.change_stream(chat_id, stream)
+                except:
+                    return await app.send_message(
+                        original_chat_id,
+                        text=_["call_6"],
+                    )
+                if videoid == "telegram":
+                    button = stream_markup2(_, chat_id)
+                    run = await app.send_photo(
+                        chat_id=original_chat_id,
+                        photo=(
+                            config.TELEGRAM_AUDIO_URL
+                            if str(streamtype) == "audio"
+                            else config.TELEGRAM_VIDEO_URL
+                        ),
+                        caption=_["stream_1"].format(
+                            config.SUPPORT_CHAT, title[:23], check[0]["dur"], user
+                        ),
+                        reply_markup=InlineKeyboardMarkup(button),
+                    )
+                    db[chat_id][0]["mystic"] = run
+                    db[chat_id][0]["markup"] = "tg"
+                elif videoid == "soundcloud":
+                    button = stream_markup2(_, chat_id)
+                    run = await app.send_photo(
+                        chat_id=original_chat_id,
+                        photo=config.SOUNCLOUD_IMG_URL,
+                        caption=_["stream_1"].format(
+                            config.SUPPORT_CHAT, title[:23], check[0]["dur"], user
+                        ),
+                        reply_markup=InlineKeyboardMarkup(button),
+                    )
+                    db[chat_id][0]["mystic"] = run
+                    db[chat_id][0]["markup"] = "tg"
+                else:
+                    img = await get_thumb(videoid)
+                    button = stream_markup(_, videoid, chat_id)
+                    run = await app.send_photo(
+                        chat_id=original_chat_id,
+                        photo=img,
+                        caption=_["stream_1"].format(
+                            f"https://t.me/{app.username}?start=info_{videoid}",
+                            title[:23],
+                            check[0]["dur"],
+                            user,
+                        ),
+                        reply_markup=InlineKeyboardMarkup(button),
+                    )
+                    db[chat_id][0]["mystic"] = run
+                    db[chat_id][0]["markup"] = "stream"
+
+    async def ping(self):
+        pings = []
+        if config.STRING1:
+            pings.append(await self.one.ping)
+        if config.STRING2:
+            pings.append(await self.two.ping)
+        if config.STRING3:
+            pings.append(await self.three.ping)
+        if config.STRING4:
+            pings.append(await self.four.ping)
+        if config.STRING5:
+            pings.append(await self.five.ping)
+        return str(round(sum(pings) / len(pings), 3))
+
+    async def start(self):
+        LOGGER(__name__).info("Starting PyTgCalls Client...\n")
+        if config.STRING1:
+            await self.one.start()
+        if config.STRING2:
+            await self.two.start()
+        if config.STRING3:
+            await self.three.start()
+        if config.STRING4:
+            await self.four.start()
+        if config.STRING5:
+            await self.five.start()
+
+    async def decorators(self):
+        @self.one.on_kicked()
+        @self.two.on_kicked()
+        @self.three.on_kicked()
+        @self.four.on_kicked()
+        @self.five.on_kicked()
+        @self.one.on_closed_voice_chat()
+        @self.two.on_closed_voice_chat()
+        @self.three.on_closed_voice_chat()
+        @self.four.on_closed_voice_chat()
+        @self.five.on_closed_voice_chat()
+        @self.one.on_left()
+        @self.two.on_left()
+        @self.three.on_left()
+        @self.four.on_left()
+        @self.five.on_left()
+        async def stream_services_handler(_, chat_id: int):
+            await self.stop_stream(chat_id)
+
+        @self.one.on_stream_end()
+        @self.two.on_stream_end()
+        @self.three.on_stream_end()
+        @self.four.on_stream_end()
+        @self.five.on_stream_end()
+        async def stream_end_handler(client, update: Update):
+            if not isinstance(update, StreamAudioEnded):
+                return
+            await self.change_stream(client, update.chat_id)
+
+
+Drag= Call()

DragMusic/core/dir.py

@@ -0,0 +1,20 @@
+import os
+
+from ..logging import LOGGER
+
+
+def dirr():
+    for file in os.listdir():
+        if file.endswith(".jpg"):
+            os.remove(file)
+        elif file.endswith(".jpeg"):
+            os.remove(file)
+        elif file.endswith(".png"):
+            os.remove(file)
+
+    if "downloads" not in os.listdir():
+        os.mkdir("downloads")
+    if "cache" not in os.listdir():
+        os.mkdir("cache")
+
+    LOGGER(__name__).info("Directories Updated.")

DragMusic/core/git.py

@@ -0,0 +1,71 @@
+import asyncio
+import shlex
+from typing import Tuple
+
+from git import Repo
+from git.exc import GitCommandError, InvalidGitRepositoryError
+
+import config
+
+from ..logging import LOGGER
+
+
+def install_req(cmd: str) -> Tuple[str, str, int, int]:
+    async def install_requirements():
+        args = shlex.split(cmd)
+        process = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+        return (
+            stdout.decode("utf-8", "replace").strip(),
+            stderr.decode("utf-8", "replace").strip(),
+            process.returncode,
+            process.pid,
+        )
+
+    return asyncio.get_event_loop().run_until_complete(install_requirements())
+
+
+def git():
+    REPO_LINK = config.UPSTREAM_REPO
+    if config.GIT_TOKEN:
+        GIT_USERNAME = REPO_LINK.split("com/")[1].split("/")[0]
+        TEMP_REPO = REPO_LINK.split("https://")[1]
+        UPSTREAM_REPO = f"https://{GIT_USERNAME}:{config.GIT_TOKEN}@{TEMP_REPO}"
+    else:
+        UPSTREAM_REPO = config.UPSTREAM_REPO
+    try:
+        repo = Repo()
+        LOGGER(__name__).info(f"Git Client Found [VPS DEPLOYER]")
+    except GitCommandError:
+        LOGGER(__name__).info(f"Invalid Git Command")
+    except InvalidGitRepositoryError:
+        repo = Repo.init()
+        if "origin" in repo.remotes:
+            origin = repo.remote("origin")
+        else:
+            origin = repo.create_remote("origin", UPSTREAM_REPO)
+        origin.fetch()
+        repo.create_head(
+            config.UPSTREAM_BRANCH,
+            origin.refs[config.UPSTREAM_BRANCH],
+        )
+        repo.heads[config.UPSTREAM_BRANCH].set_tracking_branch(
+            origin.refs[config.UPSTREAM_BRANCH]
+        )
+        repo.heads[config.UPSTREAM_BRANCH].checkout(True)
+        try:
+            repo.create_remote("origin", config.UPSTREAM_REPO)
+        except BaseException:
+            pass
+        nrs = repo.remote("origin")
+        nrs.fetch(config.UPSTREAM_BRANCH)
+        try:
+            nrs.pull(config.UPSTREAM_BRANCH)
+        except GitCommandError:
+            repo.git.reset("--hard", "FETCH_HEAD")
+        install_req("pip3 install --no-cache-dir -r requirements.txt")
+        LOGGER(__name__).info(f"Fetching updates from upstream repository...")

DragMusic/core/mongo.py

@@ -0,0 +1,14 @@
+from motor.motor_asyncio import AsyncIOMotorClient
+
+from config import MONGO_DB_URI
+
+from ..logging import LOGGER
+
+LOGGER(__name__).info("Connecting to your Mongo Database...")
+try:
+    _mongo_async_ = AsyncIOMotorClient(MONGO_DB_URI)
+    mongodb = _mongo_async_.Anon
+    LOGGER(__name__).info("Connected to your Mongo Database.")
+except:
+    LOGGER(__name__).error("Failed to connect to your Mongo Database.")
+    exit()

DragMusic/core/userbot.py

@@ -0,0 +1,170 @@
+from pyrogram import Client
+
+import config
+
+from ..logging import LOGGER
+
+assistants = []
+assistantids = []
+
+
+class Userbot(Client):
+    def __init__(self):
+        self.one = Client(
+            name="AnonXAss1",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING1),
+            no_updates=True,
+        )
+        self.two = Client(
+            name="AnonXAss2",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING2),
+            no_updates=True,
+        )
+        self.three = Client(
+            name="AnonXAss3",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING3),
+            no_updates=True,
+        )
+        self.four = Client(
+            name="AnonXAss4",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING4),
+            no_updates=True,
+        )
+        self.five = Client(
+            name="AnonXAss5",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING5),
+            no_updates=True,
+        )
+
+    async def start(self):
+        LOGGER(__name__).info(f"Starting Assistants...")
+        if config.STRING1:
+            await self.one.start()
+            try:
+                await self.one.join_chat("dragbackup")
+                await self.one.join_chat("dragbackup")
+            except:
+                pass
+            assistants.append(1)
+            try:
+                await self.one.send_message(config.LOGGER_ID, "Assistant Started")
+            except:
+                LOGGER(__name__).error(
+                    "Assistant Account 1 has failed to access the log Group. Make sure that you have added your assistant to your log group and promoted as admin!"
+                )
+                exit()
+            self.one.id = self.one.me.id
+            self.one.name = self.one.me.mention
+            self.one.username = self.one.me.username
+            assistantids.append(self.one.id)
+            LOGGER(__name__).info(f"Assistant Started as {self.one.name}")
+
+        if config.STRING2:
+            await self.two.start()
+            try:
+                await self.two.join_chat("dragbackup")
+                await self.two.join_chat("dragbackup")
+            except:
+                pass
+            assistants.append(2)
+            try:
+                await self.two.send_message(config.LOGGER_ID, "Assistant Started")
+            except:
+                LOGGER(__name__).error(
+                    "Assistant Account 2 has failed to access the log Group. Make sure that you have added your assistant to your log group and promoted as admin!"
+                )
+                exit()
+            self.two.id = self.two.me.id
+            self.two.name = self.two.me.mention
+            self.two.username = self.two.me.username
+            assistantids.append(self.two.id)
+            LOGGER(__name__).info(f"Assistant Two Started as {self.two.name}")
+
+        if config.STRING3:
+            await self.three.start()
+            try:
+                await self.three.join_chat("dragbackup")
+                await self.three.join_chat("dragbackup")
+            except:
+                pass
+            assistants.append(3)
+            try:
+                await self.three.send_message(config.LOGGER_ID, "Assistant Started")
+            except:
+                LOGGER(__name__).error(
+                    "Assistant Account 3 has failed to access the log Group. Make sure that you have added your assistant to your log group and promoted as admin! "
+                )
+                exit()
+            self.three.id = self.three.me.id
+            self.three.name = self.three.me.mention
+            self.three.username = self.three.me.username
+            assistantids.append(self.three.id)
+            LOGGER(__name__).info(f"Assistant Three Started as {self.three.name}")
+
+        if config.STRING4:
+            await self.four.start()
+            try:
+                await self.four.join_chat("dragbackup")
+                await self.four.join_chat("dragbackup")
+            except:
+                pass
+            assistants.append(4)
+            try:
+                await self.four.send_message(config.LOGGER_ID, "Assistant Started")
+            except:
+                LOGGER(__name__).error(
+                    "Assistant Account 4 has failed to access the log Group. Make sure that you have added your assistant to your log group and promoted as admin! "
+                )
+                exit()
+            self.four.id = self.four.me.id
+            self.four.name = self.four.me.mention
+            self.four.username = self.four.me.username
+            assistantids.append(self.four.id)
+            LOGGER(__name__).info(f"Assistant Four Started as {self.four.name}")
+
+        if config.STRING5:
+            await self.five.start()
+            try:
+                await self.five.join_chat("dragbackup")
+                await self.five.join_chat("dragbackup")
+            except:
+                pass
+            assistants.append(5)
+            try:
+                await self.five.send_message(config.LOGGER_ID, "Assistant Started")
+            except:
+                LOGGER(__name__).error(
+                    "Assistant Account 5 has failed to access the log Group. Make sure that you have added your assistant to your log group and promoted as admin! "
+                )
+                exit()
+            self.five.id = self.five.me.id
+            self.five.name = self.five.me.mention
+            self.five.username = self.five.me.username
+            assistantids.append(self.five.id)
+            LOGGER(__name__).info(f"Assistant Five Started as {self.five.name}")
+
+    async def stop(self):
+        LOGGER(__name__).info(f"Stopping Assistants...")
+        try:
+            if config.STRING1:
+                await self.one.stop()
+            if config.STRING2:
+                await self.two.stop()
+            if config.STRING3:
+                await self.three.stop()
+            if config.STRING4:
+                await self.four.stop()
+            if config.STRING5:
+                await self.five.stop()
+        except:
+            pass

DragMusic/logging.py

@@ -0,0 +1,19 @@
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s - %(levelname)s] - %(name)s - %(message)s",
+    datefmt="%d-%b-%y %H:%M:%S",
+    handlers=[
+        logging.FileHandler("logs.txt"),
+        logging.StreamHandler(),
+    ],
+)
+
+logging.getLogger("httpx").setLevel(logging.ERROR)
+logging.getLogger("pyrogram").setLevel(logging.ERROR)
+logging.getLogger("pytgcalls").setLevel(logging.ERROR)
+
+
+def LOGGER(name: str) -> logging.Logger:
+    return logging.getLogger(name)

DragMusic/misc.py

@@ -0,0 +1,75 @@
+import socket
+import time
+
+import heroku3
+from pyrogram import filters
+
+import config
+from DragMusic.core.mongo import mongodb
+
+from .logging import LOGGER
+
+SUDOERS = filters.user()
+
+HAPP = None
+_boot_ = time.time()
+
+
+def is_heroku():
+    return "heroku" in socket.getfqdn()
+
+
+XCB = [
+    "/",
+    "@",
+    ".",
+    "com",
+    ":",
+    "git",
+    "heroku",
+    "push",
+    str(config.HEROKU_API_KEY),
+    "https",
+    str(config.HEROKU_APP_NAME),
+    "HEAD",
+    "master",
+]
+
+
+def dbb():
+    global db
+    db = {}
+    LOGGER(__name__).info(f"Local Database Initialized.")
+
+
+async def sudo():
+    global SUDOERS
+    SUDOERS.add(config.OWNER_ID)
+    sudoersdb = mongodb.sudoers
+    sudoers = await sudoersdb.find_one({"sudo": "sudo"})
+    sudoers = [] if not sudoers else sudoers["sudoers"]
+    if config.OWNER_ID not in sudoers:
+        sudoers.append(config.OWNER_ID)
+        await sudoersdb.update_one(
+            {"sudo": "sudo"},
+            {"$set": {"sudoers": sudoers}},
+            upsert=True,
+        )
+    if sudoers:
+        for user_id in sudoers:
+            SUDOERS.add(user_id)
+    LOGGER(__name__).info(f"Sudoers Loaded.")
+
+
+def heroku():
+    global HAPP
+    if is_heroku:
+        if config.HEROKU_API_KEY and config.HEROKU_APP_NAME:
+            try:
+                Heroku = heroku3.from_key(config.HEROKU_API_KEY)
+                HAPP = Heroku.app(config.HEROKU_APP_NAME)
+                LOGGER(__name__).info(f"Heroku App Configured")
+            except BaseException:
+                LOGGER(__name__).warning(
+                    f"Please make sure your Heroku API Key and Your App name are configured correctly in the heroku."
+                )

DragMusic/platforms/Apple.py

@@ -0,0 +1,71 @@
+import re
+from typing import Union
+
+import aiohttp
+from bs4 import BeautifulSoup
+from youtubesearchpython.__future__ import VideosSearch
+
+
+class AppleAPI:
+    def __init__(self):
+        self.regex = r"^(https:\/\/music.apple.com\/)(.*)$"
+        self.base = "https://music.apple.com/in/playlist/"
+
+    async def valid(self, link: str):
+        if re.search(self.regex, link):
+            return True
+        else:
+            return False
+
+    async def track(self, url, playid: Union[bool, str] = None):
+        if playid:
+            url = self.base + url
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status != 200:
+                    return False
+                html = await response.text()
+        soup = BeautifulSoup(html, "html.parser")
+        search = None
+        for tag in soup.find_all("meta"):
+            if tag.get("property", None) == "og:title":
+                search = tag.get("content", None)
+        if search is None:
+            return False
+        results = VideosSearch(search, limit=1)
+        for result in (await results.next())["result"]:
+            title = result["title"]
+            ytlink = result["link"]
+            vidid = result["id"]
+            duration_min = result["duration"]
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+        track_details = {
+            "title": title,
+            "link": ytlink,
+            "vidid": vidid,
+            "duration_min": duration_min,
+            "thumb": thumbnail,
+        }
+        return track_details, vidid
+
+    async def playlist(self, url, playid: Union[bool, str] = None):
+        if playid:
+            url = self.base + url
+        playlist_id = url.split("playlist/")[1]
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status != 200:
+                    return False
+                html = await response.text()
+        soup = BeautifulSoup(html, "html.parser")
+        applelinks = soup.find_all("meta", attrs={"property": "music:song"})
+        results = []
+        for item in applelinks:
+            try:
+                xx = (((item["content"]).split("album/")[1]).split("/")[0]).replace(
+                    "-", " "
+                )
+            except:
+                xx = ((item["content"]).split("album/")[1]).split("/")[0]
+            results.append(xx)
+        return results, playlist_id

DragMusic/platforms/Carbon.py

@@ -0,0 +1,106 @@
+import random
+from os.path import realpath
+
+import aiohttp
+from aiohttp import client_exceptions
+
+
+class UnableToFetchCarbon(Exception):
+    pass
+
+
+themes = [
+    "3024-night",
+    "a11y-dark",
+    "blackboard",
+    "base16-dark",
+    "base16-light",
+    "cobalt",
+    "duotone-dark",
+    "dracula-pro",
+    "hopscotch",
+    "lucario",
+    "material",
+    "monokai",
+    "nightowl",
+    "nord",
+    "oceanic-next",
+    "one-light",
+    "one-dark",
+    "panda-syntax",
+    "parasio-dark",
+    "seti",
+    "shades-of-purple",
+    "solarized+dark",
+    "solarized+light",
+    "synthwave-84",
+    "twilight",
+    "verminal",
+    "vscode",
+    "yeti",
+    "zenburn",
+]
+
+colour = [
+    "#FF0000",
+    "#FF5733",
+    "#FFFF00",
+    "#008000",
+    "#0000FF",
+    "#800080",
+    "#A52A2A",
+    "#FF00FF",
+    "#D2B48C",
+    "#00FFFF",
+    "#808000",
+    "#800000",
+    "#00FFFF",
+    "#30D5C8",
+    "#00FF00",
+    "#008080",
+    "#4B0082",
+    "#EE82EE",
+    "#FFC0CB",
+    "#000000",
+    "#FFFFFF",
+    "#808080",
+]
+
+
+class CarbonAPI:
+    def __init__(self):
+        self.language = "auto"
+        self.drop_shadow = True
+        self.drop_shadow_blur = "68px"
+        self.drop_shadow_offset = "20px"
+        self.font_family = "JetBrains Mono"
+        self.width_adjustment = True
+        self.watermark = False
+
+    async def generate(self, text: str, user_id):
+        async with aiohttp.ClientSession(
+            headers={"Content-Type": "application/json"},
+        ) as ses:
+            params = {
+                "code": text,
+            }
+            params["backgroundColor"] = random.choice(colour)
+            params["theme"] = random.choice(themes)
+            params["dropShadow"] = self.drop_shadow
+            params["dropShadowOffsetY"] = self.drop_shadow_offset
+            params["dropShadowBlurRadius"] = self.drop_shadow_blur
+            params["fontFamily"] = self.font_family
+            params["language"] = self.language
+            params["watermark"] = self.watermark
+            params["widthAdjustment"] = self.width_adjustment
+            try:
+                request = await ses.post(
+                    "https://carbonara.solopov.dev/api/cook",
+                    json=params,
+                )
+            except client_exceptions.ClientConnectorError:
+                raise UnableToFetchCarbon("Can not reach the Host!")
+            resp = await request.read()
+            with open(f"cache/carbon{user_id}.jpg", "wb") as f:
+                f.write(resp)
+            return realpath(f.name)

DragMusic/platforms/Resso.py

@@ -0,0 +1,54 @@
+import re
+from typing import Union
+
+import aiohttp
+from bs4 import BeautifulSoup
+from youtubesearchpython.__future__ import VideosSearch
+
+
+class RessoAPI:
+    def __init__(self):
+        self.regex = r"^(https:\/\/m.resso.com\/)(.*)$"
+        self.base = "https://m.resso.com/"
+
+    async def valid(self, link: str):
+        if re.search(self.regex, link):
+            return True
+        else:
+            return False
+
+    async def track(self, url, playid: Union[bool, str] = None):
+        if playid:
+            url = self.base + url
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status != 200:
+                    return False
+                html = await response.text()
+        soup = BeautifulSoup(html, "html.parser")
+        for tag in soup.find_all("meta"):
+            if tag.get("property", None) == "og:title":
+                title = tag.get("content", None)
+            if tag.get("property", None) == "og:description":
+                des = tag.get("content", None)
+                try:
+                    des = des.split("·")[0]
+                except:
+                    pass
+        if des == "":
+            return
+        results = VideosSearch(title, limit=1)
+        for result in (await results.next())["result"]:
+            title = result["title"]
+            ytlink = result["link"]
+            vidid = result["id"]
+            duration_min = result["duration"]
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+        track_details = {
+            "title": title,
+            "link": ytlink,
+            "vidid": vidid,
+            "duration_min": duration_min,
+            "thumb": thumbnail,
+        }
+        return track_details, vidid

DragMusic/platforms/Soundcloud.py

@@ -0,0 +1,39 @@
+from os import path
+
+from yt_dlp import YoutubeDL
+
+from DragMusic.utils.formatters import seconds_to_min
+
+
+class SoundAPI:
+    def __init__(self):
+        self.opts = {
+            "outtmpl": "downloads/%(id)s.%(ext)s",
+            "format": "best",
+            "retries": 3,
+            "nooverwrites": False,
+            "continuedl": True,
+        }
+
+    async def valid(self, link: str):
+        if "soundcloud" in link:
+            return True
+        else:
+            return False
+
+    async def download(self, url):
+        d = YoutubeDL(self.opts)
+        try:
+            info = d.extract_info(url)
+        except:
+            return False
+        xyz = path.join("downloads", f"{info['id']}.{info['ext']}")
+        duration_min = seconds_to_min(info["duration"])
+        track_details = {
+            "title": info["title"],
+            "duration_sec": info["duration"],
+            "duration_min": duration_min,
+            "uploader": info["uploader"],
+            "filepath": xyz,
+        }
+        return track_details, xyz

DragMusic/platforms/Spotify.py

@@ -0,0 +1,98 @@
+import re
+
+import spotipy
+from spotipy.oauth2 import SpotifyClientCredentials
+from youtubesearchpython.__future__ import VideosSearch
+
+import config
+
+
+class SpotifyAPI:
+    def __init__(self):
+        self.regex = r"^(https:\/\/open.spotify.com\/)(.*)$"
+        self.client_id = config.SPOTIFY_CLIENT_ID
+        self.client_secret = config.SPOTIFY_CLIENT_SECRET
+        if config.SPOTIFY_CLIENT_ID and config.SPOTIFY_CLIENT_SECRET:
+            self.client_credentials_manager = SpotifyClientCredentials(
+                self.client_id, self.client_secret
+            )
+            self.spotify = spotipy.Spotify(
+                client_credentials_manager=self.client_credentials_manager
+            )
+        else:
+            self.spotify = None
+
+    async def valid(self, link: str):
+        if re.search(self.regex, link):
+            return True
+        else:
+            return False
+
+    async def track(self, link: str):
+        track = self.spotify.track(link)
+        info = track["name"]
+        for artist in track["artists"]:
+            fetched = f' {artist["name"]}'
+            if "Various Artists" not in fetched:
+                info += fetched
+        results = VideosSearch(info, limit=1)
+        for result in (await results.next())["result"]:
+            ytlink = result["link"]
+            title = result["title"]
+            vidid = result["id"]
+            duration_min = result["duration"]
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+        track_details = {
+            "title": title,
+            "link": ytlink,
+            "vidid": vidid,
+            "duration_min": duration_min,
+            "thumb": thumbnail,
+        }
+        return track_details, vidid
+
+    async def playlist(self, url):
+        playlist = self.spotify.playlist(url)
+        playlist_id = playlist["id"]
+        results = []
+        for item in playlist["tracks"]["items"]:
+            music_track = item["track"]
+            info = music_track["name"]
+            for artist in music_track["artists"]:
+                fetched = f' {artist["name"]}'
+                if "Various Artists" not in fetched:
+                    info += fetched
+            results.append(info)
+        return results, playlist_id
+
+    async def album(self, url):
+        album = self.spotify.album(url)
+        album_id = album["id"]
+        results = []
+        for item in album["tracks"]["items"]:
+            info = item["name"]
+            for artist in item["artists"]:
+                fetched = f' {artist["name"]}'
+                if "Various Artists" not in fetched:
+                    info += fetched
+            results.append(info)
+
+        return (
+            results,
+            album_id,
+        )
+
+    async def artist(self, url):
+        artistinfo = self.spotify.artist(url)
+        artist_id = artistinfo["id"]
+        results = []
+        artisttoptracks = self.spotify.artist_top_tracks(url)
+        for item in artisttoptracks["tracks"]:
+            info = item["name"]
+            for artist in item["artists"]:
+                fetched = f' {artist["name"]}'
+                if "Various Artists" not in fetched:
+                    info += fetched
+            results.append(info)
+
+        return results, artist_id

DragMusic/platforms/Telegram.py

@@ -0,0 +1,176 @@
+import asyncio
+import os
+import time
+from typing import Union
+
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Voice
+
+import config
+from DragMusic import app
+from DragMusic.utils.formatters import (
+    check_duration,
+    convert_bytes,
+    get_readable_time,
+    seconds_to_min,
+)
+
+
+class TeleAPI:
+    def __init__(self):
+        self.chars_limit = 4096
+        self.sleep = 5
+
+    async def send_split_text(self, message, string):
+        n = self.chars_limit
+        out = [(string[i : i + n]) for i in range(0, len(string), n)]
+        j = 0
+        for x in out:
+            if j <= 2:
+                j += 1
+                await message.reply_text(x, disable_web_page_preview=True)
+        return True
+
+    async def get_link(self, message):
+        return message.link
+
+    async def get_filename(self, file, audio: Union[bool, str] = None):
+        try:
+            file_name = file.file_name
+            if file_name is None:
+                file_name = "ᴛᴇʟᴇɢʀᴀᴍ ᴀᴜᴅɪᴏ" if audio else "ᴛᴇʟᴇɢʀᴀᴍ ᴠɪᴅᴇᴏ"
+        except:
+            file_name = "ᴛᴇʟᴇɢʀᴀᴍ ᴀᴜᴅɪᴏ" if audio else "ᴛᴇʟᴇɢʀᴀᴍ ᴠɪᴅᴇᴏ"
+        return file_name
+
+    async def get_duration(self, file):
+        try:
+            dur = seconds_to_min(file.duration)
+        except:
+            dur = "Unknown"
+        return dur
+
+    async def get_duration(self, filex, file_path):
+        try:
+            dur = seconds_to_min(filex.duration)
+        except:
+            try:
+                dur = await asyncio.get_event_loop().run_in_executor(
+                    None, check_duration, file_path
+                )
+                dur = seconds_to_min(dur)
+            except:
+                return "Unknown"
+        return dur
+
+    async def get_filepath(
+        self,
+        audio: Union[bool, str] = None,
+        video: Union[bool, str] = None,
+    ):
+        if audio:
+            try:
+                file_name = (
+                    audio.file_unique_id
+                    + "."
+                    + (
+                        (audio.file_name.split(".")[-1])
+                        if (not isinstance(audio, Voice))
+                        else "ogg"
+                    )
+                )
+            except:
+                file_name = audio.file_unique_id + "." + "ogg"
+            file_name = os.path.join(os.path.realpath("downloads"), file_name)
+        if video:
+            try:
+                file_name = (
+                    video.file_unique_id + "." + (video.file_name.split(".")[-1])
+                )
+            except:
+                file_name = video.file_unique_id + "." + "mp4"
+            file_name = os.path.join(os.path.realpath("downloads"), file_name)
+        return file_name
+
+    async def download(self, _, message, mystic, fname):
+        lower = [0, 8, 17, 38, 64, 77, 96]
+        higher = [5, 10, 20, 40, 66, 80, 99]
+        checker = [5, 10, 20, 40, 66, 80, 99]
+        speed_counter = {}
+        if os.path.exists(fname):
+            return True
+
+        async def down_load():
+            async def progress(current, total):
+                if current == total:
+                    return
+                current_time = time.time()
+                start_time = speed_counter.get(message.id)
+                check_time = current_time - start_time
+                upl = InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                text="ᴄᴀɴᴄᴇʟ",
+                                callback_data="stop_downloading",
+                            ),
+                        ]
+                    ]
+                )
+                percentage = current * 100 / total
+                percentage = str(round(percentage, 2))
+                speed = current / check_time
+                eta = int((total - current) / speed)
+                eta = get_readable_time(eta)
+                if not eta:
+                    eta = "0 sᴇᴄᴏɴᴅs"
+                total_size = convert_bytes(total)
+                completed_size = convert_bytes(current)
+                speed = convert_bytes(speed)
+                percentage = int((percentage.split("."))[0])
+                for counter in range(7):
+                    low = int(lower[counter])
+                    high = int(higher[counter])
+                    check = int(checker[counter])
+                    if low < percentage <= high:
+                        if high == check:
+                            try:
+                                await mystic.edit_text(
+                                    text=_["tg_1"].format(
+                                        app.mention,
+                                        total_size,
+                                        completed_size,
+                                        percentage[:5],
+                                        speed,
+                                        eta,
+                                    ),
+                                    reply_markup=upl,
+                                )
+                                checker[counter] = 100
+                            except:
+                                pass
+
+            speed_counter[message.id] = time.time()
+            try:
+                await app.download_media(
+                    message.reply_to_message,
+                    file_name=fname,
+                    progress=progress,
+                )
+                try:
+                    elapsed = get_readable_time(
+                        int(int(time.time()) - int(speed_counter[message.id]))
+                    )
+                except:
+                    elapsed = "0 sᴇᴄᴏɴᴅs"
+                await mystic.edit_text(_["tg_2"].format(elapsed))
+            except:
+                await mystic.edit_text(_["tg_3"])
+
+        task = asyncio.create_task(down_load())
+        config.lyrical[mystic.id] = task
+        await task
+        verify = config.lyrical.get(mystic.id)
+        if not verify:
+            return False
+        config.lyrical.pop(mystic.id)
+        return True

DragMusic/platforms/Youtube.py

@@ -0,0 +1,470 @@
+import asyncio
+import os
+import re
+import json
+from typing import Union
+import requests
+import yt_dlp
+from pyrogram.enums import MessageEntityType
+from pyrogram.types import Message
+from youtubesearchpython.__future__ import VideosSearch
+from DragMusic.utils.database import is_on_off
+from DragMusic.utils.formatters import time_to_seconds
+import os
+import glob
+import random
+import logging
+import aiohttp
+import config
+from config import API_URL, API_KEY
+
+
+def cookie_txt_file():
+    cookie_dir = f"{os.getcwd()}/cookies"
+    cookies_files = [f for f in os.listdir(cookie_dir) if f.endswith(".txt")]
+
+    cookie_file = os.path.join(cookie_dir, random.choice(cookies_files))
+    return cookie_file
+
+
+async def download_song(link: str):
+    video_id = link.split('v=')[-1].split('&')[0]
+
+    download_folder = "downloads"
+    for ext in ["mp3", "m4a", "webm"]:
+        file_path = f"{download_folder}/{video_id}.{ext}"
+        if os.path.exists(file_path):
+            #print(f"File already exists: {file_path}")
+            return file_path
+        
+    song_url = f"{API_URL}/song/{video_id}?api={API_KEY}"
+    async with aiohttp.ClientSession() as session:
+        while True:
+            try:
+                async with session.get(song_url) as response:
+                    if response.status != 200:
+                        raise Exception(f"API request failed with status code {response.status}")
+                    data = await response.json()
+                    status = data.get("status", "").lower()
+                    if status == "downloading":
+                        await asyncio.sleep(2)
+                        continue
+                    elif status == "error":
+                        error_msg = data.get("error") or data.get("message") or "Unknown error"
+                        raise Exception(f"API error: {error_msg}")
+                    elif status == "done":
+                        download_url = data.get("link")
+                        if not download_url:
+                            raise Exception("API response did not provide a download URL.")
+                        break
+                    else:
+                        raise Exception(f"Unexpected status '{status}' from API.")
+            except Exception as e:
+                print(f"Error while checking API status: {e}")
+                return None
+
+        try:
+            file_format = data.get("format", "mp3")
+            file_extension = file_format.lower()
+            file_name = f"{video_id}.{file_extension}"
+            download_folder = "downloads"
+            os.makedirs(download_folder, exist_ok=True)
+            file_path = os.path.join(download_folder, file_name)
+
+            async with session.get(download_url) as file_response:
+                with open(file_path, 'wb') as f:
+                    while True:
+                        chunk = await file_response.content.read(8192)
+                        if not chunk:
+                            break
+                        f.write(chunk)
+                return file_path
+        except aiohttp.ClientError as e:
+            print(f"Network or client error occurred while downloading: {e}")
+            return None
+        except Exception as e:
+            print(f"Error occurred while downloading song: {e}")
+            return None
+    return None
+
+async def check_file_size(link):
+    async def get_format_info(link):
+        proc = await asyncio.create_subprocess_exec(
+            "yt-dlp",
+            "--cookies", cookie_txt_file(),
+            "-J",
+            link,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            print(f'Error:\n{stderr.decode()}')
+            return None
+        return json.loads(stdout.decode())
+
+    def parse_size(formats):
+        total_size = 0
+        for format in formats:
+            if 'filesize' in format:
+                total_size += format['filesize']
+        return total_size
+
+    info = await get_format_info(link)
+    if info is None:
+        return None
+    
+    formats = info.get('formats', [])
+    if not formats:
+        print("No formats found.")
+        return None
+    
+    total_size = parse_size(formats)
+    return total_size
+
+async def shell_cmd(cmd):
+    proc = await asyncio.create_subprocess_shell(
+        cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    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):
+        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-?]*[ -/]*[@-~])")
+
+    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:
+            return False
+
+    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]
+
+    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
+
+    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
+
+    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
+
+    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",cookie_txt_file(),
+            "-g",
+            "-f",
+            "best[height<=?720][width<=?1280]",
+            f"{link}",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        if stdout:
+            return 1, stdout.decode().split("\n")[0]
+        else:
+            return 0, stderr.decode()
+
+    async def playlist(self, link, limit, user_id, videoid: Union[bool, str] = None):
+        if videoid:
+            link = self.listbase + link
+        if "&" in link:
+            link = link.split("&")[0]
+        playlist = await shell_cmd(
+            f"yt-dlp -i --get-id --flat-playlist --cookies {cookie_txt_file()} --playlist-end {limit} --skip-download {link}"
+        )
+        try:
+            result = playlist.split("\n")
+            for key in result:
+                if key == "":
+                    result.remove(key)
+        except:
+            result = []
+        return result
+
+    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 track_details, vidid
+
+    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 = {"quiet": True, "cookiefile" : cookie_txt_file()}
+        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
+                    formats_available.append(
+                        {
+                            "format": format["format"],
+                            "filesize": format["filesize"],
+                            "format_id": format["format_id"],
+                            "ext": format["ext"],
+                            "format_note": format["format_note"],
+                            "yturl": link,
+                        }
+                    )
+        return formats_available, link
+
+    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
+
+    async def download(
+        self,
+        link: str,
+        mystic,
+        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()
+        def audio_dl():
+            ydl_optssx = {
+                "format": "bestaudio/best",
+                "outtmpl": "downloads/%(id)s.%(ext)s",
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "cookiefile" : cookie_txt_file(),
+                "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,
+                "cookiefile" : cookie_txt_file(),
+                "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 song_video_dl():
+            formats = f"{format_id}+140"
+            fpath = f"downloads/{title}"
+            ydl_optssx = {
+                "format": formats,
+                "outtmpl": fpath,
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "no_warnings": True,
+                "cookiefile" : cookie_txt_file(),
+                "prefer_ffmpeg": True,
+                "merge_output_format": "mp4",
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            x.download([link])
+
+        def song_audio_dl():
+            fpath = f"downloads/{title}.%(ext)s"
+            ydl_optssx = {
+                "format": format_id,
+                "outtmpl": fpath,
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "no_warnings": True,
+                "cookiefile" : cookie_txt_file(),
+                "prefer_ffmpeg": True,
+                "postprocessors": [
+                    {
+                        "key": "FFmpegExtractAudio",
+                        "preferredcodec": "mp3",
+                        "preferredquality": "192",
+                    }
+                ],
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            x.download([link])
+
+        if songvideo:
+            await download_song(link)
+            fpath = f"downloads/{link}.mp3"
+            return fpath
+        elif songaudio:
+            await download_song(link)
+            fpath = f"downloads/{link}.mp3"
+            return fpath
+        elif video:
+            if await is_on_off(1):
+                direct = True
+                downloaded_file = await download_song(link)
+            else:
+                proc = await asyncio.create_subprocess_exec(
+                    "yt-dlp",
+                    "--cookies",cookie_txt_file(),
+                    "-g",
+                    "-f",
+                    "best[height<=?720][width<=?1280]",
+                    f"{link}",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, stderr = await proc.communicate()
+                if stdout:
+                    downloaded_file = stdout.decode().split("\n")[0]
+                    direct = False
+                else:
+                   file_size = await check_file_size(link)
+                   if not file_size:
+                     print("None file Size")
+                     return
+                   total_size_mb = file_size / (1024 * 1024)
+                   if total_size_mb > 250:
+                     print(f"File size {total_size_mb:.2f} MB exceeds the 100MB limit.")
+                     return None
+                   direct = True
+                   downloaded_file = await loop.run_in_executor(None, video_dl)
+        else:
+            direct = True
+            downloaded_file = await download_song(link)
+        return downloaded_file, direct

DragMusic/platforms/__init__.py

@@ -0,0 +1,7 @@
+from .Apple import AppleAPI
+from .Carbon import CarbonAPI
+from .Resso import RessoAPI
+from .Soundcloud import SoundAPI
+from .Spotify import SpotifyAPI
+from .Telegram import TeleAPI
+from .Youtube import YouTubeAPI

DragMusic/plugins/__init__.py

@@ -0,0 +1,19 @@
+import glob
+from os.path import dirname, isfile
+
+
+def __list_all_modules():
+    work_dir = dirname(__file__)
+    mod_paths = glob.glob(work_dir + "/*/*.py")
+
+    all_modules = [
+        (((f.replace(work_dir, "")).replace("/", "."))[:-3])
+        for f in mod_paths
+        if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
+    ]
+
+    return all_modules
+
+
+ALL_MODULES = sorted(__list_all_modules())
+__all__ = ALL_MODULES + ["ALL_MODULES"]

DragMusic/plugins/admins/auth.py

@@ -0,0 +1,89 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import app
+from DragMusic.utils import extract_user, int_to_alpha
+from DragMusic.utils.database import (
+    delete_authuser,
+    get_authuser,
+    get_authuser_names,
+    save_authuser,
+)
+from DragMusic.utils.decorators import AdminActual, language
+from DragMusic.utils.inline import close_markup
+from config import BANNED_USERS, adminlist
+
+
+@app.on_message(filters.command("auth") & filters.group & ~BANNED_USERS)
+@AdminActual
+async def auth(client, message: Message, _):
+    if not message.reply_to_message:
+        if len(message.command) != 2:
+            return await message.reply_text(_["general_1"])
+    user = await extract_user(message)
+    token = await int_to_alpha(user.id)
+    _check = await get_authuser_names(message.chat.id)
+    count = len(_check)
+    if int(count) == 25:
+        return await message.reply_text(_["auth_1"])
+    if token not in _check:
+        assis = {
+            "auth_user_id": user.id,
+            "auth_name": user.first_name,
+            "admin_id": message.from_user.id,
+            "admin_name": message.from_user.first_name,
+        }
+        get = adminlist.get(message.chat.id)
+        if get:
+            if user.id not in get:
+                get.append(user.id)
+        await save_authuser(message.chat.id, token, assis)
+        return await message.reply_text(_["auth_2"].format(user.mention))
+    else:
+        return await message.reply_text(_["auth_3"].format(user.mention))
+
+
+@app.on_message(filters.command("unauth") & filters.group & ~BANNED_USERS)
+@AdminActual
+async def unauthusers(client, message: Message, _):
+    if not message.reply_to_message:
+        if len(message.command) != 2:
+            return await message.reply_text(_["general_1"])
+    user = await extract_user(message)
+    token = await int_to_alpha(user.id)
+    deleted = await delete_authuser(message.chat.id, token)
+    get = adminlist.get(message.chat.id)
+    if get:
+        if user.id in get:
+            get.remove(user.id)
+    if deleted:
+        return await message.reply_text(_["auth_4"].format(user.mention))
+    else:
+        return await message.reply_text(_["auth_5"].format(user.mention))
+
+
+@app.on_message(
+    filters.command(["authlist", "authusers"]) & filters.group & ~BANNED_USERS
+)
+@language
+async def authusers(client, message: Message, _):
+    _wtf = await get_authuser_names(message.chat.id)
+    if not _wtf:
+        return await message.reply_text(_["setting_4"])
+    else:
+        j = 0
+        mystic = await message.reply_text(_["auth_6"])
+        text = _["auth_7"].format(message.chat.title)
+        for umm in _wtf:
+            _umm = await get_authuser(message.chat.id, umm)
+            user_id = _umm["auth_user_id"]
+            admin_id = _umm["admin_id"]
+            admin_name = _umm["admin_name"]
+            try:
+                user = (await app.get_users(user_id)).first_name
+                j += 1
+            except:
+                continue
+            text += f"{j}➤ {user}[<code>{user_id}</code>]\n"
+            text += f"   {_['auth_8']} {admin_name}[<code>{admin_id}</code>]\n\n"
+        await mystic.edit_text(text, reply_markup=close_markup(_))

DragMusic/plugins/admins/callback.py

@@ -0,0 +1,397 @@
+import asyncio
+
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+
+from DragMusic import YouTube, app
+from DragMusic.core.call import Drag
+from DragMusic.misc import SUDOERS, db
+from DragMusic.utils.database import (
+    get_active_chats,
+    get_lang,
+    get_upvote_count,
+    is_active_chat,
+    is_music_playing,
+    is_nonadmin_chat,
+    music_off,
+    music_on,
+    set_loop,
+)
+from DragMusic.utils.decorators.language import languageCB
+from DragMusic.utils.formatters import seconds_to_min
+from DragMusic.utils.inline import close_markup, stream_markup, stream_markup_timer
+from DragMusic.utils.stream.autoclear import auto_clean
+from DragMusic.utils.thumbnails import get_thumb
+from config import (
+    BANNED_USERS,
+    SUPPORT_CHAT,
+    SOUNCLOUD_IMG_URL,
+    STREAM_IMG_URL,
+    TELEGRAM_AUDIO_URL,
+    TELEGRAM_VIDEO_URL,
+    adminlist,
+    confirmer,
+    votemode,
+)
+from strings import get_string
+
+checker = {}
+upvoters = {}
+
+
+@app.on_callback_query(filters.regex("ADMIN") & ~BANNED_USERS)
+@languageCB
+async def del_back_playlist(client, CallbackQuery, _):
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    command, chat = callback_request.split("|")
+    if "_" in str(chat):
+        bet = chat.split("_")
+        chat = bet[0]
+        counter = bet[1]
+    chat_id = int(chat)
+    if not await is_active_chat(chat_id):
+        return await CallbackQuery.answer(_["general_5"], show_alert=True)
+    mention = CallbackQuery.from_user.mention
+    if command == "UpVote":
+        if chat_id not in votemode:
+            votemode[chat_id] = {}
+        if chat_id not in upvoters:
+            upvoters[chat_id] = {}
+
+        voters = (upvoters[chat_id]).get(CallbackQuery.message.id)
+        if not voters:
+            upvoters[chat_id][CallbackQuery.message.id] = []
+
+        vote = (votemode[chat_id]).get(CallbackQuery.message.id)
+        if not vote:
+            votemode[chat_id][CallbackQuery.message.id] = 0
+
+        if CallbackQuery.from_user.id in upvoters[chat_id][CallbackQuery.message.id]:
+            (upvoters[chat_id][CallbackQuery.message.id]).remove(
+                CallbackQuery.from_user.id
+            )
+            votemode[chat_id][CallbackQuery.message.id] -= 1
+        else:
+            (upvoters[chat_id][CallbackQuery.message.id]).append(
+                CallbackQuery.from_user.id
+            )
+            votemode[chat_id][CallbackQuery.message.id] += 1
+        upvote = await get_upvote_count(chat_id)
+        get_upvotes = int(votemode[chat_id][CallbackQuery.message.id])
+        if get_upvotes >= upvote:
+            votemode[chat_id][CallbackQuery.message.id] = upvote
+            try:
+                exists = confirmer[chat_id][CallbackQuery.message.id]
+                current = db[chat_id][0]
+            except:
+                return await CallbackQuery.edit_message_text(f"ғᴀɪʟᴇᴅ.")
+            try:
+                if current["vidid"] != exists["vidid"]:
+                    return await CallbackQuery.edit_message.text(_["admin_35"])
+                if current["file"] != exists["file"]:
+                    return await CallbackQuery.edit_message.text(_["admin_35"])
+            except:
+                return await CallbackQuery.edit_message_text(_["admin_36"])
+            try:
+                await CallbackQuery.edit_message_text(_["admin_37"].format(upvote))
+            except:
+                pass
+            command = counter
+            mention = "ᴜᴘᴠᴏᴛᴇs"
+        else:
+            if (
+                CallbackQuery.from_user.id
+                in upvoters[chat_id][CallbackQuery.message.id]
+            ):
+                await CallbackQuery.answer(_["admin_38"], show_alert=True)
+            else:
+                await CallbackQuery.answer(_["admin_39"], show_alert=True)
+            upl = InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            text=f"👍 {get_upvotes}",
+                            callback_data=f"ADMIN  UpVote|{chat_id}_{counter}",
+                        )
+                    ]
+                ]
+            )
+            await CallbackQuery.answer(_["admin_40"], show_alert=True)
+            return await CallbackQuery.edit_message_reply_markup(reply_markup=upl)
+    else:
+        is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+        if not is_non_admin:
+            if CallbackQuery.from_user.id not in SUDOERS:
+                admins = adminlist.get(CallbackQuery.message.chat.id)
+                if not admins:
+                    return await CallbackQuery.answer(_["admin_13"], show_alert=True)
+                else:
+                    if CallbackQuery.from_user.id not in admins:
+                        return await CallbackQuery.answer(
+                            _["admin_14"], show_alert=True
+                        )
+    if command == "Pause":
+        if not await is_music_playing(chat_id):
+            return await CallbackQuery.answer(_["admin_1"], show_alert=True)
+        await CallbackQuery.answer()
+        await music_off(chat_id)
+        await Drag.pause_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_2"].format(mention), reply_markup=close_markup(_)
+        )
+    elif command == "Resume":
+        if await is_music_playing(chat_id):
+            return await CallbackQuery.answer(_["admin_3"], show_alert=True)
+        await CallbackQuery.answer()
+        await music_on(chat_id)
+        await Drag.resume_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_4"].format(mention), reply_markup=close_markup(_)
+        )
+    elif command == "Stop" or command == "End":
+        await CallbackQuery.answer()
+        await Drag.stop_stream(chat_id)
+        await set_loop(chat_id, 0)
+        await CallbackQuery.message.reply_text(
+            _["admin_5"].format(mention), reply_markup=close_markup(_)
+        )
+        await CallbackQuery.message.delete()
+    elif command == "Skip" or command == "Replay":
+        check = db.get(chat_id)
+        if command == "Skip":
+            txt = f"➻ sᴛʀᴇᴀᴍ sᴋɪᴩᴩᴇᴅ 🎄\n│ \n└ʙʏ : {mention} 🥀"
+            popped = None
+            try:
+                popped = check.pop(0)
+                if popped:
+                    await auto_clean(popped)
+                if not check:
+                    await CallbackQuery.edit_message_text(
+                        f"➻ sᴛʀᴇᴀᴍ sᴋɪᴩᴩᴇᴅ 🎄\n│ \n└ʙʏ : {mention} 🥀"
+                    )
+                    await CallbackQuery.message.reply_text(
+                        text=_["admin_6"].format(
+                            mention, CallbackQuery.message.chat.title
+                        ),
+                        reply_markup=close_markup(_),
+                    )
+                    try:
+                        return await Drag.stop_stream(chat_id)
+                    except:
+                        return
+            except:
+                try:
+                    await CallbackQuery.edit_message_text(
+                        f"➻ sᴛʀᴇᴀᴍ sᴋɪᴩᴩᴇᴅ 🎄\n│ \n└ʙʏ : {mention} 🥀"
+                    )
+                    await CallbackQuery.message.reply_text(
+                        text=_["admin_6"].format(
+                            mention, CallbackQuery.message.chat.title
+                        ),
+                        reply_markup=close_markup(_),
+                    )
+                    return await Drag.stop_stream(chat_id)
+                except:
+                    return
+        else:
+            txt = f"➻ sᴛʀᴇᴀᴍ ʀᴇ-ᴘʟᴀʏᴇᴅ 🎄\n│ \n└ʙʏ : {mention} 🥀"
+        await CallbackQuery.answer()
+        queued = check[0]["file"]
+        title = (check[0]["title"]).title()
+        user = check[0]["by"]
+        duration = check[0]["dur"]
+        streamtype = check[0]["streamtype"]
+        videoid = check[0]["vidid"]
+        status = True if str(streamtype) == "video" else None
+        db[chat_id][0]["played"] = 0
+        exis = (check[0]).get("old_dur")
+        if exis:
+            db[chat_id][0]["dur"] = exis
+            db[chat_id][0]["seconds"] = check[0]["old_second"]
+            db[chat_id][0]["speed_path"] = None
+            db[chat_id][0]["speed"] = 1.0
+        if "live_" in queued:
+            n, link = await YouTube.video(videoid, True)
+            if n == 0:
+                return await CallbackQuery.message.reply_text(
+                    text=_["admin_7"].format(title),
+                    reply_markup=close_markup(_),
+                )
+            try:
+                image = await YouTube.thumbnail(videoid, True)
+            except:
+                image = None
+            try:
+                await Drag.skip_stream(chat_id, link, video=status, image=image)
+            except:
+                return await CallbackQuery.message.reply_text(_["call_6"])
+            button = stream_markup(_, chat_id)
+            img = await get_thumb(videoid)
+            run = await CallbackQuery.message.reply_photo(
+                photo=img,
+                caption=_["stream_1"].format(
+                    f"https://t.me/{app.username}?start=info_{videoid}",
+                    title[:23],
+                    duration,
+                    user,
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+            await CallbackQuery.edit_message_text(txt, reply_markup=close_markup(_))
+        elif "vid_" in queued:
+            mystic = await CallbackQuery.message.reply_text(
+                _["call_7"], disable_web_page_preview=True
+            )
+            try:
+                file_path, direct = await YouTube.download(
+                    videoid,
+                    mystic,
+                    videoid=True,
+                    video=status,
+                )
+            except:
+                return await mystic.edit_text(_["call_6"])
+            try:
+                image = await YouTube.thumbnail(videoid, True)
+            except:
+                image = None
+            try:
+                await Drag.skip_stream(chat_id, file_path, video=status, image=image)
+            except:
+                return await mystic.edit_text(_["call_6"])
+            button = stream_markup(_, chat_id)
+            img = await get_thumb(videoid)
+            run = await CallbackQuery.message.reply_photo(
+                photo=img,
+                caption=_["stream_1"].format(
+                    f"https://t.me/{app.username}?start=info_{videoid}",
+                    title[:23],
+                    duration,
+                    user,
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "stream"
+            await CallbackQuery.edit_message_text(txt, reply_markup=close_markup(_))
+            await mystic.delete()
+        elif "index_" in queued:
+            try:
+                await Drag.skip_stream(chat_id, videoid, video=status)
+            except:
+                return await CallbackQuery.message.reply_text(_["call_6"])
+            button = stream_markup(_, chat_id)
+            run = await CallbackQuery.message.reply_photo(
+                photo=STREAM_IMG_URL,
+                caption=_["stream_2"].format(user),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+            await CallbackQuery.edit_message_text(txt, reply_markup=close_markup(_))
+        else:
+            if videoid == "telegram":
+                image = None
+            elif videoid == "soundcloud":
+                image = None
+            else:
+                try:
+                    image = await YouTube.thumbnail(videoid, True)
+                except:
+                    image = None
+            try:
+                await Drag.skip_stream(chat_id, queued, video=status, image=image)
+            except:
+                return await CallbackQuery.message.reply_text(_["call_6"])
+            if videoid == "telegram":
+                button = stream_markup(_, chat_id)
+                run = await CallbackQuery.message.reply_photo(
+                    photo=TELEGRAM_AUDIO_URL
+                    if str(streamtype) == "audio"
+                    else TELEGRAM_VIDEO_URL,
+                    caption=_["stream_1"].format(
+                        SUPPORT_CHAT, title[:23], duration, user
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "tg"
+            elif videoid == "soundcloud":
+                button = stream_markup(_, chat_id)
+                run = await CallbackQuery.message.reply_photo(
+                    photo=SOUNCLOUD_IMG_URL
+                    if str(streamtype) == "audio"
+                    else TELEGRAM_VIDEO_URL,
+                    caption=_["stream_1"].format(
+                        SUPPORT_CHAT, title[:23], duration, user
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "tg"
+            else:
+                button = stream_markup(_, chat_id)
+                img = await get_thumb(videoid)
+                run = await CallbackQuery.message.reply_photo(
+                    photo=img,
+                    caption=_["stream_1"].format(
+                        f"https://t.me/{app.username}?start=info_{videoid}",
+                        title[:23],
+                        duration,
+                        user,
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "stream"
+            await CallbackQuery.edit_message_text(txt, reply_markup=close_markup(_))
+
+
+async def markup_timer():
+    while not await asyncio.sleep(7):
+        active_chats = await get_active_chats()
+        for chat_id in active_chats:
+            try:
+                if not await is_music_playing(chat_id):
+                    continue
+                playing = db.get(chat_id)
+                if not playing:
+                    continue
+                duration_seconds = int(playing[0]["seconds"])
+                if duration_seconds == 0:
+                    continue
+                try:
+                    mystic = playing[0]["mystic"]
+                except:
+                    continue
+                try:
+                    check = checker[chat_id][mystic.id]
+                    if check is False:
+                        continue
+                except:
+                    pass
+                try:
+                    language = await get_lang(chat_id)
+                    _ = get_string(language)
+                except:
+                    _ = get_string("en")
+                try:
+                    buttons = stream_markup_timer(
+                        _,
+                        chat_id,
+                        seconds_to_min(playing[0]["played"]),
+                        playing[0]["dur"],
+                    )
+                    await mystic.edit_reply_markup(
+                        reply_markup=InlineKeyboardMarkup(buttons)
+                    )
+                except:
+                    continue
+            except:
+                continue
+
+
+asyncio.create_task(markup_timer())

DragMusic/plugins/admins/loop.py

@@ -0,0 +1,46 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import app
+from DragMusic.utils.database import get_loop, set_loop
+from DragMusic.utils.decorators import AdminRightsCheck
+from DragMusic.utils.inline import close_markup
+from config import BANNED_USERS
+
+
+@app.on_message(filters.command(["loop", "cloop"]) & filters.group & ~BANNED_USERS)
+@AdminRightsCheck
+async def admins(cli, message: Message, _, chat_id):
+    usage = _["admin_17"]
+    if len(message.command) != 2:
+        return await message.reply_text(usage)
+    state = message.text.split(None, 1)[1].strip()
+    if state.isnumeric():
+        state = int(state)
+        if 1 <= state <= 10:
+            got = await get_loop(chat_id)
+            if got != 0:
+                state = got + state
+            if int(state) > 10:
+                state = 10
+            await set_loop(chat_id, state)
+            return await message.reply_text(
+                text=_["admin_18"].format(state, message.from_user.mention),
+                reply_markup=close_markup(_),
+            )
+        else:
+            return await message.reply_text(_["admin_17"])
+    elif state.lower() == "enable":
+        await set_loop(chat_id, 10)
+        return await message.reply_text(
+            text=_["admin_18"].format(state, message.from_user.mention),
+            reply_markup=close_markup(_),
+        )
+    elif state.lower() == "disable":
+        await set_loop(chat_id, 0)
+        return await message.reply_text(
+            _["admin_19"].format(message.from_user.mention),
+            reply_markup=close_markup(_),
+        )
+    else:
+        return await message.reply_text(usage)

DragMusic/plugins/admins/pause.py

@@ -0,0 +1,21 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import app
+from DragMusic.core.call import Drag
+from DragMusic.utils.database import is_music_playing, music_off
+from DragMusic.utils.decorators import AdminRightsCheck
+from DragMusic.utils.inline import close_markup
+from config import BANNED_USERS
+
+
+@app.on_message(filters.command(["pause", "cpause"]) & filters.group & ~BANNED_USERS)
+@AdminRightsCheck
+async def pause_admin(cli, message: Message, _, chat_id):
+    if not await is_music_playing(chat_id):
+        return await message.reply_text(_["admin_1"])
+    await music_off(chat_id)
+    await Drag.pause_stream(chat_id)
+    await message.reply_text(
+        _["admin_2"].format(message.from_user.mention), reply_markup=close_markup(_)
+    )

DragMusic/plugins/admins/resume.py

@@ -0,0 +1,21 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import app
+from DragMusic.core.call import Drag
+from DragMusic.utils.database import is_music_playing, music_on
+from DragMusic.utils.decorators import AdminRightsCheck
+from DragMusic.utils.inline import close_markup
+from config import BANNED_USERS
+
+
+@app.on_message(filters.command(["resume", "cresume"]) & filters.group & ~BANNED_USERS)
+@AdminRightsCheck
+async def resume_com(cli, message: Message, _, chat_id):
+    if await is_music_playing(chat_id):
+        return await message.reply_text(_["admin_3"])
+    await music_on(chat_id)
+    await Drag.resume_stream(chat_id)
+    await message.reply_text(
+        _["admin_4"].format(message.from_user.mention), reply_markup=close_markup(_)
+    )

DragMusic/plugins/admins/seek.py

@@ -0,0 +1,75 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import YouTube, app
+from DragMusic.core.call import Drag
+from DragMusic.misc import db
+from DragMusic.utils import AdminRightsCheck, seconds_to_min
+from DragMusic.utils.inline import close_markup
+from config import BANNED_USERS
+
+
+@app.on_message(
+    filters.command(["seek", "cseek", "seekback", "cseekback"])
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def seek_comm(cli, message: Message, _, chat_id):
+    if len(message.command) == 1:
+        return await message.reply_text(_["admin_20"])
+    query = message.text.split(None, 1)[1].strip()
+    if not query.isnumeric():
+        return await message.reply_text(_["admin_21"])
+    playing = db.get(chat_id)
+    if not playing:
+        return await message.reply_text(_["queue_2"])
+    duration_seconds = int(playing[0]["seconds"])
+    if duration_seconds == 0:
+        return await message.reply_text(_["admin_22"])
+    file_path = playing[0]["file"]
+    duration_played = int(playing[0]["played"])
+    duration_to_skip = int(query)
+    duration = playing[0]["dur"]
+    if message.command[0][-2] == "c":
+        if (duration_played - duration_to_skip) <= 10:
+            return await message.reply_text(
+                text=_["admin_23"].format(seconds_to_min(duration_played), duration),
+                reply_markup=close_markup(_),
+            )
+        to_seek = duration_played - duration_to_skip + 1
+    else:
+        if (duration_seconds - (duration_played + duration_to_skip)) <= 10:
+            return await message.reply_text(
+                text=_["admin_23"].format(seconds_to_min(duration_played), duration),
+                reply_markup=close_markup(_),
+            )
+        to_seek = duration_played + duration_to_skip + 1
+    mystic = await message.reply_text(_["admin_24"])
+    if "vid_" in file_path:
+        n, file_path = await YouTube.video(playing[0]["vidid"], True)
+        if n == 0:
+            return await message.reply_text(_["admin_22"])
+    check = (playing[0]).get("speed_path")
+    if check:
+        file_path = check
+    if "index_" in file_path:
+        file_path = playing[0]["vidid"]
+    try:
+        await Drag.seek_stream(
+            chat_id,
+            file_path,
+            seconds_to_min(to_seek),
+            duration,
+            playing[0]["streamtype"],
+        )
+    except:
+        return await mystic.edit_text(_["admin_26"], reply_markup=close_markup(_))
+    if message.command[0][-2] == "c":
+        db[chat_id][0]["played"] -= duration_to_skip
+    else:
+        db[chat_id][0]["played"] += duration_to_skip
+    await mystic.edit_text(
+        text=_["admin_25"].format(seconds_to_min(to_seek), message.from_user.mention),
+        reply_markup=close_markup(_),
+    )

DragMusic/plugins/admins/shuffle.py

@@ -0,0 +1,33 @@
+import random
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import app
+from DragMusic.misc import db
+from DragMusic.utils.decorators import AdminRightsCheck
+from DragMusic.utils.inline import close_markup
+from config import BANNED_USERS
+
+
+@app.on_message(
+    filters.command(["shuffle", "cshuffle"]) & filters.group & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def admins(Client, message: Message, _, chat_id):
+    check = db.get(chat_id)
+    if not check:
+        return await message.reply_text(_["queue_2"])
+    try:
+        popped = check.pop(0)
+    except:
+        return await message.reply_text(_["admin_15"], reply_markup=close_markup(_))
+    check = db.get(chat_id)
+    if not check:
+        check.insert(0, popped)
+        return await message.reply_text(_["admin_15"], reply_markup=close_markup(_))
+    random.shuffle(check)
+    check.insert(0, popped)
+    await message.reply_text(
+        _["admin_16"].format(message.from_user.mention), reply_markup=close_markup(_)
+    )

DragMusic/plugins/admins/skip.py

@@ -0,0 +1,232 @@
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardMarkup, Message
+
+import config
+from DragMusic import YouTube, app
+from DragMusic.core.call import Drag
+from DragMusic.misc import db
+from DragMusic.utils.database import get_loop
+from DragMusic.utils.decorators import AdminRightsCheck
+from DragMusic.utils.inline import close_markup, stream_markup
+from DragMusic.utils.stream.autoclear import auto_clean
+from DragMusic.utils.thumbnails import get_thumb
+from config import BANNED_USERS
+
+
+@app.on_message(
+    filters.command(["skip", "cskip", "next", "cnext"]) & filters.group & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def skip(cli, message: Message, _, chat_id):
+    if not len(message.command) < 2:
+        loop = await get_loop(chat_id)
+        if loop != 0:
+            return await message.reply_text(_["admin_8"])
+        state = message.text.split(None, 1)[1].strip()
+        if state.isnumeric():
+            state = int(state)
+            check = db.get(chat_id)
+            if check:
+                count = len(check)
+                if count > 2:
+                    count = int(count - 1)
+                    if 1 <= state <= count:
+                        for x in range(state):
+                            popped = None
+                            try:
+                                popped = check.pop(0)
+                            except:
+                                return await message.reply_text(_["admin_12"])
+                            if popped:
+                                await auto_clean(popped)
+                            if not check:
+                                try:
+                                    await message.reply_text(
+                                        text=_["admin_6"].format(
+                                            message.from_user.mention,
+                                            message.chat.title,
+                                        ),
+                                        reply_markup=close_markup(_),
+                                    )
+                                    await Drag.stop_stream(chat_id)
+                                except:
+                                    return
+                                break
+                    else:
+                        return await message.reply_text(_["admin_11"].format(count))
+                else:
+                    return await message.reply_text(_["admin_10"])
+            else:
+                return await message.reply_text(_["queue_2"])
+        else:
+            return await message.reply_text(_["admin_9"])
+    else:
+        check = db.get(chat_id)
+        popped = None
+        try:
+            popped = check.pop(0)
+            if popped:
+                await auto_clean(popped)
+            if not check:
+                await message.reply_text(
+                    text=_["admin_6"].format(
+                        message.from_user.mention, message.chat.title
+                    ),
+                    reply_markup=close_markup(_),
+                )
+                try:
+                    return await Drag.stop_stream(chat_id)
+                except:
+                    return
+        except:
+            try:
+                await message.reply_text(
+                    text=_["admin_6"].format(
+                        message.from_user.mention, message.chat.title
+                    ),
+                    reply_markup=close_markup(_),
+                )
+                return await Drag.stop_stream(chat_id)
+            except:
+                return
+    queued = check[0]["file"]
+    title = (check[0]["title"]).title()
+    user = check[0]["by"]
+    streamtype = check[0]["streamtype"]
+    videoid = check[0]["vidid"]
+    status = True if str(streamtype) == "video" else None
+    db[chat_id][0]["played"] = 0
+    exis = (check[0]).get("old_dur")
+    if exis:
+        db[chat_id][0]["dur"] = exis
+        db[chat_id][0]["seconds"] = check[0]["old_second"]
+        db[chat_id][0]["speed_path"] = None
+        db[chat_id][0]["speed"] = 1.0
+    if "live_" in queued:
+        n, link = await YouTube.video(videoid, True)
+        if n == 0:
+            return await message.reply_text(_["admin_7"].format(title))
+        try:
+            image = await YouTube.thumbnail(videoid, True)
+        except:
+            image = None
+        try:
+            await Drag.skip_stream(chat_id, link, video=status, image=image)
+        except:
+            return await message.reply_text(_["call_6"])
+        button = stream_markup(_, chat_id)
+        img = await get_thumb(videoid)
+        run = await message.reply_photo(
+            photo=img,
+            caption=_["stream_1"].format(
+                f"https://t.me/{app.username}?start=info_{videoid}",
+                title[:23],
+                check[0]["dur"],
+                user,
+            ),
+            reply_markup=InlineKeyboardMarkup(button),
+        )
+        db[chat_id][0]["mystic"] = run
+        db[chat_id][0]["markup"] = "tg"
+    elif "vid_" in queued:
+        mystic = await message.reply_text(_["call_7"], disable_web_page_preview=True)
+        try:
+            file_path, direct = await YouTube.download(
+                videoid,
+                mystic,
+                videoid=True,
+                video=status,
+            )
+        except:
+            return await mystic.edit_text(_["call_6"])
+        try:
+            image = await YouTube.thumbnail(videoid, True)
+        except:
+            image = None
+        try:
+            await Drag.skip_stream(chat_id, file_path, video=status, image=image)
+        except:
+            return await mystic.edit_text(_["call_6"])
+        button = stream_markup(_, chat_id)
+        img = await get_thumb(videoid)
+        run = await message.reply_photo(
+            photo=img,
+            caption=_["stream_1"].format(
+                f"https://t.me/{app.username}?start=info_{videoid}",
+                title[:23],
+                check[0]["dur"],
+                user,
+            ),
+            reply_markup=InlineKeyboardMarkup(button),
+        )
+        db[chat_id][0]["mystic"] = run
+        db[chat_id][0]["markup"] = "stream"
+        await mystic.delete()
+    elif "index_" in queued:
+        try:
+            await Drag.skip_stream(chat_id, videoid, video=status)
+        except:
+            return await message.reply_text(_["call_6"])
+        button = stream_markup(_, chat_id)
+        run = await message.reply_photo(
+            photo=config.STREAM_IMG_URL,
+            caption=_["stream_2"].format(user),
+            reply_markup=InlineKeyboardMarkup(button),
+        )
+        db[chat_id][0]["mystic"] = run
+        db[chat_id][0]["markup"] = "tg"
+    else:
+        if videoid == "telegram":
+            image = None
+        elif videoid == "soundcloud":
+            image = None
+        else:
+            try:
+                image = await YouTube.thumbnail(videoid, True)
+            except:
+                image = None
+        try:
+            await Drag.skip_stream(chat_id, queued, video=status, image=image)
+        except:
+            return await message.reply_text(_["call_6"])
+        if videoid == "telegram":
+            button = stream_markup(_, chat_id)
+            run = await message.reply_photo(
+                photo=config.TELEGRAM_AUDIO_URL
+                if str(streamtype) == "audio"
+                else config.TELEGRAM_VIDEO_URL,
+                caption=_["stream_1"].format(
+                    config.SUPPORT_CHAT, title[:23], check[0]["dur"], user
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+        elif videoid == "soundcloud":
+            button = stream_markup(_, chat_id)
+            run = await message.reply_photo(
+                photo=config.SOUNCLOUD_IMG_URL
+                if str(streamtype) == "audio"
+                else config.TELEGRAM_VIDEO_URL,
+                caption=_["stream_1"].format(
+                    config.SUPPORT_CHAT, title[:23], check[0]["dur"], user
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+        else:
+            button = stream_markup(_, chat_id)
+            img = await get_thumb(videoid)
+            run = await message.reply_photo(
+                photo=img,
+                caption=_["stream_1"].format(
+                    f"https://t.me/{app.username}?start=info_{videoid}",
+                    title[:23],
+                    check[0]["dur"],
+                    user,
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "stream"

DragMusic/plugins/admins/speed.py

@@ -0,0 +1,112 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import app
+from DragMusic.core.call import Drag
+from DragMusic.misc import SUDOERS, db
+from DragMusic.utils import AdminRightsCheck
+from DragMusic.utils.database import is_active_chat, is_nonadmin_chat
+from DragMusic.utils.decorators.language import languageCB
+from DragMusic.utils.inline import close_markup, speed_markup
+from config import BANNED_USERS, adminlist
+
+checker = []
+
+
+@app.on_message(
+    filters.command(["cspeed", "speed", "cslow", "slow", "playback", "cplayback"])
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def playback(cli, message: Message, _, chat_id):
+    playing = db.get(chat_id)
+    if not playing:
+        return await message.reply_text(_["queue_2"])
+    duration_seconds = int(playing[0]["seconds"])
+    if duration_seconds == 0:
+        return await message.reply_text(_["admin_27"])
+    file_path = playing[0]["file"]
+    if "downloads" not in file_path:
+        return await message.reply_text(_["admin_27"])
+    upl = speed_markup(_, chat_id)
+    return await message.reply_text(
+        text=_["admin_28"].format(app.mention),
+        reply_markup=upl,
+    )
+
+
+@app.on_callback_query(filters.regex("SpeedUP") & ~BANNED_USERS)
+@languageCB
+async def del_back_playlist(client, CallbackQuery, _):
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    chat, speed = callback_request.split("|")
+    chat_id = int(chat)
+    if not await is_active_chat(chat_id):
+        return await CallbackQuery.answer(_["general_5"], show_alert=True)
+    is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+    if not is_non_admin:
+        if CallbackQuery.from_user.id not in SUDOERS:
+            admins = adminlist.get(CallbackQuery.message.chat.id)
+            if not admins:
+                return await CallbackQuery.answer(_["admin_13"], show_alert=True)
+            else:
+                if CallbackQuery.from_user.id not in admins:
+                    return await CallbackQuery.answer(_["admin_14"], show_alert=True)
+    playing = db.get(chat_id)
+    if not playing:
+        return await CallbackQuery.answer(_["queue_2"], show_alert=True)
+    duration_seconds = int(playing[0]["seconds"])
+    if duration_seconds == 0:
+        return await CallbackQuery.answer(_["admin_27"], show_alert=True)
+    file_path = playing[0]["file"]
+    if "downloads" not in file_path:
+        return await CallbackQuery.answer(_["admin_27"], show_alert=True)
+    checkspeed = (playing[0]).get("speed")
+    if checkspeed:
+        if str(checkspeed) == str(speed):
+            if str(speed) == str("1.0"):
+                return await CallbackQuery.answer(
+                    _["admin_29"],
+                    show_alert=True,
+                )
+    else:
+        if str(speed) == str("1.0"):
+            return await CallbackQuery.answer(
+                _["admin_29"],
+                show_alert=True,
+            )
+    if chat_id in checker:
+        return await CallbackQuery.answer(
+            _["admin_30"],
+            show_alert=True,
+        )
+    else:
+        checker.append(chat_id)
+    try:
+        await CallbackQuery.answer(
+            _["admin_31"],
+        )
+    except:
+        pass
+    mystic = await CallbackQuery.edit_message_text(
+        text=_["admin_32"].format(CallbackQuery.from_user.mention),
+    )
+    try:
+        await Drag.speedup_stream(
+            chat_id,
+            file_path,
+            speed,
+            playing,
+        )
+    except:
+        if chat_id in checker:
+            checker.remove(chat_id)
+        return await mystic.edit_text(_["admin_33"], reply_markup=close_markup(_))
+    if chat_id in checker:
+        checker.remove(chat_id)
+    await mystic.edit_text(
+        text=_["admin_34"].format(speed, CallbackQuery.from_user.mention),
+        reply_markup=close_markup(_),
+    )

DragMusic/plugins/admins/stop.py

@@ -0,0 +1,23 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from DragMusic import app
+from DragMusic.core.call import Drag
+from DragMusic.utils.database import set_loop
+from DragMusic.utils.decorators import AdminRightsCheck
+from DragMusic.utils.inline import close_markup
+from config import BANNED_USERS
+
+
+@app.on_message(
+    filters.command(["end", "stop", "cend", "cstop"]) & filters.group & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def stop_music(cli, message: Message, _, chat_id):
+    if not len(message.command) == 1:
+        return
+    await Drag.stop_stream(chat_id)
+    await set_loop(chat_id, 0)
+    await message.reply_text(
+        _["admin_5"].format(message.from_user.mention), reply_markup=close_markup(_)
+    )

DragMusic/plugins/admins/tagall.py

@@ -0,0 +1,290 @@
+from DragMusic import app 
+import asyncio
+import random
+from pyrogram import Client, filters
+from pyrogram.enums import ChatType, ChatMemberStatus
+from pyrogram.errors import UserNotParticipant
+from pyrogram.types import ChatPermissions
+
+spam_chats = []
+
+EMOJI = [ "🦋🦋🦋🦋🦋",
+          "🧚🌸🧋🍬🫖",
+          "🥀🌷🌹🌺💐",
+          "🌸🌿💮🌱🌵",
+          "❤️💚💙💜🖤",
+          "💓💕💞💗💖",
+          "🌸💐🌺🌹🦋",
+          "🍔🦪🍛🍲🥗",
+          "🍎🍓🍒🍑🌶️",
+          "🧋🥤🧋🥛🍷",
+          "🍬🍭🧁🎂🍡",
+          "🍨🧉🍺☕🍻",
+          "🥪🥧🍦🍥🍚",
+          "🫖☕🍹🍷🥛",
+          "☕🧃🍩🍦🍙",
+          "🍁🌾💮🍂🌿",
+          "🌨️🌥️⛈️🌩️🌧️",
+          "🌷🏵️🌸🌺💐",
+          "💮🌼🌻🍀🍁",
+          "🧟🦸🦹🧙👸",
+          "🧅🍠🥕🌽🥦",
+          "🐷🐹🐭🐨🐻‍❄️",
+          "🦋🐇🐀🐈🐈‍⬛",
+          "🌼🌳🌲🌴🌵",
+          "🥩🍋🍐🍈🍇",
+          "🍴🍽️🔪🍶🥃",
+          "🕌🏰🏩⛩️🏩",
+          "🎉🎊🎈🎂🎀",
+          "🪴🌵🌴🌳🌲",
+          "🎄🎋🎍🎑🎎",
+          "🦅🦜🕊️🦤🦢",
+          "🦤🦩🦚🦃🦆",
+          "🐬🦭🦈🐋🐳",
+          "🐔🐟🐠🐡🦐",
+          "🦩🦀🦑🐙🦪",
+          "🐦🦂🕷️🕸️🐚",
+          "🥪🍰🥧🍨🍨",
+          " 🥬🍉🧁🧇",
+        ]
+
+TAGMES = [ " **➠ ʜᴇʏ ʙᴀʙʏ ᴋᴀʜᴀ ʜᴏ 🤗** ",
+           " **➠ ᴏʏᴇ sᴏ ɢʏᴇ ᴋʏᴀ ᴏɴʟɪɴᴇ ᴀᴀᴏ 😊** ",
+           " **➠ ᴠᴄ ᴄʜᴀʟᴏ ʙᴀᴛᴇɴ ᴋᴀʀᴛᴇ ʜᴀɪɴ ᴋᴜᴄʜ ᴋᴜᴄʜ 😃** ",
+           " **➠ ᴋʜᴀɴᴀ ᴋʜᴀ ʟɪʏᴇ ᴊɪ..?? 🥲** ",
+           " **➠ ɢʜᴀʀ ᴍᴇ sᴀʙ ᴋᴀɪsᴇ ʜᴀɪɴ ᴊɪ 🥺** ",
+           " **➠ ᴘᴛᴀ ʜᴀɪ ʙᴏʜᴏᴛ ᴍɪss ᴋᴀʀ ʀʜɪ ᴛʜɪ ᴀᴀᴘᴋᴏ 🤭** ",
+           " **➠ ᴏʏᴇ ʜᴀʟ ᴄʜᴀʟ ᴋᴇsᴀ ʜᴀɪ..?? 🤨** ",
+           " **➠ ᴍᴇʀɪ ʙʜɪ sᴇᴛᴛɪɴɢ ᴋᴀʀʙᴀ ᴅᴏɢᴇ..?? 🙂** ",
+           " **➠ ᴀᴀᴘᴋᴀ ɴᴀᴍᴇ ᴋʏᴀ ʜᴀɪ..?? 🥲** ",
+           " **➠ ɴᴀsᴛᴀ ʜᴜᴀ ᴀᴀᴘᴋᴀ..?? 😋** ",
+           " **➠ ᴍᴇʀᴇ ᴋᴏ ᴀᴘɴᴇ ɢʀᴏᴜᴘ ᴍᴇ ᴋɪᴅɴᴀᴘ ᴋʀ ʟᴏ 😍** ",
+           " **➠ ᴀᴀᴘᴋɪ ᴘᴀʀᴛɴᴇʀ ᴀᴀᴘᴋᴏ ᴅʜᴜɴᴅ ʀʜᴇ ʜᴀɪɴ ᴊʟᴅɪ ᴏɴʟɪɴᴇ ᴀʏɪᴀᴇ 😅** ",
+           " **➠ ᴍᴇʀᴇ sᴇ ᴅᴏsᴛɪ ᴋʀᴏɢᴇ..?? 🤔** ",
+           " **➠ sᴏɴᴇ ᴄʜᴀʟ ɢʏᴇ ᴋʏᴀ 🙄** ",
+           " **➠ ᴇᴋ sᴏɴɢ ᴘʟᴀʏ ᴋʀᴏ ɴᴀ ᴘʟss 😕** ",
+           " **➠ ᴀᴀᴘ ᴋᴀʜᴀ sᴇ ʜᴏ..?? 🙃** ",
+           " **➠ ʜᴇʟʟᴏ ᴊɪ ɴᴀᴍᴀsᴛᴇ 😛** ",
+           " **➠ ʜᴇʟʟᴏ ʙᴀʙʏ ᴋᴋʀʜ..? 🤔** ",
+           " **➠ ᴅᴏ ʏᴏᴜ ᴋɴᴏᴡ ᴡʜᴏ ɪs ᴍʏ ᴏᴡɴᴇʀ.? ☺️** ",
+           " **➠ ᴄʜʟᴏ ᴋᴜᴄʜ ɢᴀᴍᴇ ᴋʜᴇʟᴛᴇ ʜᴀɪɴ.🤗** ",
+           " **➠ ᴀᴜʀ ʙᴀᴛᴀᴏ ᴋᴀɪsᴇ ʜᴏ ʙᴀʙʏ 😇** ",
+           " **➠ ᴛᴜᴍʜᴀʀɪ ᴍᴜᴍᴍʏ ᴋʏᴀ ᴋᴀʀ ʀᴀʜɪ ʜᴀɪ 🤭** ",
+           " **➠ ᴍᴇʀᴇ sᴇ ʙᴀᴛ ɴᴏɪ ᴋʀᴏɢᴇ 🥺** ",
+           " **➠ ᴏʏᴇ ᴘᴀɢᴀʟ ᴏɴʟɪɴᴇ ᴀᴀ ᴊᴀ 😶** ",
+           " **➠ ᴀᴀᴊ ʜᴏʟɪᴅᴀʏ ʜᴀɪ ᴋʏᴀ sᴄʜᴏᴏʟ ᴍᴇ..?? 🤔** ",
+           " **➠ ᴏʏᴇ ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ 😜** ",
+           " **➠ sᴜɴᴏ ᴇᴋ ᴋᴀᴍ ʜᴀɪ ᴛᴜᴍsᴇ 🙂** ",
+           " **➠ ᴋᴏɪ sᴏɴɢ ᴘʟᴀʏ ᴋʀᴏ ɴᴀ 😪** ",
+           " **➠ ɴɪᴄᴇ ᴛᴏ ᴍᴇᴇᴛ ᴜʜ ☺** ",
+           " **➠ ᴍᴇʀᴀ ʙᴀʙᴜ ɴᴇ ᴛʜᴀɴᴀ ᴋʜᴀʏᴀ ᴋʏᴀ..? 🙊** ",
+           " **➠ sᴛᴜᴅʏ ᴄᴏᴍᴘʟᴇᴛᴇ ʜᴜᴀ?? 😺** ",
+           " **➠ ʙᴏʟᴏ ɴᴀ ᴋᴜᴄʜ ʏʀʀ 🥲** ",
+           " **➠ sᴏɴᴀʟɪ ᴋᴏɴ ʜᴀɪ...?? 😅** ",
+           " **➠ ᴛᴜᴍʜᴀʀɪ ᴇᴋ ᴘɪᴄ ᴍɪʟᴇɢɪ..? 😅** ",
+           " **➠ ᴍᴜᴍᴍʏ ᴀᴀ ɢʏɪ ᴋʏᴀ 😆** ",
+           " **➠ ᴏʀ ʙᴀᴛᴀᴏ ʙʜᴀʙʜɪ ᴋᴀɪsɪ ʜᴀɪ 😉** ",
+           " **➠ ɪ ʟᴏᴠᴇ ʏᴏᴜ 💚** ",
+           " **➠ ᴅᴏ ʏᴏᴜ ʟᴏᴠᴇ ᴍᴇ..? 👀** ",
+           " **➠ ʀᴀᴋʜɪ ᴋᴀʙ ʙᴀɴᴅ ʀᴀʜɪ ʜᴏ..?? 🙉** ",
+           " **➠ ᴇᴋ sᴏɴɢ sᴜɴᴀᴜ..? 😹** ",
+           " **➠ ᴏɴʟɪɴᴇ ᴀᴀ ᴊᴀ ʀᴇ sᴏɴɢ sᴜɴᴀ ʀᴀʜɪ ʜᴜ 😻** ",
+           " **➠ ɪɴsᴛᴀɢʀᴀᴍ ᴄʜᴀʟᴀᴛᴇ ʜᴏ..?? 🙃** ",
+           " **➠ ᴡʜᴀᴛsᴀᴘᴘ ɴᴜᴍʙᴇʀ ᴅᴏɢᴇ ᴀᴘɴᴀ ᴛᴜᴍ..? 😕** ",
+           " **➠ ᴛᴜᴍʜᴇ ᴋᴏɴ sᴀ ᴍᴜsɪᴄ sᴜɴɴᴀ ᴘᴀsᴀɴᴅ ʜᴀɪ..? 🙃** ",
+           " **➠ sᴀʀᴀ ᴋᴀᴍ ᴋʜᴀᴛᴀᴍ ʜᴏ ɢʏᴀ ᴀᴀᴘᴋᴀ..? 🙃** ",
+           " **➠ ᴋᴀʜᴀ sᴇ ʜᴏ ᴀᴀᴘ 😊** ",
+           " **➠ sᴜɴᴏ ɴᴀ 🧐** ",
+           " **➠ ᴍᴇʀᴀ ᴇᴋ ᴋᴀᴀᴍ ᴋᴀʀ ᴅᴏɢᴇ..? ♥️** ",
+           " **➠ ʙʏ ᴛᴀᴛᴀ ᴍᴀᴛ ʙᴀᴀᴛ ᴋᴀʀɴᴀ ᴀᴀᴊ ᴋᴇ ʙᴀᴅ 😠** ",
+           " **➠ ᴍᴏᴍ ᴅᴀᴅ ᴋᴀɪsᴇ ʜᴀɪɴ..? ❤** ",
+           " **➠ ᴋʏᴀ ʜᴜᴀ..? 🤔** ",
+           " **➠ ʙᴏʜᴏᴛ ʏᴀᴀᴅ ᴀᴀ ʀʜɪ ʜᴀɪ 😒** ",
+           " **➠ ʙʜᴜʟ ɢʏᴇ ᴍᴜᴊʜᴇ 😏** ",
+           " **➠ ᴊᴜᴛʜ ɴʜɪ ʙᴏʟɴᴀ ᴄʜᴀʜɪʏᴇ 🤐** ",
+           " **➠ ᴋʜᴀ ʟᴏ ʙʜᴀᴡ ᴍᴀᴛ ᴋʀᴏ ʙᴀᴀᴛ 😒** ",
+           " **➠ ᴋʏᴀ ʜᴜᴀ 😮** "
+           " **➠ ʜɪɪ ʜᴏɪ ʜᴇʟʟᴏ 👀** ",
+           " **➠ ᴀᴀᴘᴋᴇ ᴊᴀɪsᴀ ᴅᴏsᴛ ʜᴏ sᴀᴛʜ ᴍᴇ ғɪʀ ɢᴜᴍ ᴋɪs ʙᴀᴀᴛ ᴋᴀ 🙈** ",
+           " **➠ ᴀᴀᴊ ᴍᴇ sᴀᴅ ʜᴏᴏɴ ☹️** ",
+           " **➠ ᴍᴜsᴊʜsᴇ ʙʜɪ ʙᴀᴀᴛ ᴋᴀʀ ʟᴏ ɴᴀ 🥺** ",
+           " **➠ ᴋʏᴀ ᴋᴀʀ ʀᴀʜᴇ ʜᴏ 👀** ",
+           " **➠ ᴋʏᴀ ʜᴀʟ ᴄʜᴀʟ ʜᴀɪ 🙂** ",
+           " **➠ ᴋᴀʜᴀ sᴇ ʜᴏ ᴀᴀᴘ..?🤔** ",
+           " **➠ ᴄʜᴀᴛᴛɪɴɢ ᴋᴀʀ ʟᴏ ɴᴀ..🥺** ",
+           " **➠ ᴍᴇ ᴍᴀsᴏᴏᴍ ʜᴜ ɴᴀ 🥺** ",
+           " **➠ ᴋᴀʟ ᴍᴀᴊᴀ ᴀʏᴀ ᴛʜᴀ ɴᴀ 😅** ",
+           " **➠ ɢʀᴏᴜᴘ ᴍᴇ ʙᴀᴀᴛ ᴋʏᴜ ɴᴀʜɪ ᴋᴀʀᴛᴇ ʜᴏ 😕** ",
+           " **➠ ᴀᴀᴘ ʀᴇʟᴀᴛɪᴏᴍsʜɪᴘ ᴍᴇ ʜᴏ..? 👀** ",
+           " **➠ ᴋɪᴛɴᴀ ᴄʜᴜᴘ ʀᴀʜᴛᴇ ʜᴏ ʏʀʀ 😼** ",
+           " **➠ ᴀᴀᴘᴋᴏ ɢᴀɴᴀ ɢᴀɴᴇ ᴀᴀᴛᴀ ʜᴀɪ..? 😸** ",
+           " **➠ ɢʜᴜᴍɴᴇ ᴄʜᴀʟᴏɢᴇ..?? 🙈** ",
+           " **➠ ᴋʜᴜs ʀᴀʜᴀ ᴋᴀʀᴏ 🤞** ",
+           " **➠ ʜᴀᴍ ᴅᴏsᴛ ʙᴀɴ sᴀᴋᴛᴇ ʜᴀɪ...? 🥰** ",
+           " **➠ ᴋᴜᴄʜ ʙᴏʟ ᴋʏᴜ ɴʜɪ ʀᴀʜᴇ ʜᴏ.. 🥺** ",
+           " **➠ ᴋᴜᴄʜ ᴍᴇᴍʙᴇʀs ᴀᴅᴅ ᴋᴀʀ ᴅᴏ 🥲** ",
+           " **➠ sɪɴɢʟᴇ ʜᴏ ʏᴀ ᴍɪɴɢʟᴇ 😉** ",
+           " **➠ ᴀᴀᴏ ᴘᴀʀᴛʏ ᴋᴀʀᴛᴇ ʜᴀɪɴ 🥳** ",
+           " **➠ ʙɪᴏ ᴍᴇ ʟɪɴᴋ ʜᴀɪ ᴊᴏɪɴ ᴋᴀʀ ʟᴏ 🧐** ",
+           " **➠ ᴍᴜᴊʜᴇ ʙʜᴜʟ ɢʏᴇ ᴋʏᴀ 🥺** ",
+           " **➠ ʏᴀʜᴀ ᴀᴀ ᴊᴀᴏ @THE_FRIENDZ ᴍᴀsᴛɪ ᴋᴀʀᴇɴɢᴇ 🤭** ",
+           " **➠ ᴛʀᴜᴛʜ ᴀɴᴅ ᴅᴀʀᴇ ᴋʜᴇʟᴏɢᴇ..? 😊** ",
+           " **➠ ᴀᴀᴊ ᴍᴜᴍᴍʏ ɴᴇ ᴅᴀᴛᴀ ʏʀʀ 🥺** ",
+           " **➠ ᴊᴏɪɴ ᴋᴀʀ ʟᴏ 🤗** ",
+           " **➠ ᴇᴋ ᴅɪʟ ʜᴀɪ ᴇᴋ ᴅɪʟ ʜɪ ᴛᴏ ʜᴀɪ 😗** ",
+           " **➠ ᴛᴜᴍʜᴀʀᴇ ᴅᴏsᴛ ᴋᴀʜᴀ ɢʏᴇv🥺** ",
+           " **➠ ᴍʏ ᴄᴜᴛᴇ ᴏᴡɴᴇʀ @RoY_EdiTX 🥰** ",
+           " **➠ ᴋᴀʜᴀ ᴋʜᴏʏᴇ ʜᴏ ᴊᴀᴀɴ 😜** ",
+           " **➠ ɢᴏᴏᴅ ɴɪɢʜᴛ ᴊɪ ʙʜᴜᴛ ʀᴀᴛ ʜᴏ ɢʏɪ 🥰** ",
+           ]
+
+VC_TAG = [ "**➠ ᴏʏᴇ ᴠᴄ ᴀᴀᴏ ɴᴀ ᴘʟs 😒**",
+         "**➠ ᴊᴏɪɴ ᴠᴄ ғᴀsᴛ ɪᴛs ɪᴍᴀᴘᴏʀᴛᴀɴᴛ 😐**",
+         "**➠ ʙᴀʙʏ ᴄᴏᴍᴇ ᴏɴ ᴠᴄ ғᴀsᴛ 🙄**",
+         "**➠ ᴄʜᴜᴘ ᴄʜᴀᴘ ᴠᴄ ᴘʀ ᴀᴀᴏ 🤫**",
+         "**➠ ᴍᴀɪɴ ᴠᴄ ᴍᴇ ᴛᴜᴍᴀʀᴀ ᴡᴀɪᴛ ᴋʀ ʀʜɪ 🥺**",
+         "**➠ ᴠᴄ ᴘᴀʀ ᴀᴀᴏ ʙᴀᴀᴛ ᴋʀᴛᴇ ʜᴀɪ ☺️**",
+         "**➠ ʙᴀʙᴜ ᴠᴄ ᴀᴀ ᴊᴀɪʏᴇ ᴇᴋ ʙᴀʀ 🤨**",
+         "**➠ ᴠᴄ ᴘᴀʀ ʏᴇ ʀᴜssɪᴀɴ ᴋʏᴀ ᴋᴀʀ ʀʜɪ ʜᴀɪ 😮‍💨**",
+         "**➠ ᴠᴄ ᴘᴀʀ ᴀᴀᴏ ᴠᴀʀɴᴀ ʙᴀɴ ʜᴏ ᴊᴀᴏɢᴇ 🤭**",
+         "**➠ sᴏʀʀʏ ʙᴀʙʏ ᴘʟs ᴠᴄ ᴀᴀ ᴊᴀᴏ ɴᴀ 😢**",
+         "**➠ ᴠᴄ ᴀᴀɴᴀ ᴇᴋ ᴄʜɪᴊ ᴅɪᴋʜᴀᴛɪ ʜᴜ 😮**",
+         "**➠ ᴠᴄ ᴍᴇ ᴄʜᴇᴄᴋ ᴋʀᴋᴇ ʙᴀᴛᴀɴᴀ ᴋᴏɴ sᴀ sᴏɴɢ ᴘʟᴀʏ ʜᴏ ʀʜᴀ ʜᴀɪ.. 💫**",
+         "**➠ ᴠᴄ ᴊᴏɪɴ ᴋʀɴᴇ ᴍᴇ ᴋʏᴀ ᴊᴀᴛᴀ ʜᴀɪ ᴛʜᴏʀᴀ ᴅᴇʀ ᴋᴀʀ ʟᴏ ɴᴀ 😇**",
+         "**➠ ᴊᴀɴᴇᴍᴀɴ ᴠᴄ ᴀᴀᴏ ɴᴀ ʟɪᴠᴇ sʜᴏᴡ ᴅɪᴋʜᴀᴛɪ ʜᴏᴏɴ.. 😵‍💫**",
+         "**➠ ᴏᴡɴᴇʀ ʙᴀʙᴜ ᴠᴄ ᴛᴀᴘᴋᴏ ɴᴀ... 😕**",
+         "**➠ ʜᴇʏ ᴄᴜᴛɪᴇ ᴠᴄ ᴀᴀɴᴀ ᴛᴏ ᴇᴋ ʙᴀᴀʀ... 🌟**",
+         "**➠ ᴠᴄ ᴘᴀʀ ᴀᴀ ʀʜᴇ ʜᴏ ʏᴀ ɴᴀ... ✨**",
+         "**➠ ᴠᴄ ᴘᴀʀ ᴀᴀ ᴊᴀ ᴠʀɴᴀ ɢʜᴀʀ sᴇ ᴜᴛʜᴡᴀ ᴅᴜɴɢɪ... 🌝**",
+         "**➠ ʙᴀʙʏ ᴠᴄ ᴘᴀʀ ᴋʙ ᴀᴀ ʀʜᴇ ʜᴏ. 💯**",
+        ]
+
+
+@app.on_message(filters.command(["tagall", "tagmember" ], prefixes=["/", "@", "#"]))
+async def mentionall(client, message):
+    chat_id = message.chat.id
+    if message.chat.type == ChatType.PRIVATE:
+        return await message.reply("๏ ᴛʜɪs ᴄᴏᴍᴍᴀɴᴅ ᴏɴʟʏ ғᴏʀ ɢʀᴏᴜᴘs.")
+
+    is_admin = False
+    try:
+        participant = await client.get_chat_member(chat_id, message.from_user.id)
+    except UserNotParticipant:
+        is_admin = False
+    else:
+        if participant.status in (
+            ChatMemberStatus.ADMINISTRATOR,
+            ChatMemberStatus.OWNER
+        ):
+            is_admin = True
+    if not is_admin:
+        return await message.reply("๏ ʏᴏᴜ ᴀʀᴇ ɴᴏᴛ ᴀᴅᴍɪɴ ʙᴀʙʏ, ᴏɴʟʏ ᴀᴅᴍɪɴs ᴄᴀɴ ᴛᴀɢ ᴍᴇᴍʙᴇʀs. ")
+
+    if message.reply_to_message and message.text:
+        return await message.reply("/tagall ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ᴛʏᴘᴇ ʟɪᴋᴇ ᴛʜɪs / ʀᴇᴘʟʏ ᴀɴʏ ᴍᴇssᴀɢᴇ ɴᴇxᴛ ᴛɪᴍᴇ ʙᴏᴛ ᴛᴀɢɢɪɴɢ...")
+    elif message.text:
+        mode = "text_on_cmd"
+        msg = message.text
+    elif message.reply_to_message:
+        mode = "text_on_reply"
+        msg = message.reply_to_message
+        if not msg:
+            return await message.reply("/tagall ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ᴛʏᴘᴇ ʟɪᴋᴇ ᴛʜɪs / ʀᴇᴘʟʏ ᴀɴʏ ᴍᴇssᴀɢᴇ ɴᴇxᴛ ᴛɪᴍᴇ ғᴏᴛ ᴛᴀɢɢɪɴɢ...")
+    else:
+        return await message.reply("/tagall ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ᴛʏᴘᴇ ʟɪᴋᴇ ᴛʜɪs / ʀᴇᴘʟʏ ᴀɴʏ ᴍᴇssᴀɢᴇ ɴᴇxᴛ ᴛɪᴍᴇ ʙᴏᴛ ᴛᴀɢɢɪɴɢ...")
+    if chat_id in spam_chats:
+        return await message.reply("๏ ᴘʟᴇᴀsᴇ ᴀᴛ ғɪʀsᴛ sᴛᴏᴘ ʀᴜɴɴɪɴɢ ᴍᴇɴᴛɪᴏɴ ᴘʀᴏᴄᴇss...")
+    spam_chats.append(chat_id)
+    usrnum = 0
+    usrtxt = ""
+    async for usr in client.get_chat_members(chat_id):
+        if not chat_id in spam_chats:
+            break
+        if usr.user.is_bot:
+            continue
+        usrnum += 1
+        usrtxt += f"[{usr.user.first_name}](tg://user?id={usr.user.id}) "
+
+        if usrnum == 1:
+            if mode == "text_on_cmd":
+                txt = f"{usrtxt} {random.choice(TAGMES)}"
+                await client.send_message(chat_id, txt)
+            elif mode == "text_on_reply":
+                await msg.reply(f"[{random.choice(EMOJI)}](tg://user?id={usr.user.id})")
+            await asyncio.sleep(4)
+            usrnum = 0
+            usrtxt = ""
+    try:
+        spam_chats.remove(chat_id)
+    except:
+        pass
+
+
+@app.on_message(filters.command(["vctag"], prefixes=["/", "@", "#"]))
+async def mention_allvc(client, message):
+    chat_id = message.chat.id
+    if message.chat.type == ChatType.PRIVATE:
+        return await message.reply("๏ ᴛʜɪs ᴄᴏᴍᴍᴀɴᴅ ᴏɴʟʏ ғᴏʀ ɢʀᴏᴜᴘs.")
+
+    is_admin = False
+    try:
+        participant = await client.get_chat_member(chat_id, message.from_user.id)
+    except UserNotParticipant:
+        is_admin = False
+    else:
+        if participant.status in (
+            ChatMemberStatus.ADMINISTRATOR,
+            ChatMemberStatus.OWNER
+        ):
+            is_admin = True
+    if not is_admin:
+        return await message.reply("๏ ʏᴏᴜ ᴀʀᴇ ɴᴏᴛ ᴀᴅᴍɪɴ ʙᴀʙʏ, ᴏɴʟʏ ᴀᴅᴍɪɴs ᴄᴀɴ ᴛᴀɢ ᴍᴇᴍʙᴇʀs. ")
+    if chat_id in spam_chats:
+        return await message.reply("๏ ᴘʟᴇᴀsᴇ ᴀᴛ ғɪʀsᴛ sᴛᴏᴘ ʀᴜɴɴɪɴɢ ᴍᴇɴᴛɪᴏɴ ᴘʀᴏᴄᴇss...")
+    spam_chats.append(chat_id)
+    usrnum = 0
+    usrtxt = ""
+    async for usr in client.get_chat_members(chat_id):
+        if not chat_id in spam_chats:
+            break
+        if usr.user.is_bot:
+            continue
+        usrnum += 1
+        usrtxt += f"[{usr.user.first_name}](tg://user?id={usr.user.id}) "
+
+        if usrnum == 1:
+            txt = f"{usrtxt} {random.choice(VC_TAG)}"
+            await client.send_message(chat_id, txt)
+            await asyncio.sleep(4)
+            usrnum = 0
+            usrtxt = ""
+    try:
+        spam_chats.remove(chat_id)
+    except:
+        pass
+
+
+
+@app.on_message(filters.command(["cancel", "tagstop", "vcstop"]))
+async def cancel_spam(client, message):
+    if not message.chat.id in spam_chats:
+        return await message.reply("๏ ᴄᴜʀʀᴇɴᴛʟʏ ɪ'ᴍ ɴᴏᴛ ᴛᴀɢɢɪɴɢ ʙᴀʙʏ.")
+    is_admin = False
+    try:
+        participant = await client.get_chat_member(message.chat.id, message.from_user.id)
+    except UserNotParticipant:
+        is_admin = False
+    else:
+        if participant.status in (
+            ChatMemberStatus.ADMINISTRATOR,
+            ChatMemberStatus.OWNER
+        ):
+            is_admin = True
+    if not is_admin:
+        return await message.reply("๏ ʏᴏᴜ ᴀʀᴇ ɴᴏᴛ ᴀᴅᴍɪɴ ʙᴀʙʏ, ᴏɴʟʏ ᴀᴅᴍɪɴs ᴄᴀɴ ᴛᴀɢ ᴍᴇᴍʙᴇʀs.")
+    else:
+        try:
+            spam_chats.remove(message.chat.id)
+        except:
+            pass
+        return await message.reply("๏ ᴍᴇɴᴛɪᴏɴ ᴘʀᴏᴄᴇss sᴛᴏᴘᴘᴇᴅ ๏")

DragMusic/plugins/admins/zombies.py

@@ -0,0 +1,184 @@
+import os
+import asyncio
+from pyrogram import Client, filters
+from pyrogram.types import Message
+from pyrogram import enums
+from pyrogram.enums import ChatMemberStatus
+from pyrogram.errors import FloodWait
+from DragMusic import app
+from time import time
+import asyncio
+from DragMusic.utils.extraction import extract_user
+
+# Define a dictionary to track the last message timestamp for each user
+user_last_message_time = {}
+user_command_count = {}
+# Define the threshold for command spamming (e.g., 20 commands within 60 seconds)
+SPAM_THRESHOLD = 2
+SPAM_WINDOW_SECONDS = 5
+
+# ------------------------------------------------------------------------------- #
+
+chatQueue = []
+
+stopProcess = False
+
+# ------------------------------------------------------------------------------- #
+
+
+@app.on_message(filters.command(["zombies", "Deletedaccounts"]))
+async def remove(client, message):
+
+    global stopProcess
+    try:
+        try:
+            sender = await app.get_chat_member(message.chat.id, message.from_user.id)
+            has_permissions = sender.privileges
+        except:
+            has_permissions = message.sender_chat
+        if has_permissions:
+            bot = await app.get_chat_member(message.chat.id, "self")
+            if bot.status == ChatMemberStatus.MEMBER:
+                await message.reply(
+                    "➠ | ɪ ɴᴇᴇᴅ ᴀᴅᴍɪɴ ᴘᴇʀᴍɪssɪᴏɴs ᴛᴏ ʀᴇᴍᴏᴠᴇ ᴅᴇʟᴇᴛᴇᴅ ᴀᴄᴄᴏᴜɴᴛs."
+                )
+            else:
+                if len(chatQueue) > 30:
+                    await message.reply(
+                        "➠ | ɪ'ᴍ ᴀʟʀᴇᴀᴅʏ ᴡᴏʀᴋɪɴɢ ᴏɴ ᴍʏ ᴍᴀxɪᴍᴜᴍ ɴᴜᴍʙᴇʀ ᴏғ 30 ᴄʜᴀᴛs ᴀᴛ ᴛʜᴇ ᴍᴏᴍᴇɴᴛ. ᴘʟᴇᴀsᴇ ᴛʀʏ ᴀɢᴀɪɴ sʜᴏʀᴛʟʏ."
+                    )
+                else:
+                    if message.chat.id in chatQueue:
+                        await message.reply(
+                            "➠ | ᴛʜᴇʀᴇ's ᴀʟʀᴇᴀᴅʏ ᴀɴ ᴏɴɢɪɪɴɢ ᴘʀᴏᴄᴇss ɪɴ ᴛʜɪs ᴄʜᴀᴛ. ᴘʟᴇᴀsᴇ [ /stop ] ᴛᴏ sᴛᴀʀᴛ ᴀ ɴᴇᴡ ᴏɴᴇ."
+                        )
+                    else:
+                        chatQueue.append(message.chat.id)
+                        deletedList = []
+                        async for member in app.get_chat_members(message.chat.id):
+                            if member.user.is_deleted == True:
+                                deletedList.append(member.user)
+                            else:
+                                pass
+                        lenDeletedList = len(deletedList)
+                        if lenDeletedList == 0:
+                            await message.reply("⟳ | ɴᴏ ᴅᴇʟᴇᴛᴇᴅ ᴀᴄᴄᴏᴜɴᴛs ɪɴ ᴛʜɪs ᴄʜᴀᴛ.")
+                            chatQueue.remove(message.chat.id)
+                        else:
+                            k = 0
+                            processTime = lenDeletedList * 1
+                            temp = await app.send_message(
+                                message.chat.id,
+                                f"🧭 | ᴛᴏᴛᴀʟ ᴏғ {lenDeletedList} ᴅᴇʟᴇᴛᴇᴅ ᴀᴄᴄᴏᴜɴᴛs ʜᴀs ʙᴇᴇɴ ᴅᴇᴛᴇᴄᴛᴇᴅ.\n🥀 | ᴇsᴛɪᴍᴀᴛᴇᴅ ᴛɪᴍᴇ: {processTime} sᴇᴄᴏɴᴅs ғʀᴏᴍ ɴᴏᴡ.",
+                            )
+                            if stopProcess:
+                                stopProcess = False
+                            while len(deletedList) > 0 and not stopProcess:
+                                deletedAccount = deletedList.pop(0)
+                                try:
+                                    await app.ban_chat_member(
+                                        message.chat.id, deletedAccount.id
+                                    )
+                                except Exception:
+                                    pass
+                                k += 1
+                                await asyncio.sleep(10)
+                            if k == lenDeletedList:
+                                await message.reply(
+                                    f"✅ | sᴜᴄᴄᴇssғᴜʟʟʏ ʀᴇᴍᴏᴠᴇᴅ ᴀʟʟ ᴅᴇʟᴇᴛᴇᴅ ᴀᴄᴄɪᴜɴᴛs ғʀᴏᴍ ᴛʜɪs ᴄʜᴀᴛ."
+                                )
+                                await temp.delete()
+                            else:
+                                await message.reply(
+                                    f"✅ | sᴜᴄᴄᴇssғᴜʟʟʏ ʀᴇᴍᴏᴠᴇᴅ {k} ᴅᴇʟᴇᴛᴇᴅ ᴀᴄᴄᴏᴜɴᴛs ғʀᴏᴍ ᴛʜɪs ᴄʜᴀᴛ."
+                                )
+                                await temp.delete()
+                            chatQueue.remove(message.chat.id)
+        else:
+            await message.reply(
+                "👮🏻 | sᴏʀʀʏ, ᴏɴʟʏ ᴀᴅᴍɪɴ ᴄᴀɴ ᴇxᴇᴄᴜᴛᴇ ᴛʜɪs ᴄᴏᴍᴍᴀɴᴅ."
+            )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+
+
+# ------------------------------------------------------------------------------- #
+
+
+@app.on_message(filters.command(["admins", "staff"]))
+async def admins(client, message):
+
+    try:
+        adminList = []
+        ownerList = []
+        async for admin in app.get_chat_members(
+            message.chat.id, filter=enums.ChatMembersFilter.ADMINISTRATORS
+        ):
+            if admin.privileges.is_Dragmous == False:
+                if admin.user.is_bot == True:
+                    pass
+                elif admin.status == ChatMemberStatus.OWNER:
+                    ownerList.append(admin.user)
+                else:
+                    adminList.append(admin.user)
+            else:
+                pass
+        lenAdminList = len(ownerList) + len(adminList)
+        text2 = f"**ɢʀᴏᴜᴘ sᴛᴀғғ - {message.chat.title}**\n\n"
+        try:
+            owner = ownerList[0]
+            if owner.username == None:
+                text2 += f"👑 ᴏᴡɴᴇʀ\n└ {owner.mention}\n\n👮🏻 ᴀᴅᴍɪɴs\n"
+            else:
+                text2 += f"👑 ᴏᴡɴᴇʀ\n└ @{owner.username}\n\n👮🏻 ᴀᴅᴍɪɴs\n"
+        except:
+            text2 += f"👑 ᴏᴡɴᴇʀ\n└ <i>Hidden</i>\n\n👮🏻 ᴀᴅᴍɪɴs\n"
+        if len(adminList) == 0:
+            text2 += "└ <i>ᴀᴅᴍɪɴs ᴀʀᴇ ʜɪᴅᴅᴇɴ</i>"
+            await app.send_message(message.chat.id, text2)
+        else:
+            while len(adminList) > 1:
+                admin = adminList.pop(0)
+                if admin.username == None:
+                    text2 += f"├ {admin.mention}\n"
+                else:
+                    text2 += f"├ @{admin.username}\n"
+            else:
+                admin = adminList.pop(0)
+                if admin.username == None:
+                    text2 += f"└ {admin.mention}\n\n"
+                else:
+                    text2 += f"└ @{admin.username}\n\n"
+            text2 += f"✅ | ᴛᴏᴛᴀʟ ɴᴜᴍʙᴇʀ ᴏғ ᴀᴅᴍɪɴs: {lenAdminList}"
+            await app.send_message(message.chat.id, text2)
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+
+
+# ------------------------------------------------------------------------------- #
+
+
+@app.on_message(filters.command("bots"))
+async def bots(client, message):
+
+    try:
+        botList = []
+        async for bot in app.get_chat_members(
+            message.chat.id, filter=enums.ChatMembersFilter.BOTS
+        ):
+            botList.append(bot.user)
+        lenBotList = len(botList)
+        text3 = f"ʙᴏᴛ ʟɪsᴛ - {message.chat.title}\n\n🤖 ʙᴏᴛs\n"
+        while len(botList) > 1:
+            bot = botList.pop(0)
+            text3 += f"├ @{bot.username}\n"
+        else:
+            bot = botList.pop(0)
+            text3 += f" @{bot.username}\n\n"
+            text3 += f"✅ | ᴛᴏᴛᴀʟ ɴᴜᴍʙᴇʀ ᴏғ ʙᴏᴛs: {lenBotList}"
+            await app.send_message(message.chat.id, text3)
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+
+
+# ------------------------------------------------------------------------------- #

DragMusic/plugins/bot/approve.text

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,47 @@
+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/help.py

@@ -0,0 +1,90 @@
+from typing import Union
+
+from pyrogram import filters, types
+from pyrogram.types import InlineKeyboardMarkup, Message
+
+from DragMusic import app
+from DragMusic.utils import help_pannel
+from DragMusic.utils.database import get_lang
+from DragMusic.utils.decorators.language import LanguageStart, languageCB
+from DragMusic.utils.inline.help import help_back_markup, private_help_panel
+from config import BANNED_USERS, START_IMG_URL, SUPPORT_CHAT
+from strings import get_string, helpers
+
+
+@app.on_message(filters.command(["help"]) & filters.private & ~BANNED_USERS)
+@app.on_callback_query(filters.regex("settings_back_helper") & ~BANNED_USERS)
+async def helper_private(
+    client: app, update: Union[types.Message, types.CallbackQuery]
+):
+    is_callback = isinstance(update, types.CallbackQuery)
+    if is_callback:
+        try:
+            await update.answer()
+        except:
+            pass
+        chat_id = update.message.chat.id
+        language = await get_lang(chat_id)
+        _ = get_string(language)
+        keyboard = help_pannel(_, True)
+        await update.edit_message_text(
+            _["help_1"].format(SUPPORT_CHAT), reply_markup=keyboard
+        )
+    else:
+        try:
+            await update.delete()
+        except:
+            pass
+        language = await get_lang(update.chat.id)
+        _ = get_string(language)
+        keyboard = help_pannel(_)
+        await update.reply_photo(
+            photo=START_IMG_URL,
+            caption=_["help_1"].format(SUPPORT_CHAT),
+            reply_markup=keyboard,
+        )
+
+
+@app.on_message(filters.command(["help"]) & filters.group & ~BANNED_USERS)
+@LanguageStart
+async def help_com_group(client, message: Message, _):
+    keyboard = private_help_panel(_)
+    await message.reply_text(_["help_2"], reply_markup=InlineKeyboardMarkup(keyboard))
+
+
+@app.on_callback_query(filters.regex("help_callback") & ~BANNED_USERS)
+@languageCB
+async def helper_cb(client, CallbackQuery, _):
+    callback_data = CallbackQuery.data.strip()
+    cb = callback_data.split(None, 1)[1]
+    keyboard = help_back_markup(_)
+    if cb == "hb1":
+        await CallbackQuery.edit_message_text(helpers.HELP_1, reply_markup=keyboard)
+    elif cb == "hb2":
+        await CallbackQuery.edit_message_text(helpers.HELP_2, reply_markup=keyboard)
+    elif cb == "hb3":
+        await CallbackQuery.edit_message_text(helpers.HELP_3, reply_markup=keyboard)
+    elif cb == "hb4":
+        await CallbackQuery.edit_message_text(helpers.HELP_4, reply_markup=keyboard)
+    elif cb == "hb5":
+        await CallbackQuery.edit_message_text(helpers.HELP_5, reply_markup=keyboard)
+    elif cb == "hb6":
+        await CallbackQuery.edit_message_text(helpers.HELP_6, reply_markup=keyboard)
+    elif cb == "hb7":
+        await CallbackQuery.edit_message_text(helpers.HELP_7, reply_markup=keyboard)
+    elif cb == "hb8":
+        await CallbackQuery.edit_message_text(helpers.HELP_8, reply_markup=keyboard)
+    elif cb == "hb9":
+        await CallbackQuery.edit_message_text(helpers.HELP_9, reply_markup=keyboard)
+    elif cb == "hb10":
+        await CallbackQuery.edit_message_text(helpers.HELP_10, reply_markup=keyboard)
+    elif cb == "hb11":
+        await CallbackQuery.edit_message_text(helpers.HELP_11, reply_markup=keyboard)
+    elif cb == "hb12":
+        await CallbackQuery.edit_message_text(helpers.HELP_12, reply_markup=keyboard)
+    elif cb == "hb13":
+        await CallbackQuery.edit_message_text(helpers.HELP_13, reply_markup=keyboard)
+    elif cb == "hb14":
+        await CallbackQuery.edit_message_text(helpers.HELP_14, reply_markup=keyboard)
+    elif cb == "hb15":
+        await CallbackQuery.edit_message_text(helpers.HELP_15, reply_markup=keyboard)

DragMusic/plugins/bot/inline.py

@@ -0,0 +1,68 @@
+from pyrogram.types import (
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    InlineQueryResultPhoto,
+)
+from youtubesearchpython.__future__ import VideosSearch
+
+from DragMusic import app
+from DragMusic.utils.inlinequery import answer
+from config import BANNED_USERS
+
+
+@app.on_inline_query(~BANNED_USERS)
+async def inline_query_handler(client, query):
+    text = query.query.strip().lower()
+    answers = []
+    if text.strip() == "":
+        try:
+            await client.answer_inline_query(query.id, results=answer, cache_time=10)
+        except:
+            return
+    else:
+        a = VideosSearch(text, limit=20)
+        result = (await a.next()).get("result")
+        for x in range(15):
+            title = (result[x]["title"]).title()
+            duration = result[x]["duration"]
+            views = result[x]["viewCount"]["short"]
+            thumbnail = result[x]["thumbnails"][0]["url"].split("?")[0]
+            channellink = result[x]["channel"]["link"]
+            channel = result[x]["channel"]["name"]
+            link = result[x]["link"]
+            published = result[x]["publishedTime"]
+            description = f"{views} | {duration} ᴍɪɴᴜᴛᴇs | {channel}  | {published}"
+            buttons = InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            text="ʏᴏᴜᴛᴜʙᴇ 🎄",
+                            url=link,
+                        )
+                    ],
+                ]
+            )
+            searched_text = f"""
+❄ <b>ᴛɪᴛʟᴇ :</b> <a href={link}>{title}</a>
+
+⏳ <b>ᴅᴜʀᴀᴛɪᴏɴ :</b> {duration} ᴍɪɴᴜᴛᴇs
+👀 <b>ᴠɪᴇᴡs :</b> <code>{views}</code>
+🎥 <b>ᴄʜᴀɴɴᴇʟ :</b> <a href={channellink}>{channel}</a>
+⏰ <b>ᴘᴜʙʟɪsʜᴇᴅ ᴏɴ :</b> {published}
+
+
+<u><b>➻ ɪɴʟɪɴᴇ sᴇᴀʀᴄʜ ᴍᴏᴅᴇ ʙʏ {app.name}</b></u>"""
+            answers.append(
+                InlineQueryResultPhoto(
+                    photo_url=thumbnail,
+                    title=title,
+                    thumb_url=thumbnail,
+                    description=description,
+                    caption=searched_text,
+                    reply_markup=buttons,
+                )
+            )
+        try:
+            return await client.answer_inline_query(query.id, results=answers)
+        except:
+            return

DragMusic/plugins/bot/mustjoin.py

@@ -0,0 +1,61 @@
+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"
+#------------------------
+@app.on_message(filters.incoming & filters.private, group=-1)
+async def must_join_channel(app: Client, msg: Message):
+    if not MUST_JOIN:
+        return
+    try:
+        try:
+            await app.get_chat_member(MUST_JOIN, msg.from_user.id)
+        except UserNotParticipant:
+            if MUST_JOIN.isalpha():
+                link = "https://t.me/" + MUST_JOIN
+            else:
+                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 ",
+                    reply_markup=InlineKeyboardMarkup(
+                        [
+                            [
+                                InlineKeyboardButton("ᴜᴘᴅᴀᴛᴇ", url="https://t.me/haatsoja"),
+                                InlineKeyboardButton("sᴜᴘᴘᴏʀᴛ", url="https://t.me/dragbackup"),
+                            ]
+                        ]
+                    )
+                )
+                await msg.stop_propagation()
+            except ChatWriteForbidden:
+                pass
+    except ChatAdminRequired:
+        print(f"๏ ᴘʀᴏᴍᴏᴛᴇ ᴍᴇ ᴀs ᴀɴ ᴀᴅᴍɪɴ ɪɴ ᴛʜᴇ ᴍᴜsᴛ_ᴊᴏɪɴ ᴄʜᴀᴛ ๏: {MUST_JOIN} !")
+      

DragMusic/plugins/bot/settings.py

@@ -0,0 +1,391 @@
+from pyrogram import filters
+from pyrogram.enums import ChatType
+from pyrogram.errors import MessageNotModified
+from pyrogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+)
+
+from DragMusic import app
+from DragMusic.utils.database import (
+    add_nonadmin_chat,
+    get_authuser,
+    get_authuser_names,
+    get_playmode,
+    get_playtype,
+    get_upvote_count,
+    is_nonadmin_chat,
+    is_skipmode,
+    remove_nonadmin_chat,
+    set_playmode,
+    set_playtype,
+    set_upvotes,
+    skip_off,
+    skip_on,
+)
+from DragMusic.utils.decorators.admins import ActualAdminCB
+from DragMusic.utils.decorators.language import language, languageCB
+from DragMusic.utils.inline.settings import (
+    auth_users_markup,
+    playmode_users_markup,
+    setting_markup,
+    vote_mode_markup,
+)
+from DragMusic.utils.inline.start import private_panel
+from config import BANNED_USERS, OWNER_ID
+
+
+@app.on_message(
+    filters.command(["settings", "setting"]) & filters.group & ~BANNED_USERS
+)
+@language
+async def settings_mar(client, message: Message, _):
+    buttons = setting_markup(_)
+    await message.reply_text(
+        _["setting_1"].format(app.mention, message.chat.id, message.chat.title),
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+
+@app.on_callback_query(filters.regex("settings_helper") & ~BANNED_USERS)
+@languageCB
+async def settings_cb(client, CallbackQuery, _):
+    try:
+        await CallbackQuery.answer(_["set_cb_5"])
+    except:
+        pass
+    buttons = setting_markup(_)
+    return await CallbackQuery.edit_message_text(
+        _["setting_1"].format(
+            app.mention,
+            CallbackQuery.message.chat.id,
+            CallbackQuery.message.chat.title,
+        ),
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+
+@app.on_callback_query(filters.regex("settingsback_helper") & ~BANNED_USERS)
+@languageCB
+async def settings_back_markup(client, CallbackQuery: CallbackQuery, _):
+    try:
+        await CallbackQuery.answer()
+    except:
+        pass
+    if CallbackQuery.message.chat.type == ChatType.PRIVATE:
+        await app.resolve_peer(OWNER_ID)
+        OWNER = OWNER_ID
+        buttons = private_panel(_)
+        return await CallbackQuery.edit_message_text(
+            _["start_2"].format(CallbackQuery.from_user.mention, app.mention),
+            reply_markup=InlineKeyboardMarkup(buttons),
+        )
+    else:
+        buttons = setting_markup(_)
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+
+
+@app.on_callback_query(
+    filters.regex(
+        pattern=r"^(SEARCHANSWER|PLAYMODEANSWER|PLAYTYPEANSWER|AUTHANSWER|ANSWERVOMODE|VOTEANSWER|PM|AU|VM)$"
+    )
+    & ~BANNED_USERS
+)
+@languageCB
+async def without_Admin_rights(client, CallbackQuery, _):
+    command = CallbackQuery.matches[0].group(1)
+    if command == "SEARCHANSWER":
+        try:
+            return await CallbackQuery.answer(_["setting_2"], show_alert=True)
+        except:
+            return
+    if command == "PLAYMODEANSWER":
+        try:
+            return await CallbackQuery.answer(_["setting_5"], show_alert=True)
+        except:
+            return
+    if command == "PLAYTYPEANSWER":
+        try:
+            return await CallbackQuery.answer(_["setting_6"], show_alert=True)
+        except:
+            return
+    if command == "AUTHANSWER":
+        try:
+            return await CallbackQuery.answer(_["setting_3"], show_alert=True)
+        except:
+            return
+    if command == "VOTEANSWER":
+        try:
+            return await CallbackQuery.answer(
+                _["setting_8"],
+                show_alert=True,
+            )
+        except:
+            return
+    if command == "ANSWERVOMODE":
+        current = await get_upvote_count(CallbackQuery.message.chat.id)
+        try:
+            return await CallbackQuery.answer(
+                _["setting_9"].format(current),
+                show_alert=True,
+            )
+        except:
+            return
+    if command == "PM":
+        try:
+            await CallbackQuery.answer(_["set_cb_2"], show_alert=True)
+        except:
+            pass
+        playmode = await get_playmode(CallbackQuery.message.chat.id)
+        if playmode == "Direct":
+            Direct = True
+        else:
+            Direct = None
+        is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+        if not is_non_admin:
+            Group = True
+        else:
+            Group = None
+        playty = await get_playtype(CallbackQuery.message.chat.id)
+        if playty == "Everyone":
+            Playtype = None
+        else:
+            Playtype = True
+        buttons = playmode_users_markup(_, Direct, Group, Playtype)
+    if command == "AU":
+        try:
+            await CallbackQuery.answer(_["set_cb_1"], show_alert=True)
+        except:
+            pass
+        is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+        if not is_non_admin:
+            buttons = auth_users_markup(_, True)
+        else:
+            buttons = auth_users_markup(_)
+    if command == "VM":
+        mode = await is_skipmode(CallbackQuery.message.chat.id)
+        current = await get_upvote_count(CallbackQuery.message.chat.id)
+        buttons = vote_mode_markup(_, current, mode)
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return
+
+
+@app.on_callback_query(filters.regex("FERRARIUDTI") & ~BANNED_USERS)
+@ActualAdminCB
+async def addition(client, CallbackQuery, _):
+    callback_data = CallbackQuery.data.strip()
+    mode = callback_data.split(None, 1)[1]
+    if not await is_skipmode(CallbackQuery.message.chat.id):
+        return await CallbackQuery.answer(_["setting_10"], show_alert=True)
+    current = await get_upvote_count(CallbackQuery.message.chat.id)
+    if mode == "M":
+        final = current - 2
+        print(final)
+        if final == 0:
+            return await CallbackQuery.answer(
+                _["setting_11"],
+                show_alert=True,
+            )
+        if final <= 2:
+            final = 2
+        await set_upvotes(CallbackQuery.message.chat.id, final)
+    else:
+        final = current + 2
+        print(final)
+        if final == 17:
+            return await CallbackQuery.answer(
+                _["setting_12"],
+                show_alert=True,
+            )
+        if final >= 15:
+            final = 15
+        await set_upvotes(CallbackQuery.message.chat.id, final)
+    buttons = vote_mode_markup(_, final, True)
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return
+
+
+@app.on_callback_query(
+    filters.regex(pattern=r"^(MODECHANGE|CHANNELMODECHANGE|PLAYTYPECHANGE)$")
+    & ~BANNED_USERS
+)
+@ActualAdminCB
+async def playmode_ans(client, CallbackQuery, _):
+    command = CallbackQuery.matches[0].group(1)
+    if command == "CHANNELMODECHANGE":
+        is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+        if not is_non_admin:
+            await add_nonadmin_chat(CallbackQuery.message.chat.id)
+            Group = None
+        else:
+            await remove_nonadmin_chat(CallbackQuery.message.chat.id)
+            Group = True
+        playmode = await get_playmode(CallbackQuery.message.chat.id)
+        if playmode == "Direct":
+            Direct = True
+        else:
+            Direct = None
+        playty = await get_playtype(CallbackQuery.message.chat.id)
+        if playty == "Everyone":
+            Playtype = None
+        else:
+            Playtype = True
+        buttons = playmode_users_markup(_, Direct, Group, Playtype)
+    if command == "MODECHANGE":
+        try:
+            await CallbackQuery.answer(_["set_cb_3"], show_alert=True)
+        except:
+            pass
+        playmode = await get_playmode(CallbackQuery.message.chat.id)
+        if playmode == "Direct":
+            await set_playmode(CallbackQuery.message.chat.id, "Inline")
+            Direct = None
+        else:
+            await set_playmode(CallbackQuery.message.chat.id, "Direct")
+            Direct = True
+        is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+        if not is_non_admin:
+            Group = True
+        else:
+            Group = None
+        playty = await get_playtype(CallbackQuery.message.chat.id)
+        if playty == "Everyone":
+            Playtype = False
+        else:
+            Playtype = True
+        buttons = playmode_users_markup(_, Direct, Group, Playtype)
+    if command == "PLAYTYPECHANGE":
+        try:
+            await CallbackQuery.answer(_["set_cb_3"], show_alert=True)
+        except:
+            pass
+        playty = await get_playtype(CallbackQuery.message.chat.id)
+        if playty == "Everyone":
+            await set_playtype(CallbackQuery.message.chat.id, "Admin")
+            Playtype = False
+        else:
+            await set_playtype(CallbackQuery.message.chat.id, "Everyone")
+            Playtype = True
+        playmode = await get_playmode(CallbackQuery.message.chat.id)
+        if playmode == "Direct":
+            Direct = True
+        else:
+            Direct = None
+        is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+        if not is_non_admin:
+            Group = True
+        else:
+            Group = None
+        buttons = playmode_users_markup(_, Direct, Group, Playtype)
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return
+
+
+@app.on_callback_query(filters.regex(pattern=r"^(AUTH|AUTHLIST)$") & ~BANNED_USERS)
+@ActualAdminCB
+async def authusers_mar(client, CallbackQuery, _):
+    command = CallbackQuery.matches[0].group(1)
+    if command == "AUTHLIST":
+        _authusers = await get_authuser_names(CallbackQuery.message.chat.id)
+        if not _authusers:
+            try:
+                return await CallbackQuery.answer(_["setting_4"], show_alert=True)
+            except:
+                return
+        else:
+            try:
+                await CallbackQuery.answer(_["set_cb_4"], show_alert=True)
+            except:
+                pass
+            j = 0
+            await CallbackQuery.edit_message_text(_["auth_6"])
+            msg = _["auth_7"].format(CallbackQuery.message.chat.title)
+            for note in _authusers:
+                _note = await get_authuser(CallbackQuery.message.chat.id, note)
+                user_id = _note["auth_user_id"]
+                admin_id = _note["admin_id"]
+                admin_name = _note["admin_name"]
+                try:
+                    user = await app.get_users(user_id)
+                    user = user.first_name
+                    j += 1
+                except:
+                    continue
+                msg += f"{j}➤ {user}[<code>{user_id}</code>]\n"
+                msg += f"   {_['auth_8']} {admin_name}[<code>{admin_id}</code>]\n\n"
+            upl = InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            text=_["BACK_BUTTON"], callback_data=f"AU"
+                        ),
+                        InlineKeyboardButton(
+                            text=_["CLOSE_BUTTON"],
+                            callback_data=f"close",
+                        ),
+                    ]
+                ]
+            )
+            try:
+                return await CallbackQuery.edit_message_text(msg, reply_markup=upl)
+            except MessageNotModified:
+                return
+    try:
+        await CallbackQuery.answer(_["set_cb_3"], show_alert=True)
+    except:
+        pass
+    if command == "AUTH":
+        is_non_admin = await is_nonadmin_chat(CallbackQuery.message.chat.id)
+        if not is_non_admin:
+            await add_nonadmin_chat(CallbackQuery.message.chat.id)
+            buttons = auth_users_markup(_)
+        else:
+            await remove_nonadmin_chat(CallbackQuery.message.chat.id)
+            buttons = auth_users_markup(_, True)
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return
+
+
+@app.on_callback_query(filters.regex("VOMODECHANGE") & ~BANNED_USERS)
+@ActualAdminCB
+async def vote_change(client, CallbackQuery, _):
+    command = CallbackQuery.matches[0].group(1)
+    try:
+        await CallbackQuery.answer(_["set_cb_3"], show_alert=True)
+    except:
+        pass
+    mod = None
+    if await is_skipmode(CallbackQuery.message.chat.id):
+        await skip_off(CallbackQuery.message.chat.id)
+    else:
+        mod = True
+        await skip_on(CallbackQuery.message.chat.id)
+    current = await get_upvote_count(CallbackQuery.message.chat.id)
+    buttons = vote_mode_markup(_, current, mod)
+
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return

DragMusic/plugins/bot/start.py

@@ -0,0 +1,169 @@
+import time
+from pyrogram import filters
+from pyrogram.enums import ChatType
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
+from youtubesearchpython.__future__ import VideosSearch
+
+import config
+from DragMusic import app
+from DragMusic.misc import _boot_
+from DragMusic.plugins.sudo.sudoers import sudoers_list
+from DragMusic.utils.database import (
+    add_served_chat,
+    add_served_user,
+    blacklisted_chats,
+    get_lang,
+    is_banned_user,
+    is_on_off,
+)
+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
+
+@app.on_message(filters.command(["start"]) & filters.private & ~BANNED_USERS)
+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
+
+    if len(message.text.split()) > 1:
+        name = message.text.split(None, 1)[1]
+        if name[0:4] == "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),
+                reply_markup=keyboard,
+            )
+        elif name[0:3] == "sud":  # Example: Handling sudo
+            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
+                )
+            return
+        elif name[0:3] == "inf":  # Example: Handling info
+            m = await message.reply_text("🔎")
+            query = (str(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
+
+    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),
+            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
+            )
+
+@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
+
+    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)),
+        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)

DragMusic/plugins/goodnight.py

@@ -0,0 +1,42 @@
+import re
+from dotenv import load_dotenv
+from pyrogram import filters
+import random
+from pyrogram.types import Message
+from pyrogram import Client, filters
+from DragMusic import app
+
+
+
+# "/gn" command ka handler
+@app.on_message(filters.command("oodnight", prefixes="g"))
+def goodnight_command_handler(client: Client, message: Message):
+    # Randomly decide whether to send a sticker or an emoji
+    send_sticker = random.choice([True, False])
+    
+    # Send a sticker or an emoji based on the random choice
+    if send_sticker:
+        client.send_sticker(message.chat.id, get_random_sticker())
+    else:
+        client.send_message(message.chat.id, get_random_emoji())
+
+# Function to get a random sticker
+def get_random_sticker():
+    stickers = [
+        "CAACAgQAAx0Ce9_hCAACaEVlwn7HeZhgwyVfKHc3WUGC_447IAACLgwAAkQwKVPtub8VAR018x4E",
+        "CAACAgIAAx0Ce9_hCAACaEplwn7dvj7G0-a1v3wlbN281RMX2QACUgwAAligOUoi7DhLVTsNsh4E",
+        "CAACAgIAAx0Ce9_hCAACaFBlwn8AAZNB9mOUvz5oAyM7CT-5pjAAAtEKAALa7NhLvbTGyDLbe1IeBA",
+        "CAACAgUAAx0CcmOuMwACldVlwn9ZHHF2-S-CuMSYabwwtVGC3AACOAkAAoqR2VYDjyK6OOr_Px4E",
+        "CAACAgIAAx0Ce9_hCAACaFVlwn-fG58GKoEmmZpVovxEj4PodAACfwwAAqozQUrt2xSTf5Ac4h4E",
+    ]
+    return random.choice(stickers)
+
+# Function to get a random emoji
+def get_random_emoji():
+    emojis = [
+        "😴",
+        "😪", 
+        "💤",
+        
+    ]
+    return random.choice(emojis)

DragMusic/plugins/misc/autoleave.py

@@ -0,0 +1,74 @@
+import asyncio
+from datetime import datetime
+
+from pyrogram.enums import ChatType
+
+import config
+from DragMusic import app
+from DragMusic.core.call import Drag, autoend
+from DragMusic.utils.database import get_client, is_active_chat, is_autoend
+
+
+async def auto_leave():
+    if config.AUTO_LEAVING_ASSISTANT:
+        while not await asyncio.sleep(900):
+            from DragMusic.core.userbot import assistants
+
+            for num in assistants:
+                client = await get_client(num)
+                left = 0
+                try:
+                    async for i in client.get_dialogs():
+                        if i.chat.type in [
+                            ChatType.SUPERGROUP,
+                            ChatType.GROUP,
+                            ChatType.CHANNEL,
+                        ]:
+                            if (
+                                i.chat.id != config.LOGGER_ID
+                                and i.chat.id != -1001686672798
+                                and i.chat.id != -1001549206010
+                            ):
+                                if left == 20:
+                                    continue
+                                if not await is_active_chat(i.chat.id):
+                                    try:
+                                        await client.leave_chat(i.chat.id)
+                                        left += 1
+                                    except:
+                                        continue
+                except:
+                    pass
+
+
+asyncio.create_task(auto_leave())
+
+
+async def auto_end():
+    while not await asyncio.sleep(5):
+        ender = await is_autoend()
+        if not ender:
+            continue
+        for chat_id in autoend:
+            timer = autoend.get(chat_id)
+            if not timer:
+                continue
+            if datetime.now() > timer:
+                if not await is_active_chat(chat_id):
+                    autoend[chat_id] = {}
+                    continue
+                autoend[chat_id] = {}
+                try:
+                    await Drag.stop_stream(chat_id)
+                except:
+                    continue
+                try:
+                    await app.send_message(
+                        chat_id,
+                        "» ʙᴏᴛ ᴀᴜᴛᴏᴍᴀᴛɪᴄᴀʟʟʏ ʟᴇғᴛ ᴠɪᴅᴇᴏᴄʜᴀᴛ ʙᴇᴄᴀᴜsᴇ ɴᴏ ᴏɴᴇ ᴡᴀs ʟɪsᴛᴇɴɪɴɢ ᴏɴ ᴠɪᴅᴇᴏᴄʜᴀᴛ.",
+                    )
+                except:
+                    continue
+
+
+asyncio.create_task(auto_end())