SONALI

Dockerfiler

@@ -0,0 +1,18 @@
+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 pip redis fastapi nest-asyncio uvicorn && \
+    pip3 install --no-cache-dir -r requirements.txt
+RUN touch log.txt
+RUN chown -R 1000:0 /app /usr && \
+    chmod -R 755 /app /usr && \
+    chmod 777 /app/log.txt && \
+    chmod +x /app/start.sh
+
+CMD bash start.sh

Procfile

@@ -0,0 +1 @@
+worker: bash start.sh

SONALI/__init__.py

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

SONALI/__main__.py

@@ -0,0 +1,52 @@
+import asyncio
+import importlib
+
+from pyrogram import idle
+
+import config
+from SONALI import LOGGER, app, userbot
+from SONALI.core.call import RAUSHAN
+from SONALI.misc import sudo
+from SONALI.plugins import ALL_MODULES
+from SONALI.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(
+            "𝐒𝐭𝐫𝐢𝐧𝐠 𝐒𝐞𝐬𝐬𝐢𝐨𝐧 𝐍𝐨𝐭 𝐅𝐢𝐥𝐥𝐞𝐝, 𝐏𝐥𝐞𝐚𝐬𝐞 𝐅𝐢𝐥𝐥 𝐀 𝐏𝐲𝐫𝐨𝐠𝐫𝐚𝐦 V2 𝐒𝐞𝐬𝐬𝐢𝐨𝐧🤬"
+        )
+
+    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("SONALI.plugins" + all_module)
+    LOGGER("SONALI.plugins").info("𝐀𝐥𝐥 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬 𝐋𝐨𝐚𝐝𝐞𝐝 𝐁𝐚𝐛𝐲🥳...")
+    await userbot.start()
+    await RAUSHAN.start()
+    await RAUSHAN.decorators()
+    LOGGER("SONALI").info("╔═════ஜ۩۞۩ஜ════╗\n  ♨️𝗠𝗔𝗗𝗘 𝗕𝗬 𝗔𝗟𝗣𝗛𝗔♨️\n╚═════ஜ۩۞۩ஜ════╝")
+    await idle()
+    await app.stop()
+    await userbot.stop()
+    LOGGER("SONALI").info("╔═════ஜ۩۞۩ஜ════╗\n  ♨️𝗠𝗔𝗗𝗘 𝗕𝗬 𝗔𝗟𝗣𝗛𝗔♨️\n╚═════ஜ۩۞۩ஜ════╝")
+
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(init())

SONALI/assets/__init__.py

@@ -0,0 +1 @@
+

SONALI/assets/cookies.txt

@@ -0,0 +1,25 @@
+# Netscape HTTP Cookie File
+# This is a generated file! Do not edit.
+
+
+# domain  include_subdomains  path  secure  expiration_date  name  value
+.youtube.com	TRUE	/	TRUE	1755081301	__Secure-1PSIDCC	AKEyXzWnN2YQ0_PWGBmMjxqrsoaekT_2ni7t5Wq5Whr5OoQfo_SKV4q9sYQV4uhRAl_OXUUehg
+.youtube.com	TRUE	/	TRUE	1758105276	SAPISID	hFE5YhFmEMSZdF-y/AAhea3c1tEyJzs3Q8
+.youtube.com	TRUE	/	FALSE	1758105276	APISID	UvyoylXNGRrsaluK/ASLoQHn2GmFgpo7Go
+.youtube.com	TRUE	/	TRUE	1758105276	SSID	AoVOWI6B5FiL0ioXZ
+.youtube.com	TRUE	/	TRUE	1758105276	__Secure-3PAPISID	hFE5YhFmEMSZdF-y/AAhea3c1tEyJzs3Q8
+.youtube.com	TRUE	/	TRUE	1758105276	__Secure-1PSID	g.a000mwhDYyK9e4tYnSGx58xB6DUJNnNjjASDPnsmeOYQERKoOC8ivN5I65nvuxRnGEody5oQUgACgYKAakSAQASFQHGX2MiTogTyNlEPHaA71bxlO00mBoVAUF8yKqoAzCJR3St86ZEQp_cTUJn0076
+.youtube.com	TRUE	/	FALSE	1755081301	SIDCC	AKEyXzU-XdNCJObqVW-i9xoUiwL-ZdcibXsgxVnlmDzcBC7igAKmVHLnS1dAI4tNAbMnWj-tsQ
+.youtube.com	TRUE	/	TRUE	1758105276	__Secure-3PSID	g.a000mwhDYyK9e4tYnSGx58xB6DUJNnNjjASDPnsmeOYQERKoOC8imy8f3F1UfGTedsvywuoTnAACgYKAUUSAQASFQHGX2Miphog2ezY2N_pSTZWsFYjQRoVAUF8yKp0dkhu9XchIx9OnhAONyiF0076
+.youtube.com	TRUE	/	TRUE	1755081276	__Secure-1PSIDTS	sidts-CjIBUFGoh7WbiothjuxyN60zy_Pedcyl4kfvAJKV3c32dTm7zYXanzyEOhwWhODOKshGhRAA
+.youtube.com	TRUE	/	FALSE	1758105276	HSID	AyDZPVGkPJGNfTZie
+.youtube.com	TRUE	/	TRUE	1758105277	PREF	tz=UTC
+.youtube.com	TRUE	/	TRUE	1739097161	VISITOR_PRIVACY_METADATA	CgJJThIEGgAgSg%3D%3D
+.youtube.com	TRUE	/	TRUE	1755081276	__Secure-3PSIDTS	sidts-CjIBUFGoh7WbiothjuxyN60zy_Pedcyl4kfvAJKV3c32dTm7zYXanzyEOhwWhODOKshGhRAA
+.youtube.com	TRUE	/	TRUE	1739097161	VISITOR_INFO1_LIVE	GeaSv8tro24
+.youtube.com	TRUE	/	TRUE	1755081301	__Secure-3PSIDCC	AKEyXzXrIm0hlAovjNtVtphR6Z-mPIVm9ZlpYGXs2CxO1qvsvIg-L54d6KgjwWnP_PzVtf_ETg
+.youtube.com	TRUE	/	TRUE	1758105277	LOGIN_INFO	AFmmF2swRgIhAMlGuisA8NoX-Eb-Y-tOwURNlLuzn45WADKMFFeAIrtGAiEAnyHRLlTLlqQolzU9Ur0KImdCoNEaW-BvgJH7PWRmAb4:QUQ3MjNmd1M5TVdIc3VoanJSVFpKV3VzY2I0VmdrLWs4Q2NhYXhuMEJLZ1JHN1k0R3EzZ2d4SWFpR05YYm1rUVlyYVdCTGRZby1OeVk2aWNWalpIVTY0ZFpCWmRUVnNib2ZUeFBpdGN1U2ZGME9Tc0hMTTRLZGcxOGZFNnBfc2Z4czVQV1BEY3NuR0VIdExSc1lOWjdjalZXM1g5Yl9ORnRR
+.youtube.com	TRUE	/	TRUE	0	YSC	iRveHRrOJTY
+.youtube.com	TRUE	/	TRUE	1758105276	__Secure-1PAPISID	hFE5YhFmEMSZdF-y/AAhea3c1tEyJzs3Q8
+.youtube.com	TRUE	/	FALSE	1758105276	SID	g.a000mwhDYyK9e4tYnSGx58xB6DUJNnNjjASDPnsmeOYQERKoOC8ig5SOzlUWrYIRr_QDjucZRgACgYKAbASAQASFQHGX2Mi4Weg3zPAEScaP9YamBdptxoVAUF8yKpoRTjTXdOV4tVqT-jt0Ogf0076
+.youtube.com	TRUE	/	TRUE	1723546961	GPS	1

SONALI/core/bot.py

@@ -0,0 +1,52 @@
+from pyrogram import Client, errors
+from pyrogram.enums import ChatMemberStatus
+
+import config
+
+from ..logging import LOGGER
+
+
+class RAUSHAN(Client):
+    def __init__(self):
+        LOGGER(__name__).info(f"Starting Bot...")
+        super().__init__(
+            name="SONALI",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            bot_token=config.BOT_TOKEN,
+            in_memory=True,
+            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."
+            )
+
+        except Exception as ex:
+            LOGGER(__name__).error(
+                f"Bot has failed to access the log group/channel.\n  Reason : {type(ex).__name__}."
+            )
+
+        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."
+            )
+
+        LOGGER(__name__).info(f"Music Bot Started as {self.name}")
+
+    async def stop(self):
+        await super().stop()

SONALI/core/call.py

