Upload 87 files

Hellbot/__init__.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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