Delete HellBot

HellBot/__init__.py

@@ -1,60 +0,0 @@
-import os
-import time
-from platform import python_version
-
-import heroku3
-from pyrogram import __version__ as pyrogram_version
-
-from .core import LOGS, Config
-
-START_TIME = time.time()
-
-
-__version__ = {
-    "hellbot": "3.0",
-    "pyrogram": pyrogram_version,
-    "python": python_version(),
-}
-
-
-try:
-    if Config.HEROKU_APIKEY is not None and Config.HEROKU_APPNAME is not None:
-        HEROKU_APP = heroku3.from_key(Config.HEROKU_APIKEY).apps()[
-            Config.HEROKU_APPNAME
-        ]
-    else:
-        HEROKU_APP = None
-except Exception as e:
-    LOGS.error(f"Heroku Api - {e}")
-    HEROKU_APP = None
-
-
-if Config.API_HASH is None:
-    LOGS.error("Please set your API_HASH !")
-    quit(1)
-
-if Config.API_ID == 0:
-    LOGS.error("Please set your API_ID !")
-    quit(1)
-
-if Config.BOT_TOKEN is None:
-    LOGS.error("Please set your BOT_TOKEN !")
-    quit(1)
-
-if Config.DATABASE_URL is None:
-    LOGS.error("Please set your DATABASE_URL !")
-    quit(1)
-
-if Config.LOGGER_ID == 0:
-    LOGS.error("Please set your LOGGER_ID !")
-    quit(1)
-
-if Config.OWNER_ID == 0:
-    LOGS.error("Please set your OWNER_ID !")
-    quit(1)
-
-if not os.path.isdir(Config.DWL_DIR):
-    os.makedirs(Config.DWL_DIR)
-
-if not os.path.isdir(Config.TEMP_DIR):
-    os.makedirs(Config.TEMP_DIR)

HellBot/__main__.py

@@ -1,33 +0,0 @@
-from pyrogram import idle
-
-from Hellbot import __version__
-from Hellbot.core import (
-    Config,
-    ForcesubSetup,
-    GachaBotsSetup,
-    TemplateSetup,
-    UserSetup,
-    db,
-    hellbot,
-)
-from Hellbot.functions.tools import initialize_git
-from Hellbot.functions.utility import BList, Flood, TGraph
-
-
-async def main():
-    await hellbot.startup()
-    await db.connect()
-    await UserSetup()
-    await ForcesubSetup()
-    await GachaBotsSetup()
-    await TemplateSetup()
-    await Flood.updateFromDB()
-    await BList.updateBlacklists()
-    await TGraph.setup()
-    await initialize_git(Config.PLUGINS_REPO)
-    await hellbot.start_message(__version__)
-    await idle()
-
-
-if __name__ == "__main__":
-    hellbot.run(main())

HellBot/core/__init__.py

@@ -1,19 +0,0 @@
-from .clients import hellbot
-from .config import ENV, Config, Limits, Symbols
-from .database import db
-from .initializer import ForcesubSetup, GachaBotsSetup, TemplateSetup, UserSetup
-from .logger import LOGS
-
-__all__ = [
-    "hellbot",
-    "ENV",
-    "Config",
-    "Limits",
-    "Symbols",
-    "db",
-    "ForcesubSetup",
-    "GachaBotsSetup",
-    "TemplateSetup",
-    "UserSetup",
-    "LOGS",
-]

HellBot/core/clients.py

@@ -1,232 +0,0 @@
-import asyncio
-import glob
-import importlib
-import os
-import sys
-from pathlib import Path
-
-import pyroaddon  # pylint: disable=unused-import
-from pyrogram import Client
-from pyrogram.enums import ParseMode
-from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
-
-from .config import ENV, Config, Symbols
-from .database import db
-from .logger import LOGS
-
-
-class HellClient(Client):
-    def __init__(self) -> None:
-        self.users: list[Client] = []
-        self.bot: Client = Client(
-            name="HellBot",
-            api_id=Config.API_ID,
-            api_hash=Config.API_HASH,
-            bot_token=Config.BOT_TOKEN,
-            plugins=dict(root="Hellbot.plugins.bot"),
-        )
-
-    async def start_user(self) -> None:
-        sessions = await db.get_all_sessions()
-        for i, session in enumerate(sessions):
-            try:
-                client = Client(
-                    name=f"HellUser#{i + 1}",
-                    api_id=Config.API_ID,
-                    api_hash=Config.API_HASH,
-                    session_string=session["session"],
-                )
-                await client.start()
-                me = await client.get_me()
-                self.users.append(client)
-                LOGS.info(
-                    f"{Symbols.arrow_right * 2} Started User {i + 1}: '{me.first_name}' {Symbols.arrow_left * 2}"
-                )
-                is_in_logger = await self.validate_logger(client)
-                if not is_in_logger:
-                    LOGS.warning(
-                        f"Client #{i+1}: '{me.first_name}' is not in Logger Group! Check and add manually for proper functioning."
-                    )
-                try:
-                    await client.join_chat("https://t.me/+wQyUMn4891Q2OTVh")    # Channel
-                except:
-                    pass
-                # try:
-                #     await client.join_chat("https://t.me/+P4Ekwk7P7Rk3NzA9")  # Group
-                # except:
-                #     pass
-            except Exception as e:
-                LOGS.error(f"{i + 1}: {e}")
-                continue
-
-    async def start_bot(self) -> None:
-        await self.bot.start()
-        me = await self.bot.get_me()
-        LOGS.info(
-            f"{Symbols.arrow_right * 2} Started HellBot Client: '{me.username}' {Symbols.arrow_left * 2}"
-        )
-
-    async def load_plugin(self) -> None:
-        count = 0
-        files = glob.glob("Hellbot/plugins/user/*.py")
-        unload = await db.get_env(ENV.unload_plugins) or ""
-        unload = unload.split(" ")
-        for file in files:
-            with open(file) as f:
-                path = Path(f.name)
-                shortname = path.stem.replace(".py", "")
-                if shortname in unload:
-                    os.remove(Path(f"Hellbot/plugins/user/{shortname}.py"))
-                    continue
-                if shortname.startswith("__"):
-                    continue
-                fpath = Path(f"Hellbot/plugins/user/{shortname}.py")
-                name = "Hellbot.plugins.user." + shortname
-                spec = importlib.util.spec_from_file_location(name, fpath)
-                load = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(load)
-                sys.modules["Hellbot.plugins.user." + shortname] = load
-                count += 1
-            f.close()
-        LOGS.info(
-            f"{Symbols.bullet * 3} Loaded User Plugin: '{count}' {Symbols.bullet * 3}"
-        )
-
-    async def validate_logger(self, client: Client) -> bool:
-        try:
-            await client.get_chat_member(Config.LOGGER_ID, "me")
-            return True
-        except Exception:
-            return await self.join_logger(client)
-
-    async def join_logger(self, client: Client) -> bool:
-        try:
-            invite_link = await self.bot.export_chat_invite_link(Config.LOGGER_ID)
-            await client.join_chat(invite_link)
-            return True
-        except Exception:
-            return False
-
-    async def start_message(self, version: dict) -> None:
-        await self.bot.send_animation(
-            Config.LOGGER_ID,
-            "https://te.legra.ph/file/8deca5343c64d9db9401f.mp4",
-            f"**{Symbols.check_mark} 𝖧𝖾𝗅𝗅𝖡𝗈𝗍 𝗂𝗌 𝗇𝗈𝗐 𝖮𝗇𝗅𝗂𝗇𝖾!**\n\n"
-            f"**{Symbols.triangle_right} 𝖢𝗅𝗂𝖾𝗇𝗍𝗌:** `{len(self.users)}`\n"
-            f"**{Symbols.triangle_right} 𝖯𝗅𝗎𝗀𝗂𝗇𝗌:** `{len(Config.CMD_MENU)}`\n"
-            f"**{Symbols.triangle_right} 𝖢𝗈𝗆𝗆𝖺𝗇𝖽𝗌:** `{len(Config.CMD_INFO)}`\n"
-            f"**{Symbols.triangle_right} 𝖲𝗍𝖺𝗇 𝖴𝗌𝖾𝗋𝗌:** `{len(Config.STAN_USERS)}`\n"
-            f"**{Symbols.triangle_right} 𝖠𝗎𝗍𝗁 𝖴𝗌𝖾𝗋𝗌:** `{len(Config.AUTH_USERS)}`\n\n"
-            f"**{Symbols.triangle_right} 𝖧𝖾𝗅𝗅𝖡𝗈𝗍 𝖵𝖾𝗋𝗌𝗂𝗈𝗇:** `{version['hellbot']}`\n"
-            f"**{Symbols.triangle_right} 𝖯𝗒𝗋𝗈𝗀𝗋𝖺𝗆 𝖵𝖾𝗋𝗌𝗂𝗈𝗇:** `{version['pyrogram']}`\n"
-            f"**{Symbols.triangle_right} 𝖯𝗒𝗍𝗁𝗈𝗇 𝖵𝖾𝗋𝗌𝗂𝗈𝗇:** `{version['python']}`\n\n"
-            f"**</> @HellBot_Networks**",
-            parse_mode=ParseMode.MARKDOWN,
-            disable_notification=True,
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton("💫 Start Me", url=f"https://t.me/{self.bot.me.username}?start=start"),
-                        InlineKeyboardButton("💖 Repo", url="https://github.com/The-HellBot/HellBot"),
-                    ],
-                    [
-                        InlineKeyboardButton("🍀 HellBot Networks 🍀", url="https://t.me/hellbot_networks"),
-                    ],
-                ]
-            ),
-        )
-
-    async def startup(self) -> None:
-        LOGS.info(
-            f"{Symbols.bullet * 3} Starting HellBot Client & User {Symbols.bullet * 3}"
-        )
-        await self.start_bot()
-        await self.start_user()
-        await self.load_plugin()
-
-
-class CustomMethods(HellClient):
-    async def input(self, message: Message) -> str:
-        """Get the input from the user"""
-        if len(message.command) < 2:
-            output = ""
-
-        else:
-            try:
-                output = message.text.split(" ", 1)[1].strip() or ""
-            except IndexError:
-                output = ""
-
-        return output
-
-    async def edit(
-        self,
-        message: Message,
-        text: str,
-        parse_mode: ParseMode = ParseMode.DEFAULT,
-        no_link_preview: bool = True,
-    ) -> Message:
-        """Edit or Reply to a message, if possible"""
-        if message.from_user and message.from_user.id in Config.STAN_USERS:
-            if message.reply_to_message:
-                return await message.reply_to_message.reply_text(
-                    text,
-                    parse_mode=parse_mode,
-                    disable_web_page_preview=no_link_preview,
-                )
-            return await message.reply_text(
-                text, parse_mode=parse_mode, disable_web_page_preview=no_link_preview
-            )
-        return await message.edit_text(
-            text, parse_mode=parse_mode, disable_web_page_preview=no_link_preview
-        )
-
-    async def _delete(self, message: Message, delay: int = 0) -> None:
-        """Delete a message after a certain period of time"""
-        await asyncio.sleep(delay)
-        await message.delete()
-
-    async def delete(
-        self, message: Message, text: str, delete: int = 10, in_background: bool = True
-    ) -> None:
-        """Edit a message and delete it after a certain period of time"""
-        to_del = await self.edit(message, text)
-        if in_background:
-            asyncio.create_task(self._delete(to_del, delete))
-        else:
-            await self._delete(to_del, delete)
-
-    async def error(self, message: Message, text: str, delete: int = 10) -> None:
-        """Edit an error message and delete it after a certain period of time if mentioned"""
-        to_del = await self.edit(message, f"{Symbols.cross_mark} **Error:** \n\n{text}")
-        if delete:
-            asyncio.create_task(self._delete(to_del, delete))
-
-    async def _log(self, tag: str, text: str, file: str = None) -> None:
-        """Log a message to the Logger Group"""
-        msg = f"**#{tag.upper()}**\n\n{text}"
-        try:
-            if file:
-                try:
-                    await self.bot.send_document(Config.LOGGER_ID, file, caption=msg)
-                except:
-                    await self.bot.send_message(
-                        Config.LOGGER_ID, msg, disable_web_page_preview=True
-                    )
-            else:
-                await self.bot.send_message(
-                    Config.LOGGER_ID, msg, disable_web_page_preview=True
-                )
-        except Exception as e:
-            raise Exception(f"{Symbols.cross_mark} LogErr: {e}")
-
-    async def check_and_log(self, tag: str, text: str, file: str = None) -> None:
-        """Check if :
-        \n-> the Logger Group is available
-        \n-> the logging is enabled"""
-        status = await db.get_env(ENV.is_logger)
-        if status and status.lower() == "true":
-            await self._log(tag, text, file)
-
-
-hellbot = CustomMethods()

HellBot/core/config.py

@@ -1,155 +0,0 @@
-from os import getenv
-
-from dotenv import load_dotenv
-from pyrogram import filters
-
-load_dotenv()
-
-
-class Config:
-    # editable configs
-    API_HASH = getenv("API_HASH", None)
-    API_ID = int(getenv("API_ID", 0))
-    BOT_TOKEN = getenv("BOT_TOKEN", None)
-    DATABASE_URL = getenv("DATABASE_URL", None)
-    HANDLERS = getenv("HANDLERS", ". ! ?").strip().split()
-    LOGGER_ID = int(getenv("LOGGER_ID", 0))
-    OWNER_ID = int(getenv("OWNER_ID", 0))
-
-    # heroku related configs
-    HEROKU_APPNAME = getenv("HEROKU_APPNAME", None)
-    HEROKU_APIKEY = getenv("HEROKU_APIKEY", None)
-
-    # github related configs
-    PLUGINS_REPO = getenv("PLUGINS_REPO", "The-HellBot/Plugins")
-    DEPLOY_REPO = getenv("DEPLOY_REPO", "The-HellBot/Hellbot")
-
-    # storage dir: you may or may not edit
-    DWL_DIR = "./downloads/"
-    TEMP_DIR = "./temp/"
-    CHROME_BIN = getenv("CHROME_BIN", "/app/.chrome-for-testing/chrome-linux64/chrome")
-    CHROME_DRIVER = getenv(
-        "CHROME_DRIVER", "/app/.chrome-for-testing/chromedriver-linux64/chromedriver"
-    )
-    FONT_PATH = "./Hellbot/resources/fonts/Montserrat.ttf"
-
-    # users config: do not edit
-    AUTH_USERS = filters.user()
-    BANNED_USERS = filters.user()
-    GACHA_BOTS = filters.user()
-    MUTED_USERS = filters.user()
-    DEVS = filters.user([1432756163, 1874070588, 1533682758])
-    STAN_USERS = filters.user()
-    FORCESUBS = filters.chat()
-
-    # Global config: do not edit
-    AFK_CACHE = {}
-    BOT_CMD_INFO = {}
-    BOT_CMD_MENU = {}
-    BOT_HELP = {}
-    CMD_INFO = {}
-    CMD_MENU = {}
-    HELP_DICT = {}
-    TEMPLATES = {}
-
-
-class ENV:
-    """Database ENV Names"""
-
-    airing_template = "AIRING_TEMPLATE"
-    airpollution_template = "AIRPOLLUTION_TEMPLATE"
-    alive_pic = "ALIVE_PIC"
-    alive_template = "ALIVE_TEMPLATE"
-    anilist_user_template = "ANILIST_USER_TEMPLATE"
-    anime_template = "ANIME_TEMPLATE"
-    btn_in_help = "BUTTONS_IN_HELP"
-    character_template = "CHARACTER_TEMPLATE"
-    chat_info_template = "CHAT_INFO_TEMPLATE"
-    climate_api = "CLIMATE_API"
-    climate_template = "CLIMATE_TEMPLATE"
-    command_template = "COMMAND_TEMPLATE"
-    currency_api = "CURRENCY_API"
-    custom_pmpermit = "CUSTOM_PMPERMIT"
-    gban_template = "GBAN_TEMPLATE"
-    github_user_template = "GITHUB_USER_TEMPLATE"
-    help_emoji = "HELP_EMOJI"
-    help_template = "HELP_TEMPLATE"
-    is_logger = "IS_LOGGER"
-    lyrics_api = "LYRICS_API"
-    manga_template = "MANGA_TEMPLATE"
-    ocr_api = "OCR_API"
-    ping_pic = "PING_PIC"
-    ping_template = "PING_TEMPLATE"
-    pm_logger = "PM_LOGGER"
-    pm_max_spam = "PM_MAX_SPAM"
-    pmpermit = "PMPERMIT"
-    pmpermit_pic = "PMPERMIT_PIC"
-    remove_bg_api = "REMOVE_BG_API"
-    thumbnail_url = "THUMBNAIL_URL"
-    statistics_template = "STATISTICS_TEMPLATE"
-    sticker_packname = "STICKER_PACKNAME"
-    tag_logger = "TAG_LOGGER"
-    telegraph_account = "TELEGRAPH_ACCOUNT"
-    time_zone = "TIME_ZONE"
-    unload_plugins = "UNLOAD_PLUGINS"
-    unsplash_api = "UNSPLASH_API"
-    usage_template = "USAGE_TEMPLATE"
-    user_info_template = "USER_INFO_TEMPLATE"
-
-
-class Limits:
-    AdminRoleLength = 16
-    AdminsLimit = 50
-    BioLength = 70
-    BotDescriptionLength = 512
-    BotInfoLength = 120
-    BotsLimit = 20
-    CaptionLength = 1024
-    ChannelGroupsLimit = 500
-    ChatTitleLength = 128
-    FileNameLength = 60
-    MessageLength = 4096
-    NameLength = 64
-    PremiumBioLength = 140
-    PremiumCaptionLength = 2048
-    PremiumChannelGroupsLimit = 1000
-    StickerAniamtedLimit = 50
-    StickerPackNameLength = 64
-    StickerStaticLimit = 120
-
-
-class Symbols:
-    anchor = "⚘"
-    arrow_left = "«"
-    arrow_right = "»"
-    back = "🔙 back"
-    bullet = "•"
-    check_mark = "✔"
-    close = "🗑️"
-    cross_mark = "✘"
-    diamond_1 = "◇"
-    diamond_2 = "◈"
-    next = "⤚ next"
-    previous = "prev ⤙"
-    radio_select = "◉"
-    radio_unselect = "〇"
-    triangle_left = "◂"
-    triangle_right = "▸"
-
-
-os_configs = [
-    "API_HASH",
-    "API_ID",
-    "BOT_TOKEN",
-    "DATABASE_URL",
-    "DEPLOY_REPO",
-    "HANDLERS",
-    "HEROKU_APIKEY",
-    "HEROKU_APPNAME",
-    "LOGGER_ID",
-    "OWNER_ID",
-    "PLUGINS_REPO",
-]
-all_env: list[str] = [
-    value for key, value in ENV.__dict__.items() if not key.startswith("__")
-]

HellBot/core/database.py

@@ -1,584 +0,0 @@
-import datetime
-import time
-
-from motor import motor_asyncio
-from motor.core import AgnosticClient
-
-from .config import Config, Symbols
-from .logger import LOGS
-
-
-class Database:
-    def __init__(self, uri: str) -> None:
-        self.client: AgnosticClient = motor_asyncio.AsyncIOMotorClient(uri)
-        self.db = self.client["Hellbot"]
-
-        self.afk = self.db["afk"]
-        self.antiflood = self.db["antiflood"]
-        self.autopost = self.db["autopost"]
-        self.blacklist = self.db["blacklist"]
-        self.echo = self.db["echo"]
-        self.env = self.db["env"]
-        self.filter = self.db["filter"]
-        self.forcesub = self.db["forcesub"]
-        self.gachabots = self.db["gachabots"]
-        self.gban = self.db["gban"]
-        self.gmute = self.db["gmute"]
-        self.greetings = self.db["greetings"]
-        self.mute = self.db["mute"]
-        self.pmpermit = self.db["pmpermit"]
-        self.session = self.db["session"]
-        self.snips = self.db["snips"]
-        self.stan_users = self.db["stan_users"]
-
-    async def connect(self):
-        try:
-            await self.client.admin.command("ping")
-            LOGS.info(
-                f"{Symbols.bullet * 3} Database Connection Established! {Symbols.bullet * 3}"
-            )
-        except Exception as e:
-            LOGS.info(f"{Symbols.cross_mark} DatabaseErr: {e} ")
-            quit(1)
-
-    def get_datetime(self) -> str:
-        return datetime.datetime.now().strftime("%d/%m/%Y - %H:%M")
-
-    async def set_env(self, name: str, value: str) -> None:
-        await self.env.update_one(
-            {"name": name}, {"$set": {"value": value}}, upsert=True
-        )
-
-    async def get_env(self, name: str) -> str | None:
-        if await self.is_env(name):
-            data = await self.env.find_one({"name": name})
-            return data["value"]
-        return None
-
-    async def rm_env(self, name: str) -> None:
-        await self.env.delete_one({"name": name})
-
-    async def is_env(self, name: str) -> bool:
-        if await self.env.find_one({"name": name}):
-            return True
-        return False
-
-    async def get_all_env(self) -> list:
-        return [i async for i in self.env.find({})]
-
-    async def is_stan(self, client: int, user_id: int) -> bool:
-        if await self.stan_users.find_one({"client": client, "user_id": user_id}):
-            return True
-        return False
-
-    async def add_stan(self, client: int, user_id: int) -> bool:
-        if await self.is_stan(client, user_id):
-            return False
-        await self.stan_users.insert_one(
-            {"client": client, "user_id": user_id, "date": self.get_datetime()}
-        )
-        return True
-
-    async def rm_stan(self, client: int, user_id: int) -> bool:
-        if not await self.is_stan(client, user_id):
-            return False
-        await self.stan_users.delete_one({"client": client, "user_id": user_id})
-        return True
-
-    async def get_stans(self, client: int) -> list:
-        return [i async for i in self.stan_users.find({"client": client})]
-
-    async def get_all_stans(self) -> list:
-        return [i async for i in self.stan_users.find({})]
-
-    async def is_session(self, user_id: int) -> bool:
-        if await self.session.find_one({"user_id": user_id}):
-            return True
-        return False
-
-    async def update_session(self, user_id: int, session: str) -> None:
-        await self.session.update_one(
-            {"user_id": user_id},
-            {"$set": {"session": session, "date": self.get_datetime()}},
-            upsert=True,
-        )
-
-    async def rm_session(self, user_id: int) -> None:
-        await self.session.delete_one({"user_id": user_id})
-
-    async def get_session(self, user_id: int):
-        if not await self.is_session(user_id):
-            return False
-        data = await self.session.find_one({"user_id": user_id})
-        return data
-
-    async def get_all_sessions(self) -> list:
-        return [i async for i in self.session.find({})]
-
-    async def is_gbanned(self, user_id: int) -> bool:
-        if await self.gban.find_one({"user_id": user_id}):
-            return True
-        return False
-
-    async def add_gban(self, user_id: int, reason: str) -> bool:
-        if await self.is_gbanned(user_id):
-            return False
-        await self.gban.insert_one(
-            {"user_id": user_id, "reason": reason, "date": self.get_datetime()}
-        )
-        return True
-
-    async def rm_gban(self, user_id: int):
-        if not await self.is_gbanned(user_id):
-            return None
-        reason = (await self.gban.find_one({"user_id": user_id}))["reason"]
-        await self.gban.delete_one({"user_id": user_id})
-        return reason
-
-    async def get_gban(self) -> list:
-        return [i async for i in self.gban.find({})]
-
-    async def get_gban_user(self, user_id: int) -> dict | None:
-        if not await self.is_gbanned(user_id):
-            return None
-        return await self.gban.find_one({"user_id": user_id})
-
-    async def is_gmuted(self, user_id: int) -> bool:
-        if await self.gmute.find_one({"user_id": user_id}):
-            return True
-        return False
-
-    async def add_gmute(self, user_id: int, reason: str) -> bool:
-        if await self.is_gmuted(user_id):
-            return False
-        await self.gmute.insert_one(
-            {"user_id": user_id, "reason": reason, "date": self.get_datetime()}
-        )
-        return True
-
-    async def rm_gmute(self, user_id: int):
-        if not await self.is_gmuted(user_id):
-            return None
-        reason = (await self.gmute.find_one({"user_id": user_id}))["reason"]
-        await self.gmute.delete_one({"user_id": user_id})
-        return reason
-
-    async def get_gmute(self) -> list:
-        return [i async for i in self.gmute.find({})]
-
-    async def add_mute(self, client: int, user_id: int, chat_id: int, reason: str):
-        await self.mute.update_one(
-            {"client": client, "user_id": user_id, "chat_id": chat_id},
-            {"$set": {"reason": reason, "date": self.get_datetime()}},
-            upsert=True,
-        )
-
-    async def rm_mute(self, client: int, user_id: int, chat_id: int) -> str:
-        reason = (await self.get_mute(client, user_id, chat_id))["reason"]
-        await self.mute.delete_one({"client": client, "user_id": user_id, "chat_id": chat_id})
-        return reason
-
-    async def is_muted(self, client: int, user_id: int, chat_id: int) -> bool:
-        if await self.get_mute(client, user_id, chat_id):
-            return True
-        return False
-
-    async def get_mute(self, client: int, user_id: int, chat_id: int):
-        data = await self.mute.find_one({"client": client, "user_id": user_id, "chat_id": chat_id})
-        return data
-
-    async def set_afk(
-        self, user_id: int, reason: str, media: int, media_type: str
-    ) -> None:
-        await self.afk.update_one(
-            {"user_id": user_id},
-            {
-                "$set": {
-                    "reason": reason,
-                    "time": time.time(),
-                    "media": media,
-                    "media_type": media_type,
-                }
-            },
-            upsert=True,
-        )
-
-    async def get_afk(self, user_id: int):
-        data = await self.afk.find_one({"user_id": user_id})
-        return data
-
-    async def is_afk(self, user_id: int) -> bool:
-        if await self.afk.find_one({"user_id": user_id}):
-            return True
-        return False
-
-    async def rm_afk(self, user_id: int) -> None:
-        await self.afk.delete_one({"user_id": user_id})
-
-    async def set_flood(self, client_chat: tuple[int, int], settings: dict):
-        await self.antiflood.update_one(
-            {"client": client_chat[0], "chat": client_chat[1]},
-            {"$set": settings},
-            upsert=True,
-        )
-
-    async def get_flood(self, client_chat: tuple[int, int]):
-        data = await self.antiflood.find_one(
-            {"client": client_chat[0], "chat": client_chat[1]}
-        )
-        return data or {}
-
-    async def is_flood(self, client_chat: tuple[int, int]) -> bool:
-        data = await self.get_flood(client_chat)
-
-        if not data:
-            return False
-
-        if data["limit"] == 0:
-            return False
-
-        return True
-
-    async def get_all_floods(self) -> list:
-        return [i async for i in self.antiflood.find({})]
-
-    async def set_autopost(self, client: int, from_channel: int, to_channel: int):
-        await self.autopost.update_one(
-            {"client": client},
-            {
-                "$push": {
-                    "autopost": {
-                        "from_channel": from_channel,
-                        "to_channel": to_channel,
-                        "date": self.get_datetime(),
-                    }
-                }
-            },
-            upsert=True,
-        )
-
-    async def get_autopost(self, client: int, from_channel: int):
-        data = await self.autopost.find_one(
-            {
-                "client": client,
-                "autopost": {"$elemMatch": {"from_channel": from_channel}},
-            }
-        )
-        return data
-
-    async def is_autopost(
-        self, client: int, from_channel: int, to_channel: int = None
-    ) -> bool:
-        if to_channel:
-            data = await self.autopost.find_one(
-                {
-                    "client": client,
-                    "autopost": {
-                        "$elemMatch": {
-                            "from_channel": from_channel,
-                            "to_channel": to_channel,
-                        }
-                    },
-                }
-            )
-        else:
-            data = await self.autopost.find_one(
-                {
-                    "client": client,
-                    "autopost": {"$elemMatch": {"from_channel": from_channel}},
-                }
-            )
-        return True if data else False
-
-    async def rm_autopost(self, client: int, from_channel: int, to_channel: int):
-        await self.autopost.update_one(
-            {"client": client},
-            {
-                "$pull": {
-                    "autopost": {
-                        "from_channel": from_channel,
-                        "to_channel": to_channel,
-                    }
-                }
-            },
-        )
-
-    async def get_all_autoposts(self, client: int) -> list:
-        return [i async for i in self.autopost.find({"client": client})]
-
-    async def add_blacklist(self, client: int, chat: int, blacklist: str):
-        await self.blacklist.update_one(
-            {"client": client, "chat": chat},
-            {"$push": {"blacklist": blacklist}},
-            upsert=True,
-        )
-
-    async def rm_blacklist(self, client: int, chat: int, blacklist: str):
-        await self.blacklist.update_one(
-            {"client": client, "chat": chat},
-            {"$pull": {"blacklist": blacklist}},
-        )
-
-    async def is_blacklist(self, client: int, chat: int, blacklist: str) -> bool:
-        blacklists = await self.get_all_blacklists(client, chat)
-        if blacklist in blacklists:
-            return True
-        return False
-
-    async def get_all_blacklists(self, client: int, chat: int) -> list:
-        data = await self.blacklist.find_one({"client": client, "chat": chat})
-
-        if not data:
-            return []
-
-        return data["blacklist"]
-
-    async def get_blacklist_clients(self) -> list:
-        return [i async for i in self.blacklist.find({})]
-
-    async def set_echo(self, client: int, chat: int, user: int):
-        await self.echo.update_one(
-            {"client": client, "chat": chat},
-            {"$push": {"echo": user}},
-            upsert=True,
-        )
-
-    async def rm_echo(self, client: int, chat: int, user: int):
-        await self.echo.update_one(
-            {"client": client, "chat": chat},
-            {"$pull": {"echo": user}},
-        )
-
-    async def is_echo(self, client: int, chat: int, user: int) -> bool:
-        data = await self.get_all_echo(client, chat)
-        if user in data:
-            return True
-        return False
-
-    async def get_all_echo(self, client: int, chat: int) -> list:
-        data = await self.echo.find_one({"client": client, "chat": chat})
-
-        if not data:
-            return []
-
-        return data["echo"]
-
-    async def set_filter(self, client: int, chat: int, keyword: str, msgid: int):
-        await self.filter.update_one(
-            {"client": client, "chat": chat},
-            {"$push": {"filter": {"keyword": keyword, "msgid": msgid}}},
-            upsert=True,
-        )
-
-    async def rm_filter(self, client: int, chat: int, keyword: str):
-        await self.filter.update_one(
-            {"client": client, "chat": chat},
-            {"$pull": {"filter": {"keyword": keyword}}},
-        )
-
-    async def rm_all_filters(self, client: int, chat: int):
-        await self.filter.delete_one({"client": client, "chat": chat})
-
-    async def is_filter(self, client: int, chat: int, keyword: str) -> bool:
-        data = await self.get_filter(client, chat, keyword)
-        return True if data else False
-
-    async def get_filter(self, client: int, chat: int, keyword: str):
-        data = await self.filter.find_one(
-            {
-                "client": client,
-                "chat": chat,
-                "filter": {"$elemMatch": {"keyword": keyword}},
-            }
-        )
-        return data
-
-    async def get_all_filters(self, client: int, chat: int) -> list:
-        data = await self.filter.find_one({"client": client, "chat": chat})
-
-        if not data:
-            return []
-
-        return data["filter"]
-
-    async def set_snip(self, client: int, chat: int, keyword: str, msgid: int):
-        await self.snips.update_one(
-            {"client": client, "chat": chat},
-            {"$push": {"snips": {"keyword": keyword, "msgid": msgid}}},
-            upsert=True,
-        )
-
-    async def rm_snip(self, client: int, chat: int, keyword: str):
-        await self.snips.update_one(
-            {"client": client, "chat": chat},
-            {"$pull": {"snips": {"keyword": keyword}}},
-        )
-
-    async def rm_all_snips(self, client: int, chat: int):
-        await self.snips.delete_one({"client": client, "chat": chat})
-
-    async def is_snip(self, client: int, chat: int, keyword: str) -> bool:
-        data = await self.get_snip(client, chat, keyword)
-        return True if data else False
-
-    async def get_snip(self, client: int, chat: int, keyword: str):
-        data = await self.snips.find_one(
-            {
-                "client": client,
-                "chat": chat,
-                "snips": {"$elemMatch": {"keyword": keyword}},
-            }
-        )
-        return data
-
-    async def get_all_snips(self, client: int, chat: int) -> list:
-        data = await self.snips.find_one({"client": client, "chat": chat})
-
-        if not data:
-            return []
-
-        return data["snips"]
-
-    async def add_pmpermit(self, client: int, user: int):
-        await self.pmpermit.update_one(
-            {"client": client, "user": user},
-            {"$set": {"date": self.get_datetime()}},
-            upsert=True,
-        )
-
-    async def rm_pmpermit(self, client: int, user: int):
-        await self.pmpermit.delete_one({"client": client, "user": user})
-
-    async def is_pmpermit(self, client: int, user: int) -> bool:
-        data = await self.get_pmpermit(client, user)
-        return True if data else False
-
-    async def get_pmpermit(self, client: int, user: int):
-        data = await self.pmpermit.find_one({"client": client, "user": user})
-        return data
-
-    async def get_all_pmpermits(self, client: int) -> list:
-        return [i async for i in self.pmpermit.find({"client": client})]
-
-    async def set_welcome(self, client: int, chat: int, message: int):
-        await self.greetings.update_one(
-            {"client": client, "chat": chat, "welcome": True},
-            {"$set": {"message": message}},
-            upsert=True,
-        )
-
-    async def rm_welcome(self, client: int, chat: int):
-        await self.greetings.delete_one(
-            {"client": client, "chat": chat, "welcome": True}
-        )
-
-    async def is_welcome(self, client: int, chat: int) -> bool:
-        data = await self.get_welcome(client, chat)
-        return True if data else False
-
-    async def get_welcome(self, client: int, chat: int):
-        data = await self.greetings.find_one(
-            {"client": client, "chat": chat, "welcome": True}
-        )
-        return data
-
-    async def set_goodbye(self, client: int, chat: int, message: int):
-        await self.greetings.update_one(
-            {"client": client, "chat": chat, "welcome": False},
-            {"$set": {"message": message}},
-            upsert=True,
-        )
-
-    async def rm_goodbye(self, client: int, chat: int):
-        await self.greetings.delete_one(
-            {"client": client, "chat": chat, "welcome": False}
-        )
-
-    async def is_goodbye(self, client: int, chat: int) -> bool:
-        data = await self.get_goodbye(client, chat)
-        return True if data else False
-
-    async def get_goodbye(self, client: int, chat: int):
-        data = await self.greetings.find_one(
-            {"client": client, "chat": chat, "welcome": False}
-        )
-        return data
-
-    async def get_all_greetings(self, client: int) -> list:
-        return [i async for i in self.greetings.find({"client": client})]
-
-    async def add_forcesub(self, chat: int, must_join: int):
-        await self.forcesub.update_one(
-            {"chat": chat},
-            {"$push": {"must_join": must_join}},
-            upsert=True,
-        )
-
-    async def rm_forcesub(self, chat: int, must_join: int) -> int:
-        await self.forcesub.update_one(
-            {"chat": chat},
-            {"$pull": {"must_join": must_join}},
-        )
-        data = await self.forcesub.find_one({"chat": chat})
-        return len(data["must_join"])
-
-    async def rm_all_forcesub(self, in_chat: int):
-        await self.forcesub.delete_one({"chat": in_chat})
-
-    async def is_forcesub(self, chat: int, must_join: int) -> bool:
-        data = await self.get_forcesub(chat)
-        if must_join in data["must_join"]:
-            return True
-        return False
-
-    async def get_forcesub(self, in_chat: int):
-        data = await self.forcesub.find_one({"chat": in_chat})
-        return data
-
-    async def get_all_forcesubs(self) -> list:
-        return [i async for i in self.forcesub.find({})]
-
-    async def add_gachabot(
-        self, client: int, bot: tuple[int, str], catch_command: str, chat_id: int
-    ):
-        await self.gachabots.update_one(
-            {"client": client, "bot": bot[0]},
-            {
-                "$set": {
-                    "username": bot[1],
-                    "catch_command": catch_command,
-                    "chat_id": chat_id,
-                    "date": self.get_datetime(),
-                }
-            },
-            upsert=True,
-        )
-
-    async def rm_gachabot(self, client: int, bot: int, chat_id: int = None):
-        if chat_id:
-            await self.gachabots.delete_one(
-                {"client": client, "bot": bot, "chat_id": chat_id}
-            )
-        else:
-            await self.gachabots.delete_one({"client": client, "bot": bot})
-
-    async def is_gachabot(self, client: int, bot: int, chat_id: int) -> bool:
-        data = await self.get_gachabot(client, bot, chat_id)
-        return True if data else False
-
-    async def get_gachabot(self, client: int, bot: int, chat_id: int):
-        data = await self.gachabots.find_one(
-            {"client": client, "bot": bot, "chat_id": chat_id}
-        )
-
-        return data
-
-    async def get_all_gachabots(self, client: int) -> list:
-        return [i async for i in self.gachabots.find({"client": client})]
-
-    async def get_all_gachabots_id(self) -> list:
-        data = await self.gachabots.distinct("bot")
-        return data
-
-
-db = Database(Config.DATABASE_URL)