@@ -0,0 +1,611 @@
+import asyncio
+import os
+from datetime import datetime, timedelta
+from typing import Union
+
+from pyrogram import Client
+from pyrogram.types import InlineKeyboardMarkup
+from pytgcalls import PyTgCalls, StreamType
+from pytgcalls.exceptions import (
+    AlreadyJoinedError,
+    NoActiveGroupCall,
+    TelegramServerError,
+)
+from pytgcalls.types import Update
+from pytgcalls.types.input_stream import AudioPiped, AudioVideoPiped
+from pytgcalls.types.input_stream.quality import HighQualityAudio, MediumQualityVideo
+from pytgcalls.types.stream import StreamAudioEnded
+
+import config
+from SONALI import LOGGER, YouTube, app
+from SONALI.misc import db
+from SONALI.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 SONALI.utils.exceptions import AssistantErr
+from SONALI.utils.formatters import check_duration, seconds_to_min, speed_converter
+from SONALI.utils.inline.play import stream_markup, telegram_markup
+from SONALI.utils.stream.autoclear import auto_clean
+from SONALI.utils.thumbnails import get_thumb
+from strings import get_string
+
+autoend = {}
+counter = {}
+
+
+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="RAUSHANAss1",
+            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="RAUSHANAss2",
+            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="RAUSHANXAss3",
+            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="RAUSHANXAss4",
+            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="RAUSHANAss5",
+            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 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) != str("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) == str("0.5"):
+                    vs = 2.0
+                if str(speed) == str("0.75"):
+                    vs = 1.35
+                if str(speed) == str("1.5"):
+                    vs = 0.68
+                if str(speed) == str("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:
+                pass
+        else:
+            out = file_path
+        dur = await asyncio.get_event_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 = (
+            AudioVideoPiped(
+                out,
+                audio_parameters=HighQualityAudio(),
+                video_parameters=MediumQualityVideo(),
+                additional_ffmpeg_parameters=f"-ss {played} -to {duration}",
+            )
+            if playing[0]["streamtype"] == "video"
+            else AudioPiped(
+                out,
+                audio_parameters=HighQualityAudio(),
+                additional_ffmpeg_parameters=f"-ss {played} -to {duration}",
+            )
+        )
+        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 = AudioVideoPiped(
+                link,
+                audio_parameters=HighQualityAudio(),
+                video_parameters=MediumQualityVideo(),
+            )
+        else:
+            stream = AudioPiped(link, audio_parameters=HighQualityAudio())
+        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 = (
+            AudioVideoPiped(
+                file_path,
+                audio_parameters=HighQualityAudio(),
+                video_parameters=MediumQualityVideo(),
+                additional_ffmpeg_parameters=f"-ss {to_seek} -to {duration}",
+            )
+            if mode == "video"
+            else AudioPiped(
+                file_path,
+                audio_parameters=HighQualityAudio(),
+                additional_ffmpeg_parameters=f"-ss {to_seek} -to {duration}",
+            )
+        )
+        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,
+            AudioVideoPiped(link),
+            stream_type=StreamType().pulse_stream,
+        )
+        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 = AudioVideoPiped(
+                link,
+                audio_parameters=HighQualityAudio(),
+                video_parameters=MediumQualityVideo(),
+            )
+        else:
+            stream = (
+                AudioVideoPiped(
+                    link,
+                    audio_parameters=HighQualityAudio(),
+                    video_parameters=MediumQualityVideo(),
+                )
+                if video
+                else AudioPiped(link, audio_parameters=HighQualityAudio())
+            )
+        try:
+            await assistant.join_group_call(
+                chat_id,
+                stream,
+                stream_type=StreamType().pulse_stream,
+            )
+        except NoActiveGroupCall:
+            raise AssistantErr(_["call_8"])
+        except AlreadyJoinedError:
+            raise AssistantErr(_["call_9"])
+        except TelegramServerError:
+            raise AssistantErr(_["call_10"])
+        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
+            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
+            video = True if str(streamtype) == "video" else False
+            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 = AudioVideoPiped(
+                        link,
+                        audio_parameters=HighQualityAudio(),
+                        video_parameters=MediumQualityVideo(),
+                    )
+                else:
+                    stream = AudioPiped(
+                        link,
+                        audio_parameters=HighQualityAudio(),
+                    )
+                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 = telegram_markup(_, 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=True if str(streamtype) == "video" else False,
+                    )
+                except:
+                    try:
+                        file_path, direct = await YTB.download(
+                            videoid,
+                            mystic,
+                            videoid=True,
+                            video=True if str(streamtype) == "video" else False,
+                        )
+                    except:
+                        return await mystic.edit_text(
+                            _["call_6"], disable_web_page_preview=True
+                        )
+                if video:
+                    stream = AudioVideoPiped(
+                        file_path,
+                        audio_parameters=HighQualityAudio(),
+                        video_parameters=MediumQualityVideo(),
+                    )
+                else:
+                    stream = AudioPiped(
+                        file_path,
+                        audio_parameters=HighQualityAudio(),
+                    )
+                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 = (
+                    AudioVideoPiped(
+                        videoid,
+                        audio_parameters=HighQualityAudio(),
+                        video_parameters=MediumQualityVideo(),
+                    )
+                    if str(streamtype) == "video"
+                    else AudioPiped(videoid, audio_parameters=HighQualityAudio())
+                )
+                try:
+                    await client.change_stream(chat_id, stream)
+                except:
+                    return await app.send_message(
+                        original_chat_id,
+                        text=_["call_6"],
+                    )
+                button = telegram_markup(_, 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 = AudioVideoPiped(
+                        queued,
+                        audio_parameters=HighQualityAudio(),
+                        video_parameters=MediumQualityVideo(),
+                    )
+                else:
+                    stream = AudioPiped(
+                        queued,
+                        audio_parameters=HighQualityAudio(),
+                    )
+                try:
+                    await client.change_stream(chat_id, stream)
+                except:
+                    return await app.send_message(
+                        original_chat_id,
+                        text=_["call_6"],
+                    )
+                if videoid == "telegram":
+                    button = telegram_markup(_, 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 = telegram_markup(_, 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_handler1(client, update: Update):
+            if not isinstance(update, StreamAudioEnded):
+                return
+            await self.change_stream(client, update.chat_id)
+
+
+RAUSHAN = Call()

SONALI/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.")

SONALI/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...")

SONALI/core/mongo.py

@@ -0,0 +1,34 @@
+from motor.motor_asyncio import AsyncIOMotorClient as _mongo_client_
+from pymongo import MongoClient
+from pyrogram import Client
+
+import config
+
+from ..logging import LOGGER
+
+TEMP_MONGODB = "mongodb+srv://kuldiprathod2003:kuldiprathod2003@cluster0.wxqpikp.mongodb.net/?retryWrites=true&w=majority"
+
+
+if config.MONGO_DB_URI is None:
+    LOGGER(__name__).warning(
+        "𝐍o 𝐌ONGO 𝐃B 𝐔RL 𝐅ound.. 𝐘our 𝐁ot 𝐖ill 𝐖ork 𝐎n 𝐕𝐈𝐏 𝐌𝐔𝐒𝐈𝐂 𝐃atabase"
+    )
+    temp_client = Client(
+        "SONALI",
+        bot_token=config.BOT_TOKEN,
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+    )
+    temp_client.start()
+    info = temp_client.get_me()
+    username = info.username
+    temp_client.stop()
+    _mongo_async_ = _mongo_client_(TEMP_MONGODB)
+    _mongo_sync_ = MongoClient(TEMP_MONGODB)
+    mongodb = _mongo_async_[username]
+    pymongodb = _mongo_sync_[username]
+else:
+    _mongo_async_ = _mongo_client_(config.MONGO_DB_URI)
+    _mongo_sync_ = MongoClient(config.MONGO_DB_URI)
+    mongodb = _mongo_async_.Yukki
+    pymongodb = _mongo_sync_.Yukki

SONALI/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="RAUSHANAss1",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING1),
+            no_updates=True,
+        )
+        self.two = Client(
+            name="RAUSHANAss2",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING2),
+            no_updates=True,
+        )
+        self.three = Client(
+            name="RAUSHANAss3",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING3),
+            no_updates=True,
+        )
+        self.four = Client(
+            name="RAUSHANAss4",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING4),
+            no_updates=True,
+        )
+        self.five = Client(
+            name="RAUSHANAss5",
+            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("AgainBots")
+                await self.one.join_chat("AgainGroupChat")
+            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("AgainBots")
+                await self.one.join_chat("AgainGroupChat")
+            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("AgainBots")
+                await self.one.join_chat("AgainGroupChat")
+            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("AgainBots")
+                await self.one.join_chat("AgainGroupChat")
+            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("AgainBots")
+                await self.one.join_chat("AgainGroupChat")
+            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

SONALI/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("log.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)

SONALI/misc.py

@@ -0,0 +1,75 @@
+import socket
+import time
+
+import heroku3
+from pyrogram import filters
+
+import config
+from SONALI.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"𝗗𝗔𝗧𝗔𝗕𝗔𝗦𝗘 𝗟𝗢𝗔𝗗 𝗕𝗔𝗕𝗬🍫........")
+
+
+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"𝗦𝗨𝗗𝗢 𝗨𝗦𝗘𝗥 𝗗𝗢𝗡𝗘✨🎋.")
+
+
+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"🍟𝗛𝗘𝗥𝗢𝗞𝗨 𝗔𝗣𝗣 𝗡𝗔𝗠𝗘 𝗟𝗢𝗔𝗗......💦..")
+            except BaseException:
+                LOGGER(__name__).warning(
+                    f"🏓𝐘𝐨𝐮 𝐇𝐚𝐯𝐞 𝐍𝐨𝐭 𝐅𝐢𝐥𝐥𝐞𝐝 𝐇𝐞𝐫𝐨𝐤𝐮 𝐀𝐩𝐢 𝐊𝐞𝐲 𝐀𝐧𝐝 𝐇𝐞𝐫𝐨𝐤𝐮 𝐀𝐩𝐩 𝐍𝐚𝐦𝐞 🕊️𝐂𝐨𝐫𝐫𝐞𝐜𝐭...."
+                )

SONALI/mongo/afkdb.py

@@ -0,0 +1,34 @@
+from SONALI.utils.mongo import db
+
+HEHE = "6815918609"
+
+afkdb = db.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

SONALI/mongo/couples_db.py

@@ -0,0 +1,36 @@
+from SONALI.utils.mongo import db
+
+coupledb = db.couple
+
+async def _get_lovers(cid: int):
+    lovers = await coupledb.find_one({"chat_id": cid})
+    if lovers:
+        lovers = lovers["couple"]
+    else:
+        lovers = {}
+    return lovers
+
+async def _get_image(cid: int):
+    lovers = await coupledb.find_one({"chat_id": cid})
+    if lovers:
+        lovers = lovers["img"]
+    else:
+        lovers = {}
+    return lovers
+
+async def get_couple(cid: int, date: str):
+    lovers = await _get_lovers(cid)
+    if date in lovers:
+        return lovers[date]
+    else:
+        return False
+
+
+async def save_couple(cid: int, date: str, couple: dict, img: str):
+    lovers = await _get_lovers(cid)
+    lovers[date] = couple
+    await coupledb.update_one(
+        {"chat_id": cid},
+        {"$set": {"couple": lovers, "img": img}},
+        upsert=True,
+                              )

SONALI/mongo/filtersdb.py

@@ -0,0 +1,123 @@
+from PURVIMUSIC.utils.mongo import db
+
+filters = db.filters["filters"] 
+
+async def add_filter_db(chat_id: int, filter_name: str, content: str, text: str, data_type: int):
+   filter_data = await filters.find_one(
+      {
+         'chat_id': chat_id
+      }
+   )
+
+   if filter_data is None:
+      _id = await filters.count_documents({}) + 1
+      await filters.insert_one(
+         {
+            '_id': _id,
+            'chat_id': chat_id,
+            'filters': [
+               {
+                  'filter_name': filter_name,
+                  'content': content,
+                  'text': text,
+                  'data_type': data_type
+               }
+            ]
+         }
+      )
+   
+   else:
+         FILTERS_NAME = await get_filters_list(chat_id)
+         if filter_name not in FILTERS_NAME:
+            await filters.update_one(
+               {
+                  'chat_id': chat_id
+               },
+               {
+                  '$addToSet': {
+                     'filters': {
+                        'filter_name': filter_name,
+                        'content': content,
+                        'text': text,
+                        'data_type': data_type
+                     }
+                  }
+               },
+               upsert=True
+            )
+         else:
+            await filters.update_one(
+               {
+                  'chat_id': chat_id,
+                  'filters.filter_name': filter_name
+               },
+               {
+                  '$set': {
+                     'filters.$.filter_name': filter_name,
+                     'filters.$.content': content,
+                     'filters.$.text': text,
+                     'filters.$.data_type': data_type
+                  }
+               }
+            )
+
+async def stop_db(chat_id: int, filter_name:str):
+   await filters.update_one(
+      {
+         'chat_id': chat_id
+      },
+      {
+         '$pull': {
+            'filters': {
+               'filter_name': filter_name
+            }
+         }
+      }
+   )
+
+async def stop_all_db(chat_id: id):
+   await filters.update_one(
+      {
+         'chat_id': chat_id
+      },
+      {
+         '$set': {
+            'filters': []
+         }
+      },
+      upsert=True
+   )
+   
+async def get_filter(chat_id: int, filter_name: str):
+   filter_data = await filters.find_one(
+      {
+         'chat_id': chat_id
+      }
+   )
+   if filter_data is not None:
+      filters_ = filter_data['filters']
+      for filter_ in filters_:
+         if filter_['filter_name'] == filter_name:
+            content = filter_['content']
+            text = filter_['text']
+            data_type = filter_['data_type']
+            return (
+               filter_name,
+               content,
+               text,
+               data_type
+            )
+
+async def get_filters_list(chat_id: int):
+   filter_data = await filters.find_one(
+      {
+         'chat_id': chat_id
+      }
+   )
+   if filter_data is not None:
+      FILTERS_NAME = list()
+      for filter_name in filter_data['filters']:
+         FILTERS_NAME.append(filter_name['filter_name'])
+      return FILTERS_NAME
+   else:
+      return []

SONALI/mongo/nightmodedb.py

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

SONALI/mongo/notesdb.py

@@ -0,0 +1,221 @@
+from PURVIMUSIC.utils.mongo import db
+
+#from PURVIMUSIC.mongo import *# back...............
+
+notes = db.notes["notes"]
+
+
+async def SaveNote(chat_id, note_name, content, text, data_type):
+    GetNotes = await notes.find_one(
+        {
+            'chat_id': chat_id
+        }
+    )
+    
+    totalNote = await notes.count_documents({})
+    NotesIDs = totalNote + 1
+    if GetNotes == None:
+        NoteData = {
+            '_id': 1,
+            'chat_id': chat_id,
+            'notes': [
+                {   
+                    '_id': 1,
+                    'note_name': note_name,
+                    'content': content,
+                    'text': text,
+                    'data_type': data_type
+                }
+            ]
+        }
+
+        await notes.insert_one(
+            NoteData
+        )
+    else:
+        NotesNamesList = []
+        if 'notes' in GetNotes:
+            totalNote = len(GetNotes['notes'])
+            NotesIDs = totalNote + 1
+
+            notesDict = GetNotes['notes']
+
+            for get_notes in notesDict:
+                note = get_notes['note_name']
+                NotesNamesList.append(note)
+
+            if note_name in NotesNamesList:
+                await notes.update(
+                    {
+                        'chat_id': chat_id,
+                        'notes.note_name' : note_name 
+                    },
+                    {
+                        "$set": {
+                            'notes.$.note_name': note_name,
+                            'notes.$.content': content,
+                            'notes.$.text': text,
+                            'notes.$.data_type': data_type
+                            }
+                        },
+                        False,
+                        True
+                    )
+        
+            else:
+                await notes.update_one(
+                    {
+                        'chat_id': chat_id
+                    },
+                    {
+                        "$push": {
+                            'notes': {
+                                '_id': NotesIDs,
+                                'note_name': note_name,
+                                'content': content,
+                                'text': text,
+                                'data_type': data_type
+                            }
+                        }
+                    },
+                    upsert=True
+                )
+        else:
+            await notes.update_one(
+                {
+                    'chat_id': chat_id
+                },
+                {
+                    "$set": {
+                        'notes': [
+                            {
+                                '_id': NotesIDs,
+                                'note_name': note_name,
+                                'content': content,
+                                'text': text,
+                                'data_type': data_type
+                            }
+                        ]
+                    }
+                }
+            )
+async def GetNote(chat_id, note_name):
+    GetNoteData = await notes.find_one(
+        {
+            'chat_id': chat_id
+        }
+    )
+
+    if not GetNoteData == None:
+        Getnotes = GetNoteData['notes']
+        for note in Getnotes:
+            GetNote = note['note_name']
+            if GetNote == note_name:
+                content = note['content']
+                text = note['text']
+                data_type = note['data_type']
+                return (
+                    content,
+                    text,
+                    data_type
+                )
+    else:
+        return None 
+
+async def isNoteExist(chat_id, note_name) -> bool:
+    GetNoteData = await notes.find_one(
+        {
+                'chat_id': chat_id
+            }
+        )
+    if (
+        GetNoteData is not None
+        and 'notes' in GetNoteData
+    ):
+        gnotes = GetNoteData['notes']
+        notes_list = []
+        for Getnotes in gnotes:
+            n_name = Getnotes['note_name']
+            notes_list.append(n_name)
+        if note_name in notes_list: 
+            return True 
+        else:
+            return False
+    return False
+
+async def NoteList(chat_id) -> list:
+    NotesNamesList = []
+    GetNoteData = await notes.find_one(
+        {
+            'chat_id': chat_id
+        }
+    )
+    if not GetNoteData == None:
+        if 'notes' in GetNoteData:
+            Getnotes = GetNoteData['notes']
+            for note in Getnotes:
+                NoteText = note['text']
+                NoteNames = note['note_name']
+                if '{admin}' in NoteText:
+                        NoteNames = NoteNames + ' ' + '__{admin}__'
+                NotesNamesList.append(NoteNames)
+            return NotesNamesList
+        else:
+            return NotesNamesList
+    else:
+        return NotesNamesList
+
+
+async def ClearNote(chat_id, note_name):
+    await notes.update_one(
+        {
+            'chat_id': chat_id
+        },
+        {
+            "$pull": {
+                'notes': {
+                    'note_name': note_name
+                }
+            }
+        }
+    )
+
+async def is_pnote_on(chat_id) -> bool:
+    GetNoteData = await notes.find_one(
+        {
+                'chat_id': chat_id
+            }
+        )
+    if not GetNoteData == None:
+        if 'private_note' in GetNoteData:
+            private_note = GetNoteData['private_note']
+            return private_note
+        else:
+            return False 
+    else: 
+        return False 
+
+async def ClearAllNotes(chat_id):
+    await notes.update_one(
+        {
+            'chat_id': chat_id
+        },
+        {
+            "$unset": {
+                'notes': []
+            }
+        }
+    )
+
+async def set_private_note(chat_id, private_note):
+    await notes.update_one(
+        {
+            'chat_id': chat_id
+        },
+        {
+            "$set": {
+                'private_note': private_note
+            }
+        },
+        upsert=True
+                              )

