Initial commit

.dockerignore

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

.github/readme.md

@@ -0,0 +1 @@
+.

.github/workflows/build.yml

@@ -0,0 +1,11 @@
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      GIT_PYTHON_REFRESH: 'quiet'
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Run your script
+        run: |
+          # Your commands here

.github/workflows/main.yml

@@ -0,0 +1,47 @@
+name: CI
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Install Git
+        run: sudo apt-get install -y git
+
+      - name: Install Heroku CLI
+        run: |
+          curl https://cli-assets.heroku.com/install.sh | sh
+          heroku --version
+
+      - name: Setup Git for Heroku Deployment
+        run: |
+          git config --global user.name "devineparadox"
+          git config --global user.email "[email protected]"
+        
+      - name: Pull latest changes
+        run: |
+          git pull origin main
+
+      - name: Commit changes
+        run: |
+          git add .
+          git commit -m "Automated commit for redeployment" || echo "No changes to commit"
+
+      - name: Push changes to Heroku
+        env:
+          HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }}
+        run: |
+          git push heroku main
+
+      - name: Restart Heroku app
+        run: |
+          heroku restart --app ${{ secrets.HEROKU_APP_NAME }}
+
+      - name: Verify deployment
+        run: |
+          heroku logs --tail --app ${{ secrets.HEROKU_APP_NAME }}

.github/workflows/youtube_download.yml

@@ -0,0 +1,27 @@
+name: YouTube Download
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+
+jobs:
+  download:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Install yt-dlp
+        run: |
+          sudo pip install yt-dlp
+
+      - name: Create cookies.txt from secret
+        run: |
+          echo "${{ secrets.COOKIES }}" > cookies.txt
+
+      - name: Download YouTube Video
+        run: |
+          yt-dlp --cookies cookies.txt "https://www.youtube.com/watch?v=zzwRbKI2pn4"

.gitignore

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

.nixpacks.yml

@@ -0,0 +1,4 @@
+version: '1'
+language: node
+nodejs:
+  version: 16

Devine/__init__.py

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

Devine/__main__.py

