SUDOLIST\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 VIDEO INFORMATION\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
diff --git a/YukkiMusic/plugins/devs/dev.py b/YukkiMusic/plugins/devs/dev.py
new file mode 100644
index 0000000000000000000000000000000000000000..baa8ca5e1385210683222aeca3c7c99f15fb6fe1
--- /dev/null
+++ b/YukkiMusic/plugins/devs/dev.py
@@ -0,0 +1,225 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+#
+# This aeval and sh module is taken from < https://github.com/TheHamkerCat/WilliamButcherBot >
+# Credit goes to TheHamkerCat.
+#
+
+import os
+import re
+import subprocess
+import sys
+import traceback
+from inspect import getfullargspec
+from io import StringIO
+from time import time
+
+from pyrogram import filters
+from pyrogram.types import (InlineKeyboardButton,
+ InlineKeyboardMarkup, Message)
+
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+
+
+async def aexec(code, client, message):
+ exec(
+ "async def __aexec(client, message): "
+ + "".join(f"\n {a}" for a in code.split("\n"))
+ )
+ return await locals()["__aexec"](client, message)
+
+
+async def edit_or_reply(msg: Message, **kwargs):
+ func = msg.edit_text if msg.from_user.is_self else msg.reply
+ spec = getfullargspec(func.__wrapped__).args
+ await func(**{k: v for k, v in kwargs.items() if k in spec})
+
+
+@app.on_message(
+ filters.command("eval")
+ & SUDOERS
+ & ~filters.forwarded
+ & ~filters.via_bot
+)
+async def executor(client, message):
+ if len(message.command) < 2:
+ return await edit_or_reply(
+ message, text="__Nigga Give me some command to execute.__"
+ )
+ try:
+ cmd = message.text.split(" ", maxsplit=1)[1]
+ except IndexError:
+ return await message.delete()
+ t1 = time()
+ old_stderr = sys.stderr
+ old_stdout = sys.stdout
+ redirected_output = sys.stdout = StringIO()
+ redirected_error = sys.stderr = StringIO()
+ stdout, stderr, exc = None, None, None
+ try:
+ await aexec(cmd, client, message)
+ except Exception:
+ exc = traceback.format_exc()
+ stdout = redirected_output.getvalue()
+ stderr = redirected_error.getvalue()
+ sys.stdout = old_stdout
+ sys.stderr = old_stderr
+ evaluation = ""
+ if exc:
+ evaluation = exc
+ elif stderr:
+ evaluation = stderr
+ elif stdout:
+ evaluation = stdout
+ else:
+ evaluation = "Success"
+ final_output = f"**OUTPUT**:\n```{evaluation.strip()}```"
+ if len(final_output) > 4096:
+ filename = "output.txt"
+ with open(filename, "w+", encoding="utf8") as out_file:
+ out_file.write(str(evaluation.strip()))
+ t2 = time()
+ keyboard = InlineKeyboardMarkup(
+ [
+ [
+ InlineKeyboardButton(
+ text="âŗ",
+ callback_data=f"runtime {t2-t1} Seconds",
+ )
+ ]
+ ]
+ )
+ await message.reply_document(
+ document=filename,
+ caption=f"**INPUT:**\n`{cmd[0:980]}`\n\n**OUTPUT:**\n`Attached Document`",
+ quote=False,
+ reply_markup=keyboard,
+ )
+ await message.delete()
+ os.remove(filename)
+ else:
+ t2 = time()
+ keyboard = InlineKeyboardMarkup(
+ [
+ [
+ InlineKeyboardButton(
+ text="âŗ",
+ callback_data=f"runtime {round(t2-t1, 3)} Seconds",
+ ),
+ InlineKeyboardButton(
+ text="đ",
+ callback_data=f"forceclose abc|{message.from_user.id}",
+ ),
+ ]
+ ]
+ )
+ await edit_or_reply(
+ message, text=final_output, reply_markup=keyboard
+ )
+
+
+@app.on_callback_query(filters.regex(r"runtime"))
+async def runtime_func_cq(_, cq):
+ runtime = cq.data.split(None, 1)[1]
+ await cq.answer(runtime, show_alert=True)
+
+
+@app.on_callback_query(filters.regex("forceclose"))
+async def forceclose_command(_, CallbackQuery):
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ query, user_id = callback_request.split("|")
+ if CallbackQuery.from_user.id != int(user_id):
+ try:
+ return await CallbackQuery.answer(
+ "You're not allowed to close this.", show_alert=True
+ )
+ except:
+ return
+ await CallbackQuery.message.delete()
+ try:
+ await CallbackQuery.answer()
+ except:
+ return
+
+
+@app.on_message(
+ filters.command("sh")
+ & SUDOERS
+ & ~filters.forwarded
+ & ~filters.via_bot
+)
+async def shellrunner(client, message):
+ if len(message.command) < 2:
+ return await edit_or_reply(
+ message, text="**Usage:**\n/sh git pull"
+ )
+ text = message.text.split(None, 1)[1]
+ if "\n" in text:
+ code = text.split("\n")
+ output = ""
+ for x in code:
+ shell = re.split(
+ """ (?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", x
+ )
+ try:
+ process = subprocess.Popen(
+ shell,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ )
+ except Exception as err:
+ print(err)
+ await edit_or_reply(
+ message, text=f"**ERROR:**\n```{err}```"
+ )
+ output += f"**{code}**\n"
+ output += process.stdout.read()[:-1].decode("utf-8")
+ output += "\n"
+ else:
+ shell = re.split(""" (?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", text)
+ for a in range(len(shell)):
+ shell[a] = shell[a].replace('"', "")
+ try:
+ process = subprocess.Popen(
+ shell,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ )
+ except Exception as err:
+ print(err)
+ exc_type, exc_obj, exc_tb = sys.exc_info()
+ errors = traceback.format_exception(
+ etype=exc_type,
+ value=exc_obj,
+ tb=exc_tb,
+ )
+ return await edit_or_reply(
+ message, text=f"**ERROR:**\n```{''.join(errors)}```"
+ )
+ output = process.stdout.read()[:-1].decode("utf-8")
+ if str(output) == "\n":
+ output = None
+ if output:
+ if len(output) > 4096:
+ with open("output.txt", "w+") as file:
+ file.write(output)
+ await client.send_document(
+ message.chat.id,
+ "output.txt",
+ reply_to_message_id=message.message_id,
+ caption="`Output`",
+ )
+ return os.remove("output.txt")
+ await edit_or_reply(
+ message, text=f"**OUTPUT:**\n```{output}```"
+ )
+ else:
+ await edit_or_reply(message, text="**OUTPUT: **\n`No output`")
diff --git a/YukkiMusic/plugins/misc/autoleave.py b/YukkiMusic/plugins/misc/autoleave.py
new file mode 100644
index 0000000000000000000000000000000000000000..cdbe20ad409dfd565574d49e5028aa335ca97424
--- /dev/null
+++ b/YukkiMusic/plugins/misc/autoleave.py
@@ -0,0 +1,88 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+from datetime import datetime
+
+import config
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki, autoend
+from YukkiMusic.utils.database import (get_client, is_active_chat,
+ is_autoend)
+
+
+async def auto_leave():
+ if config.AUTO_LEAVING_ASSISTANT == str(True):
+ while not await asyncio.sleep(
+ config.AUTO_LEAVE_ASSISTANT_TIME
+ ):
+ from YukkiMusic.core.userbot import assistants
+
+ for num in assistants:
+ client = await get_client(num)
+ left = 0
+ try:
+ async for i in client.iter_dialogs():
+ chat_type = i.chat.type
+ if chat_type in [
+ "supergroup",
+ "group",
+ "channel",
+ ]:
+ chat_id = i.chat.id
+ if (
+ chat_id != config.LOG_GROUP_ID
+ and chat_id != -1001190342892
+ and chat_id != -1001733534088
+ and chat_id != -1001443281821
+ ):
+ if left == 20:
+ continue
+ if not await is_active_chat(chat_id):
+ try:
+ await client.leave_chat(
+ chat_id
+ )
+ left += 1
+ except:
+ continue
+ except:
+ pass
+
+
+asyncio.create_task(auto_leave())
+
+
+async def auto_end():
+ while not await asyncio.sleep(5):
+ if not await is_autoend():
+ continue
+ for chat_id in autoend:
+ timer = autoend.get(chat_id)
+ if not timer:
+ continue
+ if datetime.now() > timer:
+ if not await is_active_chat(chat_id):
+ autoend[chat_id] = {}
+ continue
+ autoend[chat_id] = {}
+ try:
+ await Yukki.stop_stream(chat_id)
+ except:
+ continue
+ try:
+ await app.send_message(
+ chat_id,
+ "Bot has left voice chat due to inactivity to avoid overload on servers. No-one was listening to the bot on voice chat.",
+ )
+ except:
+ continue
+
+
+asyncio.create_task(auto_end())
diff --git a/YukkiMusic/plugins/misc/cleanmode.py b/YukkiMusic/plugins/misc/cleanmode.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b016769995a5256125b08ed06159059dbced003
--- /dev/null
+++ b/YukkiMusic/plugins/misc/cleanmode.py
@@ -0,0 +1,279 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+from datetime import datetime, timedelta
+
+from pyrogram import filters
+from pyrogram.errors import FloodWait
+from pyrogram.raw import types
+
+import config
+from config import adminlist, chatstats, clean, userstats
+from strings import get_command
+from YukkiMusic import app, userbot
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import (get_active_chats,
+ get_authuser_names, get_client,
+ get_particular_top,
+ get_served_chats,
+ get_served_users, get_user_top,
+ is_cleanmode_on, set_queries,
+ update_particular_top,
+ update_user_top)
+from YukkiMusic.utils.decorators.language import language
+from YukkiMusic.utils.formatters import alpha_to_int
+
+BROADCAST_COMMAND = get_command("BROADCAST_COMMAND")
+AUTO_DELETE = config.CLEANMODE_DELETE_MINS
+AUTO_SLEEP = 5
+IS_BROADCASTING = False
+cleanmode_group = 15
+
+
+@app.on_raw_update(group=cleanmode_group)
+async def clean_mode(client, update, users, chats):
+ global IS_BROADCASTING
+ if IS_BROADCASTING:
+ return
+ try:
+ if not isinstance(update, types.UpdateReadChannelOutbox):
+ return
+ except:
+ return
+ if users:
+ return
+ if chats:
+ return
+ message_id = update.max_id
+ chat_id = int(f"-100{update.channel_id}")
+ if not await is_cleanmode_on(chat_id):
+ return
+ if chat_id not in clean:
+ clean[chat_id] = []
+ time_now = datetime.now()
+ put = {
+ "msg_id": message_id,
+ "timer_after": time_now + timedelta(minutes=AUTO_DELETE),
+ }
+ clean[chat_id].append(put)
+ await set_queries(1)
+
+
+@app.on_message(filters.command(BROADCAST_COMMAND) & SUDOERS)
+@language
+async def braodcast_message(client, message, _):
+ global IS_BROADCASTING
+ if message.reply_to_message:
+ x = message.reply_to_message.message_id
+ y = message.chat.id
+ else:
+ if len(message.command) < 2:
+ return await message.reply_text(_["broad_5"])
+ query = message.text.split(None, 1)[1]
+ if "-pin" in query:
+ query = query.replace("-pin", "")
+ if "-nobot" in query:
+ query = query.replace("-nobot", "")
+ if "-pinloud" in query:
+ query = query.replace("-pinloud", "")
+ if "-assistant" in query:
+ query = query.replace("-assistant", "")
+ if "-user" in query:
+ query = query.replace("-user", "")
+ if query == "":
+ return await message.reply_text(_["broad_6"])
+
+ IS_BROADCASTING = True
+
+ # Bot broadcast inside chats
+ if "-nobot" not in message.text:
+ sent = 0
+ pin = 0
+ chats = []
+ schats = await get_served_chats()
+ for chat in schats:
+ chats.append(int(chat["chat_id"]))
+ for i in chats:
+ if i == -1001733534088:
+ continue
+ try:
+ m = (
+ await app.forward_messages(i, y, x)
+ if message.reply_to_message
+ else await app.send_message(i, text=query)
+ )
+ if "-pin" in message.text:
+ try:
+ await m.pin(disable_notification=True)
+ pin += 1
+ except Exception:
+ continue
+ elif "-pinloud" in message.text:
+ try:
+ await m.pin(disable_notification=False)
+ pin += 1
+ except Exception:
+ continue
+ sent += 1
+ except FloodWait as e:
+ flood_time = int(e.x)
+ if flood_time > 200:
+ continue
+ await asyncio.sleep(flood_time)
+ except Exception:
+ continue
+ try:
+ await message.reply_text(_["broad_1"].format(sent, pin))
+ except:
+ pass
+
+ # Bot broadcasting to users
+ if "-user" in message.text:
+ susr = 0
+ served_users = []
+ susers = await get_served_users()
+ for user in susers:
+ served_users.append(int(user["user_id"]))
+ for i in served_users:
+ try:
+ m = (
+ await app.forward_messages(i, y, x)
+ if message.reply_to_message
+ else await app.send_message(i, text=query)
+ )
+ susr += 1
+ except FloodWait as e:
+ flood_time = int(e.x)
+ if flood_time > 200:
+ continue
+ await asyncio.sleep(flood_time)
+ except Exception:
+ pass
+ try:
+ await message.reply_text(_["broad_7"].format(susr))
+ except:
+ pass
+
+ # Bot broadcasting by assistant
+ if "-assistant" in message.text:
+ aw = await message.reply_text(_["broad_2"])
+ text = _["broad_3"]
+ from YukkiMusic.core.userbot import assistants
+
+ for num in assistants:
+ sent = 0
+ client = await get_client(num)
+ async for dialog in client.iter_dialogs():
+ if dialog.chat.id == -1001733534088:
+ continue
+ try:
+ await client.forward_messages(
+ dialog.chat.id, y, x
+ ) if message.reply_to_message else await client.send_message(
+ dialog.chat.id, text=query
+ )
+ sent += 1
+ except FloodWait as e:
+ flood_time = int(e.x)
+ if flood_time > 200:
+ continue
+ await asyncio.sleep(flood_time)
+ except Exception as e:
+ print(e)
+ continue
+ text += _["broad_4"].format(num, sent)
+ try:
+ await aw.edit_text(text)
+ except:
+ pass
+ IS_BROADCASTING = False
+
+
+async def auto_clean():
+ while not await asyncio.sleep(AUTO_SLEEP):
+ try:
+ for chat_id in chatstats:
+ for dic in chatstats[chat_id]:
+ vidid = dic["vidid"]
+ title = dic["title"]
+ chatstats[chat_id].pop(0)
+ spot = await get_particular_top(chat_id, vidid)
+ if spot:
+ spot = spot["spot"]
+ next_spot = spot + 1
+ new_spot = {"spot": next_spot, "title": title}
+ await update_particular_top(
+ chat_id, vidid, new_spot
+ )
+ else:
+ next_spot = 1
+ new_spot = {"spot": next_spot, "title": title}
+ await update_particular_top(
+ chat_id, vidid, new_spot
+ )
+ for user_id in userstats:
+ for dic in userstats[user_id]:
+ vidid = dic["vidid"]
+ title = dic["title"]
+ userstats[user_id].pop(0)
+ spot = await get_user_top(user_id, vidid)
+ if spot:
+ spot = spot["spot"]
+ next_spot = spot + 1
+ new_spot = {"spot": next_spot, "title": title}
+ await update_user_top(
+ user_id, vidid, new_spot
+ )
+ else:
+ next_spot = 1
+ new_spot = {"spot": next_spot, "title": title}
+ await update_user_top(
+ user_id, vidid, new_spot
+ )
+ except:
+ continue
+ try:
+ for chat_id in clean:
+ if chat_id == config.LOG_GROUP_ID:
+ continue
+ for x in clean[chat_id]:
+ if datetime.now() > x["timer_after"]:
+ try:
+ await app.delete_messages(
+ chat_id, x["msg_id"]
+ )
+ except FloodWait as e:
+ await asyncio.sleep(e.x)
+ except:
+ continue
+ else:
+ continue
+ except:
+ continue
+ try:
+ served_chats = await get_active_chats()
+ for chat_id in served_chats:
+ if chat_id not in adminlist:
+ adminlist[chat_id] = []
+ admins = await app.get_chat_members(
+ chat_id, filter="administrators"
+ )
+ for user in admins:
+ if user.can_manage_voice_chats:
+ adminlist[chat_id].append(user.user.id)
+ authusers = await get_authuser_names(chat_id)
+ for user in authusers:
+ user_id = await alpha_to_int(user)
+ adminlist[chat_id].append(user_id)
+ except:
+ continue
+
+
+asyncio.create_task(auto_clean())
diff --git a/YukkiMusic/plugins/misc/seeker.py b/YukkiMusic/plugins/misc/seeker.py
new file mode 100644
index 0000000000000000000000000000000000000000..02e0588bf37fe15ef876b54dbbb07321f1c1a516
--- /dev/null
+++ b/YukkiMusic/plugins/misc/seeker.py
@@ -0,0 +1,103 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+import asyncio
+
+from pyrogram.types import InlineKeyboardMarkup
+
+from strings import get_string
+from YukkiMusic.misc import db
+from YukkiMusic.utils.database import (get_active_chats, get_lang,
+ is_music_playing)
+from YukkiMusic.utils.formatters import seconds_to_min
+from YukkiMusic.utils.inline import (stream_markup_timer,
+ telegram_markup_timer)
+
+from ..admins.callback import wrong
+
+checker = {}
+
+
+async def timer():
+ while not await asyncio.sleep(1):
+ active_chats = await get_active_chats()
+ for chat_id in active_chats:
+ if not await is_music_playing(chat_id):
+ continue
+ playing = db.get(chat_id)
+ if not playing:
+ continue
+ file_path = playing[0]["file"]
+ if "index_" in file_path or "live_" in file_path:
+ continue
+ duration = int(playing[0]["seconds"])
+ if duration == 0:
+ continue
+ db[chat_id][0]["played"] += 1
+
+
+asyncio.create_task(timer())
+
+
+async def markup_timer():
+ while not await asyncio.sleep(4):
+ active_chats = await get_active_chats()
+ for chat_id in active_chats:
+ try:
+ if not await is_music_playing(chat_id):
+ continue
+ playing = db.get(chat_id)
+ if not playing:
+ continue
+ duration_seconds = int(playing[0]["seconds"])
+ if duration_seconds == 0:
+ continue
+ try:
+ mystic = playing[0]["mystic"]
+ markup = playing[0]["markup"]
+ except:
+ continue
+ try:
+ check = wrong[chat_id][mystic.message_id]
+ if check is False:
+ continue
+ except:
+ pass
+ try:
+ language = await get_lang(chat_id)
+ _ = get_string(language)
+ except:
+ _ = get_string("en")
+ try:
+ buttons = (
+ stream_markup_timer(
+ _,
+ playing[0]["vidid"],
+ chat_id,
+ seconds_to_min(playing[0]["played"]),
+ playing[0]["dur"],
+ )
+ if markup == "stream"
+ else telegram_markup_timer(
+ _,
+ chat_id,
+ seconds_to_min(playing[0]["played"]),
+ playing[0]["dur"],
+ )
+ )
+ await mystic.edit_reply_markup(
+ reply_markup=InlineKeyboardMarkup(buttons)
+ )
+ except:
+ continue
+ except:
+ continue
+
+
+asyncio.create_task(markup_timer())
diff --git a/YukkiMusic/plugins/misc/suggestion.py b/YukkiMusic/plugins/misc/suggestion.py
new file mode 100644
index 0000000000000000000000000000000000000000..be6ef4a68108636ac5bbd8ff5e5efb06cf42b370
--- /dev/null
+++ b/YukkiMusic/plugins/misc/suggestion.py
@@ -0,0 +1,89 @@
+#
+# 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 random
+from datetime import datetime, timedelta
+
+import config
+from config import clean
+from strings import get_string
+from YukkiMusic import app
+from YukkiMusic.utils.database import (get_lang,
+ get_private_served_chats,
+ get_served_chats,
+ is_suggestion)
+
+LEAVE_TIME = config.AUTO_SUGGESTION_TIME
+
+
+strings = []
+suggestor = {}
+
+for item in get_string("en"):
+ if item[0:3] == "sug" and item != "sug_0":
+ strings.append(item)
+
+
+async def dont_do_this():
+ if config.AUTO_SUGGESTION_MODE == str(True):
+ while not await asyncio.sleep(LEAVE_TIME):
+ try:
+ chats = []
+ if config.PRIVATE_BOT_MODE == str(True):
+ schats = await get_private_served_chats()
+ else:
+ schats = await get_served_chats()
+ for chat in schats:
+ chats.append(int(chat["chat_id"]))
+ total = len(chats)
+ if total >= 100:
+ total //= 10
+ send_to = 0
+ random.shuffle(chats)
+ for x in chats:
+ if send_to == total:
+ break
+ if x == config.LOG_GROUP_ID:
+ continue
+ if not await is_suggestion(x):
+ continue
+ try:
+ language = await get_lang(x)
+ _ = get_string(language)
+ except:
+ _ = get_string("en")
+ string = random.choice(strings)
+ previous = suggestor.get(x)
+ if previous:
+ while previous == (string.split("_")[1]):
+ string = random.choice(strings)
+ suggestor[x] = string.split("_")[1]
+ try:
+ msg = _["sug_0"] + _[string]
+ sent = await app.send_message(x, msg)
+ if x not in clean:
+ clean[x] = []
+ time_now = datetime.now()
+ put = {
+ "msg_id": sent.message_id,
+ "timer_after": time_now
+ + timedelta(
+ minutes=config.CLEANMODE_DELETE_MINS
+ ),
+ }
+ clean[x].append(put)
+ send_to += 1
+ except:
+ pass
+ except:
+ pass
+
+
+asyncio.create_task(dont_do_this())
diff --git a/YukkiMusic/plugins/play/Chat_Selecter.py b/YukkiMusic/plugins/play/Chat_Selecter.py
new file mode 100644
index 0000000000000000000000000000000000000000..87cdfdc732650ad36e0b51345c82f50d567898fb
--- /dev/null
+++ b/YukkiMusic/plugins/play/Chat_Selecter.py
@@ -0,0 +1,125 @@
+import random
+import string
+from ast import ExceptHandler
+import traceback
+from pyrogram import filters
+from pyrogram import enums
+from pyrogram.types import (InlineKeyboardMarkup,InlineKeyboardButton,WebAppInfo, InputMediaPhoto,KeyboardButton,ReplyKeyboardMarkup,
+ Message)
+from pytgcalls.exceptions import NoActiveGroupCall
+#from pyrogram.raw.types import UpdateWebViewResultSent, UpdateWebPage
+from pyrogram.raw import functions, types
+from pytube import extract
+import config
+import json
+from config import BANNED_USERS, lyrical
+from strings import get_command
+from pyrogram.enums import ParseMode, ChatType
+from YukkiMusic import (Apple, Resso, SoundCloud, Spotify, Telegram,
+ YouTube, app)
+from strings import get_string
+from YukkiMusic.utils.database import (get_cmode, get_lang,
+ get_playmode, get_playtype,
+ is_active_chat,
+ is_commanddelete_on,
+ is_served_private_chat)
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils import seconds_to_min, time_to_seconds
+from YukkiMusic.utils.channelplay import get_channeplayCB
+from YukkiMusic.utils.database import is_video_allowed
+from YukkiMusic.utils.decorators.language import languageCB
+from YukkiMusic.utils.decorators.play import PlayWrapper
+from YukkiMusic.utils.formatters import formats
+from YukkiMusic.utils.inline.play import (livestream_markup,
+ playlist_markup,
+ slider_markup, track_markup)
+from YukkiMusic.utils.inline.playlist import botplaylist_markup
+from YukkiMusic.utils.logger import play_logs
+from YukkiMusic.utils.stream.stream import stream
+
+
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+
+
+@app.on_callback_query()
+async def callback_query_handler(client, callback_query):
+ data = callback_query.data
+ print(data, callback_query)
+
+ check=data.split(' ')[0]
+ id = data.split(' ')[1]
+ chat_id = data.split(' ')[2]
+ user_idx=callback_query.from_user.id
+ user_id= callback_query.from_user.id
+ language = await get_lang(callback_query.from_user.id)
+ _ = get_string(language)
+ details, track_id = await YouTube.track(id, True)
+ streamtype = "nodownload"
+ img = details["thumb"]
+ cap = _["play_19"].format(
+ details["title"],
+ details["duration_min"],
+ )
+
+ video = True if check == "v" else None
+ #print(check,video)
+ buttons = InlineKeyboardButton("Go to Group", url='https://t.me/+MeO0kQmZ5ddiYmZl')
+ await callback_query.message.reply_photo(
+ photo=img,
+ caption=cap,
+ reply_markup=InlineKeyboardMarkup([[buttons]]),
+ )
+ try:
+ await stream(
+ _,
+ 'mystic',
+ user_id,
+ details,
+ chat_id,
+ user_name,
+ chat_id,
+ video=video,
+ streamtype=streamtype
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await client.send_message(user_idx, f"Received err: {err}")
+
+ await play_logs(callback_query.message, streamtype=streamtype)
+ #await client.send_message(user_idx, f"Received WebApp data: {web_app_data}")
+
+async def chat_selecter(client, data):
+ button_list=[]
+ """chat_list = []
+ count=0
+ async for chat in client.get_chats():
+ print(chat)
+ try:
+ chat_info = await client.get_chat(chat.id)
+ # Check if the chat is a group or supergroup
+ if chat_info.type in ["supergroup"]:
+ chat_list.append({ "text": chat_info.title, "callback_data": f"{data} {chat_info.id}"})
+ count+=1
+ except Exception as e:
+ print(f"Error fetching chat info for chat ID {chat.id}: {e}")"""
+ chat_list=[
+ { "text": "Only Logs [ Updates Group ]", "callback_data": f"{data.get('check')} {data.get('id')} {int(-1002090110322)}"},
+ { "text": "Me & Her", "callback_data": f"{data.get('check')} {data.get('id')} {int(-1001847684787)}"}
+ ]
+ for button in chat_list:
+ button_list.append(
+ InlineKeyboardButton(
+ text= button['text'],
+ callback_data = button['callback_data']
+ ))
+
+ # Send a message with the inline keyboard
+ return button_list
diff --git a/YukkiMusic/plugins/play/channel.py b/YukkiMusic/plugins/play/channel.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e0d6212021b75f87e31c712b0f40467a159c9d9
--- /dev/null
+++ b/YukkiMusic/plugins/play/channel.py
@@ -0,0 +1,76 @@
+#
+# 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 import set_cmode
+from YukkiMusic.utils.decorators.admins import AdminActual
+
+### Multi-Lang Commands
+CHANNELPLAY_COMMAND = get_command("CHANNELPLAY_COMMAND")
+
+
+@app.on_message(
+ filters.command(CHANNELPLAY_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@AdminActual
+async def playmode_(client, message: Message, _):
+ if len(message.command) < 2:
+ return await message.reply_text(
+ _["cplay_1"].format(
+ message.chat.title, CHANNELPLAY_COMMAND[0]
+ )
+ )
+ query = message.text.split(None, 2)[1].lower().strip()
+ if (str(query)).lower() == "disable":
+ await set_cmode(message.chat.id, None)
+ return await message.reply_text("Channel Play Disabled")
+ elif str(query) == "linked":
+ chat = await app.get_chat(message.chat.id)
+ if chat.linked_chat:
+ chat_id = chat.linked_chat.id
+ await set_cmode(message.chat.id, chat_id)
+ return await message.reply_text(
+ _["cplay_3"].format(
+ chat.linked_chat.title, chat.linked_chat.id
+ )
+ )
+ else:
+ return await message.reply_text(_["cplay_2"])
+ else:
+ try:
+ chat = await app.get_chat(query)
+ except:
+ return await message.reply_text(_["cplay_4"])
+ if chat.type != "channel":
+ return await message.reply_text(_["cplay_5"])
+ try:
+ admins = await app.get_chat_members(
+ chat.id, filter="administrators"
+ )
+ except:
+ return await message.reply_text(_["cplay_4"])
+ for users in admins:
+ if users.status == "creator":
+ creatorusername = users.user.username
+ creatorid = users.user.id
+ if creatorid != message.from_user.id:
+ return await message.reply_text(
+ _["cplay_6"].format(chat.title, creatorusername)
+ )
+ await set_cmode(message.chat.id, chat.id)
+ return await message.reply_text(
+ _["cplay_3"].format(chat.title, chat.id)
+ )
diff --git a/YukkiMusic/plugins/play/play.py b/YukkiMusic/plugins/play/play.py
new file mode 100644
index 0000000000000000000000000000000000000000..9890f52a64f85f00fed6e956d40f65726288f742
--- /dev/null
+++ b/YukkiMusic/plugins/play/play.py
@@ -0,0 +1,849 @@
+#
+# 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
+import string
+from ast import ExceptHandler
+import traceback
+from pyrogram import filters
+from pyrogram.types import (InlineKeyboardMarkup, InputMediaPhoto,
+ Message)
+from pytgcalls.exceptions import NoActiveGroupCall
+from pytube import extract
+import config
+from config import BANNED_USERS, lyrical
+from strings import get_command
+from YukkiMusic import (Apple, Resso, SoundCloud, Spotify, Telegram,
+ YouTube, app)
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils import seconds_to_min, time_to_seconds
+from YukkiMusic.utils.channelplay import get_channeplayCB
+from YukkiMusic.utils.database import is_video_allowed
+from YukkiMusic.utils.decorators.language import languageCB
+from YukkiMusic.utils.decorators.play import PlayWrapper
+from YukkiMusic.utils.formatters import formats
+from YukkiMusic.utils.inline.play import (livestream_markup,
+ playlist_markup,
+ slider_markup, track_markup)
+from YukkiMusic.utils.inline.playlist import botplaylist_markup
+from YukkiMusic.utils.logger import play_logs
+from YukkiMusic.utils.stream.stream import stream
+
+# Command
+PLAY_COMMAND = get_command("PLAY_COMMAND")
+
+
+
+@app.on_message(
+ filters.command(PLAY_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@PlayWrapper
+async def play_commnd(
+ client,
+ message: Message,
+ _,
+ chat_id,
+ video,
+ channel,
+ playmode,
+ url,
+ fplay,
+):
+ mystic = await message.reply_text(
+ _["play_2"].format(channel) if channel else _["play_1"]
+ )
+ plist_id = None
+ slider = None
+ plist_type = None
+ spotify = None
+ user_id = message.from_user.id
+ user_name = message.from_user.first_name
+ audio_telegram = (
+ (
+ message.reply_to_message.audio
+ or message.reply_to_message.voice
+ )
+ if message.reply_to_message
+ else None
+ )
+ video_telegram = (
+ (
+ message.reply_to_message.video
+ or message.reply_to_message.document
+ )
+ if message.reply_to_message
+ else None
+ )
+ if audio_telegram:
+ duration_min = seconds_to_min(audio_telegram.duration)
+
+ if (len(message.command) > 1) and (message.command[1].lower()== 'direct') :
+ direct=True
+ file_path = f"https://privateone-one-stream.hf.space/dl/{message.reply_to_message_id}"
+ print(file_path)
+ else:
+ if (audio_telegram.file_size > config.TG_AUDIO_FILESIZE_LIMIT) and (len(message.command) < 2) :
+ return await mystic.edit_text(_["play_5"])
+
+ if ((audio_telegram.duration) > config.DURATION_LIMIT ) and (len(message.command) < 2):
+ return await mystic.edit_text(
+ _["play_6"].format(
+ config.DURATION_LIMIT_MIN, duration_min
+ )
+ )
+ file_path = await Telegram.get_filepath(audio=audio_telegram)
+ if await Telegram.download(_, message, mystic, file_path):
+ direct=False
+ file_path=file_path
+ message_link = await Telegram.get_link(message)
+ file_name = await Telegram.get_filename(
+ audio_telegram, audio=True
+ )
+ dur = await Telegram.get_duration(audio_telegram)
+ details = {
+ "title": file_name,
+ "link": message_link,
+ "path": file_path,
+ "dur": dur,
+ "direct":direct,
+ "reply_to_message":message.reply_to_message_id
+ }
+
+ try:
+ await stream(
+ _,
+ mystic,
+ user_id,
+ details,
+ chat_id,
+ user_name,
+ message.chat.id,
+ streamtype="telegram",
+ forceplay=fplay,
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await mystic.delete()
+ #return
+ elif video_telegram:
+ if not await is_video_allowed(message.chat.id):
+ return await mystic.edit_text(_["play_3"])
+ if message.reply_to_message.document:
+ try:
+ ext = video_telegram.file_name.split(".")[-1]
+ if ext.lower() not in formats:
+ return await mystic.edit_text(
+ _["play_8"].format(f"{' | '.join(formats)}")
+ )
+ except:
+ return await mystic.edit_text(
+ _["play_8"].format(f"{' | '.join(formats)}")
+ )
+ if (len(message.command) > 1) and (message.command[1].lower()== 'direct') :
+ file_path = f"https://privateone-one-stream.hf.space/dl/{message.reply_to_message_id}"
+ direct=True
+ print(file_path)
+ else:
+ if (video_telegram.file_size > config.TG_VIDEO_FILESIZE_LIMIT) and (len(message.command) < 2):
+ return await mystic.edit_text(_["play_9"])
+ file_path = await Telegram.get_filepath(video=video_telegram)
+
+ if await Telegram.download(_, message, mystic, file_path):
+ file_path=file_path
+ direct=False
+ message_link = await Telegram.get_link(message)
+ file_name = await Telegram.get_filename(video_telegram)
+ dur = await Telegram.get_duration(video_telegram)
+ details = {
+ "title": file_name,
+ "link": message_link,
+ "path": file_path,
+ "dur": dur,
+ "direct":direct,
+ "reply_to_message":message.reply_to_message_id
+ }
+ try:
+ await stream(
+ _,
+ mystic,
+ user_id,
+ details,
+ chat_id,
+ user_name,
+ message.chat.id,
+ video=True,
+ streamtype="telegram",
+ forceplay=fplay,
+ )
+ except Exception as e:
+ print(traceback.print_exc())
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await mystic.delete()
+ #return
+ elif url:
+ if await YouTube.exists(url):
+ if "playlist" in url:
+
+ try:
+ details = await YouTube.playlist(
+ url,
+ config.PLAYLIST_FETCH_LIMIT,
+ message.from_user.id,
+ )
+ except Exception as e:
+ print(e)
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "playlist"
+ plist_type = "yt"
+ if "&" in url:
+ plist_id = (url.split("=")[1]).split("&")[0]
+ else:
+ plist_id = url.split("=")[1]
+ img = config.PLAYLIST_IMG_URL
+ cap = _["play_10"]
+ else:
+
+ try:
+ id = extract.video_id(url)
+ except Exception as e:
+ id=None
+ try:
+ if id:
+ details, track_id = await YouTube.track(id,True)
+ else:
+ details, track_id = await YouTube.track(url)
+ except Exception as e:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ if (len(message.command) > 2) and (message.command[1].lower()== 'direct'):
+ streamtype = "nodownload"
+ else:
+ streamtype = "youtube"
+ img = details["thumb"]
+ cap = _["play_11"].format(
+ details["title"],
+ details["duration_min"],
+ )
+ elif await Spotify.valid(url):
+ spotify = True
+ if (
+ not config.SPOTIFY_CLIENT_ID
+ and not config.SPOTIFY_CLIENT_SECRET
+ ):
+ return await mystic.edit_text(
+ "This bot isn't able to play spotify queries. Please ask my owner to enable spotify."
+ )
+ if "track" in url:
+ try:
+ details, track_id = await Spotify.track(url)
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "youtube"
+ img = details["thumb"]
+ cap = _["play_11"].format(
+ details["title"], details["duration_min"]
+ )
+ elif "playlist" in url:
+ try:
+ details, plist_id = await Spotify.playlist(url)
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "playlist"
+ plist_type = "spplay"
+ img = config.SPOTIFY_PLAYLIST_IMG_URL
+ cap = _["play_12"].format(
+ message.from_user.first_name
+ )
+ elif "album" in url:
+ try:
+ details, plist_id = await Spotify.album(url)
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "playlist"
+ plist_type = "spalbum"
+ img = config.SPOTIFY_ALBUM_IMG_URL
+ cap = _["play_12"].format(
+ message.from_user.first_name
+ )
+ elif "artist" in url:
+ try:
+ details, plist_id = await Spotify.artist(url)
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "playlist"
+ plist_type = "spartist"
+ img = config.SPOTIFY_ARTIST_IMG_URL
+ cap = _["play_12"].format(
+ message.from_user.first_name
+ )
+ else:
+ return await mystic.edit_text(_["play_17"])
+ elif await Apple.valid(url):
+ if "album" in url:
+ try:
+ details, track_id = await Apple.track(url)
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "youtube"
+ img = details["thumb"]
+ cap = _["play_11"].format(
+ details["title"], details["duration_min"]
+ )
+ elif "playlist" in url:
+ spotify = True
+ try:
+ details, plist_id = await Apple.playlist(url)
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "playlist"
+ plist_type = "apple"
+ cap = _["play_13"].format(
+ message.from_user.first_name
+ )
+ img = url
+ else:
+ return await mystic.edit_text(_["play_16"])
+ elif await Resso.valid(url):
+ try:
+ details, track_id = await Resso.track(url)
+ except Exception as e:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "youtube"
+ img = details["thumb"]
+ cap = _["play_11"].format(
+ details["title"], details["duration_min"]
+ )
+ elif await SoundCloud.valid(url):
+ try:
+ details, track_path = await SoundCloud.download(url)
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+ duration_sec = details["duration_sec"]
+ if duration_sec > config.DURATION_LIMIT:
+ return await mystic.edit_text(
+ _["play_6"].format(
+ config.DURATION_LIMIT_MIN,
+ details["duration_min"],
+ )
+ )
+ try:
+ await stream(
+ _,
+ mystic,
+ user_id,
+ details,
+ chat_id,
+ user_name,
+ message.chat.id,
+ streamtype="soundcloud",
+ forceplay=fplay,
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await mystic.delete()
+ else:
+ try:
+ await Yukki.stream_call(url)
+ except NoActiveGroupCall:
+ await mystic.edit_text(
+ "There's an issue with the bot. Please report it to my owner and ask them to check logger group."
+ )
+ return await app.send_message(
+ config.LOG_GROUP_ID,
+ "Please turn on Voice Chat.. Bot is not able to stream urls..",
+ )
+ except Exception as e:
+ return await mystic.edit_text(
+ _["general_3"].format(type(e).__name__)
+ )
+ await mystic.edit_text(_["str_2"])
+ try:
+ await stream(
+ _,
+ mystic,
+ message.from_user.id,
+ url,
+ chat_id,
+ message.from_user.first_name,
+ message.chat.id,
+ video=video,
+ streamtype="index",
+ forceplay=fplay,
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await play_logs(
+ message, streamtype="M3u8 or Index Link"
+ )
+ else:
+ if len(message.command) < 2:
+ buttons = botplaylist_markup(_)
+ return await mystic.edit_text(
+ _["playlist_1"],
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+ slider = True
+ query = message.text.split(None, 1)[1]
+ if "-v" in query:
+ query = query.replace("-v", "")
+ if "playlist" in query:
+ try:
+ details = await YouTube.playlist(
+ query,
+ config.PLAYLIST_FETCH_LIMIT,
+ message.from_user.id,
+ )
+ except Exception as e:
+ print(e)
+ return await mystic.edit_text(_["play_3"])
+ streamtype = "playlist"
+ plist_type = "yt"
+ if "&" in query:
+ plist_id = (query.split("=")[1]).split("&")[0]
+ else:
+ plist_id = query.split("=")[1]
+ img = config.PLAYLIST_IMG_URL
+ cap = _["play_10"]
+ else:
+ try:
+ id = extract.video_id(query)
+ except Exception as e:
+ id=None
+ try:
+ if id:
+ details, track_id = await YouTube.track(id,True)
+ else:
+ details, track_id = await YouTube.track(query)
+ #try:
+ #details, track_id = await YouTube.track(query)
+
+ except Exception:
+ print(traceback.print_exc())
+ return await mystic.edit_text(_["play_3"])
+
+ if (len(message.command) > 2) and (message.command[1].lower()== 'direct'):
+ streamtype = "nodownload"
+
+ else:
+ streamtype = "youtube"
+ #streamtype = "youtube"
+
+
+ if str(playmode) == "Direct":
+ if not plist_type:
+ if details["duration_min"]:
+ duration_sec = time_to_seconds(
+ details["duration_min"]
+ )
+ if (duration_sec > config.DURATION_LIMIT) and (message.command[1].lower() != 'direct') :
+ return await mystic.edit_text(
+ _["play_6"].format(
+ config.DURATION_LIMIT_MIN,
+ details["duration_min"],
+ )
+ )
+ else:
+ buttons = livestream_markup(
+ _,
+ track_id,
+ user_id,
+ "v" if video else "a",
+ "c" if channel else "g",
+ "f" if fplay else "d",
+ )
+ return await mystic.edit_text(
+ _["play_15"],
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+ try:
+ await stream(
+ _,
+ mystic,
+ user_id,
+ details,
+ chat_id,
+ user_name,
+ message.chat.id,
+ video=video,
+ streamtype=streamtype,
+ spotify=spotify,
+ forceplay=fplay,
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ await mystic.delete()
+ return await play_logs(message, streamtype=streamtype)
+ else:
+ if plist_type:
+ ran_hash = "".join(
+ random.choices(
+ string.ascii_uppercase + string.digits, k=10
+ )
+ )
+ lyrical[ran_hash] = plist_id
+ buttons = playlist_markup(
+ _,
+ ran_hash,
+ message.from_user.id,
+ plist_type,
+ "c" if channel else "g",
+ "f" if fplay else "d",
+ )
+ await mystic.delete()
+ await message.reply_photo(
+ photo=img,
+ caption=cap,
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+ return await play_logs(
+ message, streamtype=f"Playlist : {plist_type}"
+ )
+ else:
+ if slider:
+ buttons = slider_markup(
+ _,
+ track_id,
+ message.from_user.id,
+ query,
+ 0,
+ "c" if channel else "g",
+ "f" if fplay else "d",
+ )
+ await mystic.delete()
+ await message.reply_photo(
+ photo=details["thumb"],
+ caption=_["play_11"].format(
+ details["title"].title(),
+ details["duration_min"],
+ ),
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+ return await play_logs(
+ message, streamtype=f"Searched on Youtube"
+ )
+ else:
+ buttons = track_markup(
+ _,
+ track_id,
+ message.from_user.id,
+ "c" if channel else "g",
+ "f" if fplay else "d",
+ )
+ await mystic.delete()
+ await message.reply_photo(
+ photo=img,
+ caption=cap,
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+ return await play_logs(
+ message, streamtype=f"URL Searched Inline"
+ )
+
+
+@app.on_callback_query(filters.regex("MusicStream") & ~BANNED_USERS)
+@languageCB
+async def play_music(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ vidid, user_id, mode, cplay, fplay = callback_request.split("|")
+ if CallbackQuery.from_user.id != int(user_id):
+ try:
+ return await CallbackQuery.answer(
+ _["playcb_1"], show_alert=True
+ )
+ except:
+ return
+ try:
+ chat_id, channel = await get_channeplayCB(
+ _, cplay, CallbackQuery
+ )
+ except:
+ return
+ user_name = CallbackQuery.from_user.first_name
+ try:
+ await CallbackQuery.message.delete()
+ await CallbackQuery.answer()
+ except:
+ pass
+ mystic = await CallbackQuery.message.reply_text(
+ _["play_2"].format(channel) if channel else _["play_1"]
+ )
+ try:
+ details, track_id = await YouTube.track(vidid, True)
+ except Exception:
+ return await mystic.edit_text(_["play_3"])
+ if details["duration_min"]:
+ duration_sec = time_to_seconds(details["duration_min"])
+ if duration_sec > config.DURATION_LIMIT:
+ return await mystic.edit_text(
+ _["play_6"].format(
+ config.DURATION_LIMIT_MIN, details["duration_min"]
+ )
+ )
+ else:
+ buttons = livestream_markup(
+ _,
+ track_id,
+ CallbackQuery.from_user.id,
+ mode,
+ "c" if cplay == "c" else "g",
+ "f" if fplay else "d",
+ )
+ return await mystic.edit_text(
+ _["play_15"],
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+ video = True if mode == "v" else None
+ ffplay = True if fplay == "f" else None
+ try:
+ await stream(
+ _,
+ mystic,
+ CallbackQuery.from_user.id,
+ details,
+ chat_id,
+ user_name,
+ CallbackQuery.message.chat.id,
+ video,
+ streamtype="youtube",
+ forceplay=ffplay,
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await mystic.delete()
+
+
+@app.on_callback_query(
+ filters.regex("AnonymousAdmin") & ~BANNED_USERS
+)
+async def anonymous_check(client, CallbackQuery):
+ try:
+ await CallbackQuery.answer(
+ "You're an Anonymous Admin\n\nGo to your group's setting \n-> Administrators List \n-> Click on your name \n-> uncheck REMAIN ANONYMOUS button there.",
+ show_alert=True,
+ )
+ except:
+ return
+
+
+@app.on_callback_query(
+ filters.regex("YukkiPlaylists") & ~BANNED_USERS
+)
+@languageCB
+async def play_playlists_command(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ (
+ videoid,
+ user_id,
+ ptype,
+ mode,
+ cplay,
+ fplay,
+ ) = callback_request.split("|")
+ if CallbackQuery.from_user.id != int(user_id):
+ try:
+ return await CallbackQuery.answer(
+ _["playcb_1"], show_alert=True
+ )
+ except:
+ return
+ try:
+ chat_id, channel = await get_channeplayCB(
+ _, cplay, CallbackQuery
+ )
+ except:
+ return
+ user_name = CallbackQuery.from_user.first_name
+ await CallbackQuery.message.delete()
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ mystic = await CallbackQuery.message.reply_text(
+ _["play_2"].format(channel) if channel else _["play_1"]
+ )
+ videoid = lyrical.get(videoid)
+ video = True if mode == "v" else None
+ ffplay = True if fplay == "f" else None
+ spotify = True
+ if ptype == "yt":
+ spotify = False
+ try:
+ result = await YouTube.playlist(
+ videoid,
+ config.PLAYLIST_FETCH_LIMIT,
+ CallbackQuery.from_user.id,
+ True,
+ )
+ except Exception:
+ return await mystic.edit_text(_["play_3"])
+ if ptype == "spplay":
+ try:
+ result, spotify_id = await Spotify.playlist(videoid)
+ except Exception:
+ return await mystic.edit_text(_["play_3"])
+ if ptype == "spalbum":
+ try:
+ result, spotify_id = await Spotify.album(videoid)
+ except Exception:
+ return await mystic.edit_text(_["play_3"])
+ if ptype == "spartist":
+ try:
+ result, spotify_id = await Spotify.artist(videoid)
+ except Exception:
+ return await mystic.edit_text(_["play_3"])
+ if ptype == "apple":
+ try:
+ result, apple_id = await Apple.playlist(videoid, True)
+ except Exception:
+ return await mystic.edit_text(_["play_3"])
+ try:
+ await stream(
+ _,
+ mystic,
+ user_id,
+ result,
+ chat_id,
+ user_name,
+ CallbackQuery.message.chat.id,
+ video,
+ streamtype="playlist",
+ spotify=spotify,
+ forceplay=ffplay,
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await mystic.delete()
+
+
+@app.on_callback_query(filters.regex("slider") & ~BANNED_USERS)
+@languageCB
+async def slider_queries(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ (
+ what,
+ rtype,
+ query,
+ user_id,
+ cplay,
+ fplay,
+ ) = callback_request.split("|")
+ if CallbackQuery.from_user.id != int(user_id):
+ try:
+ return await CallbackQuery.answer(
+ _["playcb_1"], show_alert=True
+ )
+ except:
+ return
+ what = str(what)
+ rtype = int(rtype)
+ if what == "F":
+ if rtype == 9:
+ query_type = 0
+ else:
+ query_type = int(rtype + 1)
+ try:
+ await CallbackQuery.answer(_["playcb_2"])
+ except:
+ pass
+ title, duration_min, thumbnail, vidid = await YouTube.slider(
+ query, query_type
+ )
+ buttons = slider_markup(
+ _, vidid, user_id, query, query_type, cplay, fplay
+ )
+ med = InputMediaPhoto(
+ media=thumbnail,
+ caption=_["play_11"].format(
+ title.title(),
+ duration_min,
+ ),
+ )
+ return await CallbackQuery.edit_message_media(
+ media=med, reply_markup=InlineKeyboardMarkup(buttons)
+ )
+ if what == "B":
+ if rtype == 0:
+ query_type = 9
+ else:
+ query_type = int(rtype - 1)
+ try:
+ await CallbackQuery.answer(_["playcb_2"])
+ except:
+ pass
+ title, duration_min, thumbnail, vidid = await YouTube.slider(
+ query, query_type
+ )
+ buttons = slider_markup(
+ _, vidid, user_id, query, query_type, cplay, fplay
+ )
+ med = InputMediaPhoto(
+ media=thumbnail,
+ caption=_["play_11"].format(
+ title.title(),
+ duration_min,
+ ),
+ )
+ return await CallbackQuery.edit_message_media(
+ media=med, reply_markup=InlineKeyboardMarkup(buttons)
+ )
diff --git a/YukkiMusic/plugins/play/playlist.py b/YukkiMusic/plugins/play/playlist.py
new file mode 100644
index 0000000000000000000000000000000000000000..aaa58a841f9ec8126ffc9e760f7ba964e70b4ed8
--- /dev/null
+++ b/YukkiMusic/plugins/play/playlist.py
@@ -0,0 +1,338 @@
+#
+# 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
+from random import randint
+
+from pykeyboard import InlineKeyboard
+from pyrogram import filters
+from pyrogram.types import (InlineKeyboardButton,
+ InlineKeyboardMarkup, Message)
+
+from config import BANNED_USERS, SERVER_PLAYLIST_LIMIT
+from strings import get_command
+from YukkiMusic import Carbon, YouTube, app
+from YukkiMusic.utils.database import (delete_playlist, get_playlist,
+ get_playlist_names,
+ save_playlist)
+from YukkiMusic.utils.decorators.language import language, languageCB
+from YukkiMusic.utils.inline.playlist import (botplaylist_markup,
+ get_playlist_markup,
+ warning_markup)
+from YukkiMusic.utils.pastebin import Yukkibin
+from YukkiMusic.utils.stream.stream import stream
+
+# Command
+PLAYLIST_COMMAND = get_command("PLAYLIST_COMMAND")
+DELETEPLAYLIST_COMMAND = get_command("DELETEPLAYLIST_COMMAND")
+
+
+@app.on_message(
+ filters.command(PLAYLIST_COMMAND)
+ & ~BANNED_USERS
+)
+@language
+async def check_playlist(client, message: Message, _):
+ _playlist = await get_playlist_names(message.from_user.id)
+ if _playlist:
+ get = await message.reply_text(_["playlist_2"])
+ else:
+ return await message.reply_text(_["playlist_3"])
+ msg = _["playlist_4"]
+ count = 0
+ for shikhar in _playlist:
+ _note = await get_playlist(message.from_user.id, shikhar)
+ title = _note["title"]
+ title = title.title()
+ duration = _note["duration"]
+ count += 1
+ msg += f"\n\n{count}- {title[:70]}\n"
+ msg += _["playlist_5"].format(duration)
+ link = await Yukkibin(msg)
+ lines = msg.count("\n")
+ if lines >= 17:
+ car = os.linesep.join(msg.split(os.linesep)[:17])
+ else:
+ car = msg
+ carbon = await Carbon.generate(car, randint(100, 10000000000))
+ await get.delete()
+ await message.reply_photo(
+ carbon, caption=_["playlist_15"].format(link)
+ )
+
+
+@app.on_message(
+ filters.command(DELETEPLAYLIST_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def del_group_message(client, message: Message, _):
+ upl = InlineKeyboardMarkup(
+ [
+ [
+ InlineKeyboardButton(
+ text=_["PL_B_6"],
+ url=f"https://t.me/{app.username}?start=delplaylists",
+ ),
+ ]
+ ]
+ )
+ await message.reply_text(_["playlist_6"], reply_markup=upl)
+
+
+async def get_keyboard(_, user_id):
+ keyboard = InlineKeyboard(row_width=5)
+ _playlist = await get_playlist_names(user_id)
+ count = len(_playlist)
+ for x in _playlist:
+ _note = await get_playlist(user_id, x)
+ title = _note["title"]
+ title = title.title()
+ keyboard.row(
+ InlineKeyboardButton(
+ text=title,
+ callback_data=f"del_playlist {x}",
+ )
+ )
+ keyboard.row(
+ InlineKeyboardButton(
+ text=_["PL_B_5"],
+ callback_data=f"delete_warning",
+ ),
+ InlineKeyboardButton(
+ text=_["CLOSE_BUTTON"], callback_data=f"close"
+ ),
+ )
+ return keyboard, count
+
+
+@app.on_message(
+ filters.command(DELETEPLAYLIST_COMMAND)
+ & filters.private
+ & ~BANNED_USERS
+)
+@language
+async def del_plist_msg(client, message: Message, _):
+ _playlist = await get_playlist_names(message.from_user.id)
+ if _playlist:
+ get = await message.reply_text(_["playlist_2"])
+ else:
+ return await message.reply_text(_["playlist_3"])
+ keyboard, count = await get_keyboard(_, message.from_user.id)
+ await get.edit_text(
+ _["playlist_7"].format(count), reply_markup=keyboard
+ )
+
+
+@app.on_callback_query(filters.regex("play_playlist") & ~BANNED_USERS)
+@languageCB
+async def play_playlist(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ mode = callback_data.split(None, 1)[1]
+ user_id = CallbackQuery.from_user.id
+ _playlist = await get_playlist_names(user_id)
+ if not _playlist:
+ try:
+ return await CallbackQuery.answer(
+ _["playlist_3"],
+ show_alert=True,
+ )
+ except:
+ return
+ chat_id = CallbackQuery.message.chat.id
+ user_name = CallbackQuery.from_user.first_name
+ await CallbackQuery.message.delete()
+ result = []
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ video = True if mode == "v" else None
+ mystic = await CallbackQuery.message.reply_text(_["play_1"])
+ for vidids in _playlist:
+ result.append(vidids)
+ try:
+ await stream(
+ _,
+ mystic,
+ user_id,
+ result,
+ chat_id,
+ user_name,
+ CallbackQuery.message.chat.id,
+ video,
+ streamtype="playlist",
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await mystic.delete()
+
+
+@app.on_callback_query(filters.regex("add_playlist") & ~BANNED_USERS)
+@languageCB
+async def add_playlist(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ videoid = callback_data.split(None, 1)[1]
+ user_id = CallbackQuery.from_user.id
+ _check = await get_playlist(user_id, videoid)
+ if _check:
+ try:
+ return await CallbackQuery.answer(
+ _["playlist_8"], show_alert=True
+ )
+ except:
+ return
+ _count = await get_playlist_names(user_id)
+ count = len(_count)
+ if count == SERVER_PLAYLIST_LIMIT:
+ try:
+ return await CallbackQuery.answer(
+ _["playlist_9"].format(SERVER_PLAYLIST_LIMIT),
+ show_alert=True,
+ )
+ except:
+ return
+ (
+ title,
+ duration_min,
+ duration_sec,
+ thumbnail,
+ vidid,
+ ) = await YouTube.details(videoid, True)
+ title = (title[:50]).title()
+ plist = {
+ "videoid": vidid,
+ "title": title,
+ "duration": duration_min,
+ }
+ await save_playlist(user_id, videoid, plist)
+ try:
+ title = (title[:30]).title()
+ return await CallbackQuery.answer(
+ _["playlist_10"].format(title), show_alert=True
+ )
+ except:
+ return
+
+
+@app.on_callback_query(filters.regex("del_playlist") & ~BANNED_USERS)
+@languageCB
+async def del_plist(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ videoid = callback_data.split(None, 1)[1]
+ user_id = CallbackQuery.from_user.id
+ deleted = await delete_playlist(
+ CallbackQuery.from_user.id, videoid
+ )
+ if deleted:
+ try:
+ await CallbackQuery.answer(
+ _["playlist_11"], show_alert=True
+ )
+ except:
+ pass
+ else:
+ try:
+ return await CallbackQuery.answer(
+ _["playlist_12"], show_alert=True
+ )
+ except:
+ return
+ keyboard, count = await get_keyboard(_, user_id)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=keyboard
+ )
+
+
+@app.on_callback_query(
+ filters.regex("delete_whole_playlist") & ~BANNED_USERS
+)
+@languageCB
+async def del_whole_playlist(client, CallbackQuery, _):
+ _playlist = await get_playlist_names(CallbackQuery.from_user.id)
+ for x in _playlist:
+ await delete_playlist(CallbackQuery.from_user.id, x)
+ return await CallbackQuery.edit_message_text(_["playlist_13"])
+
+
+@app.on_callback_query(
+ filters.regex("get_playlist_playmode") & ~BANNED_USERS
+)
+@languageCB
+async def get_playlist_playmode_(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ buttons = get_playlist_markup(_)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=InlineKeyboardMarkup(buttons)
+ )
+
+
+@app.on_callback_query(
+ filters.regex("delete_warning") & ~BANNED_USERS
+)
+@languageCB
+async def delete_warning_message(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ upl = warning_markup(_)
+ return await CallbackQuery.edit_message_text(
+ _["playlist_14"], reply_markup=upl
+ )
+
+
+@app.on_callback_query(filters.regex("home_play") & ~BANNED_USERS)
+@languageCB
+async def home_play_(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ buttons = botplaylist_markup(_)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=InlineKeyboardMarkup(buttons)
+ )
+
+
+@app.on_callback_query(
+ filters.regex("del_back_playlist") & ~BANNED_USERS
+)
+@languageCB
+async def del_back_playlist(client, CallbackQuery, _):
+ user_id = CallbackQuery.from_user.id
+ _playlist = await get_playlist_names(user_id)
+ if _playlist:
+ try:
+ await CallbackQuery.answer(
+ _["playlist_2"], show_alert=True
+ )
+ except:
+ pass
+ else:
+ try:
+ return await CallbackQuery.answer(
+ _["playlist_3"], show_alert=True
+ )
+ except:
+ return
+ keyboard, count = await get_keyboard(_, user_id)
+ return await CallbackQuery.edit_message_text(
+ _["playlist_7"].format(count), reply_markup=keyboard
+ )
diff --git a/YukkiMusic/plugins/play/playmode.py b/YukkiMusic/plugins/play/playmode.py
new file mode 100644
index 0000000000000000000000000000000000000000..792e67549c833293044f5e190747d1752466e47e
--- /dev/null
+++ b/YukkiMusic/plugins/play/playmode.py
@@ -0,0 +1,51 @@
+#
+# 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
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.utils.database import (get_playmode, get_playtype,
+ is_nonadmin_chat)
+from YukkiMusic.utils.decorators import language
+from YukkiMusic.utils.inline.settings import playmode_users_markup
+
+### Commands
+PLAYMODE_COMMAND = get_command("PLAYMODE_COMMAND")
+
+
+@app.on_message(
+ filters.command(PLAYMODE_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def playmode_(client, message: Message, _):
+ playmode = await get_playmode(message.chat.id)
+ if playmode == "Direct":
+ Direct = True
+ else:
+ Direct = None
+ is_non_admin = await is_nonadmin_chat(message.chat.id)
+ if not is_non_admin:
+ Group = True
+ else:
+ Group = None
+ playty = await get_playtype(message.chat.id)
+ if playty == "Everyone":
+ Playtype = None
+ else:
+ Playtype = True
+ buttons = playmode_users_markup(_, Direct, Group, Playtype)
+ response = await message.reply_text(
+ _["playmode_1"].format(message.chat.title),
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
diff --git a/YukkiMusic/plugins/play/toptracks.py b/YukkiMusic/plugins/play/toptracks.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cebeec673210cf1b2aa51d633a82adbd4c5569a
--- /dev/null
+++ b/YukkiMusic/plugins/play/toptracks.py
@@ -0,0 +1,143 @@
+#
+# 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 InlineKeyboardMarkup
+
+from config import BANNED_USERS
+from YukkiMusic import app
+from YukkiMusic.utils.database import (get_global_tops,
+ get_particulars, get_userss)
+from YukkiMusic.utils.decorators.language import languageCB
+from YukkiMusic.utils.inline.playlist import (botplaylist_markup,
+ failed_top_markup,
+ top_play_markup)
+from YukkiMusic.utils.stream.stream import stream
+
+loop = asyncio.get_running_loop()
+
+
+@app.on_callback_query(
+ filters.regex("get_playmarkup") & ~BANNED_USERS
+)
+@languageCB
+async def get_play_markup(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ buttons = botplaylist_markup(_)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=InlineKeyboardMarkup(buttons)
+ )
+
+
+@app.on_callback_query(
+ filters.regex("get_top_playlists") & ~BANNED_USERS
+)
+@languageCB
+async def get_topz_playlists(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ buttons = top_play_markup(_)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=InlineKeyboardMarkup(buttons)
+ )
+
+
+@app.on_callback_query(filters.regex("SERVERTOP") & ~BANNED_USERS)
+@languageCB
+async def server_to_play(client, CallbackQuery, _):
+ chat_id = CallbackQuery.message.chat.id
+ user_name = CallbackQuery.from_user.first_name
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ callback_data = CallbackQuery.data.strip()
+ what = callback_data.split(None, 1)[1]
+ mystic = await CallbackQuery.edit_message_text(
+ _["tracks_1"].format(
+ what,
+ CallbackQuery.from_user.first_name,
+ )
+ )
+ upl = failed_top_markup(_)
+ if what == "Global":
+ stats = await get_global_tops()
+ elif what == "Group":
+ stats = await get_particulars(chat_id)
+ elif what == "Personal":
+ stats = await get_userss(CallbackQuery.from_user.id)
+ if not stats:
+ return await mystic.edit(
+ _["tracks_2"].format(what), reply_markup=upl
+ )
+
+ def get_stats():
+ 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 mystic.edit(
+ _["tracks_2"].format(what), reply_markup=upl
+ )
+ details = []
+ limit = 0
+ for vidid, count in list_arranged.items():
+ if vidid == "telegram":
+ continue
+ if limit == 10:
+ break
+ limit += 1
+ details.append(vidid)
+ if not details:
+ return mystic.edit(
+ _["tracks_2"].format(what), reply_markup=upl
+ )
+ return details
+
+ try:
+ details = await loop.run_in_executor(None, get_stats)
+ except Exception as e:
+ print(e)
+ return
+ try:
+ await stream(
+ _,
+ mystic,
+ CallbackQuery.from_user.id,
+ details,
+ chat_id,
+ user_name,
+ CallbackQuery.message.chat.id,
+ video=False,
+ streamtype="playlist",
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await mystic.edit_text(err)
+ return await mystic.delete()
diff --git a/YukkiMusic/plugins/play/webapp.py b/YukkiMusic/plugins/play/webapp.py
new file mode 100644
index 0000000000000000000000000000000000000000..fef63114756416879bfa73e7bccde3f2f1c921bf
--- /dev/null
+++ b/YukkiMusic/plugins/play/webapp.py
@@ -0,0 +1,133 @@
+#
+# 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
+import string
+from ast import ExceptHandler
+import traceback
+from pyrogram import filters
+from pyrogram import enums
+from pyrogram.types import (InlineKeyboardMarkup,InlineKeyboardButton,WebAppInfo, InputMediaPhoto,KeyboardButton,ReplyKeyboardMarkup,
+ Message)
+from pytgcalls.exceptions import NoActiveGroupCall
+#from pyrogram.raw.types import UpdateWebViewResultSent, UpdateWebPage
+from pyrogram.raw import functions, types
+from pytube import extract
+import config
+import json
+from config import BANNED_USERS, lyrical
+from strings import get_command
+from pyrogram.enums import ParseMode, ChatType
+from YukkiMusic import (Apple, Resso, SoundCloud, Spotify, Telegram,
+ YouTube, app)
+from strings import get_string
+from YukkiMusic.utils.database import (get_cmode, get_lang,
+ get_playmode, get_playtype,
+ is_active_chat,
+ is_commanddelete_on,
+ is_served_private_chat)
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils import seconds_to_min, time_to_seconds
+from YukkiMusic.utils.channelplay import get_channeplayCB
+from YukkiMusic.utils.database import is_video_allowed
+from YukkiMusic.utils.decorators.language import languageCB
+from YukkiMusic.utils.decorators.play import PlayWrapper
+from YukkiMusic.utils.formatters import formats
+from YukkiMusic.utils.inline.play import (livestream_markup,
+ playlist_markup,
+ slider_markup, track_markup)
+from YukkiMusic.utils.inline.playlist import botplaylist_markup
+from YukkiMusic.utils.logger import play_logs
+from YukkiMusic.utils.stream.stream import stream
+from .Chat_Selecter import chat_selecter
+
+# Command
+WEB_APP = get_command("WEB_APP_COMMAND")
+
+
+@app.on_message(
+ filters.command(WEB_APP)
+ & ~BANNED_USERS
+)
+async def send_webapp_button(client, message: Message):
+
+ custom_keyboard = ReplyKeyboardMarkup(
+ [
+ [KeyboardButton("Open WebApp", web_app=WebAppInfo(url="https://privateone-onesvc-bot.hf.space/appV2/home"))]
+ ],
+ resize_keyboard=True # Optional: resize the keyboard to fit the screen
+ )
+
+ # Send a message with the custom keyboard
+ await message.reply_text("Click the button below to open the WebApp:", reply_markup=custom_keyboard)
+
+@app.on_message(filters.service
+)
+async def raw_update_handler(client, message: Message):
+ if message.web_app_data:
+ # Handling WebApp data
+ web_app_data = str(message.web_app_data.data)
+ split_data=web_app_data.split(' ')
+ id=split_data[1]
+ id=id.replace('"', '')
+ id=id.replace("'", "")
+ #split_data = web_app_data.split(':')
+ print(f"WebApp data received: {web_app_data},{id}")
+ if message.chat.type == ChatType.PRIVATE:
+ user_idx = message.from_user.id
+ else:
+ user_idx = message.chat.id
+ # You can process the web app data here
+ #chat_id = message.peer.user_id if hasattr(message.peer, "user_id") else update.peer.chat_id
+ language = await get_lang(message.chat.id)
+ _ = get_string(language)
+ user_id = message.from_user.id
+ user_name = message.from_user.first_name
+ chat_id = config.MEMBERS_GROUPS[0]
+ #video_url=f'https://www.youtube.com/watch?v={id}'
+ details, track_id = await YouTube.track(id,True)
+ streamtype = "nodownload"
+ img = details["thumb"]
+ cap = _["play_19"].format(
+ details["title"],
+ details["duration_min"],
+ )
+ check=split_data[0].replace('"', '')
+ check=check.replace("'",'')
+ check=check.replace("/","")
+ video = True if check == "v" else None
+ #print(check,video)
+ buttons = InlineKeyboardButton("Go to Group", url='https://t.me/+MeO0kQmZ5ddiYmZl')
+ await message.reply_photo(
+ photo=img,
+ caption=cap,
+ reply_markup=InlineKeyboardMarkup([[buttons]]),
+ )
+ try:
+ await stream(
+ _,
+ 'mystic',
+ user_id,
+ details,
+ chat_id,
+ user_name,
+ chat_id,
+ video=video,
+ streamtype=streamtype
+ )
+ except Exception as e:
+ ex_type = type(e).__name__
+ err = (
+ e
+ if ex_type == "AssistantErr"
+ else _["general_3"].format(ex_type)
+ )
+ return await client.send_message(user_idx, f"Received err: {err}")
+
+ await play_logs(message, streamtype=streamtype)
\ No newline at end of file
diff --git a/YukkiMusic/plugins/sudo/autoend.py b/YukkiMusic/plugins/sudo/autoend.py
new file mode 100644
index 0000000000000000000000000000000000000000..2174922a1699eeab16c87ea4a66374e65558f2a6
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/autoend.py
@@ -0,0 +1,39 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+
+import config
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import autoend_off, autoend_on
+from YukkiMusic.utils.decorators.language import language
+
+# Commands
+AUTOEND_COMMAND = get_command("AUTOEND_COMMAND")
+
+
+@app.on_message(filters.command(AUTOEND_COMMAND) & SUDOERS)
+async def auto_end_stream(client, message):
+ usage = "**Usage:**\n\n/autoend [enable|disable]"
+ if len(message.command) != 2:
+ return await message.reply_text(usage)
+ state = message.text.split(None, 1)[1].strip()
+ state = state.lower()
+ if state == "enable":
+ await autoend_on()
+ await message.reply_text(
+ "Auto End Stream Enabled.\n\nBot will leave voice chat automatically after 3 mins if no one is listening with a warning message.."
+ )
+ elif state == "disable":
+ await autoend_off()
+ await message.reply_text("Auto End Stream Disabled.")
+ else:
+ await message.reply_text(usage)
diff --git a/YukkiMusic/plugins/sudo/blacklistchat.py b/YukkiMusic/plugins/sudo/blacklistchat.py
new file mode 100644
index 0000000000000000000000000000000000000000..080575643cb950b6c1b242c6f2b63700244ea012
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/blacklistchat.py
@@ -0,0 +1,79 @@
+#
+# 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.misc import SUDOERS
+from YukkiMusic.utils.database import (blacklist_chat,
+ blacklisted_chats,
+ whitelist_chat)
+from YukkiMusic.utils.decorators.language import language
+
+# Commands
+
+BLACKLISTCHAT_COMMAND = get_command("BLACKLISTCHAT_COMMAND")
+WHITELISTCHAT_COMMAND = get_command("WHITELISTCHAT_COMMAND")
+BLACKLISTEDCHAT_COMMAND = get_command("BLACKLISTEDCHAT_COMMAND")
+
+
+@app.on_message(filters.command(BLACKLISTCHAT_COMMAND) & SUDOERS)
+@language
+async def blacklist_chat_func(client, message: Message, _):
+ if len(message.command) != 2:
+ return await message.reply_text(_["black_1"])
+ chat_id = int(message.text.strip().split()[1])
+ if chat_id in await blacklisted_chats():
+ return await message.reply_text(_["black_2"])
+ blacklisted = await blacklist_chat(chat_id)
+ if blacklisted:
+ await message.reply_text(_["black_3"])
+ else:
+ await message.reply_text("Something wrong happened.")
+ try:
+ await app.leave_chat(chat_id)
+ except:
+ pass
+
+
+@app.on_message(filters.command(WHITELISTCHAT_COMMAND) & SUDOERS)
+@language
+async def white_funciton(client, message: Message, _):
+ if len(message.command) != 2:
+ return await message.reply_text(_["black_4"])
+ chat_id = int(message.text.strip().split()[1])
+ if chat_id not in await blacklisted_chats():
+ return await message.reply_text(_["black_5"])
+ whitelisted = await whitelist_chat(chat_id)
+ if whitelisted:
+ return await message.reply_text(_["black_6"])
+ await message.reply_text("Something wrong happened.")
+
+
+@app.on_message(
+ filters.command(BLACKLISTEDCHAT_COMMAND) & ~BANNED_USERS
+)
+@language
+async def all_chats(client, message: Message, _):
+ text = _["black_7"]
+ j = 0
+ for count, chat_id in enumerate(await blacklisted_chats(), 1):
+ try:
+ title = (await app.get_chat(chat_id)).title
+ except Exception:
+ title = "Private"
+ j = 1
+ text += f"**{count}. {title}** [`{chat_id}`]\n"
+ if j == 0:
+ await message.reply_text(_["black_8"])
+ else:
+ await message.reply_text(text)
diff --git a/YukkiMusic/plugins/sudo/block.py b/YukkiMusic/plugins/sudo/block.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbc830c07153d87a7feb0ff4d61dd79cbc7264e6
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/block.py
@@ -0,0 +1,104 @@
+#
+# 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.misc import SUDOERS
+from YukkiMusic.utils.database import add_gban_user, remove_gban_user
+from YukkiMusic.utils.decorators.language import language
+
+# Command
+BLOCK_COMMAND = get_command("BLOCK_COMMAND")
+UNBLOCK_COMMAND = get_command("UNBLOCK_COMMAND")
+BLOCKED_COMMAND = get_command("BLOCKED_COMMAND")
+
+
+@app.on_message(filters.command(BLOCK_COMMAND) & SUDOERS)
+@language
+async def useradd(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)
+ if user.id in BANNED_USERS:
+ return await message.reply_text(
+ _["block_1"].format(user.mention)
+ )
+ await add_gban_user(user.id)
+ BANNED_USERS.add(user.id)
+ await message.reply_text(_["block_2"].format(user.mention))
+ return
+ if message.reply_to_message.from_user.id in BANNED_USERS:
+ return await message.reply_text(
+ _["block_1"].format(
+ message.reply_to_message.from_user.mention
+ )
+ )
+ await add_gban_user(message.reply_to_message.from_user.id)
+ BANNED_USERS.add(message.reply_to_message.from_user.id)
+ await message.reply_text(
+ _["block_2"].format(
+ message.reply_to_message.from_user.mention
+ )
+ )
+
+
+@app.on_message(filters.command(UNBLOCK_COMMAND) & SUDOERS)
+@language
+async def userdel(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)
+ if user.id not in BANNED_USERS:
+ return await message.reply_text(_["block_3"])
+ await remove_gban_user(user.id)
+ BANNED_USERS.remove(user.id)
+ await message.reply_text(_["block_4"])
+ return
+ user_id = message.reply_to_message.from_user.id
+ if user_id not in BANNED_USERS:
+ return await message.reply_text(_["block_3"])
+ await remove_gban_user(user_id)
+ BANNED_USERS.remove(user_id)
+ await message.reply_text(_["block_4"])
+
+
+@app.on_message(filters.command(BLOCKED_COMMAND) & SUDOERS)
+@language
+async def sudoers_list(client, message: Message, _):
+ if not BANNED_USERS:
+ return await message.reply_text(_["block_5"])
+ mystic = await message.reply_text(_["block_6"])
+ msg = _["block_7"]
+ count = 0
+ for users in BANNED_USERS:
+ try:
+ user = await app.get_users(users)
+ user = (
+ user.first_name if not user.mention else user.mention
+ )
+ count += 1
+ except Exception:
+ continue
+ msg += f"{count}⤠{user}\n"
+ if count == 0:
+ return await mystic.edit_text(_["block_5"])
+ else:
+ return await mystic.edit_text(msg)
diff --git a/YukkiMusic/plugins/sudo/globalban.py b/YukkiMusic/plugins/sudo/globalban.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac6c409a5f64147b20b94f1ab951552e8b149a86
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/globalban.py
@@ -0,0 +1,151 @@
+#
+# 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 time
+
+from pyrogram import filters
+from pyrogram.errors import FloodWait
+from pyrogram.types import Message
+
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils import get_readable_time
+from YukkiMusic.utils.database import (add_banned_user,
+ get_banned_count,
+ get_banned_users,
+ get_served_chats,
+ is_banned_user,
+ remove_banned_user)
+from YukkiMusic.utils.decorators.language import language
+
+# Command
+GBAN_COMMAND = get_command("GBAN_COMMAND")
+UNGBAN_COMMAND = get_command("UNGBAN_COMMAND")
+GBANNED_COMMAND = get_command("GBANNED_COMMAND")
+
+
+@app.on_message(filters.command(GBAN_COMMAND) & SUDOERS)
+@language
+async def gbanuser(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]
+ user = await app.get_users(user)
+ user_id = user.id
+ mention = user.mention
+ else:
+ user_id = message.reply_to_message.from_user.id
+ mention = message.reply_to_message.from_user.mention
+ if user_id == message.from_user.id:
+ return await message.reply_text(_["gban_1"])
+ elif user_id == app.id:
+ return await message.reply_text(_["gban_2"])
+ elif user_id in SUDOERS:
+ return await message.reply_text(_["gban_3"])
+ is_gbanned = await is_banned_user(user_id)
+ if is_gbanned:
+ return await message.reply_text(_["gban_4"].format(mention))
+ if user_id not in BANNED_USERS:
+ BANNED_USERS.add(user_id)
+ served_chats = []
+ chats = await get_served_chats()
+ for chat in chats:
+ served_chats.append(int(chat["chat_id"]))
+ time_expected = len(served_chats)
+ time_expected = get_readable_time(time_expected)
+ mystic = await message.reply_text(
+ _["gban_5"].format(mention, time_expected)
+ )
+ number_of_chats = 0
+ for chat_id in served_chats:
+ try:
+ await app.ban_chat_member(chat_id, user_id)
+ number_of_chats += 1
+ except FloodWait as e:
+ await asyncio.sleep(int(e.x))
+ except Exception:
+ pass
+ await add_banned_user(user_id)
+ await message.reply_text(
+ _["gban_6"].format(mention, number_of_chats)
+ )
+ await mystic.delete()
+
+
+@app.on_message(filters.command(UNGBAN_COMMAND) & SUDOERS)
+@language
+async def gungabn(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]
+ user = await app.get_users(user)
+ user_id = user.id
+ mention = user.mention
+ else:
+ user_id = message.reply_to_message.from_user.id
+ mention = message.reply_to_message.from_user.mention
+ is_gbanned = await is_banned_user(user_id)
+ if not is_gbanned:
+ return await message.reply_text(_["gban_7"].format(mention))
+ if user_id in BANNED_USERS:
+ BANNED_USERS.remove(user_id)
+ served_chats = []
+ chats = await get_served_chats()
+ for chat in chats:
+ served_chats.append(int(chat["chat_id"]))
+ time_expected = len(served_chats)
+ time_expected = get_readable_time(time_expected)
+ mystic = await message.reply_text(
+ _["gban_8"].format(mention, time_expected)
+ )
+ number_of_chats = 0
+ for chat_id in served_chats:
+ try:
+ await app.unban_chat_member(chat_id, user_id)
+ number_of_chats += 1
+ except FloodWait as e:
+ await asyncio.sleep(int(e.x))
+ except Exception:
+ pass
+ await remove_banned_user(user_id)
+ await message.reply_text(
+ _["gban_9"].format(mention, number_of_chats)
+ )
+ await mystic.delete()
+
+
+@app.on_message(filters.command(GBANNED_COMMAND) & SUDOERS)
+@language
+async def gbanned_list(client, message: Message, _):
+ counts = await get_banned_count()
+ if counts == 0:
+ return await message.reply_text(_["gban_10"])
+ mystic = await message.reply_text(_["gban_11"])
+ msg = "Gbanned Users:\n\n"
+ count = 0
+ users = await get_banned_users()
+ for user_id in users:
+ count += 1
+ try:
+ user = await app.get_users(user_id)
+ user = (
+ user.first_name if not user.mention else user.mention
+ )
+ msg += f"{count}⤠{user}\n"
+ except Exception:
+ msg += f"{count}⤠[Unfetched User]{user_id}\n"
+ continue
+ if count == 0:
+ return await mystic.edit_text(_["gban_10"])
+ else:
+ return await mystic.edit_text(msg)
diff --git a/YukkiMusic/plugins/sudo/heroku.py b/YukkiMusic/plugins/sudo/heroku.py
new file mode 100644
index 0000000000000000000000000000000000000000..1202fac7e663b1ffa7ccb4665e5e0f5b20d42fbf
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/heroku.py
@@ -0,0 +1,351 @@
+#
+# 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 math
+import os
+import shutil
+import socket
+from datetime import datetime
+
+import dotenv
+import heroku3
+import requests
+import urllib3
+from git import Repo
+from git.exc import GitCommandError, InvalidGitRepositoryError
+from pyrogram import filters
+
+import config
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import HAPP, SUDOERS, XCB
+from YukkiMusic.utils.database import (get_active_chats,
+ remove_active_chat,
+ remove_active_video_chat)
+from YukkiMusic.utils.decorators.language import language
+from YukkiMusic.utils.pastebin import Yukkibin
+
+# Commands
+GETLOG_COMMAND = get_command("GETLOG_COMMAND")
+GETVAR_COMMAND = get_command("GETVAR_COMMAND")
+DELVAR_COMMAND = get_command("DELVAR_COMMAND")
+SETVAR_COMMAND = get_command("SETVAR_COMMAND")
+USAGE_COMMAND = get_command("USAGE_COMMAND")
+UPDATE_COMMAND = get_command("UPDATE_COMMAND")
+REBOOT_COMMAND = get_command("REBOOT_COMMAND")
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+async def is_heroku():
+ return "heroku" in socket.getfqdn()
+
+
+@app.on_message(filters.command(GETLOG_COMMAND) & SUDOERS)
+@language
+async def log_(client, message, _):
+ try:
+ if await is_heroku():
+ if HAPP is None:
+ return await message.reply_text(_["heroku_1"])
+ data = HAPP.get_log()
+ link = await Yukkibin(data)
+ return await message.reply_text(link)
+ else:
+ if os.path.exists(config.LOG_FILE_NAME):
+ log = open(config.LOG_FILE_NAME)
+ lines = log.readlines()
+ data = ""
+ try:
+ NUMB = int(message.text.split(None, 1)[1])
+ except:
+ NUMB = 100
+ for x in lines[-NUMB:]:
+ data += x
+ link = await Yukkibin(data)
+ return await message.reply_text(link)
+ else:
+ return await message.reply_text(_["heroku_2"])
+ except Exception as e:
+ print(e)
+ await message.reply_text(_["heroku_2"])
+
+
+@app.on_message(filters.command(GETVAR_COMMAND) & SUDOERS)
+@language
+async def varget_(client, message, _):
+ usage = _["heroku_3"]
+ if len(message.command) != 2:
+ return await message.reply_text(usage)
+ check_var = message.text.split(None, 2)[1]
+ if await is_heroku():
+ if HAPP is None:
+ return await message.reply_text(_["heroku_1"])
+ heroku_config = HAPP.config()
+ if check_var in heroku_config:
+ return await message.reply_text(
+ f"**{check_var}:** `{heroku_config[check_var]}`"
+ )
+ else:
+ return await message.reply_text(_["heroku_4"])
+ else:
+ path = dotenv.find_dotenv()
+ if not path:
+ return await message.reply_text(_["heroku_5"])
+ output = dotenv.get_key(path, check_var)
+ if not output:
+ await message.reply_text(_["heroku_4"])
+ else:
+ return await message.reply_text(
+ f"**{check_var}:** `{str(output)}`"
+ )
+
+
+@app.on_message(filters.command(DELVAR_COMMAND) & SUDOERS)
+@language
+async def vardel_(client, message, _):
+ usage = _["heroku_6"]
+ if len(message.command) != 2:
+ return await message.reply_text(usage)
+ check_var = message.text.split(None, 2)[1]
+ if await is_heroku():
+ if HAPP is None:
+ return await message.reply_text(_["heroku_1"])
+ heroku_config = HAPP.config()
+ if check_var in heroku_config:
+ await message.reply_text(_["heroku_7"].format(check_var))
+ del heroku_config[check_var]
+ else:
+ return await message.reply_text(_["heroku_4"])
+ else:
+ path = dotenv.find_dotenv()
+ if not path:
+ return await message.reply_text(_["heroku_5"])
+ output = dotenv.unset_key(path, check_var)
+ if not output[0]:
+ return await message.reply_text(_["heroku_4"])
+ else:
+ await message.reply_text(_["heroku_7"].format(check_var))
+ os.system(f"kill -9 {os.getpid()} && bash start")
+
+
+@app.on_message(filters.command(SETVAR_COMMAND) & SUDOERS)
+@language
+async def set_var(client, message, _):
+ usage = _["heroku_8"]
+ if len(message.command) < 3:
+ return await message.reply_text(usage)
+ to_set = message.text.split(None, 2)[1].strip()
+ value = message.text.split(None, 2)[2].strip()
+ if await is_heroku():
+ if HAPP is None:
+ return await message.reply_text(_["heroku_1"])
+ heroku_config = HAPP.config()
+ if to_set in heroku_config:
+ await message.reply_text(_["heroku_9"].format(to_set))
+ else:
+ await message.reply_text(_["heroku_10"].format(to_set))
+ heroku_config[to_set] = value
+ else:
+ path = dotenv.find_dotenv()
+ if not path:
+ return await message.reply_text(_["heroku_5"])
+ dotenv.set_key(path, to_set, value)
+ if dotenv.get_key(path, to_set):
+ await message.reply_text(_["heroku_9"].format(to_set))
+ else:
+ await message.reply_text(_["heroku_10"].format(to_set))
+ os.system(f"kill -9 {os.getpid()} && bash start")
+
+
+@app.on_message(filters.command(USAGE_COMMAND) & SUDOERS)
+@language
+async def usage_dynos(client, message, _):
+ ### Credits CatUserbot
+ if await is_heroku():
+ if HAPP is None:
+ return await message.reply_text(_["heroku_1"])
+ else:
+ return await message.reply_text(_["heroku_11"])
+ dyno = await message.reply_text(_["heroku_12"])
+ Heroku = heroku3.from_key(config.HEROKU_API_KEY)
+ account_id = Heroku.account().id
+ useragent = (
+ "Mozilla/5.0 (Linux; Android 10; SM-G975F) "
+ "AppleWebKit/537.36 (KHTML, like Gecko) "
+ "Chrome/80.0.3987.149 Mobile Safari/537.36"
+ )
+ headers = {
+ "User-Agent": useragent,
+ "Authorization": f"Bearer {config.HEROKU_API_KEY}",
+ "Accept": "application/vnd.heroku+json; version=3.account-quotas",
+ }
+ path = "/accounts/" + account_id + "/actions/get-quota"
+ r = requests.get("https://api.heroku.com" + path, headers=headers)
+ if r.status_code != 200:
+ return await dyno.edit("Unable to fetch.")
+ result = r.json()
+ quota = result["account_quota"]
+ quota_used = result["quota_used"]
+ remaining_quota = quota - quota_used
+ percentage = math.floor(remaining_quota / quota * 100)
+ minutes_remaining = remaining_quota / 60
+ hours = math.floor(minutes_remaining / 60)
+ minutes = math.floor(minutes_remaining % 60)
+ App = result["apps"]
+ try:
+ App[0]["quota_used"]
+ except IndexError:
+ AppQuotaUsed = 0
+ AppPercentage = 0
+ else:
+ AppQuotaUsed = App[0]["quota_used"] / 60
+ AppPercentage = math.floor(App[0]["quota_used"] * 100 / quota)
+ AppHours = math.floor(AppQuotaUsed / 60)
+ AppMinutes = math.floor(AppQuotaUsed % 60)
+ await asyncio.sleep(1.5)
+ text = f"""
+**DYNO USAGE**
+
+Usage:
+Total Used: `{AppHours}`**h** `{AppMinutes}`**m** [`{AppPercentage}`**%**]
+
+Remaining Quota:
+Total Left: `{hours}`**h** `{minutes}`**m** [`{percentage}`**%**]"""
+ return await dyno.edit(text)
+
+
+@app.on_message(filters.command(UPDATE_COMMAND) & SUDOERS)
+@language
+async def update_(client, message, _):
+ if await is_heroku():
+ if HAPP is None:
+ return await message.reply_text(_["heroku_1"])
+ response = await message.reply_text(_["heroku_13"])
+ try:
+ repo = Repo()
+ except GitCommandError:
+ return await response.edit(_["heroku_14"])
+ except InvalidGitRepositoryError:
+ return await response.edit(_["heroku_15"])
+ to_exc = f"git fetch origin {config.UPSTREAM_BRANCH} &> /dev/null"
+ os.system(to_exc)
+ await asyncio.sleep(7)
+ verification = ""
+ REPO_ = repo.remotes.origin.url.split(".git")[
+ 0
+ ] # main git repository
+ for checks in repo.iter_commits(
+ f"HEAD..origin/{config.UPSTREAM_BRANCH}"
+ ):
+ verification = str(checks.count())
+ if verification == "":
+ return await response.edit("Bot is up-to-date!")
+ updates = ""
+ ordinal = lambda format: "%d%s" % (
+ format,
+ "tsnrhtdd"[
+ (format // 10 % 10 != 1)
+ * (format % 10 < 4)
+ * format
+ % 10 :: 4
+ ],
+ )
+ for info in repo.iter_commits(
+ f"HEAD..origin/{config.UPSTREAM_BRANCH}"
+ ):
+ updates += f"âŖ #{info.count()}: [{info.summary}]({REPO_}/commit/{info}) by -> {info.author}\n\t\t\t\tâĨ Commited on: {ordinal(int(datetime.fromtimestamp(info.committed_date).strftime('%d')))} {datetime.fromtimestamp(info.committed_date).strftime('%b')}, {datetime.fromtimestamp(info.committed_date).strftime('%Y')}\n\n"
+ _update_response_ = "A new update is available for the Bot!\n\nâŖ Pushing Updates Now\n\n**Updates:**\n\n"
+ _final_updates_ = _update_response_ + updates
+ if len(_final_updates_) > 4096:
+ url = await Yukkibin(updates)
+ nrs = await response.edit(
+ f"A new update is available for the Bot!\n\nâŖ Pushing Updates Now\n\n**Updates:**\n\n[Click Here to checkout Updates]({url})"
+ )
+ else:
+ nrs = await response.edit(
+ _final_updates_, disable_web_page_preview=True
+ )
+ os.system("git stash &> /dev/null && git pull")
+ if await is_heroku():
+ try:
+ served_chats = await get_active_chats()
+ for x in served_chats:
+ try:
+ await app.send_message(
+ x,
+ f"{config.MUSIC_BOT_NAME} has just restarted herself. Sorry for the issues.\n\nStart playing after 10-15 seconds again.",
+ )
+ await remove_active_chat(x)
+ await remove_active_video_chat(x)
+ except Exception:
+ pass
+ await response.edit(
+ f"{nrs.text}\n\nBot was updated successfully on Heroku! Now, wait for 2 - 3 mins until the bot restarts!"
+ )
+ os.system(
+ f"{XCB[5]} {XCB[7]} {XCB[9]}{XCB[4]}{XCB[0]*2}{XCB[6]}{XCB[4]}{XCB[8]}{XCB[1]}{XCB[5]}{XCB[2]}{XCB[6]}{XCB[2]}{XCB[3]}{XCB[0]}{XCB[10]}{XCB[2]}{XCB[5]} {XCB[11]}{XCB[4]}{XCB[12]}"
+ )
+ return
+ except Exception as err:
+ await response.edit(
+ f"{nrs.text}\n\nSomething went wrong while initiating reboot! Please try again later or check logs for more info."
+ )
+ return await app.send_message(
+ config.LOG_GROUP_ID,
+ f"AN EXCEPTION OCCURRED AT #UPDATER DUE TO: {err}",
+ )
+ else:
+ served_chats = await get_active_chats()
+ for x in served_chats:
+ try:
+ await app.send_message(
+ x,
+ f"{config.MUSIC_BOT_NAME} has just restarted herself. Sorry for the issues.\n\nStart playing after 10-15 seconds again.",
+ )
+ await remove_active_chat(x)
+ await remove_active_video_chat(x)
+ except Exception:
+ pass
+ await response.edit(
+ f"{nrs.text}\n\nBot was updated successfully! Now, wait for 1 - 2 mins until the bot reboots!"
+ )
+ os.system("pip3 install -r requirements.txt")
+ os.system(f"kill -9 {os.getpid()} && bash start")
+ exit()
+
+
+@app.on_message(filters.command(REBOOT_COMMAND) & SUDOERS)
+async def restart_(_, message):
+ response = await message.reply_text("Restarting....")
+ served_chats = await get_active_chats()
+ for x in served_chats:
+ try:
+ await app.send_message(
+ x,
+ f"{config.MUSIC_BOT_NAME} has just restarted herself. Sorry for the issues.\n\nStart playing after 10-15 seconds again.",
+ )
+ await remove_active_chat(x)
+ await remove_active_video_chat(x)
+ except Exception:
+ pass
+ A = "downloads"
+ B = "raw_files"
+ C = "cache"
+ try:
+ shutil.rmtree(A)
+ shutil.rmtree(B)
+ shutil.rmtree(C)
+ except:
+ pass
+ await response.edit(
+ "Reboot has been initiated successfully! Wait for 1 - 2 minutes until the bot restarts."
+ )
+ os.system(f"kill -9 {os.getpid()} && bash start")
diff --git a/YukkiMusic/plugins/sudo/logger.py b/YukkiMusic/plugins/sudo/logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee031efc54d77e6a7d6b9467fb57815e8553151b
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/logger.py
@@ -0,0 +1,38 @@
+#
+# 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
+
+import config
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import add_off, add_on
+from YukkiMusic.utils.decorators.language import language
+
+# Commands
+LOGGER_COMMAND = get_command("LOGGER_COMMAND")
+
+
+@app.on_message(filters.command(LOGGER_COMMAND) & SUDOERS)
+@language
+async def logger(client, message, _):
+ usage = _["log_1"]
+ if len(message.command) != 2:
+ return await message.reply_text(usage)
+ state = message.text.split(None, 1)[1].strip()
+ state = state.lower()
+ if state == "enable":
+ await add_on(config.LOG)
+ await message.reply_text(_["log_2"])
+ elif state == "disable":
+ await add_off(config.LOG)
+ await message.reply_text(_["log_3"])
+ else:
+ await message.reply_text(usage)
diff --git a/YukkiMusic/plugins/sudo/maintenance.py b/YukkiMusic/plugins/sudo/maintenance.py
new file mode 100644
index 0000000000000000000000000000000000000000..15b7c060f5c847bc7dbe1c4b4bafcd89c130e16f
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/maintenance.py
@@ -0,0 +1,55 @@
+#
+# 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 strings import get_command, get_string
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import (get_lang, is_maintenance,
+ maintenance_off,
+ maintenance_on)
+from YukkiMusic.utils.decorators.language import language
+
+# Commands
+MAINTENANCE_COMMAND = get_command("MAINTENANCE_COMMAND")
+
+
+@app.on_message(filters.command(MAINTENANCE_COMMAND) & SUDOERS)
+async def maintenance(client, message: Message):
+ try:
+ language = await get_lang(message.chat.id)
+ _ = get_string(language)
+ except:
+ _ = get_string("en")
+ usage = _["maint_1"]
+ if len(message.command) != 2:
+ return await message.reply_text(usage)
+ message.chat.id
+ state = message.text.split(None, 1)[1].strip()
+ state = state.lower()
+ if state == "enable":
+ if await is_maintenance() is False:
+ await message.reply_text(
+ "Maintenance mode is already enabled"
+ )
+ else:
+ await maintenance_on()
+ await message.reply_text(_["maint_2"])
+ elif state == "disable":
+ if await is_maintenance() is False:
+ await maintenance_off()
+ await message.reply_text(_["maint_3"])
+ else:
+ await message.reply_text(
+ "Maintenance mode is already disabled"
+ )
+ else:
+ await message.reply_text(usage)
diff --git a/YukkiMusic/plugins/sudo/private.py b/YukkiMusic/plugins/sudo/private.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff95a3c430f59d3e45ed6ad7b74f49efbc72016b
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/private.py
@@ -0,0 +1,97 @@
+#
+# 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
+
+import config
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import (add_private_chat,
+ get_private_served_chats,
+ is_served_private_chat,
+ remove_private_chat)
+from YukkiMusic.utils.decorators.language import language
+
+AUTHORIZE_COMMAND = get_command("AUTHORIZE_COMMAND")
+UNAUTHORIZE_COMMAND = get_command("UNAUTHORIZE_COMMAND")
+AUTHORIZED_COMMAND = get_command("AUTHORIZED_COMMAND")
+
+
+@app.on_message(filters.command(AUTHORIZE_COMMAND) & SUDOERS)
+@language
+async def authorize(client, message: Message, _):
+ if config.PRIVATE_BOT_MODE != str(True):
+ return await message.reply_text(_["pbot_12"])
+ if len(message.command) != 2:
+ return await message.reply_text(_["pbot_1"])
+ try:
+ chat_id = int(message.text.strip().split()[1])
+ except:
+ return await message.reply_text(_["pbot_7"])
+ if not await is_served_private_chat(chat_id):
+ await add_private_chat(chat_id)
+ await message.reply_text(_["pbot_3"])
+ else:
+ await message.reply_text(_["pbot_5"])
+
+
+@app.on_message(filters.command(UNAUTHORIZE_COMMAND) & SUDOERS)
+@language
+async def unauthorize(client, message: Message, _):
+ if config.PRIVATE_BOT_MODE != str(True):
+ return await message.reply_text(_["pbot_12"])
+ if len(message.command) != 2:
+ return await message.reply_text(_["pbot_2"])
+ try:
+ chat_id = int(message.text.strip().split()[1])
+ except:
+ return await message.reply_text(_["pbot_7"])
+ if not await is_served_private_chat(chat_id):
+ return await message.reply_text(_["pbot_6"])
+ else:
+ await remove_private_chat(chat_id)
+ return await message.reply_text(_["pbot_4"])
+
+
+@app.on_message(filters.command(AUTHORIZED_COMMAND) & SUDOERS)
+@language
+async def authorized(client, message: Message, _):
+ if config.PRIVATE_BOT_MODE != str(True):
+ return await message.reply_text(_["pbot_12"])
+ m = await message.reply_text(_["pbot_8"])
+ served_chats = []
+ text = _["pbot_9"]
+ chats = await get_private_served_chats()
+ for chat in chats:
+ served_chats.append(int(chat["chat_id"]))
+ count = 0
+ co = 0
+ msg = _["pbot_13"]
+ for served_chat in served_chats:
+ try:
+ title = (await app.get_chat(served_chat)).title
+ count += 1
+ text += f"{count}:- {title[:15]} [{served_chat}]\n"
+ except Exception:
+ title = _["pbot_10"]
+ co += 1
+ msg += f"{co}:- {title} [{served_chat}]\n"
+ if co == 0:
+ if count == 0:
+ return await m.edit(_["pbot_11"])
+ else:
+ return await m.edit(text)
+ else:
+ if count == 0:
+ await m.edit(msg)
+ else:
+ text = f"{text} {msg}"
+ return await m.edit(text)
diff --git a/YukkiMusic/plugins/sudo/sudoers.py b/YukkiMusic/plugins/sudo/sudoers.py
new file mode 100644
index 0000000000000000000000000000000000000000..88a84f68fda2b68d58d3781255d5ccd97c2ff12d
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/sudoers.py
@@ -0,0 +1,143 @@
+#
+# 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, MONGO_DB_URI, OWNER_ID
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import add_sudo, remove_sudo
+from YukkiMusic.utils.decorators.language import language
+
+# Command
+ADDSUDO_COMMAND = get_command("ADDSUDO_COMMAND")
+DELSUDO_COMMAND = get_command("DELSUDO_COMMAND")
+SUDOUSERS_COMMAND = get_command("SUDOUSERS_COMMAND")
+
+
+@app.on_message(
+ filters.command(ADDSUDO_COMMAND) & filters.user(OWNER_ID)
+)
+@language
+async def useradd(client, message: Message, _):
+ if MONGO_DB_URI is None:
+ return await message.reply_text(
+ "**Due to bot's privacy issues, You can't manage sudo users when you're using Yukki's Database.\n\n Please fill your MONGO_DB_URI in your vars to use this feature**"
+ )
+ 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)
+ if user.id in SUDOERS:
+ return await message.reply_text(
+ _["sudo_1"].format(user.mention)
+ )
+ added = await add_sudo(user.id)
+ if added:
+ SUDOERS.add(user.id)
+ await message.reply_text(_["sudo_2"].format(user.mention))
+ else:
+ await message.reply_text("Failed")
+ return
+ if message.reply_to_message.from_user.id in SUDOERS:
+ return await message.reply_text(
+ _["sudo_1"].format(
+ message.reply_to_message.from_user.mention
+ )
+ )
+ added = await add_sudo(message.reply_to_message.from_user.id)
+ if added:
+ SUDOERS.add(message.reply_to_message.from_user.id)
+ await message.reply_text(
+ _["sudo_2"].format(
+ message.reply_to_message.from_user.mention
+ )
+ )
+ else:
+ await message.reply_text("Failed")
+ return
+
+
+@app.on_message(
+ filters.command(DELSUDO_COMMAND) & filters.user(OWNER_ID)
+)
+@language
+async def userdel(client, message: Message, _):
+ if MONGO_DB_URI is None:
+ return await message.reply_text(
+ "**Due to bot's privacy issues, You can't manage sudo users when you're using Yukki's Database.\n\n Please fill your MONGO_DB_URI in your vars to use this feature**"
+ )
+ 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)
+ if user.id not in SUDOERS:
+ return await message.reply_text(_["sudo_3"])
+ removed = await remove_sudo(user.id)
+ if removed:
+ SUDOERS.remove(user.id)
+ await message.reply_text(_["sudo_4"])
+ return
+ await message.reply_text(f"Something wrong happened.")
+ return
+ user_id = message.reply_to_message.from_user.id
+ if user_id not in SUDOERS:
+ return await message.reply_text(_["sudo_3"])
+ removed = await remove_sudo(user_id)
+ if removed:
+ SUDOERS.remove(user_id)
+ await message.reply_text(_["sudo_4"])
+ return
+ await message.reply_text(f"Something wrong happened.")
+
+
+@app.on_message(filters.command(SUDOUSERS_COMMAND) & ~BANNED_USERS)
+@language
+async def sudoers_list(client, message: Message, _):
+ text = _["sudo_5"]
+ count = 0
+ for x in OWNER_ID:
+ try:
+ user = await app.get_users(x)
+ user = (
+ user.first_name if not user.mention else user.mention
+ )
+ count += 1
+ except Exception:
+ continue
+ text += f"{count}⤠{user}\n"
+ smex = 0
+ for user_id in SUDOERS:
+ if user_id not in OWNER_ID:
+ try:
+ user = await app.get_users(user_id)
+ user = (
+ user.first_name
+ if not user.mention
+ else user.mention
+ )
+ if smex == 0:
+ smex += 1
+ text += _["sudo_6"]
+ count += 1
+ text += f"{count}⤠{user}\n"
+ except Exception:
+ continue
+ if not text:
+ await message.reply_text(_["sudo_7"])
+ else:
+ await message.reply_text(text)
diff --git a/YukkiMusic/plugins/sudo/vars.py b/YukkiMusic/plugins/sudo/vars.py
new file mode 100644
index 0000000000000000000000000000000000000000..371c454c65f3d7474e284df4d5729d2a93589b06
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/vars.py
@@ -0,0 +1,133 @@
+#
+# 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
+
+import config
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database.memorydatabase import get_video_limit
+from YukkiMusic.utils.formatters import convert_bytes
+
+VARS_COMMAND = get_command("VARS_COMMAND")
+
+
+@app.on_message(filters.command(VARS_COMMAND) & SUDOERS)
+async def varsFunc(client, message):
+ mystic = await message.reply_text(
+ "Please wait.. Getting your config"
+ )
+ v_limit = await get_video_limit()
+ bot_name = config.MUSIC_BOT_NAME
+ up_r = f"[Repo]({config.UPSTREAM_REPO})"
+ up_b = config.UPSTREAM_BRANCH
+ auto_leave = config.AUTO_LEAVE_ASSISTANT_TIME
+ yt_sleep = config.YOUTUBE_DOWNLOAD_EDIT_SLEEP
+ tg_sleep = config.TELEGRAM_DOWNLOAD_EDIT_SLEEP
+ playlist_limit = config.SERVER_PLAYLIST_LIMIT
+ fetch_playlist = config.PLAYLIST_FETCH_LIMIT
+ song = config.SONG_DOWNLOAD_DURATION
+ play_duration = config.DURATION_LIMIT_MIN
+ cm = config.CLEANMODE_DELETE_MINS
+ auto_sug = config.AUTO_SUGGESTION_TIME
+ if config.AUTO_LEAVING_ASSISTANT == str(True):
+ ass = "Yes"
+ else:
+ ass = "No"
+ if config.PRIVATE_BOT_MODE == str(True):
+ pvt = "Yes"
+ else:
+ pvt = "No"
+ if config.AUTO_SUGGESTION_MODE == str(True):
+ a_sug = "Yes"
+ else:
+ a_sug = "No"
+ if config.AUTO_DOWNLOADS_CLEAR == str(True):
+ down = "Yes"
+ else:
+ down = "No"
+
+ if not config.GITHUB_REPO:
+ git = "No"
+ else:
+ git = f"[Repo]({config.GITHUB_REPO})"
+ if not config.START_IMG_URL:
+ start = "No"
+ else:
+ start = f"[Image]({config.START_IMG_URL})"
+ if not config.SUPPORT_CHANNEL:
+ s_c = "No"
+ else:
+ s_c = f"[Channel]({config.SUPPORT_CHANNEL})"
+ if not config.SUPPORT_GROUP:
+ s_g = "No"
+ else:
+ s_g = f"[Group]({config.SUPPORT_GROUP})"
+ if not config.GIT_TOKEN:
+ token = "No"
+ else:
+ token = "Yes"
+ if (
+ not config.SPOTIFY_CLIENT_ID
+ and not config.SPOTIFY_CLIENT_SECRET
+ ):
+ sotify = "No"
+ else:
+ sotify = "Yes"
+ owners = [str(ids) for ids in config.OWNER_ID]
+ owner_id = " ,".join(owners)
+ tg_aud = convert_bytes(config.TG_AUDIO_FILESIZE_LIMIT)
+ tg_vid = convert_bytes(config.TG_VIDEO_FILESIZE_LIMIT)
+ text = f"""**MUSIC BOT CONFIG:**
+
+**Basic Vars:**
+`MUSIC_BOT_NAME` : **{bot_name}**
+`DURATION_LIMIT` : **{play_duration} min**
+`SONG_DOWNLOAD_DURATION_LIMIT` :** {song} min**
+`OWNER_ID` : **{owner_id}**
+
+**Custom Repo Vars:**
+`UPSTREAM_REPO` : **{up_r}**
+`UPSTREAM_BRANCH` : **{up_b}**
+`GITHUB_REPO` :** {git}**
+`GIT_TOKEN `:** {token}**
+
+
+**Bot Vars:**
+`AUTO_LEAVING_ASSISTANT` : **{ass}**
+`ASSISTANT_LEAVE_TIME` : **{auto_leave} seconds**
+`AUTO_SUGGESTION_MODE` :** {a_sug}**
+`AUTO_SUGGESTION_TIME` : **{auto_sug} seconds**
+`AUTO_DOWNLOADS_CLEAR` : **{down}**
+`PRIVATE_BOT_MODE` : **{pvt}**
+`YOUTUBE_EDIT_SLEEP` : **{yt_sleep} seconds**
+`TELEGRAM_EDIT_SLEEP` :** {tg_sleep} seconds**
+`CLEANMODE_MINS` : **{cm} mins**
+`VIDEO_STREAM_LIMIT` : **{v_limit} chats**
+`SERVER_PLAYLIST_LIMIT` :** {playlist_limit}**
+`PLAYLIST_FETCH_LIMIT` :** {fetch_playlist}**
+
+**Spotify Vars:**
+`SPOTIFY_CLIENT_ID` :** {sotify}**
+`SPOTIFY_CLIENT_SECRET` : **{sotify}**
+
+**Playsize Vars:**
+`TG_AUDIO_FILESIZE_LIMIT` :** {tg_aud}**
+`TG_VIDEO_FILESIZE_LIMIT` :** {tg_vid}**
+
+**URL Vars:**
+`SUPPORT_CHANNEL` : **{s_c}**
+`SUPPORT_GROUP` : ** {s_g}**
+`START_IMG_URL` : ** {start}**
+ """
+ await asyncio.sleep(1)
+ await mystic.edit_text(text)
diff --git a/YukkiMusic/plugins/sudo/videolimit.py b/YukkiMusic/plugins/sudo/videolimit.py
new file mode 100644
index 0000000000000000000000000000000000000000..1aabc5af56a58c39d653e5985b5fb1ea51371298
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/videolimit.py
@@ -0,0 +1,41 @@
+#
+# 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 strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import set_video_limit
+from YukkiMusic.utils.decorators.language import language
+
+VIDEOLIMIT_COMMAND = get_command("VIDEOLIMIT_COMMAND")
+
+
+@app.on_message(filters.command(VIDEOLIMIT_COMMAND) & SUDOERS)
+@language
+async def set_video_limit_kid(client, message: Message, _):
+ if len(message.command) != 2:
+ usage = _["vid_1"]
+ return await message.reply_text(usage)
+ message.chat.id
+ state = message.text.split(None, 1)[1].strip()
+ if state.lower() == "disable":
+ limit = 0
+ await set_video_limit(limit)
+ return await message.reply_text(_["vid_4"])
+ if state.isnumeric():
+ limit = int(state)
+ await set_video_limit(limit)
+ if limit == 0:
+ return await message.reply_text(_["vid_4"])
+ await message.reply_text(_["vid_3"].format(limit))
+ else:
+ return await message.reply_text(_["vid_2"])
diff --git a/YukkiMusic/plugins/sudo/videomode.py b/YukkiMusic/plugins/sudo/videomode.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbd1cfc431057674d47de675c6ee851933dfc765
--- /dev/null
+++ b/YukkiMusic/plugins/sudo/videomode.py
@@ -0,0 +1,39 @@
+#
+# Copyright (C) 2021-2022 by TeamYukki@Github, < https://github.com/TeamYukki >.
+#
+# This file is part of < https://github.com/TeamYukki/YukkiMusicBot > project,
+# and is released under the "GNU v3.0 License Agreement".
+# Please see < https://github.com/TeamYukki/YukkiMusicBot/blob/master/LICENSE >
+#
+# All rights reserved.
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+import config
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database import add_off, add_on
+from YukkiMusic.utils.decorators.language import language
+
+# Commands
+VIDEOMODE_COMMAND = get_command("VIDEOMODE_COMMAND")
+
+
+@app.on_message(filters.command(VIDEOMODE_COMMAND) & SUDOERS)
+@language
+async def videoloaymode(client, message: Message, _):
+ usage = _["vidmode_1"]
+ if len(message.command) != 2:
+ return await message.reply_text(usage)
+ state = message.text.split(None, 1)[1].strip()
+ state = state.lower()
+ if state == "download":
+ await add_on(config.YTDOWNLOADER)
+ await message.reply_text(_["vidmode_2"])
+ elif state == "m3u8":
+ await add_off(config.YTDOWNLOADER)
+ await message.reply_text(_["vidmode_3"])
+ else:
+ await message.reply_text(usage)
diff --git a/YukkiMusic/plugins/tools/active.py b/YukkiMusic/plugins/tools/active.py
new file mode 100644
index 0000000000000000000000000000000000000000..40050fa12f633bb18cda7c5ae0f9017d499a9854
--- /dev/null
+++ b/YukkiMusic/plugins/tools/active.py
@@ -0,0 +1,77 @@
+#
+# 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 strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+from YukkiMusic.utils.database.memorydatabase import (
+ get_active_chats, get_active_video_chats)
+
+# Commands
+ACTIVEVC_COMMAND = get_command("ACTIVEVC_COMMAND")
+ACTIVEVIDEO_COMMAND = get_command("ACTIVEVIDEO_COMMAND")
+
+
+@app.on_message(filters.command(ACTIVEVC_COMMAND) & SUDOERS)
+async def activevc(_, message: Message):
+ mystic = await message.reply_text(
+ "Getting active voice chats.. Please hold"
+ )
+ served_chats = await get_active_chats()
+ text = ""
+ j = 0
+ for x in served_chats:
+ try:
+ title = (await app.get_chat(x)).title
+ except Exception:
+ title = "Private Group"
+ if (await app.get_chat(x)).username:
+ user = (await app.get_chat(x)).username
+ text += f"{j + 1}. [{title}](https://t.me/{user})[`{x}`]\n"
+ else:
+ text += f"{j + 1}. {title} [`{x}`]\n"
+ j += 1
+ if not text:
+ await mystic.edit_text("No Active Voice Chats")
+ else:
+ await mystic.edit_text(
+ f"**Active Voice Chats:-**\n\n{text}",
+ disable_web_page_preview=True,
+ )
+
+
+@app.on_message(filters.command(ACTIVEVIDEO_COMMAND) & SUDOERS)
+async def activevi_(_, message: Message):
+ mystic = await message.reply_text(
+ "Getting active video chats.. Please hold"
+ )
+ served_chats = await get_active_video_chats()
+ text = ""
+ j = 0
+ for x in served_chats:
+ try:
+ title = (await app.get_chat(x)).title
+ except Exception:
+ title = "Private Group"
+ if (await app.get_chat(x)).username:
+ user = (await app.get_chat(x)).username
+ text += f"{j + 1}. [{title}](https://t.me/{user})[`{x}`]\n"
+ else:
+ text += f"{j + 1}. {title} [`{x}`]\n"
+ j += 1
+ if not text:
+ await mystic.edit_text("No Active Voice Chats")
+ else:
+ await mystic.edit_text(
+ f"**Active Video Calls:-**\n\n{text}",
+ disable_web_page_preview=True,
+ )
diff --git a/YukkiMusic/plugins/tools/languages.py b/YukkiMusic/plugins/tools/languages.py
new file mode 100644
index 0000000000000000000000000000000000000000..75eb37e6de1e5ebeb107904d142c9d0094bf6efe
--- /dev/null
+++ b/YukkiMusic/plugins/tools/languages.py
@@ -0,0 +1,104 @@
+#
+# 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 pykeyboard import InlineKeyboard
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton, Message
+
+from config import BANNED_USERS
+from strings import get_command, get_string, languages_present
+from YukkiMusic import app
+from YukkiMusic.utils.database import get_lang, set_lang
+from YukkiMusic.utils.decorators import (ActualAdminCB, language,
+ languageCB)
+
+# Languages Available
+
+
+def lanuages_keyboard(_):
+ keyboard = InlineKeyboard(row_width=3)
+ keyboard.add(
+ *[
+ (
+ InlineKeyboardButton(
+ text=languages_present[i],
+ callback_data=f"languages:{i}",
+ )
+ )
+ for i in languages_present
+ ]
+ )
+ keyboard.row(
+ InlineKeyboardButton(
+ text=_["BACK_BUTTON"],
+ callback_data=f"settingsback_helper",
+ ),
+ InlineKeyboardButton(
+ text=_["CLOSE_BUTTON"], callback_data=f"close"
+ ),
+ )
+ return keyboard
+
+
+LANGUAGE_COMMAND = get_command("LANGUAGE_COMMAND")
+
+
+@app.on_message(
+ filters.command(LANGUAGE_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def langs_command(client, message: Message, _):
+ keyboard = lanuages_keyboard(_)
+ await message.reply_text(
+ _["setting_1"].format(message.chat.title, message.chat.id),
+ reply_markup=keyboard,
+ )
+
+
+@app.on_callback_query(filters.regex("LG") & ~BANNED_USERS)
+@languageCB
+async def lanuagecb(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ keyboard = lanuages_keyboard(_)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=keyboard
+ )
+
+
+@app.on_callback_query(
+ filters.regex(r"languages:(.*?)") & ~BANNED_USERS
+)
+@ActualAdminCB
+async def language_markup(client, CallbackQuery, _):
+ langauge = (CallbackQuery.data).split(":")[1]
+ old = await get_lang(CallbackQuery.message.chat.id)
+ if str(old) == str(langauge):
+ return await CallbackQuery.answer(
+ "You're already on same language", show_alert=True
+ )
+ try:
+ _ = get_string(langauge)
+ await CallbackQuery.answer(
+ "Successfully changed your language.", show_alert=True
+ )
+ except:
+ return await CallbackQuery.answer(
+ "Failed to change language or Language under update.",
+ show_alert=True,
+ )
+ await set_lang(CallbackQuery.message.chat.id, langauge)
+ keyboard = lanuages_keyboard(_)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=keyboard
+ )
diff --git a/YukkiMusic/plugins/tools/lyrics.py b/YukkiMusic/plugins/tools/lyrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5064a15ea78ab727b5ddbb4624028ad4fdee400
--- /dev/null
+++ b/YukkiMusic/plugins/tools/lyrics.py
@@ -0,0 +1,66 @@
+#
+# 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
+import re
+import string
+
+import lyricsgenius as lg
+from pyrogram import filters
+from pyrogram.types import (InlineKeyboardButton,
+ InlineKeyboardMarkup, Message)
+
+from config import BANNED_USERS, lyrical
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.utils.decorators.language import language
+
+###Commands
+LYRICS_COMMAND = get_command("LYRICS_COMMAND")
+
+api_key = "Vd9FvPMOKWfsKJNG9RbZnItaTNIRFzVyyXFdrGHONVsGqHcHBoj3AI3sIlNuqzuf0ZNG8uLcF9wAd5DXBBnUzA"
+y = lg.Genius(
+ api_key,
+ skip_non_songs=True,
+ excluded_terms=["(Remix)", "(Live)"],
+ remove_section_headers=True,
+)
+y.verbose = False
+
+
+@app.on_message(
+ filters.command(LYRICS_COMMAND) & ~BANNED_USERS
+)
+@language
+async def lrsearch(client, message: Message, _):
+ if len(message.command) < 2:
+ return await message.reply_text(_["lyrics_1"])
+ title = message.text.split(None, 1)[1]
+ m = await message.reply_text(_["lyrics_2"])
+ S = y.search_song(title, get_full_info=False)
+ if S is None:
+ return await m.edit(_["lyrics_3"].format(title))
+ ran_hash = "".join(
+ random.choices(string.ascii_uppercase + string.digits, k=10)
+ )
+ lyric = S.lyrics
+ if "Embed" in lyric:
+ lyric = re.sub(r"\d*Embed", "", lyric)
+ lyrical[ran_hash] = lyric
+ upl = InlineKeyboardMarkup(
+ [
+ [
+ InlineKeyboardButton(
+ text=_["L_B_1"],
+ url=f"https://t.me/{app.username}?start=lyrics_{ran_hash}",
+ ),
+ ]
+ ]
+ )
+ await m.edit(_["lyrics_4"], reply_markup=upl)
diff --git a/YukkiMusic/plugins/tools/ping.py b/YukkiMusic/plugins/tools/ping.py
new file mode 100644
index 0000000000000000000000000000000000000000..f75a16faf27b5e76cd76ca6ec970107a4b2c2d28
--- /dev/null
+++ b/YukkiMusic/plugins/tools/ping.py
@@ -0,0 +1,45 @@
+#
+# 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 datetime import datetime
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from config import BANNED_USERS, MUSIC_BOT_NAME, PING_IMG_URL
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.utils import bot_sys_stats
+from YukkiMusic.utils.decorators.language import language
+
+### Commands
+PING_COMMAND = get_command("PING_COMMAND")
+
+
+@app.on_message(
+ filters.command(PING_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def ping_com(client, message: Message, _):
+ response = await message.reply_photo(
+ photo=PING_IMG_URL,
+ caption=_["ping_1"],
+ )
+ start = datetime.now()
+ pytgping = await Yukki.ping()
+ UP, CPU, RAM, DISK = await bot_sys_stats()
+ resp = (datetime.now() - start).microseconds / 1000
+ await response.edit_text(
+ _["ping_2"].format(
+ MUSIC_BOT_NAME, resp, UP, DISK, CPU, RAM, pytgping
+ )
+ )
diff --git a/YukkiMusic/plugins/tools/queue.py b/YukkiMusic/plugins/tools/queue.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c017f9d51e18fc7c48b626158cfb3ca78aad0b7
--- /dev/null
+++ b/YukkiMusic/plugins/tools/queue.py
@@ -0,0 +1,339 @@
+#
+# 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
+from random import randint
+
+from pyrogram import filters
+from pyrogram.errors import FloodWait
+from pyrogram.types import CallbackQuery, InputMediaPhoto, Message
+
+import config
+from config import BANNED_USERS
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import db
+from YukkiMusic.utils import (Yukkibin, get_channeplayCB,
+ seconds_to_min)
+from YukkiMusic.utils.database import (get_cmode, is_active_chat,
+ is_music_playing)
+from YukkiMusic.utils.decorators.language import language, languageCB
+from YukkiMusic.utils.inline import queue_back_markup, queue_markup
+
+###Commands
+QUEUE_COMMAND = get_command("QUEUE_COMMAND")
+
+basic = {}
+
+
+def get_image(videoid):
+ if os.path.isfile(f"cache/{videoid}.png"):
+ return f"cache/{videoid}.png"
+ else:
+ return config.YOUTUBE_IMG_URL
+
+
+def get_duration(playing):
+ file_path = playing[0]["file"]
+ if "index_" in file_path or "live_" in file_path:
+ return "Unknown"
+ duration_seconds = int(playing[0]["seconds"])
+ if duration_seconds == 0:
+ return "Unknown"
+ else:
+ return "Inline"
+
+
+@app.on_message(
+ filters.command(QUEUE_COMMAND) & filters.group & ~BANNED_USERS
+)
+@language
+async def ping_com(client, message: Message, _):
+ if message.command[0][0] == "c":
+ chat_id = await get_cmode(message.chat.id)
+ if chat_id is None:
+ return await message.reply_text(_["setting_12"])
+ try:
+ await app.get_chat(chat_id)
+ except:
+ return await message.reply_text(_["cplay_4"])
+ cplay = True
+ else:
+ chat_id = message.chat.id
+ cplay = False
+ if not await is_active_chat(chat_id):
+ return await message.reply_text(_["general_6"])
+ got = db.get(chat_id)
+ if not got:
+ return await message.reply_text(_["queue_2"])
+ file = got[0]["file"]
+ videoid = got[0]["vidid"]
+ user = got[0]["by"]
+ title = (got[0]["title"]).title()
+ typo = (got[0]["streamtype"]).title()
+ DUR = get_duration(got)
+ if "live_" in file:
+ IMAGE = get_image(videoid)
+ elif "vid_" in file:
+ IMAGE = get_image(videoid)
+ elif "index_" in file:
+ IMAGE = config.STREAM_IMG_URL
+ else:
+ if videoid == "telegram":
+ IMAGE = (
+ config.TELEGRAM_AUDIO_URL
+ if typo == "Audio"
+ else config.TELEGRAM_VIDEO_URL
+ )
+ elif videoid == "soundcloud":
+ IMAGE = config.SOUNCLOUD_IMG_URL
+ else:
+ IMAGE = get_image(videoid)
+ send = (
+ "**âī¸Duration:** Unknown Duration Stream\n\nClick on button below to get whole queued list."
+ if DUR == "Unknown"
+ else "\nClick on button below to get whole queued list."
+ )
+ cap = f"""**{config.MUSIC_BOT_NAME} Player**
+
+đĨ**Playing:** {title}
+
+đ**Stream Type:** {typo}
+đââī¸**Played By:** {user}
+{send}"""
+ upl = (
+ queue_markup(_, DUR, "c" if cplay else "g", videoid)
+ if DUR == "Unknown"
+ else queue_markup(
+ _,
+ DUR,
+ "c" if cplay else "g",
+ videoid,
+ seconds_to_min(got[0]["played"]),
+ got[0]["dur"],
+ )
+ )
+ basic[videoid] = True
+ mystic = await message.reply_photo(
+ IMAGE, caption=cap, reply_markup=upl
+ )
+ if DUR != "Unknown":
+ try:
+ while db[chat_id][0]["vidid"] == videoid:
+ await asyncio.sleep(5)
+ if await is_active_chat(chat_id):
+ if basic[videoid]:
+ if await is_music_playing(chat_id):
+ try:
+ buttons = queue_markup(
+ _,
+ DUR,
+ "c" if cplay else "g",
+ videoid,
+ seconds_to_min(
+ db[chat_id][0]["played"]
+ ),
+ db[chat_id][0]["dur"],
+ )
+ await mystic.edit_reply_markup(
+ reply_markup=buttons
+ )
+ except FloodWait:
+ pass
+ else:
+ pass
+ else:
+ break
+ else:
+ break
+ except:
+ return
+
+
+@app.on_callback_query(filters.regex("GetTimer") & ~BANNED_USERS)
+async def quite_timer(client, CallbackQuery: CallbackQuery):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+
+
+@app.on_callback_query(filters.regex("GetQueued") & ~BANNED_USERS)
+@languageCB
+async def queued_tracks(client, CallbackQuery: CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ what, videoid = callback_request.split("|")
+ try:
+ chat_id, channel = await get_channeplayCB(
+ _, what, CallbackQuery
+ )
+ except:
+ return
+ if not await is_active_chat(chat_id):
+ return await CallbackQuery.answer(
+ _["general_6"], show_alert=True
+ )
+ got = db.get(chat_id)
+ if not got:
+ return await CallbackQuery.answer(
+ _["queue_2"], show_alert=True
+ )
+ if len(got) == 1:
+ return await CallbackQuery.answer(
+ _["queue_5"], show_alert=True
+ )
+ await CallbackQuery.answer()
+ basic[videoid] = False
+ buttons = queue_back_markup(_, what)
+ med = InputMediaPhoto(
+ media="https://telegra.ph//file/6f7d35131f69951c74ee5.jpg",
+ caption=_["queue_1"],
+ )
+ await CallbackQuery.edit_message_media(media=med)
+ j = 0
+ msg = ""
+ for x in got:
+ j += 1
+ if j == 1:
+ msg += f'Currently Playing:\n\nđˇTitle: {x["title"]}\nDuration: {x["dur"]}\nBy: {x["by"]}\n\n'
+ elif j == 2:
+ msg += f'Queued:\n\nđˇTitle: {x["title"]}\nDuration: {x["dur"]}\nBy: {x["by"]}\n\n'
+ else:
+ msg += f'đˇTitle: {x["title"]}\nDuration: {x["dur"]}\nBy: {x["by"]}\n\n'
+ if "Queued" in msg:
+ if len(msg) < 700:
+ await asyncio.sleep(1)
+ return await CallbackQuery.edit_message_text(
+ msg, reply_markup=buttons
+ )
+ if "đˇ" in msg:
+ msg = msg.replace("đˇ", "")
+ link = await Yukkibin(msg)
+ med = InputMediaPhoto(
+ media=link, caption=_["queue_3"].format(link)
+ )
+ await CallbackQuery.edit_message_media(
+ media=med, reply_markup=buttons
+ )
+ else:
+ await asyncio.sleep(1)
+ return await CallbackQuery.edit_message_text(
+ msg, reply_markup=buttons
+ )
+
+
+@app.on_callback_query(
+ filters.regex("queue_back_timer") & ~BANNED_USERS
+)
+@languageCB
+async def queue_back(client, CallbackQuery: CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ cplay = callback_data.split(None, 1)[1]
+ try:
+ chat_id, channel = await get_channeplayCB(
+ _, cplay, CallbackQuery
+ )
+ except:
+ return
+ if not await is_active_chat(chat_id):
+ return await CallbackQuery.answer(
+ _["general_6"], show_alert=True
+ )
+ got = db.get(chat_id)
+ if not got:
+ return await CallbackQuery.answer(
+ _["queue_2"], show_alert=True
+ )
+ await CallbackQuery.answer(_["set_cb_8"], show_alert=True)
+ file = got[0]["file"]
+ videoid = got[0]["vidid"]
+ user = got[0]["by"]
+ title = (got[0]["title"]).title()
+ typo = (got[0]["streamtype"]).title()
+ DUR = get_duration(got)
+ if "live_" in file:
+ IMAGE = get_image(videoid)
+ elif "vid_" in file:
+ IMAGE = get_image(videoid)
+ elif "index_" in file:
+ IMAGE = config.STREAM_IMG_URL
+ else:
+ if videoid == "telegram":
+ IMAGE = (
+ config.TELEGRAM_AUDIO_URL
+ if typo == "Audio"
+ else config.TELEGRAM_VIDEO_URL
+ )
+ elif videoid == "soundcloud":
+ IMAGE = config.SOUNCLOUD_IMG_URL
+ else:
+ IMAGE = get_image(videoid)
+ send = (
+ "**âī¸Duration:** Unknown Duration Stream\n\nClick on button below to get whole queued list."
+ if DUR == "Unknown"
+ else "\nClick on button below to get whole queued list."
+ )
+ cap = f"""**{config.MUSIC_BOT_NAME} Player**
+
+đĨ**Playing:** {title}
+
+đ**Stream Type:** {typo}
+đââī¸**Played By:** {user}
+{send}"""
+ upl = (
+ queue_markup(_, DUR, cplay, videoid)
+ if DUR == "Unknown"
+ else queue_markup(
+ _,
+ DUR,
+ cplay,
+ videoid,
+ seconds_to_min(got[0]["played"]),
+ got[0]["dur"],
+ )
+ )
+ basic[videoid] = True
+
+ med = InputMediaPhoto(media=IMAGE, caption=cap)
+ mystic = await CallbackQuery.edit_message_media(
+ media=med, reply_markup=upl
+ )
+ if DUR != "Unknown":
+ try:
+ while db[chat_id][0]["vidid"] == videoid:
+ await asyncio.sleep(5)
+ if await is_active_chat(chat_id):
+ if basic[videoid]:
+ if await is_music_playing(chat_id):
+ try:
+ buttons = queue_markup(
+ _,
+ DUR,
+ cplay,
+ videoid,
+ seconds_to_min(
+ db[chat_id][0]["played"]
+ ),
+ db[chat_id][0]["dur"],
+ )
+ await mystic.edit_reply_markup(
+ reply_markup=buttons
+ )
+ except FloodWait:
+ pass
+ else:
+ pass
+ else:
+ break
+ else:
+ break
+ except:
+ return
diff --git a/YukkiMusic/plugins/tools/reload.py b/YukkiMusic/plugins/tools/reload.py
new file mode 100644
index 0000000000000000000000000000000000000000..92d9a6308fa1b64491690c36670074cb5c36414c
--- /dev/null
+++ b/YukkiMusic/plugins/tools/reload.py
@@ -0,0 +1,141 @@
+#
+# 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 CallbackQuery, Message
+
+from config import BANNED_USERS, MUSIC_BOT_NAME, adminlist, lyrical
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.core.call import Yukki
+from YukkiMusic.misc import db
+from YukkiMusic.utils.database import get_authuser_names, get_cmode
+from YukkiMusic.utils.decorators import (ActualAdminCB, AdminActual,
+ language)
+from YukkiMusic.utils.formatters import alpha_to_int
+
+### Multi-Lang Commands
+RELOAD_COMMAND = get_command("RELOAD_COMMAND")
+RESTART_COMMAND = get_command("RESTART_COMMAND")
+
+
+@app.on_message(
+ filters.command(RELOAD_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def reload_admin_cache(client, message: Message, _):
+ try:
+ chat_id = message.chat.id
+ admins = await app.get_chat_members(
+ chat_id, filter="administrators"
+ )
+ authusers = await get_authuser_names(chat_id)
+ adminlist[chat_id] = []
+ for user in admins:
+ if user.can_manage_voice_chats:
+ adminlist[chat_id].append(user.user.id)
+ for user in authusers:
+ user_id = await alpha_to_int(user)
+ adminlist[chat_id].append(user_id)
+ await message.reply_text(_["admin_20"])
+ except:
+ await message.reply_text(
+ "Failed to reload admincache. Make sure Bot is admin in your chat."
+ )
+
+
+@app.on_message(
+ filters.command(RESTART_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@AdminActual
+async def restartbot(client, message: Message, _):
+ mystic = await message.reply_text(
+ f"Please Wait.. Restarting {MUSIC_BOT_NAME} for your chat.."
+ )
+ await asyncio.sleep(1)
+ try:
+ db[message.chat.id] = []
+ await Yukki.stop_stream(message.chat.id)
+ except:
+ pass
+ chat_id = await get_cmode(message.chat.id)
+ if chat_id:
+ try:
+ await app.get_chat(chat_id)
+ except:
+ pass
+ try:
+ db[chat_id] = []
+ await Yukki.stop_stream(chat_id)
+ except:
+ pass
+ return await mystic.edit_text(
+ "Successfully restarted. Try playing now.."
+ )
+
+
+@app.on_callback_query(filters.regex("close") & ~BANNED_USERS)
+async def close_menu(_, CallbackQuery):
+ try:
+ await CallbackQuery.message.delete()
+ await CallbackQuery.answer()
+ except:
+ return
+
+
+@app.on_callback_query(filters.regex("close") & ~BANNED_USERS)
+async def close_menu(_, CallbackQuery):
+ try:
+ await CallbackQuery.message.delete()
+ await CallbackQuery.answer()
+ except:
+ return
+
+
+@app.on_callback_query(
+ filters.regex("stop_downloading") & ~BANNED_USERS
+)
+@ActualAdminCB
+async def stop_download(client, CallbackQuery: CallbackQuery, _):
+ message_id = CallbackQuery.message.message_id
+ task = lyrical.get(message_id)
+ if not task:
+ return await CallbackQuery.answer(
+ "Downloading already Completed.", show_alert=True
+ )
+ if task.done() or task.cancelled():
+ return await CallbackQuery.answer(
+ "Downloading already Completed or Cancelled.",
+ show_alert=True,
+ )
+ if not task.done():
+ try:
+ task.cancel()
+ try:
+ lyrical.pop(message_id)
+ except:
+ pass
+ await CallbackQuery.answer(
+ "Downloading Cancelled", show_alert=True
+ )
+ return await CallbackQuery.edit_message_text(
+ f"Download Cancelled by {CallbackQuery.from_user.mention}"
+ )
+ except:
+ return await CallbackQuery.answer(
+ "Failed to stop the Downloading.", show_alert=True
+ )
+ await CallbackQuery.answer(
+ "Failed to recognize the running task", show_alert=True
+ )
diff --git a/YukkiMusic/plugins/tools/songs.py b/YukkiMusic/plugins/tools/songs.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba267ea0fdf472cea9e0a516e852b2f913539232
--- /dev/null
+++ b/YukkiMusic/plugins/tools/songs.py
@@ -0,0 +1,311 @@
+#
+# 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 re
+
+import yt_dlp
+from pykeyboard import InlineKeyboard
+from pyrogram import enums
+from pyrogram import filters
+from pyrogram.types import (InlineKeyboardButton,
+ InlineKeyboardMarkup, InputMediaAudio,
+ InputMediaVideo, Message)
+
+from config import (BANNED_USERS, SONG_DOWNLOAD_DURATION,
+ SONG_DOWNLOAD_DURATION_LIMIT)
+from strings import get_command
+from YukkiMusic import YouTube, app
+from YukkiMusic.utils.decorators.language import language, languageCB
+from YukkiMusic.utils.formatters import convert_bytes
+from YukkiMusic.utils.inline.song import song_markup
+
+# Command
+SONG_COMMAND = get_command("SONG_COMMAND")
+
+
+@app.on_message(
+ filters.command(SONG_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def song_commad_group(client, message: Message, _):
+ upl = InlineKeyboardMarkup(
+ [
+ [
+ InlineKeyboardButton(
+ text=_["SG_B_1"],
+ url=f"https://t.me/{app.username}?start=song",
+ ),
+ ]
+ ]
+ )
+ await message.reply_text(_["song_1"], reply_markup=upl)
+
+
+# Song Module
+
+
+@app.on_message(
+ filters.command(SONG_COMMAND)
+ & filters.private
+ & ~BANNED_USERS
+)
+@language
+async def song_commad_private(client, message: Message, _):
+ await message.delete()
+ url = await YouTube.url(message)
+ if url:
+ if not await YouTube.exists(url):
+ return await message.reply_text(_["song_5"])
+ mystic = await message.reply_text(_["play_1"])
+ (
+ title,
+ duration_min,
+ duration_sec,
+ thumbnail,
+ vidid,
+ ) = await YouTube.details(url)
+ if str(duration_min) == "None":
+ return await mystic.edit_text(_["song_3"])
+ if int(duration_sec) > SONG_DOWNLOAD_DURATION_LIMIT:
+ return await mystic.edit_text(
+ _["play_4"].format(
+ SONG_DOWNLOAD_DURATION, duration_min
+ )
+ )
+ buttons = song_markup(_, vidid)
+ await mystic.delete()
+ return await message.reply_photo(
+ thumbnail,
+ caption=_["song_4"].format(title),
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+ else:
+ if len(message.command) < 2:
+ return await message.reply_text(_["song_2"])
+ mystic = await message.reply_text(_["play_1"])
+ query = message.text.split(None, 1)[1]
+ try:
+ (
+ title,
+ duration_min,
+ duration_sec,
+ thumbnail,
+ vidid,
+ ) = await YouTube.details(query)
+ except:
+ return await mystic.edit_text(_["play_3"])
+ if str(duration_min) == "None":
+ return await mystic.edit_text(_["song_3"])
+ if int(duration_sec) > SONG_DOWNLOAD_DURATION_LIMIT:
+ return await mystic.edit_text(
+ _["play_6"].format(SONG_DOWNLOAD_DURATION, duration_min)
+ )
+ buttons = song_markup(_, vidid)
+ await mystic.delete()
+ return await message.reply_photo(
+ thumbnail,
+ caption=_["song_4"].format(title),
+ reply_markup=InlineKeyboardMarkup(buttons),
+ )
+
+
+@app.on_callback_query(
+ filters.regex(pattern=r"song_back") & ~BANNED_USERS
+)
+@languageCB
+async def songs_back_helper(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ stype, vidid = callback_request.split("|")
+ buttons = song_markup(_, vidid)
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=InlineKeyboardMarkup(buttons)
+ )
+
+
+@app.on_callback_query(
+ filters.regex(pattern=r"song_helper") & ~BANNED_USERS
+)
+@languageCB
+async def song_helper_cb(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ stype, vidid = callback_request.split("|")
+ try:
+ await CallbackQuery.answer(_["song_6"], show_alert=True)
+ except:
+ pass
+ if stype == "audio":
+ try:
+ formats_available, link = await YouTube.formats(
+ vidid, True
+ )
+ except:
+ return await CallbackQuery.edit_message_text(_["song_7"])
+ keyboard = InlineKeyboard()
+ done = []
+ for x in formats_available:
+ check = x["format"]
+ if "audio" in check:
+ if x["filesize"] is None:
+ continue
+ form = x["format_note"].title()
+ if form not in done:
+ done.append(form)
+ else:
+ continue
+ sz = convert_bytes(x["filesize"])
+ fom = x["format_id"]
+ keyboard.row(
+ InlineKeyboardButton(
+ text=f"{form} Quality Audio = {sz}",
+ callback_data=f"song_download {stype}|{fom}|{vidid}",
+ ),
+ )
+ keyboard.row(
+ InlineKeyboardButton(
+ text=_["BACK_BUTTON"],
+ callback_data=f"song_back {stype}|{vidid}",
+ ),
+ InlineKeyboardButton(
+ text=_["CLOSE_BUTTON"], callback_data=f"close"
+ ),
+ )
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=keyboard
+ )
+ else:
+ try:
+ formats_available, link = await YouTube.formats(
+ vidid, True
+ )
+ except Exception as e:
+ print(e)
+ return await CallbackQuery.edit_message_text(_["song_7"])
+ keyboard = InlineKeyboard()
+ # AVC Formats Only [ YUKKI MUSIC BOT ]
+ done = [160, 133, 134, 135, 136, 137, 298, 299, 264, 304, 266]
+ for x in formats_available:
+ check = x["format"]
+ if x["filesize"] is None:
+ continue
+ if int(x["format_id"]) not in done:
+ continue
+ sz = convert_bytes(x["filesize"])
+ ap = check.split("-")[1]
+ to = f"{ap} = {sz}"
+ keyboard.row(
+ InlineKeyboardButton(
+ text=to,
+ callback_data=f"song_download {stype}|{x['format_id']}|{vidid}",
+ )
+ )
+ keyboard.row(
+ InlineKeyboardButton(
+ text=_["BACK_BUTTON"],
+ callback_data=f"song_back {stype}|{vidid}",
+ ),
+ InlineKeyboardButton(
+ text=_["CLOSE_BUTTON"], callback_data=f"close"
+ ),
+ )
+ return await CallbackQuery.edit_message_reply_markup(
+ reply_markup=keyboard
+ )
+
+
+# Downloading Songs Here
+
+
+@app.on_callback_query(
+ filters.regex(pattern=r"song_download") & ~BANNED_USERS
+)
+@languageCB
+async def song_download_cb(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer("Downloading")
+ except:
+ pass
+ callback_data = CallbackQuery.data.strip()
+ callback_request = callback_data.split(None, 1)[1]
+ stype, format_id, vidid = callback_request.split("|")
+ mystic = await CallbackQuery.edit_message_text(_["song_8"])
+ yturl = f"https://www.youtube.com/watch?v={vidid}"
+ with yt_dlp.YoutubeDL({"quiet": True}) as ytdl:
+ x = ytdl.extract_info(yturl, download=False)
+ title = (x["title"]).title()
+ title = re.sub("\W+", " ", title)
+ thumb_image_path = await CallbackQuery.message.download()
+ duration = x["duration"]
+ if stype == "video":
+ thumb_image_path = await CallbackQuery.message.download()
+ width = CallbackQuery.message.photo.width
+ height = CallbackQuery.message.photo.height
+ try:
+ file_path = await YouTube.download(
+ yturl,
+ mystic,
+ songvideo=True,
+ format_id=format_id,
+ title=title,
+ )
+ except Exception as e:
+ return await mystic.edit_text(_["song_9"].format(e))
+ med = InputMediaVideo(
+ media=file_path,
+ duration=duration,
+ width=width,
+ height=height,
+ thumb=thumb_image_path,
+ caption=title,
+ supports_streaming=True,
+ )
+ await mystic.edit_text(_["song_11"])
+ await app.send_chat_action(
+ chat_id=CallbackQuery.message.chat.id,
+ action=enums.ChatAction.UPLOAD_VIDEO,
+ )
+ try:
+ await CallbackQuery.edit_message_media(media=med)
+ except Exception as e:
+ print(e)
+ return await mystic.edit_text(_["song_10"])
+ os.remove(file_path)
+ elif stype == "audio":
+ try:
+ filename = await YouTube.download(
+ yturl,
+ mystic,
+ songaudio=True,
+ format_id=format_id,
+ title=title,
+ )
+ except Exception as e:
+ return await mystic.edit_text(_["song_9"].format(e))
+ med = InputMediaAudio(
+ media=filename,
+ caption=title,
+ thumb=thumb_image_path,
+ title=title,
+ performer=x["uploader"],
+ )
+ await mystic.edit_text(_["song_11"])
+ await app.send_chat_action(
+ chat_id=CallbackQuery.message.chat.id,
+ action=enums.ChatAction.UPLOAD_VIDEO,
+ )
+ try:
+ await CallbackQuery.edit_message_media(media=med)
+ except Exception as e:
+ print(e)
+ return await mystic.edit_text(_["song_10"])
+ os.remove(filename)
diff --git a/YukkiMusic/plugins/tools/speedtest.py b/YukkiMusic/plugins/tools/speedtest.py
new file mode 100644
index 0000000000000000000000000000000000000000..f58947b0440106354c7c1abc2434aa17da5954a4
--- /dev/null
+++ b/YukkiMusic/plugins/tools/speedtest.py
@@ -0,0 +1,59 @@
+#
+# 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 speedtest
+from pyrogram import filters
+from strings import get_command
+from YukkiMusic import app
+from YukkiMusic.misc import SUDOERS
+
+# Commands
+SPEEDTEST_COMMAND = get_command("SPEEDTEST_COMMAND")
+
+
+def testspeed(m):
+ try:
+ test = speedtest.Speedtest()
+ test.get_best_server()
+ m = m.edit("Running Download SpeedTest")
+ test.download()
+ m = m.edit("Running Upload SpeedTest")
+ test.upload()
+ test.results.share()
+ result = test.results.dict()
+ m = m.edit("Sharing SpeedTest Results")
+ except Exception as e:
+ return m.edit(e)
+ return result
+
+
+@app.on_message(filters.command(SPEEDTEST_COMMAND) & SUDOERS)
+async def speedtest_function(client, message):
+ m = await message.reply_text("Running Speed test")
+ loop = asyncio.get_event_loop()
+ result = await loop.run_in_executor(None, testspeed, m)
+ output = f"""**Speedtest Results**
+
+**Client:**
+**__ISP:__** {result['client']['isp']}
+**__Country:__** {result['client']['country']}
+
+**Server:**
+**__Name:__** {result['server']['name']}
+**__Country:__** {result['server']['country']}, {result['server']['cc']}
+**__Sponsor:__** {result['server']['sponsor']}
+**__Latency:__** {result['server']['latency']}
+**__Ping:__** {result['ping']}"""
+ msg = await app.send_photo(
+ chat_id=message.chat.id,
+ photo=result["share"],
+ caption=output
+ )
+ await m.delete()
diff --git a/YukkiMusic/plugins/tools/stats.py b/YukkiMusic/plugins/tools/stats.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7f855e79daf59a2c15bcb44220d934d672cefe0
--- /dev/null
+++ b/YukkiMusic/plugins/tools/stats.py
@@ -0,0 +1,472 @@
+#
+# 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 platform
+from sys import version as pyver
+
+import psutil
+from pyrogram import __version__ as pyrover
+from pyrogram import filters
+from pyrogram.errors import MessageIdInvalid
+from pyrogram.types import CallbackQuery, InputMediaPhoto, Message
+from pytgcalls.__version__ import __version__ as pytgver
+
+import config
+from config import BANNED_USERS, MUSIC_BOT_NAME
+from strings import get_command
+from YukkiMusic import YouTube, app
+from YukkiMusic.core.userbot import assistants
+from YukkiMusic.misc import SUDOERS, pymongodb
+from YukkiMusic.plugins import ALL_MODULES
+from YukkiMusic.utils.database import (get_global_tops,
+ get_particulars, get_queries,
+ get_served_chats,
+ get_served_users, get_sudoers,
+ get_top_chats, get_topp_users)
+from YukkiMusic.utils.decorators.language import language, languageCB
+from YukkiMusic.utils.inline.stats import (back_stats_buttons,
+ back_stats_markup,
+ get_stats_markup,
+ overallback_stats_markup,
+ stats_buttons,
+ top_ten_stats_markup)
+
+loop = asyncio.get_running_loop()
+
+# Commands
+GSTATS_COMMAND = get_command("GSTATS_COMMAND")
+STATS_COMMAND = get_command("STATS_COMMAND")
+
+
+@app.on_message(
+ filters.command(STATS_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def stats_global(client, message: Message, _):
+ upl = stats_buttons(
+ _, True if message.from_user.id in SUDOERS else False
+ )
+ await message.reply_photo(
+ photo=config.STATS_IMG_URL,
+ caption=_["gstats_11"].format(config.MUSIC_BOT_NAME),
+ reply_markup=upl,
+ )
+
+
+@app.on_message(
+ filters.command(GSTATS_COMMAND)
+ & filters.group
+ & ~BANNED_USERS
+)
+@language
+async def gstats_global(client, message: Message, _):
+ mystic = await message.reply_text(_["gstats_1"])
+ stats = await get_global_tops()
+ if not stats:
+ await asyncio.sleep(1)
+ return await mystic.edit(_["gstats_2"])
+
+ def get_stats():
+ 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 mystic.edit(_["gstats_2"])
+ videoid = None
+ co = None
+ for vidid, count in list_arranged.items():
+ if vidid == "telegram":
+ continue
+ else:
+ videoid = vidid
+ co = count
+ break
+ return videoid, co
+
+ try:
+ videoid, co = await loop.run_in_executor(None, get_stats)
+ except Exception as e:
+ print(e)
+ return
+ (
+ title,
+ duration_min,
+ duration_sec,
+ thumbnail,
+ vidid,
+ ) = await YouTube.details(videoid, True)
+ title = title.title()
+ final = f"Top Most Played Track on {MUSIC_BOT_NAME}\n\n**Title:** {title}\n\nPlayed** {co} **times"
+ upl = get_stats_markup(
+ _, True if message.from_user.id in SUDOERS else False
+ )
+ await app.send_photo(
+ message.chat.id,
+ photo=thumbnail,
+ caption=final,
+ reply_markup=upl,
+ )
+ await mystic.delete()
+
+
+@app.on_callback_query(filters.regex("GetStatsNow") & ~BANNED_USERS)
+@languageCB
+async def top_users_ten(client, CallbackQuery: CallbackQuery, _):
+ chat_id = CallbackQuery.message.chat.id
+ callback_data = CallbackQuery.data.strip()
+ what = callback_data.split(None, 1)[1]
+ upl = back_stats_markup(_)
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ mystic = await CallbackQuery.edit_message_text(
+ _["gstats_3"].format(
+ f"of {CallbackQuery.message.chat.title}"
+ if what == "Here"
+ else what
+ )
+ )
+ if what == "Tracks":
+ stats = await get_global_tops()
+ elif what == "Chats":
+ stats = await get_top_chats()
+ elif what == "Users":
+ stats = await get_topp_users()
+ elif what == "Here":
+ stats = await get_particulars(chat_id)
+ if not stats:
+ await asyncio.sleep(1)
+ return await mystic.edit(_["gstats_2"], reply_markup=upl)
+ queries = await get_queries()
+
+ def get_stats():
+ results = {}
+ for i in stats:
+ top_list = (
+ stats[i]
+ if what in ["Chats", "Users"]
+ else 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 mystic.edit(_["gstats_2"], reply_markup=upl)
+ msg = ""
+ limit = 0
+ total_count = 0
+ if what in ["Tracks", "Here"]:
+ for items, count in list_arranged.items():
+ total_count += count
+ if limit == 10:
+ continue
+ limit += 1
+ details = stats.get(items)
+ title = (details["title"][:35]).title()
+ if items == "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={items}) ** played {count} times**\n\n"
+
+ temp = (
+ _["gstats_4"].format(
+ queries,
+ config.MUSIC_BOT_NAME,
+ len(stats),
+ total_count,
+ limit,
+ )
+ if what == "Tracks"
+ else _["gstats_7"].format(
+ len(stats), total_count, limit
+ )
+ )
+ msg = temp + msg
+ return msg, list_arranged
+
+ try:
+ msg, list_arranged = await loop.run_in_executor(
+ None, get_stats
+ )
+ except Exception as e:
+ print(e)
+ return
+ limit = 0
+ if what in ["Users", "Chats"]:
+ for items, count in list_arranged.items():
+ if limit == 10:
+ break
+ try:
+ extract = (
+ (await app.get_users(items)).first_name
+ if what == "Users"
+ else (await app.get_chat(items)).title
+ )
+ if extract is None:
+ continue
+ await asyncio.sleep(0.5)
+ except:
+ continue
+ limit += 1
+ msg += f"đ`{extract}` played {count} times on bot.\n\n"
+ temp = (
+ _["gstats_5"].format(limit, MUSIC_BOT_NAME)
+ if what == "Chats"
+ else _["gstats_6"].format(limit, MUSIC_BOT_NAME)
+ )
+ msg = temp + msg
+ med = InputMediaPhoto(media=config.GLOBAL_IMG_URL, caption=msg)
+ try:
+ await CallbackQuery.edit_message_media(
+ media=med, reply_markup=upl
+ )
+ except MessageIdInvalid:
+ await CallbackQuery.message.reply_photo(
+ photo=config.GLOBAL_IMG_URL, caption=msg, reply_markup=upl
+ )
+
+
+@app.on_callback_query(filters.regex("TopOverall") & ~BANNED_USERS)
+@languageCB
+async def overall_stats(client, CallbackQuery, _):
+ callback_data = CallbackQuery.data.strip()
+ what = callback_data.split(None, 1)[1]
+ if what != "s":
+ upl = overallback_stats_markup(_)
+ else:
+ upl = back_stats_buttons(_)
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ await CallbackQuery.edit_message_text(_["gstats_8"])
+ served_chats = len(await get_served_chats())
+ served_users = len(await get_served_users())
+ total_queries = await get_queries()
+ blocked = len(BANNED_USERS)
+ sudoers = len(SUDOERS)
+ mod = len(ALL_MODULES)
+ assistant = len(assistants)
+ playlist_limit = config.SERVER_PLAYLIST_LIMIT
+ fetch_playlist = config.PLAYLIST_FETCH_LIMIT
+ song = config.SONG_DOWNLOAD_DURATION
+ play_duration = config.DURATION_LIMIT_MIN
+ if config.AUTO_LEAVING_ASSISTANT == str(True):
+ ass = "Yes"
+ else:
+ ass = "No"
+ cm = config.CLEANMODE_DELETE_MINS
+ text = f"""**Bot's Stats and Information:**
+
+**Imported Modules:** {mod}
+**Served Chats:** {served_chats}
+**Served Users:** {served_users}
+**Blocked Users:** {blocked}
+**Sudo Users:** {sudoers}
+
+**Total Queries:** {total_queries}
+**Total Assistants:** {assistant}
+**Auto Leaving Assistant:** {ass}
+**Cleanmode duration:** {cm} Mins
+
+**Play Duration Limit:** {play_duration} Mins
+**Song Download Limit:** {song} Mins
+**Bot's Server Playlist Limit:** {playlist_limit}
+**Playlist Play Limit:** {fetch_playlist}"""
+ med = InputMediaPhoto(media=config.STATS_IMG_URL, caption=text)
+ try:
+ await CallbackQuery.edit_message_media(
+ media=med, reply_markup=upl
+ )
+ except MessageIdInvalid:
+ await CallbackQuery.message.reply_photo(
+ photo=config.STATS_IMG_URL, caption=text, reply_markup=upl
+ )
+
+
+@app.on_callback_query(filters.regex("bot_stats_sudo"))
+@languageCB
+async def overall_stats(client, CallbackQuery, _):
+ if CallbackQuery.from_user.id not in SUDOERS:
+ return await CallbackQuery.answer(
+ "Only for Sudo Users", show_alert=True
+ )
+ callback_data = CallbackQuery.data.strip()
+ what = callback_data.split(None, 1)[1]
+ if what != "s":
+ upl = overallback_stats_markup(_)
+ else:
+ upl = back_stats_buttons(_)
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ await CallbackQuery.edit_message_text(_["gstats_8"])
+ sc = platform.system()
+ p_core = psutil.cpu_count(logical=False)
+ t_core = psutil.cpu_count(logical=True)
+ ram = (
+ str(round(psutil.virtual_memory().total / (1024.0**3)))
+ + " GB"
+ )
+ try:
+ cpu_freq = psutil.cpu_freq().current
+ if cpu_freq >= 1000:
+ cpu_freq = f"{round(cpu_freq / 1000, 2)}GHz"
+ else:
+ cpu_freq = f"{round(cpu_freq, 2)}MHz"
+ except:
+ cpu_freq = "Unable to Fetch"
+ hdd = psutil.disk_usage("/")
+ total = hdd.total / (1024.0**3)
+ total = str(total)
+ used = hdd.used / (1024.0**3)
+ used = str(used)
+ free = hdd.free / (1024.0**3)
+ free = str(free)
+ mod = len(ALL_MODULES)
+ db = pymongodb
+ call = db.command("dbstats")
+ datasize = call["dataSize"] / 1024
+ datasize = str(datasize)
+ storage = call["storageSize"] / 1024
+ objects = call["objects"]
+ collections = call["collections"]
+ status = db.command("serverStatus")
+ query = status["opcounters"]["query"]
+ mongouptime = status["uptime"] / 86400
+ mongouptime = str(mongouptime)
+ served_chats = len(await get_served_chats())
+ served_users = len(await get_served_users())
+ total_queries = await get_queries()
+ blocked = len(BANNED_USERS)
+ sudoers = len(await get_sudoers())
+ text = f""" **Bot's Stats and Information:**
+
+**Imported Modules:** {mod}
+**Platform:** {sc}
+**Ram:** {ram}
+**Physical Cores:** {p_core}
+**Total Cores:** {t_core}
+**Cpu Frequency:** {cpu_freq}
+
+**Python Version :** {pyver.split()[0]}
+**Pyrogram Version :** {pyrover}
+**Py-TgCalls Version :** {pytgver}
+
+**Storage Avail:** {total[:4]} GiB
+**Storage Used:** {used[:4]} GiB
+**Storage Left:** {free[:4]} GiB
+
+**Served Chats:** {served_chats}
+**Served Users:** {served_users}
+**Blocked Users:** {blocked}
+**Sudo Users:** {sudoers}
+
+**Mongo Uptime:** {mongouptime[:4]} Days
+**Total DB Size:** {datasize[:6]} Mb
+**Total DB Storage:** {storage} Mb
+**Total DB Collections:** {collections}
+**Total DB Keys:** {objects}
+**Total DB Queries:** `{query}`
+**Total Bot Queries:** `{total_queries} `
+ """
+ med = InputMediaPhoto(media=config.STATS_IMG_URL, caption=text)
+ try:
+ await CallbackQuery.edit_message_media(
+ media=med, reply_markup=upl
+ )
+ except MessageIdInvalid:
+ await CallbackQuery.message.reply_photo(
+ photo=config.STATS_IMG_URL, caption=text, reply_markup=upl
+ )
+
+
+@app.on_callback_query(
+ filters.regex(pattern=r"^(TOPMARKUPGET|GETSTATS|GlobalStats)$")
+ & ~BANNED_USERS
+)
+@languageCB
+async def back_buttons(client, CallbackQuery, _):
+ try:
+ await CallbackQuery.answer()
+ except:
+ pass
+ command = CallbackQuery.matches[0].group(1)
+ if command == "TOPMARKUPGET":
+ upl = top_ten_stats_markup(_)
+ med = InputMediaPhoto(
+ media=config.GLOBAL_IMG_URL,
+ caption=_["gstats_9"],
+ )
+ try:
+ await CallbackQuery.edit_message_media(
+ media=med, reply_markup=upl
+ )
+ except MessageIdInvalid:
+ await CallbackQuery.message.reply_photo(
+ photo=config.GLOBAL_IMG_URL,
+ caption=_["gstats_9"],
+ reply_markup=upl,
+ )
+ if command == "GlobalStats":
+ upl = get_stats_markup(
+ _,
+ True if CallbackQuery.from_user.id in SUDOERS else False,
+ )
+ med = InputMediaPhoto(
+ media=config.GLOBAL_IMG_URL,
+ caption=_["gstats_10"].format(config.MUSIC_BOT_NAME),
+ )
+ try:
+ await CallbackQuery.edit_message_media(
+ media=med, reply_markup=upl
+ )
+ except MessageIdInvalid:
+ await CallbackQuery.message.reply_photo(
+ photo=config.GLOBAL_IMG_URL,
+ caption=_["gstats_10"].format(config.MUSIC_BOT_NAME),
+ reply_markup=upl,
+ )
+ if command == "GETSTATS":
+ upl = stats_buttons(
+ _,
+ True if CallbackQuery.from_user.id in SUDOERS else False,
+ )
+ med = InputMediaPhoto(
+ media=config.STATS_IMG_URL,
+ caption=_["gstats_11"].format(config.MUSIC_BOT_NAME),
+ )
+ try:
+ await CallbackQuery.edit_message_media(
+ media=med, reply_markup=upl
+ )
+ except MessageIdInvalid:
+ await CallbackQuery.message.reply_photo(
+ photo=config.STATS_IMG_URL,
+ caption=_["gstats_11"].format(config.MUSIC_BOT_NAME),
+ reply_markup=upl,
+ )
diff --git a/YukkiMusic/server/__init__.py b/YukkiMusic/server/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9603cece66d735bcea0da0115c66e231c4735691
--- /dev/null
+++ b/YukkiMusic/server/__init__.py
@@ -0,0 +1,21 @@
+from aiohttp import web
+#from .routes_main import routes
+#from .routes_api import api
+
+from YukkiMusic.platforms.file_properties import get_file_info,get_name
+
+#from YukkiMusic.server.routes_api import fetch_youtube
+from YukkiMusic.server.routes_TGFileAPI import TGFILEAPI
+from YukkiMusic.server.routes_appV2 import sub_appV2
+
+async def root_route_handler(request):
+ return web.json_response({"status": "alive", "message": "Server is running"})
+
+def web_server():
+ web_app = web.Application(client_max_size=50)
+ web_app.router.add_get('/', root_route_handler)
+ web_app.add_subapp('/dl', TGFILEAPI)
+ web_app['TGFILEAPI'] = TGFILEAPI
+ web_app.add_subapp('/appV2', sub_appV2)
+ web_app['sub_appV2'] = sub_appV2
+ return web_app
\ No newline at end of file
diff --git a/YukkiMusic/server/__main__.py b/YukkiMusic/server/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/YukkiMusic/server/routes_TGFileAPI.py b/YukkiMusic/server/routes_TGFileAPI.py
new file mode 100644
index 0000000000000000000000000000000000000000..f60a7f65ef7b706903acbc0ce438bfa93c8cab0d
--- /dev/null
+++ b/YukkiMusic/server/routes_TGFileAPI.py
@@ -0,0 +1,119 @@
+
+import traceback
+import math
+from aiohttp import web
+import config
+from pyrogram.file_id import FileId
+from aiohttp.http_exceptions import BadStatusLine
+
+
+from YukkiMusic import app, userbot
+from YukkiMusic.core.bot import YukkiBot
+from YukkiMusic.core.userbot import multi_clients, req_client
+from YukkiMusic.platforms.custom_dl import ByteStreamer
+
+
+
+
+class InvalidHash(Exception):
+ message = "Invalid hash"
+
+class FIleNotFound(Exception):
+ message = "File not found"
+
+
+
+class_cache={}
+async def media_streamer(request: web.Request, db_id: str):
+ range_header = request.headers.get("Range", 0)
+
+ #index = min(work_loads, key=work_loads.get)
+ #faster_client = multi_clients[index]
+ client=app
+ #client = await req_client()
+ #get_me = await app.get_me()
+ #print(db_id,int(config.LOG_GROUP_ID),get_me)
+ msg = await client.get_messages(int(config.LOG_GROUP_ID),int(db_id))
+
+ #print(msg)
+ #tg_connect = ByteStreamer(client['client'])
+ tg_connect = ByteStreamer(client)
+ #class_cache[client['client']] = tg_connect
+ #logging.debug("before calling get_file_properties")
+ file_info = get_file_info(msg)
+ #file_i = file_info['file']['file_id']
+ file_id = FileId.decode(file_info['file']['file_id'])
+ #print(file_id)
+ #logging.debug("after calling get_file_properties")
+
+ file_size = file_info['file']['file_size']
+
+ if range_header:
+ from_bytes, until_bytes = range_header.replace("bytes=", "").split("-")
+ from_bytes = int(from_bytes)
+ until_bytes = int(until_bytes) if until_bytes else file_size - 1
+ else:
+ from_bytes = request.http_range.start or 0
+ until_bytes = (request.http_range.stop or file_size) - 1
+
+ if (until_bytes > file_size) or (from_bytes < 0) or (until_bytes
+ < from_bytes):
+ return web.Response(
+ status=416,
+ body="416: Range not satisfiable",
+ headers={"Content-Range": f"bytes */{file_size}"},
+ )
+
+ chunk_size = 512 * 1024
+ until_bytes = min(until_bytes, file_size - 1)
+
+ offset = from_bytes - (from_bytes % chunk_size)
+ first_part_cut = from_bytes - offset
+ last_part_cut = until_bytes % chunk_size + 1
+
+ req_length = until_bytes - from_bytes + 1
+ part_count = math.ceil(until_bytes / chunk_size) - math.floor(
+ offset / chunk_size)
+ body = tg_connect.yield_file(file_id, client, offset, first_part_cut,
+ last_part_cut, part_count, chunk_size)
+
+ mime_type = file_info['file']['mime_type']
+ file_name = get_name(msg)
+ disposition = "attachment"
+
+ # if "video/" in mime_type or "audio/" in mime_type:
+ # disposition = "inline"
+
+ return web.Response(
+ status=206 if range_header else 200,
+ body=body,
+ headers={
+ "Content-Type": f"{mime_type}",
+ "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
+ "Content-Length": str(req_length),
+ "Content-Disposition": f'{disposition}; filename="{file_name}"',
+ "Accept-Ranges": "bytes",
+ },
+ )
+
+
+async def stream_handler(request: web.Request):
+ try:
+ path = request.match_info["path"]
+ return await media_streamer(request, path)
+ except InvalidHash as e:
+ raise web.HTTPForbidden(text=e.message)
+ except FIleNotFound as e:
+ raise web.HTTPNotFound(text=e.message)
+ except (AttributeError, BadStatusLine, ConnectionResetError):
+ pass
+ except Exception as e:
+ traceback.print_exc()
+ #logging.critical(e.with_traceback(None))
+ #logging.debug(traceback.format_exc())
+ raise web.HTTPInternalServerError(text=str(e))
+
+
+TGFILEAPI = web.Application()
+
+TGFILEAPI.router.add_get('/{path}', stream_handler)
diff --git a/YukkiMusic/server/routes_appV2.py b/YukkiMusic/server/routes_appV2.py
new file mode 100644
index 0000000000000000000000000000000000000000..c958755a907101393f44e6a1b5098f75467fd7f6
--- /dev/null
+++ b/YukkiMusic/server/routes_appV2.py
@@ -0,0 +1,195 @@
+
+import json
+import jinja2
+import argparse
+import urllib.parse
+import aiohttp_jinja2
+from typing import Any, Dict
+from aiohttp import web, ClientSession
+from aiohttp.http_exceptions import BadStatusLine
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+
+from YukkiMusic.platforms.YoutubeAPI.InnertubeAPI import trending_with_post_api
+from YukkiMusic.platforms.YoutubeAPI.BS4scrapAPI import tranding_videos,search_videos
+from YukkiMusic.platforms.YoutubeAPI.InnertubeAPI import search_videos_with_post_api,search_scroll_videos_with_post_api
+
+session = ClientSession()
+#from YukkiMusic.alive import web_server
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--q', help='Search term', default='Google')
+parser.add_argument('--max-results', help='Max results', default=25)
+args = parser.parse_args()
+
+# Set DEVELOPER_KEY to the API key value from the APIs & auth > Registered apps
+# tab of
+# https://cloud.google.com/console
+# Please ensure that you have enabled the YouTube Data API for your project.
+def url_find(route_name, *args, **kwargs):
+ # Check if route belongs to sub-application
+ if route_name.startswith('subapp_'):
+ route_name = route_name[len('subapp_'):]
+ return str(sub_app.router[route_name])
+ # Otherwise, it belongs to the main application
+ return str('/')
+
+async def handle_v2(request):
+ return web.Response(text="Hello from app v2!")
+
+async def nextPage(request):
+ query = request.query.get('q', '').lower()
+ DEVELOPER_KEY = 'AIzaSyAJB2yzah87l58QCNUFrYOrzu_5I7RFQZY'
+ YOUTUBE_API_SERVICE_NAME = 'youtube'
+ YOUTUBE_API_VERSION = 'v3'
+
+
+ youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
+ developerKey=DEVELOPER_KEY)
+
+ # Call the search.list method to retrieve results matching the specified
+ # query term.
+ if request.query.get('pageToken', ''):
+ search_response = youtube.search().list(
+ q=query,
+ part='id,snippet',
+ pageToken=request.query.get('pageToken', ''),
+ maxResults=args.max_results
+ ).execute()
+ else:
+ search_response = youtube.search().list(
+ q=query,
+ part='id,snippet',
+ maxResults=args.max_results
+ ).execute()
+
+ #search_response=""
+ videos = []
+ channels = []
+ playlists = []
+
+ # Add each result to the appropriate list, and then display the lists of
+ # matching videos, channels, and playlists.
+ #search_result['snippet']['title'],
+ #search_result['id']['videoId']
+ for search_result in search_response.get('items', []):
+ if search_result['id']['kind'] == 'youtube#video':
+ videos.append(search_result)
+ elif search_result['id']['kind'] == 'youtube#channel':
+ channels.append('%s (%s)' % (search_result['snippet']['title'],
+ search_result['id']['channelId']))
+ elif search_result['id']['kind'] == 'youtube#playlist':
+ playlists.append('%s (%s)' % (search_result['snippet']['title'],
+ search_result['id']['playlistId']))
+ #print(videos)
+ data=str({'page':'search','data':videos,'nextPageToken':search_response.get('nextPageToken','')})
+
+
+ return web.Response(text=data)
+
+async def searchquery(request):
+ query = request.query.get('q', '').lower()
+ async with session.get(f'https://cors-handlers.vercel.app/api/?url=http%3A%2F%2Fsuggestqueries.google.com%2Fcomplete%2Fsearch%3Fclient%3Dfirefox%26ds%3Dyt%26q={query}') as resp:
+ data=await resp.text()
+ #print(data)
+ return web.Response(text=data)
+
+
+async def testAPI(request):
+ #query = request.query.get('q', '').lower()
+
+ resp = await trending_with_post_api("Now")
+ print(resp)
+ return resp
+
+
+#@sub_app.get("/up", allow_head=True)
+@aiohttp_jinja2.template("index.html")
+async def Index_page(request: web.Request) -> Dict[str, Any]:
+
+ return {'page':'main'}
+
+@aiohttp_jinja2.template("index.html")
+async def Home_Component(request: web.Request):
+
+ query = "now" if request.query.get('q', '') == "" else request.query.get('q', '')
+
+ videos = await trending_with_post_api(query)
+ # html_content = f"""
+ # Content for the Home page goes here.
+ #Content for the Home page goes here.{{page}}
+ +Content for the Home page goes here.{{page}}
+ +