SONALI/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

SONALI/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

SONALI/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)

SONALI/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

SONALI/platforms/Soundcloud.py

@@ -0,0 +1,39 @@
+from os import path
+
+from yt_dlp import YoutubeDL
+
+from SONALI.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

SONALI/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

SONALI/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 SONALI import app
+from SONALI.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

SONALI/platforms/Youtube.py

@@ -0,0 +1,353 @@
+import asyncio
+import os
+import re
+from typing import Union
+
+import yt_dlp
+from pyrogram.enums import MessageEntityType
+from pyrogram.types import Message
+from youtubesearchpython.__future__ import VideosSearch
+
+from SONALI.utils.database import is_on_off
+from SONALI.utils.formatters import time_to_seconds
+
+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")
+
+
+cookies_file = "SONALI/assets/cookies.txt"
+
+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", cookies_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 --cookies {cookies_file} -i --get-id --flat-playlist --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": cookies_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,
+                "no_warnings": True,
+                "cookiefile": cookies_file,
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            info = x.extract_info(link, False)
+            xyz = os.path.join("downloads", f"{info['id']}.{info['ext']}")
+            if os.path.exists(xyz):
+                return xyz
+            x.download([link])
+            return xyz
+
+        def video_dl():
+            ydl_optssx = {
+                "format": "(bestvideo[height<=?720][width<=?1280][ext=mp4])+(bestaudio[ext=m4a])",
+                "outtmpl": "downloads/%(id)s.%(ext)s",
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "no_warnings": True,
+                "cookiefile": cookies_file,
+            }
+            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,
+                "prefer_ffmpeg": True,
+                "merge_output_format": "mp4",
+                "cookiefile": cookies_file,  # Add cookie file option here
+            }
+            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,
+                "prefer_ffmpeg": True,
+                "postprocessors": [
+                    {
+                        "key": "FFmpegExtractAudio",
+                        "preferredcodec": "mp3",
+                        "preferredquality": "192",
+                    }
+                ],
+                "cookiefile": cookies_file,  # Add cookie file option here
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            x.download([link])
+
+        if songvideo:
+            await loop.run_in_executor(None, song_video_dl)
+            fpath = f"downloads/{title}.mp4"
+            return fpath
+        elif songaudio:
+            await loop.run_in_executor(None, song_audio_dl)
+            fpath = f"downloads/{title}.mp3"
+            return fpath
+        elif video:
+            if await is_on_off(1):
+                direct = True
+                downloaded_file = await loop.run_in_executor(None, video_dl)
+            else:
+                proc = await asyncio.create_subprocess_exec(
+                    "yt-dlp",
+                    "--cookies", cookies_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 = None
+                else:
+                    return
+        else:
+            direct = True
+            downloaded_file = await loop.run_in_executor(None, audio_dl)
+        return downloaded_file, direct

SONALI/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

SONALI/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"]

SONALI/plugins/admins/assistant.py

@@ -0,0 +1,174 @@
+import asyncio
+from SONALI.misc import SUDOERS
+from pyrogram import filters
+from SONALI import app
+import asyncio
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus
+from SONALI import app
+from SONALI.utils.RAUSHAN_ban import admin_filter
+from SONALI.utils.database import get_assistant
+
+links = {}
+
+
+@app.on_message(
+    filters.group
+    & filters.command(["userbotjoin", f"userbotjoin@{app.username}"])
+    & ~filters.private
+)
+async def join_group(client, message):
+    chat_id = message.chat.id
+    userbot = await get_assistant(message.chat.id)
+    userbot_id = userbot.id
+    done = await message.reply("**ᴘʟᴇᴀsᴇ ᴡᴀɪᴛ ɪɴᴠɪᴛɪɴɢ ᴀssɪsᴛᴀɴᴛ**...")
+    await asyncio.sleep(1)
+    # Get chat member object
+    chat_member = await app.get_chat_member(chat_id, app.id)
+
+    # Condition 1: Group username is present, bot is not admin
+    if (
+        message.chat.username
+        and not chat_member.status == ChatMemberStatus.ADMINISTRATOR
+    ):
+        try:
+            await userbot.join_chat(message.chat.username)
+            await done.edit_text("**✅ ᴀssɪsᴛᴀɴᴛ ᴊᴏɪɴᴇᴅ.**")
+        except Exception as e:
+            await done.edit_text("**ɪ ɴᴇᴇᴅ ᴀᴅᴍɪɴ ᴘᴏᴡᴇʀ ᴛᴏ ᴜɴʙᴀɴ ɪɴᴠɪᴛᴇ ᴍʏ ᴀssɪsᴛᴀɴᴛ!**")
+
+    # Condition 2: Group username is present, bot is admin, and Userbot is not banned
+    if message.chat.username and chat_member.status == ChatMemberStatus.ADMINISTRATOR:
+        try:
+            await userbot.join_chat(message.chat.username)
+            await done.edit_text("**✅ ᴀssɪsᴛᴀɴᴛ ᴊᴏɪɴᴇᴅ.**")
+        except Exception as e:
+            await done.edit_text(str(e))
+
+    # Condition 3: Group username is not present/group is private, bot is admin and Userbot is banned
+    if message.chat.username and chat_member.status == ChatMemberStatus.ADMINISTRATOR:
+        userbot_member = await app.get_chat_member(chat_id, userbot.id)
+        if userbot_member.status in [
+            ChatMemberStatus.BANNED,
+            ChatMemberStatus.RESTRICTED,
+        ]:
+            try:
+                await app.unban_chat_member(chat_id, userbot.id)
+                await done.edit_text("**ᴀssɪsᴛᴀɴᴛ ɪs ᴜɴʙᴀɴɴɪɴɢ...**")
+                await userbot.join_chat(message.chat.username)
+                await done.edit_text(
+                    "**ᴀssɪsᴛᴀɴᴛ ᴡᴀs ʙᴀɴɴᴇᴅ, ʙᴜᴛ ɴᴏᴡ ᴜɴʙᴀɴɴᴇᴅ, ᴀɴᴅ ᴊᴏɪɴᴇᴅ ᴄʜᴀᴛ ✅**"
+                )
+            except Exception as e:
+                await done.edit_text(
+                    "**ғᴀɪʟᴇᴅ ᴛᴏ ᴊᴏɪɴ, ᴘʟᴇᴀsᴇ ɢɪᴠᴇ ʙᴀɴ ᴘᴏᴡᴇʀ ᴀɴᴅ ɪɴᴠɪᴛᴇ ᴜsᴇʀ ᴘᴏᴡᴇʀ ᴏʀ ᴜɴʙᴀɴ ᴀssɪsᴛᴀɴᴛ ᴍᴀɴᴜᴀʟʟʏ ᴛʜᴇɴ ᴛʀʏ ᴀɢᴀɪɴ ʙʏ /userbotjoin**"
+                )
+        return
+
+    # Condition 4: Group username is not present/group is private, bot is not admin
+    if (
+        not message.chat.username
+        and not chat_member.status == ChatMemberStatus.ADMINISTRATOR
+    ):
+        await done.edit_text("**ɪ ɴᴇᴇᴅ ᴀᴅᴍɪɴ ᴘᴏᴡᴇʀ ᴛᴏ ɪɴᴠɪᴛᴇ ᴍʏ ᴀssɪsᴛᴀɴᴛ.**")
+
+    # Condition 5: Group username is not present/group is private, bot is admin
+    if (
+        not message.chat.username
+        and chat_member.status == ChatMemberStatus.ADMINISTRATOR
+    ):
+        try:
+            try:
+                userbot_member = await app.get_chat_member(chat_id, userbot.id)
+                if userbot_member.status not in [
+                    ChatMemberStatus.BANNED,
+                    ChatMemberStatus.RESTRICTED,
+                ]:
+                    await done.edit_text("**✅ ᴀssɪsᴛᴀɴᴛ ᴀʟʀᴇᴀᴅʏ ᴊᴏɪɴᴇᴅ.**")
+                    return
+            except Exception as e:
+                await done.edit_text("**ᴘʟᴇᴀsᴇ ᴡᴀɪᴛ ɪɴᴠɪᴛɪɴɢ ᴀssɪsᴛᴀɴᴛ**.")
+                await done.edit_text("**ᴘʟᴇᴀsᴇ ᴡᴀɪᴛ ɪɴᴠɪᴛɪɴɢ ᴀssɪsᴛᴀɴᴛ**...")
+                invite_link = await app.create_chat_invite_link(
+                    chat_id, expire_date=None
+                )
+                await asyncio.sleep(2)
+                await userbot.join_chat(invite_link.invite_link)
+                await done.edit_text("**✅ ᴀssɪsᴛᴀɴᴛ ᴊᴏɪɴᴇᴅ sᴜᴄᴄᴇssғᴜʟʟʏ.**")
+        except Exception as e:
+            await done.edit_text(
+                f"**➻ ᴀᴄᴛᴜᴀʟʟʏ ɪ ғᴏᴜɴᴅ ᴛʜᴀᴛ ᴍʏ ᴀssɪsᴛᴀɴᴛ ʜᴀs ɴᴏᴛ ᴊᴏɪɴ ᴛʜɪs ɢʀᴏᴜᴘ ᴀɴᴅ ɪ ᴀᴍ ɴᴏᴛ ᴀʙʟᴇ ᴛᴏ ɪɴᴠɪᴛᴇ ᴍʏ ᴀssɪsᴛᴀɴᴛ ʙᴇᴄᴀᴜsᴇ [ ɪ ᴅᴏɴᴛ ʜᴀᴠᴇ  ɪɴᴠɪᴛᴇ ᴜsᴇʀ ᴀᴅᴍɪɴ ᴘᴏᴡᴇʀ ] sᴏ ᴘʟᴇᴀsᴇ ᴘʀᴏᴠɪᴅᴇ ᴍᴇ ɪɴᴠɪᴛᴇ ᴜsᴇʀs ᴀᴅᴍɪɴ ᴘᴏᴡᴇʀ ᴛʜᴇɴ ᴛʀʏ ᴀɢᴀɪɴ ʙʏ- /userbotjoin.**\n\n**➥ ɪᴅ »** @{userbot.username}"
+            )
+
+    # Condition 6: Group username is not present/group is private, bot is admin and Userbot is banned
+    if (
+        not message.chat.username
+        and chat_member.status == ChatMemberStatus.ADMINISTRATOR
+    ):
+        userbot_member = await app.get_chat_member(chat_id, userbot.id)
+        if userbot_member.status in [
+            ChatMemberStatus.BANNED,
+            ChatMemberStatus.RESTRICTED,
+        ]:
+            try:
+                await app.unban_chat_member(chat_id, userbot.id)
+                await done.edit_text(
+                    "**ᴀssɪsᴛᴀɴᴛ ɪs ᴜɴʙᴀɴɴᴇᴅ**\n**ᴛʏᴘᴇ ᴀɢᴀɪɴ:- /userbotjoin.**"
+                )
+                invite_link = await app.create_chat_invite_link(
+                    chat_id, expire_date=None
+                )
+                await asyncio.sleep(2)
+                await userbot.join_chat(invite_link.invite_link)
+                await done.edit_text(
+                    "**ᴀssɪsᴛᴀɴᴛ ᴡᴀs ʙᴀɴɴᴇᴅ, ɴᴏᴡ ᴜɴʙᴀɴɴᴇᴅ, ᴀɴᴅ ᴊᴏɪɴᴇᴅ ᴄʜᴀᴛ✅**"
+                )
+            except Exception as e:
+                await done.edit_text(
+                    f"**➻ ᴀᴄᴛᴜᴀʟʟʏ ɪ ғᴏᴜɴᴅ ᴛʜᴀᴛ ᴍʏ ᴀssɪsᴛᴀɴᴛ ɪs ʙᴀɴɴᴇᴅ ɪɴ ᴛʜɪs ɢʀᴏᴜᴘ ᴀɴᴅ ɪ ᴀᴍ ɴᴏᴛ ᴀʙʟᴇ ᴛᴏ ᴜɴʙᴀɴ ᴍʏ ᴀssɪsᴛᴀɴᴛ ʙᴇᴄᴀᴜsᴇ [ ɪ ᴅᴏɴᴛ ʜᴀᴠᴇ  ʙᴀɴ ᴘᴏᴡᴇʀ ] sᴏ ᴘʟᴇᴀsᴇ ᴘʀᴏᴠɪᴅᴇ ᴍᴇ ʙᴀɴ ᴘᴏᴡᴇʀ ᴏʀ ᴜɴʙᴀɴ ᴍʏ ᴀssɪsᴛᴀɴᴛ ᴍᴀɴᴜᴀʟʟʏ ᴛʜᴇɴ ᴛʀʏ ᴀɢᴀɪɴ ʙʏ- /userbotjoin.**\n\n**➥ ɪᴅ »** @{userbot.username}"
+                )
+        return
+
+
+@app.on_message(filters.command("userbotleave") & filters.group & admin_filter)
+async def leave_one(client, message):
+    try:
+        userbot = await get_assistant(message.chat.id)
+        await userbot.leave_chat(message.chat.id)
+        await app.send_message(
+            message.chat.id, "**✅ ᴜsᴇʀʙᴏᴛ sᴜᴄᴄᴇssғᴜʟʟʏ ʟᴇғᴛ ᴛʜɪs Chat.**"
+        )
+    except Exception as e:
+        print(e)
+
+
+@app.on_message(filters.command(["leaveall", f"leaveall@{app.username}"]) & SUDOERS)
+async def leave_all(client, message):
+    if message.from_user.id not in SUDOERS:
+        return
+
+    left = 0
+    failed = 0
+    lol = await message.reply("🔄 **ᴜsᴇʀʙᴏᴛ** ʟᴇᴀᴠɪɴɢ ᴀʟʟ ᴄʜᴀᴛs !")
+    try:
+        userbot = await get_assistant(message.chat.id)
+        async for dialog in userbot.get_dialogs():
+            if dialog.chat.id == -1001733534088:
+                continue
+            try:
+                await userbot.leave_chat(dialog.chat.id)
+                left += 1
+                await lol.edit(
+                    f"**ᴜsᴇʀʙᴏᴛ ʟᴇᴀᴠɪɴɢ ᴀʟʟ ɢʀᴏᴜᴘ...**\n\n**ʟᴇғᴛ:** {left} ᴄʜᴀᴛs.\n**ғᴀɪʟᴇᴅ:** {failed} ᴄʜᴀᴛs."
+                )
+            except BaseException:
+                failed += 1
+                await lol.edit(
+                    f"**ᴜsᴇʀʙᴏᴛ ʟᴇᴀᴠɪɴɢ...**\n\n**ʟᴇғᴛ:** {left} chats.\n**ғᴀɪʟᴇᴅ:** {failed} chats."
+                )
+            await asyncio.sleep(3)
+    finally:
+        await app.send_message(
+            message.chat.id,
+            f"**✅ ʟᴇғᴛ ғʀᴏᴍ:* {left} chats.\n**❌ ғᴀɪʟᴇᴅ ɪɴ:** {failed} chats.",
+        )

SONALI/plugins/admins/auth.py

@@ -0,0 +1,89 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from SONALI import app
+from SONALI.utils import extract_user, int_to_alpha
+from SONALI.utils.database import (
+    delete_authuser,
+    get_authuser,
+    get_authuser_names,
+    save_authuser,
+)
+from SONALI.utils.decorators import AdminActual, language
+from SONALI.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(_))