@@ -0,0 +1,74 @@
+import asyncio
+import importlib
+
+from pyrogram import idle
+from pytgcalls.exceptions import NoActiveGroupCall
+
+import config
+from Devine import LOGGER, app, userbot
+from Devine.core.call import Anony
+from Devine.misc import sudo
+from Devine.plugins import ALL_MODULES
+from Devine.utils.database import get_banned_users, get_gbanned
+from config import BANNED_USERS
+
+# Import redeploy command (relative import, considering the repo structure)
+import sys
+sys.path.append("..")  # Add the parent directory to the Python path
+from redeploy import redeploy  # Now the redeploy.py can be imported
+
+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("Assistant client variables not defined, exiting...")
+        return  # Changed from exit() to return
+    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 Exception as e:
+        LOGGER(__name__).error(f"Error fetching banned users: {e}")
+    await app.start()
+    for all_module in ALL_MODULES:
+        importlib.import_module("Devine.plugins" + all_module)
+    LOGGER("Devine.plugins").info("Successfully Imported Modules...")
+    await userbot.start()
+    await Anony.start()
+    try:
+        await Anony.stream_call("https://telegra.ph//file/1df0320b93c2f3353c3e6.mp4")
+    except NoActiveGroupCall:
+        LOGGER("Devine").error(
+            "Please turn on the video chat of your log group/channel.\n\nStopping Bot..."
+        )
+        return  # Changed from exit() to return
+    except Exception as e:
+        LOGGER("Devine").error(f"Error in streaming call: {e}")
+    await Anony.decorators()
+    LOGGER("Devine").info(
+        "Powered by @Devine_network."
+    )
+    await idle()  # Keeps the bot running
+    await shutdown()  # Proper shutdown sequence
+
+
+async def shutdown():
+    LOGGER("Devine").info("Shutting down gracefully...")
+    try:
+        await app.stop()
+        await userbot.stop()
+        LOGGER("Devine").info("Stopping AnonX Music Bot...")
+    except Exception as e:
+        LOGGER("Devine").error(f"Error during shutdown: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(init())

Devine/core/bot.py

@@ -0,0 +1,57 @@
+from pyrogram import Client, errors
+from pyrogram.enums import ChatMemberStatus, ParseMode
+
+import config
+
+from ..logging import LOGGER
+
+
+class Anony(Client):
+    def __init__(self):
+        LOGGER(__name__).info(f"Starting Bot...")
+        super().__init__(
+            name="Devine",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            bot_token=config.BOT_TOKEN,
+            in_memory=True,
+            parse_mode=ParseMode.HTML,
+            max_concurrent_transmissions=7,
+        )
+
+    async def start(self):
+        await super().start()
+        self.id = self.me.id
+        self.name = self.me.first_name + " " + (self.me.last_name or "")
+        self.username = self.me.username
+        self.mention = self.me.mention
+
+        try:
+            await self.send_message(
+                chat_id=config.LOGGER_ID,
+                text=f"<b>{self.mention} ɪs ᴀʟɪᴠᴇ <a href='https://telegra.ph//file/db4ac98cf05117a23561c.jpg' target='_blank'>🫧</a></b>\n\n"
+                         f"<b>• ʙᴏᴛ ᴠᴇʀsɪᴏɴ ⌯</b> <code>𝟸.𝟷 ʀx</code>\n"
+                         f"<b>• ᴘʏᴛʜᴏɴ ᴠᴇʀsɪᴏɴ ⌯</b> <code>𝟹.𝟷𝟶.𝟷𝟷</code>\n"
+                         f"<b>• ᴘʏʀᴏɢʀᴀᴍ ᴠᴇʀsɪᴏɴ ⌯</b> <code>𝟸.𝟶.𝟷𝟶𝟼</code>"
+            )
+        except (errors.ChannelInvalid, errors.PeerIdInvalid):
+            LOGGER(__name__).error(
+                "Bot has failed to access the log channel. Make sure that you have added your bot to your log group/channel."
+            )
+            exit()
+        except Exception as ex:
+            LOGGER(__name__).error(
+                f"Bot has failed to access the log group/channel.\n  Reason : {type(ex).__name__}."
+            )
+            exit()
+
+        a = await self.get_chat_member(config.LOGGER_ID, self.id)
+        if a.status != ChatMemberStatus.ADMINISTRATOR:
+            LOGGER(__name__).error(
+                "Please promote your bot as an admin in your log group/channel."
+            )
+            exit()
+        LOGGER(__name__).info(f"Bot Started as {self.name}")
+
+    async def stop(self):
+        await super().stop()

Devine/core/call.py

@@ -0,0 +1,601 @@
+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 Devine import LOGGER, YouTube, app
+from Devine.misc import db
+from Devine.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 Devine.utils.exceptions import AssistantErr
+from Devine.utils.formatters import check_duration, seconds_to_min, speed_converter
+from Devine.utils.inline.play import stream_markup
+from Devine.utils.stream.autoclear import auto_clean
+from Devine.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="Devine1",
+            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="Devine2",
+            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="Devine3",
+            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="Devine5",
+            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="Devine5",
+            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 = stream_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:
+                    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(_, 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 = stream_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 = stream_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 = stream_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(_, 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)
+
+
+Anony = Call()

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

Devine/core/git.py

@@ -0,0 +1,80 @@
+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 hide_sensitive_info(message: str) -> str:
+    # Function to hide sensitive information in messages
+    return message.replace(config.UPSTREAM_REPO, "<hidden>")
+
+
+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("Git Client Found [VPS DEPLOYER]")
+    except InvalidGitRepositoryError:
+        repo = Repo.init()
+        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()
+    except GitCommandError as e:
+        LOGGER(__name__).error(f"Invalid Git Command: {e}")
+        return
+
+    try:
+        origin = repo.remote("origin")
+    except ValueError:
+        origin = repo.create_remote("origin", UPSTREAM_REPO)
+    
+    origin.fetch(config.UPSTREAM_BRANCH)
+    
+    try:
+        origin.pull(config.UPSTREAM_BRANCH)
+    except GitCommandError as e:
+        repo.git.reset("--hard", "FETCH_HEAD")
+        LOGGER(__name__).error(f"Error pulling from upstream: {e}")
+
+    install_req("pip3 install --no-cache-dir -r requirements.txt")
+    LOGGER(__name__).info(f"Fetching updates from upstream repository: {hide_sensitive_info(UPSTREAM_REPO)}")
+
+
+# Call the git function
+git()

Devine/core/mongo.py

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

Devine/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="Devine1",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING1),
+            no_updates=True,
+        )
+        self.two = Client(
+            name="Devine2",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING2),
+            no_updates=True,
+        )
+        self.three = Client(
+            name="Devine3",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING3),
+            no_updates=True,
+        )
+        self.four = Client(
+            name="Devine4",
+            api_id=config.API_ID,
+            api_hash=config.API_HASH,
+            session_string=str(config.STRING4),
+            no_updates=True,
+        )
+        self.five = Client(
+            name="Devine5",
+            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("Devine_Network")
+                await self.one.join_chat("Devine_Community")
+            except:
+                pass
+            assistants.append(1)
+            try:
+                await self.one.send_message(config.LOGGER_ID, "<b>ᴀssɪsᴛᴀɴᴛ 𝟷 sᴛᴀʀᴛᴇᴅ</b>")
+            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("Devine_Network")
+                await self.two.join_chat("Devine_community")
+            except:
+                pass
+            assistants.append(2)
+            try:
+                await self.two.send_message(config.LOGGER_ID, "<b>ᴀssɪsᴛᴀɴᴛ 𝟸 sᴛᴀʀᴛᴇᴅ</b>")
+            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("Devine_Network")
+                await self.three.join_chat("Devine_community")
+            except:
+                pass
+            assistants.append(3)
+            try:
+                await self.three.send_message(config.LOGGER_ID, "<b>ᴀssɪsᴛᴀɴᴛ 𝟹 sᴛᴀʀᴛᴇᴅ</b>")
+            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("Devine_Network")
+                await self.four.join_chat("Devine_community")
+            except:
+                pass
+            assistants.append(4)
+            try:
+                await self.four.send_message(config.LOGGER_ID, "<b>ᴀssɪsᴛᴀɴᴛ 𝟺 sᴛᴀʀᴛᴇᴅ</b>")
+            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("Devine_Network")
+                await self.five.join_chat("Devine_community")
+            except:
+                pass
+            assistants.append(5)
+            try:
+                await self.five.send_message(config.LOGGER_ID, "<b>ᴀssɪsᴛᴀɴᴛ 𝟻 sᴛᴀʀᴛᴇᴅ</b>")
+            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

Devine/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("pymongo").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)

Devine/misc.py

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

Devine/modules/fonts.py

