Refresh Update

.dockerignore

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

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

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

Dockerfile

@@ -0,0 +1,12 @@
+FROM nikolaik/python-nodejs:python3.9-nodejs18
+RUN apt-get update -y && apt-get upgrade -y \
+    && apt-get install -y --no-install-recommends ffmpeg \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+COPY . /app
+
+RUN chmod 777 /app
+WORKDIR /app
+RUN pip3 install --no-cache-dir --upgrade --requirement requirements.txt
+
+CMD ["python", "-u","-m", "YukkiMusic"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Team Yukki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,11 @@
+---
+title: One Stream
+emoji: 📈
+colorFrom: indigo
+colorTo: gray
+sdk: docker
+pinned: false
+license: gpl-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

YukkiMusic/__init__.py

@@ -0,0 +1,48 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from YukkiMusic.core.bot import YukkiBot
+from YukkiMusic.core.dir import dirr
+from YukkiMusic.core.git import git
+from YukkiMusic.core.userbot import Userbot
+from YukkiMusic.misc import dbb, heroku, sudo
+
+from .logging import LOGGER
+
+
+# Directories
+dirr()
+
+# Check Git Updates
+git()
+
+# Initialize Memory DB
+dbb()
+
+# Heroku APP
+heroku()
+
+# Load Sudo Users from DB
+sudo()
+
+# Bot Client
+app = YukkiBot()
+
+# Assistant Client
+userbot = Userbot()
+
+from .platforms import *
+
+YouTube = YouTubeAPI()
+Carbon = CarbonAPI()
+Spotify = SpotifyAPI()
+Apple = AppleAPI()
+Resso = RessoAPI()
+SoundCloud = SoundAPI()
+Telegram = TeleAPI()

YukkiMusic/__main__.py

@@ -0,0 +1,86 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+import importlib
+import sys
+from aiohttp import web
+from pyrogram import idle
+from pytgcalls.exceptions import NoActiveGroupCall
+
+import config
+from config import BANNED_USERS
+from YukkiMusic import LOGGER, app, userbot
+from .alive import web_server
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.plugins import ALL_MODULES
+from YukkiMusic.utils.database import get_banned_users, get_gbanned
+
+loop = asyncio.get_event_loop()
+server = web.AppRunner(web_server())
+
+async def init():
+    await server.setup()
+    await web.TCPSite(server,'0.0.0.0', 7860).start()
+    print("------------------------------Web Server Started ------------------------------")
+    
+    if (
+        not config.STRING1
+        and not config.STRING2
+        and not config.STRING3
+        and not config.STRING4
+        and not config.STRING5
+    ):
+        LOGGER("YukkiMusic").error(
+            "No Assistant Clients Vars Defined!.. Exiting Process."
+        )
+        return
+    if (
+        not config.SPOTIFY_CLIENT_ID
+        and not config.SPOTIFY_CLIENT_SECRET
+    ):
+        LOGGER("YukkiMusic").warning(
+            "No Spotify Vars defined. Your bot won't be able to play spotify queries."
+        )
+    try:
+        users = await get_gbanned()
+        for user_id in users:
+            BANNED_USERS.add(user_id)
+        users = await get_banned_users()
+        for user_id in users:
+            BANNED_USERS.add(user_id)
+    except:
+        pass
+    await app.start()
+    for all_module in ALL_MODULES:
+        importlib.import_module("YukkiMusic.plugins" + all_module)
+    LOGGER("Yukkimusic.plugins").info("Successfully Imported Modules ")
+    
+    await userbot.start()
+    await Yukki.start()
+    try:
+        await Yukki.stream_call(
+            "http://docs.evostream.com/sample_content/assets/sintel1m720p.mp4"
+        )
+    except NoActiveGroupCall:
+        LOGGER("YukkiMusic").error(
+            "[ERROR] - \n\nPlease turn on your Logger Group's Voice Call. Make sure you never close/end voice call in your log group"
+        )
+        sys.exit()
+    except:
+        pass
+    await Yukki.decorators()
+    LOGGER("YukkiMusic").info("Yukki Music Bot Started Successfully")
+    await idle()
+
+
+if __name__ == "__main__":
+    #keep_alive()
+    loop.run_until_complete(init())
+    LOGGER("YukkiMusic").info("Stopping Yukki Music Bot! GoodBye")

YukkiMusic/core/bot.py

@@ -0,0 +1,73 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import sys
+
+from pyrogram import Client
+from pyrogram.types import BotCommand
+
+import config
+
+from ..logging import LOGGER
+
+
+class YukkiBot(Client):
+
+  def __init__(self):
+    LOGGER(__name__).info(f"Starting Bot")
+    super().__init__(
+        "YukkiMusicBot",
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+        bot_token=config.BOT_TOKEN,
+    )
+
+  async def start(self):
+    await super().start()
+    get_me = await self.get_me()
+    self.username = get_me.username
+    self.id = get_me.id
+    try:
+      await self.send_message(config.LOG_GROUP_ID, "Bot Started")
+    except:
+      LOGGER(__name__).error(
+          "Bot has failed to access the log Group. Make sure that you have added your bot to your log channel and promoted as admin!"
+      )
+      sys.exit()
+    if config.SET_CMDS :
+      try:
+        await self.set_bot_commands([
+            BotCommand("ping", "Check that bot is alive or dead"),
+            BotCommand("play", "Starts playing the requested song"),
+            BotCommand("webapp","Open webapp of the music bot for your chat."),
+            BotCommand("skip", "Moves to the next track in queue"),
+            BotCommand("pause", "Pause the current playing song"),
+            BotCommand("resume", "Resume the paused song"),
+            BotCommand("end", "Clear the queue and leave voice chat"),
+            BotCommand("shuffle", "Randomly shuffles the queued playlist."),
+            BotCommand("playmode","Allows you to change the default playmode for your chat"),
+            BotCommand("settings","Open the settings of the music bot for your chat.")
+        ])
+      except:
+        pass
+    else:
+      pass
+    a = await self.get_chat_member(config.LOG_GROUP_ID, self.id)
+    #print(a)
+    '''if a.status != "ChatMemberStatus.ADMINISTRATOR":
+            LOGGER(__name__).error(
+                "Please promote Bot as Admin in Logger Group"
+            )
+            sys.exit()'''
+    if get_me.last_name:
+      self.name = get_me.first_name + " " + get_me.last_name
+    else:
+      self.name = get_me.first_name
+    LOGGER(__name__).info(f"MusicBot Started as {self.name}")
+

YukkiMusic/core/call.py

@@ -0,0 +1,750 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+from datetime import datetime, timedelta
+from typing import Union
+
+from pyrogram import Client
+from pyrogram.errors import (ChatAdminRequired, UserAlreadyParticipant,
+                             UserNotParticipant)
+from pyrogram.types import InlineKeyboardMarkup
+from pytgcalls import PyTgCalls, StreamType
+from pytgcalls.exceptions import (AlreadyJoinedError, NoActiveGroupCall)
+from pytgcalls.types import (JoinedGroupCallParticipant,
+                             LeftGroupCallParticipant, Update)
+from pytgcalls.types.stream.legacy import AudioPiped, AudioVideoPiped
+from pytgcalls.types.stream import MediaStream
+from pytgcalls.types.stream import StreamAudioEnded
+
+import config
+from strings import get_string
+from YukkiMusic import LOGGER, YouTube, app
+from YukkiMusic.misc import db
+from YukkiMusic.utils.database import (add_active_chat, add_active_video_chat,
+                                       get_assistant, get_audio_bitrate,
+                                       get_lang, get_loop, get_video_bitrate,
+                                       group_assistant, is_autoend, music_on,
+                                       mute_off, remove_active_chat,
+                                       remove_active_video_chat, set_loop)
+from YukkiMusic.utils.exceptions import AssistantErr
+from YukkiMusic.utils.inline.play import (stream_markup, telegram_markup)
+from YukkiMusic.utils.stream.autoclear import auto_clean
+from YukkiMusic.utils.thumbnails import gen_thumb
+
+autoend = {}
+counter = {}
+AUTO_END_TIME = 3
+
+
+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="1",
+        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="2",
+          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="3",
+          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="4",
+          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="5",
+          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 mute_stream(self, chat_id: int):
+    assistant = await group_assistant(self, chat_id)
+    await assistant.mute_stream(chat_id)
+
+  async def unmute_stream(self, chat_id: int):
+    assistant = await group_assistant(self, chat_id)
+    await assistant.unmute_stream(chat_id)
+
+  async def 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 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):
+    assistant = await group_assistant(self, chat_id)
+    audio_stream_quality = await get_audio_bitrate(chat_id)
+    video_stream_quality = await get_video_bitrate(chat_id)
+    stream = (AudioVideoPiped(
+        link,
+        audio_parameters=audio_stream_quality,
+        video_parameters=video_stream_quality,
+    ) if video else AudioPiped(link, audio_parameters=audio_stream_quality))
+    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)
+    audio_stream_quality = await get_audio_bitrate(chat_id)
+    video_stream_quality = await get_video_bitrate(chat_id)
+    stream = (AudioVideoPiped(
+        file_path,
+        audio_parameters=audio_stream_quality,
+        video_parameters=video_stream_quality,
+        additional_ffmpeg_parameters=f"-ss {to_seek} -to {duration}",
+    ) if mode == "video" else AudioPiped(
+        file_path,
+        audio_parameters=audio_stream_quality,
+        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.LOG_GROUP_ID)
+    await assistant.join_group_call(
+        config.LOG_GROUP_ID,
+        AudioVideoPiped(link),
+        #stream_type=StreamType().pulse_stream,
+    )
+    await asyncio.sleep(0.5)
+    await assistant.leave_group_call(config.LOG_GROUP_ID)
+  #####################################################################################################
+  '''async def live_call(self):
+    assistant = await group_assistant(self, config.LOG_GROUP_ID)
+    video_url="https://rr3---sn-gwpa-jj0k.googlevideo.com/videoplayback?expire=1720992868&ei=BPCTZo2hIcms9fwPxuiMoAQ&ip=34.93.83.202&id=o-AMlVXbysivqlwX1nPegSYVckA8UO6qOI1HNjA_C3ILVm&itag=137&source=youtube&requiressl=yes&xpc=EgVo2aDSNQ%3D%3D&bui=AXc671JgbdicNDMCvD64suPqy3V2hQF-GNxvsTkZ4Qpvo2dmu4bM_1b8SqzJ_I9_xQETqJurEz1vxgA2&vprv=1&mime=video%2Fmp4&rqh=1&gir=yes&clen=73860085&dur=221.916&lmt=1720511440920986&keepalive=yes&lmw=1&c=ANDROID_TV&txp=5532434&sparams=expire%2Cei%2Cip%2Cid%2Citag%2Csource%2Crequiressl%2Cxpc%2Cbui%2Cvprv%2Cmime%2Crqh%2Cgir%2Cclen%2Cdur%2Clmt&sig=AJfQdSswRgIhAOjSd5GnA0fj9-jgOyQmW1sXSKx8WClSlO75pIYEZmjlAiEAkhn6qXR6My5_e1z4RBR6C6uGmYKrgaGnhWPYJ9S9ljc%3D&redirect_counter=1&rm=sn-cvh6l7e&fexp=24350516,24350518&req_id=f179ac02cc1ba3ee&cms_redirect=yes&cmsv=e&ipbypass=yes&mh=_i&mip=2409:40e1:1f:e1b6:6820:58cf:6a51:f4ca&mm=31&mn=sn-gwpa-jj0k&ms=au&mt=1720970964&mv=m&mvi=3&pl=48&lsparams=ipbypass,mh,mip,mm,mn,ms,mv,mvi,pl&lsig=AHlkHjAwRQIhAOJXJOUSYjnXhP8mIhp7BXilkWg27LhQwSgFo7h7Sqr9AiBFk9gtmm9mYJoANtxtJDYO92RdMgOq_AXd9D-mcxHuyw%3D%3D"
+    audio_url="https://rr3---sn-gwpa-jj0k.googlevideo.com/videoplayback?expire=1720992868&ei=BPCTZo2hIcms9fwPxuiMoAQ&ip=34.93.83.202&id=o-AMlVXbysivqlwX1nPegSYVckA8UO6qOI1HNjA_C3ILVm&itag=251&source=youtube&requiressl=yes&xpc=EgVo2aDSNQ%3D%3D&bui=AXc671JgbdicNDMCvD64suPqy3V2hQF-GNxvsTkZ4Qpvo2dmu4bM_1b8SqzJ_I9_xQETqJurEz1vxgA2&vprv=1&mime=audio%2Fwebm&rqh=1&gir=yes&clen=3994328&dur=221.941&lmt=1720508953333763&keepalive=yes&lmw=1&c=ANDROID_TV&txp=5532434&sparams=expire%2Cei%2Cip%2Cid%2Citag%2Csource%2Crequiressl%2Cxpc%2Cbui%2Cvprv%2Cmime%2Crqh%2Cgir%2Cclen%2Cdur%2Clmt&sig=AJfQdSswRQIgDKbPBz-4y2_EOaOVAA99AggLmKgrfnV21tW1KGXdPPICIQD3ZGqgy9ewLeEK2-WHYpE7P1-Lqm48qYyWOOwZzuvHCA%3D%3D&redirect_counter=1&rm=sn-cvh6l7e&fexp=24350516,24350518&req_id=877fdd961f2a3ee&cms_redirect=yes&cmsv=e&ipbypass=yes&mh=_i&mip=2409:40e1:1f:e1b6:6820:58cf:6a51:f4ca&mm=31&mn=sn-gwpa-jj0k&ms=au&mt=1720970964&mv=m&mvi=3&pl=48&lsparams=ipbypass,mh,mip,mm,mn,ms,mv,mvi,pl&lsig=AHlkHjAwRAIgJmYgFL-esOsvjZ0cLdtkGojJf2RAvyY3BghjEGHqxI4CIDMb2rdPML37UNGuGCZbrkwsKjgfI5FAZ3fOGO-3VO7X"
+
+    await assistant.join_group_call(
+        config.LOG_GROUP_ID,
+        MediaStream(
+          media_path=video_url,
+          audio_path=audio_url,
+        ),
+        #stream_type=StreamType().pulse_stream,
+    )
+    
+'''
+  async def join_assistant(self, original_chat_id, chat_id):
+    language = await get_lang(original_chat_id)
+    _ = get_string(language)
+    userbot = await get_assistant(chat_id)
+    try:
+      try:
+        get = await app.get_chat_member(chat_id, userbot.id)
+      except ChatAdminRequired:
+        raise AssistantErr(_["call_1"])
+      if get.status == "banned" or get.status == "kicked":
+        raise AssistantErr(_["call_2"].format(userbot.username, userbot.id))
+    except UserNotParticipant:
+      chat = await app.get_chat(chat_id)
+      if chat.username:
+        try:
+          await userbot.join_chat(chat.username)
+        except UserAlreadyParticipant:
+          pass
+        except Exception as e:
+          raise AssistantErr(_["call_3"].format(e))
+      else:
+        try:
+          try:
+            try:
+              invitelink = chat.invite_link
+              if invitelink is None:
+                invitelink = (await app.export_chat_invite_link(chat_id))
+            except:
+              invitelink = (await app.export_chat_invite_link(chat_id))
+          except ChatAdminRequired:
+            raise AssistantErr(_["call_4"])
+          except Exception as e:
+            raise AssistantErr(e)
+          m = await app.send_message(original_chat_id, _["call_5"])
+          if invitelink.startswith("https://t.me/+"):
+            invitelink = invitelink.replace("https://t.me/+",
+                                            "https://t.me/joinchat/")
+          await asyncio.sleep(3)
+          await userbot.join_chat(invitelink)
+          await asyncio.sleep(4)
+          await m.edit(_["call_6"].format(userbot.name))
+        except UserAlreadyParticipant:
+          pass
+        except Exception as e:
+          raise AssistantErr(_["call_3"].format(e))
+
+  async def join_call(
+      self,
+      chat_id: int,
+      original_chat_id: int,
+      link,
+      video: Union[bool, str] = None,
+  ):
+    assistant = await group_assistant(self, chat_id)
+    audio_stream_quality = await get_audio_bitrate(chat_id)
+    video_stream_quality = await get_video_bitrate(chat_id)
+    stream = (AudioVideoPiped(
+        link,
+        audio_parameters=audio_stream_quality,
+        video_parameters=video_stream_quality,
+    ) if video else AudioPiped(link, audio_parameters=audio_stream_quality))
+    try:
+      print("join call")
+      await assistant.join_group_call(
+          chat_id,
+          stream,
+          #stream_type=StreamType().pulse_stream,
+      )
+    except NoActiveGroupCall:
+      try:
+        await self.join_assistant(original_chat_id, chat_id)
+      except Exception as e:
+        raise e
+      try:
+        await assistant.join_group_call(
+            chat_id,
+            stream,
+            #stream_type=StreamType().pulse_stream,
+        )
+      except Exception as e:
+        raise AssistantErr(
+            "**No Active Voice Chat Found**\n\nPlease make sure group's voice chat is enabled. If already enabled, please end it and start fresh voice chat again and if the problem continues, try /restart"
+        )
+    except AlreadyJoinedError:
+      raise AssistantErr(
+          "**Assistant Already in Voice Chat**\n\nSystems have detected that assistant is already there in the voice chat, this issue generally comes when you play 2 queries together.\n\nIf assistant is not present in voice chat, please end voice chat and start fresh voice chat again and if the  problem continues, try /restart"
+      )
+    '''except TelegramServerError:
+      raise AssistantErr(
+          "**Telegram Server Error**\n\nTelegram is having some internal server problems, Please try playing again.\n\n If this problem keeps coming everytime, please end your voice chat and start fresh voice chat again."
+      )'''
+    await add_active_chat(chat_id)
+    await mute_off(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=AUTO_END_TIME)
+
+  async def join_live_call(
+        self,
+        chat_id: int,
+        original_chat_id: int,
+        link,
+        video: Union[bool, str] = None,
+    ):
+      assistant = await group_assistant(self, chat_id)
+      audio_stream_quality = await get_audio_bitrate(chat_id)
+      video_stream_quality = await get_video_bitrate(chat_id)
+      '''stream = (AudioVideoPiped(
+          link,
+          audio_parameters=audio_stream_quality,
+          video_parameters=video_stream_quality,
+      ) if video else AudioPiped(link, audio_parameters=audio_stream_quality))'''
+      try:
+        print("join live call")
+        if video:
+          await assistant.join_group_call(
+              chat_id,
+              MediaStream(
+                media_path=link,
+                video_parameters=video_stream_quality,
+              ),
+              #stream_type=StreamType().pulse_stream,
+          )
+        else:
+          await assistant.join_group_call(
+              chat_id,
+              MediaStream(
+                media_path=link,
+                audio_parameters=audio_stream_quality,
+              ),
+              #stream_type=StreamType().pulse_stream,
+          )
+      except NoActiveGroupCall:
+        try:
+          await self.join_assistant(original_chat_id, chat_id)
+        except Exception as e:
+          raise e
+        try:
+          if video:
+            await assistant.join_group_call(
+                chat_id,
+                MediaStream(
+                  media_path=link,
+                  video_parameters=video_stream_quality,
+                ),
+                #stream_type=StreamType().pulse_stream,
+            )
+          else:
+            await assistant.join_group_call(
+                chat_id,
+                MediaStream(
+                  media_path=link,
+                  audio_parameters=audio_stream_quality,
+                ),
+                #stream_type=StreamType().pulse_stream,
+            )
+        except Exception as e:
+          raise AssistantErr(
+              "**No Active Voice Chat Found**\n\nPlease make sure group's voice chat is enabled. If already enabled, please end it and start fresh voice chat again and if the problem continues, try /restart"
+          )
+      except AlreadyJoinedError:
+        raise AssistantErr(
+            "**Assistant Already in Voice Chat**\n\nSystems have detected that assistant is already there in the voice chat, this issue generally comes when you play 2 queries together.\n\nIf assistant is not present in voice chat, please end voice chat and start fresh voice chat again and if the  problem continues, try /restart"
+        )
+      '''except TelegramServerError:
+        raise AssistantErr(
+            "**Telegram Server Error**\n\nTelegram is having some internal server problems, Please try playing again.\n\n If this problem keeps coming everytime, please end your voice chat and start fresh voice chat again."
+        )'''
+      await add_active_chat(chat_id)
+      await mute_off(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=AUTO_END_TIME)
+
+
+
+
+  async def live_call(
+          self,
+          chat_id: int,
+          original_chat_id: int,
+          video_url,
+          audio_url,
+          video: Union[bool, str] = None,
+      ):
+        
+        assistant = await group_assistant(self, chat_id)
+        audio_stream_quality = await get_audio_bitrate(chat_id)
+        video_stream_quality = await get_video_bitrate(chat_id)
+        '''stream = (AudioVideoPiped(
+            link,
+            audio_parameters=audio_stream_quality,
+            video_parameters=video_stream_quality,
+        ) if video else AudioPiped(link, audio_parameters=audio_stream_quality))'''
+        try:
+          print("live call")
+          if video:
+            await assistant.join_group_call(
+                chat_id,
+                MediaStream(
+                  media_path=video_url,
+                  audio_path=audio_url,
+                  audio_parameters=audio_stream_quality,
+                  video_parameters=video_stream_quality,
+                ),
+                #stream_type=StreamType().pulse_stream,
+            )
+          else:
+            await assistant.join_group_call(
+                chat_id,
+                MediaStream(
+                  media_path=audio_url,
+                  audio_parameters=audio_stream_quality,
+                ),
+                #stream_type=StreamType().pulse_stream,
+            )
+        except NoActiveGroupCall:
+          try:
+            await self.join_assistant(original_chat_id, chat_id)
+          except Exception as e:
+            raise e
+          try:
+            print("live call")
+            if video:
+              await assistant.join_group_call(
+                  chat_id,
+                  MediaStream(
+                    media_path=video_url,
+                    audio_path=audio_url,
+                    audio_parameters=audio_stream_quality,
+                    video_parameters=video_stream_quality,
+                  ),
+                  #stream_type=StreamType().pulse_stream,
+              )
+            else:
+              await assistant.join_group_call(
+                  chat_id,
+                  MediaStream(
+                    media_path=audio_url,
+                    audio_parameters=audio_stream_quality,
+                  ),
+                  #stream_type=StreamType().pulse_stream,
+              )
+          except Exception as e:
+            raise AssistantErr(
+                "**No Active Voice Chat Found**\n\nPlease make sure group's voice chat is enabled. If already enabled, please end it and start fresh voice chat again and if the problem continues, try /restart"
+            )
+        except AlreadyJoinedError:
+          raise AssistantErr(
+              "**Assistant Already in Voice Chat**\n\nSystems have detected that assistant is already there in the voice chat, this issue generally comes when you play 2 queries together.\n\nIf assistant is not present in voice chat, please end voice chat and start fresh voice chat again and if the  problem continues, try /restart"
+          )
+        '''except TelegramServerError:
+          raise AssistantErr(
+              "**Telegram Server Error**\n\nTelegram is having some internal server problems, Please try playing again.\n\n If this problem keeps coming everytime, please end your voice chat and start fresh voice chat again."
+          )'''
+        await add_active_chat(chat_id)
+        await mute_off(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=AUTO_END_TIME)
+
+  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)
+      if popped:
+        if config.AUTO_DOWNLOADS_CLEAR == str(True):
+          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"]
+      audio_stream_quality = await get_audio_bitrate(chat_id)
+      video_stream_quality = await get_video_bitrate(chat_id)
+      videoid = check[0]["vidid"]
+      check[0]["played"] = 0
+      if "live_" in queued:
+        n, link = await YouTube.video(videoid, True)
+        if n == 0:
+          return await app.send_message(
+              original_chat_id,
+              text=_["call_9"],
+          )
+        stream = (AudioVideoPiped(
+            link,
+            audio_parameters=audio_stream_quality,
+            video_parameters=video_stream_quality,
+        ) if str(streamtype) == "video" else AudioPiped(
+            link, audio_parameters=audio_stream_quality))
+        try:
+          await client.change_stream(chat_id, stream)
+        except Exception:
+          return await app.send_message(
+              original_chat_id,
+              text=_["call_9"],
+          )
+        img = await gen_thumb(videoid)
+        button = telegram_markup(_, chat_id)
+        run = await app.send_photo(
+            original_chat_id,
+            photo=img,
+            caption=_["stream_1"].format(
+                user,
+                f"https://t.me/{app.username}?start=info_{videoid}",
+            ),
+            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_10"])
+        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_9"],
+                                        disable_web_page_preview=True)
+        stream = (AudioVideoPiped(
+            file_path,
+            audio_parameters=audio_stream_quality,
+            video_parameters=video_stream_quality,
+        ) if str(streamtype) == "video" else AudioPiped(
+            file_path,
+            audio_parameters=audio_stream_quality,
+        ))
+        try:
+          await client.change_stream(chat_id, stream)
+        except Exception:
+          return await app.send_message(
+              original_chat_id,
+              text=_["call_9"],
+          )
+        img = await gen_thumb(videoid)
+        button = stream_markup(_, videoid, chat_id)
+        await mystic.delete()
+        run = await app.send_photo(
+            original_chat_id,
+            photo=img,
+            caption=_["stream_1"].format(
+                user,
+                f"https://t.me/{app.username}?start=info_{videoid}",
+            ),
+            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=audio_stream_quality,
+            video_parameters=video_stream_quality,
+        ) if str(streamtype) == "video" else AudioPiped(
+            videoid, audio_parameters=audio_stream_quality))
+        try:
+          await client.change_stream(chat_id, stream)
+        except Exception:
+          return await app.send_message(
+              original_chat_id,
+              text=_["call_9"],
+          )
+        button = telegram_markup(_, chat_id)
+        run = await app.send_photo(
+            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:
+        stream = (AudioVideoPiped(
+            queued,
+            audio_parameters=audio_stream_quality,
+            video_parameters=video_stream_quality,
+        ) if str(streamtype) == "video" else AudioPiped(
+            queued, audio_parameters=audio_stream_quality))
+        try:
+          await client.change_stream(chat_id, stream)
+        except Exception:
+          return await app.send_message(
+              original_chat_id,
+              text=_["call_9"],
+          )
+        if videoid == "telegram":
+          button = telegram_markup(_, chat_id)
+          run = await app.send_photo(
+              original_chat_id,
+              photo=config.TELEGRAM_AUDIO_URL
+              if str(streamtype) == "audio" else config.TELEGRAM_VIDEO_URL,
+              caption=_["stream_3"].format(title, check[0]["dur"], user),
+              reply_markup=InlineKeyboardMarkup(button),
+          )
+          db[chat_id][0]["mystic"] = run
+          db[chat_id][0]["markup"] = "tg"
+        elif videoid == "soundcloud":
+          button = telegram_markup(_, chat_id)
+          run = await app.send_photo(
+              original_chat_id,
+              photo=config.SOUNCLOUD_IMG_URL,
+              caption=_["stream_3"].format(title, check[0]["dur"], user),
+              reply_markup=InlineKeyboardMarkup(button),
+          )
+          db[chat_id][0]["mystic"] = run
+          db[chat_id][0]["markup"] = "tg"
+        else:
+          img = await gen_thumb(videoid)
+          button = stream_markup(_, videoid, chat_id)
+          run = await app.send_photo(
+              original_chat_id,
+              photo=img,
+              caption=_["stream_1"].format(
+                  user,
+                  f"https://t.me/{app.username}?start=info_{videoid}",
+              ),
+              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)
+
+    @self.one.on_participants_change()
+    @self.two.on_participants_change()
+    @self.three.on_participants_change()
+    @self.four.on_participants_change()
+    @self.five.on_participants_change()
+    async def participants_change_handler(client, update: Update):
+      if not isinstance(update, JoinedGroupCallParticipant) and not isinstance(
+          update, LeftGroupCallParticipant):
+        return
+      chat_id = update.chat_id
+      users = counter.get(chat_id)
+      if not users:
+        try:
+          got = len(await client.get_participants(chat_id))
+        except:
+          return
+        counter[chat_id] = got
+        if got == 1:
+          autoend[chat_id] = datetime.now() + timedelta(minutes=AUTO_END_TIME)
+          return
+        autoend[chat_id] = {}
+      else:
+        final = (users + 1 if isinstance(update, JoinedGroupCallParticipant)
+                 else users - 1)
+        counter[chat_id] = final
+        if final == 1:
+          autoend[chat_id] = datetime.now() + timedelta(minutes=AUTO_END_TIME)
+          return
+        autoend[chat_id] = {}
+
+  
+
+Yukki = Call()

YukkiMusic/core/dir.py

@@ -0,0 +1,33 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import os
+import sys
+from os import listdir, mkdir
+
+from ..logging import LOGGER
+
+
+def dirr():
+    if "assets" not in listdir():
+        LOGGER(__name__).warning(
+            f"Assets Folder not Found. Please clone repository again."
+        )
+        sys.exit()
+    for file in os.listdir():
+        if file.endswith(".jpg"):
+            os.remove(file)
+    for file in os.listdir():
+        if file.endswith(".jpeg"):
+            os.remove(file)
+    if "downloads" not in listdir():
+        mkdir("downloads")
+    if "cache" not in listdir():
+        mkdir("cache")
+    LOGGER(__name__).info("Directories Updated.")

YukkiMusic/core/git.py

@@ -0,0 +1,84 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+import shlex
+from typing import Tuple
+
+from git import Repo
+from git.exc import GitCommandError, InvalidGitRepositoryError
+
+import config
+
+from ..logging import LOGGER
+
+
+def install_req(cmd: str) -> Tuple[str, str, int, int]:
+    async def install_requirements():
+        args = shlex.split(cmd)
+        process = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+        return (
+            stdout.decode("utf-8", "replace").strip(),
+            stderr.decode("utf-8", "replace").strip(),
+            process.returncode,
+            process.pid,
+        )
+
+    return asyncio.get_event_loop().run_until_complete(
+        install_requirements()
+    )
+
+
+def git():
+    REPO_LINK = config.UPSTREAM_REPO
+    if config.GIT_TOKEN:
+        GIT_USERNAME = REPO_LINK.split("com/")[1].split("/")[0]
+        TEMP_REPO = REPO_LINK.split("https://")[1]
+        UPSTREAM_REPO = (
+            f"https://{GIT_USERNAME}:{config.GIT_TOKEN}@{TEMP_REPO}"
+        )
+    else:
+        UPSTREAM_REPO = config.UPSTREAM_REPO
+    try:
+        repo = Repo()
+        LOGGER(__name__).info(f"Git Client Found [VPS DEPLOYER]")
+    except GitCommandError:
+        LOGGER(__name__).info(f"Invalid Git Command")
+    except InvalidGitRepositoryError:
+        repo = Repo.init()
+        if "origin" in repo.remotes:
+            origin = repo.remote("origin")
+        else:
+            origin = repo.create_remote("origin", UPSTREAM_REPO)
+        origin.fetch()
+        repo.create_head(
+            config.UPSTREAM_BRANCH,
+            origin.refs[config.UPSTREAM_BRANCH],
+        )
+        repo.heads[config.UPSTREAM_BRANCH].set_tracking_branch(
+            origin.refs[config.UPSTREAM_BRANCH]
+        )
+        repo.heads[config.UPSTREAM_BRANCH].checkout(True)
+        try:
+            repo.create_remote("origin", config.UPSTREAM_REPO)
+        except BaseException:
+            pass
+        nrs = repo.remote("origin")
+        nrs.fetch(config.UPSTREAM_BRANCH)
+        try:
+            nrs.pull(config.UPSTREAM_BRANCH)
+        except GitCommandError:
+            repo.git.reset("--hard", "FETCH_HEAD")
+        install_req("pip3 install --no-cache-dir -r requirements.txt")
+        LOGGER(__name__).info(f"Fetched Updates from: {REPO_LINK}")

YukkiMusic/core/mongo.py

@@ -0,0 +1,43 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from motor.motor_asyncio import AsyncIOMotorClient as _mongo_client_
+from pymongo import MongoClient
+from pyrogram import Client
+
+import config
+
+from ..logging import LOGGER
+
+TEMP_MONGODB = "mongodb+srv://shikhar:shikhar@cluster0.6xzlh.mongodb.net/myFirstDatabase?retryWrites=true&w=majority"
+
+
+if config.MONGO_DB_URI is None:
+    LOGGER(__name__).warning(
+        "No MONGO DB URL found.. Your Bot will work on Yukki's Database"
+    )
+    temp_client = Client(
+        "Yukki",
+        bot_token=config.BOT_TOKEN,
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+    )
+    temp_client.start()
+    info = temp_client.get_me()
+    username = info.username
+    temp_client.stop()
+    _mongo_async_ = _mongo_client_(TEMP_MONGODB)
+    _mongo_sync_ = MongoClient(TEMP_MONGODB)
+    mongodb = _mongo_async_[username]
+    pymongodb = _mongo_sync_[username]
+else:
+    _mongo_async_ = _mongo_client_(config.MONGO_DB_URI)
+    _mongo_sync_ = MongoClient(config.MONGO_DB_URI)
+    mongodb = _mongo_async_.Yukki
+    pymongodb = _mongo_sync_.Yukki

YukkiMusic/core/userbot.py

@@ -0,0 +1,193 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import sys
+
+from pyrogram import Client
+
+import config
+
+from ..logging import LOGGER
+
+assistants = []
+assistantids = []
+multi_clients = {}
+work_loads = {}
+
+async def req_client():
+  index = min(work_loads, key=work_loads.get)
+  faster_client = multi_clients[index]
+  response = dict(index=index, client=faster_client)
+  return response
+
+class Userbot(Client):
+
+  def __init__(self):
+    self.one = Client(
+        name="1",
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+        session_string=str(config.STRING1),
+        no_updates=True,
+    )
+    self.two = Client(
+        name="2",
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+        session_string=str(config.STRING2),
+        no_updates=True,
+    )
+    self.three = Client(
+        name="3",
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+        session_string=str(config.STRING3),
+        no_updates=True,
+    )
+    self.four = Client(
+        name="4",
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+        session_string=str(config.STRING4),
+        no_updates=True,
+    )
+    self.five = Client(
+        name="5",
+        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 Assistant Clients")
+    if config.STRING1:
+        await self.one.start()
+        
+        assistants.append(1)
+        try:
+            await self.one.send_message(config.LOG_GROUP_ID, f"Assistant Started")
+        except:
+            LOGGER(__name__).error(
+                f"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! "
+            )
+            sys.exit()
+        get_me = await self.one.get_me()
+        self.one.username = get_me.username
+        self.one.id = get_me.id
+        assistantids.append(get_me.id)
+        if get_me.last_name:
+            self.one.name = (get_me.first_name + " " + get_me.last_name)
+        else:
+            self.one.name = get_me.first_name
+        LOGGER(__name__).info(f"Assistant Started as {self.one.name}")
+    if config.STRING2:
+        await self.two.start()
+        
+        assistants.append(2)
+        try:
+            await self.two.send_message(
+                config.LOG_GROUP_ID, "Assistant Started"
+            )
+        except:
+            LOGGER(__name__).error(
+                f"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! "
+            )
+            sys.exit()
+        get_me = await self.two.get_me()
+        self.two.username = get_me.username
+        self.two.id = get_me.id
+        assistantids.append(get_me.id)
+        if get_me.last_name:
+            self.two.name = (
+                get_me.first_name + " " + get_me.last_name
+            )
+        else:
+            self.two.name = get_me.first_name
+        LOGGER(__name__).info(
+            f"Assistant Two Started as {self.two.name}"
+        )
+    if config.STRING3:
+        await self.three.start()
+        
+        assistants.append(3)
+        try:
+            await self.three.send_message(
+                config.LOG_GROUP_ID, "Assistant Started"
+            )
+        except:
+            LOGGER(__name__).error(
+                f"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! "
+            )
+            sys.exit()
+        get_me = await self.three.get_me()
+        self.three.username = get_me.username
+        self.three.id = get_me.id
+        assistantids.append(get_me.id)
+        if get_me.last_name:
+            self.three.name = (
+                get_me.first_name + " " + get_me.last_name
+            )
+        else:
+            self.three.name = get_me.first_name
+        LOGGER(__name__).info(
+            f"Assistant Three Started as {self.three.name}"
+        )
+    if config.STRING4:
+        await self.four.start()
+        
+        assistants.append(4)
+        try:
+            await self.four.send_message(
+                config.LOG_GROUP_ID, "Assistant Started"
+            )
+        except:
+            LOGGER(__name__).error(
+                f"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! "
+            )
+            sys.exit()
+        get_me = await self.four.get_me()
+        self.four.username = get_me.username
+        self.four.id = get_me.id
+        assistantids.append(get_me.id)
+        if get_me.last_name:
+            self.four.name = (
+                get_me.first_name + " " + get_me.last_name
+            )
+        else:
+            self.four.name = get_me.first_name
+        LOGGER(__name__).info(
+            f"Assistant Four Started as {self.four.name}"
+        )
+    if config.STRING5:
+        await self.five.start()
+        
+        assistants.append(5)
+        try:
+            await self.five.send_message(
+                config.LOG_GROUP_ID, "Assistant Started"
+            )
+        except:
+            LOGGER(__name__).error(
+                f"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! "
+            )
+            sys.exit()
+        get_me = await self.five.get_me()
+        self.five.username = get_me.username
+        self.five.id = get_me.id
+        assistantids.append(get_me.id)
+        if get_me.last_name:
+            self.five.name = (
+                get_me.first_name + " " + get_me.last_name
+            )
+        else:
+            self.five.name = get_me.first_name
+        LOGGER(__name__).info(
+            f"Assistant Five Started as {self.five.name}"
+        )

YukkiMusic/logging.py

@@ -0,0 +1,23 @@
+import logging
+#from logging.handlers import RotatingFileHandler
+
+from config import LOG_FILE_NAME
+
+'''logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s - %(levelname)s] - %(name)s - %(message)s",
+    datefmt="%d-%b-%y %H:%M:%S",
+    handlers=[
+        RotatingFileHandler(
+            LOG_FILE_NAME, maxBytes=5000000, backupCount=10
+        ),
+        logging.StreamHandler(),
+    ],
+)'''
+
+logging.getLogger("pyrogram").setLevel(logging.ERROR)
+logging.getLogger("pytgcalls").setLevel(logging.ERROR)
+
+
+def LOGGER(name: str) -> logging.Logger:
+    return logging.getLogger(name)

YukkiMusic/misc.py

@@ -0,0 +1,90 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import socket
+import time
+
+import heroku3
+from pyrogram import filters
+
+import config
+from YukkiMusic.core.mongo import pymongodb
+
+from .logging import LOGGER
+
+SUDOERS = filters.user()
+
+HAPP = None
+_boot_ = time.time()
+
+
+def is_heroku():
+    return "heroku" in socket.getfqdn()
+
+
+XCB = [
+    "/",
+    "@",
+    ".",
+    "com",
+    ":",
+    "git",
+    "heroku",
+    "push",
+    str(config.HEROKU_API_KEY),
+    "https",
+    str(config.HEROKU_APP_NAME),
+    "HEAD",
+    "main",
+]
+
+
+def dbb():
+    global db
+    db = {}
+    LOGGER(__name__).info(f"Database Initialized.")
+
+
+def sudo():
+    global SUDOERS
+    OWNER = config.OWNER_ID
+    if config.MONGO_DB_URI is None:
+        for user_id in OWNER:
+            SUDOERS.add(user_id)
+    else:
+        sudoersdb = pymongodb.sudoers
+        sudoers = sudoersdb.find_one({"sudo": "sudo"})
+        sudoers = [] if not sudoers else sudoers["sudoers"]
+        for user_id in OWNER:
+            SUDOERS.add(user_id)
+            if user_id not in sudoers:
+                sudoers.append(user_id)
+                sudoersdb.update_one(
+                    {"sudo": "sudo"},
+                    {"$set": {"sudoers": sudoers}},
+                    upsert=True,
+                )
+        if sudoers:
+            for x in sudoers:
+                SUDOERS.add(x)
+    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."
+                )

YukkiMusic/platforms/Apple.py

@@ -0,0 +1,86 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+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

YukkiMusic/platforms/Carbon.py

@@ -0,0 +1,115 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+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.vercel.app/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)