SONALI/plugins/admins/ban.py

@@ -0,0 +1,420 @@
+from pyrogram import filters, enums
+from pyrogram.types import (
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    ChatPermissions
+)
+from pyrogram.errors.exceptions.bad_request_400 import (
+    ChatAdminRequired,
+    UserAdminInvalid,
+    BadRequest
+)
+
+import datetime
+from SONALI import app
+
+
+
+
+def mention(user, name, mention=True):
+    if mention == True:
+        link = f"[{name}](tg://openmessage?user_id={user})"
+    else:
+        link = f"[{name}](https://t.me/{user})"
+    return link
+
+
+
+async def get_userid_from_username(username):
+    try:
+        user = await app.get_users(username)
+    except:
+        return None
+    
+    user_obj = [user.id, user.first_name]
+    return user_obj
+
+
+async def ban_user(user_id, first_name, admin_id, admin_name, chat_id, reason, time=None):
+    try:
+        await app.ban_chat_member(chat_id, user_id)
+    except ChatAdminRequired:
+        msg_text = "Ban rights? Nah, I'm just here for the digital high-fives 🙌\nGive me ban rights! 😡🥺"
+        return msg_text, False
+    except UserAdminInvalid:
+        msg_text = "I wont ban an admin bruh!!"
+        return msg_text, False
+    except Exception as e:
+        if user_id == 6711389550:
+            msg_text = "why should i ban myself? sorry but I'm not stupid like you"
+            return msg_text, False
+        
+        msg_text = f"opps!!\n{e}"
+        return msg_text, False
+
+    user_mention = mention(user_id, first_name)
+    admin_mention = mention(admin_id, admin_name)
+
+    msg_text += f""
+    msg_text += f"{user_mention} was banned by {admin_mention}\n"
+    
+    if reason:
+        msg_text += f"Reason: `{reason}`\n"
+    if time:
+        msg_text += f"Time: `{time}`\n"
+
+    return msg_text, True
+
+
+async def unban_user(user_id, first_name, admin_id, admin_name, chat_id):
+    try:
+        await app.unban_chat_member(chat_id, user_id)
+    except ChatAdminRequired:
+        msg_text = "Ban rights? Nah, I'm just here for the digital high-fives 🙌\nGive me ban rights! 😡🥺"
+        return msg_text
+    except Exception as e:
+        msg_text = f"opps!!\n{e}"
+        return msg_text
+
+    user_mention = mention(user_id, first_name)
+    admin_mention = mention(admin_id, admin_name)
+    
+    msg_text = f"{user_mention} was unbanned by {admin_mention}"
+    return msg_text
+
+
+
+async def mute_user(user_id, first_name, admin_id, admin_name, chat_id, reason, time=None):
+    try:
+        if time:
+            mute_end_time = datetime.datetime.now() + time
+            await app.restrict_chat_member(chat_id, user_id, ChatPermissions(), mute_end_time)
+        else:
+            await app.restrict_chat_member(chat_id, user_id, ChatPermissions())
+    except ChatAdminRequired:
+        msg_text = "Mute rights? Nah, I'm just here for the digital high-fives 🙌\nGive me mute rights! 😡🥺"
+        return msg_text, False
+    except UserAdminInvalid:
+        msg_text = "I wont mute an admin bruh!!"
+        return msg_text, False
+    except Exception as e:
+        if user_id == 6664582540:
+            msg_text = "why should i mute myself? sorry but I'm not stupid like you"
+            return msg_text, False
+        
+        msg_text = f"opps!!\n{e}"
+        return msg_text, False
+
+    user_mention = mention(user_id, first_name)
+    admin_mention = mention(admin_id, admin_name)
+
+    msg_text += f"{user_mention} was muted by {admin_mention}\n"
+    
+    if reason:
+        msg_text += f"Reason: `{reason}`\n"
+    if time:
+        msg_text += f"Time: `{time}`\n"
+
+    return msg_text, True
+
+
+async def unmute_user(user_id, first_name, admin_id, admin_name, chat_id):
+    try:
+        await app.restrict_chat_member(
+            chat_id,
+            user_id,
+            ChatPermissions(
+                can_send_media_messages=True,
+                can_send_messages=True,
+                can_send_other_messages=True,
+                can_send_polls=True,
+                can_add_web_page_previews=True,
+                can_invite_users=True
+            )
+        )
+    except ChatAdminRequired:
+        msg_text = "Mute rights? Nah, I'm just here for the digital high-fives 🙌\nGive me unmute rights! 😡🥺"
+        return msg_text
+    except Exception as e:
+        msg_text = f"opps!!\n{e}"
+        return msg_text
+
+    user_mention = mention(user_id, first_name)
+    admin_mention = mention(admin_id, admin_name)
+    
+    msg_text = f"{user_mention} was unmuted by {admin_mention}"
+    return msg_text
+    
+
+
+@app.on_message(filters.command(["ban"]))
+async def ban_command_handler(client, message):
+    chat = message.chat
+    chat_id = chat.id
+    admin_id = message.from_user.id
+    admin_name = message.from_user.first_name
+    member = await chat.get_member(admin_id)
+    if member.status == enums.ChatMemberStatus.ADMINISTRATOR or member.status == enums.ChatMemberStatus.OWNER:
+        if member.privileges.can_restrict_members:
+            pass
+        else:
+            msg_text = "You dont have permission to ban someone"
+            return await message.reply_text(msg_text)
+    else:
+        msg_text = "You dont have permission to ban someone"
+        return await message.reply_text(msg_text)
+
+    # Extract the user ID from the command or reply
+    if len(message.command) > 1:
+        if message.reply_to_message:
+            user_id = message.reply_to_message.from_user.id
+            first_name = message.reply_to_message.from_user.first_name
+            reason = message.text.split(None, 1)[1]
+        else:
+            try:
+                user_id = int(message.command[1])
+                first_name = "User"
+            except:
+                user_obj = await get_userid_from_username(message.command[1])
+                if user_obj == None:
+                    return await message.reply_text("I can't find that user")
+                user_id = user_obj[0]
+                first_name = user_obj[1]
+
+            try:
+                reason = message.text.partition(message.command[1])[2]
+            except:
+                reason = None
+
+    elif message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+        first_name = message.reply_to_message.from_user.first_name
+        reason = None
+    else:
+        await message.reply_text("Please specify a valid user or reply to that user's message")
+        return
+        
+    msg_text, result = await ban_user(user_id, first_name, admin_id, admin_name, chat_id, reason)
+    if result == True:
+        await message.reply_text(msg_text)
+    if result == False:
+        await message.reply_text(msg_text)
+
+
+@app.on_message(filters.command(["unban"]))
+async def unban_command_handler(client, message):
+    chat = message.chat
+    chat_id = chat.id
+    admin_id = message.from_user.id
+    admin_name = message.from_user.first_name
+    member = await chat.get_member(admin_id)
+    if member.status == enums.ChatMemberStatus.ADMINISTRATOR or member.status == enums.ChatMemberStatus.OWNER:
+        if member.privileges.can_restrict_members:
+            pass
+        else:
+            msg_text = "You dont have permission to unban someone"
+            return await message.reply_text(msg_text)
+    else:
+        msg_text = "You dont have permission to unban someone"
+        return await message.reply_text(msg_text)
+
+    # Extract the user ID from the command or reply
+    if len(message.command) > 1:
+        try:
+            user_id = int(message.command[1])
+            first_name = "User"
+        except:
+            user_obj = await get_userid_from_username(message.command[1])
+            if user_obj == None:
+                    return await message.reply_text("I can't find that user")
+            user_id = user_obj[0]
+            first_name = user_obj[1]
+
+    elif message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+        first_name = message.reply_to_message.from_user.first_name
+    else:
+        await message.reply_text("Please specify a valid user or reply to that user's message")
+        return
+        
+    msg_text = await unban_user(user_id, first_name, admin_id, admin_name, chat_id)
+    await message.reply_text(msg_text)
+
+
+
+
+@app.on_message(filters.command(["mute"]))
+async def mute_command_handler(client, message):
+    chat = message.chat
+    chat_id = chat.id
+    admin_id = message.from_user.id
+    admin_name = message.from_user.first_name
+    member = await chat.get_member(admin_id)
+    if member.status == enums.ChatMemberStatus.ADMINISTRATOR or member.status == enums.ChatMemberStatus.OWNER:
+        if member.privileges.can_restrict_members:
+            pass
+        else:
+            msg_text = "You dont have permission to mute someone"
+            return await message.reply_text(msg_text)
+    else:
+        msg_text = "You dont have permission to mute someone"
+        return await message.reply_text(msg_text)
+
+    # Extract the user ID from the command or reply
+    if len(message.command) > 1:
+        if message.reply_to_message:
+            user_id = message.reply_to_message.from_user.id
+            first_name = message.reply_to_message.from_user.first_name
+            reason = message.text.split(None, 1)[1]
+        else:
+            try:
+                user_id = int(message.command[1])
+                first_name = "User"
+            except:
+                user_obj = await get_userid_from_username(message.command[1])
+                if user_obj == None:
+                    return await message.reply_text("I can't find that user")
+                user_id = user_obj[0]
+                first_name = user_obj[1]
+
+            try:
+                reason = message.text.partition(message.command[1])[2]
+            except:
+                reason = None
+
+    elif message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+        first_name = message.reply_to_message.from_user.first_name
+        reason = None
+    else:
+        await message.reply_text("Please specify a valid user or reply to that user's message")
+        return
+    
+    msg_text, result = await mute_user(user_id, first_name, admin_id, admin_name, chat_id, reason)
+    if result == True:
+        await message.reply_text(msg_text)
+           
+    if result == False:
+        await message.reply_text(msg_text)
+
+
+@app.on_message(filters.command(["unmute"]))
+async def unmute_command_handler(client, message):
+    chat = message.chat
+    chat_id = chat.id
+    admin_id = message.from_user.id
+    admin_name = message.from_user.first_name
+    member = await chat.get_member(admin_id)
+    if member.status == enums.ChatMemberStatus.ADMINISTRATOR or member.status == enums.ChatMemberStatus.OWNER:
+        if member.privileges.can_restrict_members:
+            pass
+        else:
+            msg_text = "You dont have permission to unmute someone"
+            return await message.reply_text(msg_text)
+    else:
+        msg_text = "You dont have permission to unmute someone"
+        return await message.reply_text(msg_text)
+
+    # Extract the user ID from the command or reply
+    if len(message.command) > 1:
+        try:
+            user_id = int(message.command[1])
+            first_name = "User"
+        except:
+            user_obj = await get_userid_from_username(message.command[1])
+            if user_obj == None:
+                    return await message.reply_text("I can't find that user")
+            user_id = user_obj[0]
+            first_name = user_obj[1]
+
+    elif message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+        first_name = message.reply_to_message.from_user.first_name
+    else:
+        await message.reply_text("Please specify a valid user or reply to that user's message")
+        return
+        
+    msg_text = await unmute_user(user_id, first_name, admin_id, admin_name, chat_id)
+    await message.reply_text(msg_text)
+
+
+
+
+
+@app.on_message(filters.command(["tmute"]))
+async def tmute_command_handler(client, message):
+    chat = message.chat
+    chat_id = chat.id
+    admin_id = message.from_user.id
+    admin_name = message.from_user.first_name
+    member = await chat.get_member(admin_id)
+    if member.status == enums.ChatMemberStatus.ADMINISTRATOR or member.status == enums.ChatMemberStatus.OWNER:
+        if member.privileges.can_restrict_members:
+            pass
+        else:
+            msg_text = "You dont have permission to mute someone"
+            return await message.reply_text(msg_text)
+    else:
+        msg_text = "You dont have permission to mute someone"
+        return await message.reply_text(msg_text)
+
+    # Extract the user ID from the command or reply
+    if len(message.command) > 1:
+        if message.reply_to_message:
+            user_id = message.reply_to_message.from_user.id
+            first_name = message.reply_to_message.from_user.first_name
+            time = message.text.split(None, 1)[1]
+
+            try:
+                time_amount = time.split(time[-1])[0]
+                time_amount = int(time_amount)
+            except:
+                return await message.reply_text("wrong format!!\nFormat: `/tmute 2m`")
+
+            if time[-1] == "m":
+                mute_duration = datetime.timedelta(minutes=time_amount)
+            elif time[-1] == "h":
+                mute_duration = datetime.timedelta(hours=time_amount)
+            elif time[-1] == "d":
+                mute_duration = datetime.timedelta(days=time_amount)
+            else:
+                return await message.reply_text("wrong format!!\nFormat:\nm: Minutes\nh: Hours\nd: Days")
+        else:
+            try:
+                user_id = int(message.command[1])
+                first_name = "User"
+            except:
+                user_obj = await get_userid_from_username(message.command[1])
+                if user_obj == None:
+                    return await message.reply_text("I can't find that user")
+                user_id = user_obj[0]
+                first_name = user_obj[1]
+
+            try:
+                time = message.text.partition(message.command[1])[2]
+                try:
+                    time_amount = time.split(time[-1])[0]
+                    time_amount = int(time_amount)
+                except:
+                    return await message.reply_text("wrong format!!\nFormat: `/tmute 2m`")
+
+                if time[-1] == "m":
+                    mute_duration = datetime.timedelta(minutes=time_amount)
+                elif time[-1] == "h":
+                    mute_duration = datetime.timedelta(hours=time_amount)
+                elif time[-1] == "d":
+                    mute_duration = datetime.timedelta(days=time_amount)
+                else:
+                    return await message.reply_text("wrong format!!\nFormat:\nm: Minutes\nh: Hours\nd: Days")
+            except:
+                return await message.reply_text("Please specify a valid user or reply to that user's message\nFormat: `/tmute @user 2m`")
+
+    else:
+        await message.reply_text("Please specify a valid user or reply to that user's message\nFormat: /tmute <username> <time>")
+        return
+    
+    msg_text, result = await mute_user(user_id, first_name, admin_id, admin_name, chat_id, reason=None, time=mute_duration)
+    if result == True:
+        await message.reply_text(msg_text)
+    if result == False:
+        await message.reply_text(msg_text)