HellBot/core/initializer.py

@@ -1,94 +0,0 @@
-import sys
-from .clients import hellbot
-from .config import Config, Symbols
-from .database import db
-from .logger import LOGS
-
-
-async def _AuthUsers() -> None:
-    temp_list = []
-    temp_list.append(Config.OWNER_ID)
-    temp_list.extend([(await client.get_me()).id for client in hellbot.users])
-
-    stan_users = await db.get_all_stans()
-    for user in stan_users:
-        temp_list.append(user["user_id"])
-
-    users = list(set(temp_list))
-    for user in users:
-        Config.AUTH_USERS.add(user)
-
-    temp_list = None
-    LOGS.info(
-        f"{Symbols.arrow_right * 2} Added Authorized Users {Symbols.arrow_left * 2}"
-    )
-
-
-async def _StanUsers() -> None:
-    users = await db.get_all_stans()
-    for user in users:
-        Config.STAN_USERS.add(user["user_id"])
-
-    LOGS.info(f"{Symbols.arrow_right * 2} Added Stan Users {Symbols.arrow_left * 2}")
-
-
-async def _GbanUsers() -> None:
-    users = await db.get_gban()
-    for user in users:
-        Config.BANNED_USERS.add(user["user_id"])
-
-    LOGS.info(
-        f"{Symbols.arrow_right * 2} Added {len(users)} Gbanned Users {Symbols.arrow_left * 2}"
-    )
-
-    musers = await db.get_gmute()
-    for user in musers:
-        Config.MUTED_USERS.add(user["user_id"])
-
-    LOGS.info(
-        f"{Symbols.arrow_right * 2} Added {len(musers)} Gmuted Users {Symbols.arrow_left * 2}"
-    )
-
-
-async def UserSetup() -> None:
-    """Initialize Users Config"""
-    LOGS.info(f"{Symbols.bullet * 3} Setting Up Users {Symbols.bullet * 3}")
-    await _AuthUsers()
-    await _StanUsers()
-    await _GbanUsers()
-
-
-async def ForcesubSetup() -> None:
-    """Initialize Forcesub Config"""
-    chats = await db.get_all_forcesubs()
-    for chat in chats:
-        if chat not in Config.FORCESUBS:
-            Config.FORCESUBS.add(chat["chat"])
-
-
-async def GachaBotsSetup() -> None:
-    """Initialize GachaBots Config"""
-    bots = await db.get_all_gachabots_id()
-    for bot in bots:
-        Config.GACHA_BOTS.add(bot)
-
-
-async def TemplateSetup() -> None:
-    """Initialize Templates Config"""
-    module_name = "temp_module"
-    module = sys.modules.get(module_name)
-    if module is None:
-        module = type(sys)(module_name)
-
-    with open("Hellbot/functions/templates.py", "r", encoding="utf-8") as file:
-        exec(file.read(), module.__dict__)
-
-    global_vars = module.__dict__
-
-    var_n_value: dict[str, str] = {
-        var_name: global_vars[var_name][0]
-        for var_name in global_vars
-        if var_name.isupper() and not callable(global_vars[var_name])
-    }
-
-    Config.TEMPLATES = var_n_value

HellBot/core/logger.py

@@ -1,19 +0,0 @@
-import logging
-from logging.handlers import RotatingFileHandler
-
-logging.basicConfig(
-    format="[%(asctime)s]:[%(name)s]:[%(levelname)s] - %(message)s",
-    level=logging.INFO,
-    datefmt="%H:%M:%S",
-    handlers=[
-        RotatingFileHandler(
-            "HellBot.log", maxBytes=(1024 * 1024 * 5), backupCount=10, encoding="utf-8"
-        ),
-        logging.StreamHandler(),
-    ],
-)
-
-
-logging.getLogger("pyrogram").setLevel(logging.ERROR)
-
-LOGS = logging.getLogger("HellBot")

HellBot/functions/admins.py

@@ -1,24 +0,0 @@
-from pyrogram.enums import ChatMembersFilter, ChatMemberStatus, ChatType
-from pyrogram.types import Chat
-
-from Hellbot.core import hellbot
-
-
-async def get_admins(chat_id: int) -> list:
-    admins = []
-    async for x in hellbot.bot.get_chat_members(
-        chat_id, filter=ChatMembersFilter.ADMINISTRATORS
-    ):
-        admins.append(x.user.id)
-    return admins
-
-
-async def is_user_admin(chat: Chat, user_id: int) -> bool:
-    if chat.type in [ChatType.PRIVATE, ChatType.BOT]:
-        return True
-
-    status = (await chat.get_member(user_id)).status
-    if status in [ChatMemberStatus.OWNER, ChatMemberStatus.ADMINISTRATOR]:
-        return True
-
-    return False

HellBot/functions/convert.py

@@ -1,98 +0,0 @@
-import os
-import time
-
-from pyrogram.types import Message
-from PIL import Image
-from Hellbot.core import Config
-
-from .tools import runcmd
-
-
-async def convert_to_gif(file: str, is_video: bool = False) -> str:
-    resultFileName = f"gif_{round(time.time())}.mp4"
-
-    if is_video:
-        cmd = f"ffmpeg -i '{file}' -c copy '{resultFileName}'"
-    else:
-        cmd = f"lottie_convert.py '{file}' '{resultFileName}'"
-
-    await runcmd(cmd)
-
-    return resultFileName
-
-
-async def tgs_to_png(file: str) -> str:
-    resultFileName = f"png_{round(time.time())}.png"
-
-    cmd = f"lottie_convert.py '{file}' '{resultFileName}'"
-
-    await runcmd(cmd)
-
-    return resultFileName
-
-
-async def image_to_sticker(file: str, max_size: tuple = (512, 512)) -> tuple[bool, str]:
-    try:
-        with Image.open(file) as img:
-            original_width, original_height = img.size
-
-            new_width = min(original_width, max_size[0])
-            new_height = min(original_height, max_size[1])
-
-            if original_width > max_size[0] or original_height > max_size[1]:
-                img = img.resize((new_width, new_height), Image.LANCZOS)
-
-            file_name = f"sticker_{int(time.time())}.png"
-            img.save(file_name, "PNG")
-
-        return True, file_name
-
-    except Exception as e:
-        return False, str(e)
-
-
-async def video_to_png(
-    file: str, duration: float, output: str = None
-) -> tuple[str, bool]:
-    resultFileName = output or f"{os.path.basename(file)}.png"
-    cut_at = duration // 2
-
-    cmd = f"ffmpeg -ss {cut_at} -i '{file}' -vframes 1 '{resultFileName}'"
-
-    _, err, _, _ = await runcmd(cmd)
-    if err:
-        return err, False
-
-    return resultFileName, True
-
-
-async def video_to_sticker(file: Message) -> tuple[str, bool]:
-    try:
-        if file.animation:
-            width, height = file.animation.width, file.animation.height
-        elif file.video:
-            width, height = file.video.width, file.video.height
-        else:
-            return "Unsupported media type.", False
-
-        file_path = await file.download(Config.TEMP_DIR)
-        output_path = os.path.join(Config.TEMP_DIR, "videoSticker.webm")
-
-        if height > width:
-            scale_params = f"scale=-1:512"
-        else:
-            scale_params = f"scale=512:-1"
-
-        cmd = (
-            f"ffmpeg -i {file_path} "
-            f"-vf fps=30,{scale_params} -t 3 -c:v libvpx-vp9 -b:v 256k -an -pix_fmt yuv420p -auto-alt-ref 0 -loop 0 "
-            f"-f webm {output_path}"
-        )
-
-        await runcmd(cmd)
-        os.remove(file_path)
-
-        return output_path, True
-
-    except Exception as e:
-        return f"Error during conversion: {e}", False

HellBot/functions/driver.py

@@ -1,318 +0,0 @@
-import datetime
-import json
-import random
-import re
-import time
-import urllib.parse
-from urllib.parse import quote_plus
-
-import httpx
-import requests
-from pytz import country_names, country_timezones, timezone
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.chrome.service import Service
-from selenium.webdriver.common.by import By
-
-from Hellbot.core import ENV, Config, db
-
-from .formatter import format_text
-
-
-class ChromeDriver:
-    def __init__(self) -> None:
-        self.carbon_theme = [
-            "3024-night",
-            "a11y-dark",
-            "blackboard",
-            "base16-dark",
-            "base16-light",
-            "cobalt",
-            "duotone-dark",
-            "hopscotch",
-            "lucario",
-            "material",
-            "monokai",
-            "night-owl",
-            "nord",
-            "oceanic-next",
-            "one-light",
-            "one-dark",
-            "panda-syntax",
-            "paraiso-dark",
-            "seti",
-            "shades-of-purple",
-            "solarized+dark",
-            "solarized+light",
-            "synthwave-84",
-            "twilight",
-            "verminal",
-            "vscode",
-            "yeti",
-            "zenburn",
-        ]
-
-    def get(self):
-        if not Config.CHROME_BIN:
-            return (
-                None,
-                "ChromeBinaryErr: No binary path found! Install Chromium or Google Chrome.",
-            )
-
-        try:
-            options = Options()
-            options.binary_location = Config.CHROME_BIN
-            options.add_argument("--disable-dev-shm-usage")
-            options.add_argument("--ignore-certificate-errors")
-            options.add_argument("--disable-gpu")
-            options.add_argument("--headless=new")
-            options.add_argument("--test-type")
-            options.add_argument("--no-sandbox")
-            options.add_argument("--window-size=1920x1080")
-            options.add_experimental_option(
-                "prefs", {"download.default_directory": "./"}
-            )
-            service = Service(Config.CHROME_DRIVER)
-            driver = webdriver.Chrome(options, service)
-            return driver, None
-        except Exception as e:
-            return None, f"ChromeDriverErr: {e}"
-
-    def close(self, driver: webdriver.Chrome):
-        driver.close()
-        driver.quit()
-
-    @property
-    def get_random_carbon(self) -> str:
-        url = "https://carbon.now.sh/?l=auto"
-        url += f"&t={random.choice(self.carbon_theme)}"
-        url += f"&bg=rgba%28{random.randint(1, 255)}%2C{random.randint(1, 255)}%2C{random.randint(1, 255)}%2C1%29"
-        url += "&code="
-        return url
-
-    async def generate_carbon(
-        self, driver: webdriver.Chrome, code: str, is_random: bool = False
-    ) -> str:
-        filename = f"{round(time.time())}"
-        BASE_URL = (
-            self.get_random_carbon
-            if is_random
-            else "https://carbon.now.sh/?l=auto&code="
-        )
-
-        driver.get(BASE_URL + format_text(quote_plus(code)))
-        driver.command_executor._commands["send_command"] = (
-            "POST",
-            "/session/$sessionId/chromium/send_command",
-        )
-        params = {
-            "cmd": "Page.setDownloadBehavior",
-            "params": {"behavior": "allow", "downloadPath": Config.DWL_DIR},
-        }
-        driver.execute("send_command", params)
-
-        driver.find_element(By.XPATH, "//button[@id='export-menu']").click()
-        driver.find_element(By.XPATH, "//input[@title='filename']").send_keys(filename)
-        driver.find_element(By.XPATH, "//button[@id='export-png']").click()
-
-        return f"{Config.DWL_DIR}/{filename}.png"
-
-
-class ClimateDriver:
-    def __init__(self) -> None:
-        self.weather_api = "https://api.openweathermap.org/data/2.5/weather?lat={0}&lon={1}&appid={2}&units=metric"
-        self.location_api = (
-            "https://api.openweathermap.org/geo/1.0/direct?q={0}&limit=1&appid={1}"
-        )
-        self.pollution_api = "http://api.openweathermap.org/data/2.5/air_pollution?lat={0}&lon={1}&appid={2}"
-        self.AQI_DICT = {
-            1: "Good",
-            2: "Fair",
-            3: "Moderate",
-            4: "Poor",
-            5: "Very Poor",
-        }
-
-    async def fetchLocation(self, city: str, apiKey: str):
-        response = httpx.get(self.location_api.format(city, apiKey))
-        if response.status_code == 200:
-            data = response.json()
-            if data:
-                return data[0]["lat"], data[0]["lon"]
-        return None, None
-
-    async def fetchWeather(self, city: str, apiKey: str):
-        lattitude, longitude = await self.fetchLocation(city, apiKey)
-        if not lattitude and not longitude:
-            return None
-
-        response = httpx.get(self.weather_api.format(lattitude, longitude, apiKey))
-        if response.status_code == 200:
-            return response.json()
-        return None
-
-    async def fetchAirPollution(self, city: str, apiKey: str):
-        lattitude, longitude = await self.fetchLocation(city, apiKey)
-        if not lattitude and not longitude:
-            return None
-
-        response = httpx.get(self.pollution_api.format(lattitude, longitude, apiKey))
-        if response.status_code == 200:
-            return response.json()
-        return None
-
-    async def getTime(self, timestamp: int) -> str:
-        tz = await db.get_env(ENV.time_zone) or "Asia/Kolkata"
-        tz = timezone(tz)
-        return datetime.datetime.fromtimestamp(timestamp, tz=tz).strftime("%I:%M %p")
-
-    def getCountry(self, country_code: str) -> str:
-        return country_names.get(country_code, "Unknown")
-
-    def getCountryTimezone(self, country_code: str) -> str:
-        timezones = country_timezones.get(country_code, [])
-        if timezones:
-            return ", ".join(timezones)
-        return "Unknown"
-
-    def getWindData(self, windSpeed: str, windDegree: str) -> str:
-        dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]
-        ix = round(windDegree / (360.00 / len(dirs)))
-        kmph = str(float(windSpeed) * 3.6) + " km/h"
-        return f"[{dirs[ix % len(dirs)]}] {kmph}"
-
-
-class YoutubeDriver:
-    def __init__(self, search_terms: str, max_results: int = 5):
-        self.base_url = "https://youtube.com/results?search_query={0}"
-        self.search_terms = search_terms
-        self.max_results = max_results
-        self.videos = self._search()
-
-    def _search(self):
-        encoded_search = urllib.parse.quote_plus(self.search_terms)
-        response = requests.get(self.base_url.format(encoded_search)).text
-
-        while "ytInitialData" not in response:
-            response = requests.get(self.base_url.format(encoded_search)).text
-
-        results = self._parse_html(response)
-
-        if self.max_results is not None and len(results) > self.max_results:
-            return results[: self.max_results]
-
-        return results
-
-    def _parse_html(self, response: str):
-        results = []
-        start = response.index("ytInitialData") + len("ytInitialData") + 3
-        end = response.index("};", start) + 1
-        json_str = response[start:end]
-        data = json.loads(json_str)
-
-        videos = data["contents"]["twoColumnSearchResultsRenderer"]["primaryContents"][
-            "sectionListRenderer"
-        ]["contents"][0]["itemSectionRenderer"]["contents"]
-
-        for video in videos:
-            res = {}
-            if "videoRenderer" in video.keys():
-                video_data = video.get("videoRenderer", {})
-                _id = video_data.get("videoId", None)
-
-                res["id"] = _id
-                res["thumbnail"] = f"https://i.ytimg.com/vi/{_id}/hqdefault.jpg"
-                res["title"] = (
-                    video_data.get("title", {}).get("runs", [[{}]])[0].get("text", None)
-                )
-                res["channel"] = (
-                    video_data.get("longBylineText", {})
-                    .get("runs", [[{}]])[0]
-                    .get("text", None)
-                )
-                res["duration"] = video_data.get("lengthText", {}).get("simpleText", 0)
-                res["views"] = video_data.get("viewCountText", {}).get(
-                    "simpleText", "Unknown"
-                )
-                res["publish_time"] = video_data.get("publishedTimeText", {}).get(
-                    "simpleText", "Unknown"
-                )
-                res["url_suffix"] = (
-                    video_data.get("navigationEndpoint", {})
-                    .get("commandMetadata", {})
-                    .get("webCommandMetadata", {})
-                    .get("url", None)
-                )
-
-                results.append(res)
-        return results
-
-    def to_dict(self, clear_cache=True) -> list[dict]:
-        result = self.videos
-        if clear_cache:
-            self.videos = []
-        return result
-
-    @staticmethod
-    def check_url(url: str) -> tuple[bool, str]:
-        if "&" in url:
-            url = url[: url.index("&")]
-
-        if "?si=" in url:
-            url = url[: url.index("?si=")]
-
-        youtube_regex = (
-            r"(https?://)?(www\.)?"
-            r"(youtube|youtu|youtube-nocookie)\.(com|be)/"
-            r'(video|embed|shorts/|watch\?v=|v/|e/|u/\\w+/|\\w+/)?([^"&?\\s]{11})'
-        )
-        match = re.match(youtube_regex, url)
-        if match:
-            return True, match.group(6)
-        else:
-            return False, "Invalid YouTube URL!"
-
-    @staticmethod
-    def song_options() -> dict:
-        return {
-            "format": "bestaudio",
-            "addmetadata": True,
-            "key": "FFmpegMetadata",
-            "prefer_ffmpeg": True,
-            "geo_bypass": True,
-            "nocheckcertificate": True,
-            "postprocessors": [
-                {
-                    "key": "FFmpegExtractAudio",
-                    "preferredcodec": "mp3",
-                    "preferredquality": "480",
-                }
-            ],
-            "outtmpl": "%(id)s",
-            "quiet": True,
-            "logtostderr": False,
-        }
-
-    @staticmethod
-    def video_options() -> dict:
-        return {
-            "format": "best",
-            "addmetadata": True,
-            "key": "FFmpegMetadata",
-            "prefer_ffmpeg": True,
-            "geo_bypass": True,
-            "nocheckcertificate": True,
-            "postprocessors": [
-                {
-                    "key": "FFmpegVideoConvertor",
-                    "preferedformat": "mp4",
-                }
-            ],
-            "outtmpl": "%(id)s.mp4",
-            "quiet": True,
-            "logtostderr": False,
-        }
-
-
-Driver = ChromeDriver()
-Climate = ClimateDriver()

HellBot/functions/formatter.py

@@ -1,94 +0,0 @@
-import math
-import re
-
-
-def format_text(text: str) -> str:
-    emoji_pattern = re.compile(
-        "["
-        "\U0001F600-\U0001F64F"  # emoticons
-        "\U0001F300-\U0001F5FF"  # symbols & pictographs
-        "\U0001F680-\U0001F6FF"  # transport & map symbols
-        "\U0001F700-\U0001F77F"  # alchemical symbols
-        "\U0001F780-\U0001F7FF"  # Geometric Shapes Extended
-        "\U0001F800-\U0001F8FF"  # Supplemental Arrows-C
-        "\U0001F900-\U0001F9FF"  # Supplemental Symbols and Pictographs
-        "\U0001FA00-\U0001FA6F"  # Chess Symbols
-        "\U0001FA70-\U0001FAFF"  # Symbols and Pictographs Extended-A
-        "\U00002702-\U000027B0"  # Dingbats
-        "\U000024C2-\U0001F251"  # enclosed characters
-        "]+",
-        flags=re.UNICODE,
-    )
-
-    return re.sub(emoji_pattern, "", text)
-
-
-def superscript(text: str) -> str:
-    superscript_digits = str.maketrans("0123456789", "⁰¹²³⁴⁵⁶⁷⁸⁹")
-    return text.translate(superscript_digits)
-
-
-def subscript(text: str) -> str:
-    subscript_digits = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
-    return text.translate(subscript_digits)
-
-
-def readable_time(seconds: int) -> str:
-    count = 0
-    out_time = ""
-    time_list = []
-    time_suffix_list = ["secs", "mins", "hrs", "days"]
-
-    while count < 4:
-        count += 1
-        remainder, result = divmod(seconds, 60) if count < 3 else divmod(seconds, 24)
-        if seconds == 0 and remainder == 0:
-            break
-        time_list.append(int(result))
-        seconds = int(remainder)
-
-    for x in range(len(time_list)):
-        time_list[x] = str(time_list[x]) + time_suffix_list[x]
-
-    if len(time_list) == 4:
-        out_time += time_list.pop() + ", "
-
-    time_list.reverse()
-    out_time += " ".join(time_list)
-
-    return out_time or "0 secs"
-
-
-def humanbytes(size: int):
-    if not size:
-        return ""
-    power = 2**10
-    number = 0
-    dict_power_n = {0: " ", 1: "Ki", 2: "Mi", 3: "Gi", 4: "Ti"}
-    while size > power:
-        size /= power
-        number += 1
-    return str(round(size, 2)) + " " + dict_power_n[number] + "B"
-
-
-def add_to_dict(data: dict, keys: list, value: str | int | bool = None) -> None:
-    current_level = data
-    for key in keys[:-1]:
-        current_level = current_level.setdefault(key, {})
-    current_level[keys[-1]] = value
-
-
-def get_from_dict(data: dict, key: list):
-    current_level = data
-    for k in key:
-        current_level = current_level[k]
-    return current_level
-
-
-def limit_per_page(limit: int) -> int:
-    return math.ceil(limit / 10)
-
-
-def secs_to_mins(secs: int) -> str:
-    mins, secs = divmod(secs, 60)
-    return f"{mins}:{secs}"

HellBot/functions/images.py