@@ -0,0 +1,188 @@
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+
+from AnonXMusic import app
+from AnonXMusic.utils.fonts import Fonts
+
+
+@app.on_message(filters.command(["font", "fonts"]))
+async def style_buttons(c, m, cb=False):
+    buttons = [
+        [
+            InlineKeyboardButton("𝚃𝚢𝚙𝚎𝚠𝚛𝚒𝚝𝚎𝚛", callback_data="style+typewriter"),
+            InlineKeyboardButton("𝕆𝕦𝕥𝕝𝕚𝕟𝕖", callback_data="style+outline"),
+            InlineKeyboardButton("𝐒𝐞𝐫𝐢𝐟", callback_data="style+serif"),
+        ],
+        [
+            InlineKeyboardButton("𝑺𝒆𝒓𝒊𝒇", callback_data="style+bold_cool"),
+            InlineKeyboardButton("𝑆𝑒𝑟𝑖𝑓", callback_data="style+cool"),
+            InlineKeyboardButton("Sᴍᴀʟʟ Cᴀᴘs", callback_data="style+small_cap"),
+        ],
+        [
+            InlineKeyboardButton("𝓈𝒸𝓇𝒾𝓅𝓉", callback_data="style+script"),
+            InlineKeyboardButton("𝓼𝓬𝓻𝓲𝓹𝓽", callback_data="style+script_bolt"),
+            InlineKeyboardButton("ᵗⁱⁿʸ", callback_data="style+tiny"),
+        ],
+        [
+            InlineKeyboardButton("ᑕOᗰIᑕ", callback_data="style+comic"),
+            InlineKeyboardButton("𝗦𝗮𝗻𝘀", callback_data="style+sans"),
+            InlineKeyboardButton("𝙎𝙖𝙣𝙨", callback_data="style+slant_sans"),
+        ],
+        [
+            InlineKeyboardButton("𝘚𝘢𝘯𝘴", callback_data="style+slant"),
+            InlineKeyboardButton("𝖲𝖺𝗇𝗌", callback_data="style+sim"),
+            InlineKeyboardButton("Ⓒ︎Ⓘ︎Ⓡ︎Ⓒ︎Ⓛ︎Ⓔ︎Ⓢ︎", callback_data="style+circles"),
+        ],
+        [
+            InlineKeyboardButton("🅒︎🅘︎🅡︎🅒︎🅛︎🅔︎🅢︎", callback_data="style+circle_dark"),
+            InlineKeyboardButton("𝔊𝔬𝔱𝔥𝔦𝔠", callback_data="style+gothic"),
+            InlineKeyboardButton("𝕲𝖔𝖙𝖍𝖎𝖈", callback_data="style+gothic_bolt"),
+        ],
+        [
+            InlineKeyboardButton("C͜͡l͜͡o͜͡u͜͡d͜͡s͜͡", callback_data="style+cloud"),
+            InlineKeyboardButton("H̆̈ă̈p̆̈p̆̈y̆̈", callback_data="style+happy"),
+            InlineKeyboardButton("S̑̈ȃ̈d̑̈", callback_data="style+sad"),
+        ],
+        [InlineKeyboardButton("ɴᴇxᴛ ➻", callback_data="nxt")],
+    ]
+    if not cb:
+        await m.reply_text(
+            text=m.text.split(None, 1)[1],
+            reply_markup=InlineKeyboardMarkup(buttons),
+            quote=True,
+        )
+    else:
+        await m.answer()
+        await m.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
+
+
+@pbot.on_callback_query(filters.regex("^nxt"))
+async def nxt(c, m):
+    if m.data == "nxt":
+        buttons = [
+            [
+                InlineKeyboardButton("🇸 🇵 🇪 🇨 🇮 🇦 🇱 ", callback_data="style+special"),
+                InlineKeyboardButton("🅂🅀🅄🄰🅁🄴🅂", callback_data="style+squares"),
+                InlineKeyboardButton("🆂︎🆀︎🆄︎🅰︎🆁︎🅴︎🆂︎", callback_data="style+squares_bold"),
+            ],
+            [
+                InlineKeyboardButton("ꪖꪀᦔꪖꪶꪊᥴ𝓲ꪖ", callback_data="style+andalucia"),
+                InlineKeyboardButton("爪卂几ᘜ卂", callback_data="style+manga"),
+                InlineKeyboardButton("S̾t̾i̾n̾k̾y̾", callback_data="style+stinky"),
+            ],
+            [
+                InlineKeyboardButton("B̥ͦu̥ͦb̥ͦb̥ͦl̥ͦe̥ͦs̥ͦ", callback_data="style+bubbles"),
+                InlineKeyboardButton("U͟n͟d͟e͟r͟l͟i͟n͟e͟", callback_data="style+underline"),
+                InlineKeyboardButton("꒒ꍏꀷꌩꌃꀎꁅ", callback_data="style+ladybug"),
+            ],
+            [
+                InlineKeyboardButton("R҉a҉y҉s҉", callback_data="style+rays"),
+                InlineKeyboardButton("B҈i҈r҈d҈s҈", callback_data="style+birds"),
+                InlineKeyboardButton("S̸l̸a̸s̸h̸", callback_data="style+slash"),
+            ],
+            [
+                InlineKeyboardButton("s⃠t⃠o⃠p⃠", callback_data="style+stop"),
+                InlineKeyboardButton("S̺͆k̺͆y̺͆l̺͆i̺͆n̺͆e̺͆", callback_data="style+skyline"),
+                InlineKeyboardButton("A͎r͎r͎o͎w͎s͎", callback_data="style+arrows"),
+            ],
+            [
+                InlineKeyboardButton("ዪሀክቿነ", callback_data="style+qvnes"),
+                InlineKeyboardButton("S̶t̶r̶i̶k̶e̶", callback_data="style+strike"),
+                InlineKeyboardButton("F༙r༙o༙z༙e༙n༙", callback_data="style+frozen"),
+            ],
+            [InlineKeyboardButton("ʙᴀᴄᴋ", callback_data="nxt+0")],
+        ]
+        await m.answer()
+        await m.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
+    else:
+        await style_buttons(c, m, cb=True)
+
+
+@pbot.on_callback_query(filters.regex("^style"))
+async def style(c, m):
+    await m.answer()
+    cmd, style = m.data.split("+")
+
+    if style == "typewriter":
+        cls = Fonts.typewriter
+    if style == "outline":
+        cls = Fonts.outline
+    if style == "serif":
+        cls = Fonts.serief
+    if style == "bold_cool":
+        cls = Fonts.bold_cool
+    if style == "cool":
+        cls = Fonts.cool
+    if style == "small_cap":
+        cls = Fonts.smallcap
+    if style == "script":
+        cls = Fonts.script
+    if style == "script_bolt":
+        cls = Fonts.bold_script
+    if style == "tiny":
+        cls = Fonts.tiny
+    if style == "comic":
+        cls = Fonts.comic
+    if style == "sans":
+        cls = Fonts.san
+    if style == "slant_sans":
+        cls = Fonts.slant_san
+    if style == "slant":
+        cls = Fonts.slant
+    if style == "sim":
+        cls = Fonts.sim
+    if style == "circles":
+        cls = Fonts.circles
+    if style == "circle_dark":
+        cls = Fonts.dark_circle
+    if style == "gothic":
+        cls = Fonts.gothic
+    if style == "gothic_bolt":
+        cls = Fonts.bold_gothic
+    if style == "cloud":
+        cls = Fonts.cloud
+    if style == "happy":
+        cls = Fonts.happy
+    if style == "sad":
+        cls = Fonts.sad
+    if style == "special":
+        cls = Fonts.special
+    if style == "squares":
+        cls = Fonts.square
+    if style == "squares_bold":
+        cls = Fonts.dark_square
+    if style == "andalucia":
+        cls = Fonts.andalucia
+    if style == "manga":
+        cls = Fonts.manga
+    if style == "stinky":
+        cls = Fonts.stinky
+    if style == "bubbles":
+        cls = Fonts.bubbles
+    if style == "underline":
+        cls = Fonts.underline
+    if style == "ladybug":
+        cls = Fonts.ladybug
+    if style == "rays":
+        cls = Fonts.rays
+    if style == "birds":
+        cls = Fonts.birds
+    if style == "slash":
+        cls = Fonts.slash
+    if style == "stop":
+        cls = Fonts.stop
+    if style == "skyline":
+        cls = Fonts.skyline
+    if style == "arrows":
+        cls = Fonts.arrows
+    if style == "qvnes":
+        cls = Fonts.rvnes
+    if style == "strike":
+        cls = Fonts.strike
+    if style == "frozen":
+        cls = Fonts.frozen
+    new_text = cls(m.message.reply_to_message.text.split(None, 1)[1])
+    try:
+        await m.message.edit_text(new_text, reply_markup=m.message.reply_markup)
+    except:
+        pass