YukkiMusic/platforms/Resso.py

@@ -0,0 +1,63 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+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

YukkiMusic/platforms/Soundcloud.py

@@ -0,0 +1,49 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import re
+from os import path
+
+from yt_dlp import YoutubeDL
+
+from YukkiMusic.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

YukkiMusic/platforms/Spotify.py

@@ -0,0 +1,109 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+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

YukkiMusic/platforms/Telegram.py

@@ -0,0 +1,205 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+import os
+import time
+from datetime import datetime, timedelta
+from typing import Union
+
+from pyrogram.types import (InlineKeyboardButton,
+                            InlineKeyboardMarkup, Voice)
+
+import config
+from config import MUSIC_BOT_NAME, lyrical
+from YukkiMusic import app
+
+from ..utils.formatters import (convert_bytes, get_readable_time,
+                                seconds_to_min)
+
+downloader = {}
+
+
+class TeleAPI:
+    def __init__(self):
+        self.chars_limit = 4096
+        self.sleep = config.TELEGRAM_DOWNLOAD_EDIT_SLEEP
+
+    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)
+        return True
+
+    async def get_link(self, message):
+        if message.chat.username:
+            link = f"https://t.me/{message.chat.username}/{message.reply_to_message.id}"
+        else:
+            xf = str((message.chat.id))[4:]
+            link = f"https://t.me/c/{xf}/{message.reply_to_message.id}"
+        return 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 = (
+                    "Telegram Audio File"
+                    if audio
+                    else "Telegram Video File"
+                )
+
+        except:
+            file_name = (
+                "Telegram Audio File"
+                if audio
+                else "Telegram Video File"
+            )
+        return file_name
+
+    async def get_duration(self, file):
+        try:
+            dur = seconds_to_min(file.duration)
+        except:
+            dur = "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):
+        left_time = {}
+        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="🚦 Cancel Downloading",
+                                callback_data="stop_downloading",
+                            ),
+                        ]
+                    ]
+                )
+                if datetime.now() > left_time.get(message.id):
+                    percentage = current * 100 / total
+                    percentage = str(round(percentage, 2))
+                    speed = current / check_time
+                    eta = int((total - current) / speed)
+                    downloader[message.id] = eta
+                    eta = get_readable_time(eta)
+                    if not eta:
+                        eta = "0 sec"
+                    total_size = convert_bytes(total)
+                    completed_size = convert_bytes(current)
+                    speed = convert_bytes(speed)
+                    text = f"""
+**{MUSIC_BOT_NAME} Telegram Media Downloader**
+
+**Total FileSize:** {total_size}
+**Completed:** {completed_size} 
+**Percentage:** {percentage[:5]}%
+
+**Speed:** {speed}/s
+**ETA:** {eta}"""
+                    try:
+                        await mystic.edit_text(text, reply_markup=upl)
+                    except:
+                        pass
+                    left_time[
+                        message.id
+                    ] = datetime.now() + timedelta(seconds=self.sleep)
+
+            speed_counter[message.id] = time.time()
+            left_time[message.id] = datetime.now()
+
+            try:
+                await app.download_media(
+                    message.reply_to_message,
+                    file_name=fname,
+                    progress=progress,
+                )
+                await mystic.edit_text(
+                    "Successfully Downloaded.. Processing file now"
+                )
+                downloader.pop(message.id)
+            except:
+                await mystic.edit_text(_["tg_2"])
+
+        if len(downloader) > 10:
+            timers = []
+            for x in downloader:
+                timers.append(downloader[x])
+            try:
+                low = min(timers)
+                eta = get_readable_time(low)
+            except:
+                eta = "Unknown"
+            await mystic.edit_text(_["tg_1"].format(eta))
+            return False
+
+        task = asyncio.create_task(down_load())
+        lyrical[mystic.id] = task
+        await task
+        downloaded = downloader.get(message.id)
+        if downloaded:
+            downloader.pop(message.id)
+            return False
+        verify = lyrical.get(mystic.id)
+        if not verify:
+            return False
+        lyrical.pop(mystic.id)
+        return True