@@ -1,389 +0,0 @@
-import calendar
-import logging
-import os
-import random
-import textwrap
-import time
-
-import httpx
-from icrawler.builtin import BingImageCrawler
-from PIL import Image, ImageDraw, ImageEnhance, ImageFont, ImageOps
-from unidecode import unidecode
-
-from .formatter import format_text, limit_per_page
-
-
-def convert_to_png(image: str) -> str:
-    output_img = f"png_{round(time.time())}.png"
-
-    img = Image.open(image)
-    img.save(output_img, "PNG")
-    img.close()
-
-    os.remove(image)
-    return output_img
-
-
-def add_rounded_corners(img: Image.Image, radius: int = 80):
-    circle = Image.new("L", (radius * 2, radius * 2), 0)
-
-    draw = ImageDraw.Draw(circle)
-    draw.ellipse((0, 0, radius * 2, radius * 2), fill=255)
-
-    alpha = Image.new("L", img.size, 255)
-    w, h = img.size
-
-    alpha.paste(circle.crop((0, 0, radius, radius)), (0, 0))
-    alpha.paste(circle.crop((radius, 0, radius * 2, radius)), (w - radius, 0))
-    alpha.paste(circle.crop((0, radius, radius, radius * 2)), (0, h - radius))
-    alpha.paste(
-        circle.crop((radius, radius, radius * 2, radius * 2)), (w - radius, h - radius)
-    )
-
-    img.putalpha(alpha)
-
-    return img
-
-
-def generate_alive_image(
-    username: str, profile_pic: str, del_img: bool, font_path: str
-) -> str:
-    if not profile_pic.endswith(".png"):
-        profile_pic = convert_to_png(profile_pic)
-
-    img = Image.open(profile_pic).convert("RGBA")
-    img_rotated = img.rotate(45, expand=True)
-
-    width, height = img_rotated.size
-    left = width / 2 - 480 / 2
-    top = height / 2 - 480 / 2
-    right = width / 2 + 480 / 2
-    bottom = height / 2 + 480 / 2
-
-    cropped_img = img_rotated.crop((left, top, right, bottom))
-
-    img_rotated = ImageOps.fit(
-        cropped_img, (480, 480), method=0, bleed=0.0, centering=(0.5, 0.5)
-    )
-
-    img_rounded = add_rounded_corners(img_rotated)
-
-    img = img_rounded.rotate(-45, expand=True)
-
-    background = Image.open("./Hellbot/resources/images/hellbot_alive.png").convert(
-        "RGBA"
-    )
-
-    background.paste(img, (383, 445), img)
-    draw = ImageDraw.Draw(background)
-
-    text = format_text(username[:25] + ("..." if len(username) > 25 else ""))
-
-    font_size = width // 15
-    font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
-
-    text_length = draw.textlength(text, font)
-    position = ((background.width - text_length) / 2, background.height - 145)
-    draw.text(
-        position,
-        unidecode(text),
-        (255, 255, 255),
-        font,
-    )
-
-    output_img = f"alive_{int(time.time())}.png"
-    background.save(output_img, "PNG")
-    background.close()
-
-    if del_img:
-        os.remove(profile_pic)
-
-    return output_img
-
-
-async def get_wallpapers(
-    access: str,
-    limit: int,
-    query: str = "",
-    isRandom: bool = False,
-) -> list[str]:
-    headers = {"Authorization": f"Client-ID {access}"}
-
-    if isRandom:
-        api = f"https://api.unsplash.com/photos/random?count={limit}"
-        response = httpx.get(api, headers=headers)
-        results = response.json()
-        urls = [i["urls"]["raw"] for i in results]
-    else:
-        api = f"https://api.unsplash.com/search/photos?query={query}&page={limit_per_page(limit)}"
-        response = httpx.get(api, headers=headers)
-        result = response.json()
-        urls = [i["urls"]["raw"] for i in result["results"]]
-
-    random.shuffle(urls)
-
-    return urls[:limit]
-
-
-async def deep_fry(img: Image.Image) -> Image.Image:
-    colours = (
-        (random.randint(50, 200), random.randint(40, 170), random.randint(40, 190)),
-        (random.randint(190, 255), random.randint(170, 240), random.randint(180, 250)),
-    )
-
-    img = img.copy().convert("RGB")
-    img = img.convert("RGB")
-
-    width, height = img.width, img.height
-
-    img = img.resize(
-        (
-            int(width ** random.uniform(0.8, 0.9)),
-            int(height ** random.uniform(0.8, 0.9)),
-        ),
-        resample=Image.LANCZOS,
-    )
-
-    img = img.resize(
-        (
-            int(width ** random.uniform(0.85, 0.95)),
-            int(height ** random.uniform(0.85, 0.95)),
-        ),
-        resample=Image.BILINEAR,
-    )
-
-    img = img.resize(
-        (
-            int(width ** random.uniform(0.89, 0.98)),
-            int(height ** random.uniform(0.89, 0.98)),
-        ),
-        resample=Image.BICUBIC,
-    )
-
-    img = img.resize((width, height), resample=Image.BICUBIC)
-    img = ImageOps.posterize(img, random.randint(3, 7))
-
-    overlay = img.split()[0]
-    overlay = ImageEnhance.Contrast(overlay).enhance(random.uniform(1.0, 2.0))
-    overlay = ImageEnhance.Brightness(overlay).enhance(random.uniform(1.0, 2.0))
-    overlay = ImageOps.colorize(overlay, colours[0], colours[1])
-
-    img = Image.blend(img, overlay, random.uniform(0.1, 0.4))
-    img = ImageEnhance.Sharpness(img).enhance(random.randint(5, 300))
-
-    return img
-
-
-async def make_logo(background: str, text: str, font_path: str) -> str:
-    if not background.endswith(".png"):
-        background = convert_to_png(background)
-
-    bg = Image.open(background).convert("RGBA")
-    bgWidth, bgHeight = bg.size
-
-    text = format_text(text)
-    font_size = bgWidth // len(text)
-    font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
-
-    draw = ImageDraw.Draw(bg)
-    text_length = draw.textlength(text, font)
-
-    x = (bgWidth - text_length) // 2
-    y = (bgHeight - font_size) // 2
-
-    draw.text(
-        (x, y),
-        unidecode(text),
-        (255, 255, 255),
-        font,
-        stroke_fill=(0, 0, 0),
-        stroke_width=2,
-    )
-
-    output_img = f"logo_{int(time.time())}.png"
-    bg.save(output_img, "PNG")
-    bg.close()
-
-    os.remove(background)
-
-    return output_img
-
-
-async def draw_meme(
-    image_path: str, upper_text: str = "", lower_text: str = ""
-) -> list[str]:
-    image = Image.open(image_path)
-    width, height = image.size
-
-    draw = ImageDraw.Draw(image)
-    font_size = int((30 / 500) * width)
-    font = ImageFont.truetype("./Hellbot/resources/fonts/Montserrat.ttf", font_size)
-
-    curr_height, padding = 20, 5
-    for utext in textwrap.wrap(upper_text, 25):
-        upper_width = draw.textlength(utext, font=font)
-        draw.text(
-            ((width - upper_width) / 2, curr_height),
-            unidecode(utext),
-            (255, 255, 255),
-            font,
-            stroke_width=3,
-            stroke_fill=(0, 0, 0),
-        )
-        curr_height += font_size + padding
-
-    curr_height = height - font_size
-    for ltext in reversed(textwrap.wrap(lower_text, 25)):
-        lower_width = draw.textlength(ltext, font=font)
-        draw.text(
-            ((width - lower_width) / 2, curr_height - font_size),
-            ltext,
-            (255, 255, 255),
-            font,
-            stroke_width=3,
-            stroke_fill=(0, 0, 0),
-        )
-        curr_height -= font_size + padding
-
-    filename = f"meme_{int(time.time())}"
-    image.save(f"{filename}.png", "PNG", optimize=True)
-    image.save(f"{filename}.webp", "WEBP", optimize=True)
-    image.close()
-
-    return [f"{filename}.png", f"{filename}.webp"]
-
-
-async def remove_bg(api_key: str, image: str) -> str:
-    response = httpx.post(
-        "https://api.remove.bg/v1.0/removebg",
-        files={"image_file": open(image, "rb")},
-        data={"size": "auto"},
-        headers={"X-Api-Key": api_key},
-    )
-    filename = f"removedbg_{int(time.time())}.png"
-
-    if response.is_success:
-        with open(filename, "wb") as f:
-            f.write(response.content)
-    else:
-        raise Exception(
-            f"RemoveBGError: [{response.status_code}] {response.content.decode('utf-8')}"
-        )
-
-    return filename
-
-
-def create_gradient(
-    size: tuple[int, int],
-    color_start: tuple[int, int, int],
-    color_end: tuple[int, int, int],
-) -> Image.Image:
-    gradient = Image.new("RGB", (size))
-    draw = ImageDraw.Draw(gradient)
-
-    for x in range(size[0]):
-        r = int(color_start[0] + (color_end[0] - color_start[0]) * (x / size[0]))
-        g = int(color_start[1] + (color_end[1] - color_start[1]) * (x / size[0]))
-        b = int(color_start[2] + (color_end[2] - color_start[2]) * (x / size[0]))
-
-        draw.line([(x, 0), (x, size[1])], fill=(r, g, b))
-
-    return gradient
-
-
-async def create_calendar(year: int, month: int) -> str:
-    cal = calendar.monthcalendar(year, month)
-    month_name = calendar.month_name[month]
-
-    calendar_image = create_gradient((500, 500), (140, 200, 250), (0, 150, 200))
-    draw = ImageDraw.Draw(calendar_image)
-
-    month_font = ImageFont.truetype("./Hellbot/resources/fonts/Montserrat.ttf", 40)
-    month_x = (
-        calendar_image.width - draw.textlength(f"{month_name} {year}", month_font)
-    ) // 2
-    month_y = 30
-    draw.text(
-        (month_x, month_y),
-        f"{month_name} {year}",
-        (43, 255, 136),
-        month_font,
-        stroke_width=2,
-        stroke_fill=(255, 40, 40),
-    )
-
-    week_font = ImageFont.truetype("./Hellbot/resources/fonts/Montserrat.ttf", 23)
-    weekdays_text = "   ".join([day[:3] for day in calendar.day_name])
-    textsize = draw.textlength(weekdays_text, week_font)
-    draw.text(
-        ((calendar_image.width - textsize) // 2, month_y + 80),
-        weekdays_text,
-        (150, 190, 200),
-        week_font,
-        stroke_width=2,
-        stroke_fill=(200, 150, 250),
-    )
-
-    scale_factor = 1.5
-    cell_size = 30
-    padding = 15
-
-    font = ImageFont.truetype("./Hellbot/resources/fonts/Montserrat.ttf", 30)
-
-    for week_num, week in enumerate(cal):
-        for day_num, day in enumerate(week):
-            x = int(day_num * (cell_size + padding) * scale_factor)
-            y = int((week_num + 3) * (cell_size + padding) * scale_factor)
-
-            cell_width = int(cell_size * scale_factor)
-            cell_height = int(cell_size * scale_factor)
-
-            text_x = (
-                int(x + (cell_width - draw.textlength(str(day), font=font)) // 2)
-                + cell_size
-            )
-            text_y = (
-                int(y + (cell_height - draw.textlength(str(day), font=font)) // 2) - 55
-            )
-
-            if day != 0:
-                draw.text(
-                    (text_x, text_y),
-                    str(day),
-                    (240, 200, 100),
-                    font,
-                    stroke_width=1,
-                    stroke_fill=(0, 0, 0),
-                )
-
-    filename = f"calendar_{int(time.time())}.png"
-    calendar_image.save(filename, "PNG")
-    calendar_image.close()
-
-    return filename
-
-
-async def create_thumbnail(photo: str, xy: tuple[int, int], file_size: int):
-    img = Image.open(photo)
-    img.thumbnail(xy)
-
-    size_in_bytes = file_size * 1024
-    quality = 90
-
-    while True:
-        img.save(photo, "JPEG", quality=quality, optimize=True)
-        if os.path.getsize(photo) <= size_in_bytes:
-            break
-
-        quality -= 5
-
-    return photo
-
-
-async def download_images(query: str, limit: int) -> list[str]:
-    offset = random.randint(0, 20)
-
-    crawler = BingImageCrawler(log_level=logging.ERROR)
-    crawler.crawl(query, offset=offset, max_num=limit)
-
-    return [os.path.join("images", image) for image in os.listdir("images")]

HellBot/functions/media.py

@@ -1,192 +0,0 @@
-import os
-from typing import Union
-
-import requests
-from pyrogram import Client
-from pyrogram.file_id import FileId
-from pyrogram.raw.functions.messages import UploadMedia
-from pyrogram.raw.types import (
-    DocumentAttributeFilename,
-    InputDocument,
-    InputMediaUploadedDocument,
-)
-from pyrogram.types import Animation, Audio, Document, Message, Photo, Sticker, Video
-
-from Hellbot.core import Symbols
-
-
-async def get_metedata(media: Union[Animation, Audio, Document, Photo, Sticker, Video]):
-    output = "📄 MetaData:\n\n"
-    if isinstance(media, Animation):
-        output += f"<b>{Symbols.diamond_2} File ID:</b> <code>{media.file_id}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Width:</b> <code>{media.width}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Height:</b> <code>{media.height}</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} Duration:</b> <code>{media.duration}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} File Name:</b> <code>{media.file_name}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} Mime Type:</b> <code>{media.mime_type}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} File Size:</b> <code>{media.file_size}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} Date:</b> <code>{media.date}</code>\n"
-        output += f"<b>{Symbols.diamond_2} File Type:</b> <code>Animation</code>\n"
-    elif isinstance(media, Audio):
-        output += f"<b>{Symbols.diamond_2} File ID:</b> <code>{media.file_id}</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} Duration:</b> <code>{media.duration}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} Performer:</b> <code>{media.performer}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} Title:</b> <code>{media.title}</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} File Name:</b> <code>{media.file_name}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} Mime Type:</b> <code>{media.mime_type}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} File Size:</b> <code>{media.file_size}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} Date:</b> <code>{media.date}</code>\n"
-        output += f"<b>{Symbols.diamond_2} File Type:</b> <code>Audio</code>\n"
-    elif isinstance(media, Document):
-        output += f"<b>{Symbols.diamond_2} File ID:</b> <code>{media.file_id}</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} File Name:</b> <code>{media.file_name}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} Mime Type:</b> <code>{media.mime_type}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} File Size:</b> <code>{media.file_size}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} Date:</b> <code>{media.date}</code>\n"
-        output += f"<b>{Symbols.diamond_2} File Type:</b> <code>Document</code>\n"
-    elif isinstance(media, Photo):
-        output += f"<b>{Symbols.diamond_2} File ID:</b> <code>{media.file_id}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Width:</b> <code>{media.width}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Height:</b> <code>{media.height}</code>\n"
-        output += f"<b>{Symbols.diamond_2} File Name:</b> <code>photo.jpg</code>\n"
-        output += f"<b>{Symbols.diamond_2} Mime Type:</b> <code>image/jpeg</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} File Size:</b> <code>{media.file_size}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} Date:</b> <code>{media.date}</code>\n"
-        output += f"<b>{Symbols.diamond_2} File Type:</b> <code>Photo</code>\n"
-    elif isinstance(media, Sticker):
-        output += f"<b>{Symbols.diamond_2} File ID:</b> <code>{media.file_id}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Width:</b> <code>{media.width}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Height:</b> <code>{media.height}</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} File Name:</b> <code>{media.file_name}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} Mime Type:</b> <code>{media.mime_type}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} File Size:</b> <code>{media.file_size}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} Date:</b> <code>{media.date}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Emoji:</b> <code>{media.emoji}</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} Set Name:</b> <code>{media.set_name}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} File Type:</b> <code>Sticker</code>\n"
-    elif isinstance(media, Video):
-        output += f"<b>{Symbols.diamond_2} File ID:</b> <code>{media.file_id}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Width:</b> <code>{media.width}</code>\n"
-        output += f"<b>{Symbols.diamond_2} Height:</b> <code>{media.height}</code>\n"
-        output += (
-            f"<b>{Symbols.diamond_2} Duration:</b> <code>{media.duration}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} File Name:</b> <code>{media.file_name}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} Mime Type:</b> <code>{media.mime_type}</code>\n"
-        )
-        output += (
-            f"<b>{Symbols.diamond_2} File Size:</b> <code>{media.file_size}</code>\n"
-        )
-        output += f"<b>{Symbols.diamond_2} Date:</b> <code>{media.date}</code>\n"
-        output += f"<b>{Symbols.diamond_2} File Type:</b> <code>Video</code>\n"
-    else:
-        return None
-
-    return output
-
-
-def get_media_text_ocr(filename: str, api_key: str, language: str = "eng") -> dict:
-    payload = {
-        "isOverlayRequired": False,
-        "apikey": api_key,
-        "language": language,
-    }
-
-    with open(filename, "rb") as f:
-        r = requests.post(
-            "https://api.ocr.space/parse/image",
-            files={filename: f},
-            data=payload,
-        )
-
-    return r.json()
-
-
-async def upload_media(client: Client, chat_id: int, file: str) -> InputDocument:
-    media = await client.invoke(
-        UploadMedia(
-            peer=(await client.resolve_peer(chat_id)),
-            media=InputMediaUploadedDocument(
-                file=(await client.save_file(file)),
-                mime_type=client.guess_mime_type(file) or "application/zip",
-                attributes=[
-                    DocumentAttributeFilename(file_name=os.path.basename(file))
-                ],
-                force_file=True,
-            ),
-        ),
-    )
-
-    return InputDocument(
-        id=media.document.id,
-        access_hash=media.document.access_hash,
-        file_reference=media.document.file_reference,
-    )
-
-
-async def get_media_from_id(file_id: str) -> InputDocument:
-    file = FileId.decode(file_id)
-
-    return InputDocument(
-        id=file.media_id,
-        access_hash=file.access_hash,
-        file_reference=file.file_reference,
-    )
-
-
-async def get_media_fileid(message: Message) -> str | None:
-    file_id = None
-    if message.photo:
-        file_id = message.photo.file_id
-    elif message.animation:
-        file_id = message.animation.file_id
-    elif message.audio:
-        file_id = message.audio.file_id
-    elif message.document:
-        file_id = message.document.file_id
-    elif message.video:
-        file_id = message.video.file_id
-    elif message.sticker:
-        file_id = message.sticker.file_id
-    elif message.video_note:
-        file_id = message.video_note.file_id
-    elif message.voice:
-        file_id = message.voice.file_id
-    return file_id

HellBot/functions/paste.py

@@ -1,49 +0,0 @@
-import uuid
-
-import requests
-
-from .utility import TGraph
-
-
-def post_to_telegraph(
-    title: str,
-    content: str,
-    author: str = "[ 𝖧𝖾𝗅𝗅𝖡𝗈𝗍 ]",
-    url: str = "https://t.me/Its_HellBot",
-) -> str:
-    content = content.replace("\n", "<br>")
-    try:
-        response = TGraph.telegraph.create_page(
-            title=title,
-            html_content=content,
-            author_name=author,
-            author_url=url,
-        )
-    except Exception:
-        rnd_key = uuid.uuid4().hex[:8]
-        title = f"{title}_{rnd_key}"
-        response = TGraph.telegraph.create_page(
-            title=title,
-            html_content=content,
-            author_name=author,
-            author_url=url,
-        )
-
-    return f"https://te.legra.ph/{response['path']}"
-
-
-def spaceBin(data: str, extension: str = "none") -> str:
-    data = {
-        "content": data,
-        "extension": extension,
-    }
-
-    resp = requests.post("https://spaceb.in/api/v1/documents/", data)
-
-    try:
-        result = resp.json()
-        url = f"https://spaceb.in/{result['payload']['id']}"
-    except Exception:
-        url = ""
-
-    return url

HellBot/functions/scraping.py

@@ -1,528 +0,0 @@
-import calendar
-import time
-
-import httpx
-from bs4 import BeautifulSoup
-from urllib.parse import quote, urlparse
-from Hellbot.core import Symbols
-
-from .paste import post_to_telegraph
-from .templates import (
-    airing_templates,
-    anilist_user_templates,
-    anime_template,
-    character_templates,
-    manga_templates,
-)
-
-anime_query = """query ($id: Int,$search: String) {
-    Page (perPage: 10) {
-        media (id: $id, type: ANIME,search: $search) {
-            id
-            title {
-                romaji
-                english
-                native
-            }
-            type
-            format
-            status
-            description (asHtml: false)
-            episodes
-            duration
-            countryOfOrigin
-            source
-            trailer{
-                id
-                site
-            }
-            genres
-            tags {
-                name
-            }
-            isAdult
-            averageScore
-            studios (isMain: true){
-                nodes{
-                    name
-                }
-            }
-            nextAiringEpisode{
-                episode
-            }
-            siteUrl
-        }
-    }
-}"""
-
-
-manga_query = """query ($id: Int,$search: String) {
-    Page (perPage: 10) {
-        media (id: $id, type: MANGA,search: $search) {
-            id
-            title {
-                romaji
-                english
-                native
-            }
-            type
-            format
-            status
-            description (asHtml: false)
-            chapters
-            volumes
-            countryOfOrigin
-            source
-            genres
-            isAdult
-            averageScore
-            siteUrl
-        }
-    }
-}"""
-
-
-character_query = """query ($id: Int, $search: String) {
-  	Page {
-	    characters (id: $id, search: $search) {
-            id
-            name {
-                full
-        	    native
-      	    }
-          	image {
-                large
-            }
-      	    description
-            gender
-            dateOfBirth {
-                year
-                month
-                day
-            }
-            age
-            bloodType
-      	    siteUrl
-            favourites
-            media {
-                nodes {
-                    title {
-                        romaji
-                        english
-                        native
-                    }
-                    type
-                    format
-                    siteUrl
-                }
-            }
-        }
-    }
-}"""
-
-
-airing_query = """query ($id: Int, $idMal:Int, $search: String) {
-    Media (id: $id, idMal: $idMal, search: $search, type: ANIME) {
-        id
-        title {
-            romaji
-            english
-            native
-        }
-        status
-        episodes
-        countryOfOrigin
-        nextAiringEpisode {
-            airingAt
-            timeUntilAiring
-            episode
-        }
-    }
-}"""
-
-
-anilist_user_query = """query($id: Int, $search: String) {
-	User(id: $id, name: $search) {
-		id
-		name
-        siteUrl
-        statistics {
-            anime {
-                count
-                meanScore
-                minutesWatched
-                episodesWatched
-            }
-            manga {
-                count
-                meanScore
-                chaptersRead
-                volumesRead
-            }
-        }
-	}
-}"""
-
-
-def is_valid_url(text: str) -> bool:
-    try:
-        result = urlparse(text)
-        return all([result.scheme, result.netloc])
-    except ValueError:
-        return False
-
-
-def post_request(query: str, search_term: str):
-    url = "https://graphql.anilist.co"
-    variables = {"search": search_term}
-    r = httpx.post(url, json={"query": query, "variables": variables})
-    if r.status_code != 200:
-        return None
-    return r.json()
-
-
-def get_country_flag(country: str) -> str:
-    base = ord('🇦')
-    emoji_flag = "".join(chr(base + ord(letter) - ord("A")) for letter in country)
-    return emoji_flag
-
-
-def get_date(data: dict) -> str:
-    try:
-        year = data["year"] or ""
-        if not year and not data["month"]:
-            return "N/A"
-        day = data["day"]
-        if 10 <= day % 100 <= 20:
-            day = f"{day}th"
-        else:
-            day_dict = {1: "st", 2: "nd", 3: "rd"}
-            day = f"{day}{day_dict.get(day % 10, 'th')}"
-        month_name = calendar.month_name[int(data["month"])]
-        return f"{day} {month_name} {year}"
-    except:
-        return "N/A"
-
-
-def search_anime_filler(search_term: str):
-    BASE = "https://www.animefillerlist.com/shows/"
-
-    response = httpx.get(BASE).text
-    soup = BeautifulSoup(response, "html.parser")
-    div = soup.findAll("div", {"class": "Group"})
-
-    index = {}
-    for i in div:
-        li = i.findAll("li")
-        for j in li:
-            index[j.text] = j.a["href"].split("/")[-1]
-
-    results = {}
-    keys = list(index.keys())
-    for i in range(len(keys)):
-        if search_term.lower() in keys[i].lower():
-            results[keys[i]] = index[keys[i]]
-
-    for result in results.keys():
-        data = []
-        response = httpx.get(BASE + results[result]).text
-        soup = BeautifulSoup(response, "html.parser")
-        base_div = soup.find("div", {"id": "Condensed"})
-
-        if not base_div:
-            continue
-
-        divs = base_div.findAll("div")
-        for div in divs:
-            heading = div.find("span", {"class": "Label"}).text
-            episodes = div.find("span", {"class": "Episodes"}).text
-            data.append((heading, episodes))
-
-        yield result, data
-
-
-async def get_filler_info(search_term: str) -> str:
-    animes = search_anime_filler(search_term)
-    message = ""
-
-    for anime in animes:
-        html_message = f"<strong>{Symbols.check_mark} {anime[0]} Filler Guide:</strong>\n\n"
-
-        for data in anime[1]:
-            html_message += (
-                f"<h3>{Symbols.bullet} {data[0]}:</h3> \n<code>{data[1]}</code>\n\n"
-            )
-
-        paste = post_to_telegraph(anime[0] + " Filler Guide", html_message)
-        message += f"{Symbols.anchor} [{anime[0]}]({paste})\n"
-
-    return message
-
-
-def search_watch_order(anime: str):
-    response = httpx.get(f"https://www.animechrono.com/search?q={quote(anime)}")
-    soup = BeautifulSoup(response.text, "html.parser")
-
-    item_div = soup.find("div", {"class": "search-result-items"})
-    animes = item_div.find_all("a", {"class": "list-item search w-inline-block"})
-
-    for anime in animes:
-        name = anime.find("h1", "h1 search").text
-        yield name, anime["href"]
-
-
-async def get_watch_order(search_term: str) -> str:
-    animes = search_watch_order(search_term)
-    message = ""
-
-    for anime in animes:
-        message += f"**{Symbols.anchor} {anime[0]}:** \n"
-        response = httpx.get("https://www.animechrono.com" + anime[1]).text
-        soup = BeautifulSoup(response, "html.parser")
-
-        elements = soup.find_all("h2", {"class": "heading-5"})
-        for element in elements:
-            message += f"    {Symbols.bullet} `{element.text}`\n"
-        message += "\n"
-
-    return message
-
-
-async def get_anime_info(search_term: str) -> tuple[str, str]:
-    data = post_request(anime_query, search_term)
-    if not data:
-        return "", ""
-
-    data = data["data"]["Page"]["media"][0]
-    english_title = data["title"]["english"]
-    native_title = data["title"]["native"]
-    if not english_title:
-        english_title = data["title"]["romaji"]
-    flag = get_country_flag(data["countryOfOrigin"])
-    name = f"**[{flag}] {english_title} ({native_title})**"
-
-    anime_id = data["id"]
-    score = data["averageScore"] if data["averageScore"] else "N/A"
-    source = str(data["source"]).title() if data["source"] else "N/A"
-    mtype = str(data["type"]).title() if data["type"] else "N/A"
-    synopsis = data["description"]
-
-    episodes = data["episodes"]
-    if not episodes:
-        try:
-            episodes = data["nextAiringEpisode"]["episode"] - 1
-        except:
-            episodes = "N/A"
-
-    duration = data["duration"] if data["duration"] else "N/A"
-    status = str(data["status"]).title() if data["status"] else "N/A"
-    format = str(data["format"]).title() if data["format"] else "N/A"
-    genre = ", ".join(data["genres"]) if data["genres"] else "N/A"
-    tags = ", ".join([i["name"] for i in data["tags"][:5]]) if data["tags"] else "N/A"
-    studio = data["studios"]["nodes"][0]["name"] if data["studios"]["nodes"] else "N/A"
-    siteurl = f"[Anilist Website]({data['siteUrl']})" if data["siteUrl"] else "N/A"
-    isAdult = data["isAdult"]
-
-    trailer = "N/A"
-    if data["trailer"] and data["trailer"]["site"] == "youtube":
-        trailer = f"[Youtube](https://youtu.be/{data['trailer']['id']})"
-
-    response = httpx.get(f"https://img.anili.st/media/{anime_id}").content
-    banner = f"anime_{anime_id}.jpg"
-    with open(banner, "wb") as f:
-        f.write(response)
-
-    description = post_to_telegraph(name, synopsis)
-
-    message = await anime_template(
-        name=name,
-        score=score,
-        source=source,
-        mtype=mtype,
-        episodes=episodes,
-        duration=duration,
-        status=status,
-        format=format,
-        genre=genre,
-        studio=studio,
-        trailer=trailer,
-        siteurl=siteurl,
-        description=description,
-        tags=tags,
-        isAdult=isAdult,
-    )
-
-    return message, banner
-
-
-async def get_manga_info(search_term: str) -> tuple[str, str]:
-    data = post_request(manga_query, search_term)
-    if not data:
-        return "", ""
-
-    data = data["data"]["Page"]["media"][0]
-    english_title = data["title"]["english"]
-    native_title = data["title"]["native"]
-    if not english_title:
-        english_title = data["title"]["romaji"]
-    flag = get_country_flag(data["countryOfOrigin"])
-    name = f"**[{flag}] {english_title} ({native_title})**"
-
-    manga_id = data["id"]
-    score = data["averageScore"] if data["averageScore"] else "N/A"
-    source = str(data["source"]).title() if data["source"] else "N/A"
-    mtype = str(data["type"]).title() if data["type"] else "N/A"
-    synopsis = data["description"]
-
-    chapters = data["chapters"] if data["chapters"] else "N/A"
-    volumes = data["volumes"] if data["volumes"] else "N/A"
-    status = str(data["status"]).title() if data["status"] else "N/A"
-    format = str(data["format"]).title() if data["format"] else "N/A"
-    genre = ", ".join(data["genres"]) if data["genres"] else "N/A"
-    siteurl = f"[Anilist Website]({data['siteUrl']})" if data["siteUrl"] else "N/A"
-    isAdult = data["isAdult"]
-
-    response = httpx.get(f"https://img.anili.st/media/{manga_id}").content
-    banner = f"manga_{manga_id}.jpg"
-    with open(banner, "wb") as f:
-        f.write(response)
-
-    description = post_to_telegraph(name, synopsis)
-
-    message = await manga_templates(
-        name=name,
-        score=score,
-        source=source,
-        mtype=mtype,
-        chapters=chapters,
-        volumes=volumes,
-        status=status,
-        format=format,
-        genre=genre,
-        siteurl=siteurl,
-        description=description,
-        isAdult=isAdult,
-    )
-
-    return message, banner
-
-
-async def get_character_info(search_term: str) -> tuple[str, str]:
-    data = post_request(character_query, search_term)
-    if not data:
-        return "", ""
-
-    data = data["data"]["Page"]["characters"][0]
-    name = f"**{data['name']['full']} ({data['name']['native']})**"
-    char_id = data["id"]
-
-    description = data["description"].split("\n\n", 1)[0]
-    gender = data["gender"] if data["gender"] else "N/A"
-    date_of_birth = get_date(data["dateOfBirth"])
-    age = data["age"] if data["age"] else "N/A"
-    blood_type = data["bloodType"] if data["bloodType"] else "N/A"
-    siteurl = f"[Anilist Website]({data['siteUrl']})" if data["siteUrl"] else "N/A"
-    favorites = data["favourites"] if data["favourites"] else "N/A"
-
-    cameo = data["media"]["nodes"][0] if data["media"]["nodes"] else {}
-    if cameo:
-        role_in = f"\n╰➢ **𝖱𝗈𝗅𝖾 𝖨𝗇:** [{cameo['title']['romaji']}]({cameo['siteUrl']})"
-    else:
-        role_in = ""
-
-    response = httpx.get(data["image"]["large"]).content
-    banner = f"character_{char_id}.jpg"
-    with open(banner, "wb") as f:
-        f.write(response)
-
-    message = await character_templates(
-        name=name,
-        gender=gender,
-        date_of_birth=date_of_birth,
-        age=age,
-        blood_type=blood_type,
-        favorites=favorites,
-        siteurl=siteurl,
-        role_in=role_in,
-        description=description,
-    )
-
-    return message, banner
-
-
-async def get_airing_info(search_term: str) -> tuple[str, str]:
-    data = post_request(airing_query, search_term)
-    if not data:
-        return "", ""
-
-    data = data["data"]["Media"]
-    english_title = data["title"]["english"]
-    native_title = data["title"]["native"]
-    if not english_title:
-        english_title = data["title"]["romaji"]
-    flag = get_country_flag(data["countryOfOrigin"])
-    name = f"**[{flag}] {english_title} ({native_title})**"
-
-    episode = data["episodes"]
-    if not episode:
-        try:
-            episode = data["nextAiringEpisode"]["episode"]
-        except:
-            episode = "N/A"
-
-    response = httpx.get(f"https://img.anili.st/media/{data['id']}").content
-    banner = f"airing_{data['id']}.jpg"
-    with open(banner, "wb") as f:
-        f.write(response)
-
-    status = str(data["status"]).title() if data["status"] else "N/A"
-    next_date = data["nextAiringEpisode"]["airingAt"] if data["nextAiringEpisode"] else ""
-
-    airing_info = ""
-    if next_date:
-        airing_info = f"\n**🗓️ {time.ctime(next_date)}**"
-
-    message = await airing_templates(
-        name=name,
-        status=status,
-        episode=episode,
-        airing_info=airing_info,
-    )
-
-    return message, banner
-
-
-async def get_anilist_user_info(search_term: str) -> tuple[str, str]:
-    data = post_request(anilist_user_query, search_term)
-    if not data:
-        return "", ""
-
-    data = data["data"]["User"]
-    user_id = data["id"]
-    name = data['name']
-    siteurl = f"[Anilist Website]({data['siteUrl']})" if data["siteUrl"] else "N/A"
-
-    response = httpx.get(f"https://img.anili.st/user/{user_id}").content
-    banner = f"aniuser_{user_id}.jpg"
-    with open(banner, "wb") as f:
-        f.write(response)
-
-    anime_stats = data["statistics"]["anime"]
-    manga_stats = data["statistics"]["manga"]
-
-    anime = (
-        anime_stats["count"] or 0,
-        anime_stats["meanScore"] or 0,
-        anime_stats["minutesWatched"] or 0,
-        anime_stats["episodesWatched"] or 0,
-    )
-    manga = (
-        manga_stats["count"] or 0,
-        manga_stats["meanScore"] or 0,
-        manga_stats["chaptersRead"] or 0,
-        manga_stats["volumesRead"] or 0,
-    )
-
-    message = await anilist_user_templates(name, anime, manga, siteurl)
-
-    return message, banner

HellBot/functions/sticker.py

@@ -1,135 +0,0 @@
-from typing import Tuple
-
-from emoji import EMOJI_DATA
-from pyrogram import Client
-from pyrogram.raw.functions.messages import GetStickerSet
-from pyrogram.raw.functions.stickers import AddStickerToSet, CreateStickerSet, RemoveStickerFromSet
-from pyrogram.raw import base, types
-from pyrogram.types import Message
-
-from .media import get_media_from_id, upload_media
-
-
-def is_emoji(text: str) -> bool:
-    return any(c in EMOJI_DATA for c in text)
-
-
-def get_emoji_and_id(message: Message) -> Tuple[int, str]:
-    pack_id = None
-    pack_emoji = None
-
-    for command in message.command:
-        if command.isdigit():
-            pack_id = int(command)
-        elif is_emoji(command):
-            pack_emoji = command
-
-    if pack_id is None:
-        pack_id = 1
-
-    if pack_emoji is None:
-        sticker = message.reply_to_message.sticker
-        try:
-            pack_emoji = sticker.emoji if sticker and sticker.emoji else "🍀"
-        except:
-            pack_emoji = "🍀"
-
-    return pack_id, pack_emoji
-
-
-def check_sticker_data(replied: Message) -> Tuple[str | None, bool, bool, bool, int]:
-    pack_type = None
-    is_animated = False
-    is_video = False
-    is_static = False
-    pack_limit = 50
-
-    if replied.sticker:
-        if replied.sticker.is_animated:
-            pack_type, is_animated = "animated", True
-        elif replied.sticker.is_video:
-            pack_type, is_video = "video", True
-        else:
-            pack_type, is_static, pack_limit = "static", True, 120
-
-    elif replied.photo:
-        pack_type, is_static, pack_limit = "static", True, 120
-
-    elif replied.video or replied.animation:
-        pack_type, is_video = "video", True
-
-    elif replied.document:
-        mime_type = replied.document.mime_type.lower()
-        if mime_type.startswith("video/"):
-            pack_type, is_video = "video", True
-        elif mime_type.startswith("image/"):
-            pack_type, is_static, pack_limit = "static", True, 120
-        elif mime_type in ["application/x-tgsticker", "application/x-bad-tgsticker"]:
-            pack_type, is_animated = "animated", True
-
-    return pack_type, is_animated, is_video, is_static, pack_limit
-
-
-async def create_sticker(
-    client: Client,
-    chat_id: int,
-    file: str,
-    emoji: str,
-) -> types.InputStickerSetItem:
-    sticker = await upload_media(client, chat_id, file)
-
-    return types.InputStickerSetItem(
-        document=sticker,
-        emoji=emoji,
-    )
-
-
-async def remove_sticker(client: Client, stickerid: str) -> base.messages.StickerSet:
-    sticker = await get_media_from_id(stickerid)
-    return await client.invoke(RemoveStickerFromSet(sticker=sticker))
-
-
-async def get_sticker_set(client: Client, name: str) -> base.messages.StickerSet | None:
-    try:
-        return await client.invoke(
-            GetStickerSet(
-                stickerset=types.InputStickerSetShortName(short_name=name),
-                hash=0,
-            )
-        )
-    except:
-        return None
-
-
-async def add_sticker(
-    client: Client,
-    stickerset: base.messages.StickerSet,
-    sticker: base.InputStickerSetItem,
-) -> base.messages.StickerSet:
-    return await client.invoke(
-        AddStickerToSet(
-            stickerset=types.InputStickerSetShortName(short_name=stickerset.set.short_name),
-            sticker=sticker,
-        )
-    )
-
-
-async def new_sticker_set(
-    client: Client,
-    user_id: int,
-    title: str,
-    short_name: str,
-    stickers: list[base.InputStickerSetItem],
-    animated: bool,
-    video: bool,
-) -> base.messages.StickerSet:
-    return await client.invoke(
-        CreateStickerSet(
-            user_id=(await client.resolve_peer(user_id)),
-            title=title,
-            short_name=short_name,
-            stickers=stickers,
-            animated=animated,
-            videos=video,
-        )
-    )

HellBot/functions/templates.py

@@ -1,466 +0,0 @@
-import random
-
-from Hellbot import __version__
-from Hellbot.core import ENV, db
-
-ALIVE_TEMPLATES = [
-    (
-        "•────────────────•\n"
-        "•       𝐇ᴇʟʟ𝐁ᴏᴛ 𝐈s 𝐀ʟɪᴠᴇ        •\n"
-        "╭────────────────•\n"
-        "╰➢ ᴏᴡɴᴇʀ » {owner}\n"
-        "╰➢ ᴘʏʀᴏɢʀᴀᴍ » {pyrogram}\n"
-        "╰➢ ʜᴇʟʟʙᴏᴛ » {hellbot}\n"
-        "╰➢ ᴘʏᴛʜᴏɴ » {python}\n"
-        "╰➢ ᴜᴘᴛɪᴍᴇ » {uptime}\n"
-        "╰────────────────•\n"
-        "𝖡𝗒 © @HellBot_Networks\n"
-        "•────────────────•\n"
-    ),
-]
-
-PING_TEMPLATES = [
-    """**🍀 𝖯𝗂𝗇𝗀!**
-
-    ⚘  **ѕρєє∂:** {speed} m/s
-    ⚘  **υρтιмє:** {uptime}
-    ⚘  **σωηєя:** {owner}""",
-]
-
-HELP_MENU_TEMPLATES = [
-    """**🍀 𝖧𝖾𝗅𝗉 𝖬𝖾𝗇𝗎 𝖿𝗈𝗋:** {owner}
-
-__📃 𝖫𝗈𝖺𝖽𝖾𝖽__ **{plugins} 𝗉𝗅𝗎𝗀𝗂𝗇𝗌** __𝗐𝗂𝗍𝗁 𝖺 𝗍𝗈𝗍𝖺𝗅 𝗈𝖿__ **{commands} 𝖼𝗈𝗆𝗆𝖺𝗇𝖽𝗌.**
-
-**📑 Page:** __{current}/{last}__""",
-]
-
-COMMAND_MENU_TEMPLATES = [
-    """**𝖯𝗅𝗎𝗀𝗂𝗇 𝖥𝗂𝗅𝖾:** `{file}`
-**𝖯𝗅𝗎𝗀𝗂𝗇 𝖨𝗇𝖿𝗈:** __{info} 🍀__
-
-**📃 𝖫𝗈𝖺𝖽𝖾𝖽 𝖢𝗈𝗆𝗆𝖺𝗇𝖽𝗌:** `{commands}`""",
-]
-
-ANIME_TEMPLATES = [
-    """
-{name}
-
-╭────────────────•
-╰➢ **𝖲𝖼𝗈𝗋𝖾:** `{score}`
-╰➢ **𝖲𝗈𝗎𝗋𝖼𝖾:** `{source}`
-╰➢ **𝖳𝗒𝗉𝖾:** `{mtype}`
-╰➢ **𝖤𝗉𝗂𝗌𝗈𝖽𝖾𝗌:** `{episodes}`
-╰➢ **𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{duration} minutes`
-╰➢ **𝖲𝗍𝖺𝗍𝗎𝗌:** `{status}`
-╰➢ **𝖥𝗈𝗋𝗆𝖺𝗍:** `{format}`
-╰➢ **𝖦𝖾𝗇𝗋𝖾:** `{genre}`
-╰➢ **𝖳𝖺𝗀𝗌:** `{tags}`
-╰➢ **𝖠𝖽𝗎𝗅𝗍 𝖱𝖺𝗍𝖾𝖽:** `{isAdult}`
-╰➢ **𝖲𝗍𝗎𝖽𝗂𝗈:** `{studio}`
-╰➢ **𝖳𝗋𝖺𝗂𝗅𝖾𝗋:** {trailer}
-╰➢ **𝖶𝖾𝖻𝗌𝗂𝗍𝖾:** {siteurl}
-╰➢ **𝖲𝗒𝗇𝗈𝗉𝗌𝗂𝗌:** [𝖢𝗅𝗂𝖼𝗄 𝖧𝖾𝗋𝖾]({description})
-╰────────────────•
-"""
-]
-
-MANGA_TEMPLATES = [
-    """
-{name}
-
-╭────────────────•
-╰➢ **𝖲𝖼𝗈𝗋𝖾:** `{score}`
-╰➢ **𝖲𝗈𝗎𝗋𝖼𝖾:** `{source}`
-╰➢ **𝖳𝗒𝗉𝖾:** `{mtype}`
-╰➢ **𝖢𝗁𝖺𝗉𝗍𝖾𝗋𝗌:** `{chapters}`
-╰➢ **𝖵𝗈𝗅𝗎𝗆𝖾𝗌:** `{volumes}`
-╰➢ **𝖲𝗍𝖺𝗍𝗎𝗌:** `{status}`
-╰➢ **𝖥𝗈𝗋𝗆𝖺𝗍:** `{format}`
-╰➢ **𝖦𝖾𝗇𝗋𝖾:** `{genre}`
-╰➢ **𝖠𝖽𝗎𝗅𝗍 𝖱𝖺𝗍𝖾𝖽:** `{isAdult}`
-╰➢ **𝖶𝖾𝖻𝗌𝗂𝗍𝖾:** {siteurl}
-╰➢ **𝖲𝗒𝗇𝗈𝗉𝗌𝗂𝗌:** [𝖢𝗅𝗂𝖼𝗄 𝖧𝖾𝗋𝖾]({description})
-╰────────────────•
-"""
-]
-
-CHARACTER_TEMPLATES = [
-    """
-{name}
-
-╭────────────────•
-╰➢ **𝖦𝖾𝗇𝖽𝖾𝗋:** `{gender}`
-╰➢ **𝖣𝖺𝗍𝖾 𝗈𝖿 𝖡𝗂𝗋𝗍𝗁:** `{date_of_birth}`
-╰➢ **𝖠𝗀𝖾:** `{age}`
-╰➢ **𝖡𝗅𝗈𝗈𝖽 𝖳𝗒𝗉𝖾:** `{blood_type}`
-╰➢ **𝖥𝖺𝗏𝗈𝗎𝗋𝗂𝗍𝖾𝗌:** `{favorites}`
-╰➢ **𝖶𝖾𝖻𝗌𝗂𝗍𝖾:** {siteurl}{role_in}
-╰────────────────•
-{description}
-"""
-]
-
-AIRING_TEMPLATES = [
-    """
-{name}
-
-╭────────────────•
-╰➢ **𝖲𝗍𝖺𝗍𝗎𝗌:** `{status}`
-╰➢ **𝖤𝗉𝗂𝗌𝗈𝖽𝖾:** `{episode}`
-╰────────────────•{airing_info}
-"""
-]
-
-ANILIST_USER_TEMPLATES = [
-    """
-**💫 {name}**
-
-╭──── 𝖠𝗇𝗂𝗆𝖾 ─────•
-╰➢ **𝖢𝗈𝗎𝗇𝗍:** `{anime_count}`
-╰➢ **𝖲𝖼𝗈𝗋𝖾:** `{anime_score}`
-╰➢ **𝖬𝗂𝗇𝗎𝗍𝖾𝗌 𝖲𝗉𝖾𝗇𝗍:** `{minutes}`
-╰➢ **𝖤𝗉𝗂𝗌𝗈𝖽𝖾𝗌 𝖶𝖺𝗍𝖼𝗁𝖾𝖽:** `{episodes}`
-╰────────────────•
-╭──── 𝖬𝖺𝗇𝗀𝖺 ─────•
-╰➢ **𝖢𝗈𝗎𝗇𝗍:** `{manga_count}`
-╰➢ **𝖲𝖼𝗈𝗋𝖾:** `{manga_score}`
-╰➢ **𝖢𝗁𝖺𝗉𝗍𝖾𝗋𝗌:** `{chapters}`
-╰➢ **𝖵𝗈𝗅𝗎𝗆𝖾𝗌:** `{volumes}`
-╰────────────────•
-
-𝖶𝖾𝖻𝗌𝗂𝗍𝖾: {siteurl}
-"""
-]
-
-CLIMATE_TEMPLATES = [
-    """
-🌆 {city_name}, {country}
-
-╭────────────────•
-╰➢ **𝖶𝖾𝖺𝗍𝗁𝖾𝗋:** {weather}
-╰➢ **𝖳𝗂𝗆𝖾𝗓𝗈𝗇𝖾:** {timezone}
-╰➢ **𝖲𝗎𝗇𝗋𝗂𝗌𝖾:** {sunrise}
-╰➢ **𝖲𝗎𝗇𝗌𝖾𝗍:** {sunset}
-╰➢ **𝖶𝗂𝗇𝖽:** {wind}
-╰➢ **𝖳𝖾𝗆𝗉𝖾𝗋𝖺𝗍𝗎𝗋𝖾:** {temperature}°C
-╰➢ **𝖥𝖾𝖾𝗅𝗌 𝗅𝗂𝗄𝖾:** {feels_like}°C
-╰➢ **𝖬𝗂𝗇𝗂𝗆𝗎𝗆:** {temp_min}°C
-╰➢ **𝖬𝖺𝗑𝗂𝗆𝗎𝗆:** {temp_max}°C
-╰➢ **𝖯𝗋𝖾𝗌𝗌𝗎𝗋𝖾:** {pressure} hPa
-╰➢ **𝖧𝗎𝗆𝗂𝖽𝗂𝗍𝗒:** {humidity}%
-╰➢ **𝖵𝗂𝗌𝗂𝖻𝗂𝗅𝗂𝗍𝗒:** {visibility} m
-╰➢ **𝖢𝗅𝗈𝗎𝖽𝗌:** {clouds}%
-╰────────────────•
-"""
-]
-
-AIR_POLLUTION_TEMPLATES = [
-    """
-🌆 {city_name}
-
-╭────────────────•
-╰➢ **𝖠𝖰𝖨:** {aqi}
-╰➢ **𝖢𝖺𝗋𝖻𝗈𝗇 𝖬𝗈𝗇𝗈𝗑𝗂𝖽𝖾:** {co}
-╰➢ **𝖭𝗈𝗂𝗍𝗋𝗈𝗀𝖾𝗇 𝖬𝗈𝗇𝗈𝗑𝗂𝖽𝖾:** {no}
-╰➢ **𝖭𝗂𝗍𝗋𝗈𝗀𝖾𝗇 𝖣𝗂𝗈𝗑𝗂𝖽𝖾:** {no2}
-╰➢ **𝖮𝗓𝗈𝗇𝖾:** {o3}
-╰➢ **𝖲𝗎𝗅𝗉𝗁𝗎𝗋 𝖣𝗂𝗈𝗑𝗂𝖽𝖾:** {so2}
-╰➢ **𝖠𝗆𝗆𝗈𝗇𝗂𝖺:** {nh3}
-╰➢ **𝖥𝗂𝗇𝖾 𝖯𝖺𝗋𝗍𝗂𝖼𝗅𝖾𝗌 (PM{sub2_5}):** {pm2_5}
-╰➢ **𝖢𝗈𝖺𝗋𝗌𝖾 𝖯𝖺𝗋𝗍𝗂𝖼𝗅𝖾𝗌 (PM{sub10}):** {pm10}
-╰────────────────•
-"""
-]
-
-GITHUB_USER_TEMPLATES = [
-    """
-🍀 {username} ({git_id})
-
-╭──────── {id_type} ────────•
-╰➢ **𝖭𝖺𝗆𝖾:** [{name}]({profile_url})
-╰➢ **𝖡𝗅𝗈𝗀:** {blog}
-╰➢ **𝖢𝗈𝗆𝗉𝖺𝗇𝗒:** {company}
-╰➢ **𝖤𝗆𝖺𝗂𝗅:** {email}
-╰➢ **𝖫𝗈𝖼𝖺𝗍𝗂𝗈𝗇:** {location}
-╰➢ **𝖱𝖾𝗉𝗈:** {public_repos}
-╰➢ **𝖦𝗂𝗌𝗍𝗌:** {public_gists}
-╰➢ **𝖥𝗈𝗅𝗅𝗈𝗐𝖾𝗋𝗌:** {followers}
-╰➢ **𝖥𝗈𝗅𝗅𝗈𝗐𝗂𝗇𝗀:** {following}
-╰➢ **𝖠𝖼𝖼𝗈𝗎𝗇𝗍 𝖼𝗋𝖾𝖺𝗍𝖾𝖽:** {created_at}
-╰────────────────•
-
-**💫 𝖡𝗂𝗈:** {bio}
-"""
-]
-
-STATISTICS_TEMPLATES = [
-    """
-🍀 {name}
-
-╭──────── 𝖢𝗁𝖺𝗇𝗇𝖾𝗅𝗌 ────────•
-╰➢ **𝖳𝗈𝗍𝖺𝗅:** `{channels}`
-╰➢ **𝖠𝖽𝗆𝗂𝗇:** `{ch_admin}`
-╰➢ **𝖮𝗐𝗇𝖾𝗋:** `{ch_owner}`
-
-╭──────── 𝖦𝗋𝗈𝗎𝗉𝗌 ────────•
-╰➢ **𝖳𝗈𝗍𝖺𝗅:** `{groups}`
-╰➢ **𝖠𝖽𝗆𝗂𝗇:** `{gc_admin}`
-╰➢ **𝖮𝗐𝗇𝖾𝗋:** `{gc_owner}`
-
-╭──────── 𝖮𝗍𝗁𝖾𝗋𝗌 ────────•
-╰➢ **𝖯𝗋𝗂𝗏𝖺𝗍𝖾:** `{users}`
-╰➢ **𝖡𝗈𝗍𝗌:** `{bots}`
-╰➢ **𝖴𝗇𝗋𝖾𝖺𝖽 𝖬𝖾𝗌𝗌𝖺𝗀𝖾𝗌:** `{unread_msg}`
-╰➢ **𝖴𝗇𝗋𝖾𝖺𝖽 𝖬𝖾𝗇𝗍𝗂𝗈𝗇𝗌:** `{unread_mention}`
-
-⌛ **𝖳𝗂𝗆𝖾 𝖳𝖺𝗄𝖾𝗇:** `{time_taken}`
-"""
-]
-
-GBAN_TEMPLATES = [
-    """
-╭──────── {gtype} ────────•
-╰➢ **𝖵𝗂𝖼𝗍𝗂𝗆:** {name}
-╰➢ **𝖲𝗎𝖼𝖼𝖾𝗌𝗌:** {success}
-╰➢ **𝖥𝖺𝗂𝗅𝖾𝖽:** {failed}
-╰➢ **𝖱𝖾𝖺𝗌𝗈𝗇:** {reason}
-╰────────────────•
-"""
-]
-
-USAGE_TEMPLATES = [
-    """
-**📝 𝖣𝗂𝗌𝗄 & 𝖣𝗒𝗇𝗈 𝖴𝗌𝖺𝗀𝖾:**
-
-**➢ 𝖣𝗒𝗇𝗈 𝖴𝗌𝖺𝗀𝖾 𝖿𝗈𝗋** `{appName}`
-    ◈ __{appHours}hrs {appMinutes}mins__ | __{appPercentage}%__
-
-**➢ 𝖣𝗒𝗇𝗈 𝗋𝖾𝗆𝖺𝗂𝗇𝗂𝗇𝗀 𝗍𝗁𝗂𝗌 𝗆𝗈𝗇𝗍𝗁:**
-    ◈ __{hours}hrs {minutes}mins__ | __{percentage}%__
-
-**➢ 𝖣𝗂𝗌𝗄 𝖴𝗌𝖺𝗀𝖾:**
-    ◈ __{diskUsed}GB__ / __{diskTotal}GB__ | __{diskPercent}%__
-
-**➢ 𝖬𝖾𝗆𝗈𝗋𝗒 𝖴𝗌𝖺𝗀𝖾:**
-    ◈ __{memoryUsed}GB__ / __{memoryTotal}GB__ | __{memoryPercent}%__
-"""
-]
-
-USER_INFO_TEMPLATES = [
-    """
-**🍀 𝖴𝗌𝖾𝗋 𝖨𝗇𝖿𝗈 𝗈𝖿 {mention}:**
-
-**➢ 𝖥𝗂𝗋𝗌𝗍 𝖭𝖺𝗆𝖾:** `{firstName}`
-**➢ 𝖫𝖺𝗌𝗍 𝖭𝖺𝗆𝖾:** `{lastName}`
-**➢ 𝖴𝗌𝖾𝗋𝖨𝖣:** `{userId}`
-
-**➢ 𝖢𝗈𝗆𝗆𝗈𝗇 𝖦𝗋𝗈𝗎𝗉𝗌:** `{commonGroups}`
-**➢ 𝖣𝖢-𝖨𝖣:** `{dcId}`
-**➢ 𝖯𝗂𝖼𝗍𝗎𝗋𝖾𝗌:** `{totalPictures}`
-**➢ 𝖱𝖾𝗌𝗍𝗋𝗂𝖼𝗍𝖾𝖽:** `{isRestricted}`
-**➢ 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝖽:** `{isVerified}`
-**➢ 𝖡𝗈𝗍:** `{isBot}`
-**➢ 𝖡𝗂𝗈:** `{bio}`
-
-**</> @HellBot_Networks**
-"""
-]
-
-CHAT_INFO_TEMPLATES = [
-    """
-**🍀 𝖢𝗁𝖺𝗍 𝖨𝗇𝖿𝗈:**
-
-**➢ 𝖢𝗁𝖺𝗍 𝖭𝖺𝗆𝖾:** `{chatName}`
-**➢ 𝖢𝗁𝖺𝗍 𝖨𝖣:** `{chatId}`
-**➢ 𝖢𝗁𝖺𝗍 𝖫𝗂𝗇𝗄:** {chatLink}
-**➢ 𝖮𝗐𝗇𝖾𝗋:** {chatOwner}
-**➢ 𝖣𝖢-𝖨𝖣:** `{dcId}`
-**➢ 𝖬𝖾𝗆𝖻𝖾𝗋𝗌:** `{membersCount}`
-**➢ 𝖠𝖽𝗆𝗂𝗇𝗌:** `{adminsCount}`
-**➢ 𝖡𝗈𝗍𝗌:** `{botsCount}`
-**➢ 𝖣𝖾𝗌𝖼𝗋𝗂𝗉𝗍𝗂𝗈𝗇:** `{description}`
-
-**</> @HellBot_Networks**
-"""
-]
-
-
-async def alive_template(owner: str, uptime: str) -> str:
-    template = await db.get_env(ENV.alive_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(ALIVE_TEMPLATES)
-    return message.format(
-        owner=owner,
-        pyrogram=__version__["pyrogram"],
-        hellbot=__version__["hellbot"],
-        python=__version__["python"],
-        uptime=uptime,
-    )
-
-
-async def ping_template(speed: float, uptime: str, owner: str) -> str:
-    template = await db.get_env(ENV.ping_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(PING_TEMPLATES)
-    return message.format(speed=speed, uptime=uptime, owner=owner)
-
-
-async def help_template(
-    owner: str, cmd_n_plgn: tuple[int, int], page: tuple[int, int]
-) -> str:
-    template = await db.get_env(ENV.help_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(HELP_MENU_TEMPLATES)
-    return message.format(
-        owner=owner,
-        commands=cmd_n_plgn[0],
-        plugins=cmd_n_plgn[1],
-        current=page[0],
-        last=page[1],
-    )
-
-
-async def command_template(file: str, info: str, commands: str) -> str:
-    template = await db.get_env(ENV.command_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(COMMAND_MENU_TEMPLATES)
-    return message.format(file=file, info=info, commands=commands)
-
-
-async def anime_template(**kwargs) -> str:
-    template = await db.get_env(ENV.anime_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(ANIME_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def manga_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.manga_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(MANGA_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def character_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.character_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(CHARACTER_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def airing_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.airing_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(AIRING_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def anilist_user_templates(
-    name: str, anime: tuple, manga: tuple, siteurl: str
-) -> str:
-    template = await db.get_env(ENV.anilist_user_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(ANILIST_USER_TEMPLATES)
-    return message.format(
-        name=name,
-        anime_count=anime[0],
-        anime_score=anime[1],
-        minutes=anime[2],
-        episodes=anime[3],
-        manga_count=manga[0],
-        manga_score=manga[1],
-        chapters=manga[2],
-        volumes=manga[3],
-        siteurl=siteurl,
-    )
-
-
-async def climate_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.climate_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(CLIMATE_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def airpollution_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.airpollution_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(AIR_POLLUTION_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def statistics_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.statistics_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(STATISTICS_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def github_user_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.github_user_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(GITHUB_USER_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def gban_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.gban_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(GBAN_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def usage_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.usage_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(USAGE_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def user_info_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.user_info_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(USER_INFO_TEMPLATES)
-    return message.format(**kwargs)
-
-
-async def chat_info_templates(**kwargs) -> str:
-    template = await db.get_env(ENV.chat_info_template)
-    if template:
-        message = template
-    else:
-        message = random.choice(CHAT_INFO_TEMPLATES)
-    return message.format(**kwargs)

HellBot/functions/tools.py

@@ -1,139 +0,0 @@
-import asyncio
-import contextlib
-import math
-import os
-import shlex
-import shutil
-import time
-
-from git import Repo
-from git.exc import GitCommandError, InvalidGitRepositoryError, NoSuchPathError
-from pyrogram.types import Message
-
-from Hellbot.core import Config, Symbols
-
-from .formatter import humanbytes, readable_time
-
-
-async def progress(
-    current: int, total: int, message: Message, start: float, process: str
-):
-    now = time.time()
-    diff = now - start
-    if round(diff % 10.00) == 0 or current == total:
-        percentage = current * 100 / total
-        speed = current / diff
-        elapsed_time = round(diff) * 1000
-        complete_time = round((total - current) / speed) * 1000
-        estimated_total_time = elapsed_time + complete_time
-        progress_str = "**[{0}{1}] : {2}%\n**".format(
-            "".join(["●" for i in range(math.floor(percentage / 10))]),
-            "".join(["○" for i in range(10 - math.floor(percentage / 10))]),
-            round(percentage, 2),
-        )
-        msg = (
-            progress_str
-            + "__{0}__ **𝗈𝖿** __{1}__\n**𝖲𝗉𝖾𝖾𝖽:** __{2}/s__\n**𝖤𝖳𝖠:** __{3}__".format(
-                humanbytes(current),
-                humanbytes(total),
-                humanbytes(speed),
-                readable_time(estimated_total_time / 1000),
-            )
-        )
-        await message.edit_text(f"**{process} ...**\n\n{msg}")
-
-
-async def get_files_from_directory(directory: str) -> list:
-    all_files = []
-    for path, _, files in os.walk(directory):
-        for file in files:
-            all_files.append(os.path.join(path, file))
-    return all_files
-
-
-async def runcmd(cmd: str) -> tuple[str, str, int, int]:
-    args = shlex.split(cmd)
-    process = await asyncio.create_subprocess_exec(
-        *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-    )
-    stdout, stderr = await process.communicate()
-    return (
-        stdout.decode("utf-8", "replace").strip(),
-        stderr.decode("utf-8", "replace").strip(),
-        process.returncode,
-        process.pid,
-    )
-
-
-async def update_dotenv(key: str, value: str) -> None:
-    with open(".env", "r") as file:
-        data = file.readlines()
-
-    for index, line in enumerate(data):
-        if line.startswith(f"{key}="):
-            data[index] = f"{key}={value}\n"
-            break
-
-    with open(".env", "w") as file:
-        file.writelines(data)
-
-
-async def restart(
-    update: bool = False,
-    clean_up: bool = False,
-    shutdown: bool = False,
-):
-    try:
-        shutil.rmtree(Config.DWL_DIR)
-        shutil.rmtree(Config.TEMP_DIR)
-    except BaseException:
-        pass
-
-    if clean_up:
-        os.system(f"mkdir {Config.DWL_DIR}")
-        os.system(f"mkdir {Config.TEMP_DIR}")
-        return
-
-    if shutdown:
-        return os.system(f"kill -9 {os.getpid()}")
-
-    cmd = (
-        "git pull && pip3 install -U -r requirements.txt && bash start.sh"
-        if update
-        else "bash start.sh"
-    )
-
-    os.system(f"kill -9 {os.getpid()} && {cmd}")
-
-
-async def gen_changelogs(repo: Repo, branch: str) -> str:
-    changelogs = ""
-    commits = list(repo.iter_commits(branch))[:5]
-    for index, commit in enumerate(commits):
-        changelogs += f"**{Symbols.triangle_right} {index + 1}.** `{commit.summary}`\n"
-
-    return changelogs
-
-
-async def initialize_git(git_repo: str):
-    force = False
-    try:
-        repo = Repo()
-    except NoSuchPathError as pathErr:
-        repo.__del__()
-        return False, pathErr, force
-    except GitCommandError as gitErr:
-        repo.__del__()
-        return False, gitErr, force
-    except InvalidGitRepositoryError:
-        repo = Repo.init()
-        origin = repo.create_remote("upstream", f"https://github.com/{git_repo}")
-        origin.fetch()
-        repo.create_head("master", origin.refs.master)
-        repo.heads.master.set_tracking_branch(origin.refs.master)
-        repo.heads.master.checkout(True)
-        force = True
-    with contextlib.suppress(BaseException):
-        repo.create_remote("upstream", f"https://github.com/{git_repo}")
-
-    return True, repo, force

HellBot/functions/utility.py

@@ -1,241 +0,0 @@
-import asyncio
-import os
-import time
-
-from pyrogram import Client
-from pyrogram.enums import ChatType
-from pyrogram.errors import FloodWait
-from pyrogram.types import Message
-from telegraph import Telegraph
-
-from Hellbot.core import ENV, LOGS, db
-
-from .formatter import readable_time
-
-
-class TelegraphAPI:
-    def __init__(self) -> None:
-        self.shortname: str = "TheHellbot"
-        self.telegraph: Telegraph = None
-
-    async def setup(self):
-        shortname = await db.get_env(ENV.telegraph_account) or self.shortname
-
-        try:
-            self.telegraph = Telegraph(domain="telegra.ph")
-            self.telegraph.create_account(shortname)
-        except:
-            LOGS.warning("Failed to setup Telegraph API")
-
-
-class Gcast:
-    def __init__(self) -> None:
-        self.file_name = "gcast_{0}.txt"
-        self.complete_msg = "**🍀 𝖦𝖼𝖺𝗌𝗍 𝖢𝗈𝗆𝗉𝗅𝖾𝗍𝖾𝖽!** \n\n**𝖬𝖾𝗌𝗌𝖺𝗀𝖾:** [click here]({0})\n**𝖢𝗈𝗎𝗇𝗍:** `{1} {2}`\n**𝖥𝗈𝗋𝗐𝖺𝗋𝖽 𝗍𝖺𝗀:** `{3}`\n**𝖳𝗂𝗆𝖾 𝗍𝖺𝗄𝖾𝗇:** `{4}`"
-
-    async def _send_msg(self, chat_id: int, msg: Message, tag: bool):
-        await msg.forward(chat_id) if tag else await msg.copy(chat_id)
-
-    async def start(self, message: Message, client: Client, mode: str, tag: bool):
-        link = message.link
-        status = "Enabled" if tag else "Removed"
-        start = time.time()
-
-        if mode == "all":
-            uCount, uFileName = await self.users(message, client, tag)
-            gCount, gFileName = await self.groups(message, client, tag)
-            count = uCount + gCount
-            with open(uFileName, "a", encoding="utf-8") as file1, open(
-                gFileName, "r", encoding="utf-8"
-            ) as file2:
-                file1.write(file2.read())
-            file2.close()
-            file1.close()
-            os.remove(gFileName)
-            fileName = uFileName
-        elif mode == "groups":
-            count, fileName = await self.groups(message, client, tag)
-        elif mode == "users":
-            count, fileName = await self.users(message, client, tag)
-        else:
-            return None
-
-        end = time.time()
-        outStr = self.complete_msg.format(
-            link, count, mode, status, readable_time(int(end - start))
-        )
-
-        return fileName, outStr
-
-    async def groups(self, message: Message, client: Client, tag: bool):
-        filename = self.file_name.format(round(time.time()))
-        count = 0
-
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write("Group ID | Error\n\n")
-            async for dialog in client.get_dialogs():
-                if dialog.chat.type == ChatType.SUPERGROUP:
-                    try:
-                        await self._send_msg(dialog.chat.id, message, tag)
-                        count += 1
-                    except FloodWait as fw:
-                        await asyncio.sleep(fw.value)
-                        await self._send_msg(dialog.chat.id, message, tag)
-                        count += 1
-                    except Exception as e:
-                        f.write(f"{dialog.chat.id} | {e}\n")
-
-        f.close()
-
-        return count, filename
-
-    async def users(self, message: Message, client: Client, tag: bool):
-        filename = self.file_name.format(round(time.time()))
-        count = 0
-
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write("User ID | Error\n\n")
-            async for dialog in client.get_dialogs():
-                if dialog.chat.type == ChatType.PRIVATE:
-                    try:
-                        await self._send_msg(dialog.chat.id, message, tag)
-                        count += 1
-                    except FloodWait as fw:
-                        await asyncio.sleep(fw.value)
-                        await self._send_msg(dialog.chat.id, message, tag)
-                        count += 1
-                    except Exception as e:
-                        f.write(f"{dialog.chat.id} | {e}\n")
-
-        f.close()
-
-        return count, filename
-
-
-class AntiFlood:
-    def __init__(self) -> None:
-        self.FloodCount = {}
-        self.settings = {}
-        self.client_chats = {}
-
-    def updateSettings(self, client: int, chat: int, data: dict):
-        mode = data.get("mode", "mute")
-        mtime = data.get("time", 0)
-        limit = data.get("limit", 5)
-
-        self.settings[client] = {chat: {"mode": mode, "time": mtime, "limit": limit}}
-
-    def getSettings(self, client: int, chat: int) -> tuple[str, int, int]:
-        mode = "mute"
-        mtime = 0
-        limit = 5
-
-        cli_settings: dict = self.settings.get(client, None)
-        if cli_settings:
-            chat_settings: dict = cli_settings.get(chat, None)
-            if chat_settings:
-                mode = chat_settings.get("mode", "mute")
-                mtime = chat_settings.get("time", 0)
-                limit = chat_settings.get("limit", 5)
-
-        return mode, int(mtime), limit
-
-    def updateFlood(self, client: int, chat: int, user: int, count: int):
-        self.FloodCount[client] = {chat: {"last_user": user, "count": count}}
-
-    def getLastUser(self, client: int, chat: int) -> tuple[int, int]:
-        try:
-            cli_dict: dict = self.FloodCount[client]
-        except KeyError:
-            self.FloodCount[client] = {}
-            cli_dict: dict = self.FloodCount[client]
-
-        try:
-            chat_dict: dict = cli_dict[chat]
-        except KeyError:
-            cli_dict[chat] = {}
-            chat_dict: dict = cli_dict[chat]
-
-        last_user: int = chat_dict.get("last_user", 0)
-        count: int = chat_dict.get("count", 0)
-
-        return last_user, count
-
-    async def updateFromDB(self):
-        floods = await db.get_all_floods()
-        for flood in floods:
-            client = flood["client"]
-            chat = flood["chat"]
-            mode = flood.get("mode", "mute")
-            mtime = flood.get("time", 0)
-            limit = flood.get("limit", 5)
-            settings = {"mode": mode, "time": mtime, "limit": limit}
-
-            self.updateSettings(client, chat, settings)
-            try:
-                self.client_chats[client].append(chat)
-            except KeyError:
-                self.client_chats[client] = [chat]
-
-    def check_client_chat(self, client: int, chat: int) -> bool:
-        try:
-            chats = self.client_chats[client]
-        except KeyError:
-            return False
-
-        if chat in chats:
-            return True
-
-        return False
-
-
-class Blacklists:
-    def __init__(self) -> None:
-        self.blacklists = {}
-
-    async def updateBlacklists(self):
-        datas = await db.get_blacklist_clients()
-        for data in datas:
-            client = data["client"]
-            chats = data.get("chats", [])
-            for chat in chats:
-                blacklists = data["blacklist"]
-                self.blacklists[client] = {chat: blacklists}
-
-    async def addBlacklist(self, client: int, chat: int, text: str):
-        try:
-            self.blacklists[client][chat].append(text)
-        except KeyError:
-            self.blacklists[client] = {chat: [text]}
-
-        await db.add_blacklist(client, chat, text)
-
-    async def rmBlacklist(self, client: int, chat: int, text: str):
-        try:
-            self.blacklists[client][chat].remove(text)
-        except KeyError:
-            return
-
-        await db.rm_blacklist(client, chat, text)
-
-    def getBlacklists(self, client: int, chat: int) -> list:
-        try:
-            return self.blacklists[client][chat]
-        except KeyError:
-            return []
-
-    def check_client_chat(self, client: int, chat: int) -> bool:
-        try:
-            chats = self.blacklists[client]
-        except KeyError:
-            return False
-
-        if chat in chats:
-            return True
-
-        return False
-
-
-Flood = AntiFlood()
-BList = Blacklists()
-TGraph = TelegraphAPI()

HellBot/plugins/bot/__init__.py

@@ -1,29 +0,0 @@
-from Hellbot.core.clients import hellbot
-from Hellbot.core.config import Config, Symbols
-from Hellbot.core.database import db
-from Hellbot.plugins.help import BotHelp
-
-
-START_MSG = """
-👋 **𝖦𝗋𝖾𝖾𝗍𝗂𝗇𝗀𝗌, {0} - 𝗐𝖺𝗋𝗋𝗂𝗈𝗋𝗌 𝗈𝖿 𝖧𝖾𝗅𝗅𝖻𝗈𝗍!** 👹 𝖨 𝖺𝗆 𝗒𝗈𝗎𝗋 𝗍𝗋𝗎𝗌𝗍𝗒 𝖼𝗈𝗆𝗉𝖺𝗇𝗂𝗈𝗇, 𝗍𝗁𝖾 **𝖧𝖾𝗅𝗅𝖻𝗈𝗍 𝖠𝗌𝗌𝗂𝗌𝗍𝖺𝗇𝗍!** 🚀
-
-𝖧𝖾𝗋𝖾 𝗍𝗈 𝗌𝖾𝗋𝗏𝖾, 𝗀𝗎𝗂𝖽𝖾, 𝖺𝗇𝖽 💪 𝗎𝗇𝗅𝖾𝖺𝗌𝗁 𝗍𝗁𝖾 𝗉𝗈𝗐𝖾𝗋 𝗈𝖿 𝖧𝖾𝗅𝗅𝖡𝗈𝗍 𝖺𝗍 𝗒𝗈𝗎𝗋 𝖼𝗈𝗆𝗆𝖺𝗇𝖽! 🎉
-𝖶𝗁𝖾𝗍𝗁𝖾𝗋 𝗂𝗍'𝗌 𝖼𝗋𝖾𝖺𝗍𝗂𝗇𝗀, 𝖽𝖾𝗅𝖾𝗍𝗂𝗇𝗀, 𝗈𝗋 𝗎𝗉𝖽𝖺𝗍𝗂𝗇𝗀 𝗒𝗈𝗎𝗋 𝗎𝗌𝖾𝗋𝖻𝗈𝗍, 𝖨'𝗏𝖾 𝗀𝗈𝗍 𝗒𝗈𝗎𝗋 𝖻𝖺𝖼𝗄.
-𝖢𝗈𝗇𝗌𝗂𝖽𝖾𝗋 𝗆𝖾 𝗒𝗈𝗎𝗋 𝗉𝖾𝗋𝗌𝗈𝗇𝖺𝗅 𝗌𝗂𝖽𝖾𝗄𝗂𝖼𝗄 🤭 𝗂𝗇 𝗍𝗁𝖾 𝗋𝖾𝖺𝗅𝗆 𝗈𝖿 𝗎𝗅𝗍𝗂𝗆𝖺𝗍𝖾 𝗎𝗌𝖾𝗋𝖻𝗈𝗍 𝗆𝖺𝗌𝗍𝖾𝗋𝗒.
-
-🍀 𝖫𝖾𝗍'𝗌 𝖾𝗆𝖻𝖺𝗋𝗄 𝗈𝗇 𝗍𝗁𝗂𝗌 𝖾𝗉𝗂𝖼 𝗃𝗈𝗎𝗋𝗇𝖾𝗒 𝗍𝗈𝗀𝖾𝗍𝗁𝖾𝗋!
-𝖨𝖿 𝗒𝗈𝗎 𝖾𝗏𝖾𝗋 𝗇𝖾𝖾𝖽 𝖺𝗌𝗌𝗂𝗌𝗍𝖺𝗇𝖼𝖾 𝗈𝗋 𝖼𝗋𝖺𝗏𝖾 ✨ 𝗍𝗁𝖾 𝗍𝗁𝗋𝗂𝗅𝗅 𝗈𝖿 𝗎𝗇𝗅𝖾𝖺𝗌𝗁𝗂𝗇𝗀 𝖧𝖾𝗅𝗅𝖻𝗈𝗍'𝗌 𝗆𝗂𝗀𝗁𝗍, 𝗃𝗎𝗌𝗍 𝗌𝗎𝗆𝗆𝗈𝗇 𝗆𝖾.
-𝖶𝖾'𝗋𝖾 𝖺𝖻𝗈𝗎𝗍 𝗍𝗈 𝖼𝗈𝗇𝗊𝗎𝖾𝗋 𝗇𝖾𝗐 𝗁𝖾𝗂𝗀𝗁𝗍𝗌 🚀 𝗂𝗇 𝗍𝗁𝖾 𝗎𝗌𝖾𝗋𝖻𝗈𝗍 𝗎𝗇𝗂𝗏𝖾𝗋𝗌𝖾!
-
-💫 𝖬𝖺𝗒 𝗒𝗈𝗎𝗋 𝖼𝗈𝗆𝗆𝖺𝗇𝖽𝗌 𝖻𝖾 𝗌𝗐𝗂𝖿𝗍 𝖺𝗇𝖽 𝗒𝗈𝗎𝗋 𝗌𝖾𝗌𝗌𝗂𝗈𝗇𝗌 𝗅𝖾𝗀𝖾𝗇𝖽𝖺𝗋𝗒.
-**𝖶𝖾𝗅𝖼𝗈𝗆𝖾 𝗍𝗈 𝖧𝖾𝗅𝗅𝖻𝗈𝗍 𝖠𝗌𝗌𝗂𝗌𝗍𝖺𝗇𝗍 – 𝗐𝗁𝖾𝗋𝖾 𝖧𝖾𝗅𝗅𝖻𝗈𝗍'𝗌 𝗅𝖾𝗀𝖺𝖼𝗒 𝗅𝗂𝗏𝖾𝗌 𝗈𝗇 🤖!**
-"""
-
-HELP_MSG = """
-**⚙️ 𝖧𝖾𝗅𝗉:**
-
-__» All commands are categorized and you can use these buttons below to navigate each category and get respective commands.__
-__» Feel free to contact us if you need any help regarding the bot.__
-
-**❤️ @HellBot_Networks 🇮🇳**
-"""

HellBot/plugins/bot/bot.py

@@ -1,60 +0,0 @@
-import heroku3
-from pyrogram import filters
-from pyrogram.types import InlineKeyboardMarkup, Message
-
-from Hellbot import HEROKU_APP
-from Hellbot.core import LOGS
-from Hellbot.functions.tools import restart
-
-from ..btnsG import gen_bot_help_buttons, start_button
-from . import HELP_MSG, START_MSG, BotHelp, Config, hellbot
-
-
-@hellbot.bot.on_message(filters.command("start") & Config.AUTH_USERS)
-async def start_pm(_, message: Message):
-    btns = start_button()
-
-    await message.reply_text(
-        START_MSG.format(message.from_user.mention),
-        disable_web_page_preview=True,
-        reply_markup=InlineKeyboardMarkup(btns),
-    )
-
-
-@hellbot.bot.on_message(filters.command("help") & Config.AUTH_USERS)
-async def help_pm(_, message: Message):
-    btns = await gen_bot_help_buttons()
-
-    await message.reply_text(
-        HELP_MSG,
-        disable_web_page_preview=True,
-        reply_markup=InlineKeyboardMarkup(btns),
-    )
-
-
-@hellbot.bot.on_message(filters.command("restart") & Config.AUTH_USERS)
-async def restart_clients(_, message: Message):
-    await message.reply_text("Restarted Bot Successfully ✅")
-    try:
-        if HEROKU_APP:
-            try:
-                heroku = heroku3.from_key(Config.HEROKU_APIKEY)
-                app = heroku.apps()[Config.HEROKU_APPNAME]
-                app.restart()
-            except:
-                await restart()
-        else:
-            await restart()
-    except Exception as e:
-        LOGS.error(e)
-
-
-BotHelp("Others").add(
-    "start", "To start the bot and get the main menu."
-).add(
-    "help", "To get the help menu with all the command for this assistant bot."
-).add(
-    "restart", "To restart the bot."
-).info(
-    "Some basic commands of the bot."
-).done()

HellBot/plugins/bot/callbacks.py

@@ -1,279 +0,0 @@
-from pyrogram import filters
-from pyrogram.enums import ParseMode
-from pyrogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup
-
-from Hellbot.functions.templates import command_template, help_template
-
-from ..btnsG import gen_bot_help_buttons, gen_inline_help_buttons, start_button
-from . import HELP_MSG, START_MSG, Config, Symbols, hellbot
-
-
-async def check_auth_click(cb: CallbackQuery) -> bool:
-    if cb.from_user.id not in Config.AUTH_USERS:
-        await cb.answer(
-            "You are not authorized to use this bot. \n\n</> @Its_HellBot",
-            show_alert=True,
-        )
-        return False
-    return True
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"auth_close"))
-async def auth_close_cb(_, cb: CallbackQuery):
-    if await check_auth_click(cb):
-        await cb.message.delete()
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"close"))
-async def close_cb(_, cb: CallbackQuery):
-    await cb.message.delete()
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"bot_help_menu"))
-async def bot_help_menu_cb(_, cb: CallbackQuery):
-    if not await check_auth_click(cb):
-        return
-
-    plugin = str(cb.data.split(":")[1])
-
-    try:
-        buttons = [
-            InlineKeyboardButton(f"{Symbols.bullet} {i}", f"bot_help_cmd:{plugin}:{i}")
-            for i in sorted(Config.BOT_HELP[plugin]["commands"])
-        ]
-    except KeyError:
-        await cb.answer("No description provided for this plugin!", show_alert=True)
-        return
-
-    buttons = [buttons[i : i + 2] for i in range(0, len(buttons), 2)]
-    buttons.append([InlineKeyboardButton(Symbols.back, "help_data:bothelp")])
-
-    caption = (
-        f"**𝖯𝗅𝗎𝗀𝗂𝗇 𝖥𝗂𝗅𝖾:** `{plugin}`\n"
-        f"**𝖯𝗅𝗎𝗀𝗂𝗇 𝖨𝗇𝖿𝗈:** __{Config.BOT_HELP[plugin]['info']} 🍀__\n\n"
-        f"**📃 𝖫𝗈𝖺𝖽𝖾𝖽 𝖢𝗈𝗆𝗆𝖺𝗇𝖽𝗌:** `{len(sorted(Config.BOT_HELP[plugin]['commands']))}`"
-    )
-
-    try:
-        await cb.edit_message_text(
-            caption,
-            disable_web_page_preview=True,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    except Exception:
-        # handles MessageNotModified error
-        pass
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"bot_help_cmd"))
-async def bot_help_cmd_cb(_, cb: CallbackQuery):
-    if not await check_auth_click(cb):
-        return
-
-    result = ""
-    plugin = str(cb.data.split(":")[1])
-    command = str(cb.data.split(":")[2])
-    cmd_dict = Config.BOT_HELP[plugin]["commands"][command]
-
-    result += f"**{Symbols.radio_select} 𝖢𝗈𝗆𝗆𝖺𝗇𝖽:** `/{cmd_dict['command']}`"
-    result += (
-        f"\n\n**{Symbols.arrow_right} 𝖣𝖾𝗌𝖼𝗋𝗂𝗉𝗍𝗂𝗈𝗇:** __{cmd_dict['description']}__"
-    )
-    result += f"\n\n**<\\> @Its_HellBot 🍀**"
-
-    buttons = [
-        [
-            InlineKeyboardButton(Symbols.back, f"bot_help_menu:{plugin}"),
-            InlineKeyboardButton(Symbols.close, "help_data:botclose"),
-        ]
-    ]
-
-    try:
-        await cb.edit_message_text(
-            result,
-            ParseMode.MARKDOWN,
-            True,
-            InlineKeyboardMarkup(buttons),
-        )
-    except Exception:
-        # handles MessageNotModified error
-        pass
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"help_page"))
-async def help_page_cb(_, cb: CallbackQuery):
-    if not await check_auth_click(cb):
-        return
-
-    page = int(cb.data.split(":")[1])
-    buttons, max_page = await gen_inline_help_buttons(page, sorted(Config.CMD_MENU))
-
-    caption = await help_template(
-        cb.from_user.mention,
-        (len(Config.CMD_INFO), len(Config.CMD_MENU)),
-        (page + 1, max_page),
-    )
-
-    try:
-        await cb.edit_message_text(
-            caption,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    except Exception:
-        # handles MessageNotModified error
-        pass
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"help_menu"))
-async def help_menu_cb(_, cb: CallbackQuery):
-    if not await check_auth_click(cb):
-        return
-
-    page = int(cb.data.split(":")[1])
-    plugin = str(cb.data.split(":")[2])
-
-    try:
-        buttons = [
-            InlineKeyboardButton(
-                f"{Symbols.bullet} {i}", f"help_cmd:{page}:{plugin}:{i}"
-            )
-            for i in sorted(Config.HELP_DICT[plugin]["commands"])
-        ]
-    except KeyError:
-        await cb.answer("No description provided for this plugin!", show_alert=True)
-        return
-
-    buttons = [buttons[i : i + 2] for i in range(0, len(buttons), 2)]
-    buttons.append([InlineKeyboardButton(Symbols.back, f"help_page:{page}")])
-
-    caption = await command_template(
-        plugin,
-        Config.HELP_DICT[plugin]["info"],
-        len(sorted(Config.HELP_DICT[plugin]["commands"])),
-    )
-
-    try:
-        await cb.edit_message_text(
-            caption,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    except Exception:
-        # handles MessageNotModified error
-        pass
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"help_cmd"))
-async def help_cmd_cb(_, cb: CallbackQuery):
-    if not await check_auth_click(cb):
-        return
-
-    page = int(cb.data.split(":")[1])
-    plugin = str(cb.data.split(":")[2])
-    command = str(cb.data.split(":")[3])
-    result = ""
-    cmd_dict = Config.HELP_DICT[plugin]["commands"][command]
-
-    if cmd_dict["parameters"] is None:
-        result += f"**{Symbols.radio_select} 𝖢𝗈𝗆𝗆𝖺𝗇𝖽:** `{Config.HANDLERS[0]}{cmd_dict['command']}`"
-    else:
-        result += f"**{Symbols.radio_select} 𝖢𝗈𝗆𝗆𝖺𝗇𝖽:** `{Config.HANDLERS[0]}{cmd_dict['command']} {cmd_dict['parameters']}`"
-
-    if cmd_dict["description"]:
-        result += (
-            f"\n\n**{Symbols.arrow_right} 𝖣𝖾𝗌𝖼𝗋𝗂𝗉𝗍𝗂𝗈𝗇:** __{cmd_dict['description']}__"
-        )
-
-    if cmd_dict["example"]:
-        result += f"\n\n**{Symbols.arrow_right} 𝖤𝗑𝖺𝗆𝗉𝗅𝖾:** `{Config.HANDLERS[0]}{cmd_dict['example']}`"
-
-    if cmd_dict["note"]:
-        result += f"\n\n**{Symbols.arrow_right} 𝖭𝗈𝗍𝖾:** __{cmd_dict['note']}__"
-
-    result += f"\n\n**<\\> @Its_HellBot 🍀**"
-
-    buttons = [
-        [
-            InlineKeyboardButton(Symbols.back, f"help_menu:{page}:{plugin}"),
-            InlineKeyboardButton(Symbols.close, "help_data:c"),
-        ]
-    ]
-
-    try:
-        await cb.edit_message_text(
-            result,
-            ParseMode.MARKDOWN,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    except Exception:
-        # handles MessageNotModified error
-        pass
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"help_data"))
-async def help_close_cb(_, cb: CallbackQuery):
-    if not await check_auth_click(cb):
-        return
-
-    action = str(cb.data.split(":")[1])
-    if action == "c":
-        await cb.edit_message_text(
-            "**𝖧𝖾𝗅𝗉 𝖬𝖾𝗇𝗎 𝖢𝗅𝗈𝗌𝖾𝖽!**",
-            reply_markup=InlineKeyboardMarkup(
-                [[InlineKeyboardButton("Reopen", "help_data:reopen")]]
-            ),
-        )
-    elif action == "reopen":
-        buttons, pages = await gen_inline_help_buttons(0, sorted(Config.CMD_MENU))
-        caption = await help_template(
-            cb.from_user.mention,
-            (len(Config.CMD_INFO), len(Config.CMD_MENU)),
-            (1, pages),
-        )
-        await cb.edit_message_text(
-            caption,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    elif action == "botclose":
-        await cb.message.delete()
-    elif action == "bothelp":
-        buttons = await gen_bot_help_buttons()
-        await cb.edit_message_text(
-            HELP_MSG,
-            disable_web_page_preview=True,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    elif action == "source":
-        buttons = [
-            [
-                InlineKeyboardButton("🚀 Deploy", url="https://github.com/The-HellBot/HellBot"),
-                InlineKeyboardButton("Plugins 📂", url="https://github.com/The-HellBot/Plugins"),
-            ],
-            [
-                InlineKeyboardButton("нєℓℓвσт ηєтωσяк 🇮🇳", url="https://t.me/HellBot_Networks"),
-            ],
-            [
-                InlineKeyboardButton("🎙️ Support", url="https://t.me/HellBot_Chats"),
-                InlineKeyboardButton("Updates 📣", url="https://t.me/Its_HellBot"),
-            ],
-            [
-                InlineKeyboardButton("🔙", "help_data:start"),
-                InlineKeyboardButton(Symbols.close, "help_data:botclose"),
-            ],
-        ]
-        await cb.edit_message_text(
-            "__» The source code is available on GitHub. You can find the link below.__\n"
-            "__» Every project available under The-HellBot are open-source and free to use and modify to your needs.__\n"
-            "__» Anyone pretending to be the developer of this bot and selling the code, is a scammer.__\n\n"
-            "__» Please consider giving a star to the repository if you liked the project.__\n"
-            "__» Feel free to contact us if you need any help regarding the source code.__\n\n"
-            "**❤️ @HellBot_Networks 🇮🇳**",
-            disable_web_page_preview=True,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )
-    elif action == "start":
-        buttons = start_button()
-        await cb.edit_message_text(
-            START_MSG.format(cb.from_user.mention),
-            disable_web_page_preview=True,
-            reply_markup=InlineKeyboardMarkup(buttons),
-        )

HellBot/plugins/bot/forcesub.py

@@ -1,226 +0,0 @@
-from pyrogram import Client, filters
-from pyrogram.errors import ChatAdminRequired, UserNotParticipant
-from pyrogram.types import (
-    CallbackQuery,
-    ChatPermissions,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Message,
-)
-
-from Hellbot.core import LOGS
-from Hellbot.functions.admins import is_user_admin
-
-from ..btnsG import gen_inline_keyboard
-from . import BotHelp, Config, Symbols, db, hellbot
-
-
-@hellbot.bot.on_message(filters.command("forcesub") & Config.AUTH_USERS & filters.group)
-async def force_sub(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await message.reply_text("Give a channel username with command!")
-
-    try:
-        is_admin = await is_user_admin(message.chat, client.me.id)
-        if not is_admin:
-            return await message.reply_text(f"To use forcesub i must be an admin in {must_join}!")
-    except UserNotParticipant:
-        return await message.reply_text(f"To use forcesub i must be an admin in {must_join}!")
-
-    must_join = message.command[1]
-    try:
-        chat = await client.get_chat(must_join)
-    except Exception as e:
-        return await message.reply_text(f"**Error:**\n`{e}`")
-
-    if not await is_user_admin(chat, client.me.id):
-        return await message.reply_text("Make me admin in that channel first!")
-
-    await db.add_forcesub(message.chat.id, chat.id)
-    await message.reply_text(
-        f"**📌 𝖢𝗁𝖺𝗍 𝖥𝗈𝗋𝖼𝖾𝗌𝗎𝖻 𝖤𝗇𝖺𝖻𝗅𝖾𝖽!** \n\n"
-        f"__Users must join__ {chat.title} (`{chat.id}`) __to chat here!__"
-    )
-
-    if message.chat.id not in Config.FORCESUBS:
-        Config.FORCESUBS.add(message.chat.id)
-
-
-@hellbot.bot.on_message(filters.command("unforcesub") & Config.AUTH_USERS)
-async def unforce_sub(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await message.reply_text(
-            "Give a channel username with command or give 'all' to remove all forcesubs from this chat!"
-        )
-
-    if not await is_user_admin(message.chat, client.me.id):
-        return await message.reply_text("To use forcesub i must be an admin!")
-
-    if "all" == message.command[1].lower():
-        await db.rm_all_forcesub(message.chat.id)
-        Config.FORCESUBS.remove(message.chat.id)
-        return await message.reply_text(f"**📌 Forcesub disabled!**")
-
-    try:
-        if await db.is_forcesub(message.chat.id, int(message.command[1])):
-            remaining = await db.rm_forcesub(message.chat.id, int(message.command[1]))
-            if remaining:
-                return await message.reply_text(
-                    f"**📌 Removed Forcesub `{message.command[1]}`!**\n\n**Remaining Forcesub(s) in this chat:** `{remaining}`"
-                )
-            else:
-                Config.FORCESUBS.remove(message.chat.id)
-                return await message.reply_text(
-                    f"**📌 Removed Forcesub `{message.command[1]}`!**"
-                )
-        else:
-            return await message.reply_text(f"**📌 This chat is not forcesub enabled!**")
-    except Exception as e:
-        return await message.reply_text(f"**Error:**\n`{e}`")
-
-
-@hellbot.bot.on_message(filters.command("listforcesub") & Config.AUTH_USERS)
-async def list_force_subs(client: Client, message: Message):
-    if not await is_user_admin(message.chat, client.me.id):
-        return await message.reply_text("To use forcesub i must be an admin!")
-
-    all_forcesubs = Config.FORCESUBS
-
-    text = ""
-    if len(all_forcesubs) > 0:
-        for forcesub in all_forcesubs:
-            try:
-                chat = await client.get_chat(forcesub["chat"])
-                text += f"**📌 {chat.title}** (`{chat.id}`)\n"
-            except:
-                text += f"**📌 {forcesub['chat']}** - `Invalid Chat!`\n"
-    else:
-        text = "**📌 No Forcesub Enabled in Bot!**"
-
-    await message.reply_text(text)
-
-
-@hellbot.bot.on_message(filters.command("getforcesub") & Config.AUTH_USERS)
-async def getforcesub(client: Client, message: Message):
-    if len(message.command) < 2:
-        chat = message.chat
-    else:
-        try:
-            chat = await client.get_chat(message.command[1])
-        except:
-            return await message.reply_text(f"**Invalid Channel Username/ID!**")
-
-    mustjoins = await db.get_forcesub(chat.id)
-    if mustjoins:
-        text = f"**This chat has {len(mustjoins['must_join'])} forcesub(s):**\n"
-        for must_join in mustjoins["must_join"]:
-            try:
-                chat = await client.get_chat(must_join)
-                text += f"**📌 {chat.title}** (`{chat.id}`)\n"
-            except:
-                text += f"**📌 {must_join}** - `Invalid Chat!`\n"
-    else:
-        text = "**📌 No Forcesub Enabled in This Chat!**"
-
-    await message.reply_text(text)
-
-
-@hellbot.bot.on_message(
-    filters.group
-    & filters.incoming
-    & filters.new_chat_members
-    & ~filters.bot
-    & ~filters.service
-    & ~Config.AUTH_USERS
-    & ~filters.me
-)
-async def handle_force_sub(client: Client, message: Message):
-    if message.chat.id not in Config.FORCESUBS:
-        return
-
-    if not is_user_admin(message.chat, client.me.id):
-        return
-
-    btns_list = []
-    mustjoins = await db.get_forcesub(message.chat.id)
-
-    for i, must_join in enumerate(mustjoins["must_join"]):
-        try:
-            await client.get_chat_member(must_join, message.from_user.id)
-        except UserNotParticipant:
-            invite_link = await client.export_chat_invite_link(must_join)
-            btns_list.append((f"Join {i}", invite_link, "url"))
-            continue
-        except ChatAdminRequired:
-            continue
-        except Exception as e:
-            LOGS.warning(e)
-            continue
-
-    if len(btns_list) == 0:
-        return
-
-    join_btns = gen_inline_keyboard(btns_list, 2)
-    join_btns.append(
-        [
-            InlineKeyboardButton("Unmute 🗣️", f"forcesub:unmute:{message.from_user.id}:{message.chat.id}")
-        ]
-    )
-    await message.reply_text(
-        f"**👋 Welcome to {message.chat.title}!**\n\n"
-        f"To be able to chat here, you must follow the instructions below:\n"
-        f"  {Symbols.anchor} __Click the buttons below to join our important channels.__"
-        f"  {Symbols.anchor} __After joining all channels, press the unmute button below.__"
-        f"  {Symbols.anchor} __Then you can chat here.__",
-        disable_web_page_preview=True,
-        reply_markup=InlineKeyboardMarkup(join_btns),
-    )
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"forcesub"))
-async def forcesub_cb(client: Client, cb: CallbackQuery):
-    data = cb.data.split(":")
-    if data[1] == "unmute":
-        try:
-            if not int(data[3]) == cb.message.chat.id:
-                return await cb.answer(
-                    "**This is not for this chat!**", show_alert=True
-                )
-
-            must_join = await db.get_forcesub(cb.message.chat.id)
-            for chat in must_join["must_join"]:
-                try:
-                    await client.get_chat_member(int(chat), cb.from_user.id)
-                except UserNotParticipant:
-                    return await cb.answer(
-                        "**You must join all channels first!**", show_alert=True
-                    )
-                except ChatAdminRequired:
-                    return await cb.answer(
-                        "I'm not admin in some of the channels! Ask owner to make me admin.",
-                        show_alert=True,
-                    )
-                except Exception as e:
-                    return await cb.answer(f"**Error:**\n`{e}`")
-
-            permissions = ChatPermissions(can_send_messages=True)
-            await cb.message.chat.restrict_member(int(data[2]), permissions)
-        except Exception as e:
-            return await cb.answer(f"**Error:**\n`{e}`")
-
-        await cb.answer("**📌 Unmuted!**", show_alert=True)
-        return await cb.message.delete()
-
-
-BotHelp("ForceSub").add(
-    "forcesub",
-    "This command is used to force users to join some channels to chat in group.",
-).add(
-    "unforcesub", "This command is used to remove channels from forcesub in group."
-).add(
-    "listforcesub", "This command is used to list all forcesub in bot."
-).add(
-    "getforcesub", "This command is used to get forcesub in group."
-).info(
-    "ForceSub 🚀"
-).done()

HellBot/plugins/bot/inline.py

@@ -1,39 +0,0 @@
-from pyrogram import filters
-from pyrogram.types import (
-    InlineKeyboardMarkup,
-    InlineQuery,
-    InlineQueryResultArticle,
-    InputTextMessageContent,
-)
-
-from Hellbot.functions.templates import help_template
-
-from ..btnsG import gen_inline_help_buttons
-from . import Config, hellbot
-
-
-@hellbot.bot.on_inline_query(filters.regex(r"help_menu"))
-async def help_inline(_, query: InlineQuery):
-    if not query.from_user.id in Config.AUTH_USERS:
-        return
-    no_of_plugins = len(Config.CMD_MENU)
-    no_of_commands = len(Config.CMD_INFO)
-    buttons, pages = await gen_inline_help_buttons(0, sorted(Config.CMD_MENU))
-    caption = await help_template(
-        query.from_user.mention, (no_of_commands, no_of_plugins), (1, pages)
-    )
-    await query.answer(
-        results=[
-            (
-                InlineQueryResultArticle(
-                    "HellBot Help Menu 🍀",
-                    InputTextMessageContent(
-                        caption,
-                        disable_web_page_preview=True,
-                    ),
-                    description="Inline Query for Help Menu of HellBot",
-                    reply_markup=InlineKeyboardMarkup(buttons),
-                )
-            )
-        ],
-    )

HellBot/plugins/bot/sessions.py

@@ -1,183 +0,0 @@
-from pyrogram import Client, filters
-from pyrogram.errors import SessionPasswordNeeded
-from pyrogram.types import (
-    CallbackQuery,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Message,
-    ReplyKeyboardRemove,
-)
-
-from ..btnsG import gen_inline_keyboard, start_button
-from ..btnsK import session_keyboard
-from . import START_MSG, BotHelp, Config, Symbols, db, hellbot
-
-
-@hellbot.bot.on_message(
-    filters.command("session") & Config.AUTH_USERS & filters.private
-)
-async def session_menu(_, message: Message):
-    await message.reply_text(
-        "**🍀 𝖯𝗅𝖾𝖺𝗌𝖾 𝖼𝗁𝗈𝗈𝗌𝖾 𝖺𝗇 𝗈𝗉𝗍𝗂𝗈𝗇 𝖿𝗋𝗈𝗆 𝖻𝖾𝗅𝗈𝗐:**",
-        reply_markup=session_keyboard(),
-    )
-
-
-@hellbot.bot.on_message(filters.regex(r"New 💫") & Config.AUTH_USERS & filters.private)
-async def new_session(_, message: Message):
-    await message.reply_text(
-        "**𝖮𝗄𝖺𝗒!** 𝖫𝖾𝗍'𝗌 𝗌𝖾𝗍𝗎𝗉 𝖺 𝗇𝖾𝗐 𝗌𝖾𝗌𝗌𝗂𝗈𝗇",
-        reply_markup=ReplyKeyboardRemove(),
-    )
-
-    phone_number = await hellbot.bot.ask(
-        message.chat.id,
-        "**1.** 𝖤𝗇𝗍𝖾𝗋 𝗒𝗈𝗎𝗋 𝗍𝖾𝗅𝖾𝗀𝗋𝖺𝗆 𝖺𝖼𝖼𝗈𝗎𝗇𝗍 𝗉𝗁𝗈𝗇𝖾 𝗇𝗎𝗆𝖻𝖾𝗋 𝗍𝗈 𝖺𝖽𝖽 𝗍𝗁𝖾 𝗌𝖾𝗌𝗌𝗂𝗈𝗇: \n\n__𝖲𝖾𝗇𝖽 /cancel 𝗍𝗈 𝖼𝖺𝗇𝖼𝖾𝗅 𝗍𝗁𝖾 𝗈𝗉𝖾𝗋𝖺𝗍𝗂𝗈𝗇.__",
-        filters=filters.text,
-        timeout=120,
-    )
-
-    if phone_number.text == "/cancel":
-        return await message.reply_text("**𝖢𝖺𝗇𝖼𝖾𝗅𝗅𝖾𝖽!**")
-    elif not phone_number.text.startswith("+") and not phone_number.text[1:].isdigit():
-        return await message.reply_text(
-            "**𝖤𝗋𝗋𝗈𝗋!** 𝖯𝗁𝗈𝗇𝖾 𝗇𝗎𝗆𝖻𝖾𝗋 𝗆𝗎𝗌𝗍 𝖻𝖾 𝗂𝗇 𝖽𝗂𝗀𝗂𝗍𝗌 𝖺𝗇𝖽 𝗌𝗁𝗈𝗎𝗅𝖽 𝖼𝗈𝗇𝗍𝖺𝗂𝗇 𝖼𝗈𝗎𝗇𝗍𝗋𝗒 𝖼𝗈𝖽𝖾."
-        )
-
-    try:
-        client = Client(
-            name="Hellbot",
-            api_id=Config.API_ID,
-            api_hash=Config.API_HASH,
-            in_memory=True,
-        )
-        await client.connect()
-
-        code = await client.send_code(phone_number.text)
-        ask_otp = await hellbot.bot.ask(
-            message.chat.id,
-            "**2.** 𝖤𝗇𝗍𝖾𝗋 𝗍𝗁𝖾 𝖮𝖳𝖯 𝗌𝖾𝗇𝗍 𝗍𝗈 𝗒𝗈𝗎𝗋 𝗍𝖾𝗅𝖾𝗀𝗋𝖺𝗆 𝖺𝖼𝖼𝗈𝗎𝗇𝗍 𝖻𝗒 𝗌𝖾𝗉𝖺𝗋𝖺𝗍𝗂𝗇𝗀 𝖾𝗏𝖾𝗋𝗒 𝗇𝗎𝗆𝖻𝖾𝗋 𝗐𝗂𝗍𝗁 𝖺 𝗌𝗉𝖺𝖼𝖾. \n\n**𝖤𝗑𝖺𝗆𝗉𝗅𝖾:** `2 4 1 7 4`\n\n__𝖲𝖾𝗇𝖽 /cancel 𝗍𝗈 𝖼𝖺𝗇𝖼𝖾𝗅 𝗍𝗁𝖾 𝗈𝗉𝖾𝗋𝖺𝗍𝗂𝗈𝗇.__",
-            filters=filters.text,
-            timeout=300,
-        )
-        if ask_otp.text == "/cancel":
-            return await message.reply_text("**𝖢𝖺𝗇𝖼𝖾𝗅𝗅𝖾𝖽!**")
-        otp = ask_otp.text.replace(" ", "")
-
-        try:
-            await client.sign_in(phone_number.text, code.phone_code_hash, otp)
-        except SessionPasswordNeeded:
-            two_step_pass = await hellbot.bot.ask(
-                message.chat.id,
-                "**3.** 𝖤𝗇𝗍𝖾𝗋 𝗒𝗈𝗎𝗋 𝗍𝗐𝗈 𝗌𝗍𝖾𝗉 𝗏𝖾𝗋𝗂𝖿𝗂𝖼𝖺𝗍𝗂𝗈𝗇 𝗉𝖺𝗌𝗌𝗐𝗈𝗋𝖽: \n\n__𝖲𝖾𝗇𝖽 /cancel 𝗍𝗈 𝖼𝖺𝗇𝖼𝖾𝗅 𝗍𝗁𝖾 𝗈𝗉𝖾𝗋𝖺𝗍𝗂𝗈𝗇.__",
-                filters=filters.text,
-                timeout=120,
-            )
-            if two_step_pass.text == "/cancel":
-                return await message.reply_text("**𝖢𝖺𝗇𝖼𝖾𝗅𝗅𝖾𝖽!**")
-            await client.check_password(two_step_pass.text)
-
-        session_string = await client.export_session_string()
-        await message.reply_text(
-            f"**𝖲𝗎𝖼𝖼𝖾𝗌𝗌!** 𝖸𝗈𝗎𝗋 𝗌𝖾𝗌𝗌𝗂𝗈𝗇 𝗌𝗍𝗋𝗂𝗇𝗀 𝗂𝗌 𝗀𝖾𝗇𝖾𝗋𝖺𝗍𝖾𝖽. 𝖠𝖽𝖽𝗂𝗇𝗀 𝗂𝗍 𝗍𝗈 𝖽𝖺𝗍𝖺𝖻𝖺𝗌𝖾..."
-        )
-        user_id = (await client.get_me()).id
-        await db.update_session(user_id, session_string)
-        await client.disconnect()
-        await message.reply_text(
-            "**𝖲𝗎𝖼𝖼𝖾𝗌𝗌!** 𝖲𝖾𝗌𝗌𝗂𝗈𝗇 𝗌𝗍𝗋𝗂𝗇𝗀 𝖺𝖽𝖽𝖾𝖽 𝗍𝗈 𝖽𝖺𝗍𝖺𝖻𝖺𝗌𝖾. 𝖸𝗈𝗎 𝖼𝖺𝗇 𝗇𝗈𝗐 𝗎𝗌𝖾 𝖧𝖾𝗅𝗅𝖡𝗈𝗍 𝗈𝗇 𝗍𝗁𝗂𝗌 𝖺𝖼𝖼𝗈𝗎𝗇𝗍 𝖺𝖿𝗍𝖾𝗋 𝗋𝖾𝗌𝗍𝖺𝗋𝗍𝗂𝗇𝗀 𝗍𝗁𝖾 𝖻𝗈𝗍.\n\n**𝖭𝖮𝖳𝖤:** 𝖥𝗈𝗋 𝗌𝖾𝖼𝗎𝗋𝗂𝗍𝗒 𝗉𝗎𝗋𝗉𝗈���𝖾𝗌 𝗇𝗈𝖻𝗈𝖽𝗒 𝗐𝗂𝗅𝗅 𝗁𝖺𝗏𝖾 𝗍𝗁𝖾 𝖺𝖼𝖼𝖾𝗌𝗌 𝗍𝗈 𝗒𝗈𝗎𝗋 𝗌𝖾𝗌𝗌𝗂𝗈𝗇 𝗌𝗍𝗋𝗂𝗇𝗀. 𝖭𝗈𝗍 𝖾𝗏𝖾𝗇 𝗒𝗈𝗎 𝗈𝗋 𝗍𝗁𝖾 𝖻𝗈𝗍."
-        )
-    except TimeoutError:
-        await message.reply_text(
-            "**𝖳𝗂𝗆𝖾𝗈𝗎𝗍𝖤𝗋𝗋𝗈𝗋!** 𝖸𝗈𝗎 𝗍𝗈𝗈𝗄 𝗅𝗈𝗇𝗀𝖾𝗋 𝗍𝗁𝖺𝗇 𝖾𝗑𝖼𝗉𝖾𝖼𝗍𝖾𝖽 𝗍𝗈 𝖼𝗈𝗆𝗉𝗅𝖾𝗍𝖾 𝗍𝗁𝖾 𝗉𝗋𝗈𝖼𝖾𝗌𝗌. 𝖯𝗅𝖾𝖺𝗌𝖾 𝗍𝗋𝗒 𝖺𝗀𝖺𝗂𝗇."
-        )
-    except Exception as e:
-        await message.reply_text(f"**𝖤𝗋𝗋𝗈𝗋!** {e}")
-
-
-@hellbot.bot.on_message(
-    filters.regex(r"Delete ❌") & Config.AUTH_USERS & filters.private
-)
-async def delete_session(_, message: Message):
-    all_sessions = await db.get_all_sessions()
-    if not all_sessions:
-        return await message.reply_text("𝖭𝗈 𝗌𝖾𝗌𝗌𝗂𝗈𝗇𝗌 𝖿𝗈𝗎𝗇𝖽 𝗂𝗇 𝖽𝖺𝗍𝖺𝖻𝖺𝗌𝖾.")
-
-    collection = []
-    for i in all_sessions:
-        collection.append((i["user_id"], f"rm_session:{i['user_id']}"))
-
-    buttons = gen_inline_keyboard(collection, 2)
-    buttons.append([InlineKeyboardButton("Cancel ❌", "auth_close")])
-
-    await message.reply_text(
-        "**𝖢𝗁𝗈𝗈𝗌𝖾 𝖺 𝗌𝖾𝗌𝗌𝗂𝗈𝗇 𝗍𝗈 𝖽𝖾𝗅𝖾𝗍𝖾:**",
-        reply_markup=InlineKeyboardMarkup(buttons),
-    )
-
-
-@hellbot.bot.on_callback_query(filters.regex(r"rm_session"))
-async def rm_session_cb(client: Client, cb: CallbackQuery):
-    collection = []
-    user_id = int(cb.data.split(":")[1])
-    all_sessions = await db.get_all_sessions()
-
-    if not all_sessions:
-        return await cb.message.delete()
-
-    try:
-        owner = await client.get_users(Config.OWNER_ID)
-        owner_id = owner.id
-        owner_name = owner.first_name
-    except:
-        owner_id = Config.OWNER_ID
-        owner_name = "𝖮𝗐𝗇𝖾𝗋"
-    if cb.from_user.id not in [user_id, owner_id]:
-        return await cb.answer(
-            f"𝖠𝖼𝖼𝖾𝗌𝗌 𝗋𝖾𝗌𝗍𝗋𝗂𝖼𝗍𝖾𝖽 𝗍𝗈 𝖺𝗇𝗈𝗍𝗁𝖾𝗋 𝗎𝗌𝖾𝗋𝗌. Only {owner_name} and session client can delete this session!",
-            show_alert=True,
-        )
-
-    await db.rm_session(user_id)
-    await cb.answer("**𝖲𝗎𝖼𝖼𝖾𝗌𝗌!** 𝖲𝖾𝗌𝗌𝗂𝗈𝗇 𝖽𝖾𝗅𝖾𝗍𝖾𝖽 𝖿𝗋𝗈𝗆 𝖽𝖺𝗍𝖺𝖻𝖺𝗌𝖾. \n__Restart the bot to apply changes.__", show_alert=True)
-
-    for i in all_sessions:
-        collection.append((i["user_id"], f"rm_session:{i['user_id']}"))
-
-    buttons = gen_inline_keyboard(collection, 2)
-    buttons.append([InlineKeyboardButton("Cancel ❌", "auth_close")])
-
-    await cb.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
-
-
-@hellbot.bot.on_message(filters.regex(r"List 📜") & Config.AUTH_USERS & filters.private)
-async def list_sessions(_, message: Message):
-    all_sessions = await db.get_all_sessions()
-    if not all_sessions:
-        return await message.reply_text("𝖭𝗈 𝗌𝖾𝗌𝗌𝗂𝗈𝗇𝗌 𝖿𝗈𝗎𝗇𝖽 𝗂𝗇 𝖽𝖺𝗍𝖺𝖻𝖺𝗌𝖾.")
-
-    text = f"**{Symbols.cross_mark} 𝖫𝗂𝗌𝗍 𝗈𝖿 𝗌𝖾𝗌𝗌𝗂𝗈𝗇𝗌:**\n\n"
-    for i, session in enumerate(all_sessions):
-        text += f"[{'0' if i <= 9 else ''}{i+1}] {Symbols.bullet} **𝖴𝗌𝖾𝗋 𝖨𝖣:** `{session['user_id']}`\n"
-
-    await message.reply_text(text)
-
-
-@hellbot.bot.on_message(filters.regex(r"Home 🏠") & filters.private & Config.AUTH_USERS)
-async def go_home(_, message: Message):
-    await message.reply_text(
-        "**Home 🏠**",
-        reply_markup=ReplyKeyboardRemove(),
-    )
-    await message.reply_text(
-        START_MSG.format(message.from_user.mention),
-        disable_web_page_preview=True,
-        reply_markup=InlineKeyboardMarkup(start_button()),
-    )
-
-
-BotHelp("Sessions").add(
-    "session", "This command is packed with tools to manage userbot sessions."
-).info(
-    "Session 🚀"
-).done()

HellBot/plugins/bot/users.py

@@ -1,82 +0,0 @@
-from pyrogram import Client, filters
-from pyrogram.types import Message
-
-from . import BotHelp, Config, Symbols, hellbot
-
-
-@hellbot.bot.on_message(
-    filters.command("addauth") & Config.AUTH_USERS
-)
-async def addauth(client: Client, message: Message):
-    if not message.reply_to_message:
-        if len(message.command) < 2:
-            return await message.reply_text(
-                "Reply to a user or give me a userid/username to add them as an auth user!"
-            )
-        try:
-            user = await client.get_users(message.command[1])
-        except Exception:
-            return await message.reply_text(
-                "Give me a valid userid/username to add them as an auth user!"
-            )
-    else:
-        user = message.reply_to_message.from_user
-
-    if user.is_self:
-        return await message.reply_text("I can't add myself as an auth user!")
-
-    if user.id in Config.AUTH_USERS:
-        return await message.reply_text(f"**{user.mention} is already authorized**")
-
-    Config.AUTH_USERS.add(user.id)
-    await message.reply_text(f"**Added {user.mention} to auth users!**")
-
-
-@hellbot.bot.on_message(
-    filters.command("delauth") & Config.AUTH_USERS
-)
-async def delauth(client: Client, message: Message):
-    if not message.reply_to_message:
-        if len(message.command) < 2:
-            return await message.reply_text(
-                "Reply to a user or give me a userid/username to add them as an auth user!"
-            )
-        try:
-            user = await client.get_users(message.command[1])
-        except Exception:
-            return await message.reply_text(
-                "Give me a valid userid/username to add them as an auth user!"
-            )
-    else:
-        user = message.reply_to_message.from_user
-
-    if user.id in Config.AUTH_USERS:
-        Config.AUTH_USERS.remove(user.id)
-        await message.reply_text(f"**Removed {user.mention} from auth users!**")
-    else:
-        await message.reply_text(f"**{user.mention} is not authorized**")
-
-
-@hellbot.bot.on_message(
-    filters.command("authlist") & Config.AUTH_USERS
-)
-async def authlist(client: Client, message: Message):
-    text = "**🍀 Authorized Users:**\n\n"
-    for i, userid in enumerate(Config.AUTH_USERS):
-        try:
-            user = await client.get_users(userid)
-            text += f"    {Symbols.anchor} {user.mention} (`{user.id}`)\n"
-        except:
-            text += f"    {Symbols.anchor} Auth User #{i+1} (`{userid}`)\n"
-
-    await message.reply_text(text)
-
-
-BotHelp("Users").add(
-    "addauth",
-    "This command is used to add a user as an authorized user. An authorized user can create and manage userbot session!",
-).add("delauth", "This command is used to remove a user from authorized users.").add(
-    "authlist", "This command is used to list all authorized users."
-).info(
-    "Users Command 🚀"
-).done()

HellBot/plugins/btnsG.py

@@ -1,106 +0,0 @@
-# G: Glass Buttons
-
-from math import ceil
-
-from pyrogram.types import InlineKeyboardButton
-
-from Hellbot.core import ENV, Symbols, db, Config
-
-
-def gen_inline_keyboard(collection: list, row: int = 2) -> list[list[InlineKeyboardButton]]:
-    keyboard = []
-    for i in range(0, len(collection), row):
-        kyb = []
-        for x in collection[i : i + row]:
-            button = btn(*x)
-            kyb.append(button)
-        keyboard.append(kyb)
-    return keyboard
-
-
-def btn(text, value, type="callback_data") -> InlineKeyboardButton:
-    return InlineKeyboardButton(text, **{type: value})
-
-
-async def gen_inline_help_buttons(page: int, plugins: list) -> tuple[list, int]:
-    buttons = []
-    column = await db.get_env(ENV.btn_in_help) or 5
-    column = int(column)
-    emoji = await db.get_env(ENV.help_emoji) or "✧"
-    pairs = list(map(list, zip(plugins[::2], plugins[1::2])))
-
-    if len(plugins) % 2 == 1:
-        pairs.append([plugins[-1]])
-
-    max_pages = ceil(len(pairs) / column)
-    pairs = [pairs[i : i + column] for i in range(0, len(pairs), column)]
-
-    for pair in pairs[page]:
-        btn_pair = []
-        for i, plugin in enumerate(pair):
-            if i % 2 == 0:
-                btn_pair.append(
-                    InlineKeyboardButton(f"{emoji} {plugin}", f"help_menu:{page}:{plugin}")
-                )
-            else:
-                btn_pair.append(
-                    InlineKeyboardButton(f"{plugin} {emoji}", f"help_menu:{page}:{plugin}")
-                )
-        buttons.append(btn_pair)
-
-    buttons.append(
-        [
-            InlineKeyboardButton(
-                Symbols.previous, f"help_page:{(max_pages - 1) if page == 0 else (page - 1)}",
-            ),
-            InlineKeyboardButton(
-                Symbols.close, "help_data:c"
-            ),
-            InlineKeyboardButton(
-                Symbols.next, f"help_page:{0 if page == (max_pages - 1) else (page + 1)}",
-            ),
-        ]
-    )
-
-    return buttons, max_pages
-
-
-async def gen_bot_help_buttons() -> list[list[InlineKeyboardButton]]:
-    buttons = []
-    plugins = sorted(Config.BOT_CMD_MENU)
-    emoji = await db.get_env(ENV.help_emoji) or "✧"
-    pairs = list(map(list, zip(plugins[::2], plugins[1::2])))
-
-    if len(plugins) % 2 == 1:
-        pairs.append([plugins[-1]])
-
-    for pair in pairs:
-        btn_pair = []
-        for i, plugin in enumerate(pair):
-            if i % 2 == 0:
-                btn_pair.append(
-                    InlineKeyboardButton(f"{emoji} {plugin}", f"bot_help_menu:{plugin}")
-                )
-            else:
-                btn_pair.append(
-                    InlineKeyboardButton(f"{plugin} {emoji}", f"bot_help_menu:{plugin}")
-                )
-        buttons.append(btn_pair)
-
-    buttons.append(
-        [
-            InlineKeyboardButton("🏠", "help_data:start"),
-            InlineKeyboardButton(Symbols.close, "help_data:botclose"),
-        ]
-    )
-
-    return buttons
-
-
-def start_button() -> list[list[InlineKeyboardButton]]:
-    return [
-        [
-            InlineKeyboardButton("⚙️ Help", "help_data:bothelp"),
-            InlineKeyboardButton("Source 📦", "help_data:source"),
-        ]
-    ]

HellBot/plugins/btnsK.py

@@ -1,45 +0,0 @@
-# K: Keyboard Buttons
-
-from pyrogram.types import KeyboardButton, ReplyKeyboardMarkup
-
-
-def gen_keyboard(collection: list, row: int = 2) -> list[list[KeyboardButton]]:
-    keyboard = []
-    for i in range(0, len(collection), row):
-        kyb = []
-        for x in collection[i : i + row]:
-            kyb.append(KeyboardButton(x))
-        keyboard.append(kyb)
-    return keyboard
-
-
-def session_keyboard() -> ReplyKeyboardMarkup:
-    return ReplyKeyboardMarkup(
-        [
-            [
-                KeyboardButton("New 💫"),
-                KeyboardButton("Delete ❌"),
-            ],
-            [
-                KeyboardButton("List 📜"),
-                KeyboardButton("Home 🏠"),
-            ],
-        ],
-        resize_keyboard=True,
-    )
-
-
-def start_keyboard() -> ReplyKeyboardMarkup:
-    return ReplyKeyboardMarkup(
-        [
-            [
-                KeyboardButton("📟 Session"),
-                KeyboardButton("Force Sub ✨"),
-            ],
-            [
-                KeyboardButton("👥 Users"),
-                KeyboardButton("Others 📣"),
-            ],
-        ],
-        resize_keyboard=True,
-    )

HellBot/plugins/decorator.py

@@ -1,67 +0,0 @@
-from pyrogram import Client, filters
-from pyrogram.enums import ChatType
-from pyrogram.handlers import MessageHandler
-from pyrogram.types import Message
-
-from Hellbot.core import Config, db, hellbot
-from Hellbot.functions.admins import is_user_admin
-
-
-def on_message(
-    command: str | list[str],
-    group: int = 0,
-    chat_type: list[ChatType] = None,
-    admin_only: bool = False,
-    allow_stan: bool = False,
-):
-    if allow_stan:
-        _filter = (
-            filters.command(command, Config.HANDLERS)
-            & (filters.me | Config.STAN_USERS)
-            & ~filters.forwarded
-            & ~filters.via_bot
-        )
-    else:
-        _filter = (
-            filters.command(command, Config.HANDLERS)
-            & filters.me
-            & ~filters.forwarded
-            & ~filters.via_bot
-        )
-
-    def decorator(func):
-        async def wrapper(client: Client, message: Message):
-            if client.me.id != message.from_user.id:
-                if not await db.is_stan(client.me.id, message.from_user.id):
-                    return
-
-            if admin_only and not message.chat.type == ChatType.PRIVATE:
-                if not await is_user_admin(message.chat, client.me.id):
-                    return await hellbot.edit(message, "𝖨 𝖺𝗆 𝗇𝗈𝗍 𝖺𝗇 𝖺𝖽𝗆𝗂𝗇 𝗁𝖾𝗋𝖾!")
-
-            if chat_type and message.chat.type not in chat_type:
-                return await hellbot.edit(message, "𝖢𝖺𝗇'𝗍 𝗎𝗌𝖾 𝗍𝗁𝗂𝗌 𝖼𝗈𝗆𝗆𝖺𝗇𝖽 𝗁𝖾𝗋𝖾!")
-
-            await func(client, message)
-            message.continue_propagation()
-
-        for user in hellbot.users:
-            user.add_handler(MessageHandler(wrapper, _filter), group)
-
-        return wrapper
-
-    return decorator
-
-
-def custom_handler(filters: filters.Filter, group: int = 0):
-    def decorator(func):
-        async def wrapper(client: Client, message: Message):
-            await func(client, message)
-            message.continue_propagation()
-
-        for user in hellbot.users:
-            user.add_handler(MessageHandler(wrapper, filters), group)
-
-        return wrapper
-
-    return decorator

HellBot/plugins/help.py

@@ -1,132 +0,0 @@
-from Hellbot.core.config import Config, Symbols
-
-
-class HelpMenu:
-    def __init__(self, file: str) -> None:
-        self.filename = file
-        self.command_dict = {}
-        self.command_info = ""
-
-    def add(
-        self,
-        command: str,
-        parameters: str = None,
-        description: str = None,
-        example: str = None,
-        note: str = None,
-    ):
-        self.command_dict[command] = {
-            "command": command,
-            "parameters": parameters,
-            "description": description,
-            "example": example,
-            "note": note,
-        }
-        return self
-
-    def info(self, command_info: str):
-        self.command_info = command_info
-        return self
-
-    def get_menu(self) -> str:
-        result = f"**𝖯𝗅𝗎𝗀𝗂𝗇 𝖥𝗂𝗅𝖾:** `{self.filename}`"
-        if self.command_info:
-            result += f"\n**𝖯𝗅𝗎𝗀𝗂𝗇 𝖨𝗇𝖿𝗈:** __{self.command_info} 🍀__"
-        result += "\n\n"
-        for command in self.command_dict:
-            command = self.command_dict[command]
-            result += f"**{Symbols.radio_select} 𝖢𝗈𝗆𝗆𝖺𝗇𝖽:** `{Config.HANDLERS[0]}{command['command']}"
-            if command["parameters"]:
-                result += f" {command['parameters']}`\n"
-            else:
-                result += "`\n"
-            if command["description"]:
-                result += (
-                    f"**{Symbols.arrow_right} 𝖣𝖾𝗌𝖼𝗋𝗂𝗉𝗍𝗂𝗈𝗇:** __{command['description']}__\n"
-                )
-            if command["example"]:
-                result += f"**{Symbols.arrow_right} 𝖤𝗑𝖺𝗆𝗉𝗅𝖾:** `{Config.HANDLERS[0]}{command['example']}`\n"
-            if command["note"]:
-                result += f"**{Symbols.arrow_right} 𝖭𝗈𝗍𝖾:** __{command['note']}__\n"
-
-            result += "\n"
-
-            Config.CMD_INFO[command["command"]] = {
-                "command": f"{command['command']} {command['parameters'] if command['parameters'] else ''}",
-                "description": command["description"],
-                "example": command["example"],
-                "note": command["note"],
-                "plugin": self.filename,
-            }
-
-        return result
-
-    def done(self) -> None:
-        Config.HELP_DICT[self.filename] = {
-            "commands": self.command_dict,
-            "info": self.command_info,
-        }
-        Config.CMD_MENU[self.filename] = self.get_menu()
-
-
-class BotHelp:
-    def __init__(self, file: str) -> None:
-        self.category = file
-        self.command_dict = {}
-        self.command_info = ""
-
-    def add(self, command: str, description: str):
-        self.command_dict[command] = {"command": command, "description": description}
-        return self
-
-    def info(self, command_info: str):
-        self.command_info = command_info
-        return self
-
-    def get_menu(self) -> str:
-        result = f"**𝖯𝗅𝗎𝗀𝗂𝗇 𝖢𝖺𝗍𝖾𝗀𝗈𝗋𝗒:** `{self.category}`"
-        if self.command_info:
-            result += f"\n**𝖯𝗅𝗎𝗀𝗂𝗇 𝖨𝗇𝖿𝗈:** __{self.command_info}__"
-        result += "\n\n"
-        for command in self.command_dict:
-            command = self.command_dict[command]
-            result += f"**{Symbols.radio_select} 𝖢𝗈𝗆𝗆𝖺𝗇𝖽:** `/{command['command']}`\n"
-            if command["description"]:
-                result += (
-                    f"**{Symbols.arrow_right} 𝖣𝖾𝗌𝖼𝗋𝗂𝗉𝗍𝗂𝗈𝗇:** __{command['description']}__\n"
-                )
-            result += "\n"
-
-            Config.BOT_CMD_INFO[command["command"]] = {
-                "command": command["command"],
-                "description": command["description"],
-                "category": self.category,
-            }
-
-        return result
-
-    def done(self) -> None:
-        Config.BOT_HELP[self.category] = {
-            "commands": self.command_dict,
-            "info": self.command_info,
-        }
-        Config.BOT_CMD_MENU[self.category] = self.get_menu()
-
-
-# example usage of HelpMenu class
-"""
-HelpMenu("example").add(
-    "example", "<text>", "description of command", "example of command", "note of command"
-).info(
-    "information of plugin"
-).done()
-"""
-
-# example usage of BotHelp class
-"""
-BotHelp("example").add(
-    "example", "description of command"
-).info(
-    "information of category"
-).done()
-"""

HellBot/plugins/user/__init__.py

@@ -1,16 +0,0 @@
-from pyrogram.enums import ChatType
-
-from Hellbot.core.clients import hellbot
-from Hellbot.core.config import Config, Symbols
-from Hellbot.core.database import db
-from Hellbot.plugins.decorator import custom_handler, on_message
-from Hellbot.plugins.help import HelpMenu
-
-handler = Config.HANDLERS[0]
-bot = hellbot.bot
-
-bot_only = [ChatType.BOT]
-group_n_channel = [ChatType.GROUP, ChatType.SUPERGROUP, ChatType.CHANNEL]
-group_only = [ChatType.GROUP, ChatType.SUPERGROUP]
-private_n_bot = [ChatType.PRIVATE, ChatType.BOT]
-private_only = [ChatType.PRIVATE]

HellBot/plugins/user/admins.py

@@ -1,510 +0,0 @@
-import asyncio
-
-from pyrogram import Client, filters
-from pyrogram.types import ChatPermissions, ChatPrivileges, Message
-
-from Hellbot.core import LOGS
-
-from . import HelpMenu, custom_handler, db, group_only, handler, hellbot, on_message
-
-
-@on_message(
-    "promote",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def promote(client: Client, message: Message):
-    if len(message.command) < 2 and not message.reply_to_message:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝗉𝗋𝗈𝗆𝗈𝗍𝖾 𝗍𝗁𝖾𝗆!"
-        )
-
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-        title = await hellbot.input(message)
-    else:
-        user = await client.get_users(message.command[1])
-        title = (await hellbot.input(message)).split(" ", 1)[1].strip() or ""
-
-    try:
-        privileges = ChatPrivileges(
-            can_manage_chat=True,
-            can_delete_messages=True,
-            can_manage_video_chats=True,
-            can_restrict_members=False,
-            can_promote_members=False,
-            can_change_info=False,
-            can_invite_users=True,
-            can_pin_messages=True,
-            is_anonymous=False,
-        )
-        await message.chat.promote_member(user.id, privileges)
-        await client.set_administrator_title(message.chat.id, user.id, title)
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    await hellbot.delete(message, f"**💫 𝖯𝗋𝗈𝗆𝗈𝗍𝖾𝖽 {user.mention} 𝗌𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**")
-    await hellbot.check_and_log(
-        "promote",
-        f"**Promoted User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    "demote",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def demote(client: Client, message: Message):
-    if len(message.command) < 2 and not message.reply_to_message:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝖽𝖾𝗆𝗈𝗍𝖾 𝗍𝗁𝖾𝗆!"
-        )
-
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-    else:
-        user = await client.get_users(message.command[1])
-    try:
-        privileges = ChatPrivileges(
-            can_manage_chat=False,
-            can_delete_messages=False,
-            can_manage_video_chats=False,
-            can_restrict_members=False,
-            can_promote_members=False,
-            can_change_info=False,
-            can_invite_users=False,
-            can_pin_messages=False,
-            is_anonymous=False,
-        )
-        await message.chat.promote_member(user.id, privileges)
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    await hellbot.delete(message, f"**🙄 𝖣𝖾𝗆𝗈𝗍𝖾𝖽 {user.mention} 𝗌𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**")
-    await hellbot.check_and_log(
-        "demote",
-        f"**Demoted User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    ["ban", "dban"],
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def ban(client: Client, message: Message):
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-        if len(message.command) < 2:
-            reason = None
-        else:
-            reason = await hellbot.input(message)
-        if message.command[0][0].lower() == "d":
-            await message.reply_to_message.delete()
-    elif len(message.command) == 2:
-        user = await client.get_users(message.command[1])
-        reason = None
-    elif len(message.command) > 2:
-        user = await client.get_users(message.command[1])
-        reason = (await hellbot.input(message)).split(" ", 1)[1].strip()
-    else:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝖻𝖺𝗇 𝗍𝗁𝖾𝗆!"
-        )
-
-    try:
-        await message.chat.ban_member(user.id)
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    reason = reason if reason else "Not Specified"
-    await hellbot.delete(
-        message,
-        f"**☠️ 𝖡𝖺𝗇𝗇𝖾𝖽 {user.mention} 𝗌𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**\n**𝖱𝖾𝖺𝗌𝗈𝗇:** `{reason}`",
-        30,
-    )
-    await hellbot.check_and_log(
-        "ban",
-        f"**Banned User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Reason:** `{reason}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    "unban",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def unban(client: Client, message: Message):
-    if len(message.command) < 2 and not message.reply_to_message:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝗎𝗇𝖻𝖺𝗇 𝗍𝗁𝖾𝗆!"
-        )
-
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-    else:
-        user = await client.get_users(message.command[1])
-
-    try:
-        await message.chat.unban_member(user.id)
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    await hellbot.delete(message, f"**🤗 𝖴𝗇𝖻𝖺𝗇𝗇𝖾𝖽 {user.mention} 𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**", 30)
-    await hellbot.check_and_log(
-        "unban",
-        f"**Unbanned User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    ["kick", "dkick"],
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def kick(client: Client, message: Message):
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-        if len(message.command) < 2:
-            reason = None
-        else:
-            reason = await hellbot.input(message)
-        if message.command[0][0].lower() == "d":
-            await message.reply_to_message.delete()
-    elif len(message.command) == 2:
-        user = await client.get_users(message.command[1])
-        reason = None
-    elif len(message.command) > 2:
-        user = await client.get_users(message.command[1])
-        reason = (await hellbot.input(message)).split(" ", 1)[1].strip()
-    else:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝗄𝗂𝖼𝗄 𝗍𝗁𝖾𝗆!"
-        )
-
-    try:
-        await message.chat.ban_member(user.id)
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    reason = reason if reason else "Not Specified"
-    await hellbot.delete(
-        message,
-        f"**👋 𝖪𝗂𝖼𝗄𝖾𝖽 {user.mention} 𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**\n**𝖱𝖾𝖺𝗌𝗈𝗇:** `{reason}`",
-        30,
-    )
-    await hellbot.check_and_log(
-        "kick",
-        f"**Kicked User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Reason:** `{reason}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-    await asyncio.sleep(5)
-    await message.chat.unban_member(user.id)
-
-
-@on_message(
-    "mute",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def mute(client: Client, message: Message):
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-        if len(message.command) < 2:
-            reason = None
-        else:
-            reason = await hellbot.input(message)
-    elif len(message.command) == 2:
-        user = await client.get_users(message.command[1])
-        reason = None
-    elif len(message.command) > 2:
-        user = await client.get_users(message.command[1])
-        reason = (await hellbot.input(message)).split(" ", 1)[1].strip()
-    else:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝗆𝗎𝗍𝖾 𝗍𝗁𝖾𝗆!"
-        )
-
-    try:
-        permissions = ChatPermissions(
-            can_send_messages=False,
-        )
-        await message.chat.restrict_member(user.id, permissions)
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    reason = reason if reason else "Not Specified"
-    await hellbot.delete(
-        message,
-        f"**🤐 𝖬𝗎𝗍𝖾𝖽 {user.mention} 𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**\n**𝖱𝖾𝖺𝗌𝗈𝗇:** `{reason}`",
-        30,
-    )
-    await hellbot.check_and_log(
-        "mute",
-        f"**Muted User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Reason:** `{reason}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    "unmute",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def unmute(client: Client, message: Message):
-    if len(message.command) < 2 and not message.reply_to_message:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝗎𝗇𝗆𝗎𝗍𝖾 𝗍𝗁𝖾𝗆!"
-        )
-
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-    else:
-        user = await client.get_users(message.command[1])
-
-    try:
-        permissions = ChatPermissions(
-            can_send_messages=True,
-        )
-        await message.chat.restrict_member(user.id, permissions)
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    await hellbot.delete(message, f"**😁 𝖴𝗇𝗆𝗎𝗍𝖾𝖽 {user.mention} 𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**", 30)
-    await hellbot.check_and_log(
-        "unmute",
-        f"**Unmuted User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message("dmute", allow_stan=True)
-async def dmute(client: Client, message: Message):
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-        if len(message.command) < 2:
-            reason = None
-        else:
-            reason = await hellbot.input(message)
-    elif len(message.command) == 2:
-        user = await client.get_users(message.command[1])
-        reason = None
-    elif len(message.command) > 2:
-        user = await client.get_users(message.command[1])
-        reason = (await hellbot.input(message)).split(" ", 1)[1].strip()
-    else:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝗆𝗎𝗍𝖾 𝗍𝗁𝖾𝗆!"
-        )
-
-    if await db.is_muted(client.me.id, user.id, message.chat.id):
-        return await hellbot.delete(message, "This user is already dmuted.")
-
-    reason = reason if reason else "Not Specified"
-    await db.add_mute(client.me.id, user.id, message.chat.id, reason)
-    await hellbot.delete(
-        message,
-        f"**🤐 𝖬𝗎𝗍𝖾𝖽 {user.mention} 𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**\n**𝖱𝖾𝖺𝗌𝗈𝗇:** `{reason}`",
-        30,
-    )
-    await hellbot.check_and_log(
-        "dmute",
-        f"**D-Muted User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Reason:** `{reason}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title or message.chat.first_name}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message("undmute", allow_stan=True)
-async def undmute(client: Client, message: Message):
-    if len(message.command) < 2 and not message.reply_to_message:
-        return await hellbot.delete(
-            message, "𝖭𝖾𝖾𝖽 𝖺 𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽 𝗈𝗋 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝖺 𝗎𝗌𝖾𝗋 𝗍𝗈 𝗎𝗇𝗆𝗎𝗍𝖾 𝗍𝗁𝖾𝗆!"
-        )
-
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user
-    else:
-        user = await client.get_users(message.command[1])
-
-    if not await db.is_muted(client.me.id, user.id, message.chat.id):
-        return await hellbot.delete(message, "𝖳𝗁𝖾 𝗎𝗌𝖾𝗋 𝗂𝗌 𝗇𝗈𝗍 𝗆𝗎𝗍𝖾𝖽!")
-
-    reason = await db.rm_mute(client.me.id, user.id, message.chat.id)
-    await hellbot.delete(
-        message,
-        f"**😁 𝖴𝗇𝗆𝗎𝗍𝖾𝖽 {user.mention} 𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖿𝗎𝗅𝗅𝗒!**\n\n**Mute reason was:** `{reason}`",
-        30,
-    )
-    await hellbot.check_and_log(
-        "unmute",
-        f"**D-Unmuted User**\n\n**User:** {user.mention}\n**User ID:** `{user.id}`\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    "pin",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def pin(_, message: Message):
-    if not message.reply_to_message:
-        return await hellbot.delete(message, "𝖭𝖾𝖾𝖽 𝖺 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝗉𝗂𝗇 𝖺 𝗆𝖾𝗌𝗌𝖺𝗀𝖾!")
-
-    try:
-        await message.reply_to_message.pin()
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    await hellbot.delete(
-        message,
-        f"**📌 𝖯𝗂𝗇𝗇𝖾𝖽 [𝖬𝖾𝗌𝗌𝖺𝗀𝖾]({message.reply_to_message.link}) 𝗂𝗇 {message.chat.title}!**",
-        30,
-    )
-    await hellbot.check_and_log(
-        "pin",
-        f"**Pinned Message**\n\n**Message:** [Click Here]({message.reply_to_message.link})\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    "unpin",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def unpin(_, message: Message):
-    if not message.reply_to_message:
-        return await hellbot.delete(message, "𝖭𝖾𝖾𝖽 𝖺 𝗋𝖾𝗉𝗅𝗒 𝗍𝗈 𝗎𝗇𝗉𝗂𝗇 𝖺 𝗆𝖾𝗌𝗌𝖺𝗀𝖾!")
-
-    try:
-        await message.reply_to_message.unpin()
-    except Exception as e:
-        return await hellbot.error(message, e)
-
-    await hellbot.delete(
-        message,
-        f"**📌 𝖴𝗇𝗉𝗂𝗇𝗇𝖾𝖽 [𝖬𝖾𝗌𝗌𝖺𝗀𝖾]({message.reply_to_message.link}) 𝗂𝗇 {message.chat.title}!**",
-        30,
-    )
-    await hellbot.check_and_log(
-        "unpin",
-        f"**Unpinned Message**\n\n**Message:** [Click Here]({message.reply_to_message.link})\n**Admin:** `{message.from_user.mention}`\n**Group:** `{message.chat.title}`\n**Group ID:** `{message.chat.id}`",
-    )
-
-
-@on_message(
-    "zombies",
-    chat_type=group_only,
-    admin_only=True,
-    allow_stan=True,
-)
-async def zombies(_, message: Message):
-    hell = await hellbot.edit(message, "☠️ 𝖣𝖾𝗍𝖾𝖼𝗍𝗂𝗇𝗀 𝗓𝗈𝗆𝖻𝗂𝖾𝗌...")
-    ded_users = []
-    async for members in message.chat.get_members():
-        if members.user.is_deleted:
-            ded_users.append(members.user.id)
-
-    if not ded_users:
-        return await hell.edit(
-            "🫡 𝖣𝗈𝗇'𝗍 𝗁𝖺𝗏𝖾 𝖺𝗇𝗒 𝗓𝗈𝗆𝖻𝗂𝖾𝗌 𝗂𝗇 𝗍𝗁𝗂𝗌 𝗀𝗋𝗈𝗎𝗉. **𝖦𝗋𝗈𝗎𝗉𝗌' 𝖼𝗅𝖾𝖺𝗇 𝖠𝖥!**"
-        )
-
-    if len(message.command) > 1 and message.command[1].lower() == "clean":
-        await hell.edit(
-            f"☠️ 𝖥𝗈𝗎𝗇𝖽 {len(ded_users)} 𝗓𝗈𝗆𝖻𝗂𝖾𝗌... **🔫 𝖳𝗂𝗆𝖾 𝗍𝗈 𝗉𝗎𝗋𝗀𝖾 𝗍𝗁𝖾𝗆!**"
-        )
-        failed = 0
-        success = 0
-        for user in ded_users:
-            try:
-                await message.chat.ban_member(user)
-                success += 1
-            except Exception as e:
-                LOGS.error(e)
-                failed += 1
-
-        await hell.edit(f"**𝖯𝗎𝗋𝗀𝖾𝖽 {success} 𝗓𝗈𝗆𝖻𝗂𝖾𝗌!**\n`{failed}` holds immunity!")
-    else:
-        await hell.edit(
-            f"**☠️ 𝖥𝗈𝗎𝗇𝖽 {len(ded_users)} 𝗓𝗈𝗆𝖻𝗂𝖾𝗌!**\n\n__Use__ `{handler}zombies clean` __to kill them!__"
-        )
-
-
-@custom_handler(filters.incoming)
-async def multiple_handler(client: Client, message: Message):
-    if not message.from_user:
-        return
-
-    if await db.is_muted(client.me.id, message.from_user.id, message.chat.id):
-        try:
-            await message.delete()
-        except:
-            pass
-
-    elif await db.is_gmuted(message.from_user.id):
-        try:
-            await message.delete()
-        except:
-            pass
-
-    elif await db.is_echo(client.me.id, message.chat.id, message.from_user.id):
-        await message.copy(message.chat.id, reply_to_message_id=message.id)
-
-
-HelpMenu("admin").add(
-    "promote",
-    "<𝗎𝗌𝖾𝗋𝗇𝖺𝗆𝖾/𝗂𝖽/reply> <𝗍𝗂𝗍𝗅𝖾>",
-    "Promote a user to admin.",
-    "promote @ForGo10God hellboy",
-).add(
-    "demote", "<username/id/reply>", "Demote a user from admin.", "demote @ForGo10God"
-).add(
-    "ban",
-    "<username/id/reply> <reason>",
-    "Ban a user from the group.",
-    "ban @ForGo10God",
-    "You can also use dban to delete the message of the user.",
-).add(
-    "unban", "<username/id/reply>", "Unban a user from the group.", "unban @ForGo10God"
-).add(
-    "kick",
-    "<username/id/reply> <reason>",
-    "Kick a user from the group.",
-    "kick @ForGo10God",
-    "You can also use dkick to delete the message of the user.",
-).add(
-    "mute",
-    "<username/id/reply> <reason>",
-    "Mute a user in the group",
-    "mute @ForGo10God",
-    "You can also use dmute to delete the message of the user.",
-).add(
-    "unmute", "<username/id/reply>", "Unmute a user in the group.", "unmute @ForGo10God"
-).add(
-    "dmute",
-    "<username/id/reply>",
-    "Mute a user by deleting their new messages in the group.",
-    "dmute @ForGo10God",
-    "Need delete message permission for proper functioning.",
-).add(
-    "undmute",
-    "<username/id/reply>",
-    "Unmute a user who's muted using 'dmute' command in the group.",
-    "undmute @ForGo10God",
-).add(
-    "pin", "<reply>", "Pin the replied message in the group."
-).add(
-    "unpin", "<reply>", "Unpin the replied pinned message in the group."
-).add(
-    "zombies",
-    "clean",
-    "Finds the total number of deleted users present in that group and ban them.",
-).info(
-    "Admin Menu"
-).done()

HellBot/plugins/user/afk.py

@@ -1,157 +0,0 @@
-import os
-import random
-import time
-
-from pyrogram import Client, filters
-from pyrogram.enums import MessageMediaType
-from pyrogram.types import Message
-
-from Hellbot.core import Config, db, hellbot
-from Hellbot.functions.formatter import add_to_dict, get_from_dict, readable_time
-
-from . import HelpMenu, custom_handler, group_only, on_message
-
-afk_quotes = [
-    "🚶‍♂️ Taking a break, be back soon!",
-    "⏳ AFK - Away From the Keyboard momentarily.",
-    "🔜 Stepped away, but I'll return shortly.",
-    "👋 Gone for a moment, not forgotten.",
-    "🌿 Taking a breather, back in a bit.",
-    "📵 Away for a while, feel free to leave a message!",
-    "⏰ On a short break, back shortly.",
-    "🌈 Away from the screen, catching a breath.",
-    "💤 Offline for a moment, but still here in spirit.",
-    "🚀 Exploring the real world, back in a moment!",
-    "🍵 Taking a tea break, back shortly!",
-    "🌙 Resting my keyboard, back after a short nap.",
-    "🚶‍♀️ Stepping away for a moment of peace.",
-    "🎵 AFK but humming along, back shortly!",
-    "🌞 Taking a sunshine break, back soon!",
-    "🌊 Away, catching some waves of relaxation.",
-    "🚪 Temporarily closed, be back in a bit!",
-    "🌸 Taking a moment to smell the digital roses.",
-    "🍃 Stepped into the real world for a while.",
-]
-
-
-@on_message("afk")
-async def afk(_, message: Message):
-    if await db.is_afk(message.from_user.id):
-        return await hellbot.delete(message, "🙄 𝖨'𝗆 𝖺𝗅𝗋𝖾𝖺𝖽𝗒 𝖠𝖥𝖪!")
-
-    media_type = None
-    media = None
-
-    if message.reply_to_message and message.reply_to_message.media:
-        if message.reply_to_message.media == MessageMediaType.ANIMATION:
-            media_type = "animation"
-        elif message.reply_to_message.media == MessageMediaType.AUDIO:
-            media_type = "audio"
-        elif message.reply_to_message.media == MessageMediaType.PHOTO:
-            media_type = "photo"
-        elif message.reply_to_message.media == MessageMediaType.STICKER:
-            media_type = "sticker"
-        elif message.reply_to_message.media == MessageMediaType.VIDEO:
-            media_type = "video"
-        elif message.reply_to_message.media == MessageMediaType.VOICE:
-            media_type = "voice"
-
-        media = await message.reply_to_message.forward(Config.LOGGER_ID)
-
-    reason = await hellbot.input(message)
-    reason = reason if reason else "Not specified"
-
-    await db.set_afk(
-        message.from_user.id, reason, media.id if media else None, media_type
-    )
-    await hellbot.delete(message, "🫡 𝖦𝗈𝗂𝗇𝗀 𝖠𝖥𝖪! 𝖲𝖾𝖾 𝗒𝖺'𝗅𝗅 𝗅𝖺𝗍𝖾𝗋.")
-    await hellbot.check_and_log(
-        "afk",
-        f"Going AFK! \n\n**Reason:** `{reason}`",
-    )
-    add_to_dict(Config.AFK_CACHE, [message.from_user.id, message.chat.id])
-
-
-@custom_handler(filters.incoming & ~filters.bot & ~filters.service)
-async def afk_watch(client: Client, message: Message):
-    afk_data = await db.get_afk(client.me.id)
-    if not afk_data:
-        return
-
-    if message.from_user.id == afk_data["user_id"]:
-        return
-
-    if message.chat.type in group_only:
-        if not message.mentioned:
-            return
-
-    afk_time = readable_time(round(time.time() - afk_data["time"]))
-    caption = f"**{random.choice(afk_quotes)}**\n\n**💫 𝖱𝖾𝖺𝗌𝗈𝗇:** {afk_data['reason']}\n**⏰ 𝖠𝖥𝖪 𝖥𝗋𝗈𝗆:** `{afk_time}`"
-
-    if afk_data["media_type"] == "animation":
-        media = await client.get_messages(Config.LOGGER_ID, afk_data["media"])
-        sent = await client.send_animation(
-            message.chat.id, media.animation.file_id, caption, True
-        )
-
-    elif afk_data["media_type"] in ["audio", "photo", "video", "voice"]:
-        sent = await client.copy_message(
-            message.chat.id,
-            Config.LOGGER_ID,
-            afk_data["media"],
-            caption,
-            reply_to_message_id=message.id,
-        )
-
-    elif afk_data["media_type"] == "sticker":
-        media = await client.get_messages(Config.LOGGER_ID, afk_data["media"])
-        await client.download_media(media, "afk.png")
-        sent = await message.reply_photo("afk.png", caption=caption)
-        os.remove("afk.png")
-
-    else:
-        sent = await message.reply_text(caption)
-
-    link = message.link if message.chat.type in group_only else "No DM Link"
-
-    await hellbot.check_and_log(
-        "afk",
-        f"{message.from_user.mention} mentioned you when you were AFK! \n\n**Link:** {link}",
-    )
-    try:
-        data = get_from_dict(Config.AFK_CACHE, [afk_data["user_id"], message.chat.id])
-        if data:
-            await client.delete_messages(message.chat.id, data)
-        add_to_dict(Config.AFK_CACHE, [afk_data["user_id"], message.chat.id], sent.id)
-    except KeyError:
-        add_to_dict(Config.AFK_CACHE, [afk_data["user_id"], message.chat.id], sent.id)
-
-
-@custom_handler(filters.outgoing, 2)
-async def remove_afk(_, message: Message):
-    if await db.is_afk(message.from_user.id):
-        if "afk" in message.text:
-            return
-
-        data = await db.get_afk(message.from_user.id)
-        total_afk_time = readable_time(round(time.time() - data["time"]))
-
-        hell = await message.reply_text(
-            f"🫡 **𝖡𝖺𝖼𝗄 𝗍𝗈 𝗏𝗂𝗋𝗍𝗎𝖺𝗅 𝗐𝗈𝗋𝗅𝖽! \n\n⌚ Was away for:** `{total_afk_time}`"
-        )
-        await message.delete()
-
-        await db.rm_afk(message.from_user.id)
-        await hellbot.check_and_log(
-            "afk",
-            f"Returned from AFK! \n\n**Time:** `{total_afk_time}`\n**Link:** {hell.link}",
-        )
-
-
-HelpMenu("afk").add(
-    "afk",
-    "<reason>",
-    "Set your status as AFK. When someone mentions' you, the bot will tell them you're currently Offline! You can also use a media by replying to it.",
-    "afk good night!",
-    "To unset afk you can send a message to any chat and it'll automaticslly get disabled! You can use 'afk' in your message to bypass automatic disabling of afk.",
-).info("Away From Keyboard").done()

HellBot/plugins/user/anime.py

@@ -1,184 +0,0 @@
-import os
-
-from pyrogram.errors import ChatSendMediaForbidden
-from pyrogram.types import Message
-
-from Hellbot.core import hellbot
-from Hellbot.functions.scraping import (
-    get_airing_info,
-    get_anilist_user_info,
-    get_anime_info,
-    get_character_info,
-    get_filler_info,
-    get_manga_info,
-    get_watch_order,
-)
-
-from . import HelpMenu, on_message
-
-
-@on_message("anime", allow_stan=True)
-async def anime(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me an anime name to search!")
-
-    query = await hellbot.input(message)
-    hell = await hellbot.edit(message, "Searching ...")
-    caption, photo = await get_anime_info(query)
-
-    try:
-        await message.reply_photo(photo, caption=caption)
-        await hell.delete()
-    except ChatSendMediaForbidden:
-        await hell.edit(caption, disable_web_page_preview=True)
-
-    if os.path.exists(photo):
-        os.remove(photo)
-
-
-@on_message("manga", allow_stan=True)
-async def manga(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me a manga name to search!")
-
-    query = await hellbot.input(message)
-    hell = await hellbot.edit(message, "Searching ...")
-    caption, photo = await get_manga_info(query)
-
-    try:
-        await message.reply_photo(photo, caption=caption)
-        await hell.delete()
-    except ChatSendMediaForbidden:
-        await hell.edit(caption, disable_web_page_preview=True)
-
-    if os.path.exists(photo):
-        os.remove(photo)
-
-
-@on_message("character", allow_stan=True)
-async def character(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me a character name to search!")
-
-    query = await hellbot.input(message)
-    hell = await hellbot.edit(message, "Searching ...")
-    caption, photo = await get_character_info(query)
-
-    try:
-        await message.reply_photo(photo, caption=caption)
-        await hell.delete()
-    except ChatSendMediaForbidden:
-        await hell.edit(caption, disable_web_page_preview=True)
-
-    if os.path.exists(photo):
-        os.remove(photo)
-
-
-@on_message("airing", allow_stan=True)
-async def airing(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me an anime name to search!")
-
-    query = await hellbot.input(message)
-    hell = await hellbot.edit(message, "Searching ...")
-    caption, photo = await get_airing_info(query)
-
-    try:
-        await message.reply_photo(photo, caption=caption)
-        await hell.delete()
-    except ChatSendMediaForbidden:
-        await hell.edit(caption, disable_web_page_preview=True)
-
-    if os.path.exists(photo):
-        os.remove(photo)
-
-
-@on_message(["anilistuser", "aniuser"], allow_stan=True)
-async def anilist_user(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me an anilist username to search!")
-
-    query = await hellbot.input(message)
-    hell = await hellbot.edit(message, "Searching ...")
-    caption, photo = await get_anilist_user_info(query)
-
-    try:
-        await message.reply_photo(photo, caption=caption)
-        await hell.delete()
-    except ChatSendMediaForbidden:
-        await hell.edit(caption, disable_web_page_preview=True)
-
-    if os.path.exists(photo):
-        os.remove(photo)
-
-
-@on_message(["filler", "canon"], allow_stan=True)
-async def fillers(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me an anime name to search!")
-
-    query = await hellbot.input(message)
-    hell = await hellbot.edit(message, "Searching ...")
-
-    caption = await get_filler_info(query)
-    if caption == "":
-        return await hellbot.delete(hell, "No results found!")
-
-    await hell.edit(caption, disable_web_page_preview=True)
-
-
-@on_message("watchorder", allow_stan=True)
-async def watch_order(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me an anime name to search!")
-
-    query = await hellbot.input(message)
-    hell = await hellbot.edit(message, "Searching ...")
-
-    caption = await get_watch_order(query)
-    if caption == "":
-        return await hellbot.delete(hell, "No results found!")
-
-    await hell.edit(caption, disable_web_page_preview=True)
-
-
-HelpMenu("anime").add(
-    "anime",
-    "<name>",
-    "Get a detailed information about the mentioned anime.",
-    "anime one piece",
-).add(
-    "manga",
-    "<name>",
-    "Get a detailed information about the mentioned manga.",
-    "manga one piece",
-).add(
-    "character",
-    "<name>",
-    "Get a detailed information about the mentioned character.",
-    "character monkey d luffy",
-).add(
-    "airing",
-    "<name>",
-    "Get a detailed airing information about the mentioned anime.",
-    "airing one piece",
-).add(
-    "anilistuser",
-    "<username>",
-    "Get a detailed information about the mentioned anilist user.",
-    "anilistuser meizhellboy",
-    "You can also use 'aniuser' as alias",
-).add(
-    "filler",
-    "<name>",
-    "Get the list of filler/canon episodes about the mentioned anime.",
-    "filler one piece",
-    "You can also use 'canon' as alias",
-).add(
-    "watchorder",
-    "<name>",
-    "Get the watch order about the mentioned anime.",
-    "watchorder one piece",
-).info(
-    "Anime Menu"
-).done()

HellBot/plugins/user/antiflood.py

@@ -1,200 +0,0 @@
-import asyncio
-import datetime
-import time
-
-from pyrogram import Client, filters
-from pyrogram.types import ChatPermissions, Message
-
-from Hellbot.core import Config, Symbols, db
-from Hellbot.functions.utility import Flood
-
-from . import HelpMenu, custom_handler, group_only, hellbot, on_message
-
-
-@on_message("setflood", chat_type=group_only, admin_only=True, allow_stan=True)
-async def setflood(client: Client, message: Message):
-    count = 5
-    mtime = 0
-    mode = "mute"
-
-    try:
-        time_data = "N/A"
-        if len(message.command) == 2:
-            count = int(message.command[1])
-        elif len(message.command) == 3:
-            count = int(message.command[1])
-            mode = message.command[2]
-        elif len(message.command) >= 4:
-            count = int(message.command[1])
-            mode = message.command[2]
-            time_data = message.command[3]
-            if time_data.endswith(("d", "day", "days")):
-                mtime = int(time_data.split("d")[0].strip()) * 24 * 60 * 60
-            elif time_data.endswith(("h", "hrs", "hour", "hours")):
-                mtime = int(time_data.split("h")[0].strip()) * 60 * 60
-            elif time_data.endswith(("m", "mins", "minute", "minutes")):
-                mtime = int(time_data.split("m")[0].strip()) * 60
-            else:
-                return await hellbot.error(
-                    message,
-                    "Please pass time in correct format!\n\nExample: 12d or 12h or 12m",
-                )
-    except Exception as e:
-        return await hellbot.error(message, str(e))
-
-    if mode.lower() not in ["mute", "kick", "ban"]:
-        return await hellbot.error(
-            message, "**Invalid mode! Choose one: **\n`mute`, `kick`, `ban`"
-        )
-
-    settings = {
-        "mode": mode,
-        "limit": count,
-        "time": mtime,
-    }
-
-    await db.set_flood((client.me.id, message.chat.id), settings)
-    Flood.updateSettings(client.me.id, message.chat.id, settings)
-
-    if count == 0:
-        return await hellbot.delete(message, "Antiflood disabled!")
-
-    await hellbot.delete(
-        message,
-        f"**Antiflood enabled!**\n\n**{Symbols.triangle_right} Mode:** `{mode}`\n**{Symbols.triangle_right} Limit:** `{count}`\n**{Symbols.triangle_right} Time:** `{time_data}`",
-        20,
-    )
-
-
-@custom_handler(
-    filters.all
-    & filters.group
-    & filters.incoming
-    & ~filters.bot
-    & ~Config.AUTH_USERS
-    & ~filters.me
-    & ~filters.service
-)
-async def antiflood(client: Client, message: Message):
-    mode, mtime, limit = Flood.getSettings(client.me.id, message.chat.id)
-
-    if limit == 0:
-        return
-    if not Flood.check_client_chat(client.me.id, message.chat.id):
-        return
-
-    last_user, count = Flood.getLastUser(client.me.id, message.chat.id)
-
-    if last_user == message.from_user.id:
-        if (count + 1) >= limit:
-            template = (
-                "**🤫 𝖠𝗇𝗍𝗂𝖥𝗅𝗈𝗈𝖽 {mode}!!** \n\n"
-                "**{symbol} 𝖴𝗌𝖾𝗋:** `{mention}`\n"
-                "**{symbol} 𝖳𝗂𝗅𝗅 𝖣𝖺𝗍𝖾:** `🗓️ {till_date}`\n"
-            )
-            hell = await message.reply_text("Flood Detected!")
-
-            if mode == "mute":
-                permission = ChatPermissions(can_send_messages=False)
-                until_date = datetime.datetime.fromtimestamp(time.time() + mtime)
-                try:
-                    await client.restrict_chat_member(
-                        message.chat.id,
-                        message.from_user.id,
-                        permission,
-                        until_date,
-                    )
-                except Exception as e:
-                    return await hellbot.error(
-                        hell, f"__Error in Antiflood while trying to mute!__\n{str(e)}"
-                    )
-
-                Flood.updateFlood(
-                    client.me.id, message.chat.id, message.from_user.id, 0
-                )
-                till_date = "Forever" if mtime == 0 else until_date.ctime()
-
-                return await hell.edit(
-                    template.format(
-                        mode=mode.title(),
-                        symbol=Symbols.triangle_right,
-                        mention=message.from_user.mention,
-                        till_date=till_date,
-                    )
-                )
-
-            elif mode == "kick":
-                try:
-                    await client.ban_chat_member(message.chat.id, message.from_user.id)
-                except Exception as e:
-                    return await hellbot.error(
-                        hell, f"__Error in Antiflood while trying to kick!__\n{str(e)}"
-                    )
-
-                await hell.edit(
-                    template.format(
-                        mode=mode.title(),
-                        symbol=Symbols.triangle_right,
-                        mention=message.from_user.mention,
-                        till_date="Kicked Users can join back after 5 seconds!",
-                    )
-                )
-                Flood.updateFlood(
-                    client.me.id, message.chat.id, message.from_user.id, 0
-                )
-                await asyncio.sleep(5)
-                await client.unban_chat_member(message.chat.id, message.from_user.id)
-                return
-
-            elif mode == "ban":
-                until_date = datetime.datetime.fromtimestamp(time.time() + mtime)
-                try:
-                    await client.ban_chat_member(
-                        message.chat.id,
-                        message.from_user.id,
-                        until_date,
-                    )
-                except Exception as e:
-                    return await hellbot.error(
-                        hell, f"__Error in Antiflood while trying to ban!__\n{str(e)}"
-                    )
-
-                Flood.updateFlood(
-                    client.me.id, message.chat.id, message.from_user.id, 0
-                )
-                till_date = "Forever" if mtime == 0 else until_date.ctime()
-
-                return await hell.edit(
-                    template.format(
-                        mode=mode.title(),
-                        symbol=Symbols.triangle_right,
-                        mention=message.from_user.mention,
-                        till_date=till_date,
-                    )
-                )
-            else:
-                return
-        else:
-            count += 1
-            Flood.updateFlood(
-                client.me.id, message.chat.id, message.from_user.id, count
-            )
-            return
-    else:
-        Flood.updateFlood(client.me.id, message.chat.id, message.from_user.id, 1)
-
-
-HelpMenu("antiflood").add(
-    "setflood",
-    "<limit> <mode> <time>",
-    "Set antiflood in the chat! All arguments are optional, bydefault limit is 5 and mode is permanent mute.",
-    "setflood 10 ban 1d",
-    "Mode can be mute, kick or ban. Time can be xd (days), xh (hours) or xm (minutes) where x is number.",
-).add(
-    "setflood 0",
-    None,
-    "Disable antiflood in the chat!",
-    "setflood 0",
-).info(
-    "Control Flood in the chat!"
-).done()

HellBot/plugins/user/archiver.py

@@ -1,99 +0,0 @@
-import os
-import time
-import zipfile
-
-from pyrogram.types import Message
-
-from Hellbot.functions.formatter import readable_time
-from Hellbot.functions.tools import get_files_from_directory, progress
-
-from . import Config, HelpMenu, hellbot, on_message
-
-
-@on_message("zip", allow_stan=True)
-async def zip_files(_, message: Message):
-    if not message.reply_to_message:
-        return await hellbot.delete(message, "Reply to a message to zip it.")
-
-    media = message.reply_to_message.media
-    if not media:
-        return await hellbot.delete(message, "Reply to a media message to zip it.")
-
-    hell = await hellbot.edit(message, "`Zipping...`")
-    start = time.time()
-    download_path = await message.reply_to_message.download(
-        f"{Config.TEMP_DIR}temp_{round(time.time())}",
-        progress=progress,
-        progress_args=(hell, start, "📦 Zipping"),
-    )
-
-    zip_path = Config.TEMP_DIR + f"zipped_{int(time.time())}.zip"
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
-        zip_file.write(download_path)
-
-    await hellbot.delete(hell, "Zipped Successfully.")
-    await message.reply_document(
-        zip_path,
-        caption=f"**Zipped in {readable_time(time.time() - start)}.**",
-        progress=progress,
-        progress_args=(hell, start, "⬆️ Uploading"),
-    )
-
-    os.remove(zip_path)
-    os.remove(download_path)
-
-
-@on_message("unzip", allow_stan=True)
-async def unzip_file(_, message: Message):
-    if not message.reply_to_message:
-        return await hellbot.delete(message, "Reply to a message to unzip it.")
-
-    media = message.reply_to_message.media
-    if not media:
-        return await hellbot.delete(message, "Reply to a media message to unzip it.")
-
-    hell = await hellbot.edit(message, "`Unzipping...`")
-    start = time.time()
-    download_path = await message.reply_to_message.download(
-        f"{Config.TEMP_DIR}temp_{round(time.time())}",
-        progress=progress,
-        progress_args=(hell, start, "📦 Unzipping"),
-    )
-
-    with zipfile.ZipFile(download_path, "r") as zip_file:
-        if not os.path.isdir(Config.TEMP_DIR + "unzipped/"):
-            os.mkdir(Config.TEMP_DIR + "unzipped/")
-        zip_file.extractall(Config.TEMP_DIR + "unzipped/")
-
-    await hellbot.delete(hell, "Unzipped Successfully.")
-    files = await get_files_from_directory(Config.TEMP_DIR + "unzipped/")
-
-    for file in files:
-        if os.path.exists(file):
-            try:
-                await message.reply_document(
-                    file,
-                    caption=f"**Unzipped {os.path.basename(file)}.**",
-                    force_document=True,
-                    progress=progress,
-                    progress_args=(hell, start, "⬆️ Uploading"),
-                )
-            except Exception as e:
-                await message.reply_text(f"**{file}:** `{e}`")
-                continue
-            os.remove(file)
-
-    os.remove(download_path)
-
-
-HelpMenu("archiver").add(
-    "zip",
-    "<reply to a media>",
-    "Zip the replied media and upload it in the chat.",
-).add(
-    "unzip",
-    "<reply to a zip file>",
-    "Unzip the replied zip file and upload it in the chat.",
-).info(
-    "Manage Archives"
-).done()

HellBot/plugins/user/autopost.py

@@ -1,143 +0,0 @@
-from pyrogram import Client, filters
-from pyrogram.types import Message
-
-from Hellbot.core import Symbols
-
-from . import HelpMenu, custom_handler, db, group_n_channel, hellbot, on_message
-
-
-@on_message("autopost", chat_type=group_n_channel, allow_stan=True)
-async def autopost(client: Client, message: Message):
-    if len(message.command) != 2:
-        return await hellbot.delete(
-            message, "Wrong usage of command.\nCheck help menu for more info."
-        )
-
-    hell = await hellbot.edit(message, "Starting Autopost in this group/channel...")
-
-    post_from = message.command[1]
-    _chat = await client.get_chat(post_from)
-
-    if not _chat:
-        return await hellbot.delete(hell, "Invalid chat/channel id.")
-
-    if _chat.type not in group_n_channel:
-        return await hellbot.delete(
-            hell, "You can only autopost in groups and channels."
-        )
-
-    if _chat.id == message.chat.id:
-        return await hellbot.delete(
-            hell, "You can't autopost in the same group/channel."
-        )
-
-    if _chat.id in await db.is_autopost(client.me.id, _chat.id, message.chat.id):
-        return await hellbot.delete(
-            hell, "This group/channel is already in autopost list."
-        )
-
-    await db.set_autopost(client.me.id, _chat.id, message.chat.id)
-
-    await hellbot.delete(
-        hell, f"Autopost started from {_chat.title} to {message.chat.title}."
-    )
-    await hellbot.check_and_log(
-        "autopost start",
-        f"**AutoPost From:** {_chat.title} \n**AutoPost To:** {message.chat.title}\n**AutoPost By:** {client.me.mention}",
-    )
-
-
-@on_message("stopautopost", chat_type=group_n_channel, allow_stan=True)
-async def stop_autopost(client: Client, message: Message):
-    if len(message.command) != 2:
-        return await hellbot.delete(
-            message, "Wrong usage of command.\nCheck help menu for more info."
-        )
-
-    hell = await hellbot.edit(message, "Stopping Autopost in this group/channel...")
-
-    post_from = message.command[1]
-    _chat = await client.get_chat(post_from)
-
-    if not _chat:
-        return await hellbot.delete(hell, "Invalid chat/channel id.")
-
-    if _chat.type not in group_n_channel:
-        return await hellbot.delete(
-            hell, "You can only autopost in groups and channels."
-        )
-
-    if _chat.id not in await db.is_autopost(client.me.id, _chat.id, message.chat.id):
-        return await hellbot.delete(hell, "This group/channel is not in autopost list.")
-
-    await db.rm_autopost(client.me.id, _chat.id, message.chat.id)
-
-    await hellbot.delete(
-        hell, f"Autopost stopped from {_chat.title} to {message.chat.title}."
-    )
-    await hellbot.check_and_log(
-        "autopost stop",
-        f"**AutoPost From:** {_chat.title} \n**AutoPost To:** {message.chat.title}\n**AutoPost By:** {client.me.mention}",
-    )
-
-
-@on_message("autoposts", chat_type=group_n_channel, allow_stan=True)
-async def autoposts(client: Client, message: Message):
-    hell = await hellbot.edit(message, "Getting autopost list...")
-
-    data = await db.get_all_autoposts(client.me.id)
-    if not data:
-        return await hellbot.delete(hell, "No autoposts found.")
-
-    text = f"**𝖠𝖼𝗍𝗂𝗏𝖾 𝖠𝗎𝗍𝗈𝗉𝗈𝗌𝗍𝗌 𝖿𝗈𝗋: {client.me.mention}**\n\n"
-    for i in data:
-        from_chat = await client.get_chat(i["from_channel"])
-        to_chat = await client.get_chat(i["to_channel"])
-
-        from_chat_name = (
-            f"{from_chat.title} [{from_chat.id}]" if from_chat else i["from_channel"]
-        )
-        to_chat_name = f"{to_chat.title} [{to_chat.id}]" if to_chat else i["to_channel"]
-
-        text += f"   {Symbols.anchor} **From:** {from_chat_name}\n"
-        text += f"   {Symbols.anchor} **To:** {to_chat_name}\n"
-        text += f"   {Symbols.anchor} **Date:** {i['date']}\n\n"
-
-    await hellbot.edit(hell, text)
-
-
-@custom_handler(filters.incoming & filters.group & filters.channel & ~filters.service)
-async def handle_autopost(client: Client, message: Message):
-    if not await db.is_autopost(client.me.id, message.chat.id):
-        return
-
-    data = await db.get_autopost(client.me.id, message.chat.id)
-    if not data:
-        return
-
-    from_chat = await client.get_chat(data["from_channel"])
-    if not from_chat:
-        return
-
-    if message.chat.id != data["to_channel"]:
-        return
-
-    await message.copy(int(data["to_channel"]))
-
-
-HelpMenu("autopost").add(
-    "autopost",
-    "<channel id>",
-    "Start autoposting in current group/channel from the mentioned chatid/username of channel.",
-    "autopost @Its_HellBot",
-    "This module will post all incoming post from the target channel to the current chat without forward tag!",
-).add(
-    "stopautopost",
-    "<channel id>",
-    "Stops autoposting in current chroup/channel from the mentioned chatid/username of channel.",
-    "stopautopost @Its_HellBot",
-).add(
-    "autoposts", None, "Get all active autoposts!", "autoposts"
-).info(
-    "AutoPost Module"
-).done()

HellBot/plugins/user/blacklist.py

@@ -1,78 +0,0 @@
-import re
-
-from pyrogram import Client, filters
-from pyrogram.types import Message
-
-from Hellbot.core import Config, Symbols
-from Hellbot.functions.utility import BList
-
-from . import HelpMenu, custom_handler, db, hellbot, on_message
-
-
-@on_message("blacklist", admin_only=True, allow_stan=True)
-async def blacklist(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me something to blacklist.")
-
-    text = await hellbot.input(message)
-
-    if await db.is_blacklist(client.me.id, message.chat.id, text):
-        return await hellbot.delete(message, f"**Already blacklisted** `{text}`")
-
-    await BList.addBlacklist(client.me.id, message.chat.id, text)
-    await hellbot.delete(message, f"**Blacklisted:** `{text}`")
-
-
-@on_message("unblacklist", admin_only=True, allow_stan=True)
-async def unblacklist(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me something to unblacklist.")
-
-    text = await hellbot.input(message)
-
-    if not await db.is_blacklist(client.me.id, message.chat.id, text):
-        return await hellbot.delete(message, f"`{text}` does not exist in blacklist.")
-
-    await BList.rmBlacklist(client.me.id, message.chat.id, text)
-    await hellbot.delete(message, f"**Unblacklisted:** `{text}`")
-
-
-@on_message("blacklists", admin_only=True, allow_stan=True)
-async def blacklists(client: Client, message: Message):
-    blacklists = await db.get_all_blacklists(client.me.id, message.chat.id)
-
-    if not blacklists:
-        return await hellbot.delete(message, "No blacklists found.")
-
-    text = f"**{Symbols.bullet} 𝖡𝗅𝖺𝖼𝗄𝗅𝗂𝗌𝗍𝗌 𝗂𝗇 {message.chat.title}:**\n\n"
-    for i in blacklists:
-        text += f"    {Symbols.anchor} `{i}`\n"
-
-    await hellbot.edit(message, text)
-
-
-@custom_handler(filters.text & filters.incoming & ~Config.AUTH_USERS & ~filters.service)
-async def handle_blacklists(client: Client, message: Message):
-    if BList.check_client_chat(client.me.id, message.chat.id):
-        blacklists = BList.getBlacklists(client.me.id, message.chat.id)
-        for blacklist in blacklists:
-            pattern = r"( |^|[^\w])" + re.escape(blacklist) + r"( |$|[^\w])"
-            if re.search(pattern, message.text, flags=re.IGNORECASE):
-                try:
-                    await message.delete()
-                except Exception:
-                    await BList.rmBlacklist(client.me.id, message.chat.id, blacklist)
-
-
-HelpMenu("blacklist").add(
-    "blacklist",
-    "<text>",
-    "Add the text to blacklist. If the text is sent in the chat it will be deleted.",
-    "blacklist hello",
-).add(
-    "unblacklist", "<text>", "Remove the text from blacklist.", "unblacklist hello"
-).add(
-    "blacklists", None, "List all the blacklisted words in the chat.", "blacklists"
-).info(
-    "Blacklist Module"
-).done()

HellBot/plugins/user/bot.py

@@ -1,164 +0,0 @@
-import os
-import random
-import time
-
-from pyrogram import Client
-from pyrogram.types import Message
-
-from Hellbot import START_TIME
-from Hellbot.core import ENV
-from Hellbot.functions.formatter import readable_time
-from Hellbot.functions.images import generate_alive_image
-from Hellbot.functions.templates import alive_template, ping_template
-
-from . import Config, HelpMenu, db, hellbot, on_message
-
-
-@on_message("alive", allow_stan=True)
-async def alive(client: Client, message: Message):
-    hell = await hellbot.edit(message, "Processing ...")
-
-    img = await db.get_env(ENV.alive_pic)
-    if not img:
-        if message.from_user.photo:
-            user_pfp = await client.download_media(message.from_user.photo.big_file_id)
-            del_path = True
-        else:
-            user_pfp = "./Hellbot/resources/images/hellbot_logo.png"
-            del_path = False
-        img = [
-            generate_alive_image(
-                message.from_user.first_name, user_pfp, del_path, Config.FONT_PATH
-            )
-        ]
-    else:
-        img = img.split(" ")
-
-    img = random.choice(img)
-    uptime = readable_time(time.time() - START_TIME)
-    caption = await alive_template(client.me.first_name, uptime)
-
-    if img.endswith(".mp4"):
-        await message.reply_video(img, caption=caption)
-    else:
-        await message.reply_photo(img, caption=caption)
-    await hell.delete()
-
-    try:
-        os.remove(img)
-    except:
-        pass
-
-
-@on_message("ping", allow_stan=True)
-async def ping(client: Client, message: Message):
-    start_time = time.time()
-    hell = await hellbot.edit(message, "**Pong ~**")
-    uptime = readable_time(time.time() - START_TIME)
-    img = await db.get_env(ENV.ping_pic)
-    end_time = time.time()
-    speed = end_time - start_time
-    caption = await ping_template(round(speed, 3), uptime, client.me.mention)
-    if img:
-        img = random.choice(img.split(" "))
-        if img.endswith(".mp4"):
-            await message.reply_video(
-                img,
-                caption=caption,
-            )
-        else:
-            await message.reply_photo(
-                img,
-                caption=caption,
-            )
-            await hell.delete()
-        return
-    await hellbot.edit(hell, caption, no_link_preview=True)
-
-
-@on_message("history", allow_stan=True)
-async def history(client: Client, message: Message):
-    if not message.reply_to_message:
-        if len(message.command) < 2:
-            return await hellbot.delete(
-                message, "Either reply to an user or give me a username to get history."
-            )
-        try:
-            user = await client.get_users(message.command[1])
-        except Exception as e:
-            return await hellbot.error(message, f"`{str(e)}`")
-    else:
-        user = message.reply_to_message.from_user
-
-    hell = await hellbot.edit(message, "Processing ...")
-
-    try:
-        response = await client.ask("@SangMata_BOT", f"{user.id}", timeout=60)
-    except Exception as e:
-        return await hellbot.error(hell, f"`{str(e)}`")
-
-    if "you have used up your quota for today" in response.text:
-        return await hellbot.delete(
-            hell,
-            f"Your quota of using SangMata Bot is over. Wait till 00:00 UTC before using it again.",
-        )
-
-    try:
-        await response.delete()
-        await response.request.delete()
-    except:
-        pass
-
-    await hellbot.edit(hell, response.text)
-
-
-@on_message("template", allow_stan=True)
-async def template_example(_, message: Message):
-    variable_names = list(Config.TEMPLATES.keys())
-    if len(message.command) < 2:
-        return await hellbot.delete(
-            message,
-            f"__Give a template name to get template example.__\n\n**Available Templates:**\n`{'`,    `'.join(variable_names)}`",
-            30,
-        )
-
-    if message.command[1].upper() not in variable_names:
-        return await hellbot.delete(
-            message,
-            f"__Invalid template name:__ `{message.command[1].upper()}`\n\n**Available Templates:**\n`{'`,    `'.join(variable_names)}`",
-            30,
-        )
-
-    await hellbot.edit(
-        message,
-        f"**{message.command[1].upper()} Template Example:**\n\n```{Config.TEMPLATES[message.command[1].upper()]}```"
-    )
-
-
-HelpMenu("bot").add(
-    "alive",
-    None,
-    "Get the alive message of the bot.",
-    "alive",
-    "You can also customize alive message with suitable variables for it.",
-).add(
-    "ping",
-    None,
-    "Check the ping speed and uptime of bot.",
-    "ping",
-    "You can also customize ping message by adding a media to it.",
-).add(
-    "history",
-    "<reply to user>/<username/id>",
-    "Get the username, name history of an user.",
-    "history @ForGo10_God",
-    "This command uses SangMata Bot to get the history.",
-).add(
-    "template",
-    "<template name>",
-    "Get the example of a template.",
-    "template alive_templates",
-    "This command is used to get the example of a template and a list of customisable templates.",
-).info(
-    "Alive Menu"
-).done()

HellBot/plugins/user/carbon.py

@@ -1,73 +0,0 @@
-import asyncio
-import os
-
-from pyrogram.types import Message
-
-from Hellbot.functions.driver import Driver
-
-from . import HelpMenu, hellbot, on_message
-
-
-@on_message("carbon", allow_stan=True)
-async def carbon(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me some code to make carbon.")
-
-    code = await hellbot.input(message)
-    hell = await hellbot.edit(message, "**[ 50% ]** __Making carbon...__")
-
-    driver, resp = Driver.get()
-    if not driver:
-        return await hellbot.error(message, resp)
-
-    await hell.edit("**[ 75% ]** __Making carbon...__")
-    image = await Driver.generate_carbon(driver, code)
-    await asyncio.sleep(4)
-
-    await hell.edit("**[ 100% ]** __Uploading carbon...__")
-    Driver.close(driver)
-
-    await hell.reply_photo(image, caption=f"**𝖢𝖺𝗋𝖻𝗈𝗇𝖾𝖽:**\n`{code}`")
-    await hell.delete()
-    os.remove(image)
-
-
-@on_message("karbon", allow_stan=True)
-async def karbon(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me some code to make karbon.")
-
-    code = await hellbot.input(message)
-    hell = await hellbot.edit(message, "**[ 50% ]** __Making karbon...__")
-
-    driver, resp = Driver.get()
-    if not driver:
-        return await hellbot.error(message, resp)
-
-    await hell.edit("**[ 75% ]** __Making karbon...__")
-    image = await Driver.generate_carbon(driver, code, True)
-    await asyncio.sleep(4)
-
-    await hell.edit("**[ 100% ]** __Uploading karbon...__")
-    Driver.close(driver)
-
-    await hell.reply_photo(image, caption=f"**𝖢𝖺𝗋𝖻𝗈𝗇𝖾𝖽:**\n`{code}`")
-    await hell.delete()
-    os.remove(image)
-
-
-HelpMenu("carbon").add(
-    "carbon",
-    "<code snippet>",
-    "Makes carbon of given code snippet.",
-    "carbon print('Hello World!')",
-    "The style is fixed and cannot be changed.",
-).add(
-    "karbon",
-    "<code snippet>",
-    "Makes carbon of given code snippet.",
-    "karbon print('Hello World!')",
-    "The style is randomly choosed.",
-).info(
-    "Carbon is a code snippet sharing service. You can make carbon of your code and share it with others."
-).done()

HellBot/plugins/user/climate.py

@@ -1,140 +0,0 @@
-from pyrogram.types import Message
-
-from Hellbot.core import ENV
-from Hellbot.functions.driver import Climate
-from Hellbot.functions.formatter import subscript, superscript
-from Hellbot.functions.templates import airpollution_templates, climate_templates
-
-from . import HelpMenu, db, hellbot, on_message
-
-
-@on_message("climate", allow_stan=True)
-async def climate(_, message: Message):
-    if len(message.command) < 2:
-        city = "Delhi"
-    else:
-        city = await hellbot.input(message)
-
-    hell = await hellbot.edit(message, f"**Fetching climate data for `{city}`**")
-
-    apiKey = await db.get_env(ENV.climate_api)
-    if not apiKey:
-        return await hellbot.delete(
-            hell, f"**Climate API not found!** Setup `{ENV.climate_api}` first."
-        )
-
-    data = await Climate.fetchWeather(city, apiKey)
-    if not data:
-        return await hellbot.delete(hell, f"**Climate data not found for `{city}`**")
-
-    city_name = data["name"]
-    country = Climate.getCountry(data["sys"]["country"])
-    weather = data["weather"][0]["main"]
-    timezone = Climate.getCountryTimezone(data["sys"]["country"])
-    sunrise = await Climate.getTime(data["sys"]["sunrise"])
-    sunset = await Climate.getTime(data["sys"]["sunset"])
-    wind = Climate.getWindData(data["wind"]["speed"], data["wind"]["deg"])
-    temperature = data["main"]["temp"]
-    feels_like = data["main"]["feels_like"]
-    temp_min = data["main"]["temp_min"]
-    temp_max = data["main"]["temp_max"]
-    pressure = data["main"]["pressure"]
-    humidity = data["main"]["humidity"]
-    visibility = data["visibility"]
-    clouds = data["clouds"]["all"]
-
-    await hell.edit(
-        await climate_templates(
-            city_name=city_name,
-            country=country,
-            weather=weather,
-            timezone=timezone,
-            sunrise=sunrise,
-            sunset=sunset,
-            wind=wind,
-            temperature=temperature,
-            feels_like=feels_like,
-            temp_min=temp_min,
-            temp_max=temp_max,
-            pressure=pressure,
-            humidity=humidity,
-            visibility=visibility,
-            clouds=clouds,
-        ),
-        disable_web_page_preview=True,
-    )
-
-
-@on_message("airpollution", allow_stan=True)
-async def airpollution(_, message: Message):
-    if len(message.command) < 2:
-        city = "Delhi"
-    else:
-        city = await hellbot.input(message)
-
-    hell = await hellbot.edit(message, f"**Fetching air pollution data for `{city}`**")
-
-    apiKey = await db.get_env(ENV.climate_api)
-    if not apiKey:
-        return await hellbot.delete(
-            hell, f"**Climate API not found!** Setup `{ENV.climate_api}` first."
-        )
-
-    data = await Climate.fetchAirPollution(city, apiKey)
-    if not data:
-        return await hellbot.delete(
-            hell, f"**Air pollution data not found for `{city}`**"
-        )
-
-    data = data["list"][0]
-    ugm3 = superscript("µg/m³")
-    sub2_5 = subscript("2.5")
-    sub10 = subscript("10")
-
-    city_name = city.upper()
-    aqi_index = data["main"]["aqi"]
-    aqi_cond = Climate.AQI_DICT[aqi_index]
-    aqi = f"{aqi_index} ({aqi_cond})"
-    co = f"{data['components']['co']} {ugm3}"
-    no = f"{data['components']['no']} {ugm3}"
-    no2 = f"{data['components']['no2']} {ugm3}"
-    o3 = f"{data['components']['o3']} {ugm3}"
-    so2 = f"{data['components']['so2']} {ugm3}"
-    nh3 = f"{data['components']['nh3']} {ugm3}"
-    pm2_5 = data["components"]["pm2_5"]
-    pm10 = data["components"]["pm10"]
-
-    await hell.edit(
-        await airpollution_templates(
-            city_name=city_name,
-            aqi=aqi,
-            co=co,
-            no=no,
-            no2=no2,
-            o3=o3,
-            so2=so2,
-            nh3=nh3,
-            pm2_5=pm2_5,
-            pm10=pm10,
-            sub2_5=sub2_5,
-            sub10=sub10,
-        ),
-        disable_web_page_preview=True,
-    )
-
-
-HelpMenu("climate").add(
-    "climate",
-    "<city name>",
-    "Get climate data of a city.",
-    "climate Delhi",
-    "City name is optional. Bydefault Delhi's climate data will be fetched.",
-).add(
-    "airpollution",
-    "<city name>",
-    "Get air pollution data of a city.",
-    "airpollution Delhi",
-    "City name is optional. Bydefault Delhi's air pollution data will be fetched.",
-).info(
-    "Get the API Key from [here](https://openweathermap.org/price)"
-).done()

HellBot/plugins/user/clone.py

@@ -1,106 +0,0 @@
-import os
-
-from pyrogram import Client
-from pyrogram.raw.functions.users import GetFullUser
-from pyrogram.types import Message
-
-from . import HelpMenu, db, hellbot, on_message
-
-
-@on_message("clone", allow_stan=True)
-async def clone(client: Client, message: Message):
-    if not message.reply_to_message:
-        return await hellbot.delete(
-            message, "Reply to a user's message to clone their profile."
-        )
-
-    replied_user = message.reply_to_message.from_user
-    if replied_user.is_self:
-        return await hellbot.delete(message, "I can't clone myself!")
-
-    hell = await hellbot.edit(message, "Cloning ...")
-
-    try:
-        meh = await client.resolve_peer(client.me.id)
-        fullUser = await client.invoke(GetFullUser(id=meh))
-        about = fullUser.full_user.about or ""
-    except:
-        about = ""
-
-    first_name = client.me.first_name
-    last_name = client.me.last_name or ""
-
-    await db.set_env("CLONE_FIRST_NAME", first_name)
-    await db.set_env("CLONE_LAST_NAME", last_name)
-    await db.set_env("CLONE_ABOUT", about)
-
-    try:
-        targetUser = await client.resolve_peer(replied_user.id)
-        repliedFullUser = await client.invoke(GetFullUser(id=targetUser))
-        await client.update_profile(
-            first_name=replied_user.first_name,
-            last_name=replied_user.last_name or "",
-            about=repliedFullUser.full_user.about or "",
-        )
-    except:
-        await client.update_profile(
-            first_name=replied_user.first_name,
-            last_name=replied_user.last_name or "",
-        )
-
-    try:
-        profile_pic = await client.download_media(replied_user.photo.big_file_id)
-        await client.set_profile_photo(photo=profile_pic)
-        os.remove(profile_pic)
-    except:
-        pass
-
-    await hell.edit("**😁 𝖧𝖾𝗅𝗅𝗈 𝗆𝗒 𝖿𝗋𝗂𝖾𝗇𝖽!**")
-    await hellbot.check_and_log(
-        "clone",
-        f"**Cloned {replied_user.mention}** ({replied_user.id}) \n\n**By:** {first_name}",
-    )
-
-
-@on_message("revert", allow_stan=True)
-async def revert(client: Client, message: Message):
-    first_name = await db.get_env("CLONE_FIRST_NAME")
-    last_name = await db.get_env("CLONE_LAST_NAME")
-    about = await db.get_env("CLONE_ABOUT")
-
-    if not first_name:
-        return await hellbot.delete(message, "I'm not cloned yet.")
-
-    hell = await hellbot.edit(message, "Reverting ...")
-
-    await client.update_profile(first_name, last_name, about)
-
-    async for photos in client.get_chat_photos("me", 1):
-        await client.delete_profile_photos(photos.file_id)
-
-    await db.rm_env("CLONE_FIRST_NAME")
-    await db.rm_env("CLONE_LAST_NAME")
-    await db.rm_env("CLONE_ABOUT")
-
-    await hell.edit("**Reverted back!**")
-    await hellbot.check_and_log(
-        "revert",
-        f"**Reverted to my original profile.** \n\n**By:** {first_name}",
-    )
-
-
-HelpMenu("clone").add(
-    "clone",
-    "<reply to user's message>",
-    "Clone the profile of replied user.",
-    "clone",
-    "You can revert back to last profile only. Clone with precaution.",
-).add(
-    "revert",
-    None,
-    "Revert back to original profile.",
-    "revert",
-    "You can revert back to last profile only. Clone with precaution.",
-).info(
-    "Clone Menu"
-).done()

HellBot/plugins/user/convert.py

@@ -1,216 +0,0 @@
-import os
-import time
-
-from pyrogram.types import Message
-
-from Hellbot.functions.convert import convert_to_gif
-from Hellbot.functions.tools import runcmd
-
-from . import HelpMenu, hellbot, on_message, Config
-
-
-@on_message("stog", allow_stan=True)
-async def sticker_to_gif(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.sticker:
-        return await hellbot.delete(
-            message, "Reply to an animated/video sticker to convert it to gif."
-        )
-
-    hell = await hellbot.edit(message, "Converting ...")
-
-    replied_sticker = message.reply_to_message.sticker
-
-    if replied_sticker.is_animated:
-        is_video = False
-    elif replied_sticker.is_video:
-        is_video = True
-    else:
-        return await hellbot.delete(hell, "Reply to an animated/video sticker.")
-
-    dwl_path = await message.reply_to_message.download(Config.TEMP_DIR)
-    gif_path = await convert_to_gif(dwl_path, is_video)
-
-    await message.reply_animation(gif_path)
-    await hellbot.delete(hell, "Converted to gif successfully!")
-
-    os.remove(dwl_path)
-    os.remove(gif_path)
-
-
-@on_message("stoi", allow_stan=True)
-async def sticker_to_image(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.sticker:
-        return await hellbot.delete(
-            message, "Reply to an sticker to convert it to image."
-        )
-
-    hell = await hellbot.edit(message, "Converting ...")
-    fileName = f"image_{round(time.time())}.png"
-    dwl_path = await message.reply_to_message.download(f"{Config.TEMP_DIR}{fileName}")
-
-    await message.reply_photo(dwl_path)
-    await hellbot.delete(hell, "Converted to image successfully!")
-
-    os.remove(dwl_path)
-
-
-@on_message("itos", allow_stan=True)
-async def image_to_sticker(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.photo:
-        return await hellbot.delete(
-            message, "Reply to an image to convert it to sticker."
-        )
-
-    hell = await hellbot.edit(message, "Converting ...")
-    fileName = f"sticker_{round(time.time())}.webp"
-    dwl_path = await message.reply_to_message.download(f"{Config.TEMP_DIR}{fileName}")
-
-    await message.reply_sticker(dwl_path)
-    await hellbot.delete(hell, "Converted to sticker successfully!")
-
-    os.remove(dwl_path)
-
-
-@on_message("ftoi", allow_stan=True)
-async def file_to_image(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.document:
-        return await hellbot.delete(message, "Reply to a file to convert it to image.")
-
-    if message.reply_to_message.document.mime_type.split("/")[0] != "image":
-        return await hellbot.delete(message, "Reply to an image file.")
-
-    hell = await hellbot.edit(message, "Converting ...")
-    fileName = f"image_{round(time.time())}.png"
-    dwl_path = await message.reply_to_message.download(f"{Config.TEMP_DIR}{fileName}")
-
-    await message.reply_photo(dwl_path)
-    await hellbot.delete(hell, "Converted to image successfully!")
-
-    os.remove(dwl_path)
-
-
-@on_message("itof", allow_stan=True)
-async def image_to_file(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.photo:
-        return await hellbot.delete(message, "Reply to an image to convert it to file.")
-
-    hell = await hellbot.edit(message, "Converting ...")
-    fileName = f"file_{round(time.time())}.png"
-    dwl_path = await message.reply_to_message.download(f"{Config.TEMP_DIR}{fileName}")
-
-    await message.reply_document(dwl_path)
-    await hellbot.delete(hell, "Converted to file successfully!")
-
-    os.remove(dwl_path)
-
-
-@on_message("tovoice", allow_stan=True)
-async def media_to_voice(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.media:
-        return await hellbot.delete(message, "Reply to a media to convert it to voice.")
-
-    hell = await hellbot.edit(message, "Converting ...")
-    dwl_path = await message.reply_to_message.download(f"{Config.TEMP_DIR}")
-    voice_path = f"{round(time.time())}.ogg"
-
-    cmd_list = [
-        "ffmpeg",
-        "-i",
-        dwl_path,
-        "-map",
-        "0:a",
-        "-codec:a",
-        "libopus",
-        "-b:a",
-        "100k",
-        "-vbr",
-        "on",
-        voice_path,
-    ]
-
-    _, err, _, _ = await runcmd(" ".join(cmd_list))
-
-    if os.path.exists(voice_path):
-        await message.reply_voice(voice_path)
-        await hellbot.delete(hell, "Converted to voice successfully!")
-        os.remove(voice_path)
-    else:
-        await hellbot.error(hell, f"`{err}`")
-
-    os.remove(dwl_path)
-
-
-@on_message("tomp3", allow_stan=True)
-async def media_to_mp3(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.media:
-        return await hellbot.delete(message, "Reply to a media to convert it to mp3.")
-
-    hell = await hellbot.edit(message, "Converting ...")
-    dwl_path = await message.reply_to_message.download(f"{Config.TEMP_DIR}")
-    mp3_path = f"{round(time.time())}.mp3"
-
-    cmd_list = [
-        "ffmpeg",
-        "-i",
-        dwl_path,
-        "-vn",
-        mp3_path,
-    ]
-
-    _, stderr, _, _ = await runcmd(" ".join(cmd_list))
-
-    if os.path.exists(mp3_path):
-        await message.reply_audio(mp3_path)
-        await hellbot.delete(hell, "Converted to mp3 successfully!")
-        os.remove(mp3_path)
-    else:
-        await hellbot.error(hell, f"`{stderr}`")
-
-    os.remove(dwl_path)
-
-
-HelpMenu("convert").add(
-    "stog", #Bugged: to-be-fixed
-    "<reply>",
-    "Converts animated sticker to gif.",
-    None,
-    "Only animated sticker and video sticker can be converted to gif.",
-).add(
-    "stoi",
-    "<reply>",
-    "Converts sticker to image.",
-    None,
-    "Only static stickers can be converted to image.",
-).add(
-    "itos",
-    "<reply>",
-    "Converts image to sticker.",
-    None,
-    "Only images can be converted to sticker.",
-).add(
-    "ftoi",
-    "<reply>",
-    "Converts file to image.",
-    None,
-    "Only image files can be converted to image.",
-).add(
-    "itof",
-    "<reply>",
-    "Converts image to file.",
-    None,
-    "Only images can be converted to file.",
-).add(
-    "tovoice",
-    "<reply>",
-    "Converts media to voice.",
-    None,
-    "Only video/audio can be converted to voice.",
-).add(
-    "tomp3",
-    "<reply>",
-    "Converts media to mp3.",
-    None,
-    "Only video/audio can be converted to mp3.",
-).info(
-    "Converts media to other formats."
-).done()

HellBot/plugins/user/core.py

@@ -1,321 +0,0 @@
-import importlib
-import os
-import sys
-from pathlib import Path
-
-from pyrogram import Client
-from pyrogram.enums import MessagesFilter, ParseMode
-from pyrogram.types import Message
-
-from Hellbot.core import ENV, Config, Symbols
-
-from . import HelpMenu, bot, db, handler, hellbot, on_message
-
-
-@on_message("help", allow_stan=True)
-async def help(client: Client, message: Message):
-    hell = await hellbot.edit(message, "**Processing...**")
-    if len(message.command) == 1:
-        try:
-            result = await client.get_inline_bot_results(bot.me.username, "help_menu")
-            await client.send_inline_bot_result(
-                message.chat.id,
-                result.query_id,
-                result.results[0].id,
-                True,
-            )
-            return await hell.delete()
-        except Exception as e:
-            await hellbot.error(hell, str(e), 20)
-            return
-
-    plugin = await hellbot.input(message)
-    if plugin.lower() in Config.CMD_MENU:
-        try:
-            await hellbot.edit(
-                hell, Config.CMD_MENU[plugin.lower()], ParseMode.MARKDOWN
-            )
-            return
-        except Exception as e:
-            await hellbot.error(hell, str(e), 20)
-            return
-
-    available_plugins = f"{Symbols.bullet} **𝖠𝗏𝖺𝗂𝗅𝖺𝖻𝗅𝖾 𝗉𝗅𝗎𝗀𝗂𝗇𝗌:**\n\n"
-    for i in sorted(list(Config.CMD_MENU.keys())):
-        available_plugins += f"`{i}`, "
-    available_plugins = available_plugins[:-2]
-    available_plugins += (
-        f"\n\n𝖣𝗈 `{handler}help <plugin name>` 𝗍𝗈 𝗀𝖾𝗍 𝖽𝖾𝗍𝖺𝗂𝗅𝖾𝖽 𝗂𝗇𝖿𝗈 𝗈𝖿 𝗍𝗁𝖺𝗍 𝗉𝗅𝗎𝗀𝗂𝗇."
-    )
-    await hellbot.edit(hell, available_plugins, ParseMode.MARKDOWN)
-
-
-@on_message("repo", allow_stan=True)
-async def repo(_, message: Message):
-    REPO_TEXT = (
-        "__🍀 𝖱𝖾𝗉𝗈:__ [Github](https://github.com/The-HellBot/HellBot)\n\n"
-        "__🍀 Updates:__ @Its_HellBot\n"
-        "__🍀 Support:__ @HellBot_Chats\n\n"
-        "**By ©️ @HellBot_Networks**"
-    )
-    await hellbot.edit(message, REPO_TEXT, no_link_preview=True)
-
-
-@on_message("plinfo", allow_stan=True)
-async def plugin_info(_, message: Message):
-    plugin = await hellbot.input(message)
-    if plugin.lower() in Config.CMD_MENU:
-        try:
-            await hellbot.edit(
-                message, Config.CMD_MENU[plugin.lower()], ParseMode.MARKDOWN
-            )
-            return
-        except Exception as e:
-            await hellbot.error(message, str(e), 20)
-            return
-    await hellbot.error(message, f"**Invalid Plugin Name:** `{plugin}`", 20)
-
-
-@on_message("cmdinfo", allow_stan=True)
-async def command_info(_, message: Message):
-    cmd = await hellbot.input(message)
-    if cmd.lower() in Config.CMD_INFO:
-        try:
-            cmd_dict = Config.CMD_INFO[cmd.lower()]
-            template = (
-                f"**🍀 𝖯𝗅𝗎𝗀𝗂𝗇:** `{cmd_dict['plugin']}.py`\n\n"
-                f"**{Symbols.anchor} 𝖢𝗈𝗆𝗆𝖺𝗇𝖽:** `{cmd_dict['command']}`\n"
-                f"**{Symbols.anchor} 𝖣𝖾𝗌𝖼𝗋𝗂𝗉𝗍𝗂𝗈𝗇:** __{cmd_dict['description']}__\n"
-                f"**{Symbols.anchor} 𝖤𝗑𝖺𝗆𝗉𝗅𝖾:** `{cmd_dict['example']}`\n"
-                f"**{Symbols.anchor} 𝖭𝗈𝗍𝖾:** __{cmd_dict['note']}__\n"
-            )
-            await hellbot.edit(message, template, ParseMode.MARKDOWN)
-            return
-        except Exception as e:
-            await hellbot.error(message, str(e), 20)
-            return
-    await hellbot.error(message, f"**Invalid Command Name:** `{cmd}`", 20)
-
-
-@on_message("send", allow_stan=True)
-async def send_plugin(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me a plugin name to send.")
-
-    plugin = message.command[1].lower().replace(".py", "").strip()
-    if plugin not in Config.CMD_MENU:
-        return await hellbot.delete(message, f"**Invalid Plugin Name:** `{plugin}`")
-
-    try:
-        await client.send_document(
-            message.chat.id,
-            f"./Hellbot/plugins/user/{plugin}.py",
-            caption=f"**🍀 𝖯𝗅𝗎𝗀𝗂𝗇:** `{plugin}.py`",
-        )
-        await hellbot.delete(message, f"**Sent:** `{plugin}.py`")
-    except Exception as e:
-        await hellbot.error(message, str(e), 20)
-
-
-@on_message("install", allow_stan=True)
-async def install_plugins(_, message: Message):
-    if not message.reply_to_message or not message.reply_to_message.document:
-        return await hellbot.delete(message, "Reply to a plugin to install it.")
-
-    hell = await hellbot.edit(message, "**Installing...**")
-    plugin_path = await message.reply_to_message.download("./Hellbot/plugins/user/")
-
-    if not plugin_path.endswith(".py"):
-        os.remove(plugin_path)
-        return await hellbot.error(hell, "**Invalid Plugin:** Not a python file.", 20)
-
-    plugin = plugin_path.split("/")[-1].replace(".py", "").strip()
-    if plugin in Config.CMD_MENU:
-        os.remove(plugin_path)
-        return await hellbot.error(
-            hell, f"**Plugin Already Installed:** `{plugin}.py`", 20
-        )
-
-    if "(" in plugin:
-        os.remove(plugin_path)
-        return await hellbot.error(
-            hell, f"**Plugin Already Installed:** `{plugin}.py`", 20
-        )
-
-    try:
-        shortname = Path(plugin_path).stem.replace(".py", "")
-        path = Path(f"Hellbot/plugins/user/{shortname}.py")
-        name = "Hellbot.plugins.user." + shortname
-        spec = importlib.util.spec_from_file_location(name, path)
-        load = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(load)
-        sys.modules["Hellbot.plugins.user." + shortname] = load
-        await hellbot.edit(hell, f"**Installed:** `{plugin}.py`")
-    except Exception as e:
-        await hellbot.error(hell, str(e), 20)
-        os.remove(plugin_path)
-
-
-@on_message("uninstall", allow_stan=True)
-async def uninstall_plugins(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me a plugin name to uninstall.")
-
-    plugin = message.command[1].lower().replace(".py", "").strip()
-    if plugin not in Config.CMD_MENU:
-        return await hellbot.delete(message, f"**Invalid Plugin Name:** `{plugin}`")
-
-    try:
-        os.remove(f"./Hellbot/plugins/user/{plugin}.py")
-        for i in Config.HELP_DICT[plugin]["commands"]:
-            cmd = i["command"]
-            for i in hellbot.users:
-                i.remove_handler(cmd)
-            del Config.CMD_INFO[cmd]
-        del Config.HELP_DICT[plugin]
-        del Config.CMD_MENU[plugin]
-        await hellbot.delete(message, f"**Uninstalled:** `{plugin}.py`")
-    except Exception as e:
-        await hellbot.error(message, str(e), 20)
-
-
-@on_message("installall", allow_stan=True)
-async def installall(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(
-            message, "Give me channel username to install plugins."
-        )
-
-    try:
-        chat = await client.get_chat(message.command[1])
-    except Exception as e:
-        return await hellbot.delete(message, f"**Invalid Channel Username:** `{e}`")
-
-    hell = await hellbot.edit(message, f"**Installing plugins from {chat.title}...**")
-    finalStr = f"{Symbols.check_mark} **𝖯𝗅𝗎𝗀𝗂𝗇𝗌 𝖨𝗇𝗌𝗍𝖺𝗅𝗅𝖾𝖽: {chat.title}**\n\n"
-    count = 0
-
-    async for msg in client.search_messages(chat.id, filter=MessagesFilter.DOCUMENT):
-        if msg.document.file_name.endswith(".py"):
-            dwl_path = await msg.download("./Hellbot/plugins/user/")
-            plugin = dwl_path.split("/")[-1].replace(".py", "").strip()
-            if plugin in Config.CMD_MENU:
-                os.remove(dwl_path)
-                finalStr += (
-                    f"   {Symbols.anchor} `{plugin}.py` - **𝖠𝗅𝗋𝖾𝖺𝖽𝗒 𝖨𝗇𝗌𝗍𝖺𝗅𝗅𝖾𝖽!**\n"
-                )
-                continue
-            if "(" in plugin:
-                os.remove(dwl_path)
-                finalStr += (
-                    f"   {Symbols.anchor} `{plugin}.py` - **𝖠𝗅𝗋𝖾𝖺𝖽𝗒 𝖨𝗇𝗌𝗍𝖺𝗅𝗅𝖾𝖽!**\n"
-                )
-                continue
-            try:
-                shortname = Path(dwl_path).stem.replace(".py", "")
-                path = Path(f"Hellbot/plugins/user/{shortname}.py")
-                name = "Hellbot.plugins.user." + shortname
-                spec = importlib.util.spec_from_file_location(name, path)
-                load = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(load)
-                sys.modules["Hellbot.plugins.user." + shortname] = load
-                count += 1
-                finalStr += f"   {Symbols.anchor} `{plugin}.py` - **𝖨𝗇𝗌𝗍𝖺𝗅𝗅𝖾𝖽!**\n"
-            except Exception as e:
-                os.remove(dwl_path)
-                finalStr += (
-                    f"   {Symbols.anchor} `{plugin}.py` - **𝖤𝗋𝗋𝗈𝗋 𝖨𝗇𝗌𝗍𝖺𝗅𝗅𝗂𝗇𝗀!**\n"
-                )
-                continue
-
-    finalStr += f"\n**🍀 𝖳𝗈𝗍𝖺𝗅 𝖯𝗅𝗎𝗀𝗂𝗇𝗌 𝖨𝗇𝗌𝗍𝖺𝗅𝗅𝖾𝖽:** `{count}`"
-    await hell.edit(finalStr, ParseMode.MARKDOWN, disable_web_page_preview=True)
-
-
-@on_message("unload", allow_stan=True)
-async def unload_plugins(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me a plugin name to unload.")
-
-    plugin = message.command[1].lower().replace(".py", "").strip()
-    if plugin not in Config.CMD_MENU:
-        return await hellbot.delete(message, f"**Invalid Plugin Name:** `{plugin}`")
-
-    unloaded = await db.get_env(ENV.unload_plugins) or ""
-    unloaded = unloaded.split(" ")
-    if plugin in unloaded:
-        return await hellbot.delete(message, f"**Already Unloaded:** `{plugin}.py`")
-
-    unloaded.append(plugin)
-    await db.set_env(ENV.unload_plugins, " ".join(unloaded))
-    await hellbot.delete(
-        message, f"**Unloaded:** `{plugin}.py` \n\n__Restart the bot to see changes.__"
-    )
-
-
-@on_message("load", allow_stan=True)
-async def load_plugins(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "Give me a plugin name to load.")
-
-    plugin = message.command[1].lower().replace(".py", "").strip()
-    unloaded = await db.get_env(ENV.unload_plugins) or ""
-    unloaded = unloaded.split(" ")
-    if plugin not in unloaded:
-        return await hellbot.delete(message, f"**Already Loaded:** `{plugin}.py`")
-
-    unloaded.remove(plugin)
-    await db.set_env(ENV.unload_plugins, " ".join(unloaded))
-    await hellbot.delete(
-        message, f"**Loaded:** `{plugin}.py` \n\n__Restart the bot to see changes.__"
-    )
-
-
-HelpMenu("help").add(
-    "help",
-    "<plugin name>",
-    "Get the detailed help menu for that mentioned plugin or get the whole help menu instead.",
-    "help alive",
-).add("repo", None, "Get the repo link of the bot.", "repo").add(
-    "plinfo",
-    "<plugin name>",
-    "Get the detailed info of the mentioned plugin.",
-    "plinfo alive",
-).add(
-    "cmdinfo",
-    "<command name>",
-    "Get the detailed info of the mentioned command.",
-    "cmdinfo alive",
-).add(
-    "send", "<plugin name>", "Send the mentioned plugin.", "send alive"
-).add(
-    "install",
-    "<reply to plugin>",
-    "Install the replied plugin.",
-    None,
-    "Do not install plugins from untrusted sources, they can be a malware. We're not responsible for any damage caused by them.",
-).add(
-    "uninstall",
-    "<plugin name>",
-    "Uninstall the mentioned plugin.",
-    "uninstall alive",
-    "This will remove all the commands of that plugin from the bot till a restart is initiated.",
-).add(
-    "installall",
-    "<channel username>",
-    "Install all the plugins from the mentioned channel.",
-    "installall @plugins_for_hellbot",
-    "Do not install plugins from untrusted sources, they can be a malware. We're not responsible for any damage caused by them.",
-).add(
-    "unload",
-    "<plugin name>",
-    "Unload the mentioned plugin.",
-    "unload alive",
-    "This will remove all the commands of that plugin from the bot permanently.",
-).add(
-    "load",
-    "<plugin name>",
-    "Load the mentioned plugin.",
-    "load alive",
-    "This will load all the commands of that plugin to the bot that was previously unloaded permanently.",
-)

HellBot/plugins/user/downloads.py

@@ -1,85 +0,0 @@
-import time
-
-from pyrogram.types import Message
-from pySmartDL import SmartDL
-
-from Hellbot.core import LOGS, Symbols
-from Hellbot.functions.formatter import readable_time
-from Hellbot.functions.tools import progress
-
-from . import Config, HelpMenu, hellbot, on_message
-
-
-@on_message("download", allow_stan=True)
-async def download(_, message: Message):
-    hell = await hellbot.edit(message, "Starting to download...")
-    if message.reply_to_message and message.reply_to_message.media:
-        start_time = time.time()
-        try:
-            dwl_path = await message.reply_to_message.download(
-                Config.DWL_DIR,
-                progress=progress,
-                progress_args=(
-                    hell,
-                    start_time,
-                    "⬇️ Downloading",
-                ),
-            )
-        except Exception as e:
-            return await hellbot.error(hell, f"`{e}`", 10)
-
-        await hell.edit(
-            f"**Downloaded to** `{dwl_path}` **in** {readable_time(round(time.time() - start_time))} seconds.**"
-        )
-
-    elif len(message.command) > 2:
-        dwl_url = (await hellbot.input(message)).split(" ")
-        start_time = time.time()
-        try:
-            dl = SmartDL(dwl_url, Config.DWL_DIR, progress_bar=False)
-            dl.start(blocking=False)
-            while not dl.isFinished():
-                display_msg = ""
-                downloaded_size = dl.get_dl_size(human=True)
-                file_size = dl.filesize or "Unknown"
-                diff = time.time() - start_time
-                speed = dl.get_speed(human=True)
-                dl_percentage = round((dl.get_progress() * 100), 2)
-                eta = dl.get_eta(human=True)
-                try:
-                    current_msg = (
-                        f"**⬇️ Downloading...**\n\n"
-                        f"**{Symbols.anchor} URL:** `{dwl_url}`\n"
-                        f"**{Symbols.anchor} Downloaded:** `{downloaded_size}` of `{file_size}`\n"
-                        f"**{Symbols.anchor} Speed:** `{speed}`\n"
-                        f"**{Symbols.anchor} ETA:** `{eta}`\n"
-                        f"**{Symbols.anchor} Progress:** `{dl_percentage}%`"
-                    )
-                    if round(diff % 10.00) == 0 and current_msg != display_msg:
-                        await hell.edit(current_msg)
-                        display_msg = current_msg
-                except Exception as e:
-                    LOGS.warning(f"PySmartDl: {str(e)}")
-
-            end_time = readable_time(round(time.time() - start_time))
-            if dl.isSuccessful():
-                await hell.edit(
-                    f"**Downloaded to** `{dl.get_dest()}` **in** `{end_time}` **seconds.**"
-                )
-            else:
-                await hellbot.error(hell, f"**Failed to download** `{len(dwl_url)} url(s)`")
-        except Exception as e:
-            return await hellbot.error(hell, f"`{e}`", 10)
-    else:
-        return await hellbot.delete(
-            message, "Reply to a media message or pass direct urls to download it."
-        )
-
-
-HelpMenu("downloads").add(
-    "download",
-    "<reply to media> or <direct link>",
-    "Download media to server.",
-    "download https://example.com/file.mp4",
-    "You can pass multiple urls to download it on my server.",
-).info("Downloader").done()

HellBot/plugins/user/echo.py

@@ -1,91 +0,0 @@
-from pyrogram import Client
-from pyrogram.types import Message
-
-from Hellbot.core import Symbols
-
-from . import HelpMenu, db, hellbot, on_message
-
-
-@on_message("echo", allow_stan=True)
-async def echo(client: Client, message: Message):
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user.id
-    elif len(message.command) > 1:
-        user = (await client.get_users(message.command[1])).id
-    else:
-        return await hellbot.delete(
-            message, "Reply to an user or pass me a user id to start echoing!"
-        )
-
-    if await db.is_echo(client.me.id, message.chat.id, user):
-        return await hellbot.delete(message, "Echo is already enabled for this user!")
-
-    await db.set_echo(client.me.id, message.chat.id, user)
-    await hellbot.delete(message, "Echo enabled for this user!")
-
-
-@on_message("unecho", allow_stan=True)
-async def unecho(client: Client, message: Message):
-    if message.reply_to_message:
-        user = message.reply_to_message.from_user.id
-    elif len(message.command) > 1:
-        user = (await client.get_users(message.command[1])).id
-    else:
-        return await hellbot.delete(
-            message, "Reply to an user or pass me a user id to stop echoing!"
-        )
-
-    if not await db.is_echo(client.me.id, message.chat.id, user):
-        return await hellbot.delete(message, "Echo is already disabled for this user!")
-
-    await db.rm_echo(client.me.id, message.chat.id, user)
-    await hellbot.delete(message, "Echo disabled for this user!")
-
-
-@on_message("listecho", allow_stan=True)
-async def listecho(client: Client, message: Message):
-    echos = await db.get_all_echo(client.me.id, message.chat.id)
-    if not echos:
-        return await hellbot.delete(message, "No echos in this chat!")
-
-    text = "**𝖫𝗂𝗌𝗍 𝗈𝖿 𝖤𝖼𝗁𝗈 𝗂𝗇 𝗍𝗁𝗂𝗌 𝖼𝗁𝖺𝗍:**\n\n"
-    for echo in echos:
-        text += f"    {Symbols.anchor} `{echo}`\n"
-
-    await hellbot.edit(message, text)
-
-
-@on_message(["resend", "copy"], allow_stan=True)
-async def reSend(_, message: Message):
-    if message.reply_to_message:
-        await message.reply_to_message.copy(
-            message.chat.id, reply_to_message_id=message.reply_to_message.id
-        )
-    await message.delete()
-
-
-HelpMenu("echo").add(
-    "echo",
-    "<reply> or <userid>",
-    "Echo every message of the replied user in present chat!",
-    "echo @ForGo10God",
-    "Echo works on text and sticker messages only!",
-).add(
-    "unecho",
-    "<reply> or <userid>",
-    "Stop echoing messages of the replied user in present chat!",
-    "unecho @ForGo10God",
-).add(
-    "listecho",
-    None,
-    "List all the users whose messages are being echoed in present chat!",
-    "listecho",
-).add(
-    "resend",
-    "<reply>",
-    "Resend the replied message!",
-    "resend",
-    "An alias of 'copy' is also available!",
-).info(
-    "Is it Echoing?"
-).done()

HellBot/plugins/user/eval.py

@@ -1,272 +0,0 @@
-import io
-import re
-import subprocess
-import sys
-import traceback
-
-import bs4
-import requests
-from pyrogram import Client
-from pyrogram.errors import MessageTooLong
-from pyrogram.types import Message
-from speedtest import Speedtest
-
-from . import HelpMenu, hellbot, on_message
-
-
-async def aexec(code, client, message):
-    exec(
-        "async def __aexec(client, message): "
-        + "".join(f"\n {l_}" for l_ in code.split("\n"))
-    )
-    return await locals()["__aexec"](client, message)
-
-
-@on_message("eval", allow_stan=True)
-async def runeval(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "No python code provided!")
-
-    reply_to = message.reply_to_message or message
-
-    code = await hellbot.input(message)
-    hell = await hellbot.edit(message, "`running...`")
-
-    old_stderr = sys.stderr
-    old_stdout = sys.stdout
-    redirected_output = sys.stdout = io.StringIO()
-    redirected_error = sys.stderr = io.StringIO()
-    stdout, stderr, exc = None, None, None
-
-    try:
-        await aexec(code, client, message)
-    except Exception:
-        exc = traceback.format_exc()
-
-    evaluation = ""
-    stdout = redirected_output.getvalue()
-    stderr = redirected_error.getvalue()
-    sys.stdout = old_stdout
-    sys.stderr = old_stderr
-
-    if exc:
-        evaluation = exc
-    elif stderr:
-        evaluation = stderr
-    elif stdout:
-        evaluation = stdout
-    else:
-        evaluation = "Success"
-
-    heading = f"**𝖤𝗏𝖺𝗅:**\n```python\n{code}```\n\n"
-    output = f"**𝖮𝗎𝗍𝗉𝗎𝗍:**\n`{evaluation.strip()}`"
-    final_output = heading + output
-
-    try:
-        await reply_to.reply_text(final_output, disable_web_page_preview=True)
-    except MessageTooLong:
-        with io.BytesIO(str.encode(output)) as out_file:
-            out_file.name = "eval.txt"
-            await reply_to.reply_document(out_file, caption=heading)
-
-    await hell.delete()
-
-
-@on_message(["exec", "term"], allow_stan=True)
-async def runterm(client: Client, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "No shell code provided!")
-
-    reply_to = message.reply_to_message or message
-
-    cmd = await hellbot.input(message)
-    hell = await hellbot.edit(message, "`running...`")
-
-    if "\n" in cmd:
-        code = cmd.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 hell.edit(f"**Error:** \n`{err}`")
-            output += f"**{code}**\n"
-            output += process.stdout.read()[:-1].decode("utf-8")
-            output += "\n"
-    else:
-        shell = re.split(""" (?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", cmd)
-        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:
-            exc_type, exc_obj, exc_tb = sys.exc_info()
-            errors = traceback.format_exception(exc_type, exc_obj, exc_tb)
-            await hell.edit("**Error:**\n`{}`".format("".join(errors)))
-            return
-        output = process.stdout.read()[:-1].decode("utf-8")
-
-    if str(output) == "\n":
-        return await hell.edit(f"**𝖮𝗎𝗍𝗉𝗎𝗍:** __𝖭𝗈 𝗈𝗎𝗍𝗉𝗎𝗍!__")
-    else:
-        try:
-            await reply_to.reply_text(
-                f"**{client.me.id}@hellbot:~$** `{cmd}`\n\n**𝖮𝗎𝗍𝗉𝗎𝗍:**\n```\n{output}```"
-            )
-        except MessageTooLong:
-            with io.BytesIO(str.encode(output)) as out_file:
-                out_file.name = "exec.txt"
-                await reply_to.reply_document(
-                    out_file,
-                    caption=f"**{client.me.id}@hellbot:~$** `{cmd}`",
-                )
-
-    await hell.delete()
-
-
-@on_message(["sh", "shell"], allow_stan=True)
-async def runshell(_, message: Message):
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "No shell code provided!")
-
-    code = await hellbot.input(message)
-    hell = await hellbot.edit(message, "`executing...`")
-
-    result = subprocess.run(code, shell=True, capture_output=True, text=True)
-    output = result.stdout + result.stderr
-
-    heading = f"**𝖲𝗁𝖾𝗅𝗅:**\n```sh\n{code}```\n\n"
-    output = f"**𝖮𝗎𝗍𝗉𝗎𝗍:**\n`{output.strip()}`"
-    final_output = heading + output
-
-    try:
-        await message.reply_text(final_output, disable_web_page_preview=True)
-    except MessageTooLong:
-        with io.BytesIO(str.encode(output)) as out_file:
-            out_file.name = "shell.txt"
-            await message.reply_document(out_file, caption=heading)
-
-    await hell.delete()
-
-
-@on_message("fext", allow_stan=True)
-async def file_extention(_, message: Message):
-    BASE_URL = "https://www.fileext.com/file-extension/{0}.html"
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "No file extention provided!")
-
-    extention = message.command[1]
-    hell = await hellbot.edit(message, "`getting information...`")
-
-    response = requests.get(BASE_URL.format(extention))
-    if response.status_code == 200:
-        soup = bs4.BeautifulSoup(response.content, "html.parser")
-        details = soup.find_all("td", {"colspan": "3"})[-1].text
-        await hell.edit(f"**𝖥𝗂𝗅𝖾 𝖤𝗑𝗍𝖾𝗇𝗍𝗂𝗈𝗇:** `{extention}`\n\n**𝖣𝖾𝗍𝖺𝗂𝗅𝗌:**\n`{details}`")
-    else:
-        await hell.edit(f"**𝖥𝗂𝗅𝖾 𝖤𝗑𝗍𝖾𝗇𝗍𝗂𝗈𝗇:** `{extention}`\n\n**𝖣𝖾𝗍𝖺𝗂𝗅𝗌:**\n`Not Found`")
-
-
-@on_message("pypi", allow_stan=True)
-async def pypi(_, message: Message):
-    BASE_URL = "https://pypi.org/pypi/{0}/json"
-    if len(message.command) < 2:
-        return await hellbot.delete(message, "No package name provided!")
-
-    package = message.command[1]
-    hell = await hellbot.edit(message, "`getting information...`")
-
-    response = requests.get(BASE_URL.format(package))
-    if response.status_code == 200:
-        data = response.json()
-        info = data["info"]
-        name = info["name"]
-        url = info["package_url"]
-        version = info["version"]
-        summary = info["summary"]
-        await hell.edit(f"**𝖯𝖺𝖼𝗄𝖺𝗀𝖾:** [{name}]({url}) (`{version}`)\n\n**𝖣𝖾𝗍𝖺𝗂𝗅𝗌:** `{summary}`")
-    else:
-        await hell.edit(f"**𝖯𝖺𝖼𝗄𝖺𝗀𝖾:** `{package}`\n\n**𝖣𝖾𝗍𝖺𝗂𝗅𝗌:** `Not Found`")
-
-
-@on_message("speedtest", allow_stan=True)
-async def speed_test(_, message: Message):
-    hell = await hellbot.edit(message, "`testing speed...`")
-
-    speed = Speedtest()
-    speed.get_best_server()
-
-    await hell.edit("`calculating download speed...`")
-    speed.download()
-
-    await hell.edit("`calculating upload speed...`")
-    speed.upload()
-
-    await hell.edit("`finising up...`")
-    speed.results.share()
-    result = speed.results.dict()
-
-    form = """**𝖲𝗉𝖾𝖾𝖽𝖳𝖾𝗌𝗍 𝖱𝖾𝗌𝗎𝗅𝗍𝗌 🍀**
-
-    **✧ 𝖨𝖲𝖯:** `{0}, {1}` 
-    **✧ 𝖯𝗂𝗇𝗀:** `{2}`
-    **✧ 𝖲𝖾𝗋𝗏𝖾𝗋:** `{3}, {4}`
-    **✧ 𝖲𝗉𝗈𝗇𝗌𝗈𝗋:** `{5}`
-    """
-
-    await message.reply_photo(
-        result["share"],
-        caption=form.format(
-            result["client"]["isp"],
-            result["client"]["country"],
-            result["ping"],
-            result["server"]["name"],
-            result["server"]["country"],
-            result["server"]["sponsor"],
-        )
-    )
-    await hell.delete()
-
-
-HelpMenu("eval").add(
-    "eval",
-    "<python code>",
-    "Execute the python code and get results.",
-    "eval print('hello world')",
-    "Use this command with caution! Using this command senselessly and getting yourself in trouble is not Hellbot's responsibility!"
-).add(
-    "exec",
-    "<linux command>",
-    "Execute the linux command and get results.",
-    "exec ls -a",
-    "Use this command with caution! Using this command senselessly and getting yourself in trouble is not Hellbot's responsibility!"
-).add(
-    "shell",
-    "<shell script>",
-    "Execute the shell script and get results.",
-    "shell echo hello world",
-    "Use this command with caution! Using this command senselessly and getting yourself in trouble is not Hellbot's responsibility!"
-).add(
-    "fext",
-    "<file extention>",
-    "Get the details of the file extention.",
-    "fext py",
-).add(
-    "pypi",
-    "<package name>",
-    "Get the details of the package from pypi.",
-    "pypi pyrogram",
-).add(
-    "speedtest",
-    None,
-    "Test the speed of server and client.",
-    "speedtest",
-).info(
-    "Execute python, linux and shell scripts."
-).done()