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