ClearUp

.dockerignore

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

.gitattributes

@@ -1,35 +0,0 @@
-*.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

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

.replit

@@ -1,15 +0,0 @@
-entrypoint = "main.py"
-modules = ["python-3.10:v18-20230807-322e88b"]
-
-[nix]
-channel = "stable-23_05"
-
-[unitTest]
-language = "python3"
-
-[gitHubImport]
-requiredFiles = [".replit", "replit.nix"]
-
-[deployment]
-run = ["python3", "main.py"]
-deploymentTarget = "cloudrun"

Dockerfile

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

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

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

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

@@ -1,89 +0,0 @@
-#
-# 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 YukkiMusic.server 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():
-    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."
-        )
-    
-    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()
-    print("------------------------------Bot Called ------------------------------")
-    await server.setup()
-    await web.TCPSite(server,'0.0.0.0', 7860).start()
-    print("------------------------------Web Server Started ------------------------------")
-    
-    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

@@ -1,65 +0,0 @@
-#
-# 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__(
-        "ONesVCBot",
-        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
-    self.name = get_me.first_name
-    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()
-    
-    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
-
-    """
-    a = await self.get_chat_member(config.LOG_GROUP_ID, self.id)
-    self.name = get_me.first_name
-    LOGGER(__name__).info(f"MusicBot Started as {self.name}")"""
-

YukkiMusic/core/call.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,279 +0,0 @@
-#
-# 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())