YukkiMusic/platforms/Youtube.py

@@ -0,0 +1,467 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+import os
+import re
+from typing import Union
+
+import aiohttp
+import yt_dlp
+from pyrogram.types import Message
+from youtubesearchpython.__future__ import VideosSearch
+import scrapetube
+from innertube import InnerTube
+from pprint import pprint
+
+
+import config
+from YukkiMusic.utils.database import is_on_off
+from YukkiMusic.utils.formatters import time_to_seconds
+
+
+async def shell_cmd(cmd):
+    proc = await asyncio.create_subprocess_shell(
+        cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    out, errorz = await proc.communicate()
+    if errorz:
+        if (
+            "unavailable videos are hidden"
+            in (errorz.decode("utf-8")).lower()
+        ):
+            return out.decode("utf-8")
+        else:
+            return errorz.decode("utf-8")
+    return out.decode("utf-8")
+
+
+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 == "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 == "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:
+            link1 = self.base + link
+        if "&" in link:
+            link1 = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            title = result["title"]
+            duration_min = result["duration"]
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+            vidid = result["id"]
+            if str(duration_min) == "None":
+                duration_sec = 0
+            else:
+                duration_sec = int(time_to_seconds(duration_min))
+        return title, duration_min, duration_sec, thumbnail, vidid
+
+    async def title(
+        self, link: str, videoid: Union[bool, str] = None
+    ):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            title = result["title"]
+        return title
+
+    async def duration(
+        self, link: str, videoid: Union[bool, str] = None
+    ):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            duration = result["duration"]
+        return duration
+
+    async def thumbnail(
+        self, link: str, videoid: Union[bool, str] = None
+    ):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        for result in (await results.next())["result"]:
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+        return thumbnail
+
+    async def video(
+        self, link: str, videoid: Union[bool, str] = None
+    ):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        proc = await asyncio.create_subprocess_exec(
+            "yt-dlp",
+            "-g",
+            "-f",
+            "best[height<=?720][width<=?1280]",
+            f"{link}",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        if stdout:
+            return 1, stdout.decode().split("\n")[0]
+        else:
+            return 0, stderr.decode()
+
+    async def playlist(
+        self, link, limit, user_id, videoid: Union[bool, str] = None
+    ):
+        if videoid:
+            link1 = self.listbase + link
+        if "&" in link:
+            link1 = link.split("&")[0]
+        playlist = await shell_cmd(
+            f"yt-dlp -i --get-id --flat-playlist --playlist-end {limit} --skip-download {link}"
+        )
+        try:
+            result = playlist.split("\n")
+            for key in result:
+                if key == "":
+                    result.remove(key)
+        except:
+            result = []
+        return result
+
+    async def track(
+        self, link: str, videoid: Union[bool, str] = None
+    ):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        results = VideosSearch(link, limit=1)
+        #results = scrapetube.get_search(link,limit=1)
+        for result in (await results.next())["result"]:
+            #print(result)
+            title = result["id"] if result["title"]=='' else 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,
+        }
+        '''
+        for result in results:
+            print(result)
+            title = result['title']['runs']['text']
+            duration_min = result['lengthText']['simpleText']
+            vidid = result['videoId']
+            yturl = link
+            thumbnail = result['thumbnail']['thumbnails'][0]['url']
+
+            
+        track_details = {
+                "title":title ,
+                "link": link,
+                "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}
+        ydl = yt_dlp.YoutubeDL(ytdl_opts)
+        with ydl:
+            formats_available = []
+            r = ydl.extract_info(link, download=False)
+            for format in r["formats"]:
+                try:
+                    str(format["format"])
+                except:
+                    continue
+                if not "dash" in str(format["format"]).lower():
+                    try:
+                        format["format"]
+                        format["filesize"]
+                        format["format_id"]
+                        format["ext"]
+                        format["format_note"]
+                    except:
+                        continue
+                    formats_available.append(
+                        {
+                            "format": format["format"],
+                            "filesize": format["filesize"],
+                            "format_id": format["format_id"],
+                            "ext": format["ext"],
+                            "format_note": format["format_note"],
+                            "yturl": link,
+                        }
+                    )
+        return formats_available, link
+
+    async def slider(
+        self,
+        link: str,
+        query_type: int,
+        videoid: Union[bool, str] = None,
+    ):
+        if videoid:
+            link = self.base + link
+        if "&" in link:
+            link = link.split("&")[0]
+        a = VideosSearch(link, limit=10)
+        result = (await a.next()).get("result")
+        title = result[query_type]["title"]
+        duration_min = result[query_type]["duration"]
+        vidid = result[query_type]["id"]
+        thumbnail = result[query_type]["thumbnails"][0]["url"].split(
+            "?"
+        )[0]
+        return title, duration_min, thumbnail, vidid
+
+    async def download(
+        self,
+        link: str,
+        mystic,
+        video: Union[bool, str] = None,
+        videoid: Union[bool, str] = None,
+        songaudio: Union[bool, str] = None,
+        songvideo: Union[bool, str] = None,
+        format_id: Union[bool, str] = None,
+        title: Union[bool, str] = None,
+    ) -> str:
+        if videoid:
+            link = self.base + link
+        loop = asyncio.get_running_loop()
+
+        def audio_dl():
+            ydl_optssx = {
+                "format": "bestaudio/best",
+                "outtmpl": "downloads/%(id)s.%(ext)s",
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "no_warnings": True,
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            info = x.extract_info(link, False)
+            xyz = os.path.join(
+                "downloads", f"{info['id']}.{info['ext']}"
+            )
+            if os.path.exists(xyz):
+                return xyz
+            x.download([link])
+            return xyz
+
+        def video_dl():
+            ydl_optssx = {
+                "format": "(bestvideo[height<=?720][width<=?1280][ext=mp4])+(bestaudio[ext=m4a])",
+                "outtmpl": "downloads/%(id)s.%(ext)s",
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "no_warnings": True,
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            info = x.extract_info(link, False)
+            xyz = os.path.join(
+                "downloads", f"{info['id']}.{info['ext']}"
+            )
+            if os.path.exists(xyz):
+                return xyz
+            x.download([link])
+            return xyz
+
+        def song_video_dl():
+            formats = f"{format_id}+140"
+            fpath = f"downloads/{title}"
+            ydl_optssx = {
+                "format": formats,
+                "outtmpl": fpath,
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "no_warnings": True,
+                "prefer_ffmpeg": True,
+                "merge_output_format": "mp4",
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            x.download([link])
+
+        def song_audio_dl():
+            fpath = f"downloads/{title}.%(ext)s"
+            ydl_optssx = {
+                "format": format_id,
+                "outtmpl": fpath,
+                "geo_bypass": True,
+                "nocheckcertificate": True,
+                "quiet": True,
+                "no_warnings": True,
+                "prefer_ffmpeg": True,
+                "postprocessors": [
+                    {
+                        "key": "FFmpegExtractAudio",
+                        "preferredcodec": "mp3",
+                        "preferredquality": "192",
+                    }
+                ],
+            }
+            x = yt_dlp.YoutubeDL(ydl_optssx)
+            x.download([link])
+
+        if songvideo:
+            await loop.run_in_executor(None, song_video_dl)
+            fpath = f"downloads/{title}.mp4"
+            return fpath
+        elif songaudio:
+            await loop.run_in_executor(None, song_audio_dl)
+            fpath = f"downloads/{title}.mp3"
+            return fpath
+        elif video:
+            if await is_on_off(config.YTDOWNLOADER):
+                direct = True
+                downloaded_file = await loop.run_in_executor(
+                    None, video_dl
+                )
+            else:
+                proc = await asyncio.create_subprocess_exec(
+                    "yt-dlp",
+                    "-g",
+                    "-f",
+                    "best[height<=?720][width<=?1280]",
+                    f"{link}",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, stderr = await proc.communicate()
+                if stdout:
+                    downloaded_file = stdout.decode().split("\n")[0]
+                    direct = None
+                else:
+                    return
+        else:
+            direct = True
+            downloaded_file = await loop.run_in_executor(
+                None, audio_dl
+            )
+        return downloaded_file, direct
+    async def audio_video_url(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:
+            video_id= link
+        loop = asyncio.get_running_loop()
+        
+        def get_audio_url():
+            #yclient = InnerTube("ANDROID_TV")
+            yclient = InnerTube("ANDROID_LITE")
+            # Fetch the player data for the video
+            data = yclient.player(video_id)
+
+            # List of streams of the video
+            streams = data["streamingData"]["adaptiveFormats"]
+            for stream in streams:
+                if stream["mimeType"].find('video'):
+                    audio_url=stream['url']
+                    break
+                else:
+                    continue
+            return audio_url
+        def get_video_url():
+
+            #yclient = InnerTube("ANDROID_TV")
+            yclient = InnerTube("ANDROID_LITE")
+
+            
+            # Fetch the player data for the video
+            data = yclient.player(video_id)
+
+            # List of streams of the video
+            streams = data["streamingData"]["adaptiveFormats"]
+            for stream in streams:
+                if stream["mimeType"].find('audio'):
+                    video_url=stream['url']
+                    break
+                else:
+                    continue
+            return video_url
+        video_url = await loop.run_in_executor(
+                    None, get_video_url
+                )
+        audio_url = await loop.run_in_executor(
+                    None, get_audio_url
+                )
+        
+        return video_url, audio_url

YukkiMusic/platforms/YoutubeAPI/BS4scrapAPI.py

@@ -0,0 +1,179 @@
+
+from bs4 import BeautifulSoup
+from urllib.request import urlopen
+from urllib.parse import urlencode
+import requests
+import re
+import json
+
+
+
+async def extract_json_tranding(data):
+    # Join the list into a single string
+    combined_str = ''.join(data)
+
+    # Use regular expression to find the JSON data after 'ytInitialData = '
+    match = re.search(r'var ytInitialData\s*=\s*(\{.*\});', combined_str)
+
+    if match:
+        json_str = match.group(1)  # Extract the JSON string
+        json_str = json_str.encode('utf-8').decode('unicode_escape')
+        try:
+            # Parse the JSON data
+            json_data = json.loads(json_str)
+            return json_data
+        except json.JSONDecodeError as e:
+            print("Error decoding JSON:", e)
+            return None
+    else:
+        print("No JSON data found.")
+        return None
+
+
+
+async def search_videos(query):
+    searchresult_list=[]
+    
+    final_query={'search_query':query,'sp':'EgIQAQ%253D%253D','persist_gl':'IN'}
+    param=urlencode(final_query)
+    url = urlopen(f'https://www.youtube.com/results?{param}').read()
+    soup = BeautifulSoup(url, 'lxml')
+    allscript = soup.findAll('script')
+    text = ''
+    for script in allscript:
+        if 'var ytInitialData' in str(script.contents):
+            text = str(script.contents)
+        else:
+            continue
+
+    json_data = await extract_json_tranding(text)
+    all_search_video = json_data.get('contents', {}).get(
+    'twoColumnSearchResultsRenderer',
+    {}).get('primaryContents',
+            {}).get('sectionListRenderer',
+                    {}).get('contents', [])[0].get('itemSectionRenderer',
+                                                   {}).get('contents', [])
+    
+    for video in all_search_video:
+        if video.get('videoRenderer', {}):
+            if video.get('videoRenderer',{}).get('descriptionSnippet',{}):
+                description=video['videoRenderer']['descriptionSnippet']['runs'][0]['text']
+            else:
+                description=''
+            details={
+                "id":video['videoRenderer']['videoId'],
+                "title":video['videoRenderer']['title']['runs'][0]['text'],
+                "thumbnails":video['videoRenderer']['thumbnail']['thumbnails'],
+                "description":description,
+                "publishedTime":video['videoRenderer']['publishedTimeText']['simpleText'] if video.get('videoRenderer',{}).get('publishedTimeText',{}) else '' ,
+                "length":video['videoRenderer']['lengthText']['simpleText'] if video.get('videoRenderer',{}).get('lengthText',{}) else '',
+                "views":video['videoRenderer']['viewCountText']['simpleText'] if video.get('videoRenderer',{}).get('viewCountText',{}).get('simpleText','') else '',
+                "url":f"https://www.youtube.com{video['videoRenderer']['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url']}",
+                "short_views":video['videoRenderer']['shortViewCountText']['simpleText'] if video.get('videoRenderer',{}).get('shortViewCountText',{}).get('simpleText','') else '',
+                "channelThumbnail":video['videoRenderer']['channelThumbnailSupportedRenderers']['channelThumbnailWithLinkRenderer']['thumbnail']['thumbnails'][0]['url'] if video.get('videoRenderer',{}).get('channelThumbnailSupportedRenderers',{}) else '',
+                "channel":video['videoRenderer']['ownerText']['runs'][0]['text']
+
+            }
+            searchresult_list.append(details)
+        elif video.get('childVideoRenderer', {}):
+            if video.get('childVideoRenderer',{}).get('descriptionSnippet',{}):
+                description=video['childVideoRenderer']['descriptionSnippet']['runs'][0]['text']
+            else:
+                description=''
+            details={
+                "id":video['childVideoRenderer']['videoId'],
+                "title":video['childVideoRenderer']['title']['runs'][0]['text'],
+                "thumbnails":video['childVideoRenderer']['thumbnail']['thumbnails'],
+                "description":description,
+                "publishedTime":video['childVideoRenderer']['publishedTimeText']['simpleText'] if video.get('childVideoRenderer',{}).get('publishedTimeText',{}) else '' ,
+                "length":video['childVideoRenderer']['lengthText']['simpleText'] if video.get('childVideoRenderer',{}).get('lengthText',{}) else '',
+                "views":video['childVideoRenderer']['viewCountText']['simpleText'] if video.get('childVideoRenderer',{}).get('viewCountText',{}).get('simpleText','') else '',
+                "url":f"https://www.youtube.com{video['childVideoRenderer']['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url']}",
+                "short_views":video['childVideoRenderer']['shortViewCountText']['simpleText'] if video.get('childVideoRenderer',{}).get('shortViewCountText',{}).get('simpleText','') else '',
+                "channelThumbnail":video['childVideoRenderer']['channelThumbnailSupportedRenderers']['channelThumbnailWithLinkRenderer']['thumbnail']['thumbnails'][0]['url'] if video.get('childVideoRenderer',{}).get('channelThumbnailSupportedRenderers',{}) else '',
+                "channel":video['childVideoRenderer']['ownerText']['runs'][0]['text']
+
+            }
+            searchresult_list.append(details)
+        elif video.get('gridVideoRenderer', {}):
+            if video.get('gridVideoRenderer',{}).get('descriptionSnippet',{}):
+                description=video['gridVideoRenderer']['descriptionSnippet']['runs'][0]['text']
+            else:
+                description=''
+            details={
+                "id":video['gridVideoRenderer']['videoId'],
+                "title":video['gridVideoRenderer']['title']['runs'][0]['text'],
+                "thumbnails":video['gridVideoRenderer']['thumbnail']['thumbnails'],
+                "description":description,
+                "publishedTime":video['gridVideoRenderer']['publishedTimeText']['simpleText'] if video.get('gridVideoRenderer',{}).get('publishedTimeText',{}) else '' ,
+                "length":video['gridVideoRenderer']['lengthText']['simpleText'] if video.get('gridVideoRenderer',{}).get('lengthText',{}) else '',
+                "views":video['gridVideoRenderer']['viewCountText']['simpleText'] if video.get('gridVideoRenderer',{}).get('viewCountText',{}).get('simpleText','') else '',
+                "url":f"https://www.youtube.com{video['gridVideoRenderer']['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url']}",
+                "short_views":video['gridVideoRenderer']['shortViewCountText']['simpleText'] if video.get('gridVideoRenderer',{}).get('shortViewCountText',{}).get('simpleText','') else '',
+                "channelThumbnail":video['gridVideoRenderer']['channelThumbnailSupportedRenderers']['channelThumbnailWithLinkRenderer']['thumbnail']['thumbnails'][0]['url'] if video.get('gridVideoRenderer',{}).get('channelThumbnailSupportedRenderers',{}) else '',
+                "channel":video['gridVideoRenderer']['ownerText']['runs'][0]['text']
+
+            }
+            searchresult_list.append(details)
+    #print(url,searchresult_list)
+    return searchresult_list
+
+
+
+async def tranding_videos():
+    tranding_list=[]
+    url = urlopen('https://www.youtube.com/feed/trending/?persist_gl=1&gl=IN').read()
+    soup = BeautifulSoup(url, 'lxml')
+    allscript = soup.findAll('script')
+    text = ''
+    for script in allscript:
+        if 'var ytInitialData' in str(script.contents):
+            text = str(script.contents)
+        else:
+            continue
+
+    json_data = await extract_json_tranding(text)
+    
+    all_video = json_data.get('contents', {}).get(
+        'twoColumnBrowseResultsRenderer',
+        {}).get('tabs', [])[0].get('tabRenderer', {}).get('content', {}).get(
+            'sectionListRenderer',
+            {}).get('contents', [])[3].get('itemSectionRenderer', {}).get(
+                'contents',
+                [])[0].get('shelfRenderer',
+                        {}).get('content',
+                                {}).get('expandedShelfContentsRenderer',
+                                        {}).get('items', [])
+    #"descriptions":video['videoRenderer']['descriptionSnippet']['runs'][0]['text'],
+    '''nextPageToken = json_data['contents']['twoColumnSearchResultsRenderer']['primaryContents']['sectionListRenderer']['contents'][1]['continuationItemRenderer']['continuationEndpoint']['continuationCommand']['token'] if json_data.get('contents', {}).get(
+    'twoColumnSearchResultsRenderer',
+    {}).get('primaryContents',
+            {}).get('sectionListRenderer',
+                    {}).get('contents', [])[1].get('continuationItemRenderer',{}).get('continuationEndpoint',{}).get('continuationCommand',{}).get('token','') else None
+    '''
+
+
+
+    for video in all_video:
+        if video.get('videoRenderer',{}).get('descriptionSnippet',{}):
+            description=video['videoRenderer']['descriptionSnippet']['runs'][0]['text']
+        else:
+            description=''
+        details={
+                "id":video['videoRenderer']['videoId'],
+                "title":video['videoRenderer']['title']['runs'][0]['text'],
+                "thumbnails":video['videoRenderer']['thumbnail']['thumbnails'],
+                "description":description,
+                "publishedTime":video['videoRenderer']['publishedTimeText']['simpleText'] if video.get('videoRenderer',{}).get('publishedTimeText',{}) else '' ,
+                "length":video['videoRenderer']['lengthText']['simpleText'] if video.get('videoRenderer',{}).get('lengthText',{}) else '',
+                "views":video['videoRenderer']['viewCountText']['simpleText'] if video.get('videoRenderer',{}).get('viewCountText',{}).get('simpleText','') else '',
+                "url":f"https://www.youtube.com{video['videoRenderer']['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url']}",
+                "short_views":video['videoRenderer']['shortViewCountText']['simpleText'] if video.get('videoRenderer',{}).get('shortViewCountText',{}).get('simpleText','') else '',
+                "channelThumbnail":video['videoRenderer']['channelThumbnailSupportedRenderers']['channelThumbnailWithLinkRenderer']['thumbnail']['thumbnails'][0]['url'] if video.get('videoRenderer',{}).get('channelThumbnailSupportedRenderers',{}) else '',
+                "channel":video['videoRenderer']['ownerText']['runs'][0]['text']
+
+            }
+        tranding_list.append(details)
+    #print(tranding_list)
+    return tranding_list
+

YukkiMusic/platforms/YoutubeAPI/InnertubeAPI.py

@@ -0,0 +1,250 @@
+from urllib.request import urlopen
+from urllib.parse import urlencode
+import requests
+import re
+import json
+import asyncio
+import aiohttp
+from .JSON_DATA import *
+
+async def trending_with_post_api(query):
+    #res = requests.get('https://www.youtube.com/')
+    searchresult_list=[]
+
+    key_value ={
+        "now":"",
+        "music":"4gINGgt5dG1hX2NoYXJ0cw%3D%3D",
+        "gaming":"4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D",
+        "movies":"4gIKGgh0cmFpbGVycw%3D%3D",
+    }
+    
+    final_query={
+        "browseId": "FEtrending",
+        "params": key_value.get(query),
+        "context": {
+            "client": {
+                "hl":"en",
+                "gl":"IN",
+            "clientName": "WEB",
+            "clientVersion": "2.20230728.00.00"
+            
+            }
+        }
+        }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+                'https://youtubei.googleapis.com/youtubei/v1/browse',
+                json=final_query) as response:
+            
+            json_data= await response.text()
+            json_data=json.loads(json_data)
+
+    
+    key_value_list=list(key_value.keys())
+    print(key_value_list,key_value_list.index(query))
+    all_search_video = json_data.get('contents', {}).get('twoColumnBrowseResultsRenderer',{}).get('tabs',[])[ key_value_list.index(query) ].get('tabRenderer',{}).get('content', {}).get('sectionListRenderer',{}).get('contents', [])[0].get('itemSectionRenderer',{}).get('contents', [])[0].get('shelfRenderer',{}).get('content',{}).get('expandedShelfContentsRenderer',{}).get('items',[])
+    #.get('twoColumnSearchResultsRenderer',{}).get('tabs',[])
+    #.get('sectionListRenderer',{}).get('contents', [])[0].get('itemSectionRenderer',{}).get('contents', [])[0].get('shelfRenderer',{}).get('content',{}).get('expandedShelfContentsRenderer',{}).get('items',[])
+    #return all_search_video
+    for video in all_search_video:
+        if video.get('videoRenderer', {}):
+            searchresult_list.append(JSON_videoRenderer_Formatter(video))
+
+    if query == 'now':
+        all_video_Now = json_data.get('contents', {}).get('twoColumnBrowseResultsRenderer',{}).get('tabs',[])[ key_value_list.index(query) ].get('tabRenderer',{}).get('content', {}).get('sectionListRenderer',{}).get('contents', [])[2].get('itemSectionRenderer',{}).get('contents', [])[0].get('shelfRenderer',{}).get('content',{}).get('expandedShelfContentsRenderer',{}).get('items',[])
+        for video in all_video_Now:
+            if video.get('videoRenderer', {}):
+                searchresult_list.append(JSON_videoRenderer_Formatter(video))
+
+    return searchresult_list
+                
+
+
+
+async def search_videos_with_post_api(query):
+    searchresult_list=[]
+    final_query={
+                "query": query, 
+                "key":"AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+                "context": {
+                    "client": {
+                        "clientName": "WEB",
+                        "clientVersion": "2.20230728.00.00"
+                    }
+                }
+                }
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+                'https://youtubei.googleapis.com/youtubei/v1/search',
+                json=final_query) as response:
+            
+            json_data= await response.text()
+            json_data=json.loads(json_data)
+    
+    all_search_video = json_data.get('contents', {}).get(
+    'twoColumnSearchResultsRenderer',
+    {}).get('primaryContents',
+            {}).get('sectionListRenderer',
+                    {}).get('contents', [])[0].get('itemSectionRenderer',
+                                                   {}).get('contents', [])
+    
+    nextPageToken = json_data['contents']['twoColumnSearchResultsRenderer']['primaryContents']['sectionListRenderer']['contents'][1]['continuationItemRenderer']['continuationEndpoint']['continuationCommand']['token'] if json_data.get('contents', {}).get(
+    'twoColumnSearchResultsRenderer',
+    {}).get('primaryContents',
+            {}).get('sectionListRenderer',
+                    {}).get('contents', [])[1].get('continuationItemRenderer',{}).get('continuationEndpoint',{}).get('continuationCommand',{}).get('token','') else None
+    
+
+
+    for video in all_search_video:
+        if video.get('videoRenderer', {}):
+            searchresult_list.append(JSON_videoRenderer_Formatter(video))
+
+        elif video.get('childVideoRenderer', {}): 
+            searchresult_list.append(JSON_childVideoRenderer_Formatter(video))
+
+        elif video.get('gridVideoRenderer', {}):
+            searchresult_list.append(JSON_childVideoRenderer_Formatter(video))
+
+    #print(url,searchresult_list)
+    return searchresult_list, nextPageToken
+
+async def search_scroll_videos_with_post_api(query):
+    searchresult_list=[]
+    
+    final_query={
+        "continuation": query, 
+        "key":"AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8", 
+        "context": {
+            "client": {
+                "clientName": "WEB", 
+                "clientVersion": "2.20230728.00.00"
+                }
+                }
+            }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+                'https://youtubei.googleapis.com/youtubei/v1/search',
+                json=final_query) as response:
+            
+            json_data= await response.text()
+            json_data=json.loads(json_data)
+    #return json_data
+    all_search_video = json_data.get('onResponseReceivedCommands', [])[0].get(
+    'appendContinuationItemsAction',
+    {}).get('continuationItems',
+            [])[0].get('itemSectionRenderer',
+                    {}).get('contents', [])
+    
+
+    nextPageToken =json_data['onResponseReceivedCommands'][0]['appendContinuationItemsAction']['continuationItems'][1]['continuationItemRenderer']['continuationEndpoint']['continuationCommand']['token'] if len(json_data.get('onResponseReceivedCommands', [])) > 0 and json_data.get('onResponseReceivedCommands', [])[0].get(
+    'appendContinuationItemsAction',
+    {}).get('continuationItems',
+            [])[1].get('continuationItemRenderer',{}).get('continuationEndpoint',{}).get('continuationCommand',{}).get('token','') else None
+    
+
+    for video in all_search_video:
+        if video.get('videoRenderer', {}):
+            searchresult_list.append(JSON_videoRenderer_Formatter(video))
+
+        elif video.get('childVideoRenderer', {}): 
+            searchresult_list.append(JSON_childVideoRenderer_Formatter(video))
+
+        elif video.get('gridVideoRenderer', {}):
+            searchresult_list.append(JSON_childVideoRenderer_Formatter(video))
+
+    #print(url,searchresult_list)
+    return searchresult_list, nextPageToken
+
+
+
+#####-------------RETURN VIDEO LIST WITH STREAMING URL BY VIDEO ID------######
+async def search_player_data_with_post_api(query):
+    searchresult_list=[]
+    
+    
+    final_query={
+                "videoId": query, 
+                "key":"AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+                "context": {
+                    "client": {
+                        "clientName": "ANDROID_TV",
+                        "clientVersion": "2.16.032"
+                        }
+                    }
+                }
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+                'https://youtubei.googleapis.com/youtubei/v1/player',
+                json=final_query) as response:
+            
+            json_data= await response.text()
+            json_data=json.loads(json_data)
+    #return json_data
+    all_formats_video = json_data.get('streamingData', {}).get(
+    'formats',
+    [])
+    all_adaptive_formats_video = json_data.get('streamingData', {}).get(
+    'adaptiveFormats',
+    [])
+    '''   video details content JSON DATA {} with key:value
+    demo data 
+    {
+        "videoId": "k3g_WjLCsXM",
+        "title": "Sajni (Song): Arijit Singh, Ram Sampath | Laapataa Ladies |  Aamir Khan Productions",
+        "lengthSeconds": "146",
+        "keywords": [
+            "sajni laapata ladies",
+            "sajni laapataa ladies",
+            "sajni"
+        ],
+        "channelId": "UCq-Fj5jknLsUf-MWSy4_brA",
+        "isOwnerViewing": false,
+        "shortDescription": "Presenting the Song \"Sajni\" from the upcoming film Laapataa Ladies. Sung by Arijit Singh, Composed by Ram Sampath and Penned by Prashant Pandey.\n\n#LaapataaLadies #Sajni #ArijitSingh #RamSampath\n\nJio Studios Presents \nAamir Khan Productions \"LAAPATAA LADIES\" \n\n♪Full Song Available on♪ \nJioSaavn: https://bit.ly/3SV0n0w\nSpotify: https://bit.ly/3wgICzV\nHungama: https://bit.ly/499FkNy\nApple Music: https://bit.ly/3SEqRlL\nAmazon Prime Music: https://bit.ly/3Uxi1Zv\nWynk: https://bit.ly/3uwyX7O\nYouTube Music: https://bit.ly/4bzkV5R\n\nSong Credits:\nSong Name: Sajni\nComposed By : Ram Sampath\nLyricist : Prashant Pandey\nSinger : Arijit Singh\nMusic Arranged & Produced by : Ram Sampath\nMusic Supervisor : Vrashal Chavan\nRecorded & Mixed at Omgrown Music, Mumbai by Amey Wadibhasme\nMastered by Gethin John at Hafod Mastering\nVocal Recordist : Sukanto Singha\nVocal Editor : Prithviraj Sarkar\nMusic Label: T-Series\n\nFilm Credits: \nDirected by Kiran Rao \nProduced by Aamir Khan, Kiran Rao & Jyoti Deshpande\nStarring : Nitanshi Goel, Pratibha Ranta, Sparsh Shrivastava, Ravi Kishan and Chhaya Kadam\nCo Stars : Bhaskar Jha, Durgesh Kumar, Geeta Aggarwal, Pankaj Sharma, Rachna Gupta, Abeer Jain, Kirti Jain, Daood Hussain, Pranjal Pateriya, Samarth Mohar, Satendra Soni, Ravi Kapadiya, Kishore Soni. \nOriginal Story : Biplab Goswami \nScreenplay & Dialogues : Sneha Desai \nAdditional Dialogues : Divyanidhi Sharma \nMusic : Ram Sampath \nLyricists : Swanand Kirkire, Prashant Pandey, Divyanidhi Sharma \nSingers: Shreya Ghoshal, Arijit Singh, Sukhwinder Singh, Sona Mohapatra\nDirector of Photography : Vikash Nowlakha\nEditor : Jabeen Merchant \nProduction Designer : Vikram Singh \nCostume Designer : Darshan Jalan \nCasting : Romil Jain \nSound Designer : Ayush Ahuja \nProduction Sound Mixer : Ravi Dev Singh \nMake Up Designer : Kamlesh Shinde \nHair Designer : Joyce Fernandez \n1st Assistant Director : Rakesh E. Nair \nLine Producer : Jaspal Dogra \nScript Supervisor : Mandira Roy \nDialect Coach : Sonu Anand \nDirector's Assistant : Pooja Kumar \nColorist : Michele Ricossa \nVisual Effects Studio : SM Rolling \nVFX DI Studio : Prasad Labs \nVisual Promotions : Just Right Studioz NX \nAKP Finance Team : Sharada Harihar, Aditya Shah, Huzvak Batliwala, Pankti Mehta, Tejasvi Gurav, Manisha Abhyankar\nFinancial Advisor : Bimal Parekh & Co \nExecutive Producers : Antara Banerjee & Naved Farooqui \nCo-Producers : B. Shrinivas Rao & Tanaji Dasgupta \n\nDownload Song Beat: https://bit.ly/3Cjh24R \n\n___________________________________\nEnjoy & stay connected with us!\n👉 Subscribe to T-Series: https://youtube.com/tseries\n👉 Like us on Facebook: https://www.facebook.com/tseriesmusic\n👉 Follow us on X: https://twitter.com/tseries\n👉 Follow us on Instagram: https://instagram.com/tseries.official",
+        "isCrawlable": true,
+        "thumbnail": {
+            "thumbnails": [
+                {
+                    "url": "https://i.ytimg.com/vi/k3g_WjLCsXM/default.jpg",
+                    "width": 120,
+                    "height": 90
+                },
+                {
+                    "url": "https://i.ytimg.com/vi/k3g_WjLCsXM/mqdefault.jpg",
+                    "width": 320,
+                    "height": 180
+                },
+                {
+                    "url": "https://i.ytimg.com/vi/k3g_WjLCsXM/hqdefault.jpg",
+                    "width": 480,
+                    "height": 360
+                },
+                {
+                    "url": "https://i.ytimg.com/vi/k3g_WjLCsXM/sddefault.jpg",
+                    "width": 640,
+                    "height": 480
+                }
+            ]
+        },
+        "allowRatings": true,
+        "viewCount": "70761818",
+        "author": "T-Series",
+        "isPrivate": false,
+        "isUnpluggedCorpus": false,
+        "isLiveContent": false
+    }'''
+
+    videodetails = json_data.get('videoDetails', {})
+
+
+    for video in all_formats_video:
+        
+        searchresult_list.append(video)
+    for video in all_adaptive_formats_video:
+        
+        searchresult_list.append(video)
+        
+    #print(url,searchresult_list)
+    return searchresult_list, videodetails

YukkiMusic/platforms/YoutubeAPI/JSON_DATA.py

@@ -0,0 +1,58 @@
+def JSON_gridVideoRenderer_Formatter(video):
+    if video.get('gridVideoRenderer',{}).get('descriptionSnippet',{}):
+        description=video['gridVideoRenderer']['descriptionSnippet']['runs'][0]['text']
+    else:
+        description=''
+
+    return{
+        "id":video['gridVideoRenderer']['videoId'],
+        "title":video['gridVideoRenderer']['title']['runs'][0]['text'],
+        "thumbnails":video['gridVideoRenderer']['thumbnail']['thumbnails'],
+        "description":description,
+        "publishedTime":video['gridVideoRenderer']['publishedTimeText']['simpleText'] if video.get('gridVideoRenderer',{}).get('publishedTimeText',{}) else '' ,
+        "length":video['gridVideoRenderer']['lengthText']['simpleText'] if video.get('gridVideoRenderer',{}).get('lengthText',{}) else '',
+        "views":video['gridVideoRenderer']['viewCountText']['simpleText'] if video.get('gridVideoRenderer',{}).get('viewCountText',{}).get('simpleText','') else '',
+        "url":f"https://www.youtube.com{video['gridVideoRenderer']['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url']}",
+        "short_views":video['gridVideoRenderer']['shortViewCountText']['simpleText'] if video.get('gridVideoRenderer',{}).get('shortViewCountText',{}).get('simpleText','') else '',
+        "channelThumbnail":video['gridVideoRenderer']['channelThumbnailSupportedRenderers']['channelThumbnailWithLinkRenderer']['thumbnail']['thumbnails'][0]['url'] if video.get('gridVideoRenderer',{}).get('channelThumbnailSupportedRenderers',{}) else '',
+        "channel":video['gridVideoRenderer']['ownerText']['runs'][0]['text']
+        }
+        
+def JSON_childVideoRenderer_Formatter(video):
+    if video.get('childVideoRenderer',{}).get('descriptionSnippet',{}):
+        description=video['childVideoRenderer']['descriptionSnippet']['runs'][0]['text']
+    else:
+        description=''
+
+    return {
+        "id":video['childVideoRenderer']['videoId'],
+        "title":video['childVideoRenderer']['title']['runs'][0]['text'],
+        "thumbnails":video['childVideoRenderer']['thumbnail']['thumbnails'],
+        "description":description,
+        "publishedTime":video['childVideoRenderer']['publishedTimeText']['simpleText'] if video.get('childVideoRenderer',{}).get('publishedTimeText',{}) else '' ,
+        "length":video['childVideoRenderer']['lengthText']['simpleText'] if video.get('childVideoRenderer',{}).get('lengthText',{}) else '',
+        "views":video['childVideoRenderer']['viewCountText']['simpleText'] if video.get('childVideoRenderer',{}).get('viewCountText',{}).get('simpleText','') else '',
+        "url":f"https://www.youtube.com{video['childVideoRenderer']['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url']}",
+        "short_views":video['childVideoRenderer']['shortViewCountText']['simpleText'] if video.get('childVideoRenderer',{}).get('shortViewCountText',{}).get('simpleText','') else '',
+        "channelThumbnail":video['childVideoRenderer']['channelThumbnailSupportedRenderers']['channelThumbnailWithLinkRenderer']['thumbnail']['thumbnails'][0]['url'] if video.get('childVideoRenderer',{}).get('channelThumbnailSupportedRenderers',{}) else '',
+        "channel":video['childVideoRenderer']['ownerText']['runs'][0]['text']
+    }
+
+def JSON_videoRenderer_Formatter(video):
+    if video.get('videoRenderer',{}).get('descriptionSnippet',{}):
+        description=video['videoRenderer']['descriptionSnippet']['runs'][0]['text']
+    else:
+        description=''
+    return{
+        "id":video['videoRenderer']['videoId'],
+        "title":video['videoRenderer']['title']['runs'][0]['text'],
+        "thumbnails":video['videoRenderer']['thumbnail']['thumbnails'],
+        "description":description,
+        "publishedTime":video['videoRenderer']['publishedTimeText']['simpleText'] if video.get('videoRenderer',{}).get('publishedTimeText',{}) else '' ,
+        "length":video['videoRenderer']['lengthText']['simpleText'] if video.get('videoRenderer',{}).get('lengthText',{}) else '',
+        "views":video['videoRenderer']['viewCountText']['simpleText'] if video.get('videoRenderer',{}).get('viewCountText',{}).get('simpleText','') else '',
+        "url":f"https://www.youtube.com{video['videoRenderer']['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url']}",
+        "short_views":video['videoRenderer']['shortViewCountText']['simpleText'] if video.get('videoRenderer',{}).get('shortViewCountText',{}).get('simpleText','') else '',
+        "channelThumbnail":video['videoRenderer']['channelThumbnailSupportedRenderers']['channelThumbnailWithLinkRenderer']['thumbnail']['thumbnails'][0]['url'] if video.get('videoRenderer',{}).get('channelThumbnailSupportedRenderers',{}) else '',
+        "channel":video['videoRenderer']['ownerText']['runs'][0]['text']
+    }

YukkiMusic/platforms/__init__.py

@@ -0,0 +1,16 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+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

YukkiMusic/platforms/custom_dl.py

@@ -0,0 +1,185 @@
+import asyncio
+import logging
+from typing import Dict, Union
+from YukkiMusic.core.userbot import work_loads
+from pyrogram import Client, utils, raw
+#from .file_properties import get_file_ids
+from pyrogram.session import Session, Auth
+from pyrogram.errors import AuthBytesInvalid
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from pyrogram.types import Message
+
+
+class ByteStreamer:
+
+  def __init__(self, client: Client):
+    self.clean_timer = 30 * 60
+    self.client: Client = client
+    self.cached_file_ids: Dict[str, FileId] = {}
+    asyncio.create_task(self.clean_cache())
+
+  
+
+  async def generate_media_session(self, client: Client,
+                                   file_id: FileId) -> Session:
+    """
+        Generates the media session for the DC that contains the media file.
+        This is required for getting the bytes from Telegram servers.
+        """
+
+    media_session = client.media_sessions.get(file_id.dc_id, None)
+
+    if media_session is None:
+      if file_id.dc_id != await client.storage.dc_id():
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await Auth(client, file_id.dc_id, await
+                       client.storage.test_mode()).create(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+
+        for _ in range(6):
+          exported_auth = await client.invoke(
+              raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id))
+
+          try:
+            await media_session.invoke(
+                raw.functions.auth.ImportAuthorization(
+                    id=exported_auth.id, bytes=exported_auth.bytes))
+            break
+          except AuthBytesInvalid:
+            logging.debug(
+                f"Invalid authorization bytes for DC {file_id.dc_id}")
+            continue
+        else:
+          await media_session.stop()
+          raise AuthBytesInvalid
+      else:
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await client.storage.auth_key(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+      logging.debug(f"Created media session for DC {file_id.dc_id}")
+      client.media_sessions[file_id.dc_id] = media_session
+    else:
+      logging.debug(f"Using cached media session for DC {file_id.dc_id}")
+    return media_session
+
+  @staticmethod
+  async def get_location(
+      file_id: FileId
+  ) -> Union[
+      raw.types.InputPhotoFileLocation,
+      raw.types.InputDocumentFileLocation,
+      raw.types.InputPeerPhotoFileLocation,
+  ]:
+    """
+        Returns the file location for the media file.
+        """
+    file_type = file_id.file_type
+
+    if file_type == FileType.CHAT_PHOTO:
+      if file_id.chat_id > 0:
+        peer = raw.types.InputPeerUser(user_id=file_id.chat_id,
+                                       access_hash=file_id.chat_access_hash)
+      else:
+        if file_id.chat_access_hash == 0:
+          peer = raw.types.InputPeerChat(chat_id=-file_id.chat_id)
+        else:
+          peer = raw.types.InputPeerChannel(
+              channel_id=utils.get_channel_id(file_id.chat_id),
+              access_hash=file_id.chat_access_hash,
+          )
+
+      location = raw.types.InputPeerPhotoFileLocation(
+          peer=peer,
+          volume_id=file_id.volume_id,
+          local_id=file_id.local_id,
+          big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
+      )
+    elif file_type == FileType.PHOTO:
+      location = raw.types.InputPhotoFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    else:
+      location = raw.types.InputDocumentFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    return location
+
+  async def yield_file(
+      self,
+      file_id: FileId,
+      index: int,
+      offset: int,
+      first_part_cut: int,
+      last_part_cut: int,
+      part_count: int,
+      chunk_size: int,
+  ) -> Union[str, None]:
+
+    client = self.client
+    #work_loads[index] += 1
+    logging.debug(f"Starting to yielding file with client {index}.")
+    media_session = await self.generate_media_session(client, file_id)
+
+    current_part = 1
+
+    location = await self.get_location(file_id)
+
+    try:
+      r = await media_session.invoke(
+          raw.functions.upload.GetFile(location=location,
+                                       offset=offset,
+                                       limit=chunk_size), )
+      if isinstance(r, raw.types.upload.File):
+        while True:
+          chunk = r.bytes
+          if not chunk:
+            break
+          elif part_count == 1:
+            yield chunk[first_part_cut:last_part_cut]
+          elif current_part == 1:
+            yield chunk[first_part_cut:]
+          elif current_part == part_count:
+            yield chunk[:last_part_cut]
+          else:
+            yield chunk
+
+          current_part += 1
+          offset += chunk_size
+
+          if current_part > part_count:
+            break
+
+          r = await media_session.invoke(
+              raw.functions.upload.GetFile(location=location,
+                                           offset=offset,
+                                           limit=chunk_size), )
+    except (TimeoutError, AttributeError):
+      pass
+    finally:
+      logging.debug(f"Finished yielding file with {current_part} parts.")
+      #work_loads[index] -= 1
+
+  async def clean_cache(self) -> None:
+    """
+        function to clean the cache to reduce memory usage
+        """
+    while True:
+      await asyncio.sleep(self.clean_timer)
+      self.cached_file_ids.clear()
+      logging.debug("Cleaned the cache")

YukkiMusic/platforms/file_properties.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+import logging
+from datetime import datetime
+from pyrogram import Client
+from typing import Any, Optional
+
+from pyrogram.enums import ParseMode, ChatType
+from pyrogram.types import Message
+from pyrogram.file_id import FileId
+#-----------------------------------------------------
+
+
+
+
+#------------------------------
+def get_media_from_message(message: "Message") -> Any:
+  media_types = (
+      "audio",
+      "document",
+      "photo",
+      "sticker",
+      "animation",
+      "video",
+      "voice",
+      "video_note",
+  )
+  for attr in media_types:
+    media = getattr(message, attr, None)
+    if media:
+      return media
+
+
+def get_media_file_size(m):
+  media = get_media_from_message(m)
+  return getattr(media, "file_size", "None")
+
+
+def get_name(media_msg: Message | FileId) -> str:
+  if isinstance(media_msg, Message):
+    media = get_media_from_message(media_msg)
+    file_name = getattr(media, "file_name", "")
+
+  elif isinstance(media_msg, FileId):
+    file_name = getattr(media_msg, "file_name", "")
+
+  if not file_name:
+    if isinstance(media_msg, Message) and media_msg.media:
+      media_type = media_msg.media.value
+    elif media_msg.file_type:
+      media_type = media_msg.file_type.name.lower()
+    else:
+      media_type = "file"
+
+    formats = {
+        "photo": "jpg",
+        "audio": "mp3",
+        "voice": "ogg",
+        "video": "mp4",
+        "animation": "mp4",
+        "video_note": "mp4",
+        "sticker": "webp"
+    }
+
+    ext = formats.get(media_type)
+    ext = "." + ext if ext else ""
+
+    date = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    file_name = f"{media_type}-{date}{ext}"
+
+  return file_name
+
+
+def get_file_info(message):
+  media = get_media_from_message(message)
+  """
+  //Used a single Liner Insted of this Block
+  if message.chat.type == ChatType.PRIVATE:
+      user_idx = message.from_user.id
+  else:
+      user_idx = message.chat.id
+  """
+
+  return {
+      
+      "message_id": message.id,
+      "location": message.from_user.id if (message.chat.type == ChatType.PRIVATE) else message.chat.id,
+      "file": {
+          "file_id": getattr(media, "file_id", ""),
+          "file_unique_id": getattr(media, "file_unique_id", ""),
+          "file_name": get_name(message),
+          "file_size": getattr(media, "file_size", 0),
+          "mime_type": getattr(media, "mime_type", "None/unknown"),
+          
+      },
+  }
+
+
+

YukkiMusic/plugins/__init__.py

@@ -0,0 +1,31 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+#
+
+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"]

YukkiMusic/plugins/admins/auth.py

@@ -0,0 +1,159 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS, adminlist
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.utils.database import (delete_authuser, get_authuser,
+                                       get_authuser_names,
+                                       save_authuser)
+from YukkiMusic.utils.decorators import AdminActual, language
+from YukkiMusic.utils.formatters import int_to_alpha
+
+# Command
+AUTH_COMMAND = get_command("AUTH_COMMAND")
+UNAUTH_COMMAND = get_command("UNAUTH_COMMAND")
+AUTHUSERS_COMMAND = get_command("AUTHUSERS_COMMAND")
+
+
+@app.on_message(
+    filters.command(AUTH_COMMAND)
+    & 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 = message.text.split(None, 1)[1]
+        if "@" in user:
+            user = user.replace("@", "")
+        user = await app.get_users(user)
+        user_id = message.from_user.id
+        token = await int_to_alpha(user.id)
+        from_user_name = message.from_user.first_name
+        from_user_id = message.from_user.id
+        _check = await get_authuser_names(message.chat.id)
+        count = len(_check)
+        if int(count) == 20:
+            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": from_user_id,
+                "admin_name": from_user_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"])
+        else:
+            await message.reply_text(_["auth_3"])
+        return
+    from_user_id = message.from_user.id
+    user_id = message.reply_to_message.from_user.id
+    user_name = message.reply_to_message.from_user.first_name
+    token = await int_to_alpha(user_id)
+    from_user_name = message.from_user.first_name
+    _check = await get_authuser_names(message.chat.id)
+    count = 0
+    for smex in _check:
+        count += 1
+    if int(count) == 20:
+        return await message.reply_text(_["auth_1"])
+    if token not in _check:
+        assis = {
+            "auth_user_id": user_id,
+            "auth_name": user_name,
+            "admin_id": from_user_id,
+            "admin_name": from_user_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"])
+    else:
+        await message.reply_text(_["auth_3"])
+
+
+@app.on_message(
+    filters.command(UNAUTH_COMMAND)
+    & 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 = message.text.split(None, 1)[1]
+        if "@" in user:
+            user = user.replace("@", "")
+        user = await app.get_users(user)
+        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"])
+        else:
+            return await message.reply_text(_["auth_5"])
+    user_id = message.reply_to_message.from_user.id
+    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"])
+    else:
+        return await message.reply_text(_["auth_5"])
+
+
+@app.on_message(
+    filters.command(AUTHUSERS_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@language
+async def authusers(client, message: Message, _):
+    _playlist = await get_authuser_names(message.chat.id)
+    if not _playlist:
+        return await message.reply_text(_["setting_5"])
+    else:
+        j = 0
+        mystic = await message.reply_text(_["auth_6"])
+        text = _["auth_7"]
+        for note in _playlist:
+            _note = await get_authuser(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 Exception:
+                continue
+            text += f"{j}➤ {user}[`{user_id}`]\n"
+            text += f"   {_['auth_8']} {admin_name}[`{admin_id}`]\n\n"
+        await mystic.delete()
+        await message.reply_text(text)

YukkiMusic/plugins/admins/callback.py

@@ -0,0 +1,444 @@
+import random
+
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, InlineKeyboardMarkup
+
+from config import (AUTO_DOWNLOADS_CLEAR, BANNED_USERS,
+                    SOUNCLOUD_IMG_URL, STREAM_IMG_URL,
+                    TELEGRAM_AUDIO_URL, TELEGRAM_VIDEO_URL, adminlist)
+from YukkiMusic import YouTube, app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.misc import SUDOERS, db
+from YukkiMusic.utils.database import (is_active_chat,
+                                       is_music_playing, is_muted,
+                                       is_nonadmin_chat, music_off,
+                                       music_on, mute_off, mute_on,
+                                       set_loop)
+from YukkiMusic.utils.decorators.language import languageCB
+from YukkiMusic.utils.formatters import seconds_to_min
+from YukkiMusic.utils.inline.play import (panel_markup_1,
+                                          panel_markup_2,
+                                          panel_markup_3,
+                                          stream_markup,
+                                          telegram_markup)
+from YukkiMusic.utils.stream.autoclear import auto_clean
+from YukkiMusic.utils.thumbnails import gen_thumb
+
+wrong = {}
+
+
+@app.on_callback_query(filters.regex("PanelMarkup") & ~BANNED_USERS)
+@languageCB
+async def markup_panel(client, CallbackQuery: CallbackQuery, _):
+    await CallbackQuery.answer()
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    videoid, chat_id = callback_request.split("|")
+    chat_id = CallbackQuery.message.chat.id
+    buttons = panel_markup_1(_, videoid, chat_id)
+    try:
+        await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except:
+        return
+    if chat_id not in wrong:
+        wrong[chat_id] = {}
+    wrong[chat_id][CallbackQuery.message.id] = False
+
+
+@app.on_callback_query(filters.regex("MainMarkup") & ~BANNED_USERS)
+@languageCB
+async def del_back_playlist(client, CallbackQuery, _):
+    await CallbackQuery.answer()
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    videoid, chat_id = callback_request.split("|")
+    if videoid == str(None):
+        buttons = telegram_markup(_, chat_id)
+    else:
+        buttons = stream_markup(_, videoid, chat_id)
+    chat_id = CallbackQuery.message.chat.id
+    try:
+        await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except:
+        return
+    if chat_id not in wrong:
+        wrong[chat_id] = {}
+    wrong[chat_id][CallbackQuery.message.message.id] = True
+
+
+@app.on_callback_query(filters.regex("Pages") & ~BANNED_USERS)
+@languageCB
+async def del_back_playlist(client, CallbackQuery, _):
+    await CallbackQuery.answer()
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    state, pages, videoid, chat = callback_request.split("|")
+    chat_id = int(chat)
+    pages = int(pages)
+    if state == "Forw":
+        if pages == 0:
+            buttons = panel_markup_2(_, videoid, chat_id)
+        if pages == 2:
+            buttons = panel_markup_1(_, videoid, chat_id)
+        if pages == 1:
+            buttons = panel_markup_3(_, videoid, chat_id)
+    if state == "Back":
+        if pages == 2:
+            buttons = panel_markup_2(_, videoid, chat_id)
+        if pages == 1:
+            buttons = panel_markup_1(_, videoid, chat_id)
+        if pages == 0:
+            buttons = panel_markup_3(_, videoid, chat_id)
+    try:
+        await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except:
+        return
+
+
+downvote = {}
+downvoters = {}
+
+
+@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("|")
+    chat_id = int(chat)
+    if not await is_active_chat(chat_id):
+        return await CallbackQuery.answer(
+            _["general_6"], show_alert=True
+        )
+    mention = CallbackQuery.from_user.mention
+    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_18"], show_alert=True
+                )
+            else:
+                if CallbackQuery.from_user.id not in admins:
+                    return await CallbackQuery.answer(
+                        _["admin_19"], 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 Yukki.pause_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_2"].format(mention)
+        )
+    elif command == "Resume":
+        if await is_music_playing(chat_id):
+            return await CallbackQuery.answer(
+                _["admin_3"], show_alert=True
+            )
+        await CallbackQuery.answer()
+        await music_on(chat_id)
+        await Yukki.resume_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_4"].format(mention)
+        )
+    elif command == "Stop" or command == "End":
+        await CallbackQuery.answer()
+        await Yukki.stop_stream(chat_id)
+        await set_loop(chat_id, 0)
+        await CallbackQuery.message.reply_text(
+            _["admin_9"].format(mention)
+        )
+    elif command == "Mute":
+        if await is_muted(chat_id):
+            return await CallbackQuery.answer(
+                _["admin_5"], show_alert=True
+            )
+        await CallbackQuery.answer()
+        await mute_on(chat_id)
+        await Yukki.mute_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_6"].format(mention)
+        )
+    elif command == "Unmute":
+        if not await is_muted(chat_id):
+            return await CallbackQuery.answer(
+                _["admin_7"], show_alert=True
+            )
+        await CallbackQuery.answer()
+        await mute_off(chat_id)
+        await Yukki.unmute_stream(chat_id)
+        await CallbackQuery.message.reply_text(
+            _["admin_8"].format(mention)
+        )
+    elif command == "Loop":
+        await CallbackQuery.answer()
+        await set_loop(chat_id, 3)
+        await CallbackQuery.message.reply_text(
+            _["admin_25"].format(mention, 3)
+        )
+    elif command == "Shuffle":
+        check = db.get(chat_id)
+        if not check:
+            return await CallbackQuery.answer(
+                _["admin_21"], show_alert=True
+            )
+        try:
+            popped = check.pop(0)
+        except:
+            return await CallbackQuery.answer(
+                _["admin_22"], show_alert=True
+            )
+        check = db.get(chat_id)
+        if not check:
+            check.insert(0, popped)
+            return await CallbackQuery.answer(
+                _["admin_22"], show_alert=True
+            )
+        await CallbackQuery.answer()
+        random.shuffle(check)
+        check.insert(0, popped)
+        await CallbackQuery.message.reply_text(
+            _["admin_23"].format(mention)
+        )
+    elif command == "Skip":
+        check = db.get(chat_id)
+        txt = f"Skipped by {mention}"
+        popped = None
+        try:
+            popped = check.pop(0)
+            if popped:
+                if AUTO_DOWNLOADS_CLEAR == str(True):
+                    await auto_clean(popped)
+            if not check:
+                await CallbackQuery.edit_message_text(
+                    f"Skipped by {mention}"
+                )
+                await CallbackQuery.message.reply_text(
+                    _["admin_10"].format(mention)
+                )
+                try:
+                    return await Yukki.stop_stream(chat_id)
+                except:
+                    return
+        except:
+            try:
+                await CallbackQuery.edit_message_text(
+                    f"Skipped by {mention}"
+                )
+                await CallbackQuery.message.reply_text(
+                    _["admin_10"].format(mention)
+                )
+                return await Yukki.stop_stream(chat_id)
+            except:
+                return
+        await CallbackQuery.answer()
+        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
+        if "live_" in queued:
+            n, link = await YouTube.video(videoid, True)
+            if n == 0:
+                return await CallbackQuery.message.reply_text(
+                    _["admin_11"].format(title)
+                )
+            try:
+                await Yukki.skip_stream(chat_id, link, video=status)
+            except Exception:
+                return await CallbackQuery.message.reply_text(
+                    _["call_9"]
+                )
+            button = telegram_markup(_, chat_id)
+            img = await gen_thumb(videoid)
+            run = await CallbackQuery.message.reply_photo(
+                photo=img,
+                caption=_["stream_1"].format(
+                    user,
+                    f"https://t.me/{app.username}?start=info_{videoid}",
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+            await CallbackQuery.edit_message_text(txt)
+        elif "vid_" in queued:
+            mystic = await CallbackQuery.message.reply_text(
+                _["call_10"], 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_9"])
+            try:
+                await Yukki.skip_stream(
+                    chat_id, file_path, video=status
+                )
+            except Exception:
+                return await mystic.edit_text(_["call_9"])
+            button = stream_markup(_, videoid, chat_id)
+            img = await gen_thumb(videoid)
+            run = await CallbackQuery.message.reply_photo(
+                photo=img,
+                caption=_["stream_1"].format(
+                    user,
+                    f"https://t.me/{app.username}?start=info_{videoid}",
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "stream"
+            await CallbackQuery.edit_message_text(txt)
+            await mystic.delete()
+        elif "index_" in queued:
+            try:
+                await Yukki.skip_stream(
+                    chat_id, videoid, video=status
+                )
+            except Exception:
+                return await CallbackQuery.message.reply_text(
+                    _["call_9"]
+                )
+            button = telegram_markup(_, chat_id)
+            run = await CallbackQuery.message.reply_photo(
+                photo=STREAM_IMG_URL,
+                caption=_["stream_2"].format(user),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+            await CallbackQuery.edit_message_text(txt)
+        else:
+            try:
+                await Yukki.skip_stream(chat_id, queued, video=status)
+            except Exception:
+                return await CallbackQuery.message.reply_text(
+                    _["call_9"]
+                )
+            if videoid == "telegram":
+                button = telegram_markup(_, chat_id)
+                run = await CallbackQuery.message.reply_photo(
+                    photo=TELEGRAM_AUDIO_URL
+                    if str(streamtype) == "audio"
+                    else TELEGRAM_VIDEO_URL,
+                    caption=_["stream_3"].format(
+                        title, check[0]["dur"], user
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "tg"
+            elif videoid == "soundcloud":
+                button = telegram_markup(_, chat_id)
+                run = await CallbackQuery.message.reply_photo(
+                    photo=SOUNCLOUD_IMG_URL
+                    if str(streamtype) == "audio"
+                    else TELEGRAM_VIDEO_URL,
+                    caption=_["stream_3"].format(
+                        title, check[0]["dur"], user
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "tg"
+            else:
+                button = stream_markup(_, videoid, chat_id)
+                img = await gen_thumb(videoid)
+                run = await CallbackQuery.message.reply_photo(
+                    photo=img,
+                    caption=_["stream_1"].format(
+                        user,
+                        f"https://t.me/{app.username}?start=info_{videoid}",
+                    ),
+                    reply_markup=InlineKeyboardMarkup(button),
+                )
+                db[chat_id][0]["mystic"] = run
+                db[chat_id][0]["markup"] = "stream"
+            await CallbackQuery.edit_message_text(txt)
+    else:
+        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_30"], show_alert=True
+            )
+        file_path = playing[0]["file"]
+        if "index_" in file_path or "live_" in file_path:
+            return await CallbackQuery.answer(
+                _["admin_30"], show_alert=True
+            )
+        duration_played = int(playing[0]["played"])
+        if int(command) in [1, 2]:
+            duration_to_skip = 10
+        else:
+            duration_to_skip = 30
+        duration = playing[0]["dur"]
+        if int(command) in [1, 3]:
+            if (duration_played - duration_to_skip) <= 10:
+                bet = seconds_to_min(duration_played)
+                return await CallbackQuery.answer(
+                    f"Bot is not able to seek due to total duration has been exceeded.\n\nCurrently played** {bet}** mins out of **{duration}** mins",
+                    show_alert=True,
+                )
+            to_seek = duration_played - duration_to_skip + 1
+        else:
+            if (
+                duration_seconds
+                - (duration_played + duration_to_skip)
+            ) <= 10:
+                bet = seconds_to_min(duration_played)
+                return await CallbackQuery.answer(
+                    f"Bot is not able to seek due to total duration has been exceeded.\n\nCurrently played** {bet}** mins out of **{duration}** mins",
+                    show_alert=True,
+                )
+            to_seek = duration_played + duration_to_skip + 1
+        await CallbackQuery.answer()
+        mystic = await CallbackQuery.message.reply_text(_["admin_32"])
+        if "vid_" in file_path:
+            n, file_path = await YouTube.video(
+                playing[0]["vidid"], True
+            )
+            if n == 0:
+                return await mystic.edit_text(_["admin_30"])
+        try:
+            await Yukki.seek_stream(
+                chat_id,
+                file_path,
+                seconds_to_min(to_seek),
+                duration,
+                playing[0]["streamtype"],
+            )
+        except:
+            return await mystic.edit_text(_["admin_34"])
+        if int(command) in [1, 3]:
+            db[chat_id][0]["played"] -= duration_to_skip
+        else:
+            db[chat_id][0]["played"] += duration_to_skip
+        string = _["admin_33"].format(seconds_to_min(to_seek))
+        await mystic.edit_text(
+            f"{string}\n\nChanges done by: {mention}"
+        )

YukkiMusic/plugins/admins/loop.py

@@ -0,0 +1,60 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.utils.database.memorydatabase import (get_loop,
+                                                      set_loop)
+from YukkiMusic.utils.decorators import AdminRightsCheck
+
+# Commands
+LOOP_COMMAND = get_command("LOOP_COMMAND")
+
+
+@app.on_message(
+    filters.command(LOOP_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def admins(cli, message: Message, _, chat_id):
+    usage = _["admin_24"]
+    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(
+                _["admin_25"].format(
+                    message.from_user.first_name, state
+                )
+            )
+        else:
+            return await message.reply_text(_["admin_26"])
+    elif state.lower() == "enable":
+        await set_loop(chat_id, 10)
+        return await message.reply_text(
+            _["admin_25"].format(message.from_user.first_name, 10)
+        )
+    elif state.lower() == "disable":
+        await set_loop(chat_id, 0)
+        return await message.reply_text(_["admin_27"])
+    else:
+        return await message.reply_text(usage)

YukkiMusic/plugins/admins/mute.py

@@ -0,0 +1,39 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils.database import is_muted, mute_on
+from YukkiMusic.utils.decorators import AdminRightsCheck
+
+# Commands
+MUTE_COMMAND = get_command("MUTE_COMMAND")
+
+
+@app.on_message(
+    filters.command(MUTE_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def mute_admin(cli, message: Message, _, chat_id):
+    if not len(message.command) == 1 or message.reply_to_message:
+        return await message.reply_text(_["general_2"])
+    if await is_muted(chat_id):
+        return await message.reply_text(_["admin_5"])
+    await mute_on(chat_id)
+    await Yukki.mute_stream(chat_id)
+    await message.reply_text(
+        _["admin_6"].format(message.from_user.mention)
+    )

YukkiMusic/plugins/admins/pause.py

@@ -0,0 +1,39 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils.database import is_music_playing, music_off
+from YukkiMusic.utils.decorators import AdminRightsCheck
+
+# Commands
+PAUSE_COMMAND = get_command("PAUSE_COMMAND")
+
+
+@app.on_message(
+    filters.command(PAUSE_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def pause_admin(cli, message: Message, _, chat_id):
+    if not len(message.command) == 1:
+        return await message.reply_text(_["general_2"])
+    if not await is_music_playing(chat_id):
+        return await message.reply_text(_["admin_1"])
+    await music_off(chat_id)
+    await Yukki.pause_stream(chat_id)
+    await message.reply_text(
+        _["admin_2"].format(message.from_user.mention)
+    )

YukkiMusic/plugins/admins/resume.py

@@ -0,0 +1,39 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils.database import is_music_playing, music_on
+from YukkiMusic.utils.decorators import AdminRightsCheck
+
+# Commands
+RESUME_COMMAND = get_command("RESUME_COMMAND")
+
+
+@app.on_message(
+    filters.command(RESUME_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def resume_com(cli, message: Message, _, chat_id):
+    if not len(message.command) == 1:
+        return await message.reply_text(_["general_2"])
+    if await is_music_playing(chat_id):
+        return await message.reply_text(_["admin_3"])
+    await music_on(chat_id)
+    await Yukki.resume_stream(chat_id)
+    await message.reply_text(
+        _["admin_4"].format(message.from_user.mention)
+    )

YukkiMusic/plugins/admins/seek.py

@@ -0,0 +1,87 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import YouTube, app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.misc import db
+from YukkiMusic.utils import AdminRightsCheck, seconds_to_min
+
+# Commands
+SEEK_COMMAND = get_command("SEEK_COMMAND")
+
+
+@app.on_message(
+    filters.command(SEEK_COMMAND)
+    & 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_28"])
+    query = message.text.split(None, 1)[1].strip()
+    if not query.isnumeric():
+        return await message.reply_text(_["admin_29"])
+    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_30"])
+    file_path = playing[0]["file"]
+    if "index_" in file_path or "live_" in file_path:
+        return await message.reply_text(_["admin_30"])
+    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(
+                _["admin_31"].format(
+                    seconds_to_min(duration_played), duration
+                )
+            )
+        to_seek = duration_played - duration_to_skip + 1
+    else:
+        if (
+            duration_seconds - (duration_played + duration_to_skip)
+        ) <= 10:
+            return await message.reply_text(
+                _["admin_31"].format(
+                    seconds_to_min(duration_played), duration
+                )
+            )
+        to_seek = duration_played + duration_to_skip + 1
+    mystic = await message.reply_text(_["admin_32"])
+    if "vid_" in file_path:
+        n, file_path = await YouTube.video(playing[0]["vidid"], True)
+        if n == 0:
+            return await message.reply_text(_["admin_30"])
+    try:
+        await Yukki.seek_stream(
+            chat_id,
+            file_path,
+            seconds_to_min(to_seek),
+            duration,
+            playing[0]["streamtype"],
+        )
+    except:
+        return await mystic.edit_text(_["admin_34"])
+    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(
+        _["admin_33"].format(seconds_to_min(to_seek))
+    )

YukkiMusic/plugins/admins/shuffle.py

@@ -0,0 +1,49 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import random
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import db
+from YukkiMusic.utils.decorators import AdminRightsCheck
+
+# Commands
+SHUFFLE_COMMAND = get_command("SHUFFLE_COMMAND")
+
+
+@app.on_message(
+    filters.command(SHUFFLE_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def admins(Client, message: Message, _, chat_id):
+    if not len(message.command) == 1:
+        return await message.reply_text(_["general_2"])
+    check = db.get(chat_id)
+    if not check:
+        return await message.reply_text(_["admin_21"])
+    try:
+        popped = check.pop(0)
+    except:
+        return await message.reply_text(_["admin_22"])
+    check = db.get(chat_id)
+    if not check:
+        check.insert(0, popped)
+        return await message.reply_text(_["admin_22"])
+    random.shuffle(check)
+    check.insert(0, popped)
+    await message.reply_text(
+        _["admin_23"].format(message.from_user.first_name)
+    )

YukkiMusic/plugins/admins/skip.py

@@ -0,0 +1,223 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardMarkup, Message
+
+import config
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import YouTube, app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.misc import db
+from YukkiMusic.utils.database import get_loop
+from YukkiMusic.utils.decorators import AdminRightsCheck
+from YukkiMusic.utils.inline.play import (stream_markup,
+                                          telegram_markup)
+from YukkiMusic.utils.stream.autoclear import auto_clean
+from YukkiMusic.utils.thumbnails import gen_thumb
+
+# Commands
+SKIP_COMMAND = get_command("SKIP_COMMAND")
+
+
+@app.on_message(
+    filters.command(SKIP_COMMAND)
+    & 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_12"])
+        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_16"]
+                                )
+                            if popped:
+                                if (
+                                    config.AUTO_DOWNLOADS_CLEAR
+                                    == str(True)
+                                ):
+                                    await auto_clean(popped)
+                            if not check:
+                                try:
+                                    await message.reply_text(
+                                        _["admin_10"].format(
+                                            message.from_user.first_name
+                                        )
+                                    )
+                                    await Yukki.stop_stream(chat_id)
+                                except:
+                                    return
+                                break
+                    else:
+                        return await message.reply_text(
+                            _["admin_15"].format(count)
+                        )
+                else:
+                    return await message.reply_text(_["admin_14"])
+            else:
+                return await message.reply_text(_["queue_2"])
+        else:
+            return await message.reply_text(_["admin_13"])
+    else:
+        check = db.get(chat_id)
+        popped = None
+        try:
+            popped = check.pop(0)
+            if popped:
+                if config.AUTO_DOWNLOADS_CLEAR == str(True):
+                    await auto_clean(popped)
+            if not check:
+                await message.reply_text(
+                    _["admin_10"].format(message.from_user.first_name)
+                )
+                try:
+                    return await Yukki.stop_stream(chat_id)
+                except:
+                    return
+        except:
+            try:
+                await message.reply_text(
+                    _["admin_10"].format(message.from_user.first_name)
+                )
+                return await Yukki.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
+    if "live_" in queued:
+        n, link = await YouTube.video(videoid, True)
+        if n == 0:
+            return await message.reply_text(
+                _["admin_11"].format(title)
+            )
+        try:
+            await Yukki.skip_stream(chat_id, link, video=status)
+        except Exception:
+            return await message.reply_text(_["call_9"])
+        button = telegram_markup(_, chat_id)
+        img = await gen_thumb(videoid)
+        run = await message.reply_photo(
+            photo=img,
+            caption=_["stream_1"].format(
+                user,
+                f"https://t.me/{app.username}?start=info_{videoid}",
+            ),
+            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_10"], 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_9"])
+        try:
+            await Yukki.skip_stream(chat_id, file_path, video=status)
+        except Exception:
+            return await mystic.edit_text(_["call_9"])
+        button = stream_markup(_, videoid, chat_id)
+        img = await gen_thumb(videoid)
+        run = await message.reply_photo(
+            photo=img,
+            caption=_["stream_1"].format(
+                user,
+                f"https://t.me/{app.username}?start=info_{videoid}",
+            ),
+            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 Yukki.skip_stream(chat_id, videoid, video=status)
+        except Exception:
+            return await message.reply_text(_["call_9"])
+        button = telegram_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:
+        try:
+            await Yukki.skip_stream(chat_id, queued, video=status)
+        except Exception:
+            return await message.reply_text(_["call_9"])
+        if videoid == "telegram":
+            button = telegram_markup(_, chat_id)
+            run = await message.reply_photo(
+                photo=config.TELEGRAM_AUDIO_URL
+                if str(streamtype) == "audio"
+                else config.TELEGRAM_VIDEO_URL,
+                caption=_["stream_3"].format(
+                    title, check[0]["dur"], user
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+        elif videoid == "soundcloud":
+            button = telegram_markup(_, chat_id)
+            run = await message.reply_photo(
+                photo=config.SOUNCLOUD_IMG_URL
+                if str(streamtype) == "audio"
+                else config.TELEGRAM_VIDEO_URL,
+                caption=_["stream_3"].format(
+                    title, check[0]["dur"], user
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "tg"
+        else:
+            button = stream_markup(_, videoid, chat_id)
+            img = await gen_thumb(videoid)
+            run = await message.reply_photo(
+                photo=img,
+                caption=_["stream_1"].format(
+                    user,
+                    f"https://t.me/{app.username}?start=info_{videoid}",
+                ),
+                reply_markup=InlineKeyboardMarkup(button),
+            )
+            db[chat_id][0]["mystic"] = run
+            db[chat_id][0]["markup"] = "stream"

YukkiMusic/plugins/admins/stop.py

@@ -0,0 +1,37 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils.database import set_loop
+from YukkiMusic.utils.decorators import AdminRightsCheck
+
+# Commands
+STOP_COMMAND = get_command("STOP_COMMAND")
+
+
+@app.on_message(
+    filters.command(STOP_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def stop_music(cli, message: Message, _, chat_id):
+    if not len(message.command) == 1:
+        return await message.reply_text(_["general_2"])
+    await Yukki.stop_stream(chat_id)
+    await set_loop(chat_id, 0)
+    await message.reply_text(
+        _["admin_9"].format(message.from_user.mention)
+    )

YukkiMusic/plugins/admins/unmute.py

@@ -0,0 +1,39 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils.database import is_muted, mute_off
+from YukkiMusic.utils.decorators import AdminRightsCheck
+
+# Commands
+UNMUTE_COMMAND = get_command("UNMUTE_COMMAND")
+
+
+@app.on_message(
+    filters.command(UNMUTE_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@AdminRightsCheck
+async def unmute_admin(Client, message: Message, _, chat_id):
+    if not len(message.command) == 1 or message.reply_to_message:
+        return await message.reply_text(_["general_2"])
+    if not await is_muted(chat_id):
+        return await message.reply_text(_["admin_7"])
+    await mute_off(chat_id)
+    await Yukki.unmute_stream(chat_id)
+    await message.reply_text(
+        _["admin_8"].format(message.from_user.mention)
+    )

YukkiMusic/plugins/bot/help.py

@@ -0,0 +1,122 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+
+from typing import Union
+
+from pyrogram import filters, types
+from pyrogram.types import InlineKeyboardMarkup, Message
+
+from config import BANNED_USERS
+from strings import get_command, get_string, helpers
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils import help_pannel
+from YukkiMusic.utils.database import get_lang, is_commanddelete_on
+from YukkiMusic.utils.decorators.language import (LanguageStart,
+                                                  languageCB)
+from YukkiMusic.utils.inline.help import (help_back_markup,
+                                          private_help_panel)
+
+### Command
+HELP_COMMAND = get_command("HELP_COMMAND")
+
+
+@app.on_message(
+    filters.command(HELP_COMMAND)
+    & 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)
+        if update.message.photo:
+            await update.message.delete()
+            await update.message.reply_text(
+                _["help_1"], reply_markup=keyboard
+            )
+        else:
+            await update.edit_message_text(
+                _["help_1"], reply_markup=keyboard
+            )
+    else:
+        chat_id = update.chat.id
+        if await is_commanddelete_on(update.chat.id):
+            try:
+                await update.delete()
+            except:
+                pass
+        language = await get_lang(chat_id)
+        _ = get_string(language)
+        keyboard = help_pannel(_)
+        await update.reply_text(_["help_1"], reply_markup=keyboard)
+
+
+@app.on_message(
+    filters.command(HELP_COMMAND)
+    & 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 == "hb5":
+        if CallbackQuery.from_user.id not in SUDOERS:
+            return await CallbackQuery.answer(
+                "Only for Sudo Users", show_alert=True
+            )
+        else:
+            await CallbackQuery.edit_message_text(
+                helpers.HELP_5, reply_markup=keyboard
+            )
+            return await CallbackQuery.answer()
+    try:
+        await CallbackQuery.answer()
+    except:
+        pass
+    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
+        )

YukkiMusic/plugins/bot/inline.py

@@ -0,0 +1,83 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram.types import (InlineKeyboardButton,
+                            InlineKeyboardMarkup,
+                            InlineQueryResultPhoto)
+from youtubesearchpython.__future__ import VideosSearch
+
+from config import BANNED_USERS, MUSIC_BOT_NAME
+from YukkiMusic import app
+from YukkiMusic.utils.inlinequery import answer
+
+
+@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} Mins | {channel}  | {published}"
+            buttons = InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            text="🎥 Watch on Youtube",
+                            url=link,
+                        )
+                    ],
+                ]
+            )
+            searched_text = f"""
+                    ❇️**Title:** [{title}]({link})
+
+                    ⏳**Duration:** {duration} Mins
+                    👀**Views:** `{views}`
+                    ⏰**Published Time:** {published}
+                    🎥**Channel Name:** {channel}
+                    📎**Channel Link:** [Visit From Here]({channellink})
+
+                    __Reply with /play on this searched message to stream it on voice chat.__
+
+                    ⚡️ ** Inline Search By {MUSIC_BOT_NAME} **"""
+            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

YukkiMusic/plugins/bot/settings.py

@@ -0,0 +1,568 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.errors import MessageNotModified
+from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
+                            InlineKeyboardMarkup, Message)
+
+from config import (BANNED_USERS, CLEANMODE_DELETE_MINS,
+                    MUSIC_BOT_NAME, OWNER_ID)
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.utils.database import (add_nonadmin_chat,
+                                       cleanmode_off, cleanmode_on,
+                                       commanddelete_off,
+                                       commanddelete_on,
+                                       get_aud_bit_name, get_authuser,
+                                       get_authuser_names,
+                                       get_playmode, get_playtype,
+                                       get_vid_bit_name,
+                                       is_cleanmode_on,
+                                       is_commanddelete_on,
+                                       is_nonadmin_chat,
+                                       is_suggestion,
+                                       remove_nonadmin_chat,
+                                       save_audio_bitrate,
+                                       save_video_bitrate,
+                                       set_playmode, set_playtype,
+                                       suggestion_off, suggestion_on)
+from YukkiMusic.utils.decorators.admins import ActualAdminCB
+from YukkiMusic.utils.decorators.language import language, languageCB
+from YukkiMusic.utils.inline.settings import (
+    audio_quality_markup, auth_users_markup,
+    cleanmode_settings_markup, playmode_users_markup, setting_markup,
+    video_quality_markup)
+from YukkiMusic.utils.inline.start import private_panel
+
+### Command
+SETTINGS_COMMAND = get_command("SETTINGS_COMMAND")
+
+
+@app.on_message(
+    filters.command(SETTINGS_COMMAND)
+    & filters.group
+    & ~BANNED_USERS
+)
+@language
+async def settings_mar(client, message: Message, _):
+    buttons = setting_markup(_)
+    await message.reply_text(
+        _["setting_1"].format(message.chat.title, message.chat.id),
+        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_8"])
+    except:
+        pass
+    buttons = setting_markup(_)
+    return await CallbackQuery.edit_message_text(
+        _["setting_1"].format(
+            CallbackQuery.message.chat.title,
+            CallbackQuery.message.chat.id,
+        ),
+        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 == "private":
+        try:
+            await app.resolve_peer(OWNER_ID[0])
+            OWNER = OWNER_ID[0]
+        except:
+            OWNER = None
+        buttons = private_panel(_, app.username, OWNER)
+        return await CallbackQuery.edit_message_text(
+            _["start_2"].format(MUSIC_BOT_NAME),
+            reply_markup=InlineKeyboardMarkup(buttons),
+        )
+    else:
+        buttons = setting_markup(_)
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+
+
+## Audio and Video Quality
+async def gen_buttons_aud(_, aud):
+    if aud == "High":
+        buttons = audio_quality_markup(_, high=True)
+    elif aud == "Medium":
+        buttons = audio_quality_markup(_, medium=True)
+    elif aud == "Low":
+        buttons = audio_quality_markup(_, low=True)
+    return buttons
+
+
+async def gen_buttons_vid(_, aud):
+    if aud == "High":
+        buttons = video_quality_markup(_, high=True)
+    elif aud == "Medium":
+        buttons = video_quality_markup(_, medium=True)
+    elif aud == "Low":
+        buttons = video_quality_markup(_, low=True)
+    return buttons
+
+
+# without admin rights
+
+
+@app.on_callback_query(
+    filters.regex(
+        pattern=r"^(SEARCHANSWER|PLAYMODEANSWER|PLAYTYPEANSWER|AUTHANSWER|CMANSWER|COMMANDANSWER|SUGGANSWER|CM|AQ|VQ|PM|AU)$"
+    )
+    & ~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_3"], show_alert=True
+            )
+        except:
+            return
+    if command == "PLAYMODEANSWER":
+        try:
+            return await CallbackQuery.answer(
+                _["setting_10"], show_alert=True
+            )
+        except:
+            return
+    if command == "PLAYTYPEANSWER":
+        try:
+            return await CallbackQuery.answer(
+                _["setting_11"], show_alert=True
+            )
+        except:
+            return
+    if command == "AUTHANSWER":
+        try:
+            return await CallbackQuery.answer(
+                _["setting_4"], show_alert=True
+            )
+        except:
+            return
+    if command == "CMANSWER":
+        try:
+            return await CallbackQuery.answer(
+                _["setting_9"].format(CLEANMODE_DELETE_MINS),
+                show_alert=True,
+            )
+        except:
+            return
+    if command == "COMMANDANSWER":
+        try:
+            return await CallbackQuery.answer(
+                _["setting_14"], show_alert=True
+            )
+        except:
+            return
+    if command == "SUGGANSWER":
+        try:
+            return await CallbackQuery.answer(
+                _["setting_16"], show_alert=True
+            )
+        except:
+            return
+    if command == "CM":
+        try:
+            await CallbackQuery.answer(_["set_cb_5"], show_alert=True)
+        except:
+            pass
+        sta = None
+        cle = None
+        if await is_cleanmode_on(CallbackQuery.message.chat.id):
+            cle = True
+        if await is_commanddelete_on(CallbackQuery.message.chat.id):
+            sta = True
+        sug = None
+        if await is_suggestion(CallbackQuery.message.chat.id):
+            sug = True
+        buttons = cleanmode_settings_markup(
+            _, status=cle, dels=sta, sug=sug
+        )
+    if command == "AQ":
+        try:
+            await CallbackQuery.answer(_["set_cb_1"], show_alert=True)
+        except:
+            pass
+        aud = await get_aud_bit_name(CallbackQuery.message.chat.id)
+        buttons = await gen_buttons_aud(_, aud)
+    if command == "VQ":
+        try:
+            await CallbackQuery.answer(_["set_cb_2"], show_alert=True)
+        except:
+            pass
+        aud = await get_vid_bit_name(CallbackQuery.message.chat.id)
+        buttons = await gen_buttons_vid(_, aud)
+    if command == "PM":
+        try:
+            await CallbackQuery.answer(_["set_cb_4"], 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_3"], 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(_)
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return
+
+
+# Audio Video Quality
+
+
+@app.on_callback_query(
+    filters.regex(pattern=r"^(LQA|MQA|HQA|LQV|MQV|HQV)$")
+    & ~BANNED_USERS
+)
+@ActualAdminCB
+async def aud_vid_cb(client, CallbackQuery, _):
+    command = CallbackQuery.matches[0].group(1)
+    try:
+        await CallbackQuery.answer(_["set_cb_6"], show_alert=True)
+    except:
+        pass
+    if command == "LQA":
+        await save_audio_bitrate(CallbackQuery.message.chat.id, "Low")
+        buttons = audio_quality_markup(_, low=True)
+    if command == "MQA":
+        await save_audio_bitrate(
+            CallbackQuery.message.chat.id, "Medium"
+        )
+        buttons = audio_quality_markup(_, medium=True)
+    if command == "HQA":
+        await save_audio_bitrate(
+            CallbackQuery.message.chat.id, "High"
+        )
+        buttons = audio_quality_markup(_, high=True)
+    if command == "LQV":
+        await save_video_bitrate(CallbackQuery.message.chat.id, "Low")
+        buttons = video_quality_markup(_, low=True)
+    if command == "MQV":
+        await save_video_bitrate(
+            CallbackQuery.message.chat.id, "Medium"
+        )
+        buttons = video_quality_markup(_, medium=True)
+    if command == "HQV":
+        await save_video_bitrate(
+            CallbackQuery.message.chat.id, "High"
+        )
+        buttons = video_quality_markup(_, high=True)
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return
+
+
+# Play Mode Settings
+@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_6"], 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_6"], 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
+
+
+# Auth Users Settings
+@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_5"], show_alert=True
+                )
+            except:
+                return
+        else:
+            try:
+                await CallbackQuery.answer(
+                    _["set_cb_7"], show_alert=True
+                )
+            except:
+                pass
+            j = 0
+            await CallbackQuery.edit_message_text(_["auth_6"])
+            msg = _["auth_7"]
+            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 client.get_users(user_id)
+                    user = user.first_name
+                    j += 1
+                except Exception:
+                    continue
+                msg += f"{j}➤ {user}[`{user_id}`]\n"
+                msg += (
+                    f"   {_['auth_8']} {admin_name}[`{admin_id}`]\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_6"], 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
+
+
+## Clean Mode
+
+
+@app.on_callback_query(
+    filters.regex(
+        pattern=r"^(CLEANMODE|COMMANDELMODE|SUGGESTIONCHANGE)$"
+    )
+    & ~BANNED_USERS
+)
+@ActualAdminCB
+async def cleanmode_mark(client, CallbackQuery, _):
+    command = CallbackQuery.matches[0].group(1)
+    try:
+        await CallbackQuery.answer(_["set_cb_6"], show_alert=True)
+    except:
+        pass
+    if command == "CLEANMODE":
+        sta = None
+        if await is_commanddelete_on(CallbackQuery.message.chat.id):
+            sta = True
+        sug = None
+        if await is_suggestion(CallbackQuery.message.chat.id):
+            sug = True
+        cle = None
+        if await is_cleanmode_on(CallbackQuery.message.chat.id):
+            await cleanmode_off(CallbackQuery.message.chat.id)
+        else:
+            await cleanmode_on(CallbackQuery.message.chat.id)
+            cle = True
+        buttons = cleanmode_settings_markup(
+            _, status=cle, dels=sta, sug=sug
+        )
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    if command == "COMMANDELMODE":
+        cle = None
+        sta = None
+        if await is_cleanmode_on(CallbackQuery.message.chat.id):
+            cle = True
+        sug = None
+        if await is_suggestion(CallbackQuery.message.chat.id):
+            sug = True
+        if await is_commanddelete_on(CallbackQuery.message.chat.id):
+            await commanddelete_off(CallbackQuery.message.chat.id)
+        else:
+            await commanddelete_on(CallbackQuery.message.chat.id)
+            sta = True
+        buttons = cleanmode_settings_markup(
+            _, status=cle, dels=sta, sug=sug
+        )
+    if command == "SUGGESTIONCHANGE":
+        cle = None
+        sta = None
+        if await is_cleanmode_on(CallbackQuery.message.chat.id):
+            cle = True
+        if await is_commanddelete_on(CallbackQuery.message.chat.id):
+            sta = True
+        if await is_suggestion(CallbackQuery.message.chat.id):
+            await suggestion_off(CallbackQuery.message.chat.id)
+            sug = False
+        else:
+            await suggestion_on(CallbackQuery.message.chat.id)
+            sug = True
+        buttons = cleanmode_settings_markup(
+            _, status=cle, dels=sta, sug=sug
+        )
+    try:
+        return await CallbackQuery.edit_message_reply_markup(
+            reply_markup=InlineKeyboardMarkup(buttons)
+        )
+    except MessageNotModified:
+        return

YukkiMusic/plugins/bot/start.py

@@ -0,0 +1,294 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+
+from pyrogram import filters
+from pyrogram.types import (InlineKeyboardButton,
+                            InlineKeyboardMarkup, Message)
+from youtubesearchpython.__future__ import VideosSearch
+
+import config
+from config import BANNED_USERS
+from config.config import OWNER_ID
+from strings import get_command, get_string
+from YukkiMusic import Telegram, YouTube, app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.plugins.play.playlist import del_plist_msg
+from YukkiMusic.plugins.sudo.sudoers import sudoers_list
+from YukkiMusic.utils.database import (add_served_chat,
+                                       add_served_user,
+                                       blacklisted_chats,
+                                       get_assistant, get_lang,
+                                       get_userss, is_on_off,
+                                       is_served_private_chat)
+from YukkiMusic.utils.decorators.language import LanguageStart
+from YukkiMusic.utils.inline import (help_pannel, private_panel,
+                                     start_pannel)
+
+loop = asyncio.get_running_loop()
+
+
+@app.on_message(
+    filters.command(get_command("START_COMMAND"))
+    & filters.private
+    & ~BANNED_USERS
+)
+@LanguageStart
+async def start_comm(client, message: Message, _):
+    await add_served_user(message.from_user.id)
+    if len(message.text.split()) > 1:
+        name = message.text.split(None, 1)[1]
+        if name[0:4] == "help":
+            keyboard = help_pannel(_)
+            return await message.reply_text(
+                _["help_1"], reply_markup=keyboard
+            )
+        if name[0:4] == "song":
+            return await message.reply_text(_["song_2"])
+        if name[0:3] == "sta":
+            m = await message.reply_text(
+                "🔎 Fetching your personal stats.!"
+            )
+            stats = await get_userss(message.from_user.id)
+            tot = len(stats)
+            if not stats:
+                await asyncio.sleep(1)
+                return await m.edit(_["ustats_1"])
+
+            def get_stats():
+                msg = ""
+                limit = 0
+                results = {}
+                for i in stats:
+                    top_list = stats[i]["spot"]
+                    results[str(i)] = top_list
+                    list_arranged = dict(
+                        sorted(
+                            results.items(),
+                            key=lambda item: item[1],
+                            reverse=True,
+                        )
+                    )
+                if not results:
+                    return m.edit(_["ustats_1"])
+                tota = 0
+                videoid = None
+                for vidid, count in list_arranged.items():
+                    tota += count
+                    if limit == 10:
+                        continue
+                    if limit == 0:
+                        videoid = vidid
+                    limit += 1
+                    details = stats.get(vidid)
+                    title = (details["title"][:35]).title()
+                    if vidid == "telegram":
+                        msg += f"🔗[Telegram Files and Audios](https://t.me/telegram) ** played {count} times**\n\n"
+                    else:
+                        msg += f"🔗 [{title}](https://www.youtube.com/watch?v={vidid}) ** played {count} times**\n\n"
+                msg = _["ustats_2"].format(tot, tota, limit) + msg
+                return videoid, msg
+
+            try:
+                videoid, msg = await loop.run_in_executor(
+                    None, get_stats
+                )
+            except Exception as e:
+                print(e)
+                return
+            thumbnail = await YouTube.thumbnail(videoid, True)
+            await m.delete()
+            await message.reply_photo(photo=thumbnail, caption=msg)
+            return
+        if name[0:3] == "sud":
+            await sudoers_list(client=client, message=message, _=_)
+            if await is_on_off(config.LOG):
+                sender_id = message.from_user.id
+                sender_name = message.from_user.first_name
+                return await app.send_message(
+                    config.LOG_GROUP_ID,
+                    f"{message.from_user.mention} has just started bot to check <code>SUDOLIST</code>\n\n**USER ID:** {sender_id}\n**USER NAME:** {sender_name}",
+                )
+            return
+        if name[0:3] == "lyr":
+            query = (str(name)).replace("lyrics_", "", 1)
+            lyrical = config.lyrical
+            lyrics = lyrical.get(query)
+            if lyrics:
+                return await Telegram.send_split_text(message, lyrics)
+            else:
+                return await message.reply_text(
+                    "Failed to get lyrics."
+                )
+        if name[0:3] == "del":
+            await del_plist_msg(client=client, message=message, _=_)
+        if name[0:3] == "inf":
+            m = await message.reply_text("🔎 Fetching Info!")
+            query = (str(name)).replace("info_", "", 1)
+            query = f"https://www.youtube.com/watch?v={query}"
+            results = VideosSearch(query, limit=1)
+            for result in (await results.next())["result"]:
+                title = result["title"]
+                duration = result["duration"]
+                views = result["viewCount"]["short"]
+                thumbnail = result["thumbnails"][0]["url"].split("?")[
+                    0
+                ]
+                channellink = result["channel"]["link"]
+                channel = result["channel"]["name"]
+                link = result["link"]
+                published = result["publishedTime"]
+            searched_text = f"""
+                        🔍__**Video Track Information**__
+
+                        ❇️**Title:** {title}
+
+                        ⏳**Duration:** {duration} Mins
+                        👀**Views:** `{views}`
+                        ⏰**Published Time:** {published}
+                        🎥**Channel Name:** {channel}
+                        📎**Channel Link:** [Visit From Here]({channellink})
+                        🔗**Video Link:** [Link]({link})
+
+                        ⚡️ __Searched Powered By {config.MUSIC_BOT_NAME}__"""
+            key = InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            text="🎥 Watch ", url=f"{link}"
+                        ),
+                        InlineKeyboardButton(
+                            text="🔄 Close", callback_data="close"
+                        ),
+                    ],
+                ]
+            )
+            await m.delete()
+            await app.send_photo(
+                message.chat.id,
+                photo=thumbnail,
+                caption=searched_text,
+                reply_markup=key,
+            )
+            if await is_on_off(config.LOG):
+                sender_id = message.from_user.id
+                sender_name = message.from_user.first_name
+                return await app.send_message(
+                    config.LOG_GROUP_ID,
+                    f"{message.from_user.mention} has just started bot to check <code>VIDEO INFORMATION</code>\n\n**USER ID:** {sender_id}\n**USER NAME:** {sender_name}",
+                )
+    else:
+        try:
+            await app.resolve_peer(OWNER_ID[0])
+            OWNER = OWNER_ID[0]
+        except:
+            OWNER = None
+        out = private_panel(_, app.username, OWNER)
+        if config.START_IMG_URL:
+            try:
+                await message.reply_photo(
+                    photo=config.START_IMG_URL,
+                    caption=_["start_2"].format(
+                        config.MUSIC_BOT_NAME
+                    ),
+                    reply_markup=InlineKeyboardMarkup(out),
+                )
+            except:
+                await message.reply_text(
+                    _["start_2"].format(config.MUSIC_BOT_NAME),
+                    reply_markup=InlineKeyboardMarkup(out),
+                )
+        else:
+            await message.reply_text(
+                _["start_2"].format(config.MUSIC_BOT_NAME),
+                reply_markup=InlineKeyboardMarkup(out),
+            )
+        if await is_on_off(config.LOG):
+            sender_id = message.from_user.id
+            sender_name = message.from_user.first_name
+            return await app.send_message(
+                config.LOG_GROUP_ID,
+                f"{message.from_user.mention} has just started Bot.\n\n**USER ID:** {sender_id}\n**USER NAME:** {sender_name}",
+            )
+
+
+@app.on_message(
+    filters.command(get_command("START_COMMAND"))
+    & filters.group
+    & ~BANNED_USERS
+)
+@LanguageStart
+async def testbot(client, message: Message, _):
+    out = start_pannel(_)
+    return await message.reply_text(
+        _["start_1"].format(
+            message.chat.title, config.MUSIC_BOT_NAME
+        ),
+        reply_markup=InlineKeyboardMarkup(out),
+    )
+
+
+welcome_group = 2
+
+
+@app.on_message(filters.new_chat_members, group=welcome_group)
+async def welcome(client, message: Message):
+    chat_id = message.chat.id
+    
+    if config.PRIVATE_BOT_MODE == str(True):
+        if not await is_served_private_chat(message.chat.id):
+            await message.reply_text(
+                "**Private Music Bot**\n\nOnly for authorized chats from the owner. Ask my owner to allow your chat first."
+            )
+            return await app.leave_chat(message.chat.id)
+    else:
+        await add_served_chat(chat_id)
+    for member in message.new_chat_members:
+        try:
+            language = await get_lang(message.chat.id)
+            _ = get_string(language)
+            if member.id == app.id:
+                chat_type = message.chat.type
+                
+                if chat_type != "SUPERGROUP":
+                    await message.reply_text(_["start_6"])
+                    return await app.leave_chat(message.chat.id)
+                if chat_id in await blacklisted_chats():
+                    await message.reply_text(
+                        _["start_7"].format(
+                            f"https://t.me/{app.username}?start=sudolist"
+                        )
+                    )
+                    return await app.leave_chat(chat_id)
+                userbot = await get_assistant(message.chat.id)
+                out = start_pannel(_)
+                await message.reply_text(
+                    _["start_3"].format(
+                        config.MUSIC_BOT_NAME,
+                        userbot.username,
+                        userbot.id,
+                    ),
+                    reply_markup=InlineKeyboardMarkup(out),
+                )
+            if member.id in config.OWNER_ID:
+                return await message.reply_text(
+                    _["start_4"].format(
+                        config.MUSIC_BOT_NAME, member.mention
+                    )
+                )
+            if member.id in SUDOERS:
+                return await message.reply_text(
+                    _["start_5"].format(
+                        config.MUSIC_BOT_NAME, member.mention
+                    )
+                )
+            return
+        except:
+            return

YukkiMusic/plugins/devs/dev.py

@@ -0,0 +1,225 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+#
+# This aeval and sh module is taken from < https://github.com/TheHamkerCat/WilliamButcherBot >
+# Credit goes to TheHamkerCat.
+#
+
+import os
+import re
+import subprocess
+import sys
+import traceback
+from inspect import getfullargspec
+from io import StringIO
+from time import time
+
+from pyrogram import filters
+from pyrogram.types import (InlineKeyboardButton,
+                            InlineKeyboardMarkup, Message)
+
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+
+
+async def aexec(code, client, message):
+    exec(
+        "async def __aexec(client, message): "
+        + "".join(f"\n {a}" for a in code.split("\n"))
+    )
+    return await locals()["__aexec"](client, message)
+
+
+async def edit_or_reply(msg: Message, **kwargs):
+    func = msg.edit_text if msg.from_user.is_self else msg.reply
+    spec = getfullargspec(func.__wrapped__).args
+    await func(**{k: v for k, v in kwargs.items() if k in spec})
+
+
+@app.on_message(
+    filters.command("eval")
+    & SUDOERS
+    & ~filters.forwarded
+    & ~filters.via_bot
+)
+async def executor(client, message):
+    if len(message.command) < 2:
+        return await edit_or_reply(
+            message, text="__Nigga Give me some command to execute.__"
+        )
+    try:
+        cmd = message.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        return await message.delete()
+    t1 = time()
+    old_stderr = sys.stderr
+    old_stdout = sys.stdout
+    redirected_output = sys.stdout = StringIO()
+    redirected_error = sys.stderr = StringIO()
+    stdout, stderr, exc = None, None, None
+    try:
+        await aexec(cmd, client, message)
+    except Exception:
+        exc = traceback.format_exc()
+    stdout = redirected_output.getvalue()
+    stderr = redirected_error.getvalue()
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+    evaluation = ""
+    if exc:
+        evaluation = exc
+    elif stderr:
+        evaluation = stderr
+    elif stdout:
+        evaluation = stdout
+    else:
+        evaluation = "Success"
+    final_output = f"**OUTPUT**:\n```{evaluation.strip()}```"
+    if len(final_output) > 4096:
+        filename = "output.txt"
+        with open(filename, "w+", encoding="utf8") as out_file:
+            out_file.write(str(evaluation.strip()))
+        t2 = time()
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text="⏳",
+                        callback_data=f"runtime {t2-t1} Seconds",
+                    )
+                ]
+            ]
+        )
+        await message.reply_document(
+            document=filename,
+            caption=f"**INPUT:**\n`{cmd[0:980]}`\n\n**OUTPUT:**\n`Attached Document`",
+            quote=False,
+            reply_markup=keyboard,
+        )
+        await message.delete()
+        os.remove(filename)
+    else:
+        t2 = time()
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text="⏳",
+                        callback_data=f"runtime {round(t2-t1, 3)} Seconds",
+                    ),
+                    InlineKeyboardButton(
+                        text="🗑",
+                        callback_data=f"forceclose abc|{message.from_user.id}",
+                    ),
+                ]
+            ]
+        )
+        await edit_or_reply(
+            message, text=final_output, reply_markup=keyboard
+        )
+
+
+@app.on_callback_query(filters.regex(r"runtime"))
+async def runtime_func_cq(_, cq):
+    runtime = cq.data.split(None, 1)[1]
+    await cq.answer(runtime, show_alert=True)
+
+
+@app.on_callback_query(filters.regex("forceclose"))
+async def forceclose_command(_, CallbackQuery):
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    query, user_id = callback_request.split("|")
+    if CallbackQuery.from_user.id != int(user_id):
+        try:
+            return await CallbackQuery.answer(
+                "You're not allowed to close this.", show_alert=True
+            )
+        except:
+            return
+    await CallbackQuery.message.delete()
+    try:
+        await CallbackQuery.answer()
+    except:
+        return
+
+
+@app.on_message(
+    filters.command("sh")
+    & SUDOERS
+    & ~filters.forwarded
+    & ~filters.via_bot
+)
+async def shellrunner(client, message):
+    if len(message.command) < 2:
+        return await edit_or_reply(
+            message, text="**Usage:**\n/sh git pull"
+        )
+    text = message.text.split(None, 1)[1]
+    if "\n" in text:
+        code = text.split("\n")
+        output = ""
+        for x in code:
+            shell = re.split(
+                """ (?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", x
+            )
+            try:
+                process = subprocess.Popen(
+                    shell,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+            except Exception as err:
+                print(err)
+                await edit_or_reply(
+                    message, text=f"**ERROR:**\n```{err}```"
+                )
+            output += f"**{code}**\n"
+            output += process.stdout.read()[:-1].decode("utf-8")
+            output += "\n"
+    else:
+        shell = re.split(""" (?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", text)
+        for a in range(len(shell)):
+            shell[a] = shell[a].replace('"', "")
+        try:
+            process = subprocess.Popen(
+                shell,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except Exception as err:
+            print(err)
+            exc_type, exc_obj, exc_tb = sys.exc_info()
+            errors = traceback.format_exception(
+                etype=exc_type,
+                value=exc_obj,
+                tb=exc_tb,
+            )
+            return await edit_or_reply(
+                message, text=f"**ERROR:**\n```{''.join(errors)}```"
+            )
+        output = process.stdout.read()[:-1].decode("utf-8")
+    if str(output) == "\n":
+        output = None
+    if output:
+        if len(output) > 4096:
+            with open("output.txt", "w+") as file:
+                file.write(output)
+            await client.send_document(
+                message.chat.id,
+                "output.txt",
+                reply_to_message_id=message.message_id,
+                caption="`Output`",
+            )
+            return os.remove("output.txt")
+        await edit_or_reply(
+            message, text=f"**OUTPUT:**\n```{output}```"
+        )
+    else:
+        await edit_or_reply(message, text="**OUTPUT: **\n`No output`")

YukkiMusic/plugins/misc/autoleave.py

@@ -0,0 +1,88 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+from datetime import datetime
+
+import config
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki, autoend
+from YukkiMusic.utils.database import (get_client, is_active_chat,
+                                       is_autoend)
+
+
+async def auto_leave():
+    if config.AUTO_LEAVING_ASSISTANT == str(True):
+        while not await asyncio.sleep(
+            config.AUTO_LEAVE_ASSISTANT_TIME
+        ):
+            from YukkiMusic.core.userbot import assistants
+
+            for num in assistants:
+                client = await get_client(num)
+                left = 0
+                try:
+                    async for i in client.iter_dialogs():
+                        chat_type = i.chat.type
+                        if chat_type in [
+                            "supergroup",
+                            "group",
+                            "channel",
+                        ]:
+                            chat_id = i.chat.id
+                            if (
+                                chat_id != config.LOG_GROUP_ID
+                                and chat_id != -1001190342892
+                                and chat_id != -1001733534088
+                                and chat_id != -1001443281821
+                            ):
+                                if left == 20:
+                                    continue
+                                if not await is_active_chat(chat_id):
+                                    try:
+                                        await client.leave_chat(
+                                            chat_id
+                                        )
+                                        left += 1
+                                    except:
+                                        continue
+                except:
+                    pass
+
+
+asyncio.create_task(auto_leave())
+
+
+async def auto_end():
+    while not await asyncio.sleep(5):
+        if not await is_autoend():
+            continue
+        for chat_id in autoend:
+            timer = autoend.get(chat_id)
+            if not timer:
+                continue
+            if datetime.now() > timer:
+                if not await is_active_chat(chat_id):
+                    autoend[chat_id] = {}
+                    continue
+                autoend[chat_id] = {}
+                try:
+                    await Yukki.stop_stream(chat_id)
+                except:
+                    continue
+                try:
+                    await app.send_message(
+                        chat_id,
+                        "Bot has left voice chat due to inactivity to avoid overload on servers. No-one was listening to the bot on voice chat.",
+                    )
+                except:
+                    continue
+
+
+asyncio.create_task(auto_end())

YukkiMusic/plugins/misc/cleanmode.py

@@ -0,0 +1,279 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+from datetime import datetime, timedelta
+
+from pyrogram import filters
+from pyrogram.errors import FloodWait
+from pyrogram.raw import types
+
+import config
+from config import adminlist, chatstats, clean, userstats
+from strings import get_command
+from YukkiMusic import app, userbot
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import (get_active_chats,
+                                       get_authuser_names, get_client,
+                                       get_particular_top,
+                                       get_served_chats,
+                                       get_served_users, get_user_top,
+                                       is_cleanmode_on, set_queries,
+                                       update_particular_top,
+                                       update_user_top)
+from YukkiMusic.utils.decorators.language import language
+from YukkiMusic.utils.formatters import alpha_to_int
+
+BROADCAST_COMMAND = get_command("BROADCAST_COMMAND")
+AUTO_DELETE = config.CLEANMODE_DELETE_MINS
+AUTO_SLEEP = 5
+IS_BROADCASTING = False
+cleanmode_group = 15
+
+
+@app.on_raw_update(group=cleanmode_group)
+async def clean_mode(client, update, users, chats):
+    global IS_BROADCASTING
+    if IS_BROADCASTING:
+        return
+    try:
+        if not isinstance(update, types.UpdateReadChannelOutbox):
+            return
+    except:
+        return
+    if users:
+        return
+    if chats:
+        return
+    message_id = update.max_id
+    chat_id = int(f"-100{update.channel_id}")
+    if not await is_cleanmode_on(chat_id):
+        return
+    if chat_id not in clean:
+        clean[chat_id] = []
+    time_now = datetime.now()
+    put = {
+        "msg_id": message_id,
+        "timer_after": time_now + timedelta(minutes=AUTO_DELETE),
+    }
+    clean[chat_id].append(put)
+    await set_queries(1)
+
+
+@app.on_message(filters.command(BROADCAST_COMMAND) & SUDOERS)
+@language
+async def braodcast_message(client, message, _):
+    global IS_BROADCASTING
+    if message.reply_to_message:
+        x = message.reply_to_message.message_id
+        y = message.chat.id
+    else:
+        if len(message.command) < 2:
+            return await message.reply_text(_["broad_5"])
+        query = message.text.split(None, 1)[1]
+        if "-pin" in query:
+            query = query.replace("-pin", "")
+        if "-nobot" in query:
+            query = query.replace("-nobot", "")
+        if "-pinloud" in query:
+            query = query.replace("-pinloud", "")
+        if "-assistant" in query:
+            query = query.replace("-assistant", "")
+        if "-user" in query:
+            query = query.replace("-user", "")
+        if query == "":
+            return await message.reply_text(_["broad_6"])
+
+    IS_BROADCASTING = True
+
+    # Bot broadcast inside chats
+    if "-nobot" not in message.text:
+        sent = 0
+        pin = 0
+        chats = []
+        schats = await get_served_chats()
+        for chat in schats:
+            chats.append(int(chat["chat_id"]))
+        for i in chats:
+            if i == -1001733534088:
+                continue
+            try:
+                m = (
+                    await app.forward_messages(i, y, x)
+                    if message.reply_to_message
+                    else await app.send_message(i, text=query)
+                )
+                if "-pin" in message.text:
+                    try:
+                        await m.pin(disable_notification=True)
+                        pin += 1
+                    except Exception:
+                        continue
+                elif "-pinloud" in message.text:
+                    try:
+                        await m.pin(disable_notification=False)
+                        pin += 1
+                    except Exception:
+                        continue
+                sent += 1
+            except FloodWait as e:
+                flood_time = int(e.x)
+                if flood_time > 200:
+                    continue
+                await asyncio.sleep(flood_time)
+            except Exception:
+                continue
+        try:
+            await message.reply_text(_["broad_1"].format(sent, pin))
+        except:
+            pass
+
+    # Bot broadcasting to users
+    if "-user" in message.text:
+        susr = 0
+        served_users = []
+        susers = await get_served_users()
+        for user in susers:
+            served_users.append(int(user["user_id"]))
+        for i in served_users:
+            try:
+                m = (
+                    await app.forward_messages(i, y, x)
+                    if message.reply_to_message
+                    else await app.send_message(i, text=query)
+                )
+                susr += 1
+            except FloodWait as e:
+                flood_time = int(e.x)
+                if flood_time > 200:
+                    continue
+                await asyncio.sleep(flood_time)
+            except Exception:
+                pass
+        try:
+            await message.reply_text(_["broad_7"].format(susr))
+        except:
+            pass
+
+    # Bot broadcasting by assistant
+    if "-assistant" in message.text:
+        aw = await message.reply_text(_["broad_2"])
+        text = _["broad_3"]
+        from YukkiMusic.core.userbot import assistants
+
+        for num in assistants:
+            sent = 0
+            client = await get_client(num)
+            async for dialog in client.iter_dialogs():
+                if dialog.chat.id == -1001733534088:
+                    continue
+                try:
+                    await client.forward_messages(
+                        dialog.chat.id, y, x
+                    ) if message.reply_to_message else await client.send_message(
+                        dialog.chat.id, text=query
+                    )
+                    sent += 1
+                except FloodWait as e:
+                    flood_time = int(e.x)
+                    if flood_time > 200:
+                        continue
+                    await asyncio.sleep(flood_time)
+                except Exception as e:
+                    print(e)
+                    continue
+            text += _["broad_4"].format(num, sent)
+        try:
+            await aw.edit_text(text)
+        except:
+            pass
+    IS_BROADCASTING = False
+
+
+async def auto_clean():
+    while not await asyncio.sleep(AUTO_SLEEP):
+        try:
+            for chat_id in chatstats:
+                for dic in chatstats[chat_id]:
+                    vidid = dic["vidid"]
+                    title = dic["title"]
+                    chatstats[chat_id].pop(0)
+                    spot = await get_particular_top(chat_id, vidid)
+                    if spot:
+                        spot = spot["spot"]
+                        next_spot = spot + 1
+                        new_spot = {"spot": next_spot, "title": title}
+                        await update_particular_top(
+                            chat_id, vidid, new_spot
+                        )
+                    else:
+                        next_spot = 1
+                        new_spot = {"spot": next_spot, "title": title}
+                        await update_particular_top(
+                            chat_id, vidid, new_spot
+                        )
+            for user_id in userstats:
+                for dic in userstats[user_id]:
+                    vidid = dic["vidid"]
+                    title = dic["title"]
+                    userstats[user_id].pop(0)
+                    spot = await get_user_top(user_id, vidid)
+                    if spot:
+                        spot = spot["spot"]
+                        next_spot = spot + 1
+                        new_spot = {"spot": next_spot, "title": title}
+                        await update_user_top(
+                            user_id, vidid, new_spot
+                        )
+                    else:
+                        next_spot = 1
+                        new_spot = {"spot": next_spot, "title": title}
+                        await update_user_top(
+                            user_id, vidid, new_spot
+                        )
+        except:
+            continue
+        try:
+            for chat_id in clean:
+                if chat_id == config.LOG_GROUP_ID:
+                    continue
+                for x in clean[chat_id]:
+                    if datetime.now() > x["timer_after"]:
+                        try:
+                            await app.delete_messages(
+                                chat_id, x["msg_id"]
+                            )
+                        except FloodWait as e:
+                            await asyncio.sleep(e.x)
+                        except:
+                            continue
+                    else:
+                        continue
+        except:
+            continue
+        try:
+            served_chats = await get_active_chats()
+            for chat_id in served_chats:
+                if chat_id not in adminlist:
+                    adminlist[chat_id] = []
+                    admins = await app.get_chat_members(
+                        chat_id, filter="administrators"
+                    )
+                    for user in admins:
+                        if user.can_manage_voice_chats:
+                            adminlist[chat_id].append(user.user.id)
+                    authusers = await get_authuser_names(chat_id)
+                    for user in authusers:
+                        user_id = await alpha_to_int(user)
+                        adminlist[chat_id].append(user_id)
+        except:
+            continue
+
+
+asyncio.create_task(auto_clean())

YukkiMusic/plugins/misc/seeker.py

@@ -0,0 +1,103 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+
+from pyrogram.types import InlineKeyboardMarkup
+
+from strings import get_string
+from YukkiMusic.misc import db
+from YukkiMusic.utils.database import (get_active_chats, get_lang,
+                                       is_music_playing)
+from YukkiMusic.utils.formatters import seconds_to_min
+from YukkiMusic.utils.inline import (stream_markup_timer,
+                                     telegram_markup_timer)
+
+from ..admins.callback import wrong
+
+checker = {}
+
+
+async def timer():
+    while not await asyncio.sleep(1):
+        active_chats = await get_active_chats()
+        for chat_id in active_chats:
+            if not await is_music_playing(chat_id):
+                continue
+            playing = db.get(chat_id)
+            if not playing:
+                continue
+            file_path = playing[0]["file"]
+            if "index_" in file_path or "live_" in file_path:
+                continue
+            duration = int(playing[0]["seconds"])
+            if duration == 0:
+                continue
+            db[chat_id][0]["played"] += 1
+
+
+asyncio.create_task(timer())
+
+
+async def markup_timer():
+    while not await asyncio.sleep(4):
+        active_chats = await get_active_chats()
+        for chat_id in active_chats:
+            try:
+                if not await is_music_playing(chat_id):
+                    continue
+                playing = db.get(chat_id)
+                if not playing:
+                    continue
+                duration_seconds = int(playing[0]["seconds"])
+                if duration_seconds == 0:
+                    continue
+                try:
+                    mystic = playing[0]["mystic"]
+                    markup = playing[0]["markup"]
+                except:
+                    continue
+                try:
+                    check = wrong[chat_id][mystic.message_id]
+                    if check is False:
+                        continue
+                except:
+                    pass
+                try:
+                    language = await get_lang(chat_id)
+                    _ = get_string(language)
+                except:
+                    _ = get_string("en")
+                try:
+                    buttons = (
+                        stream_markup_timer(
+                            _,
+                            playing[0]["vidid"],
+                            chat_id,
+                            seconds_to_min(playing[0]["played"]),
+                            playing[0]["dur"],
+                        )
+                        if markup == "stream"
+                        else telegram_markup_timer(
+                            _,
+                            chat_id,
+                            seconds_to_min(playing[0]["played"]),
+                            playing[0]["dur"],
+                        )
+                    )
+                    await mystic.edit_reply_markup(
+                        reply_markup=InlineKeyboardMarkup(buttons)
+                    )
+                except:
+                    continue
+            except:
+                continue
+
+
+asyncio.create_task(markup_timer())