Devine/mongo/afkdb.py

@@ -0,0 +1,32 @@
+from Devine.utils.mongo import db
+
+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

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

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

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

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

Devine/platforms/Soundcloud.py

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

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

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

Devine/platforms/Youtube.py

@@ -0,0 +1,407 @@
+import asyncio
+import glob
+import os
+import random
+import re
+from typing import Union
+
+from pyrogram.enums import MessageEntityType
+from pyrogram.types import Message
+from youtubesearchpython.__future__ import VideosSearch
+from yt_dlp import YoutubeDL
+
+import config
+from Devine.utils.database import is_on_off
+from Devine.utils.formatters import time_to_seconds
+
+def cookies():
+    folder_path = f"{os.getcwd()}/cookies"
+    txt_files = glob.glob(os.path.join(folder_path, "*.txt"))
+    if not txt_files:
+        raise FileNotFoundError("No .txt files found in the specified folder.")
+    cookie_txt_file = random.choice(txt_files)
+    return f"""cookies/{str(cookie_txt_file).split("/")[-1]}"""
+
+
+def get_ytdl_options(ytdl_opts: Union[str, dict, list], commandline: bool = True) -> Union[str, dict, list]:
+    token_data = os.getenv("TOKEN_DATA")
+    
+    if isinstance(ytdl_opts, list):
+        if token_data:
+            ytdl_opts += ["--username" if commandline else "username", "oauth2", "--password" if commandline else "password", "''"]
+        else:
+            ytdl_opts += ["--cookies" if commandline else "cookiefile", cookies()]
+    
+    elif isinstance(ytdl_opts, str):
+        if token_data:
+            ytdl_opts += "--username oauth2 --password '' " if commandline else "username oauth2 password '' "
+        else:
+            ytdl_opts += f"--cookies {cookies()}" if commandline else f"cookiefile {cookies()}"
+    
+    elif isinstance(ytdl_opts, dict):
+        if token_data:
+            ytdl_opts.update({"username": "oauth2", "password": ""})
+        else:
+            ytdl_opts["cookiefile"] = cookies()
+    
+    return ytdl_opts
+
+
+async def shell_cmd(cmd):
+    proc = await asyncio.create_subprocess_shell(
+        cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    out, errorz = await proc.communicate()
+    if errorz:
+        if "unavailable videos are hidden" in (errorz.decode("utf-8")).lower():
+            return out.decode("utf-8")
+        else:
+            return errorz.decode("utf-8")
+    return out.decode("utf-8")
+
+
+class YouTubeAPI:
+    def __init__(self):
+        self.base = "https://www.youtube.com/watch?v="
+        self.regex = r"(?:youtube\.com|youtu\.be)"
+        self.status = "https://www.youtube.com/oembed?url="
+        self.listbase = "https://youtube.com/playlist?list="
+        self.reg = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+    async def exists(self, link: str, videoid: Union[bool, str] = None):
+        if videoid:
+            link = self.base + link
+        if re.search(self.regex, link):
+            return True
+        else:
+            return False
+
+    async def url(self, message_1: Message) -> Union[str, None]:
+        messages = [message_1]
+        if message_1.reply_to_message:
+            messages.append(message_1.reply_to_message)
+        text = ""
+        offset = None
+        length = None
+        for message in messages:
+            if offset:
+                break
+            if message.entities:
+                for entity in message.entities:
+                    if entity.type == MessageEntityType.URL:
+                        text = message.text or message.caption
+                        offset, length = entity.offset, entity.length
+                        break
+            elif message.caption_entities:
+                for entity in message.caption_entities:
+                    if entity.type == MessageEntityType.TEXT_LINK:
+                        return entity.url
+        if offset in (None,):
+            return None
+        return text[offset : offset + length]
+
+    async def details(self, link: str, videoid: Union[bool, str] = None):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            title = result["title"]
+            duration_min = result["duration"]
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+            vidid = result["id"]
+            if str(duration_min) == "None":
+                duration_sec = 0
+            else:
+                duration_sec = int(time_to_seconds(duration_min))
+        return title, duration_min, duration_sec, thumbnail, vidid
+
+    async def title(self, link: str, videoid: Union[bool, str] = None):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            title = result["title"]
+        return title
+
+    async def duration(self, link: str, videoid: Union[bool, str] = None):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            duration = result["duration"]
+        return duration
+
+    async def thumbnail(self, link: str, videoid: Union[bool, str] = None):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+        return thumbnail
+
+    async def video(self, link: str, videoid: Union[bool, str] = None):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        cmd = [
+            "yt-dlp",
+            "-g",
+            "-f",
+            "best[height<=?720][width<=?1280]",
+            f"{link}",
+        ]
+        cmd = get_ytdl_options(cmd)
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            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]
+
+        cmd = get_ytdl_options(
+            f"yt-dlp -i --get-id --flat-playlist --playlist-end {limit} --skip-download {link}"
+        )
+        playlist = await shell_cmd(cmd)
+        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,
+        }
+        ytdl_opts = get_ytdl_options(ytdl_opts, False)
+
+        ydl = YoutubeDL(ytdl_opts)
+        with ydl:
+            formats_available = []
+            r = ydl.extract_info(link, download=False)
+            for format in r["formats"]:
+                try:
+                    str(format["format"])
+                except Exception:
+                    continue
+                if "dash" not in str(format["format"]).lower():
+                    try:
+                        format["format"]
+                        format["filesize"]
+                        format["format_id"]
+                        format["ext"]
+                        format["format_note"]
+                    except KeyError:
+                        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,
+            }
+            ydl_optssx = get_ytdl_options(ydl_optssx, False)
+
+            x = 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,
+            }
+            ydl_optssx = get_ytdl_options(ydl_optssx, False)
+
+            x = 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",
+            }
+            ydl_optssx = get_ytdl_options(ydl_optssx, False)
+
+            x = 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",
+                    }
+                ],
+            }
+            ydl_optssx = get_ytdl_options(ydl_optssx, False)
+
+            x = 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(config.YTDOWNLOADER):
+                direct = True
+                downloaded_file = await loop.run_in_executor(None, video_dl)
+            else:
+                command = [
+                    "yt-dlp",
+                    "-g",
+                    "-f",
+                    "best[height<=?720][width<=?1280]",
+                    link,
+                ]
+                command = get_ytdl_options(command)
+                
+                proc = await asyncio.create_subprocess_exec(
+                    *command,
+                    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

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

Devine/plugins/Dev/fonts.py

@@ -0,0 +1,196 @@
+from pyrogram import  filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+
+from Devine.utils.fonts import Fonts
+from Devine import app
+
+@app.on_message(filters.command(["font", "fonts"]))
+async def style_buttons(c, m, cb=False):
+    text = m.text.split(' ',1)[1]
+    buttons = [
+        [
+            InlineKeyboardButton("𝗦𝗮𝗻𝘀", callback_data="style+sans"),
+            InlineKeyboardButton("𝙎𝙖𝙣𝙨", callback_data="style+slant_sans"),
+            InlineKeyboardButton("𝖲𝖺𝗇𝗌", callback_data="style+sim"),
+        ],
+        [
+            InlineKeyboardButton("𝘚𝘢𝘯𝘴", callback_data="style+slant"),
+            InlineKeyboardButton("𝐒𝐞𝐫𝐢𝐟", callback_data="style+serif"),
+            InlineKeyboardButton("𝑺𝒆𝒓𝒊𝒇", callback_data="style+bold_cool"),
+        ],
+        [
+            InlineKeyboardButton("𝑆𝑒𝑟𝑖𝑓", callback_data="style+cool"),
+            InlineKeyboardButton("𝓈𝒸𝓇𝒾𝓅𝓉", callback_data="style+script"),
+            InlineKeyboardButton("𝓼𝓬𝓻𝓲𝓹𝓽", callback_data="style+script_bolt"),
+        ],
+        [
+            InlineKeyboardButton("Sᴍᴀʟʟ Cᴀᴘs", callback_data="style+small_cap"),
+            InlineKeyboardButton("🅒︎🅘︎🅡︎🅒︎🅛︎🅔︎🅢︎", callback_data="style+circle_dark"),
+            InlineKeyboardButton("Ⓒ︎Ⓘ︎Ⓡ︎Ⓒ︎Ⓛ︎Ⓔ︎Ⓢ︎", callback_data="style+circles"),
+        ],
+        [
+            InlineKeyboardButton("𝕲𝖔𝖙𝖍𝖎𝖈", callback_data="style+gothic_bolt"),
+            InlineKeyboardButton("𝔊𝔬𝔱𝔥𝔦𝔠", callback_data="style+gothic"),
+            InlineKeyboardButton("ᵗⁱⁿʸ", callback_data="style+tiny"),
+        ],
+        [
+            InlineKeyboardButton("𝚃𝚢𝚙𝚎𝚠𝚛𝚒𝚝𝚎𝚛", callback_data="style+typewriter"),
+            InlineKeyboardButton("𝕆𝕦𝕥𝕝𝕚𝕟𝕖", callback_data="style+outline"),
+            InlineKeyboardButton("ᑕOᗰIᑕ", callback_data="style+comic"),
+        ],
+        [
+            InlineKeyboardButton("C͜͡l͜͡o͜͡u͜͡d͜͡s͜͡", callback_data="style+cloud"),
+            InlineKeyboardButton("H̆̈ă̈p̆̈p̆̈y̆̈", callback_data="style+happy"),
+            InlineKeyboardButton("S̑̈ȃ̈d̑̈", callback_data="style+sad"),
+        ],
+        [
+            InlineKeyboardButton ("ᴄʟᴏsᴇ",callback_data="close_reply"),InlineKeyboardButton ("ɴᴇxᴛ", callback_data="nxt")],
+    ]
+    if not cb:
+        await m.reply_text(
+            f"{text}", reply_markup=InlineKeyboardMarkup(buttons), quote=True
+        )
+    else:
+        await m.answer()
+        await m.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
+
+
+@app.on_callback_query(filters.regex("^nxt"))
+async def nxt(c, m):
+    if m.data == "nxt":
+        buttons = [
+            [
+                InlineKeyboardButton("🇸 🇵 🇪 🇨 🇮 🇦 🇱 ", callback_data="style+special"),
+                InlineKeyboardButton("🅂🅀🅄🄰🅁🄴🅂", callback_data="style+squares"),
+                InlineKeyboardButton(
+                    "🆂︎🆀︎🆄︎🅰︎🆁︎🅴︎🆂︎", callback_data="style+squares_bold"
+                ),
+            ],
+            [
+                InlineKeyboardButton("ꪖꪀᦔꪖꪶꪊᥴ𝓲ꪖ", callback_data="style+andalucia"),
+                InlineKeyboardButton("爪卂几ᘜ卂", callback_data="style+manga"),
+                InlineKeyboardButton("S̾t̾i̾n̾k̾y̾", callback_data="style+stinky"),
+            ],
+            [
+                InlineKeyboardButton(
+                    "B̥ͦu̥ͦb̥ͦb̥ͦl̥ͦe̥ͦs̥ͦ", callback_data="style+bubbles"
+                ),
+                InlineKeyboardButton(
+                    "U͟n͟d͟e͟r͟l͟i͟n͟e͟", callback_data="style+underline"
+                ),
+                InlineKeyboardButton("꒒ꍏꀷꌩꌃꀎꁅ", callback_data="style+ladybug"),
+            ],
+            [
+                InlineKeyboardButton("R҉a҉y҉s҉", callback_data="style+rays"),
+                InlineKeyboardButton("B҈i҈r҈d҈s҈", callback_data="style+birds"),
+                InlineKeyboardButton("S̸l̸a̸s̸h̸", callback_data="style+slash"),
+            ],
+            [
+                InlineKeyboardButton("s⃠t⃠o⃠p⃠", callback_data="style+stop"),
+                InlineKeyboardButton(
+                    "S̺͆k̺͆y̺͆l̺͆i̺͆n̺͆e̺͆", callback_data="style+skyline"
+                ),
+                InlineKeyboardButton("A͎r͎r͎o͎w͎s͎", callback_data="style+arrows"),
+            ],
+            [
+                InlineKeyboardButton("ዪሀክቿነ", callback_data="style+qvnes"),
+                InlineKeyboardButton("S̶t̶r̶i̶k̶e̶", callback_data="style+strike"),
+                InlineKeyboardButton("F༙r༙o༙z༙e༙n༙", callback_data="style+frozen"),
+            ],
+            [
+                InlineKeyboardButton ("ᴄʟᴏsᴇ",callback_data="close_reply"),InlineKeyboardButton ("ʙᴀᴄᴋ", callback_data="nxt+0")],
+        ]
+        await m.answer()
+        await m.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
+    else:
+        await style_buttons(c, m, cb=True)
+
+
+@app.on_callback_query(filters.regex("^style"))
+async def style(c, m):
+    await m.answer()
+    cmd,style = m.data.split('+')
+    if style == "typewriter":
+        cls = Fonts.typewriter
+    if style == "outline":
+        cls = Fonts.outline
+    if style == "serif":
+        cls = Fonts.serief
+    if style == "bold_cool":
+        cls = Fonts.bold_cool
+    if style == "cool":
+        cls = Fonts.cool
+    if style == "small_cap":
+        cls = Fonts.smallcap
+    if style == "script":
+        cls = Fonts.script
+    if style == "script_bolt":
+        cls = Fonts.bold_script
+    if style == "tiny":
+        cls = Fonts.tiny
+    if style == "comic":
+        cls = Fonts.comic
+    if style == "sans":
+        cls = Fonts.san
+    if style == "slant_sans":
+        cls = Fonts.slant_san
+    if style == "slant":
+        cls = Fonts.slant
+    if style == "sim":
+        cls = Fonts.sim
+    if style == "circles":
+        cls = Fonts.circles
+    if style == "circle_dark":
+        cls = Fonts.dark_circle
+    if style == "gothic":
+        cls = Fonts.gothic
+    if style == "gothic_bolt":
+        cls = Fonts.bold_gothic
+    if style == "cloud":
+        cls = Fonts.cloud
+    if style == "happy":
+        cls = Fonts.happy
+    if style == "sad":
+        cls = Fonts.sad
+    if style == "special":
+        cls = Fonts.special
+    if style == "squares":
+        cls = Fonts.square
+    if style == "squares_bold":
+        cls = Fonts.dark_square
+    if style == "andalucia":
+        cls = Fonts.andalucia
+    if style == "manga":
+        cls = Fonts.manga
+    if style == "stinky":
+        cls = Fonts.stinky
+    if style == "bubbles":
+        cls = Fonts.bubbles
+    if style == "underline":
+        cls = Fonts.underline
+    if style == "ladybug":
+        cls = Fonts.ladybug
+    if style == "rays":
+        cls = Fonts.rays
+    if style == "birds":
+        cls = Fonts.birds
+    if style == "slash":
+        cls = Fonts.slash
+    if style == "stop":
+        cls = Fonts.stop
+    if style == "skyline":
+        cls = Fonts.skyline
+    if style == "arrows":
+        cls = Fonts.arrows
+    if style == "qvnes":
+        cls = Fonts.rvnes
+    if style == "strike":
+        cls = Fonts.strike
+    if style == "frozen":
+        cls = Fonts.frozen
+    #text = m.text.split(' ',1)[1]    
+    new_text = cls(m.message.reply_to_message.text.split(" ",1)[1])
+    try:
+        await m.message.edit_text(new_text, reply_markup=m.message.reply_markup)
+    except:
+        pass

Devine/plugins/Dev/groupdata.py

@@ -0,0 +1,53 @@
+import os
+import time
+from asyncio import sleep
+from pyrogram import Client, filters
+from pyrogram import enums, filters
+from config import OWNER_ID, SPECIAL_USER_ID
+from Devine import app
+
+@app.on_message(~filters.private & filters.command(["groupdata"]), group=2)
+async def instatus(app, message):
+    start_time = time.perf_counter()
+    user = await app.get_chat_member(message.chat.id, message.from_user.id)
+    count = await app.get_chat_members_count(message.chat.id)
+    
+    if user.status in (
+        enums.ChatMemberStatus.ADMINISTRATOR,
+        enums.ChatMemberStatus.OWNER,
+    ) or message.from_user.id in {OWNER_ID, SPECIAL_USER_ID}:
+        sent_message = await message.reply_text("ɢᴇᴛᴛɪɴɢ ɪɴғᴏʀᴍᴀᴛɪᴏɴ...")
+        deleted_acc = 0
+        premium_acc = 0
+        banned = 0
+        bot = 0
+        uncached = 0
+        
+        async for ban in app.get_chat_members(message.chat.id, filter=enums.ChatMembersFilter.BANNED):
+            banned += 1
+        
+        async for member in app.get_chat_members(message.chat.id):
+            user = member.user
+            if user.is_deleted:
+                deleted_acc += 1
+            elif user.is_bot:
+                bot += 1
+            elif user.is_premium:
+                premium_acc += 1
+            else:
+                uncached += 1
+        
+        end_time = time.perf_counter()
+        timelog = "{:.2f}".format(end_time - start_time)
+        await sent_message.edit(f"""
+<b>• ɴᴀᴍᴇ : {message.chat.title}</b>
+<b>• ᴍᴇᴍʙᴇʀs : {count}</b>
+<b>• ʙᴏᴛs : {bot}</b>
+<b>• ᴢᴏᴍʙɪᴇs : {deleted_acc}</b>
+<b>• ʙᴀɴɴᴇᴅ ᴜsᴇʀs : {banned}</b>
+<b>• ᴘʀᴇᴍɪᴜᴍ ᴜsᴇʀs : {premium_acc}</b>\n
+<b>↬ ᴛɪᴍᴇ ᴛᴀᴋᴇɴ : {timelog}s</b>""")
+    else:
+        sent_message = await message.reply_text("ᴏɴʟʏ ᴀᴅᴍɪɴ ᴄᴀɴ ᴇxᴇᴄᴜᴛᴇ ᴛʜᴇ ᴄᴏᴍᴍᴀɴᴅ !")
+        await sleep(5)
+        await sent_message.delete()

Devine/plugins/Dev/groupinfo.py

@@ -0,0 +1,50 @@
+from pyrogram import Client, filters
+from pyrogram.types import Message
+from Devine import app
+
+@app.on_message(filters.command("groupinfo", prefixes="/"))
+async def get_group_status(_, message: Message):
+    if len(message.command) != 2:
+        await message.reply("ᴘʟᴇᴀsᴇ ᴘʀᴏᴠɪᴅᴇ ᴀ ɢʀᴏᴜᴘ ᴜsᴇʀɴᴀᴍᴇ. ᴇxᴀᴍᴘʟᴇ: `/groupinfo YourGroupUsername`")
+        return
+    
+    group_username = message.command[1]
+    
+    try:
+        group = await app.get_chat(group_username)
+    except Exception as e:
+        await message.reply(f"ᴇʀʀᴏʀ: {e}")
+        return
+    
+    total_members = await app.get_chat_members_count(group.id)
+    group_description = group.description
+    premium_acc = banned = deleted_acc = bot = 0  # Replace with actual counts.
+
+    # Close the parenthesis here
+    response_text = (
+        f"➲ ɢʀᴏᴜᴘ ɴᴀᴍᴇ : {group.title}\n"
+        f"➲ ɢʀᴏᴜᴘ ɪᴅ : <code>{group.id}</code>\n"
+        f"➲ ᴛᴏᴛᴀʟ ᴍᴇᴍʙᴇʀs : {total_members}\n"
+        f"➲ ᴅᴇsᴄʀɪᴘᴛɪᴏɴ : {group_description or 'N/A'}\n"
+        f"➲ ᴜsᴇʀɴᴀᴍᴇ : {group_username}.t.me\n"
+    )  # <-- This closes the string
+
+    await message.reply(response_text)
+
+
+# Command handler to get group status
+@app.on_message(filters.command("cstatus") & filters.group)
+def group_status(client, message):
+    chat = message.chat  # Chat where the command was sent
+    status_text = (
+        f"ɢʀᴏᴜᴘ ɪᴅ: {chat.id}\n"
+        f"ᴛɪᴛʟᴇ: <code>{chat.title}</code>\n"
+        f"ᴛʏᴘᴇ: {chat.type}\n"
+    )
+                  
+    if chat.username:  # Not all groups have a username
+        status_text += f"ᴜsᴇʀɴᴀᴍᴇ: {chat.username}.t.me"
+    else:
+        status_text += "ᴜsᴇʀɴᴀᴍᴇ: None"
+
+    message.reply_text(status_text)

Devine/plugins/Dev/password.py

@@ -0,0 +1,46 @@
+import random
+import string
+from pyrogram import Client, filters, enums
+from Devine import app
+
+def generate_strong_password(length):
+    # Define character sets
+    lowercase = string.ascii_lowercase
+    uppercase = string.ascii_uppercase
+    digits = string.digits
+    special_chars = "!@#$%^&*()_+"
+
+    # Ensure the password has at least one character from each set
+    password = [
+        random.choice(lowercase),
+        random.choice(uppercase),
+        random.choice(digits),
+        random.choice(special_chars),
+    ]
+
+    # Fill the rest of the password length with random choices from all sets
+    all_chars = lowercase + uppercase + digits + special_chars
+    password += random.choices(all_chars, k=length - len(password))
+
+    # Shuffle to prevent predictable patterns
+    random.shuffle(password)
+    
+    # Join the list into a string
+    return ''.join(password)
+
+@app.on_message(filters.command(["genpass", 'genpw', "genpassword"]))
+async def password(bot, update):
+    message = await update.reply_text(text="ᴘʀᴏᴄᴇꜱꜱɪɴɢ...")
+    
+    if len(update.command) > 1:
+        qw = update.text.split(" ", 1)[1]
+    else:
+        ST = ["12", "14", "16", "18", "20"]  # Stronger password length
+        qw = random.choice(ST)
+    
+    limit = int(qw)
+    random_value = generate_strong_password(limit)
+    
+    txt = f"<b>ʟɪᴍɪᴛ :</b> {str(limit)} \n<b> ᴘᴀꜱꜱᴡᴏʀᴅ: <code>{random_value}</code>"
+    
+    await message.edit_text(text=txt, parse_mode=enums.ParseMode.HTML)

Devine/plugins/Dev/sangmeta.py

@@ -0,0 +1,56 @@
+import asyncio
+import random
+from pyrogram import Client, filters
+from pyrogram.types import Message
+from pyrogram.raw.functions.messages import DeleteHistory
+from Devine import userbot as us, app
+from Devine.core.userbot import assistants
+
+
+@app.on_message(filters.command(["sg", "sang", "sangmeta"]))
+async def sg(client: Client, message: Message):
+    if len(message.command) < 2 and not message.reply_to_message:
+        return await message.reply("<b>ᴘʀᴏᴠɪᴅᴇ ᴀ ᴜsᴇʀɴᴀᴍᴇ, ᴜsᴇʀ ɪᴅ, ᴏʀ ʀᴇᴘʟʏ ᴛᴏ ᴀ ᴜsᴇʀ's ᴍᴇssᴀɢᴇ.</b>")
+
+    if message.reply_to_message:
+        args = message.reply_to_message.from_user.id
+    else:
+        args = message.text.split()[1]
+
+    lol = await message.reply("<b>ᴘʀᴏᴄᴇssɪɴɢ...</b>")
+
+    try:
+        user = await client.get_users(f"{args}")
+    except Exception:
+        return await lol.edit("<b>sᴘᴇᴄɪғʏ ᴀ ᴠᴀʟɪᴅ ᴜsᴇʀ !</b>")
+
+    bo = ["sangmata_bot", "sangmata_beta_bot"]
+    sg = random.choice(bo)
+
+    if 1 in assistants:
+        ubot = us.one
+
+    try:
+        a = await ubot.send_message(sg, f"{user.id}")
+        await a.delete()
+    except Exception as e:
+        return await lol.edit(f"Error: {e}")
+
+    await asyncio.sleep(1)
+
+    async for stalk in ubot.search_messages(a.chat.id):
+        if stalk.text is None:
+            continue
+        if not stalk:
+            await message.reply("<b>ᴛʜᴇ ʙᴏᴛ ɪs ᴜɴʀᴇsᴘᴏɴsɪᴠᴇ.</b>")
+        elif stalk:
+            await message.reply(f"{stalk.text}")
+            break  # Exit the loop after displaying one message
+
+    try:
+        user_info = await ubot.resolve_peer(sg)
+        await ubot.send(DeleteHistory(peer=user_info, max_id=0, revoke=True))
+    except Exception:
+        pass
+
+    await lol.delete()

Devine/plugins/Dev/truth_and_dare.py

@@ -0,0 +1,17 @@
+import requests
+from pyrogram import Client, filters
+from pyrogram.types import Message
+
+from Devine import app  
+
+@app.on_message(filters.command("truth"))
+async def truth(client: Client, message: Message):
+    truth = requests.get("https://api.truthordarebot.xyz/v1/truth").json()["question"]
+    await message.reply_text(truth)
+
+
+@app.on_message(filters.command("dare"))
+async def dare(client: Client, message: Message):
+    dare = requests.get("https://api.truthordarebot.xyz/v1/dare").json()["question"]
+    await message.reply_text(dare)
+

Devine/plugins/Dev/upload.py

@@ -0,0 +1,79 @@
+import requests
+from pyrogram import Client, filters
+from Devine import app as Devine
+import time
+import asyncio
+from config import OWNER_ID
+
+CLOUDINARY_UPLOAD_URL = "https://api.cloudinary.com/v1_1/your_cloud_name/upload"
+CLOUD_NAME = "Untitled"  
+API_KEY = "769593722143466"
+API_SECRET = "DztGFORQqYfBoxCdawh0g5jBRCg"
+MAX_FILE_SIZE_MB = 32  
+USER_UPLOAD_LIMIT = {}
+
+async def send_temp_message(message, text):
+    reply = await message.reply(text)
+    
+    for i in range(3):
+        await asyncio.sleep(0.3)  
+        updated_text = text + '.' * (i + 1)  
+        await reply.edit(updated_text)  
+        
+    return reply  
+
+async def upload_file(client, message, file_path):
+    waiting_message = await send_temp_message(message, "ᴡᴀɪᴛ")
+    
+    start_time = time.time()
+
+    with open(file_path, 'rb') as file:
+        files = {
+            "file": file,
+            "api_key": API_KEY,
+            "timestamp": int(time.time()),
+            "signature": API_SECRET  
+
+        response = requests.post(CLOUDINARY_UPLOAD_URL, data=files)
+
+    upload_time = round(time.time() - start_time, 2)
+
+    if response.status_code == 200:
+        response_data = response.json()
+        file_url = response_data["secure_url"]  
+
+        await waiting_message.edit(f"<b>ᴜᴘʟᴏᴀᴅᴇᴅ ᴛᴏ <a href='{file_url}' target='_blank'>Cloudinary</a> ɪɴ {upload_time} sᴇᴄᴏɴᴅs.</b>\n\n"
+                                   f"<b>ᴄᴏᴘʏ ʟɪɴᴋ : <code>{file_url}</code></b> ")
+    else:
+        await waiting_message.edit("<b>ғᴀɪʟᴇᴅ ᴛᴏ ᴜᴘʟᴏᴀᴅ ᴛʜᴇ ғɪʟᴇ.</b>")
+
+async def handle_upload(client, message, target_message):
+    user_id = message.from_user.id
+    current_time = time.time()
+    last_upload_time = USER_UPLOAD_LIMIT.get(user_id, 0)
+
+    if current_time - last_upload_time < 10:
+        await message.reply("<b>ʏᴏᴜ ᴀʀᴇ ʙᴇɪɴɢ ʀᴀᴛᴇ-ʟɪᴍɪᴛᴇᴅ. ᴛʀʏ ᴀɢᴀɪɴ ᴀғᴛᴇʀ 10 sᴇᴄᴏɴᴅs.</b>")
+        return
+
+    USER_UPLOAD_LIMIT[user_id] = current_time
+
+    file_size = (target_message.photo or target_message.video).file_size / (1024 * 1024)  
+    if file_size > MAX_FILE_SIZE_MB:
+        await message.reply("<b>ғɪʟᴇ sɪᴢᴇ ᴇxᴄᴇᴇᴅs 32 ᴍʙ ʟɪᴍɪᴛ.</b>")
+    else:
+        file_path = await target_message.download()
+        await upload_file(client, message, file_path)
+
+@Devine.on_message(filters.command("xtgm"))
+async def upload_command(client, message):
+    if message.from_user.is_bot:
+        return  
+
+    target_message = message.reply_to_message if message.reply_to_message else message
+    media = target_message.photo or target_message.video
+
+    if media:
+        await handle_upload(client, message, target_message)
+    else:
+        await message.reply("<b>sᴇɴᴅ ᴏʀ ʀᴇᴘʟʏ ᴛᴏ ᴀ ᴘʜᴏᴛᴏ ᴏʀ ᴠɪᴅᴇᴏ ғᴏʀ ᴜᴘʟᴏᴀᴅ.</b>")

Devine/plugins/Dev/write.py

@@ -0,0 +1,24 @@
+from pyrogram import filters
+from pyrogram import *
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
+from datetime import datetime
+from Devine import app as app
+import requests
+
+@app.on_message(filters.command("write"))
+async def handwrite(_, message: Message):
+    if message.reply_to_message:
+        text = message.reply_to_message.text
+    else:
+        text =message.text.split(None, 1)[1]
+    m =await message.reply_text( "<b>ʜᴏʟᴅ ᴏɴ,\nᴡʀɪᴛɪɴɢ ʏᴏᴜʀ ᴛᴇxᴛ...</b>")
+    write = requests.get(f"https://apis.xditya.me/write?text={text}").url
+
+    caption = f"""
+<b>sᴜᴄᴇssғᴜʟʟʏ ᴛᴇxᴛ ᴡʀɪᴛᴛᴇɴ, ✨</b>
+
+<b>• ᴡʀɪᴛᴛᴇɴ ʙʏ : </b>{app.mention}
+<b>• ʀᴇǫᴜᴇsᴛᴇᴅ ʙʏ : </b>{message.from_user.mention}
+"""
+    await m.delete()
+    await message.reply_photo(photo=write,caption=caption)

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

Devine/plugins/admins/auth.py

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

Devine/plugins/admins/callback.py

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

Devine/plugins/admins/loop.py

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

Devine/plugins/admins/pause.py

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

Devine/plugins/admins/resume.py

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

Devine/plugins/admins/seek.py

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

Devine/plugins/admins/shuffle.py

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

Devine/plugins/admins/skip.py

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

Devine/plugins/admins/speed.py

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

Devine/plugins/admins/stop.py

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

Devine/plugins/bot/help.py

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

Devine/plugins/bot/inline.py

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

Devine/plugins/bot/settings.py

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