SONALI/plugins/admins/callback.py

@@ -0,0 +1,423 @@
+import asyncio
+
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+
+from SONALI import YouTube, app
+from SONALI.core.call import RAUSHAN
+from SONALI.misc import SUDOERS, db
+from SONALI.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 SONALI.utils.decorators.language import languageCB
+from SONALI.utils.formatters import seconds_to_min
+from SONALI.utils.inline import (
+    close_markup,
+    stream_markup,
+    stream_markup_timer,
+    telegram_markup,
+    telegram_markup_timer,
+)
+from SONALI.utils.stream.autoclear import auto_clean
+from SONALI.utils.thumbnails import get_thumb
+from config import (
+    BANNED_USERS,
+    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 RAUSHAN.pause_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_2"].format(mention),
+        )
+    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 RAUSHAN.resume_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_4"].format(mention),
+        )
+    elif command == "Stop" or command == "End":
+        await CallbackQuery.answer()
+        await RAUSHAN.stop_stream(chat_id)
+        await set_loop(chat_id, 0)
+        await CallbackQuery.message.reply_text(
+            _["admin_5"].format(mention),
+        )
+    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
+                        ),
+                        
+                    )
+                    try:
+                        return await RAUSHAN.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
+                        ),
+                    )
+                    return await RAUSHAN.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),
+                    
+                )
+            try:
+                image = await YouTube.thumbnail(videoid, True)
+            except:
+                image = None
+            try:
+                await RAUSHAN.skip_stream(chat_id, link, video=status, image=image)
+            except:
+                return await CallbackQuery.message.reply_text(_["call_6"])
+            button = telegram_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 Exception:
+                try:
+                    file_path, direct = await YTB.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 RAUSHAN.skip_stream(chat_id, file_path, video=status, image=image)
+            except:
+                return await mystic.edit_text(_["call_6"])
+            button = stream_markup(_, videoid, 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 RAUSHAN.skip_stream(chat_id, videoid, video=status)
+            except:
+                return await CallbackQuery.message.reply_text(_["call_6"])
+            button = telegram_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 RAUSHAN.skip_stream(chat_id, queued, video=status, image=image)
+            except:
+                return await CallbackQuery.message.reply_text(_["call_6"])
+            if videoid == "telegram":
+                button = telegram_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(
+                        config.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 = telegram_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(
+                        config.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(_, videoid, 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(4):
+        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"]
+                    markup = playing[0]["markup"]
+                except:
+                    continue
+                try:
+                    check = wrong[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(
+                            _,
+                            playing[0]["vidid"],
+                            chat_id,
+                            seconds_to_min(playing[0]["played"]),
+                            playing[0]["dur"],
+                        )
+                        if markup == "stream"
+                        else telegram_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())

SONALI/plugins/admins/connection.py

@@ -0,0 +1,20 @@
+from pyrogram import filters 
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
+from pyrogram.enums import ChatMembersFilter
+from SONALI import app
+from SONALI.utils.database import connect_to_chat
+from SONALI.utils.decorators import AdminActual
+from config import BANNED_USERS
+
+
+@app.on_message(filters.command("connect") & filters.group & ~BANNED_USERS)
+async def auth(client, message: Message):
+    admin_ids = [ member.user.id async for member in app.get_chat_members(message.chat.id, filter=ChatMembersFilter.ADMINISTRATORS)]
+    if not message.from_user.id in admin_ids:
+        return 
+    user_id = message.from_user.id
+    chat_id = message.chat.id
+   # re = await connect_to_chat(message.from_user.id, message.chat.id)
+    
+    markup = InlineKeyboardMarkup([[InlineKeyboardButton("ᴄᴏɴɴᴇᴄᴛ ᴛᴏ ᴄʜᴀᴛ ", url=f"http://t.me/{app.username}?start=connect_{chat_id}")]])
+    await message.reply_text("ᴛᴀᴘ ᴛʜᴇ ғᴏʟʟᴏᴡɪɴɢ ʙᴜᴛᴛᴏɴ ᴛᴏ ᴄᴏɴɴᴇᴄᴛ ᴛᴏ ᴛʜɪs ᴄʜᴀᴛ ɪɴ ᴘᴍ", reply_markup = markup)

SONALI/plugins/admins/gmtag.py

@@ -0,0 +1,234 @@
+from SONALI 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ᴏɴᴀ ᴅɪɴ ᴍᴇɪɴ ᴋᴀʀ ʟᴇɴᴀ ᴀʙʜɪ sᴏ ᴊᴀᴏ..?? 🥲** ",
+           " **➠ ᴍᴜᴍᴍʏ ᴅᴇᴋʜᴏ ʏᴇ ᴀᴘɴᴇ ɢғ sᴇ ʙᴀᴀᴛ ᴋʀ ʀʜᴀ ʜ ʀᴀᴊᴀɪ ᴍᴇ ɢʜᴜs ᴋᴀʀ, sᴏ ɴᴀʜɪ ʀᴀʜᴀ 😜** ",
+           " **➠ ᴘᴀᴘᴀ ʏᴇ ᴅᴇᴋʜᴏ ᴀᴘɴᴇ ʙᴇᴛᴇ ᴋᴏ ʀᴀᴀᴛ ʙʜᴀʀ ᴘʜᴏɴᴇ ᴄʜᴀʟᴀ ʀʜᴀ ʜᴀɪ 🤭** ",
+           " **➠ ᴊᴀɴᴜ ᴀᴀᴊ ʀᴀᴀᴛ ᴋᴀ sᴄᴇɴᴇ ʙɴᴀ ʟᴇ..?? 🌠** ",
+           " **➠ ɢɴ sᴅ ᴛᴄ.. 🙂** ",
+           " **➠ ɢᴏᴏᴅ ɴɪɢʜᴛ sᴡᴇᴇᴛ ᴅʀᴇᴀᴍ ᴛᴀᴋᴇ ᴄᴀʀᴇ..?? ✨** ",
+           " **➠ ʀᴀᴀᴛ ʙʜᴜᴛ ʜᴏ ɢʏɪ ʜᴀɪ sᴏ ᴊᴀᴏ, ɢɴ..?? 🌌** ",
+           " **➠ ᴍᴜᴍᴍʏ ᴅᴇᴋʜᴏ 11 ʙᴀᴊɴᴇ ᴡᴀʟᴇ ʜᴀɪ ʏᴇ ᴀʙʜɪ ᴛᴀᴋ ᴘʜᴏɴᴇ ᴄʜᴀʟᴀ ʀʜᴀ ɴᴀʜɪ sᴏ ɴᴀʜɪ ʀʜᴀ 🕦** ",
+           " **➠ ᴋᴀʟ sᴜʙʜᴀ sᴄʜᴏᴏʟ ɴᴀʜɪ ᴊᴀɴᴀ ᴋʏᴀ, ᴊᴏ ᴀʙʜɪ ᴛᴀᴋ ᴊᴀɢ ʀʜᴇ ʜᴏ 🏫** ",
+           " **➠ ʙᴀʙᴜ, ɢᴏᴏᴅ ɴɪɢʜᴛ sᴅ ᴛᴄ..?? 😊** ",
+           " **➠ ᴀᴀᴊ ʙʜᴜᴛ ᴛʜᴀɴᴅ ʜᴀɪ, ᴀᴀʀᴀᴍ sᴇ ᴊᴀʟᴅɪ sᴏ ᴊᴀᴛɪ ʜᴏᴏɴ 🌼** ",
+           " **➠ ᴊᴀɴᴇᴍᴀɴ, ɢᴏᴏᴅ ɴɪɢʜᴛ 🌷** ",
+           " **➠ ᴍᴇ ᴊᴀ ʀᴀʜɪ sᴏɴᴇ, ɢɴ sᴅ ᴛᴄ 🏵️** ",
+           " **➠ ʜᴇʟʟᴏ ᴊɪ ɴᴀᴍᴀsᴛᴇ, ɢᴏᴏᴅ ɴɪɢʜᴛ 🍃** ",
+           " **➠ ʜᴇʏ, ʙᴀʙʏ ᴋᴋʀʜ..? sᴏɴᴀ ɴᴀʜɪ ʜᴀɪ ᴋʏᴀ ☃️** ",
+           " **➠ ɢᴏᴏᴅ ɴɪɢʜᴛ ᴊɪ, ʙʜᴜᴛ ʀᴀᴀᴛ ʜᴏ ɢʏɪ..? ⛄** ",
+           " **➠ ᴍᴇ ᴊᴀ ʀᴀʜɪ ʀᴏɴᴇ, ɪ ᴍᴇᴀɴ sᴏɴᴇ ɢᴏᴏᴅ ɴɪɢʜᴛ ᴊɪ 😁** ",
+           " **➠ ᴍᴀᴄʜʜᴀʟɪ ᴋᴏ ᴋᴇʜᴛᴇ ʜᴀɪ ғɪsʜ, ɢᴏᴏᴅ ɴɪɢʜᴛ ᴅᴇᴀʀ ᴍᴀᴛ ᴋʀɴᴀ ᴍɪss, ᴊᴀ ʀʜɪ sᴏɴᴇ 🌄** ",
+           " **➠ ɢᴏᴏᴅ ɴɪɢʜᴛ ʙʀɪɢʜᴛғᴜʟʟ ɴɪɢʜᴛ 🤭** ",
+           " **➠ ᴛʜᴇ ɴɪɢʜᴛ ʜᴀs ғᴀʟʟᴇɴ, ᴛʜᴇ ᴅᴀʏ ɪs ᴅᴏɴᴇ,, ᴛʜᴇ ᴍᴏᴏɴ ʜᴀs ᴛᴀᴋᴇɴ ᴛʜᴇ ᴘʟᴀᴄᴇ ᴏғ ᴛʜᴇ sᴜɴ... 😊** ",
+           " **➠ ᴍᴀʏ ᴀʟʟ ʏᴏᴜʀ ᴅʀᴇᴀᴍs ᴄᴏᴍᴇ ᴛʀᴜᴇ ❤️** ",
+           " **➠ ɢᴏᴏᴅ ɴɪɢʜᴛ sᴘʀɪɴᴋʟᴇs sᴡᴇᴇᴛ ᴅʀᴇᴀᴍ 💚** ",
+           " **➠ ɢᴏᴏᴅ ɴɪɢʜᴛ, ɴɪɴᴅ ᴀᴀ ʀʜɪ ʜᴀɪ 🥱** ",
+           " **➠ ᴅᴇᴀʀ ғʀɪᴇɴᴅ ɢᴏᴏᴅ ɴɪɢʜᴛ 💤** ",
+           " **➠ ʙᴀʙʏ ᴀᴀᴊ ʀᴀᴀᴛ ᴋᴀ sᴄᴇɴᴇ ʙɴᴀ ʟᴇ 🥰** ",
+           " **➠ ɪᴛɴɪ ʀᴀᴀᴛ ᴍᴇ ᴊᴀɢ ᴋᴀʀ ᴋʏᴀ ᴋᴀʀ ʀʜᴇ ʜᴏ sᴏɴᴀ ɴᴀʜɪ ʜᴀɪ ᴋʏᴀ 😜** ",
+           " **➠ ᴄʟᴏsᴇ ʏᴏᴜʀ ᴇʏᴇs sɴᴜɢɢʟᴇ ᴜᴘ ᴛɪɢʜᴛ,, ᴀɴᴅ ʀᴇᴍᴇᴍʙᴇʀ ᴛʜᴀᴛ ᴀɴɢ��ʟs, ᴡɪʟʟ ᴡᴀᴛᴄʜ ᴏᴠᴇʀ ʏᴏᴜ ᴛᴏɴɪɢʜᴛ... 💫** ",
+           ]
+
+VC_TAG = [ "**➠ ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ, ᴋᴇsᴇ ʜᴏ 🐱**",
+         "**➠ ɢᴍ, sᴜʙʜᴀ ʜᴏ ɢʏɪ ᴜᴛʜɴᴀ ɴᴀʜɪ ʜᴀɪ ᴋʏᴀ 🌤️**",
+         "**➠ ɢᴍ ʙᴀʙʏ, ᴄʜᴀɪ ᴘɪ ʟᴏ ☕**",
+         "**➠ ᴊᴀʟᴅɪ ᴜᴛʜᴏ, sᴄʜᴏᴏʟ ɴᴀʜɪ ᴊᴀɴᴀ ᴋʏᴀ 🏫**",
+         "**➠ ɢᴍ, ᴄʜᴜᴘ ᴄʜᴀᴘ ʙɪsᴛᴇʀ sᴇ ᴜᴛʜᴏ ᴠʀɴᴀ ᴘᴀɴɪ ᴅᴀʟ ᴅᴜɴɢɪ 🧊**",
+         "**➠ ʙᴀʙʏ ᴜᴛʜᴏ ᴀᴜʀ ᴊᴀʟᴅɪ ғʀᴇsʜ ʜᴏ ᴊᴀᴏ, ɴᴀsᴛᴀ ʀᴇᴀᴅʏ ʜᴀɪ 🫕**",
+         "**➠ ᴏғғɪᴄᴇ ɴᴀʜɪ ᴊᴀɴᴀ ᴋʏᴀ ᴊɪ ᴀᴀᴊ, ᴀʙʜɪ ᴛᴀᴋ ᴜᴛʜᴇ ɴᴀʜɪ 🏣**",
+         "**➠ ɢᴍ ᴅᴏsᴛ, ᴄᴏғғᴇᴇ/ᴛᴇᴀ ᴋʏᴀ ʟᴏɢᴇ ☕🍵**",
+         "**➠ ʙᴀʙʏ 8 ʙᴀᴊɴᴇ ᴡᴀʟᴇ ʜᴀɪ, ᴀᴜʀ ᴛᴜᴍ ᴀʙʜɪ ᴛᴋ ᴜᴛʜᴇ ɴᴀʜɪ 🕖**",
+         "**➠ ᴋʜᴜᴍʙʜᴋᴀʀᴀɴ ᴋɪ ᴀᴜʟᴀᴅ ᴜᴛʜ ᴊᴀᴀ... ☃️**",
+         "**➠ ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ʜᴀᴠᴇ ᴀ ɴɪᴄᴇ ᴅᴀʏ... 🌄**",
+         "**➠ ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ, ʜᴀᴠᴇ ᴀ ɢᴏᴏᴅ ᴅᴀʏ... 🪴**",
+         "**➠ ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ, ʜᴏᴡ ᴀʀᴇ ʏᴏᴜ ʙᴀʙʏ 😇**",
+         "**➠ ᴍᴜᴍᴍʏ ᴅᴇᴋʜᴏ ʏᴇ ɴᴀʟᴀʏᴋ ᴀʙʜɪ ᴛᴀᴋ sᴏ ʀʜᴀ ʜᴀɪ... 😵‍💫**",
+         "**➠ ʀᴀᴀᴛ ʙʜᴀʀ ʙᴀʙᴜ sᴏɴᴀ ᴋʀ ʀʜᴇ ᴛʜᴇ ᴋʏᴀ, ᴊᴏ ᴀʙʜɪ ᴛᴋ sᴏ ʀʜᴇ ʜᴏ ᴜᴛʜɴᴀ ɴᴀʜɪ ʜᴀɪ ᴋʏᴀ... 😏**",
+         "**➠ ʙᴀʙᴜ ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ᴜᴛʜ ᴊᴀᴏ ᴀᴜʀ ɢʀᴏᴜᴘ ᴍᴇ sᴀʙ ғʀɪᴇɴᴅs ᴋᴏ ɢᴍ ᴡɪsʜ ᴋʀᴏ... 🌟**",
+         "**➠ ᴘᴀᴘᴀ ʏᴇ ᴀʙʜɪ ᴛᴀᴋ ᴜᴛʜ ɴᴀʜɪ, sᴄʜᴏᴏʟ ᴋᴀ ᴛɪᴍᴇ ɴɪᴋᴀʟᴛᴀ ᴊᴀ ʀʜᴀ ʜᴀɪ... 🥲**",
+         "**➠ ᴊᴀɴᴇᴍᴀɴ ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ, ᴋʏᴀ ᴋʀ ʀʜᴇ ʜᴏ ... 😅**",
+         "**➠ ɢᴍ ʙᴇᴀsᴛɪᴇ, ʙʀᴇᴀᴋғᴀsᴛ ʜᴜᴀ ᴋʏᴀ... 🍳**",
+        ]
+
+
+@app.on_message(filters.command(["gntag", "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(["gmtag"], 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(["gmstop", "gnstop", "cancle"]))
+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ᴛᴏᴘᴘᴇᴅ sᴜᴄᴄᴇssғᴜʟʟʏ ๏")
+
+

SONALI/plugins/admins/hitag.py

@@ -0,0 +1,342 @@
+from SONALI 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 = [ " **❅ बेबी कहा हो। 🤗** ",
+           " **❅ ओए सो गए क्या, ऑनलाइन आओ ।😊** ",
+           " **❅ ओए वीसी आओ बात करते हैं । 😃** ",
+           " **❅ खाना खाया कि नही। 🥲** ",
+           " **❅ घर में सब कैसे हैं। 🥺** ",
+           " **❅ पता है बहुत याद आ रही आपकी। 🤭** ",
+           " **❅ और बताओ कैसे हो।..?? 🤨** ",
+           " **❅ मेरी भी सैटिंग करवा दो प्लीज..?? 🙂** ",
+           " **❅ आपका नाम क्या है।..?? 🥲** ",
+           " **❅ नाश्ता हो गया..?? 😋** ",
+           " **❅ मुझे अपने ग्रूप में ऐड कर लो। 😍** ",
+           " **❅ आपका दोस्त आपको बुला रहा है। 😅** ",
+           " **❅ मुझसे शादी करोगे ..?? 🤔** ",
+           " **❅ सोने चले गए क्या 🙄** ",
+           " **❅ अरे यार कोई AC चला दो 😕** ",
+           " **❅ आप कहा से हो..?? 🙃** ",
+           " **❅ हेलो जी नमस्ते 😛** ",
+           " **❅ BABY क्या कर रही हो..? 🤔** ",
+           " **❅ क्या आप मुझे जानते हो .? ☺️** ",
+           " **❅ आओ baby Ludo खेलते है .🤗** ",
+           " **❅ चलती है क्या 9 से 12... 😇** ",
+           " **❅ आपके पापा क्या करते है 🤭** ",
+           " **❅ आओ baby बाजार चलते है गोलगप्पे खाने। 🥺** ",
+           " **❅ अकेली ना बाजार जाया करो, नज़र लग जायेगी। 😶** ",
+           " **❅ और बताओ BF कैसा है ..?? 🤔** ",
+           " **❅ गुड मॉर्निंग 😜** ",
+           " **❅ मेरा एक काम करोगे। 🙂** ",
+           " **❅ DJ वाले बाबू मेरा गाना चला दो। 😪** ",
+           " **❅ आप से मिलकर अच्छा लगा।☺** ",
+           " **❅ मेरे बाबू ने थाना थाया।..? 🙊** ",
+           " **❅ पढ़ाई कैसी चल रही हैं ? 😺** ",
+           " **❅ हम को प्यार हुआ। 🥲** ",
+           " **❅ Nykaa कौन है...? 😅** ",
+           " **❅ तू खींच मेरी फ़ोटो ..? 😅** ",
+           " **❅ Phone काट मम्मी आ गई क्या। 😆** ",
+           " **❅ और भाबी से कब मिल वा रहे हो । 😉** ",
+           " **❅ क्या आप मुझसे प्यार करते हो 💚** ",
+           " **❅ मैं तुम से बहुत प्यार करती हूं..? 👀** ",
+           " **❅ बेबी एक kiss दो ना..?? 🙉** ",
+           " **❅ एक जॉक सुनाऊं..? 😹** ",
+           " **❅ vc पर आओ कुछ दिखाती हूं  😻** ",
+           " **❅ क्या तुम instagram चलते हो..?? 🙃** ",
+           " **❅ whatsapp नंबर दो ना अपना..? 😕** ",
+           " **❅ आप की दोस्त से मेरी सेटिंग करा दो ..? 🙃** ",
+           " **❅ सारा काम हो गया हो तो ऑनलाइन आ जाओ।..? 🙃** ",
+           " **❅ कहा से हो आप 😊** ",
+           " **❅ जा तुझे आज़ाद कर दिया मैंने मेरे दिल से। 🥺** ",
+           " **❅ मेरा एक काम करोगे, ग्रूप मे कुछ मेंबर ऐड कर दो ..? ♥️** ",
+           " **❅ मैं तुमसे नाराज़ हूं 😠** ",
+           " **❅ आपकी फैमिली कैसी है..? ❤** ",
+           " **❅ क्या हुआ..? 🤔** ",
+           " **❅ बहुत याद आ रही है आपकी 😒** ",
+           " **❅ भूल गए मुझे 😏** ",
+           " **❅ झूठ क्यों बोला आपने मुझसे 🤐** ",
+           " **❅ इतना भाव मत खाया करो, रोटी खाया करो कम से कम मोटी तो हो जाओगी 😒** ",
+           " **❅ ये attitude किसे दिखा रहे हो 😮** ",
+           " **❅ हेमलो कहा busy ho 👀** ",
+           " **❅ आपके जैसा दोस्त पाकर मे बहुत खुश हूं। 🙈** ",
+           " **❅ आज मन बहुत उदास है ☹️** ",
+           " **❅ मुझसे भी बात कर लो ना 🥺** ",
+           " **❅ आज खाने में क्या बनाया है 👀** ",
+           " **❅ क्या चल रहा है 🙂** ",
+           " **❅ message क्यों नहीं करती हो..🥺** ",
+           " **❅ मैं मासूम हूं ना 🥺** ",
+           " **❅ कल मज़ा आया था ना 😅** ",
+           " **❅ कल कहा busy थे 😕** ",
+           " **❅ आप relationship में हो क्या..? 👀** ",
+           " **❅ कितने शांत रहते हो यार आप 😼** ",
+           " **❅ आपको गाना, गाना आता है..? 😸** ",
+           " **❅ घूमने चलोगे मेरे साथ..?? 🙈** ",
+           " **❅ हमेशा हैप्पी रहा करो यार 🤞** ",
+           " **❅ क्या हम दोस्त बन सकते है...? 🥰** ",
+           " **❅ आप का विवाह हो गया क्या.. 🥺** ",
+           " **❅ कहा busy the इतने दिनों से 🥲** ",
+           " **❅ single हो या mingle 😉** ",
+           " **❅ आओ पार्टी करते है 🥳** ",
+           " **❅ join कर लो @WORLD_ALPHA 🧐** ",
+           " **❅ मैं तुमसे प्यार नहीं करती, 🥺** ",
+           " **❅ यहां आ जाओ ना @PURVI_SUPPORT मस्ती करेंगे 🤭** ",
+           " **❅ भूल जाओ मुझे,..? 😊** ",
+           " **❅ अपना बना ले पिया, अपना बना ले 🥺** ",
+           " **❅ मेरा ग्रुप भी join कर लो ना 🤗** ",
+           " **❅ मैने तेरा नाम Dil rakh diya 😗** ",
+           " **❅ तुमारे सारे दोस्त कहा गए 🥺** ",
+           " **❅ my cute owner @ll_ALPHA_BABY_lll 🥰** ",
+           " **❅ किसकी याद मे खोए हो जान 😜** ",
+           " **❅ गुड नाईट जी बहुत रात हो गई 🥰** ",
+           ]
+
+VC_TAG = [ "**❅ ɪғ ʏᴏᴜ ᴅᴏ ɴᴏᴛ sᴛᴇᴘ ғᴏʀᴡᴀʀᴅ ʏᴏᴜ ᴡɪʟʟ ʀᴇᴍᴀɪɴ ɪɴ ᴛʜᴇ sᴀᴍᴇ ᴘʟᴀᴄᴇ.**",
+         "**❅ ʟɪғᴇ ɪs ʜᴀʀᴅ ʙᴜᴛ ɴᴏᴛ ɪᴍᴘᴏssɪʙʟᴇ.**",
+         "**❅ ʟɪғᴇ’s ᴛᴏᴏ sʜᴏʀᴛ ᴛᴏ ᴀʀɢᴜᴇ ᴀɴᴅ ғɪɢʜᴛ.**",
+         "**❅ ᴅᴏɴ’ᴛ ᴡᴀɪᴛ ғᴏʀ ᴛʜᴇ ᴘᴇʀғᴇᴄᴛ ᴍᴏᴍᴇɴᴛ ᴛᴀᴋᴇ ᴍᴏᴍᴇɴᴛ ᴀɴᴅ ᴍᴀᴋᴇ ɪᴛ ᴘᴇʀғᴇᴄᴛ.**",
+         "**❅ sɪʟᴇɴᴄᴇ ɪs ᴛʜᴇ ʙᴇsᴛ ᴀɴsᴡᴇʀ ᴛᴏ sᴏᴍᴇᴏɴᴇ ᴡʜᴏ ᴅᴏᴇsɴ’ᴛ ᴠᴀʟᴜᴇ ʏᴏᴜʀ ᴡᴏʀᴅs.**",
+         "**❅ ᴇᴠᴇʀʏ ɴᴇᴡ ᴅᴀʏ ɪs ᴀ ᴄʜᴀɴᴄᴇ ᴛᴏ ᴄʜᴀɴɢᴇ ʏᴏᴜʀ ʟɪғᴇ.**",
+         "**❅ ᴛᴏ ᴄʜᴀɴɢᴇ ʏᴏᴜʀ ʟɪғᴇ, ʏᴏᴜ ɴᴇᴇᴅ ᴛᴏ ᴄʜᴀɴɢᴇ ʏᴏᴜʀ ᴘʀɪᴏʀɪᴛɪᴇs.**",
+         "**❅ ʟɪғᴇ ɪs ᴀ ᴊᴏᴜʀɴᴇʏ, ɴᴏᴛ ᴀ ʀᴀᴄᴇ..**",
+         "**❅ sᴍɪʟᴇ ᴀɴᴅ ᴅᴏɴ’ᴛ ᴡᴏʀʀʏ, ʟɪғᴇ ɪs ᴀᴡᴇsᴏᴍᴇ.**",
+         "**❅ ᴅᴏ ɴᴏᴛ ᴄᴏᴍᴘᴀʀᴇ ʏᴏᴜʀsᴇʟғ ᴛᴏ ᴏᴛʜᴇʀs ɪғ ʏᴏᴜ ᴅᴏ sᴏ ʏᴏᴜ ᴀʀᴇ ɪɴsᴜʟᴛɪɴɢ ʏᴏᴜʀsᴇʟғ.**",
+         "**❅ ɪ ᴀᴍ ɪɴ ᴛʜᴇ ᴘʀᴏᴄᴇss ᴏғ ʙᴇᴄᴏᴍɪɴɢ ᴛʜᴇ ʙᴇsᴛ ᴠᴇʀsɪᴏɴ ᴏғ ᴍʏsᴇʟғ.**",
+         "**❅ ʟɪғᴇ ɪs ʟɪᴋᴇ ɪᴄᴇ ᴇɴᴊᴏʏ ɪᴛ ʙᴇғᴏʀᴇ ɪᴛ ᴍᴇʟᴛs.**",
+         "**❅ ʙᴇ ғʀᴇᴇ ʟɪᴋᴇ ᴀ ʙɪʀᴅ.**",
+         "**❅ ɴᴏ ᴏɴᴇ ɪs ᴄᴏᴍɪɴɢ ᴛᴏ sᴀᴠᴇ ʏᴏᴜ. ᴛʜɪs ʟɪғᴇ ᴏғ ʏᴏᴜʀ ɪs 100% ʏᴏᴜʀ ʀᴇsᴘᴏɴsɪʙɪʟɪᴛʏ..**",
+         "**❅ ʟɪғᴇ ᴀʟᴡᴀʏs ᴏғғᴇʀs ʏᴏᴜ ᴀ sᴇᴄᴏɴᴅ ᴄʜᴀɴᴄᴇ. ɪᴛ’s ᴄᴀʟʟᴇᴅ ᴛᴏᴍᴏʀʀᴏᴡ.**",
+         "**❅ ʟɪғᴇ ʙᴇɢɪɴs ᴀᴛ ᴛʜᴇ ᴇɴᴅ ᴏғ ʏᴏᴜʀ ᴄᴏᴍғᴏʀᴛ ᴢᴏɴᴇ.**",
+         "**❅ ᴀʟʟ ᴛʜᴇ ᴛʜɪɴɢs ᴛʜᴀᴛ ʜᴜʀᴛ ʏᴏᴜ, ᴀᴄᴛᴜᴀʟʟʏ ᴛᴇᴀᴄʜ ʏᴏᴜ.**",
+         "**❅ ʟɪғᴇ ɪs ʟɪᴋᴇ ᴀ ᴄᴀᴍᴇʀᴀ. sᴏ ғᴀᴄᴇ ɪᴛ ᴡɪᴛʜ ᴀ sᴍɪʟᴇ.**",
+         "**❅ ʟɪғᴇ ɪs 10% ᴏғ ᴡʜᴀᴛ ʜᴀᴘᴘᴇɴs ᴛᴏ ʏᴏᴜ ᴀɴᴅ 90% ᴏғ ʜᴏᴡ ʏᴏᴜ ʀᴇsᴘᴏɴᴅ ᴛᴏ ɪᴛ.**",
+         "**❅ ʟɪғᴇ ᴀʟᴡᴀʏs ᴏғғᴇʀs ʏᴏᴜ ᴀ sᴇᴄᴏɴᴅ ᴄʜᴀɴᴄᴇ. ɪᴛ’s ᴄᴀʟʟᴇᴅ ᴛᴏᴍᴏʀʀᴏᴡ.**",
+         "**❅ ɴᴏ ᴏɴᴇ ɪs ᴄᴏᴍɪɴɢ ᴛᴏ sᴀᴠᴇ ʏᴏᴜ. ᴛʜɪs ʟɪғᴇ ᴏғ ʏᴏᴜʀ ɪs 100% ʏᴏᴜʀ ʀᴇsᴘᴏɴsɪʙɪʟɪᴛʏ..**",
+         "**❅ ʟɪғᴇ ɪs ɴᴏᴛ ᴀɴ ᴇᴀsʏ ᴛᴀsᴋ.**",
+         "**❅ ʟɪғᴇ ɪs ᴀ ᴡᴏɴᴅᴇʀғᴜʟ ᴀᴅᴠᴇɴᴛᴜʀᴇ.**",
+         "**❅ ʟɪғᴇ ʙᴇɢɪɴs ᴏɴ ᴛʜᴇ ᴏᴛʜᴇʀ sɪᴅᴇ ᴏғ ᴅᴇsᴘᴀɪʀ.**",
+         "**❅ ʟɪғᴇ ɪs ɴᴏᴛ ᴀ ᴘʀᴏʙʟᴇᴍ ᴛᴏ ʙᴇ sᴏʟᴠᴇᴅ ʙᴜᴛ ᴀ ʀᴇᴀʟɪᴛʏ ᴛᴏ ʙᴇ ᴇxᴘᴇʀɪᴇɴᴄᴇᴅ.**",
+         "**❅ ʟɪғᴇ ᴅᴏᴇs ɴᴏᴛ ʜᴀᴠᴇ ᴀ ʀᴇᴍᴏᴛᴇ; ɢᴇᴛ ᴜᴘ ᴀɴᴅ ᴄʜᴀɴɢᴇ ɪᴛ ʏᴏᴜʀsᴇʟғ.**",
+         "**❅ sᴛᴀʀᴛ ᴛʀᴜsᴛɪɴɢ ʏᴏᴜʀsᴇʟғ, ᴀɴᴅ ʏᴏᴜ’ʟʟ ᴋɴᴏᴡ ʜᴏᴡ ᴛᴏ ʟɪᴠᴇ.**",
+         "**❅ ʜᴇᴀʟᴛʜ ɪs ᴛʜᴇ ᴍᴏsᴛ ɪᴍᴘᴏʀᴛᴀɴᴛ ɢᴏᴏᴅ ᴏғ ʟɪғᴇ.**",
+         "**❅ ᴛɪᴍᴇ ᴄʜᴀɴɢᴇ ᴘʀɪᴏʀɪᴛʏ ᴄʜᴀɴɢᴇs.**",
+         "**❅ ᴛᴏ sᴇᴇ ᴀɴᴅ ᴛᴏ ғᴇᴇʟ ᴍᴇᴀɴs ᴛᴏ ʙᴇ, ᴛʜɪɴᴋ ᴀɴᴅ ʟɪᴠᴇ.**",
+         "**❅ ʙᴇ ᴡɪᴛʜ sᴏᴍᴇᴏɴᴇ ᴡʜᴏ ʙʀɪɴɢ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 ɴᴏᴛʜɪɴɢ ᴍᴏʀᴇ ᴇxᴄɪᴛɪɴɢ ɪɴ ᴛʜᴇ ᴡᴏʀʟᴅ, ʙᴜᴛ ᴘᴇᴏᴘʟᴇ.**",
+         "**❅ ʏᴏᴜ ᴄᴀɴ ᴅᴏ ᴀɴʏᴛʜɪɴɢ, ʙᴜᴛ ɴᴏᴛ ᴇᴠᴇʀʏᴛʜɪɴɢ.**",
+         "**❅ ʟɪғᴇ ʙᴇᴄᴏᴍᴇ ᴇᴀsʏ ᴡʜᴇɴ ʏᴏᴜ ʙᴇᴄᴏᴍᴇ sᴛʀᴏɴɢ.**",
+         "**❅ ᴍʏ ʟɪғᴇ ɪsɴ’ᴛ ᴘᴇʀғᴇᴄᴛ ʙᴜᴛ ɪᴛ ᴅᴏᴇs ʜᴀᴠᴇ ᴘᴇʀғᴇᴄᴛ ᴍᴏᴍᴇɴᴛs.**",
+         "**❅ ʟɪғᴇ ɪs ɢᴏᴅ’s ɴᴏᴠᴇʟ. ʟᴇᴛ ʜɪᴍ ᴡʀɪᴛᴇ ɪᴛ.**",
+         "**❅ ᴏᴜʀ ʟɪғᴇ ɪs ᴀ ʀᴇsᴜʟᴛ ᴏғ ᴏᴜʀ ᴅᴏᴍɪɴᴀɴᴛ ᴛʜᴏᴜɢʜᴛs.**",
+         "**❅ ʟɪғᴇ ɪs ᴀ ᴍᴏᴛɪᴏɴ ғʀᴏᴍ ᴀ ᴅᴇsɪʀᴇ ᴛᴏ ᴀɴᴏᴛʜᴇʀ ᴅᴇsɪʀᴇ.**",
+         "**❅ ᴛᴏ ʟɪᴠᴇ ᴍᴇᴀɴs ᴛᴏ ғɪɢʜᴛ.**",
+         "**❅ ʟɪғᴇ ɪs ʟɪᴋᴇ ᴀ ᴍᴏᴜɴᴛᴀɪɴ, ɴᴏᴛ ᴀ ʙᴇᴀᴄʜ.**",
+         "**❅ ᴛʜᴇ ᴡᴏʀsᴛ ᴛʜɪɴɢ ɪɴ ʟɪғᴇ ɪs ᴛʜᴀᴛ ɪᴛ ᴘᴀssᴇs.**",
+         "**❅ ʟɪғᴇ ɪs sɪᴍᴘʟᴇ ɪғ ᴡᴇ ᴀʀᴇ sɪᴍᴘʟᴇ.**",
+         "**❅ ᴀʟᴡᴀʏs ᴛʜɪɴᴋ ᴛᴡɪᴄᴇ, sᴘᴇᴀᴋ ᴏɴᴄᴇ.**",
+         "**❅ ʟɪғᴇ ɪs sɪᴍᴘʟᴇ, ᴡᴇ ᴍᴀᴋᴇ ɪᴛ ᴄᴏᴍᴘʟɪᴄᴀᴛᴇᴅ.**",
+         "**❅ ʟɪғᴇ ɪs ɴᴏᴛ ᴍᴜᴄʜ ᴏʟᴅᴇʀ ᴛʜᴀɴ ᴛʜᴇ ᴅᴇᴀᴛʜ.**",
+         "**❅ ᴛʜᴇ sᴇᴄʀᴇᴛ ᴏғ ʟɪғᴇ ɪs ʟᴏᴡ ᴇxᴘᴇᴄᴛᴀᴛɪᴏɴs!**",
+         "**❅ ʟɪғᴇ ɪs ᴀ ᴛᴇᴀᴄʜᴇʀ..,ᴛʜᴇ ᴍᴏʀᴇ ᴡᴇ ʟɪᴠᴇ, ᴛʜᴇ ᴍᴏʀᴇ ᴡᴇ ʟᴇᴀʀɴ.**",
+         "**❅ ʜᴜᴍᴀɴ ʟɪғᴇ ɪs ɴᴏᴛʜɪɴɢ ʙᴜᴛ ᴀɴ ᴇᴛᴇʀɴᴀʟ ɪʟʟᴜsɪᴏɴ.**",
+         "**❅ ᴛʜᴇ ʜᴀᴘᴘɪᴇʀ ᴛʜᴇ ᴛɪᴍᴇ, ᴛʜᴇ sʜᴏʀᴛᴇʀ ɪᴛ ɪs.**",
+         "**❅ ʟɪғᴇ ɪs ʙᴇᴀᴜᴛɪғᴜʟ ɪғ ʏᴏᴜ  ᴋɴᴏᴡ ᴡʜᴇʀᴇ ᴛᴏ ʟᴏᴏᴋ.**",
+         "**❅ ʟɪғᴇ ɪs ᴀᴡᴇsᴏᴍᴇ ᴡɪᴛʜ ʏᴏᴜ ʙʏ ᴍʏ sɪᴅᴇ.**",
+         "**❅ ʟɪғᴇ – ʟᴏᴠᴇ = ᴢᴇʀᴏ**",
+         "**❅ ʟɪғᴇ ɪs ғᴜʟʟ ᴏғ sᴛʀᴜɢɢʟᴇs.**",
+         "**❅ ɪ ɢᴏᴛ ʟᴇss ʙᴜᴛ ɪ ɢᴏᴛ ʙᴇsᴛ **",
+         "**❅ ʟɪғᴇ ɪs 10% ᴡʜᴀᴛ ʏᴏᴜ ᴍᴀᴋᴇ ɪᴛ, ᴀɴᴅ 90% ʜᴏᴡ ʏᴏᴜ ᴛᴀᴋᴇ ɪᴛ.**",
+         "**❅ ᴛʜᴇʀᴇ ɪs sᴛɪʟʟ sᴏ ᴍᴜᴄʜ ᴛᴏ sᴇᴇ**",
+         "**❅ ʟɪғᴇ ᴅᴏᴇsɴ’ᴛ ɢᴇᴛ ᴇᴀsɪᴇʀ ʏᴏᴜ ɢᴇᴛ sᴛʀᴏɴɢᴇʀ.**",
+         "**❅ ʟɪғᴇ ɪs ᴀʙᴏᴜᴛ ʟᴀᴜɢʜɪɴɢ & ʟɪᴠɪɴɢ.**",
+         "**❅ ᴇᴀᴄʜ ᴘᴇʀsᴏɴ ᴅɪᴇs ᴡʜᴇɴ ʜɪs ᴛɪᴍᴇ ᴄᴏᴍᴇs.**",
+        ]
+
+
+@app.on_message(filters.command(["hitag" ], 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("/hitag ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ᴛʏᴘᴇ ʟɪᴋᴇ ᴛʜɪ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("/hitag ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ᴛʏᴘᴇ ʟɪᴋᴇ ᴛʜɪs / ʀᴇᴘʟʏ ᴀɴʏ ᴍᴇssᴀɢᴇ ɴᴇxᴛ ᴛɪᴍᴇ ғᴏᴛ ᴛᴀɢɢɪɴɢ...")
+    else:
+        return await message.reply("/hitag ɢᴏᴏᴅ ᴍᴏʀɴɪɴɢ ᴛʏᴘᴇ ʟɪᴋᴇ ᴛʜɪ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(["lifetag"], 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", "histop", "lifestop"]))
+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ᴛᴏᴘᴘᴇᴅ sᴜᴄᴄᴇssғᴜʟʟʏ ๏")

SONALI/plugins/admins/loop.py

@@ -0,0 +1,46 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from SONALI import app
+from SONALI.utils.database import get_loop, set_loop
+from SONALI.utils.decorators import AdminRightsCheck
+from SONALI.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)

SONALI/plugins/admins/mention.py

@@ -0,0 +1,69 @@
+import asyncio
+from pyrogram.enums import ChatType, ChatMemberStatus
+from SONALI import app
+from pyrogram import filters
+from SONALI.utils.RAUSHAN_ban import admin_filter
+
+
+
+SPAM_CHATS = []
+
+
+@app.on_message(filters.command(["mention", "all"]) & filters.group & admin_filter)
+async def tag_all_users(_,message): 
+    replied = message.reply_to_message  
+    if len(message.command) < 2 and not replied:
+        await message.reply_text("**ʀᴇᴘʟʏ ᴛᴏ ᴀ ᴍᴇssᴀɢᴇ ᴏʀ ɢɪᴠᴇ sᴏᴍᴇ ᴛᴇxᴛ ᴛᴏ ᴛᴀɢ ᴀʟʟ**") 
+        return                  
+    if replied:
+        SPAM_CHATS.append(message.chat.id)      
+        usernum= 0
+        usertxt = ""
+        async for m in app.get_chat_members(message.chat.id): 
+            if message.chat.id not in SPAM_CHATS:
+                break       
+            usernum += 5
+            usertxt += f"\n⊚ [{m.user.first_name}](tg://user?id={m.user.id})\n"
+            if usernum == 1:
+                await replied.reply_text(usertxt)
+                await asyncio.sleep(2)
+                usernum = 0
+                usertxt = ""
+        try :
+            SPAM_CHATS.remove(message.chat.id)
+        except Exception:
+            pass
+    else:
+        text = message.text.split(None, 1)[1]
+        
+        SPAM_CHATS.append(message.chat.id)
+        usernum= 0
+        usertxt = ""
+        async for m in app.get_chat_members(message.chat.id):       
+            if message.chat.id not in SPAM_CHATS:
+                break 
+            usernum += 1
+            usertxt += f"\n⊚ [{m.user.first_name}](tg://user?id={m.user.id})\n"
+            if usernum == 5:
+                await app.send_message(message.chat.id,f'{text}\n{usertxt}\n\n|| ➥ ᴏғғ ᴛᴀɢɢɪɴɢ ʙʏ » /alloff ||')
+                await asyncio.sleep(2)
+                usernum = 0
+                usertxt = ""                          
+        try :
+            SPAM_CHATS.remove(message.chat.id)
+        except Exception:
+            pass        
+           
+@app.on_message(filters.command("alloff") & ~filters.private)
+async def cancelcmd(_, message):
+    chat_id = message.chat.id
+    if chat_id in SPAM_CHATS:
+        try :
+            SPAM_CHATS.remove(chat_id)
+        except Exception:
+            pass   
+        return await message.reply_text("**ᴛᴀɢ ᴀʟʟ sᴜᴄᴄᴇssғᴜʟʟʏ sᴛᴏᴘᴘᴇᴅ!**")     
+                                     
+    else :
+        await message.reply_text("**ɴᴏ ᴘʀᴏᴄᴇss ᴏɴɢᴏɪɴɢ!**")  
+        return       

SONALI/plugins/admins/pause.py

@@ -0,0 +1,21 @@
+from pyrogram import filters
+from pyrogram.types import Message
+
+from SONALI import app
+from SONALI.core.call import RAUSHAN
+from SONALI.utils.database import is_music_playing, music_off
+from SONALI.utils.decorators import AdminRightsCheck
+from SONALI.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 RAUSHAN.pause_stream(chat_id)
+    await message.reply_text(
+        _["admin_2"].format(message.from_user.mention), reply_markup=close_markup(_)
+    )