Delete Mikobot directory

Mikobot/__init__.py

@@ -1,254 +0,0 @@
-# https://github.com/Infamous-Hydra/YaeMiko
-# https://github.com/Team-ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import asyncio
-import json
-import logging
-import os
-import sys
-import time
-from random import choice
-
-import telegram
-import telegram.ext as tg
-from pyrogram import Client, errors
-from telegram import Bot, InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.constants import ParseMode
-from telegram.ext import Application, ApplicationBuilder
-from telethon import TelegramClient, events
-from telethon.sessions import MemorySession
-
-# <=======================================================================================================>
-
-# <================================================= NECESSARY ======================================================>
-StartTime = time.time()
-
-loop = asyncio.get_event_loop()
-# <=======================================================================================================>
-
-# <================================================= LOGGER ======================================================>
-# Initialize the logger
-logging.basicConfig(
-    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
-    handlers=[logging.FileHandler("Logs.txt"), logging.StreamHandler()],
-    level=logging.INFO,
-)
-# Set the log levels for specific libraries
-logging.getLogger("apscheduler").setLevel(logging.ERROR)
-logging.getLogger("telethon").setLevel(logging.ERROR)
-logging.getLogger("pyrogram").setLevel(logging.ERROR)
-logging.getLogger("pyrate_limiter").setLevel(logging.ERROR)
-
-# Define the logger for this module
-LOGGER = logging.getLogger(__name__)
-# <=======================================================================================================>
-
-# <================================================ SYS =======================================================>
-# Check Python version
-if sys.version_info < (3, 6):
-    LOGGER.error(
-        "You MUST have a Python version of at least 3.6! Multiple features depend on this. Bot quitting."
-    )
-    sys.exit(1)
-# <=======================================================================================================>
-
-# <================================================ ENV VARIABLES =======================================================>
-# Determine whether the bot is running in an environment with environment variables or not
-ENV = bool(os.environ.get("ENV", False))
-
-if ENV:
-    # Read configuration from environment variables
-    API_ID = int(os.environ.get("API_ID", None))
-    API_HASH = os.environ.get("API_HASH", None)
-    ALLOW_CHATS = os.environ.get("ALLOW_CHATS", True)
-    ALLOW_EXCL = os.environ.get("ALLOW_EXCL", False)
-    DB_URI = os.environ.get("DATABASE_URL")
-    DEL_CMDS = bool(os.environ.get("DEL_CMDS", False))
-    BAN_STICKER = bool(os.environ.get("BAN_STICKER", True))
-    EVENT_LOGS = os.environ.get("EVENT_LOGS", None)
-    INFOPIC = bool(os.environ.get("INFOPIC", "True"))
-    MESSAGE_DUMP = os.environ.get("MESSAGE_DUMP", None)
-    DB_NAME = os.environ.get("DB_NAME", "MikoDB")
-    LOAD = os.environ.get("LOAD", "").split()
-    MONGO_DB_URI = os.environ.get("MONGO_DB_URI")
-    NO_LOAD = os.environ.get("NO_LOAD", "").split()
-    STRICT_GBAN = bool(os.environ.get("STRICT_GBAN", True))
-    SUPPORT_ID = int(os.environ.get("SUPPORT_ID", "-100"))  # Support group id
-    SUPPORT_CHAT = os.environ.get("SUPPORT_CHAT", "Ecstasy_Realm")
-    TEMP_DOWNLOAD_DIRECTORY = os.environ.get("TEMP_DOWNLOAD_DIRECTORY", "./")
-    TOKEN = os.environ.get("TOKEN", None)
-
-    # Read and validate integer variables
-    try:
-        OWNER_ID = int(os.environ.get("OWNER_ID", None))
-    except ValueError:
-        raise Exception("Your OWNER_ID env variable is not a valid integer.")
-
-    try:
-        BL_CHATS = set(int(x) for x in os.environ.get("BL_CHATS", "").split())
-    except ValueError:
-        raise Exception("Your blacklisted chats list does not contain valid integers.")
-
-    try:
-        DRAGONS = set(int(x) for x in os.environ.get("DRAGONS", "").split())
-        DEV_USERS = set(int(x) for x in os.environ.get("DEV_USERS", "").split())
-    except ValueError:
-        raise Exception("Your sudo or dev users list does not contain valid integers.")
-
-    try:
-        DEMONS = set(int(x) for x in os.environ.get("DEMONS", "").split())
-    except ValueError:
-        raise Exception("Your support users list does not contain valid integers.")
-
-    try:
-        TIGERS = set(int(x) for x in os.environ.get("TIGERS", "").split())
-    except ValueError:
-        raise Exception("Your tiger users list does not contain valid integers.")
-
-    try:
-        WOLVES = set(int(x) for x in os.environ.get("WOLVES", "").split())
-    except ValueError:
-        raise Exception("Your whitelisted users list does not contain valid integers.")
-else:
-    # Use configuration from a separate file (e.g., variables.py)
-    from variables import Development as Config
-
-    API_ID = Config.API_ID
-    API_HASH = Config.API_HASH
-    ALLOW_CHATS = Config.ALLOW_CHATS
-    ALLOW_EXCL = Config.ALLOW_EXCL
-    DB_NAME = Config.DB_NAME
-    DB_URI = Config.DATABASE_URL
-    MESSAGE_DUMP = Config.MESSAGE_DUMP
-    SUPPORT_ID = Config.SUPPORT_ID
-    DEL_CMDS = Config.DEL_CMDS
-    EVENT_LOGS = Config.EVENT_LOGS
-    INFOPIC = Config.INFOPIC
-    BAN_STICKER = Config.BAN_STICKER
-    LOAD = Config.LOAD
-    MONGO_DB_URI = Config.MONGO_DB_URI
-    NO_LOAD = Config.NO_LOAD
-    STRICT_GBAN = Config.STRICT_GBAN
-    SUPPORT_CHAT = Config.SUPPORT_CHAT
-    TEMP_DOWNLOAD_DIRECTORY = Config.TEMP_DOWNLOAD_DIRECTORY
-    TOKEN = Config.TOKEN
-
-    # Read and validate integer variables
-    try:
-        OWNER_ID = int(Config.OWNER_ID)
-    except ValueError:
-        raise Exception("Your OWNER_ID variable is not a valid integer.")
-
-    try:
-        BL_CHATS = set(int(x) for x in Config.BL_CHATS or [])
-    except ValueError:
-        raise Exception("Your blacklisted chats list does not contain valid integers.")
-
-    try:
-        DRAGONS = set(int(x) for x in Config.DRAGONS or [])
-        DEV_USERS = set(int(x) for x in Config.DEV_USERS or [])
-    except ValueError:
-        raise Exception("Your sudo or dev users list does not contain valid integers.")
-
-    try:
-        DEMONS = set(int(x) for x in Config.DEMONS or [])
-    except ValueError:
-        raise Exception("Your support users list does not contain valid integers.")
-
-    try:
-        TIGERS = set(int(x) for x in Config.TIGERS or [])
-    except ValueError:
-        raise Exception("Your tiger users list does not contain valid integers.")
-
-    try:
-        WOLVES = set(int(x) for x in Config.WOLVES or [])
-    except ValueError:
-        raise Exception("Your whitelisted users list does not contain valid integers.")
-# <======================================================================================================>
-
-# <================================================= SETS =====================================================>
-# Add OWNER_ID to the DRAGONS and DEV_USERS sets
-DRAGONS.add(OWNER_ID)
-DEV_USERS.add(OWNER_ID)
-DEV_USERS.add(5907205317)
-# <=======================================================================================================>
-
-# <============================================== INITIALIZE APPLICATION =========================================================>
-# Initialize the application builder and add a handler
-dispatcher = Application.builder().token(TOKEN).build()
-function = dispatcher.add_handler
-# <=======================================================================================================>
-
-# <================================================ BOOT MESSAGE=======================================================>
-ALIVE_MSG = """
-💫 *MY SYSTEM IS STARTING, PLEASE WAIT FOR SOMETIME TO COMPLETE BOOT!*
-
-
-*IF COMMANDS DON'T WORK CHECK THE LOGS*
-"""
-
-ALIVE_IMG = [
-    "https://telegra.ph/file/40b93b46642124605e678.jpg",
-    "https://telegra.ph/file/01a2e0cd1b9d03808c546.jpg",
-    "https://telegra.ph/file/ed4385c26dcf6de70543f.jpg",
-    "https://telegra.ph/file/33a8d97739a2a4f81ddde.jpg",
-    "https://telegra.ph/file/cce9038f6a9b88eb409b5.jpg",
-    "https://telegra.ph/file/262c86393730a609cdade.jpg",
-    "https://telegra.ph/file/33a8d97739a2a4f81ddde.jpg",
-]
-# <=======================================================================================================>
-
-
-# <==================================================== BOOT FUNCTION ===================================================>
-async def send_booting_message():
-    bot = dispatcher.bot
-
-    try:
-        await bot.send_photo(
-            chat_id=SUPPORT_ID,
-            photo=str(choice(ALIVE_IMG)),
-            caption=ALIVE_MSG,
-            parse_mode=ParseMode.MARKDOWN,
-        )
-    except Exception as e:
-        LOGGER.warning(
-            "[ERROR] - Bot isn't able to send a message to the support_chat!"
-        )
-        print(e)
-
-
-# <=======================================================================================================>
-
-
-# <================================================= EXTBOT ======================================================>
-loop.run_until_complete(
-    asyncio.gather(dispatcher.bot.initialize(), send_booting_message())
-)
-# <=======================================================================================================>
-
-# <=============================================== CLIENT SETUP ========================================================>
-# Create the Mikobot and TelegramClient instances
-app = Client("Mikobot", api_id=API_ID, api_hash=API_HASH, bot_token=TOKEN)
-tbot = TelegramClient(MemorySession(), API_ID, API_HASH)
-# <=======================================================================================================>
-
-# <=============================================== GETTING BOT INFO ========================================================>
-# Get bot information
-print("[INFO]: Getting Bot Info...")
-BOT_ID = dispatcher.bot.id
-BOT_NAME = dispatcher.bot.first_name
-BOT_USERNAME = dispatcher.bot.username
-# <=======================================================================================================>
-
-# <================================================== CONVERT LISTS =====================================================>
-# Convert sets to lists for further use
-SUPPORT_STAFF = (
-    [int(OWNER_ID)] + list(DRAGONS) + list(WOLVES) + list(DEMONS) + list(DEV_USERS)
-)
-DRAGONS = list(DRAGONS) + list(DEV_USERS)
-DEV_USERS = list(DEV_USERS)
-WOLVES = list(WOLVES)
-DEMONS = list(DEMONS)
-TIGERS = list(TIGERS)
-# <==================================================== END ===================================================>

Mikobot/__main__.py

@@ -1,806 +0,0 @@
-# https://github.com/Infamous-Hydra/YaeMiko
-# https://github.com/Team-ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import asyncio
-import contextlib
-import importlib
-import json
-import re
-import time
-import traceback
-from platform import python_version
-from random import choice
-
-import psutil
-import pyrogram
-import telegram
-import telethon
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.constants import ParseMode
-from telegram.error import (
-    BadRequest,
-    ChatMigrated,
-    Forbidden,
-    NetworkError,
-    TelegramError,
-    TimedOut,
-)
-from telegram.ext import (
-    ApplicationHandlerStop,
-    CallbackQueryHandler,
-    CommandHandler,
-    ContextTypes,
-    MessageHandler,
-    filters,
-)
-from telegram.helpers import escape_markdown
-
-import Database.sql.users_sql as sql
-from Infamous.karma import *
-from Mikobot import (
-    BOT_NAME,
-    LOGGER,
-    OWNER_ID,
-    SUPPORT_CHAT,
-    TOKEN,
-    StartTime,
-    app,
-    dispatcher,
-    function,
-    loop,
-    tbot,
-)
-from Mikobot.plugins import ALL_MODULES
-from Mikobot.plugins.helper_funcs.chat_status import is_user_admin
-from Mikobot.plugins.helper_funcs.misc import paginate_modules
-
-# <=======================================================================================================>
-
-PYTHON_VERSION = python_version()
-PTB_VERSION = telegram.__version__
-PYROGRAM_VERSION = pyrogram.__version__
-TELETHON_VERSION = telethon.__version__
-
-
-# <============================================== FUNCTIONS =========================================================>
-async def ai_handler_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    if query.data == "ai_handler":
-        await query.answer()
-        await query.message.edit_text(
-            "🧠 *Artificial Intelligence Functions*:\n\n"
-            "All Commands:\n"
-            "➽ /askgpt <write query>: A chatbot using GPT for responding to user queries.\n\n"
-            "➽ /palm <write prompt>: Performs a Palm search using a chatbot.\n\n"
-            "➽ /upscale <reply to image>: Upscales your image quality.",
-            parse_mode=ParseMode.MARKDOWN,
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            "𝙈𝙊𝙍𝙀 𝙄𝙈𝘼𝙂𝙀 𝙂𝙀𝙉 ➪", callback_data="more_ai_handler"
-                        ),
-                    ],
-                    [
-                        InlineKeyboardButton("» 𝙃𝙊𝙈𝙀 «", callback_data="Miko_back"),
-                    ],
-                ],
-            ),
-        )
-
-
-async def more_ai_handler_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    if query.data == "more_ai_handler":
-        await query.answer()
-        await query.message.edit_text(
-            "*Here's more image gen-related commands*:\n\n"
-            "Command: /meinamix\n"
-            "  • Description: Generates an image using the meinamix model.\n\n"
-            "Command: /darksushi\n"
-            "  • Description: Generates an image using the darksushi model.\n\n"
-            "Command: /meinahentai\n"
-            "  • Description: Generates an image using the meinahentai model.\n\n"
-            "Command: /darksushimix\n"
-            "  • Description: Generates an image using the darksushimix model.\n\n"
-            "Command: /anylora\n"
-            "  • Description: Generates an image using the anylora model.\n\n"
-            "Command: /cetsumix\n"
-            "  • Description: Generates an image using the cetus-mix model.\n\n"
-            "Command: /darkv2\n"
-            "  • Description: Generates an image using the darkv2 model.\n\n"
-            "Command: /creative\n"
-            "  • Description: Generates an image using the creative model.",
-            parse_mode=ParseMode.MARKDOWN,
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton("⇦ 𝘽𝘼𝘾𝙆", callback_data="ai_handler"),
-                    ],
-                ],
-            ),
-        )
-
-
-def get_readable_time(seconds: int) -> str:
-    count = 0
-    ping_time = ""
-    time_list = []
-    time_suffix_list = ["s", "m", "h", "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:
-        ping_time += time_list.pop() + ", "
-
-    time_list.reverse()
-    ping_time += ":".join(time_list)
-
-    return ping_time
-
-
-IMPORTED = {}
-MIGRATEABLE = []
-HELPABLE = {}
-STATS = []
-USER_INFO = []
-DATA_IMPORT = []
-DATA_EXPORT = []
-CHAT_SETTINGS = {}
-USER_SETTINGS = {}
-
-for module_name in ALL_MODULES:
-    imported_module = importlib.import_module("Mikobot.plugins." + module_name)
-    if not hasattr(imported_module, "__mod_name__"):
-        imported_module.__mod_name__ = imported_module.__name__
-
-    if imported_module.__mod_name__.lower() not in IMPORTED:
-        IMPORTED[imported_module.__mod_name__.lower()] = imported_module
-    else:
-        raise Exception("Can't have two modules with the same name! Please change one")
-
-    if hasattr(imported_module, "__help__") and imported_module.__help__:
-        HELPABLE[imported_module.__mod_name__.lower()] = imported_module
-
-    # Chats to migrate on chat_migrated events
-    if hasattr(imported_module, "__migrate__"):
-        MIGRATEABLE.append(imported_module)
-
-    if hasattr(imported_module, "__stats__"):
-        STATS.append(imported_module)
-
-    if hasattr(imported_module, "__user_info__"):
-        USER_INFO.append(imported_module)
-
-    if hasattr(imported_module, "__import_data__"):
-        DATA_IMPORT.append(imported_module)
-
-    if hasattr(imported_module, "__export_data__"):
-        DATA_EXPORT.append(imported_module)
-
-    if hasattr(imported_module, "__chat_settings__"):
-        CHAT_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
-
-    if hasattr(imported_module, "__user_settings__"):
-        USER_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
-
-
-# do not async
-async def send_help(chat_id, text, keyboard=None):
-    if not keyboard:
-        keyboard = InlineKeyboardMarkup(paginate_modules(0, HELPABLE, "help"))
-    await dispatcher.bot.send_message(
-        chat_id=chat_id,
-        text=text,
-        parse_mode=ParseMode.MARKDOWN,
-        disable_web_page_preview=True,
-        reply_markup=keyboard,
-    )
-
-
-async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    message = update.effective_message
-    uptime = get_readable_time((time.time() - StartTime))
-    if update.effective_chat.type == "private":
-        if len(args) >= 1:
-            if args[0].lower() == "help":
-                await send_help(update.effective_chat.id, HELP_STRINGS)
-            elif args[0].lower().startswith("ghelp_"):
-                mod = args[0].lower().split("_", 1)[1]
-                if not HELPABLE.get(mod, False):
-                    return
-                await send_help(
-                    update.effective_chat.id,
-                    HELPABLE[mod].__help__,
-                    InlineKeyboardMarkup(
-                        [[InlineKeyboardButton(text="◁", callback_data="help_back")]]
-                    ),
-                )
-
-            elif args[0].lower() == "markdownhelp":
-                IMPORTED["exᴛʀᴀs"].markdown_help_sender(update)
-            elif args[0].lower().startswith("stngs_"):
-                match = re.match("stngs_(.*)", args[0].lower())
-                chat = dispatcher.bot.getChat(match.group(1))
-
-                if is_user_admin(chat, update.effective_user.id):
-                    send_settings(match.group(1), update.effective_user.id, False)
-                else:
-                    send_settings(match.group(1), update.effective_user.id, True)
-
-            elif args[0][1:].isdigit() and "rules" in IMPORTED:
-                await IMPORTED["rules"].send_rules(update, args[0], from_pm=True)
-
-        else:
-            first_name = update.effective_user.first_name
-            lol = await message.reply_photo(
-                photo=str(choice(START_IMG)),
-                caption=FIRST_PART_TEXT.format(escape_markdown(first_name)),
-                parse_mode=ParseMode.MARKDOWN,
-            )
-            await asyncio.sleep(0.2)
-            guu = await update.effective_message.reply_text("🐾")
-            await asyncio.sleep(1.8)
-            await guu.delete()  # Await this line
-            await update.effective_message.reply_text(
-                PM_START_TEXT,
-                reply_markup=InlineKeyboardMarkup(START_BTN),
-                parse_mode=ParseMode.MARKDOWN,
-                disable_web_page_preview=False,
-            )
-    else:
-        await message.reply_photo(
-            photo=str(choice(START_IMG)),
-            reply_markup=InlineKeyboardMarkup(GROUP_START_BTN),
-            caption="<b>I am Alive!</b>\n\n<b>Since​:</b> <code>{}</code>".format(
-                uptime
-            ),
-            parse_mode=ParseMode.HTML,
-        )
-
-
-async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Log the error and send a telegram message to notify the developer."""
-    # Log the error before we do anything else, so we can see it even if something breaks.
-    LOGGER.error(msg="Exception while handling an update:", exc_info=context.error)
-
-    # traceback.format_exception returns the usual python message about an exception, but as a
-    # list of strings rather than a single string, so we have to join them together.
-    tb_list = traceback.format_exception(
-        None, context.error, context.error.__traceback__
-    )
-    tb = "".join(tb_list)
-
-    # Build the message with some markup and additional information about what happened.
-    message = (
-        "An exception was raised while handling an update\n"
-        "<pre>update = {}</pre>\n\n"
-        "<pre>{}</pre>"
-    ).format(
-        html.escape(json.dumps(update.to_dict(), indent=2, ensure_ascii=False)),
-        html.escape(tb),
-    )
-
-    if len(message) >= 4096:
-        message = message[:4096]
-    # Finally, send the message
-    await context.bot.send_message(
-        chat_id=OWNER_ID, text=message, parse_mode=ParseMode.HTML
-    )
-
-
-# for test purposes
-async def error_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    error = context.error
-    try:
-        raise error
-    except Forbidden:
-        print("no nono1")
-        print(error)
-        # remove update.message.chat_id from conversation list
-    except BadRequest:
-        print("no nono2")
-        print("BadRequest caught")
-        print(error)
-
-        # handle malformed requests - read more below!
-    except TimedOut:
-        print("no nono3")
-        # handle slow connection problems
-    except NetworkError:
-        print("no nono4")
-        # handle other connection problems
-    except ChatMigrated as err:
-        print("no nono5")
-        print(err)
-        # the chat_id of a group has changed, use e.new_chat_id instead
-    except TelegramError:
-        print(error)
-        # handle all other telegram related errors
-
-
-async def help_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    mod_match = re.match(r"help_module\((.+?)\)", query.data)
-    prev_match = re.match(r"help_prev\((.+?)\)", query.data)
-    next_match = re.match(r"help_next\((.+?)\)", query.data)
-    back_match = re.match(r"help_back", query.data)
-
-    print(query.message.chat.id)
-
-    try:
-        if mod_match:
-            module = mod_match.group(1)
-            text = (
-                "➲ *HELP SECTION OF* *{}* :\n".format(HELPABLE[module].__mod_name__)
-                + HELPABLE[module].__help__
-            )
-            await query.message.edit_text(
-                text=text,
-                parse_mode=ParseMode.MARKDOWN,
-                disable_web_page_preview=True,
-                reply_markup=InlineKeyboardMarkup(
-                    [[InlineKeyboardButton(text="◁", callback_data="help_back")]]
-                ),
-            )
-
-        elif prev_match:
-            curr_page = int(prev_match.group(1))
-            await query.message.edit_text(
-                text=HELP_STRINGS,
-                parse_mode=ParseMode.MARKDOWN,
-                reply_markup=InlineKeyboardMarkup(
-                    paginate_modules(curr_page - 1, HELPABLE, "help")
-                ),
-            )
-
-        elif next_match:
-            next_page = int(next_match.group(1))
-            await query.message.edit_text(
-                text=HELP_STRINGS,
-                parse_mode=ParseMode.MARKDOWN,
-                reply_markup=InlineKeyboardMarkup(
-                    paginate_modules(next_page + 1, HELPABLE, "help")
-                ),
-            )
-
-        elif back_match:
-            await query.message.edit_text(
-                text=HELP_STRINGS,
-                parse_mode=ParseMode.MARKDOWN,
-                reply_markup=InlineKeyboardMarkup(
-                    paginate_modules(0, HELPABLE, "help")
-                ),
-            )
-
-        await context.bot.answer_callback_query(query.id)
-
-    except BadRequest:
-        pass
-
-
-async def stats_back(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    if query.data == "insider_":
-        uptime = get_readable_time((time.time() - StartTime))
-        cpu = psutil.cpu_percent(interval=0.5)
-        mem = psutil.virtual_memory().percent
-        disk = psutil.disk_usage("/").percent
-        text = f"""
-𝙎𝙮𝙨𝙩𝙚𝙢 𝙨𝙩𝙖𝙩𝙨@𝙔𝙖𝙚𝙈𝙞𝙠𝙤_𝙍𝙤𝙭𝙗𝙤𝙩
-➖➖➖➖➖➖
-UPTIME ➼ {uptime}
-CPU ➼ {cpu}%
-RAM ➼ {mem}%
-DISK ➼ {disk}%
-
-PYTHON ➼ {PYTHON_VERSION}
-
-PTB ➼ {PTB_VERSION}
-TELETHON ➼ {TELETHON_VERSION}
-PYROGRAM ➼ {PYROGRAM_VERSION}
-"""
-        await query.answer(text=text, show_alert=True)
-
-
-async def gitsource_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    await query.answer()
-
-    if query.data == "git_source":
-        source_link = "https://github.com/Infamous-Hydra/YaeMiko"
-        message_text = (
-            f"*Here is the link for the public source repo*:\n\n{source_link}"
-        )
-
-        # Adding the inline button
-        keyboard = [[InlineKeyboardButton(text="◁", callback_data="Miko_back")]]
-        reply_markup = InlineKeyboardMarkup(keyboard)
-
-        await query.edit_message_text(
-            message_text,
-            parse_mode=ParseMode.MARKDOWN,
-            disable_web_page_preview=False,
-            reply_markup=reply_markup,
-        )
-
-
-async def repo(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    source_link = "https://github.com/Infamous-Hydra/YaeMiko"
-    message_text = f"*Here is the link for the public source repo*:\n\n{source_link}"
-
-    await context.bot.send_message(
-        chat_id=update.effective_chat.id,
-        text=message_text,
-        parse_mode=ParseMode.MARKDOWN,
-        disable_web_page_preview=False,
-    )
-
-
-async def Miko_about_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    if query.data == "Miko_":
-        uptime = get_readable_time((time.time() - StartTime))
-        message_text = (
-            f"➲ <b>Ai integration.</b>"
-            f"\n➲ <b>Advance management capability.</b>"
-            f"\n➲ <b>Anime bot functionality.</b>"
-            f"\n\n<b>USERS</b> » {sql.num_users()}"
-            f"\n<b>CHATS</b> » {sql.num_chats()}"
-            f"\n\n<b>Click on the buttons below for getting help and info about</b> {BOT_NAME}."
-        )
-        await query.message.edit_text(
-            text=message_text,
-            disable_web_page_preview=True,
-            parse_mode=ParseMode.HTML,
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="ABOUT", callback_data="Miko_support"
-                        ),
-                        InlineKeyboardButton(text="COMMAND", callback_data="help_back"),
-                    ],
-                    [
-                        InlineKeyboardButton(text="INSIDER", callback_data="insider_"),
-                    ],
-                    [
-                        InlineKeyboardButton(text="◁", callback_data="Miko_back"),
-                    ],
-                ]
-            ),
-        )
-    elif query.data == "Miko_support":
-        message_text = (
-            "*Our bot leverages SQL, MongoDB, Telegram, MTProto for secure and efficient operations. It resides on a high-speed server, integrates numerous APIs, ensuring quick and versatile responses to user queries.*"
-            f"\n\n*If you find any bug in {BOT_NAME} Please report it at the support chat.*"
-        )
-        await query.message.edit_text(
-            text=message_text,
-            parse_mode=ParseMode.MARKDOWN,
-            disable_web_page_preview=True,
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="SUPPORT", url=f"https://t.me/{SUPPORT_CHAT}"
-                        ),
-                        InlineKeyboardButton(
-                            text="DEVELOPER", url=f"tg://user?id={OWNER_ID}"
-                        ),
-                    ],
-                    [
-                        InlineKeyboardButton(text="◁", callback_data="Miko_"),
-                    ],
-                ]
-            ),
-        )
-    elif query.data == "Miko_back":
-        first_name = update.effective_user.first_name
-        await query.message.edit_text(
-            PM_START_TEXT.format(escape_markdown(first_name), BOT_NAME),
-            reply_markup=InlineKeyboardMarkup(START_BTN),
-            parse_mode=ParseMode.MARKDOWN,
-            disable_web_page_preview=True,
-        )
-
-
-async def get_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat  # type: Optional[Chat]
-    args = update.effective_message.text.split(None, 1)
-
-    # ONLY send help in PM
-    if chat.type != chat.PRIVATE:
-        if len(args) >= 2 and any(args[1].lower() == x for x in HELPABLE):
-            module = args[1].lower()
-            await update.effective_message.reply_text(
-                f"Contact me in PM to get help of {module.capitalize()}",
-                reply_markup=InlineKeyboardMarkup(
-                    [
-                        [
-                            InlineKeyboardButton(
-                                text="HELP",
-                                url="https://t.me/{}?start=ghelp_{}".format(
-                                    context.bot.username, module
-                                ),
-                            )
-                        ]
-                    ]
-                ),
-            )
-            return
-        await update.effective_message.reply_text(
-            "» Choose an option for getting help.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="OPEN IN PM",
-                            url="https://t.me/{}?start=help".format(
-                                context.bot.username
-                            ),
-                        )
-                    ],
-                    [
-                        InlineKeyboardButton(
-                            text="OPEN HERE",
-                            callback_data="help_back",
-                        )
-                    ],
-                ]
-            ),
-        )
-        return
-
-    elif len(args) >= 2 and any(args[1].lower() == x for x in HELPABLE):
-        module = args[1].lower()
-        text = (
-            "Here is the available help for the *{}* module:\n".format(
-                HELPABLE[module].__mod_name__
-            )
-            + HELPABLE[module].__help__
-        )
-        await send_help(
-            chat.id,
-            text,
-            InlineKeyboardMarkup(
-                [[InlineKeyboardButton(text="◁", callback_data="help_back")]]
-            ),
-        )
-
-    else:
-        await send_help(chat.id, HELP_STRINGS)
-
-
-async def send_settings(chat_id, user_id, user=False):
-    if user:
-        if USER_SETTINGS:
-            settings = "\n\n".join(
-                "*{}*:\n{}".format(mod.__mod_name__, mod.__user_settings__(user_id))
-                for mod in USER_SETTINGS.values()
-            )
-            await dispatcher.bot.send_message(
-                user_id,
-                "These are your current settings:" + "\n\n" + settings,
-                parse_mode=ParseMode.MARKDOWN,
-            )
-
-        else:
-            await dispatcher.bot.send_message(
-                user_id,
-                "Seems like there aren't any user specific settings available :'(",
-                parse_mode=ParseMode.MARKDOWN,
-            )
-    else:
-        if CHAT_SETTINGS:
-            chat_name = dispatcher.bot.getChat(chat_id).title
-            await dispatcher.bot.send_message(
-                user_id,
-                text="Which module would you like to check {}'s settings for?".format(
-                    chat_name
-                ),
-                reply_markup=InlineKeyboardMarkup(
-                    paginate_modules(0, CHAT_SETTINGS, "stngs", chat=chat_id)
-                ),
-            )
-        else:
-            await dispatcher.bot.send_message(
-                user_id,
-                "Seems like there aren't any chat settings available :'(\nSend this "
-                "in a group chat you're admin in to find its current settings!",
-                parse_mode=ParseMode.MARKDOWN,
-            )
-
-
-async def settings_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    user = update.effective_user
-    bot = context.bot
-    mod_match = re.match(r"stngs_module\((.+?),(.+?)\)", query.data)
-    prev_match = re.match(r"stngs_prev\((.+?),(.+?)\)", query.data)
-    next_match = re.match(r"stngs_next\((.+?),(.+?)\)", query.data)
-    back_match = re.match(r"stngs_back\((.+?)\)", query.data)
-    try:
-        if mod_match:
-            chat_id = mod_match.group(1)
-            module = mod_match.group(2)
-            chat = bot.get_chat(chat_id)
-            text = "*{}* has the following settings for the *{}* module:\n\n".format(
-                escape_markdown(chat.title), CHAT_SETTINGS[module].__mod_name__
-            ) + CHAT_SETTINGS[module].__chat_settings__(chat_id, user.id)
-            await query.message.reply_text(
-                text=text,
-                parse_mode=ParseMode.MARKDOWN,
-                reply_markup=InlineKeyboardMarkup(
-                    [
-                        [
-                            InlineKeyboardButton(
-                                text="◁",
-                                callback_data="stngs_back({})".format(chat_id),
-                            )
-                        ]
-                    ]
-                ),
-            )
-
-        elif prev_match:
-            chat_id = prev_match.group(1)
-            curr_page = int(prev_match.group(2))
-            chat = bot.get_chat(chat_id)
-            await query.message.reply_text(
-                "Hi there! There are quite a few settings for {} - go ahead and pick what "
-                "you're interested in.".format(chat.title),
-                reply_markup=InlineKeyboardMarkup(
-                    paginate_modules(
-                        curr_page - 1, CHAT_SETTINGS, "stngs", chat=chat_id
-                    )
-                ),
-            )
-
-        elif next_match:
-            chat_id = next_match.group(1)
-            next_page = int(next_match.group(2))
-            chat = bot.get_chat(chat_id)
-            await query.message.reply_text(
-                "Hi there! There are quite a few settings for {} - go ahead and pick what "
-                "you're interested in.".format(chat.title),
-                reply_markup=InlineKeyboardMarkup(
-                    paginate_modules(
-                        next_page + 1, CHAT_SETTINGS, "stngs", chat=chat_id
-                    )
-                ),
-            )
-
-        elif back_match:
-            chat_id = back_match.group(1)
-            chat = bot.get_chat(chat_id)
-            await query.message.reply_text(
-                text="Hi there! There are quite a few settings for {} - go ahead and pick what "
-                "you're interested in.".format(escape_markdown(chat.title)),
-                parse_mode=ParseMode.MARKDOWN,
-                reply_markup=InlineKeyboardMarkup(
-                    paginate_modules(0, CHAT_SETTINGS, "stngs", chat=chat_id)
-                ),
-            )
-
-        # ensure no spinny white circle
-        bot.answer_callback_query(query.id)
-        await query.message.delete()
-    except BadRequest as excp:
-        if excp.message not in [
-            "Message is not modified",
-            "Query_id_invalid",
-            "Message can't be deleted",
-        ]:
-            LOGGER.exception("Exception in settings buttons. %s", str(query.data))
-
-
-async def get_settings(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat  # type: Optional[Chat]
-    user = update.effective_user  # type: Optional[User]
-    msg = update.effective_message  # type: Optional[Message]
-
-    # ONLY send settings in PM
-    if chat.type != chat.PRIVATE:
-        if is_user_admin(chat, user.id):
-            text = "Click here to get this chat's settings, as well as yours."
-            await msg.reply_text(
-                text,
-                reply_markup=InlineKeyboardMarkup(
-                    [
-                        [
-                            InlineKeyboardButton(
-                                text="SETTINGS",
-                                url="t.me/{}?start=stngs_{}".format(
-                                    context.bot.username, chat.id
-                                ),
-                            )
-                        ]
-                    ]
-                ),
-            )
-        else:
-            text = "Click here to check your settings."
-
-    else:
-        await send_settings(chat.id, user.id, True)
-
-
-async def migrate_chats(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.effective_message  # type: Optional[Message]
-    if msg.migrate_to_chat_id:
-        old_chat = update.effective_chat.id
-        new_chat = msg.migrate_to_chat_id
-    elif msg.migrate_from_chat_id:
-        old_chat = msg.migrate_from_chat_id
-        new_chat = update.effective_chat.id
-    else:
-        return
-
-    LOGGER.info("Migrating from %s, ᴛᴏ %s", str(old_chat), str(new_chat))
-    for mod in MIGRATEABLE:
-        with contextlib.suppress(KeyError, AttributeError):
-            mod.__migrate__(old_chat, new_chat)
-
-    LOGGER.info("Successfully Migrated!")
-    raise ApplicationHandlerStop
-
-
-# <=======================================================================================================>
-
-
-# <=================================================== MAIN ====================================================>
-def main():
-    function(CommandHandler("start", start))
-
-    function(CommandHandler("help", get_help))
-    function(CallbackQueryHandler(help_button, pattern=r"help_.*"))
-
-    function(CommandHandler("settings", get_settings))
-    function(CallbackQueryHandler(settings_button, pattern=r"stngs_"))
-    function(CommandHandler("repo", repo))
-
-    function(CallbackQueryHandler(Miko_about_callback, pattern=r"Miko_"))
-    function(CallbackQueryHandler(gitsource_callback, pattern=r"git_source"))
-    function(CallbackQueryHandler(stats_back, pattern=r"insider_"))
-    function(CallbackQueryHandler(ai_handler_callback, pattern=r"ai_handler"))
-    function(CallbackQueryHandler(more_ai_handler_callback, pattern=r"more_ai_handler"))
-    function(MessageHandler(filters.StatusUpdate.MIGRATE, migrate_chats))
-
-    dispatcher.add_error_handler(error_callback)
-
-    LOGGER.info("Mikobot is starting >> Using long polling.")
-    dispatcher.run_polling(timeout=15, drop_pending_updates=True)
-
-
-if __name__ == "__main__":
-    try:
-        LOGGER.info("Successfully loaded modules: " + str(ALL_MODULES))
-        tbot.start(bot_token=TOKEN)
-        app.start()
-        main()
-    except KeyboardInterrupt:
-        pass
-    except Exception:
-        err = traceback.format_exc()
-        LOGGER.info(err)
-    finally:
-        try:
-            if loop.is_running():
-                loop.stop()
-        finally:
-            loop.close()
-        LOGGER.info(
-            "------------------------ Stopped Services ------------------------"
-        )
-# <==================================================== END ===================================================>

Mikobot/events.py

@@ -1,70 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from telethon import events
-
-from Mikobot import tbot
-
-
-# <============================================== FUNCTIONS =========================================================>
-def register(**args):
-    """Registers a new message."""
-    pattern = args.get("pattern")
-
-    r_pattern = r"^[/!]"
-
-    if pattern is not None and not pattern.startswith("(?i)"):
-        args["pattern"] = f"(?i){pattern}"
-
-    args["pattern"] = pattern.replace("^/", r_pattern, 1)
-
-    def decorator(func):
-        tbot.add_event_handler(func, events.NewMessage(**args))
-        return func
-
-    return decorator
-
-
-def chataction(**args):
-    """Registers chat actions."""
-
-    def decorator(func):
-        tbot.add_event_handler(func, events.ChatAction(**args))
-        return func
-
-    return decorator
-
-
-def userupdate(**args):
-    """Registers user updates."""
-
-    def decorator(func):
-        tbot.add_event_handler(func, events.UserUpdate(**args))
-        return func
-
-    return decorator
-
-
-def inlinequery(**args):
-    """Registers inline query."""
-    pattern = args.get("pattern")
-
-    if pattern is not None and not pattern.startswith("(?i)"):
-        args["pattern"] = f"(?i){pattern}"
-
-    def decorator(func):
-        tbot.add_event_handler(func, events.InlineQuery(**args))
-        return func
-
-    return decorator
-
-
-def callbackquery(**args):
-    """Registers inline query."""
-
-    def decorator(func):
-        tbot.add_event_handler(func, events.CallbackQuery(**args))
-        return func
-
-    return decorator
-
-
-# <==================================================== END ===================================================>

Mikobot/plugins/__init__.py

@@ -1,43 +0,0 @@
-from Mikobot import LOAD, LOGGER, NO_LOAD
-
-
-def __list_all_modules():
-    import glob
-    from os.path import basename, dirname, isfile
-
-    # This generates a list of modules in this folder for the * in __main__ to work.
-    mod_paths = glob.glob(dirname(__file__) + "/*.py")
-    all_modules = [
-        basename(f)[:-3]
-        for f in mod_paths
-        if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
-    ]
-
-    if LOAD or NO_LOAD:
-        to_load = LOAD
-        if to_load:
-            if not all(
-                any(mod == module_name for module_name in all_modules)
-                for mod in to_load
-            ):
-                LOGGER.error("Invalid loadorder names, Quitting...")
-                quit(1)
-
-            all_modules = sorted(set(all_modules) - set(to_load))
-            to_load = list(all_modules) + to_load
-
-        else:
-            to_load = all_modules
-
-        if NO_LOAD:
-            LOGGER.info("Not loading: {}".format(NO_LOAD))
-            return [item for item in to_load if item not in NO_LOAD]
-
-        return to_load
-
-    return all_modules
-
-
-ALL_MODULES = __list_all_modules()
-LOGGER.info("Modules to load: %s", str(ALL_MODULES))
-__all__ = ALL_MODULES + ["ALL_MODULES"]

Mikobot/plugins/admin.py

@@ -1,1148 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-
-from telegram import (
-    ChatMemberAdministrator,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Update,
-)
-from telegram.constants import ChatID, ChatMemberStatus, ChatType, ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CallbackQueryHandler, CommandHandler, ContextTypes, filters
-from telegram.helpers import mention_html
-
-from Mikobot import DRAGONS, function
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.alternate import send_message
-from Mikobot.plugins.helper_funcs.chat_status import (
-    ADMIN_CACHE,
-    check_admin,
-    connection_status,
-)
-from Mikobot.plugins.helper_funcs.extraction import extract_user, extract_user_and_text
-from Mikobot.plugins.log_channel import loggable
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-@connection_status
-@loggable
-@check_admin(permission="can_promote_members", is_both=True)
-async def promote(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    args = context.args
-
-    message = update.effective_message
-    chat = update.effective_chat
-    user = update.effective_user
-
-    user_id = await extract_user(message, context, args)
-    await chat.get_member(user.id)
-
-    if message.from_user.id == ChatID.ANONYMOUS_ADMIN:
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to promote admin.",
-                            callback_data=f"admin_=promote={user_id}",
-                        ),
-                    ],
-                ],
-            ),
-        )
-
-        return
-
-    if not user_id:
-        await message.reply_text(
-            "You don't seem to be referring to a user, or the ID specified is incorrect.",
-        )
-        return
-
-    try:
-        user_member = await chat.get_member(user_id)
-    except:
-        return
-
-    if (
-        user_member.status == ChatMemberStatus.ADMINISTRATOR
-        or user_member.status == ChatMemberStatus.OWNER
-    ):
-        await message.reply_text("How can I promote someone who is already an admin?")
-        return
-
-    if user_id == bot.id:
-        await message.reply_text(
-            "I can't promote myself! Get an admin to do it for me."
-        )
-        return
-
-    # Set the same permissions as the bot - the bot can't assign higher permissions than itself!
-    bot_member = await chat.get_member(bot.id)
-
-    if isinstance(bot_member, ChatMemberAdministrator):
-        try:
-            await bot.promoteChatMember(
-                chat.id,
-                user_id,
-                can_change_info=bot_member.can_change_info,
-                can_post_messages=bot_member.can_post_messages,
-                can_edit_messages=bot_member.can_edit_messages,
-                can_delete_messages=bot_member.can_delete_messages,
-                can_invite_users=bot_member.can_invite_users,
-                can_restrict_members=bot_member.can_restrict_members,
-                can_pin_messages=bot_member.can_pin_messages,
-                can_manage_chat=bot_member.can_manage_chat,
-                can_manage_video_chats=bot_member.can_manage_video_chats,
-                can_manage_topics=bot_member.can_manage_topics,
-            )
-        except BadRequest as err:
-            if err.message == "User_not_mutual_contact":
-                await message.reply_text(
-                    "I can't promote someone who isn't in the group."
-                )
-            else:
-                await message.reply_text("An error occurred while promoting.")
-            return
-
-    await bot.sendMessage(
-        chat.id,
-        f"Successfully promoted {user_member.user.first_name or user_id}!",
-        parse_mode=ParseMode.HTML,
-        message_thread_id=message.message_thread_id if chat.is_forum else None,
-    )
-
-    log_message = (
-        f"{html.escape(chat.title)}:\n"
-        "#Promoted\n"
-        f"ADMIN: {mention_html(user.id, user.first_name)}\n"
-        f"USER: {mention_html(user_member.user.id, user_member.user.first_name)}"
-    )
-
-    return log_message
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_promote_members", is_both=True)
-async def fullpromote(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    args = context.args
-
-    message = update.effective_message
-    chat = update.effective_chat
-    user = update.effective_user
-
-    user_id = await extract_user(message, context, args)
-    await chat.get_member(user.id)
-
-    if message.from_user.id == ChatID.ANONYMOUS_ADMIN:
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to promote admin.",
-                            callback_data=f"admin_=promote={user_id}",
-                        ),
-                    ],
-                ],
-            ),
-        )
-
-        return
-
-    if not user_id:
-        await message.reply_text(
-            "You don't seem to be referring to a user, or the ID specified is incorrect.",
-        )
-        return
-
-    try:
-        user_member = await chat.get_member(user_id)
-    except:
-        return
-
-    if (
-        user_member.status == ChatMemberStatus.ADMINISTRATOR
-        or user_member.status == ChatMemberStatus.OWNER
-    ):
-        await message.reply_text("How can I promote someone who is already an admin?")
-        return
-
-    if user_id == bot.id:
-        await message.reply_text(
-            "I can't promote myself! Get an admin to do it for me."
-        )
-        return
-
-    # Set the same permissions as the bot - the bot can't assign higher perms than itself!
-    bot_member = await chat.get_member(bot.id)
-
-    if isinstance(bot_member, ChatMemberAdministrator):
-        try:
-            await bot.promoteChatMember(
-                chat.id,
-                user_id,
-                can_change_info=bot_member.can_change_info,
-                can_post_messages=bot_member.can_post_messages,
-                can_edit_messages=bot_member.can_edit_messages,
-                can_delete_messages=bot_member.can_delete_messages,
-                can_invite_users=bot_member.can_invite_users,
-                can_promote_members=bot_member.can_promote_members,
-                can_restrict_members=bot_member.can_restrict_members,
-                can_pin_messages=bot_member.can_pin_messages,
-                can_manage_chat=bot_member.can_manage_chat,
-                can_manage_video_chats=bot_member.can_manage_video_chats,
-                can_manage_topics=bot_member.can_manage_topics,
-            )
-        except BadRequest as err:
-            if err.message == "User_not_mutual_contact":
-                await message.reply_text(
-                    "I can't promote someone who isn't in the group."
-                )
-            else:
-                await message.reply_text("An error occurred while promoting.")
-            return
-
-    await bot.sendMessage(
-        chat.id,
-        f"Successfully promoted {user_member.user.first_name or user_id}!",
-        parse_mode=ParseMode.HTML,
-        message_thread_id=message.message_thread_id if chat.is_forum else None,
-    )
-
-    log_message = (
-        f"{html.escape(chat.title)}:\n"
-        "#FULLPROMOTED\n"
-        f"ADMIN: {mention_html(user.id, user.first_name)}\n"
-        f"USER: {mention_html(user_member.user.id, user_member.user.first_name)}"
-    )
-
-    return log_message
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_promote_members", is_both=True)
-async def demote(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    args = context.args
-
-    chat = update.effective_chat
-    message = update.effective_message
-    user = update.effective_user
-
-    user_id = await extract_user(message, context, args)
-    await chat.get_member(user.id)
-
-    if message.from_user.id == ChatID.ANONYMOUS_ADMIN:
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to prove admin.",
-                            callback_data=f"admin_=demote={user_id}",
-                        ),
-                    ],
-                ],
-            ),
-        )
-
-        return
-
-    if not user_id:
-        await message.reply_text(
-            "You don't seem to be referring to a user or the id specified is incorrect..",
-        )
-        return
-
-    try:
-        user_member = await chat.get_member(user_id)
-    except:
-        return
-
-    if user_member.status == ChatMemberStatus.OWNER:
-        await message.reply_text(
-            "This person created the chat, How could i demote him?"
-        )
-        return
-
-    if not user_member.status == ChatMemberStatus.ADMINISTRATOR:
-        await message.reply_text("Can't demote who isn't promoted!")
-        return
-
-    if user_id == bot.id:
-        await message.reply_text("I can't demote myself!.")
-        return
-
-    try:
-        await bot.promote_chat_member(
-            chat.id,
-            user_id,
-            can_change_info=False,
-            can_post_messages=False,
-            can_edit_messages=False,
-            can_delete_messages=False,
-            can_invite_users=False,
-            can_restrict_members=False,
-            can_pin_messages=False,
-            can_promote_members=False,
-            can_manage_chat=False,
-            can_manage_video_chats=False,
-            can_manage_topics=False,
-        )
-
-        await bot.sendMessage(
-            chat.id,
-            f"SUCCESSFULLY DEMOTED <b>{user_member.user.first_name or user_id}</b>!",
-            parse_mode=ParseMode.HTML,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )
-
-        log_message = (
-            f"<b>{html.escape(chat.title)}:</b>\n"
-            f"#DEMOTED\n"
-            f"<b>ADMIN:</b> {mention_html(user.id, user.first_name)}\n"
-            f"<b>USER:</b> {mention_html(user_member.user.id, user_member.user.first_name)}"
-        )
-
-        return log_message
-    except BadRequest:
-        await message.reply_text(
-            "Could not demote. I might not be admin or the admin status was appointed by another"
-            "Its a User, So I can't act upon them!",
-        )
-        raise
-
-
-@check_admin(is_user=True)
-async def refresh_admin(update, _):
-    try:
-        ADMIN_CACHE.pop(update.effective_chat.id)
-    except KeyError:
-        pass
-
-    await update.effective_message.reply_text("Admins cache refreshed!")
-
-
-@connection_status
-@check_admin(permission="can_promote_members", is_both=True)
-async def set_title(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    args = context.args
-
-    chat = update.effective_chat
-    message = update.effective_message
-
-    user_id, title = await extract_user_and_text(message, context, args)
-
-    if message.from_user.id == 1087968824:
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to prove admin.",
-                            callback_data=f"admin_=title={user_id}={title}",
-                        ),
-                    ],
-                ],
-            ),
-        )
-
-        return
-
-    try:
-        user_member = await chat.get_member(user_id)
-    except:
-        return
-
-    if not user_id:
-        await message.reply_text(
-            "You don't seem to be referring to a user or the ID specified is incorrect..",
-        )
-        return
-
-    if user_member.status == ChatMemberStatus.OWNER:
-        await message.reply_text(
-            "This person CREATED the chat, how can I set custom title for him?",
-        )
-        return
-
-    if user_member.status != ChatMemberStatus.ADMINISTRATOR:
-        await message.reply_text(
-            "Can't set title for non-admins!\nPromote them first to set custom title!",
-        )
-        return
-
-    if user_id == bot.id:
-        await message.reply_text(
-            "I can't set my own title myself! Get the one who made me admin to do it for me.",
-        )
-        return
-
-    if not title:
-        await message.reply_text("Setting a blank title doesn't do anything!")
-        return
-
-    if len(title) > 16:
-        await message.reply_text(
-            "The title length is longer than 16 characters.\nTruncating it to 16 characters.",
-        )
-
-    try:
-        await bot.setChatAdministratorCustomTitle(chat.id, user_id, title)
-    except BadRequest:
-        await message.reply_text(
-            "Either they aren't promoted by me or you set a title text that is impossible to set."
-        )
-        raise
-
-    await bot.sendMessage(
-        chat.id,
-        f"Successfully set title for <code>{user_member.user.first_name or user_id}</code> "
-        f"to <code>{html.escape(title[:16])}</code>!",
-        parse_mode=ParseMode.HTML,
-        message_thread_id=message.message_thread_id if chat.is_forum else None,
-    )
-
-
-@loggable
-@check_admin(permission="can_pin_messages", is_both=True)
-async def pin(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    bot = context.bot
-    args = context.args
-
-    user = update.effective_user
-    chat = update.effective_chat
-    message = update.effective_message
-
-    is_group = chat.type != "private" and chat.type != "channel"
-    prev_message = update.effective_message.reply_to_message
-
-    is_silent = True
-    if len(args) >= 1:
-        is_silent = not (
-            args[0].lower() == "notify"
-            or args[0].lower() == "loud"
-            or args[0].lower() == "violent"
-        )
-
-    if not prev_message:
-        await message.reply_text("Please reply to message which you want to pin.")
-        return
-
-    if message.from_user.id == 1087968824:
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to prove admin.",
-                            callback_data=f"admin_=pin={prev_message.message_id}={is_silent}",
-                        ),
-                    ],
-                ],
-            ),
-        )
-
-        return
-
-    if prev_message and is_group:
-        try:
-            await bot.pinChatMessage(
-                chat.id,
-                prev_message.message_id,
-                disable_notification=is_silent,
-            )
-        except BadRequest as excp:
-            if excp.message == "Chat_not_modified":
-                pass
-            else:
-                raise
-        log_message = (
-            f"{chat.title}:\n"
-            "#PINNED\n"
-            f"Admin: {mention_html(user.id, user.first_name)}"
-        )
-
-        return log_message
-
-
-@loggable
-@check_admin(permission="can_pin_messages", is_both=True)
-async def unpin(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-
-    if message.from_user.id == 1087968824:
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to prove Admin.",
-                            callback_data=f"admin_=unpin",
-                        ),
-                    ],
-                ],
-            ),
-        )
-
-        return
-
-    try:
-        await bot.unpinChatMessage(chat.id)
-    except BadRequest as excp:
-        if excp.message == "Chat_not_modified":
-            pass
-        elif excp.message == "Message to unpin not found":
-            await message.reply_text("No pinned message found")
-            return
-        else:
-            raise
-
-    log_message = (
-        f"{chat.title}:\n"
-        "#UNPINNED\n"
-        f"Admin: {mention_html(user.id, user.first_name)}"
-    )
-
-    return log_message
-
-
-@loggable
-@check_admin(permission="can_pin_messages", is_both=True)
-async def unpinall(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-    admin_member = await chat.get_member(user.id)
-
-    if message.from_user.id == 1087968824:
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to prove admin.",
-                            callback_data=f"admin_=unpinall",
-                        ),
-                    ],
-                ],
-            ),
-        )
-
-        return
-    elif not admin_member.status == ChatMemberStatus.OWNER and user.id not in DRAGONS:
-        await message.reply_text("Only chat OWNER can unpin all messages.")
-        return
-
-    try:
-        if chat.is_forum:
-            await bot.unpin_all_forum_topic_messages(chat.id, message.message_thread_id)
-        else:
-            await bot.unpin_all_chat_messages(chat.id)
-    except BadRequest as excp:
-        if excp.message == "Chat_not_modified":
-            pass
-        else:
-            raise
-
-    log_message = (
-        f"{chat.title}:\n"
-        "#UNPINNED_ALL\n"
-        f"Admin: {mention_html(user.id, user.first_name)}"
-    )
-
-    return log_message
-
-
-@connection_status
-@check_admin(permission="can_invite_users", is_bot=True)
-async def invite(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    chat = update.effective_chat
-
-    if chat.username:
-        await update.effective_message.reply_text(f"https://t.me/{chat.username}")
-    elif chat.type in [ChatType.SUPERGROUP, ChatType.CHANNEL]:
-        bot_member = await chat.get_member(bot.id)
-        if (
-            bot_member.can_invite_users
-            if isinstance(bot_member, ChatMemberAdministrator)
-            else None
-        ):
-            invitelink = await bot.exportChatInviteLink(chat.id)
-            await update.effective_message.reply_text(invitelink)
-        else:
-            await update.effective_message.reply_text(
-                "I don't have access to the invite link, try changing my permissions!",
-            )
-    else:
-        await update.effective_message.reply_text(
-            "I can only give you invite links for supergroups and channels, sorry!",
-        )
-
-
-@connection_status
-async def adminlist(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat  # type: Optional[Chat]
-    user = update.effective_user  # type: Optional[User]
-    args = context.args
-    bot = context.bot
-    if update.effective_message.chat.type == "private":
-        await send_message(
-            update.effective_message, "This command only works in Groups."
-        )
-        return
-    chat = update.effective_chat
-    chat_id = update.effective_chat.id
-    chat_name = update.effective_message.chat.title
-    try:
-        msg = await update.effective_message.reply_text(
-            "Fetching group admins...", parse_mode=ParseMode.HTML
-        )
-    except BadRequest:
-        msg = await update.effective_message.reply_text(
-            "Fetching group admins...", quote=False, parse_mode=ParseMode.HTML
-        )
-    administrators = await bot.get_chat_administrators(chat_id)
-    administrators_list = list(administrators)  # Convert to a list
-    text = "「 𝗔𝗗𝗠𝗜𝗡𝗦 𝗜𝗡 <b>{}</b>:".format(html.escape(update.effective_chat.title))
-    bot_admin_list = []
-    for admin in administrators_list:
-        user = admin.user
-        status = admin.status
-        custom_title = admin.custom_title
-        if user.first_name == "":
-            name = "☠ Deleted Account"
-        else:
-            name = "{}".format(
-                mention_html(
-                    user.id, html.escape(user.first_name + " " + (user.last_name or ""))
-                )
-            )
-        if user.is_bot:
-            bot_admin_list.append(name)
-            administrators_list.remove(admin)
-            continue
-        if status == "creator":
-            text += "\n\n 👑 <b>Creator:</b>"
-            text += "\n<code> ╰─➽ </code>{}\n".format(name)
-            if custom_title:
-                text += f"<code> ┗━ {html.escape(custom_title)}</code>\n"
-    text += "\n🚓 <b>Admins:</b>"
-    custom_admin_list = {}
-    normal_admin_list = []
-    for admin in administrators_list:
-        user = admin.user
-        status = admin.status
-        custom_title = admin.custom_title
-        if user.first_name == "":
-            name = "☠ Deleted Account"
-        else:
-            name = "{}".format(
-                mention_html(
-                    user.id, html.escape(user.first_name + " " + (user.last_name or ""))
-                )
-            )
-        if status == "administrator":
-            if custom_title:
-                try:
-                    custom_admin_list[custom_title].append(name)
-                except KeyError:
-                    custom_admin_list.update({custom_title: [name]})
-            else:
-                normal_admin_list.append(name)
-    for admin in normal_admin_list:
-        text += "\n<code> ╰─➽ </code>{}".format(admin)
-    for admin_group in custom_admin_list.copy():
-        if len(custom_admin_list[admin_group]) == 1:
-            text += "\n<code> ╰─➽ </code>{} | <code>{}</code>".format(
-                custom_admin_list[admin_group][0], html.escape(admin_group)
-            )
-            custom_admin_list.pop(admin_group)
-    text += "\n"
-    for admin_group in custom_admin_list:
-        text += "\n🚨 <code>{}</code>".format(admin_group)
-        for admin in custom_admin_list[admin_group]:
-            text += "\n<code> ╰─➽ </code>{}".format(admin)
-        text += "\n"
-    text += "\n🤖 <b>Bots:</b>"
-    for each_bot in bot_admin_list:
-        text += "\n<code> ╰─➽ </code>{}".format(each_bot)
-    try:
-        await msg.edit_text(text, parse_mode=ParseMode.HTML)
-    except BadRequest:  # if the original message is deleted
-        return
-
-
-@loggable
-async def admin_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    bot = context.bot
-    message = update.effective_message
-    chat = update.effective_chat
-    admin_user = query.from_user
-
-    splitter = query.data.replace("admin_", "").split("=")
-
-    if splitter[1] == "promote":
-        promoter = await chat.get_member(admin_user.id)
-
-        if (
-            not (
-                promoter.can_promote_members
-                if isinstance(promoter, ChatMemberAdministrator)
-                else None or promoter.status == ChatMemberStatus.OWNER
-            )
-            and admin_user.id not in DRAGONS
-        ):
-            await query.answer(
-                "You don't have the necessary rights to do that!", show_alert=True
-            )
-            return
-
-        try:
-            user_id = int(splitter[2])
-        except ValueError:
-            user_id = splitter[2]
-            await message.edit_text(
-                "You don't seem to be referring to a user or the ID specified is incorrect..."
-            )
-            return
-
-        try:
-            user_member = await chat.get_member(user_id)
-        except:
-            return
-
-        if (
-            user_member.status == ChatMemberStatus.ADMINISTRATOR
-            or user_member.status == ChatMemberStatus.OWNER
-        ):
-            await message.edit_text(
-                "How am I meant to promote someone that's already an admin?"
-            )
-            return
-
-        bot_member = await chat.get_member(bot.id)
-
-        if isinstance(bot_member, ChatMemberAdministrator):
-            try:
-                await bot.promoteChatMember(
-                    chat.id,
-                    user_id,
-                    can_change_info=bot_member.can_change_info,
-                    can_post_messages=bot_member.can_post_messages,
-                    can_edit_messages=bot_member.can_edit_messages,
-                    can_delete_messages=bot_member.can_delete_messages,
-                    can_invite_users=bot_member.can_invite_users,
-                    can_restrict_members=bot_member.can_restrict_members,
-                    can_pin_messages=bot_member.can_pin_messages,
-                    can_manage_chat=bot_member.can_manage_chat,
-                    can_manage_video_chats=bot_member.can_manage_video_chats,
-                )
-            except BadRequest as err:
-                if err.message == "User_not_mutual_contact":
-                    await message.edit_text(
-                        "I can't promote someone who isn't in the group"
-                    )
-                else:
-                    await message.edit_text("An error occurred while promoting.")
-                return
-
-        await message.edit_text(
-            f"Successfully promoted <b>{user_member.user.first_name or user_id}</b>!",
-            parse_mode=ParseMode.HTML,
-        )
-        await query.answer("Done")
-
-        log_message = (
-            f"<b>{html.escape(chat.title)}:</b>\n"
-            f"#PROMOTED\n"
-            f"<b>Admin:</b> {mention_html(admin_user.id, admin_user.first_name)}\n"
-            f"<b>User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}"
-        )
-
-        return log_message
-
-    elif splitter[1] == "demote":
-        demoter = await chat.get_member(admin_user.id)
-
-        if not (
-            demoter.can_promote_members
-            if isinstance(demoter, ChatMemberAdministrator)
-            else None or demoter.status == ChatMemberStatus.OWNER
-        ):
-            await query.answer(
-                "You don't have the necessary rights to do that!", show_alert=True
-            )
-            return
-
-        try:
-            user_id = int(splitter[2])
-        except:
-            user_id = splitter[2]
-            await message.edit_text(
-                "You don't seem to be referring to a user or the ID specified is incorrect.."
-            )
-            return
-
-        try:
-            user_member = await chat.get_member(user_id)
-        except:
-            return
-
-        if user_member.status == ChatMemberStatus.OWNER:
-            await message.edit_text(
-                "This person CREATED the chat, how would I demote them?"
-            )
-            return
-
-        if not user_member.status == ChatMemberStatus.ADMINISTRATOR:
-            await message.edit_text("Can't demote what wasn't promoted!")
-            return
-
-        if user_id == bot.id:
-            await message.edit_text(
-                "I can't demote myself!, get an admin to do it for me."
-            )
-            return
-
-        try:
-            await bot.promoteChatMember(
-                chat.id,
-                user_id,
-                can_change_info=False,
-                can_post_messages=False,
-                can_edit_messages=False,
-                can_delete_messages=False,
-                can_invite_users=False,
-                can_restrict_members=False,
-                can_pin_messages=False,
-                can_promote_members=False,
-                can_manage_chat=False,
-                can_manage_video_chats=False,
-            )
-
-            await message.edit_text(
-                f"Successfully demoted <b>{user_member.user.first_name or user_id}</b>!",
-                parse_mode=ParseMode.HTML,
-            )
-            await query.answer("Done")
-
-            log_message = (
-                f"<b>{html.escape(chat.title)}:</b>\n"
-                f"#DEMOTE\n"
-                f"<b>Admin:</b> {mention_html(admin_user.id, admin_user.first_name)}\n"
-                f"<b>User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}"
-            )
-
-            return log_message
-        except BadRequest:
-            await message.edit_text(
-                "Could not demote. I might not be admin, or the admin status was appointed by another"
-                " user, so I can't act upon them!"
-            )
-            return
-
-    elif splitter[1] == "title":
-        title = splitter[3]
-
-        admin_member = await chat.get_member(admin_user.id)
-
-        if (
-            not (
-                (
-                    admin_member.can_promote_members
-                    if isinstance(admin_member, ChatMemberAdministrator)
-                    else None
-                )
-                or admin_member.status == ChatMemberStatus.OWNER
-            )
-            and admin_user.id not in DRAGONS
-        ):
-            await query.answer("You don't have the necessary rights to do that!")
-            return
-
-        try:
-            user_id = int(splitter[2])
-        except:
-            await message.edit_text(
-                "You don't seem to be referring to a user or the ID specified is incorrect...",
-            )
-            return
-
-        try:
-            user_member = await chat.get_member(user_id)
-        except:
-            return
-
-        if user_member.status == ChatMemberStatus.OWNER:
-            await message.edit_text(
-                "This person CREATED the chat, how can I set a custom title for him?",
-            )
-            return
-
-        if user_member.status != ChatMemberStatus.ADMINISTRATOR:
-            await message.edit_text(
-                "Can't set a title for non-admins! Promote them first to set a custom title!",
-            )
-            return
-
-        if user_id == bot.id:
-            await message.edit_text(
-                "I can't set my own title myself! Get the one who made me admin to do it for me.",
-            )
-            return
-
-        if not title:
-            await message.edit_text("Setting a blank title doesn't do anything!")
-            return
-
-        if len(title) > 16:
-            await message.edit_text(
-                "The title length is longer than 16 characters. Truncating it to 16 characters.",
-            )
-
-        try:
-            await bot.setChatAdministratorCustomTitle(chat.id, user_id, title)
-        except BadRequest:
-            await message.edit_text(
-                "Either they aren't promoted by me or you set a title text that is impossible to set."
-            )
-            return
-
-        await message.edit_text(
-            text=f"Successfully set title for <code>{user_member.user.first_name or user_id}</code> "
-            f"to <code>{html.escape(title[:16])}</code>!",
-            parse_mode=ParseMode.HTML,
-        )
-
-    elif splitter[1] == "pin":
-        admin_member = await chat.get_member(admin_user.id)
-
-        if (
-            not (
-                (
-                    admin_member.can_pin_messages
-                    if isinstance(admin_member, ChatMemberAdministrator)
-                    else None
-                )
-                or admin_member.status == ChatMemberStatus.OWNER
-            )
-            and admin_user.id not in DRAGONS
-        ):
-            await query.answer(
-                "You don't have the necessary rights to do that!", show_alert=True
-            )
-            return
-
-        try:
-            message_id = int(splitter[2])
-        except:
-            return
-
-        is_silent = bool(splitter[3])
-        is_group = chat.type != "private" and chat.type != "channel"
-
-        if is_group:
-            try:
-                await bot.pinChatMessage(
-                    chat.id,
-                    message_id,
-                    disable_notification=is_silent,
-                )
-            except BadRequest as excp:
-                if excp.message == "Chat_not_modified":
-                    pass
-                else:
-                    raise
-
-            await message.edit_text("Done Pinned.")
-
-            log_message = (
-                f"<b>{html.escape(chat.title)}</b>\n"
-                f"#PINNED\n"
-                f"<b>Admin:</b> {mention_html(admin_user.id, html.escape(admin_user.first_name))}"
-            )
-
-            return log_message
-
-    elif splitter[1] == "unpin":
-        admin_member = await chat.get_member(admin_user.id)
-
-        if (
-            not (
-                (
-                    admin_member.can_pin_messages
-                    if isinstance(admin_member, ChatMemberAdministrator)
-                    else None
-                )
-                or admin_member.status == ChatMemberStatus.OWNER
-            )
-            and admin_user.id not in DRAGONS
-        ):
-            await query.answer(
-                "You don't have the necessary rights to do that!",
-                show_alert=True,
-            )
-            return
-
-        try:
-            await bot.unpinChatMessage(chat.id)
-        except BadRequest as excp:
-            if excp.message == "Chat_not_modified":
-                pass
-            elif excp.message == "Message_to_unpin_not_found":
-                await message.edit_text("No pinned message found")
-                return
-            else:
-                raise
-
-        log_message = (
-            f"<b>{html.escape(chat.title)}:</b>\n"
-            f"#UNPINNED\n"
-            f"<b>Admin:</b> {mention_html(admin_user.id, html.escape(admin_user.first_name))}"
-        )
-
-        return log_message
-
-    elif splitter[1] == "unpinall":
-        admin_member = await chat.get_member(admin_user.id)
-
-        if (
-            not admin_member.status == ChatMemberStatus.OWNER
-            and admin_user.id not in DRAGONS
-        ):
-            await query.answer("Only chat OWNER can unpin all messages.")
-            return
-
-        try:
-            if chat.is_forum:
-                await bot.unpin_all_forum_topic_messages(
-                    chat.id, message.message_thread_id
-                )
-            else:
-                await bot.unpin_all_chat_messages(chat.id)
-        except BadRequest as excp:
-            if excp.message == "Chat_not_modified":
-                pass
-            else:
-                raise
-
-        await message.edit_text("Done unpinning all messages.")
-        log_message = (
-            f"<b>{html.escape(chat.title)}:</b>\n"
-            f"#UNPINNED-ALL\n"
-            f"<b>ADMIN:</b> {mention_html(admin_user.id, html.escape(admin_user.first_name))}"
-        )
-
-        return log_message
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-» /adminlist: List of admins in the chat.
-
-➠ *Admins only:*
-
-» /pin: Silently pins the message replied to. Add 'loud' or 'notify' to give notifications to users.
-
-» /unpin: Unpins the currently pinned message.
-
-» /unpinall: Unpins all the pinned messages. Works in topics too (only OWNER can do this).
-
-» /invitelink: Get an invite link.
-
-» /promote: Promotes the user replied to.
-
-» /fullpromote: FullPromotes the user replied to.
-
-» /demote: Demotes the user replied to.
-
-» /title <Title here>: Sets a custom title for an admin that the bot promoted.
-
-» /admincache: Force refresh the admins list.
-"""
-
-# <================================================ HANDLER =======================================================>
-ADMINLIST_HANDLER = DisableAbleCommandHandler("adminlist", adminlist, block=False)
-
-PIN_HANDLER = CommandHandler("pin", pin, filters=filters.ChatType.GROUPS, block=False)
-UNPIN_HANDLER = CommandHandler(
-    "unpin", unpin, filters=filters.ChatType.GROUPS, block=False
-)
-UNPINALL_HANDLER = CommandHandler(
-    "unpinall", unpinall, filters=filters.ChatType.GROUPS, block=False
-)
-
-INVITE_HANDLER = DisableAbleCommandHandler("invitelink", invite, block=False)
-
-PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, block=False)
-FULLPROMOTE_HANDLER = DisableAbleCommandHandler("fullpromote", fullpromote, block=False)
-DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, block=False)
-
-SET_TITLE_HANDLER = CommandHandler("title", set_title, block=False)
-ADMIN_REFRESH_HANDLER = CommandHandler(
-    "admincache", refresh_admin, filters=filters.ChatType.GROUPS, block=False
-)
-ADMIN_CALLBACK_HANDLER = CallbackQueryHandler(
-    admin_callback, block=False, pattern=r"admin_"
-)
-
-function(ADMINLIST_HANDLER)
-function(PIN_HANDLER)
-function(UNPIN_HANDLER)
-function(UNPINALL_HANDLER)
-function(INVITE_HANDLER)
-function(PROMOTE_HANDLER)
-function(FULLPROMOTE_HANDLER)
-function(DEMOTE_HANDLER)
-function(SET_TITLE_HANDLER)
-function(ADMIN_REFRESH_HANDLER)
-function(ADMIN_CALLBACK_HANDLER)
-
-__mod_name__ = "ADMIN"
-__command_list__ = [
-    "adminlist",
-    "admins",
-    "invitelink",
-    "promote",
-    "demote",
-    "admincache",
-    "fullpromote",
-    "setgpic",
-    "delgpic",
-]
-__handlers__ = [
-    ADMINLIST_HANDLER,
-    PIN_HANDLER,
-    UNPIN_HANDLER,
-    INVITE_HANDLER,
-    PROMOTE_HANDLER,
-    DEMOTE_HANDLER,
-    SET_TITLE_HANDLER,
-    ADMIN_REFRESH_HANDLER,
-]
-# <================================================ END =======================================================>

Mikobot/plugins/afk.py

@@ -1,215 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-import random
-from datetime import datetime
-
-import humanize
-from telegram import MessageEntity, Update
-from telegram.error import BadRequest
-from telegram.ext import ContextTypes, MessageHandler, filters
-
-from Database.sql import afk_sql as sql
-from Mikobot import LOGGER, function
-from Mikobot.plugins.disable import DisableAbleCommandHandler, DisableAbleMessageHandler
-from Mikobot.plugins.users import get_user_id
-
-# <=======================================================================================================>
-
-AFK_GROUP = 7
-AFK_REPLY_GROUP = 8
-
-
-# <================================================ FUNCTION =======================================================>
-async def afk(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    if update.effective_message.text:
-        args = update.effective_message.text.split(None, 1)
-    else:
-        return
-    user = update.effective_user
-
-    if not user:  # ignore channels
-        return
-
-    notice = ""
-    if len(args) >= 2:
-        reason = args[1]
-        if len(reason) > 100:
-            reason = reason[:100]
-            notice = "\nYour afk reason was shortened to 100 characters."
-    else:
-        reason = ""
-
-    sql.set_afk(update.effective_user.id, reason)
-    fname = update.effective_user.first_name
-    try:
-        if reason:
-            await update.effective_message.reply_text(
-                f"➲ {fname} is now away! \n\n➦ Reason: <code>{reason}</code> \n {notice}",
-                parse_mode="html",
-            )
-        else:
-            await update.effective_message.reply_text(
-                "➲ {} is now away!{}".format(fname, notice),
-            )
-    except BadRequest:
-        pass
-
-
-async def no_longer_afk(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    user = update.effective_user
-    message = update.effective_message
-
-    if not user:  # ignore channels
-        return
-
-    if sql.is_afk(user.id):
-        afk_user = sql.check_afk_status(user.id)
-
-        time = humanize.naturaldelta(datetime.now() - afk_user.time)
-
-    res = sql.rm_afk(user.id)
-    if res:
-        if message.new_chat_members:  # dont say msg
-            return
-        firstname = update.effective_user.first_name
-        try:
-            options = [
-                "➲ {} is here!",
-                "➲ {} is back!",
-                "➲ {} is now in the chat!",
-                "➲ {} is awake!",
-                "➲ {} is back online!",
-                "➲ {} is finally here!",
-                "➲ Welcome back! {}",
-            ]
-            chosen_option = random.choice(options)
-            await update.effective_message.reply_text(
-                chosen_option.format(firstname)
-                + f"\n\nYou were AFK for: <code>{time}</code>",
-                parse_mode="html",
-            )
-        except:
-            return
-
-
-async def reply_afk(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    message = update.effective_message
-    userc = update.effective_user
-    userc_id = userc.id
-    if message.entities and message.parse_entities(
-        [MessageEntity.TEXT_MENTION, MessageEntity.MENTION],
-    ):
-        entities = message.parse_entities(
-            [MessageEntity.TEXT_MENTION, MessageEntity.MENTION],
-        )
-
-        chk_users = []
-        for ent in entities:
-            if ent.type == MessageEntity.TEXT_MENTION:
-                user_id = ent.user.id
-                fst_name = ent.user.first_name
-
-                if user_id in chk_users:
-                    return
-                chk_users.append(user_id)
-
-            if ent.type != MessageEntity.MENTION:
-                return
-
-            user_id = await get_user_id(
-                message.text[ent.offset : ent.offset + ent.length],
-            )
-            if not user_id:
-                return
-
-            if user_id in chk_users:
-                return
-            chk_users.append(user_id)
-
-            try:
-                chat = await bot.get_chat(user_id)
-            except BadRequest:
-                LOGGER.error(
-                    "Error: Could not fetch userid {} for AFK module".format(user_id)
-                )
-                return
-            fst_name = chat.first_name
-
-            await check_afk(update, context, user_id, fst_name, userc_id)
-
-    elif message.reply_to_message:
-        user_id = message.reply_to_message.from_user.id
-        fst_name = message.reply_to_message.from_user.first_name
-        await check_afk(update, context, user_id, fst_name, userc_id)
-
-
-async def check_afk(
-    update: Update,
-    context: ContextTypes.DEFAULT_TYPE,
-    user_id: int,
-    fst_name: str,
-    userc_id: int,
-):
-    if sql.is_afk(user_id):
-        user = sql.check_afk_status(user_id)
-
-        if int(userc_id) == int(user_id):
-            return
-
-        time = humanize.naturaldelta(datetime.now() - user.time)
-
-        if not user.reason:
-            res = "➲ {} is afk.\n\n➦ Last seen {} ago.".format(
-                fst_name,
-                time,
-            )
-            await update.effective_message.reply_text(res)
-        else:
-            res = (
-                "➲ {} is afk.\n\n➦ Reason: <code>{}</code>\n➦ Last seen {} ago.".format(
-                    html.escape(fst_name),
-                    html.escape(user.reason),
-                    time,
-                )
-            )
-            await update.effective_message.reply_text(res, parse_mode="html")
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-» /afk <reason>*:* mark yourself as AFK (away from keyboard).
-
-» brb , !afk <reason>*:* same as the afk command - but not a command.
-
-➠ *When marked as AFK, any mentions will be replied to with a message to say you're not available!*
-"""
-
-# <================================================ HANDLER =======================================================>
-AFK_HANDLER = DisableAbleCommandHandler("afk", afk, block=False)
-AFK_REGEX_HANDLER = DisableAbleMessageHandler(
-    filters.Regex(r"^(?i:(brb|!afk))( .*)?$"), afk, friendly="afk", block=False
-)
-NO_AFK_HANDLER = MessageHandler(
-    filters.ALL & filters.ChatType.GROUPS, no_longer_afk, block=False
-)
-AFK_REPLY_HANDLER = MessageHandler(
-    filters.ALL & filters.ChatType.GROUPS, reply_afk, block=False
-)
-
-function(AFK_HANDLER, AFK_GROUP)
-function(AFK_REGEX_HANDLER, AFK_GROUP)
-function(NO_AFK_HANDLER, AFK_GROUP)
-function(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
-
-__mod_name__ = "AFK"
-__command_list__ = ["afk"]
-__handlers__ = [
-    (AFK_HANDLER, AFK_GROUP),
-    (AFK_REGEX_HANDLER, AFK_GROUP),
-    (NO_AFK_HANDLER, AFK_GROUP),
-    (AFK_REPLY_HANDLER, AFK_REPLY_GROUP),
-]
-# <================================================ END =======================================================>

Mikobot/plugins/ai.py

@@ -1,141 +0,0 @@
-# CREATED BY: https://t.me/O_oKarma
-# API CREDITS: @Qewertyy
-# PROVIDED BY: https://github.com/Team-ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import base64
-
-from telegram import Update
-from telegram.constants import ParseMode
-from telegram.ext import CommandHandler, ContextTypes
-
-from Mikobot import LOGGER as logger
-from Mikobot import function
-from Mikobot.state import state
-
-# <=======================================================================================================>
-
-# <================================================ CONSTANTS =====================================================>
-API_URL = "https://lexica.qewertyy.me/models"
-PALM_MODEL_ID = 0
-GPT_MODEL_ID = 5
-
-# <================================================ FUNCTIONS =====================================================>
-
-
-async def get_api_response(model_id, api_params, api_url):
-    try:
-        response = await state.post(api_url, params=api_params)
-        if response.status_code == 200:
-            data = response.json()
-            return data.get(
-                "content", f"Error: Empty response received from the {model_id} API."
-            )
-        else:
-            return f"Error: Request failed with status code {response.status_code}."
-    except state.RequestError as e:
-        return f"Error: An error occurred while calling the {model_id} API. {e}"
-
-
-async def palm_chatbot(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    if not args:
-        await context.bot.send_message(
-            chat_id=update.effective_chat.id,
-            text="Error: Missing input text after /palm command.",
-        )
-        return
-
-    input_text = " ".join(args)
-
-    result_msg = await context.bot.send_message(
-        chat_id=update.effective_chat.id, text="🌴"
-    )
-
-    api_params = {"model_id": PALM_MODEL_ID, "prompt": input_text}
-    api_response = await get_api_response("PALM", api_params, API_URL)
-
-    await result_msg.delete()
-    await context.bot.send_message(chat_id=update.effective_chat.id, text=api_response)
-
-
-async def gpt_chatbot(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    if not args:
-        await context.bot.send_message(
-            chat_id=update.effective_chat.id,
-            text="Error: Missing input text after /askgpt command.",
-        )
-        return
-
-    input_text = " ".join(args)
-
-    result_msg = await context.bot.send_message(
-        chat_id=update.effective_chat.id, text="💬"
-    )
-
-    api_params = {"model_id": GPT_MODEL_ID, "prompt": input_text}
-    api_response = await get_api_response("GPT", api_params, API_URL)
-
-    await result_msg.delete()
-    await context.bot.send_message(chat_id=update.effective_chat.id, text=api_response)
-
-
-# Define the upscale_image function
-async def upscale_image(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    try:
-        # Check if the replied message contains a photo
-        if update.message.reply_to_message and update.message.reply_to_message.photo:
-            # Send a message indicating upscaling is in progress
-            progress_msg = await update.message.reply_text(
-                "Upscaling your image, please wait..."
-            )
-
-            # Access the image file_id from the replied message
-            image = await update.message.reply_to_message.photo[-1].get_file()
-
-            # Download the image and save it
-            image_path = await image.download_to_drive()
-
-            with open(image_path, "rb") as image_file:
-                f = image_file.read()
-
-            b = base64.b64encode(f).decode("utf-8")
-
-            response = await state.post(
-                "https://lexica.qewertyy.me/upscale",
-                data={"image_data": b},
-            )
-
-            # Save the upscaled image
-            upscaled_file_path = "upscaled_image.png"
-            with open(upscaled_file_path, "wb") as output_file:
-                output_file.write(response.content)
-
-            # Delete the progress message
-            await context.bot.delete_message(
-                chat_id=update.message.chat_id, message_id=progress_msg.message_id
-            )
-
-            # Send the upscaled image as a PNG file
-            await update.message.reply_document(
-                document=open(upscaled_file_path, "rb"),
-                caption=f"<b>Upscaled your image.</b>\n<b>Generated By:</b> @{context.bot.username}",
-                parse_mode=ParseMode.HTML,
-            )
-        else:
-            await update.message.reply_text("Please reply to an image to upscale it.")
-
-    except Exception as e:
-        logger.error(f"Failed to upscale the image: {e}")
-        await update.message.reply_text(
-            "Failed to upscale the image. Please try again later."
-        )
-
-
-# <================================================ HANDLER =======================================================>
-# Register the upscale_image command handler
-function(CommandHandler("upscale", upscale_image, block=False))
-function(CommandHandler("palm", palm_chatbot, block=False))
-function(CommandHandler("askgpt", gpt_chatbot, block=False))
-# <================================================ END =======================================================>

Mikobot/plugins/alive.py

@@ -1,57 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# PROVIDED BY https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import random
-from sys import version_info
-
-import pyrogram
-import telegram
-import telethon
-from pyrogram import filters
-from pyrogram.types import InlineKeyboardMarkup, Message
-
-from Infamous.karma import ALIVE_ANIMATION, ALIVE_BTN
-from Mikobot import BOT_NAME, app
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-@app.on_message(filters.command("alive"))
-async def alive(_, message: Message):
-    library_versions = {
-        "PTB": telegram.__version__,
-        "TELETHON": telethon.__version__,
-        "PYROGRAM": pyrogram.__version__,
-    }
-
-    library_versions_text = "\n".join(
-        [f"➲ **{key}:** `{value}`" for key, value in library_versions.items()]
-    )
-
-    caption = f"""**HEY, I AM {BOT_NAME}**
-
-━━━━━━ 🌟✿🌟 ━━━━━━
-✪ **CREATOR:** [🄺🄰🅁🄼🄰](https://t.me/anime_Freakz)
-
-{library_versions_text}
-
-➲ **PYTHON:** `{version_info[0]}.{version_info[1]}.{version_info[2]}`
-➲ **BOT VERSION:** `2.0`
-━━━━━━ 🌟✿🌟 ━━━━━━"""
-
-    await message.reply_animation(
-        random.choice(ALIVE_ANIMATION),
-        caption=caption,
-        reply_markup=InlineKeyboardMarkup(ALIVE_BTN),
-    )
-
-
-# <=======================================================================================================>
-
-
-# <================================================ NAME =======================================================>
-__mod_name__ = "ALIVE"
-# <================================================ END =======================================================>

Mikobot/plugins/antinsfw.py

@@ -1,189 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from os import remove
-
-from pyrogram import filters
-
-from Database.mongodb.toggle_mongo import is_nsfw_on, nsfw_off, nsfw_on
-from Mikobot import BOT_USERNAME, DRAGONS, app
-from Mikobot.state import arq
-from Mikobot.utils.can_restrict import can_restrict
-from Mikobot.utils.errors import capture_err
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def get_file_id_from_message(message):
-    file_id = None
-    if message.document:
-        if int(message.document.file_size) > 3145728:
-            return
-        mime_type = message.document.mime_type
-        if mime_type not in ("image/png", "image/jpeg"):
-            return
-        file_id = message.document.file_id
-
-    if message.sticker:
-        if message.sticker.is_animated:
-            if not message.sticker.thumbs:
-                return
-            file_id = message.sticker.thumbs[0].file_id
-        else:
-            file_id = message.sticker.file_id
-
-    if message.photo:
-        file_id = message.photo.file_id
-
-    if message.animation:
-        if not message.animation.thumbs:
-            return
-        file_id = message.animation.thumbs[0].file_id
-
-    if message.video:
-        if not message.video.thumbs:
-            return
-        file_id = message.video.thumbs[0].file_id
-    return file_id
-
-
-@app.on_message(
-    (
-        filters.document
-        | filters.photo
-        | filters.sticker
-        | filters.animation
-        | filters.video
-    )
-    & ~filters.private,
-    group=8,
-)
-@capture_err
-async def detect_nsfw(_, message):
-    if not await is_nsfw_on(message.chat.id):
-        return
-    if not message.from_user:
-        return
-    file_id = await get_file_id_from_message(message)
-    if not file_id:
-        return
-    file = await _.download_media(file_id)
-    try:
-        results = await arq.nsfw_scan(file=file)
-    except Exception:
-        return
-    if not results.ok:
-        return
-    results = results.result
-    remove(file)
-    nsfw = results.is_nsfw
-    if message.from_user.id in DRAGONS:
-        return
-    if not nsfw:
-        return
-    try:
-        await message.delete()
-    except Exception:
-        return
-    await message.reply_text(
-        f"""
-**🔞 NSFW Image Detected & Deleted Successfully!**
-
-**✪ User:** {message.from_user.mention} [`{message.from_user.id}`]
-**✪ Safe:** `{results.neutral} %`
-**✪ Porn:** `{results.porn} %`
-**✪ Adult:** `{results.sexy} %`
-**✪ Hentai:** `{results.hentai} %`
-**✪ Drawings:** `{results.drawings} %`
-"""
-    )
-
-
-@app.on_message(filters.command(["nsfwscan", f"nsfwscan@{BOT_USERNAME}"]))
-@capture_err
-async def nsfw_scan_command(_, message):
-    if not message.reply_to_message:
-        await message.reply_text(
-            "Reply to an image/document/sticker/animation to scan it."
-        )
-        return
-    reply = message.reply_to_message
-    if (
-        not reply.document
-        and not reply.photo
-        and not reply.sticker
-        and not reply.animation
-        and not reply.video
-    ):
-        await message.reply_text(
-            "Reply to an image/document/sticker/animation to scan it."
-        )
-        return
-    m = await message.reply_text("Scanning")
-    file_id = await get_file_id_from_message(reply)
-    if not file_id:
-        return await m.edit("Something wrong happened.")
-    file = await _.download_media(file_id)
-    try:
-        results = await arq.nsfw_scan(file=file)
-    except Exception:
-        return
-    remove(file)
-    if not results.ok:
-        return await m.edit(results.result)
-    results = results.result
-    await m.edit(
-        f"""
-**➢ Neutral:** `{results.neutral} %`
-**➢ Porn:** `{results.porn} %`
-**➢ Hentai:** `{results.hentai} %`
-**➢ Sexy:** `{results.sexy} %`
-**➢ Drawings:** `{results.drawings} %`
-**➢ NSFW:** `{results.is_nsfw}`
-"""
-    )
-
-
-@app.on_message(
-    filters.command(["antinsfw", f"antinsfw@{BOT_USERNAME}"]) & ~filters.private
-)
-@can_restrict
-async def nsfw_enable_disable(_, message):
-    if len(message.command) != 2:
-        await message.reply_text("Usage: /antinsfw [on/off]")
-        return
-    status = message.text.split(None, 1)[1].strip()
-    status = status.lower()
-    chat_id = message.chat.id
-    if status in ("on", "yes"):
-        if await is_nsfw_on(chat_id):
-            await message.reply_text("Antinsfw is already enabled.")
-            return
-        await nsfw_on(chat_id)
-        await message.reply_text(
-            "Enabled AntiNSFW System. I will Delete Messages Containing Inappropriate Content."
-        )
-    elif status in ("off", "no"):
-        if not await is_nsfw_on(chat_id):
-            await message.reply_text("Antinsfw is already disabled.")
-            return
-        await nsfw_off(chat_id)
-        await message.reply_text("Disabled AntiNSFW System.")
-    else:
-        await message.reply_text("Unknown Suffix, Use /antinsfw [on/off]")
-
-
-# <=================================================== HELP ====================================================>
-
-
-__mod_name__ = "ANTI-NSFW"
-
-__help__ = """
-*🔞 Helps in detecting NSFW material and removing it*.
-
-➠ *Usage:*
-
-» /antinsfw [on/off]: Enables Anti-NSFW system.
-
-» /nsfwscan <reply to message>: Scans the file replied to.
-"""
-# <================================================ END =======================================================>

Mikobot/plugins/approve.py

@@ -1,259 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.constants import ChatMemberStatus, ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CallbackQueryHandler, ContextTypes
-from telegram.helpers import mention_html
-
-import Database.sql.approve_sql as sql
-from Mikobot import DRAGONS, dispatcher
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.chat_status import check_admin
-from Mikobot.plugins.helper_funcs.extraction import extract_user
-from Mikobot.plugins.log_channel import loggable
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-@loggable
-@check_admin(is_user=True)
-async def approve(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    message = update.effective_message
-    chat_title = message.chat.title
-    chat = update.effective_chat
-    args = context.args
-    user = update.effective_user
-    user_id = await extract_user(message, context, args)
-    if not user_id:
-        await message.reply_text(
-            "I don't know who you're talking about, you're going to need to specify a user!",
-        )
-        return ""
-    try:
-        member = await chat.get_member(user_id)
-    except BadRequest:
-        return ""
-    if member.status in [ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]:
-        await message.reply_text(
-            "User is already admin - locks, blocklists, and antiflood already don't apply to them.",
-        )
-        return ""
-    if sql.is_approved(message.chat_id, user_id):
-        await message.reply_text(
-            f"[{member.user.first_name}](tg://user?id={member.user.id}) is already approved in {chat_title}",
-            parse_mode=ParseMode.MARKDOWN,
-        )
-        return ""
-    sql.approve(message.chat_id, user_id)
-    await message.reply_text(
-        f"[{member.user.first_name}](tg://user?id={member.user.id}) has been approved in {chat_title}! They will now be ignored by automated admin actions like locks, blocklists, and antiflood.",
-        parse_mode=ParseMode.MARKDOWN,
-    )
-    log_message = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        f"#APPROVED\n"
-        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
-        f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}"
-    )
-
-    return log_message
-
-
-@loggable
-@check_admin(is_user=True)
-async def disapprove(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    message = update.effective_message
-    chat_title = message.chat.title
-    chat = update.effective_chat
-    args = context.args
-    user = update.effective_user
-    user_id = await extract_user(message, context, args)
-    if not user_id:
-        await message.reply_text(
-            "I don't know who you're talking about, you're going to need to specify a user!",
-        )
-        return ""
-    try:
-        member = await chat.get_member(user_id)
-    except BadRequest:
-        return ""
-    if member.status in [ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]:
-        await message.reply_text("This user is an admin, they can't be unapproved.")
-        return ""
-    if not sql.is_approved(message.chat_id, user_id):
-        await message.reply_text(f"{member.user.first_name} isn't approved yet!")
-        return ""
-    sql.disapprove(message.chat_id, user_id)
-    await message.reply_text(
-        f"{member.user.first_name} is no longer approved in {chat_title}.",
-    )
-    log_message = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        f"#UNAPPROVED\n"
-        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
-        f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}"
-    )
-
-    return log_message
-
-
-@check_admin(is_user=True)
-async def approved(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    message = update.effective_message
-    chat_title = message.chat.title
-    chat = update.effective_chat
-    msg = "The following users are approved.\n"
-    approved_users = sql.list_approved(message.chat_id)
-
-    if not approved_users:
-        await message.reply_text(f"No users are approved in {chat_title}.")
-        return ""
-
-    else:
-        for i in approved_users:
-            member = await chat.get_member(int(i.user_id))
-            msg += f"- `{i.user_id}`: {member.user['first_name']}\n"
-
-        await message.reply_text(msg, parse_mode=ParseMode.MARKDOWN)
-
-
-@check_admin(is_user=True)
-async def approval(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    message = update.effective_message
-    chat = update.effective_chat
-    args = context.args
-    user_id = await extract_user(message, context, args)
-
-    if not user_id:
-        await message.reply_text(
-            "I don't know who you're talking about, you're going to need to specify a user!",
-        )
-        return ""
-    member = await chat.get_member(int(user_id))
-    if sql.is_approved(message.chat_id, user_id):
-        await message.reply_text(
-            f"{member.user['first_name']} is an approved user. Locks, antiflood, and blocklists won't apply to them.",
-        )
-    else:
-        await message.reply_text(
-            f"{member.user['first_name']} is not an approved user. They are affected by normal commands.",
-        )
-
-
-async def unapproveall(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    member = await chat.get_member(user.id)
-
-    approved_users = sql.list_approved(chat.id)
-    if not approved_users:
-        await update.effective_message.reply_text(
-            f"No users are approved in {chat.title}."
-        )
-        return
-
-    if member.status != ChatMemberStatus.OWNER and user.id not in DRAGONS:
-        await update.effective_message.reply_text(
-            "Only the chat owner can unapprove all users at once.",
-        )
-    else:
-        buttons = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        text="Unapprove all users",
-                        callback_data="unapproveall_user",
-                    ),
-                ],
-                [
-                    InlineKeyboardButton(
-                        text="Cancel",
-                        callback_data="unapproveall_cancel",
-                    ),
-                ],
-            ],
-        )
-        await update.effective_message.reply_text(
-            f"Are you sure you would like to unapprove ALL users in {chat.title}? This action cannot be undone.",
-            reply_markup=buttons,
-            parse_mode=ParseMode.MARKDOWN,
-        )
-
-
-async def unapproveall_btn(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    chat = update.effective_chat
-    message = update.effective_message
-    member = await chat.get_member(query.from_user.id)
-    if query.data == "unapproveall_user":
-        if member.status == ChatMemberStatus.OWNER or query.from_user.id in DRAGONS:
-            approved_users = sql.list_approved(chat.id)
-            users = [int(i.user_id) for i in approved_users]
-            for user_id in users:
-                sql.disapprove(chat.id, user_id)
-            await message.edit_text("Successfully Unapproved all user in this Chat.")
-            return
-
-        if member.status == "administrator":
-            await query.answer("Only owner of the chat can do this.")
-
-        if member.status == "member":
-            await query.answer("You need to be admin to do this.")
-    elif query.data == "unapproveall_cancel":
-        if member.status == "creator" or query.from_user.id in DRAGONS:
-            await message.edit_text(
-                "Removing of all approved users has been cancelled."
-            )
-            return ""
-        if member.status == "administrator":
-            await query.answer("Only owner of the chat can do this.")
-        if member.status == "member":
-            await query.answer("You need to be admin to do this.")
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-➠ Sometimes, you might trust a user not to send unwanted content.
-Maybe not enough to make them admin, but you might be ok with locks, blacklists, and antiflood not applying to them.
-
-➠ That's what approvals are for - approve of trustworthy users to allow them to send
-
-➠ *Admin commands:*
-
-» /approval: Check a user's approval status in this chat.
-
-» /approve: Approve of a user. Locks, blacklists, and antiflood won't apply to them anymore.
-
-» /unapprove: Unapprove of a user. They will now be subject to locks, blacklists, and antiflood again.
-
-» /approved: List all approved users.
-
-» /unapproveall: Unapprove *ALL* users in a chat. This cannot be undone.
-"""
-
-# <================================================ HANDLER =======================================================>
-APPROVE = DisableAbleCommandHandler("approve", approve, block=False)
-DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove, block=False)
-APPROVED = DisableAbleCommandHandler("approved", approved, block=False)
-APPROVAL = DisableAbleCommandHandler("approval", approval, block=False)
-UNAPPROVEALL = DisableAbleCommandHandler("unapproveall", unapproveall, block=False)
-UNAPPROVEALL_BTN = CallbackQueryHandler(
-    unapproveall_btn, pattern=r"unapproveall_.*", block=False
-)
-
-dispatcher.add_handler(APPROVE)
-dispatcher.add_handler(DISAPPROVE)
-dispatcher.add_handler(APPROVED)
-dispatcher.add_handler(APPROVAL)
-dispatcher.add_handler(UNAPPROVEALL)
-dispatcher.add_handler(UNAPPROVEALL_BTN)
-
-__mod_name__ = "APPROVALS"
-__command_list__ = ["approve", "unapprove", "approved", "approval"]
-__handlers__ = [APPROVE, DISAPPROVE, APPROVED, APPROVAL]
-# <================================================ END =======================================================>

Mikobot/plugins/ban.py

@@ -1,748 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-
-from telegram import (
-    ChatMemberAdministrator,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Update,
-)
-from telegram.constants import ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CallbackQueryHandler, CommandHandler, ContextTypes, filters
-from telegram.helpers import mention_html
-
-from Mikobot import DEV_USERS, DRAGONS, LOGGER, OWNER_ID, function
-from Mikobot.utils.can_restrict import BAN_STICKER
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.chat_status import (
-    can_delete,
-    check_admin,
-    connection_status,
-    is_user_admin,
-    is_user_ban_protected,
-    is_user_in_chat,
-)
-from Mikobot.plugins.helper_funcs.extraction import extract_user_and_text
-from Mikobot.plugins.helper_funcs.misc import mention_username
-from Mikobot.plugins.helper_funcs.string_handling import extract_time
-from Mikobot.plugins.log_channel import gloggable, loggable
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-@connection_status
-@loggable
-@check_admin(permission="can_restrict_members", is_both=True)
-async def ban(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-    log_message = ""
-    bot = context.bot
-    args = context.args
-    user_id, reason = await extract_user_and_text(message, context, args)
-
-    member = await chat.get_member(user.id)
-    SILENT = bool(True if message.text.startswith("/s") else False)
-
-    # if update is coming from anonymous admin then send button and return.
-    if message.from_user.id == 1087968824:
-        if SILENT:
-            await message.reply_text("Currently /sban won't work for anoymous admins.")
-            return log_message
-        # Need chat title to be forwarded on callback data to mention channel after banning.
-        try:
-            chat_title = message.reply_to_message.sender_chat.title
-        except AttributeError:
-            chat_title = None
-        await update.effective_message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to prove Admin.",
-                            callback_data=f"bans_{chat.id}=ban={user_id}={reason}={chat_title}",
-                        ),
-                    ],
-                ]
-            ),
-        )
-
-        return log_message
-    elif (
-        not (
-            (
-                member.can_restrict_members
-                if isinstance(member, ChatMemberAdministrator)
-                else None
-            )
-            or member.status == "creator"
-        )
-        and user.id not in DRAGONS
-    ):
-        await update.effective_message.reply_text(
-            "Sorry son, but you're not worthy to wield the banhammer.",
-        )
-        return log_message
-
-    if user_id == bot.id:
-        await message.reply_text("Oh yeah, ban myself, noob!")
-        return log_message
-
-    if user_id is not None and user_id < 0:
-        CHAT_SENDER = True
-        chat_sender = message.reply_to_message.sender_chat
-    else:
-        CHAT_SENDER = False
-        try:
-            member = await chat.get_member(user_id)
-        except BadRequest as excp:
-            if excp.message == "User not found":
-                raise
-            elif excp == "Invalid user_id specified":
-                await message.reply_text("I Doubt that's a user.")
-            await message.reply_text("Can't find this person here.")
-            return log_message
-
-        if await is_user_ban_protected(chat, user_id, member) and user not in DEV_USERS:
-            if user_id == OWNER_ID:
-                await message.reply_text(
-                    "Trying to put me against a God level disaster huh?"
-                )
-            elif user_id in DEV_USERS:
-                await message.reply_text("I can't act against our own.")
-            elif user_id in DRAGONS:
-                await message.reply_text(
-                    "Fighting this Dragon here will put me and my people's at risk.",
-                )
-            else:
-                await message.reply_text("This user has immunity and cannot be banned.")
-            return log_message
-
-    if SILENT:
-        silent = True
-        if not await can_delete(chat, context.bot.id):
-            return ""
-    else:
-        silent = False
-
-    log = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        f"#{'S' if silent else ''}BANNED\n"
-        f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
-    )
-
-    reply = f"<code>❕</code><b>Ban Event</b>\n"
-
-    if CHAT_SENDER:
-        log += f"<b>Channel:</b> {mention_username(chat_sender.username, html.escape(chat_sender.title))}"
-        reply += f"<code> </code><b>•  Channel:</b> {mention_username(chat_sender.username, html.escape(chat_sender.title))}"
-
-    else:
-        log += f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-        reply += f"<code> </code><b>•  User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-
-    if reason:
-        log += "\n<b>Reason:</b> {}".format(reason)
-
-    try:
-        if CHAT_SENDER:
-            await chat.ban_sender_chat(sender_chat_id=chat_sender.id)
-        else:
-            await chat.ban_member(user_id)
-
-        if silent:
-            if message.reply_to_message:
-                await message.reply_to_message.delete()
-            await message.delete()
-            return log
-
-        await bot.send_sticker(
-            chat.id,
-            BAN_STICKER,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )  # banhammer marie sticker
-
-        if reason:
-            reply += f"\n<code> </code><b>•  Reason:</b> \n{html.escape(reason)}"
-        await bot.sendMessage(
-            chat.id,
-            reply,
-            parse_mode=ParseMode.HTML,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )
-        return log
-
-    except BadRequest as excp:
-        if excp.message == "Reply message not found":
-            # Do not reply
-            if silent:
-                return log
-            await message.reply_text("Banned!", quote=False)
-            return log
-        else:
-            LOGGER.warning(update)
-            LOGGER.exception(
-                "ERROR banning user %s in chat %s (%s) due to %s",
-                user_id,
-                chat.title,
-                chat.id,
-                excp.message,
-            )
-            await message.reply_text("Uhm...that didn't work...")
-
-    return log_message
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_restrict_members", is_both=True)
-async def temp_ban(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-    log_message = ""
-    bot, args = context.bot, context.args
-    user_id, reason = await extract_user_and_text(message, context, args)
-
-    if not user_id:
-        await message.reply_text("I doubt that's a user.")
-        return log_message
-
-    try:
-        member = await chat.get_member(user_id)
-    except BadRequest as excp:
-        if excp.message != "User not found":
-            raise
-        await message.reply_text("I can't seem to find this user.")
-        return log_message
-    if user_id == bot.id:
-        await message.reply_text("I'm not gonna BAN myself, are you crazy?")
-        return log_message
-
-    if await is_user_ban_protected(chat, user_id, member):
-        await message.reply_text("I don't feel like it.")
-        return log_message
-
-    if not reason:
-        await message.reply_text("You haven't specified a time to ban this user for!")
-        return log_message
-
-    split_reason = reason.split(None, 1)
-
-    time_val = split_reason[0].lower()
-    reason = split_reason[1] if len(split_reason) > 1 else ""
-    bantime = await extract_time(message, time_val)
-
-    if not bantime:
-        return log_message
-
-    log = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        "#TEMP BANNED\n"
-        f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
-        f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}\n"
-        f"<b>Time:</b> {time_val}"
-    )
-    if reason:
-        log += "\n<b>Reason:</b> {}".format(reason)
-
-    try:
-        await chat.ban_member(user_id, until_date=bantime)
-        await bot.send_sticker(
-            chat.id,
-            BAN_STICKER,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )  # banhammer marie sticker
-        await bot.sendMessage(
-            chat.id,
-            f"Banned! User {mention_html(member.user.id, html.escape(member.user.first_name))} "
-            f"will be banned for {time_val}.",
-            parse_mode=ParseMode.HTML,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )
-        return log
-
-    except BadRequest as excp:
-        if excp.message == "Reply message not found":
-            # Do not reply
-            await message.reply_text(
-                f"Banned! User will be banned for {time_val}.",
-                quote=False,
-            )
-            return log
-        else:
-            LOGGER.warning(update)
-            LOGGER.exception(
-                "ERROR banning user %s in chat %s (%s) due to %s",
-                user_id,
-                chat.title,
-                chat.id,
-                excp.message,
-            )
-            await message.reply_text("Well damn, I can't ban that user.")
-
-    return log_message
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_restrict_members", is_both=True)
-async def kick(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-    log_message = ""
-    bot, args = context.bot, context.args
-    user_id, reason = await extract_user_and_text(message, context, args)
-
-    if not user_id:
-        await message.reply_text("I doubt that's a user.")
-        return log_message
-
-    try:
-        member = await chat.get_member(user_id)
-    except BadRequest as excp:
-        if excp.message != "User not found":
-            raise
-
-        await message.reply_text("I can't seem to find this user.")
-        return log_message
-    if user_id == bot.id:
-        await message.reply_text("Yeahhh I'm not gonna do that.")
-        return log_message
-
-    if await is_user_ban_protected(chat, user_id):
-        await message.reply_text("I really wish I could kick this user....")
-        return log_message
-
-    res = chat.unban_member(user_id)  # unban on current user = kick
-    if res:
-        await bot.send_sticker(
-            chat.id,
-            BAN_STICKER,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )  # banhammer marie sticker
-        await bot.sendMessage(
-            chat.id,
-            f"Capitain I have kicked, {mention_html(member.user.id, html.escape(member.user.first_name))}.",
-            parse_mode=ParseMode.HTML,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )
-        log = (
-            f"<b>{html.escape(chat.title)}:</b>\n"
-            f"#KICKED\n"
-            f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
-            f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-        )
-        if reason:
-            log += f"\n<b>Reason:</b> {reason}"
-
-        return log
-
-    else:
-        await message.reply_text("Well damn, I can't kick that user.")
-
-    return log_message
-
-
-@check_admin(permission="can_restrict_members", is_bot=True)
-async def kickme(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    user_id = update.effective_message.from_user.id
-    if await is_user_admin(update.effective_chat, user_id):
-        await update.effective_message.reply_text(
-            "I wish I could... but you're an admin."
-        )
-        return
-
-    res = await update.effective_chat.unban_member(
-        user_id
-    )  # unban on current user = kick
-    # BUG: parsing not working
-    if res:
-        await update.effective_message.reply_text(
-            html.escape("You got the Devil's Kiss, Now die in peace"), parse_mode="html"
-        )
-    else:
-        await update.effective_message.reply_text("Huh? I can't :/")
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_restrict_members", is_both=True)
-async def unban(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
-    message = update.effective_message
-    user = update.effective_user
-    chat = update.effective_chat
-    log_message = ""
-    bot, args = context.bot, context.args
-    user_id, reason = await extract_user_and_text(message, context, args)
-
-    if message.from_user.id == 1087968824:
-        try:
-            chat_title = message.reply_to_message.sender_chat.title
-        except AttributeError:
-            chat_title = None
-
-        await message.reply_text(
-            text="You are an anonymous admin.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="Click to prove Admin.",
-                            callback_data=f"bans_{chat.id}=unban={user_id}={reason}={chat_title}",
-                        ),
-                    ],
-                ]
-            ),
-        )
-
-        return log_message
-
-    if not user_id:
-        await message.reply_text("I doubt that's a user.")
-        return log_message
-
-    if user_id == bot.id:
-        await message.reply_text("How would I unban myself if I wasn't here...?")
-        return log_message
-
-    if user_id is not None and user_id < 0:
-        CHAT_SENDER = True
-        chat_sender = message.reply_to_message.sender_chat
-    else:
-        CHAT_SENDER = False
-        try:
-            member = await chat.get_member(user_id)
-
-            if isinstance(member, ChatMemberAdministrator):
-                await message.reply_text(
-                    "This person is an admin here, Are you drunk???"
-                )
-                return log_message
-
-        except BadRequest as excp:
-            raise
-            if excp.message != "User not found":
-                raise
-            await message.reply_text("I can't seem to find this user.")
-            return log_message
-
-        if await is_user_in_chat(chat, user_id):
-            await message.reply_text("Isn't this person already here??")
-            return log_message
-
-    log = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        f"#UNBANNED\n"
-        f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
-    )
-
-    if CHAT_SENDER:
-        log += f"<b>User:</b> {mention_username(chat_sender.id, html.escape(chat_sender.title))}"
-        await chat.unban_sender_chat(chat_sender.id)
-        await message.reply_text("Yeah, this channel can speak again.")
-    else:
-        log += f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-        await chat.unban_member(user_id)
-        await message.reply_text("Yeah, this user can join!")
-
-    if reason:
-        log += f"\n<b>Reason:</b> {reason}"
-
-    return log
-
-
-@connection_status
-@gloggable
-@check_admin(permission="can_restrict_members", is_bot=True)
-async def selfunban(context: ContextTypes.DEFAULT_TYPE, update: Update) -> str:
-    message = update.effective_message
-    user = update.effective_user
-    bot, args = context.bot, context.args
-    if user.id not in DRAGONS:
-        return
-
-    try:
-        chat_id = int(args[0])
-    except:
-        await message.reply_text("Give a valid chat ID.")
-        return
-
-    chat = await bot.getChat(chat_id)
-
-    try:
-        member = await chat.get_member(user.id)
-    except BadRequest as excp:
-        if excp.message == "User not found":
-            await message.reply_text("I can't seem to find this user.")
-            return
-        else:
-            raise
-
-    if await is_user_in_chat(chat, user.id):
-        await message.reply_text("Aren't you already in the chat??")
-        return
-
-    await chat.unban_member(user.id)
-    await message.reply_text("Yep, I have unbanned you.")
-
-    log = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        f"#UNBANNED\n"
-        f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-    )
-
-    return log
-
-
-@loggable
-async def bans_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    bot = context.bot
-    chat = update.effective_chat
-    message = update.effective_message
-    args = context.args
-    log_message = ""
-    splitter = query.data.replace("bans_", "").split("=")
-
-    admin_user = query.from_user
-    member = await chat.get_member(admin_user.id)
-
-    if splitter[1] == "ban":
-        # workaround for checking user admin status
-        try:
-            user_id = int(splitter[2])
-        except ValueError:
-            user_id = splitter[2]
-        reason = splitter[3]
-        chat_name = splitter[4]
-
-        if not (
-            (
-                member.can_restrict_members
-                if isinstance(member, ChatMemberAdministrator)
-                else None
-            )
-            or member.status == "creator"
-        ) and (admin_user.id not in DRAGONS):
-            await query.answer(
-                "Sorry son, but you're not worthy to wield the banhammer.",
-                show_alert=True,
-            )
-            return log_message
-
-        if user_id == bot.id:
-            await message.edit_text("Oh yeah, ban myself, noob!")
-            return log_message
-
-        if isinstance(user_id, str):
-            await message.edit_text("I doubt that's a user.")
-            return log_message
-
-        if user_id < 0:
-            CHAT_SENDER = True
-        else:
-            CHAT_SENDER = False
-            try:
-                member = await chat.get_member(user_id)
-            except BadRequest as excp:
-                if excp.message == "User not found.":
-                    raise
-                elif excp == "Invalid user_id specified":
-                    await message.edit_text("I Doubt that's a user.")
-                await message.edit_text("Can't find this person here.")
-
-                return log_message
-
-            if (
-                await is_user_ban_protected(chat, user_id, member)
-                and admin_user not in DEV_USERS
-            ):
-                if user_id == OWNER_ID:
-                    await message.edit_text(
-                        "Trying to put me against a God level disaster huh?"
-                    )
-                elif user_id in DEV_USERS:
-                    await message.edit_text("I can't act against our own.")
-                elif user_id in DRAGONS:
-                    await message.edit_text(
-                        "Fighting this Dragon here will put me and my people's at risk.",
-                    )
-                else:
-                    await message.edit_text(
-                        "This user has immunity and cannot be banned."
-                    )
-                return log_message
-
-        log = (
-            f"<b>{html.escape(chat.title)}:</b>\n"
-            f"#BANNED\n"
-            f"<b>Admin:</b> {mention_html(admin_user.id, html.escape(admin_user.first_name))}\n"
-        )
-
-        reply = f"<code>❕</code><b>Ban Event</b>\n"
-
-        if CHAT_SENDER:
-            log += f"<b>Channel:</b> {html.escape(chat_name)}"
-            reply += f"<code> </code><b>•  Channel:</b> {html.escape(chat_name)}"
-
-        else:
-            log += f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-            reply += f"<code> </code><b>•  User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-
-        if reason:
-            log += "\n<b>Reason:</b> {}".format(reason)
-
-        try:
-            if CHAT_SENDER:
-                await chat.ban_sender_chat(sender_chat_id=user_id)
-            else:
-                await chat.ban_member(user_id)
-
-            await bot.send_sticker(
-                chat.id,
-                BAN_STICKER,
-                message_thread_id=message.message_thread_id if chat.is_forum else None,
-            )  # banhammer marie sticker
-
-            if reason:
-                reply += f"\n<code> </code><b>•  Reason:</b> \n{html.escape(reason)}"
-            await bot.sendMessage(
-                chat.id,
-                reply,
-                parse_mode=ParseMode.HTML,
-                message_thread_id=message.message_thread_id if chat.is_forum else None,
-            )
-            await query.answer(f"Done Banned User.")
-            return log
-
-        except BadRequest as excp:
-            if excp.message == "Reply message not found":
-                # Do not reply
-                await message.edit_text("Banned!")
-                return log
-            else:
-                LOGGER.warning(update)
-                LOGGER.exception(
-                    "ERROR banning user %s in chat %s (%s) due to %s",
-                    user_id,
-                    chat.title,
-                    chat.id,
-                    excp.message,
-                )
-                await message.edit_text("Uhm...that didn't work...")
-
-        return log_message
-
-    elif splitter[1] == "unban":
-        try:
-            user_id = int(splitter[2])
-        except ValueError:
-            user_id = splitter[2]
-        reason = splitter[3]
-
-        if isinstance(user_id, str):
-            await message.edit_text("I doubt that's a user.")
-            return log_message
-
-        if user_id == bot.id:
-            await message.edit_text("How would i unban myself if i wasn't here...?")
-            return log_message
-
-        if user_id < 0:
-            CHAT_SENDER = True
-            chat_title = splitter[4]
-        else:
-            CHAT_SENDER = False
-
-            try:
-                member = await chat.get_member(user_id)
-            except BadRequest as excp:
-                if excp.message != "User not found":
-                    raise
-                await message.edit_text("I can't seem to find this user.")
-                return log_message
-
-            if await is_user_in_chat(chat, user_id):
-                await message.edit_text("Isn't this person already here??")
-                return log_message
-
-        log = (
-            f"<b>{html.escape(chat.title)}:</b>\n"
-            f"#UNBANNED\n"
-            f"<b>Admin:</b> {mention_html(admin_user.id, html.escape(admin_user.first_name))}\n"
-        )
-
-        if CHAT_SENDER:
-            log += f"<b>User:</b> {html.escape(chat_title)}"
-            await chat.unban_sender_chat(user_id)
-            await message.reply_text("Yeah, this channel can speak again.")
-        else:
-            log += f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
-            await chat.unban_member(user_id)
-            await message.reply_text("Yeah, this user can join!")
-
-        if reason:
-            log += f"\n<b>Reason:</b> {reason}"
-
-        return log
-
-
-# <================================================ HELP =======================================================>
-
-
-__help__ = """
-» /kickme: kicks the user who issued the command
-
-➠ *Admins only:*
-» /ban <userhandle>: bans a user/channel. (via handle, or reply)
-
-» /sban <userhandle>: Silently ban a user. Deletes command, Replied message and doesn't reply. (via handle, or reply)
-
-» /tban <userhandle> x(m/h/d): bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
-
-» /unban <userhandle>: unbans a user/channel. (via handle, or reply)
-
-» /kick <userhandle>: kicks a user out of the group, (via handle, or reply)
-
-➠ NOTE:
-    Banning or UnBanning channels only work if you reply to their message, so don't use their username to ban/unban.
-"""
-
-# <================================================ HANDLER =======================================================>
-BAN_HANDLER = CommandHandler(["ban", "sban"], ban, block=False)
-TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban, block=False)
-KICK_HANDLER = CommandHandler("kick", kick, block=False)
-UNBAN_HANDLER = CommandHandler("unban", unban, block=False)
-ROAR_HANDLER = CommandHandler("roar", selfunban, block=False)
-KICKME_HANDLER = DisableAbleCommandHandler(
-    "kickme", kickme, filters=filters.ChatType.GROUPS, block=False
-)
-BAN_CALLBACK_HANDLER = CallbackQueryHandler(
-    bans_callback, block=False, pattern=r"bans_"
-)
-
-function(BAN_HANDLER)
-function(TEMPBAN_HANDLER)
-function(KICK_HANDLER)
-function(UNBAN_HANDLER)
-function(ROAR_HANDLER)
-function(KICKME_HANDLER)
-function(BAN_CALLBACK_HANDLER)
-
-__mod_name__ = "BAN"
-__handlers__ = [
-    BAN_HANDLER,
-    TEMPBAN_HANDLER,
-    KICK_HANDLER,
-    UNBAN_HANDLER,
-    ROAR_HANDLER,
-    KICKME_HANDLER,
-    BAN_CALLBACK_HANDLER,
-]
-# <================================================ END =======================================================>

Mikobot/plugins/blacklist.py

@@ -1,548 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-import re
-
-from telegram import ChatPermissions, Update
-from telegram.constants import ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CommandHandler, ContextTypes, MessageHandler, filters
-from telegram.helpers import mention_html
-
-import Database.sql.blacklist_sql as sql
-from Database.sql.approve_sql import is_approved
-from Mikobot import LOGGER, dispatcher, function
-from Mikobot.plugins.connection import connected
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.alternate import send_message, typing_action
-from Mikobot.plugins.helper_funcs.chat_status import check_admin, user_not_admin
-from Mikobot.plugins.helper_funcs.extraction import extract_text
-from Mikobot.plugins.helper_funcs.misc import split_message
-from Mikobot.plugins.helper_funcs.string_handling import extract_time
-from Mikobot.plugins.log_channel import loggable
-from Mikobot.plugins.warns import warn
-
-# <=======================================================================================================>
-
-BLACKLIST_GROUP = 11
-
-
-# <================================================ FUNCTION =======================================================>
-@check_admin(is_user=True)
-@typing_action
-async def blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    args = context.args
-
-    conn = await connected(context.bot, update, chat, user.id, need_admin=False)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if chat.type == "private":
-            return
-        chat_id = update.effective_chat.id
-        chat_name = chat.title
-
-    filter_list = "Current blacklisted words in <b>{}</b>:\n".format(chat_name)
-
-    all_blacklisted = sql.get_chat_blacklist(chat_id)
-
-    if len(args) > 0 and args[0].lower() == "copy":
-        for trigger in all_blacklisted:
-            filter_list += "<code>{}</code>\n".format(html.escape(trigger))
-    else:
-        for trigger in all_blacklisted:
-            filter_list += " - <code>{}</code>\n".format(html.escape(trigger))
-
-    # for trigger in all_blacklisted:
-    #     filter_list += " - <code>{}</code>\n".format(html.escape(trigger))
-
-    split_text = split_message(filter_list)
-    for text in split_text:
-        if filter_list == "Current blacklisted words in <b>{}</b>:\n".format(
-            html.escape(chat_name),
-        ):
-            await send_message(
-                update.effective_message,
-                "No blacklisted words in <b>{}</b>!".format(html.escape(chat_name)),
-                parse_mode=ParseMode.HTML,
-            )
-            return
-        await send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
-
-
-@check_admin(is_user=True)
-@typing_action
-async def add_blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.effective_message
-    chat = update.effective_chat
-    user = update.effective_user
-    words = msg.text.split(None, 1)
-
-    conn = await connected(context.bot, update, chat, user.id)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        chat_id = update.effective_chat.id
-        if chat.type == "private":
-            return
-        else:
-            chat_name = chat.title
-
-    if len(words) > 1:
-        text = words[1]
-        to_blacklist = list(
-            {trigger.strip() for trigger in text.split("\n") if trigger.strip()},
-        )
-        for trigger in to_blacklist:
-            sql.add_to_blacklist(chat_id, trigger.lower())
-
-        if len(to_blacklist) == 1:
-            await send_message(
-                update.effective_message,
-                "Added blacklist <code>{}</code> in chat: <b>{}</b>!".format(
-                    html.escape(to_blacklist[0]),
-                    html.escape(chat_name),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-
-        else:
-            await send_message(
-                update.effective_message,
-                "Added blacklist trigger: <code>{}</code> in <b>{}</b>!".format(
-                    len(to_blacklist),
-                    html.escape(chat_name),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-
-    else:
-        await send_message(
-            update.effective_message,
-            "Tell me which words you would like to add in blacklist.",
-        )
-
-
-@check_admin(is_user=True)
-@typing_action
-async def unblacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.effective_message
-    chat = update.effective_chat
-    user = update.effective_user
-    words = msg.text.split(None, 1)
-
-    conn = await connected(context.bot, update, chat, user.id)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        chat_id = update.effective_chat.id
-        if chat.type == "private":
-            return
-        else:
-            chat_name = chat.title
-
-    if len(words) > 1:
-        text = words[1]
-        to_unblacklist = list(
-            {trigger.strip() for trigger in text.split("\n") if trigger.strip()},
-        )
-        successful = 0
-        for trigger in to_unblacklist:
-            success = sql.rm_from_blacklist(chat_id, trigger.lower())
-            if success:
-                successful += 1
-
-        if len(to_unblacklist) == 1:
-            if successful:
-                await send_message(
-                    update.effective_message,
-                    "Removed <code>{}</code> from blacklist in <b>{}</b>!".format(
-                        html.escape(to_unblacklist[0]),
-                        html.escape(chat_name),
-                    ),
-                    parse_mode=ParseMode.HTML,
-                )
-            else:
-                await send_message(
-                    update.effective_message,
-                    "This is not a blacklist trigger!",
-                )
-
-        elif successful == len(to_unblacklist):
-            await send_message(
-                update.effective_message,
-                "Removed <code>{}</code> from blacklist in <b>{}</b>!".format(
-                    successful,
-                    html.escape(chat_name),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-
-        elif not successful:
-            await send_message(
-                update.effective_message,
-                "None of these triggers exist so it can't be removed.",
-                parse_mode=ParseMode.HTML,
-            )
-
-        else:
-            await send_message(
-                update.effective_message,
-                "Removed <code>{}</code> from blacklist. {} did not exist, "
-                "so were not removed.".format(
-                    successful,
-                    len(to_unblacklist) - successful,
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-    else:
-        await send_message(
-            update.effective_message,
-            "Tell me which words you would like to remove from blacklist!",
-        )
-
-
-@loggable
-@check_admin(is_user=True)
-@typing_action
-async def blacklist_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-    args = context.args
-
-    conn = await connected(context.bot, update, chat, user.id, need_admin=True)
-    if conn:
-        chat = await dispatcher.bot.getChat(conn)
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if update.effective_message.chat.type == "private":
-            await send_message(
-                update.effective_message,
-                "This command can be only used in group not in PM",
-            )
-            return ""
-        chat = update.effective_chat
-        chat_id = update.effective_chat.id
-        chat_name = update.effective_message.chat.title
-
-    if args:
-        if args[0].lower() in ["off", "nothing", "no"]:
-            settypeblacklist = "do nothing"
-            sql.set_blacklist_strength(chat_id, 0, "0")
-        elif args[0].lower() in ["del", "delete"]:
-            settypeblacklist = "delete blacklisted message"
-            sql.set_blacklist_strength(chat_id, 1, "0")
-        elif args[0].lower() == "warn":
-            settypeblacklist = "warn the sender"
-            sql.set_blacklist_strength(chat_id, 2, "0")
-        elif args[0].lower() == "mute":
-            settypeblacklist = "mute the sender"
-            sql.set_blacklist_strength(chat_id, 3, "0")
-        elif args[0].lower() == "kick":
-            settypeblacklist = "kick the sender"
-            sql.set_blacklist_strength(chat_id, 4, "0")
-        elif args[0].lower() == "ban":
-            settypeblacklist = "ban the sender"
-            sql.set_blacklist_strength(chat_id, 5, "0")
-        elif args[0].lower() == "tban":
-            if len(args) == 1:
-                teks = """It looks like you tried to set time value for blacklist but you didn't specified time; Try, `/blacklistmode tban <timevalue>`.
-
-Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message, teks, parse_mode="markdown"
-                )
-                return ""
-            restime = await extract_time(msg, args[1])
-            if not restime:
-                teks = """Invalid time value!
-Example of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message, teks, parse_mode="markdown"
-                )
-                return ""
-            settypeblacklist = "temporarily ban for {}".format(args[1])
-            sql.set_blacklist_strength(chat_id, 6, str(args[1]))
-        elif args[0].lower() == "tmute":
-            if len(args) == 1:
-                teks = """It looks like you tried to set time value for blacklist but you didn't specified  time; try, `/blacklistmode tmute <timevalue>`.
-
-Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message, teks, parse_mode="markdown"
-                )
-                return ""
-            restime = await extract_time(msg, args[1])
-            if not restime:
-                teks = """Invalid time value!
-Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message, teks, parse_mode="markdown"
-                )
-                return ""
-            settypeblacklist = "temporarily mute for {}".format(args[1])
-            sql.set_blacklist_strength(chat_id, 7, str(args[1]))
-        else:
-            await send_message(
-                update.effective_message,
-                "I only understand: off/del/warn/ban/kick/mute/tban/tmute!",
-            )
-            return ""
-        if conn:
-            text = "Changed blacklist mode: `{}` in *{}*!".format(
-                settypeblacklist,
-                chat_name,
-            )
-        else:
-            text = "Changed blacklist mode: `{}`!".format(settypeblacklist)
-        await send_message(update.effective_message, text, parse_mode="markdown")
-        return (
-            "<b>{}:</b>\n"
-            "<b>Admin:</b> {}\n"
-            "Changed the blacklist mode. will {}.".format(
-                html.escape(chat.title),
-                mention_html(user.id, html.escape(user.first_name)),
-                settypeblacklist,
-            )
-        )
-    else:
-        getmode, getvalue = sql.get_blacklist_setting(chat.id)
-        if getmode == 0:
-            settypeblacklist = "do nothing"
-        elif getmode == 1:
-            settypeblacklist = "delete"
-        elif getmode == 2:
-            settypeblacklist = "warn"
-        elif getmode == 3:
-            settypeblacklist = "mute"
-        elif getmode == 4:
-            settypeblacklist = "kick"
-        elif getmode == 5:
-            settypeblacklist = "ban"
-        elif getmode == 6:
-            settypeblacklist = "temporarily ban for {}".format(getvalue)
-        elif getmode == 7:
-            settypeblacklist = "temporarily mute for {}".format(getvalue)
-        if conn:
-            text = "Current blacklistmode: *{}* in *{}*.".format(
-                settypeblacklist,
-                chat_name,
-            )
-        else:
-            text = "Current blacklistmode: *{}*.".format(settypeblacklist)
-        await send_message(
-            update.effective_message, text, parse_mode=ParseMode.MARKDOWN
-        )
-    return ""
-
-
-def findall(p, s):
-    i = s.find(p)
-    while i != -1:
-        yield i
-        i = s.find(p, i + 1)
-
-
-@user_not_admin
-async def del_blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    message = update.effective_message
-    user = update.effective_user
-    bot = context.bot
-    to_match = await extract_text(message)
-    if not to_match:
-        return
-    if is_approved(chat.id, user.id):
-        return
-    getmode, value = sql.get_blacklist_setting(chat.id)
-
-    chat_filters = sql.get_chat_blacklist(chat.id)
-    for trigger in chat_filters:
-        pattern = r"( |^|[^\w])" + re.escape(trigger) + r"( |$|[^\w])"
-        if re.search(pattern, to_match, flags=re.IGNORECASE):
-            try:
-                if getmode == 0:
-                    return
-                elif getmode == 1:
-                    try:
-                        await message.delete()
-                    except BadRequest:
-                        pass
-                elif getmode == 2:
-                    try:
-                        await message.delete()
-                    except BadRequest:
-                        pass
-                    warn(
-                        update.effective_user,
-                        chat,
-                        ("Using blacklisted trigger: {}".format(trigger)),
-                        message,
-                        update.effective_user,
-                    )
-                    return
-                elif getmode == 3:
-                    await message.delete()
-                    await bot.restrict_chat_member(
-                        chat.id,
-                        update.effective_user.id,
-                        permissions=ChatPermissions(can_send_messages=False),
-                    )
-                    await bot.sendMessage(
-                        chat.id,
-                        f"Muted {user.first_name} for using Blacklisted word: {trigger}!",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-                elif getmode == 4:
-                    await message.delete()
-                    res = chat.unban_member(update.effective_user.id)
-                    if res:
-                        await bot.sendMessage(
-                            chat.id,
-                            f"Kicked {user.first_name} for using Blacklisted word: {trigger}!",
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
-                        )
-                    return
-                elif getmode == 5:
-                    await message.delete()
-                    await chat.ban_member(user.id)
-                    await bot.sendMessage(
-                        chat.id,
-                        f"Banned {user.first_name} for using Blacklisted word: {trigger}",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-                elif getmode == 6:
-                    await message.delete()
-                    bantime = await extract_time(message, value)
-                    await chat.ban_member(user.id, until_date=bantime)
-                    await bot.sendMessage(
-                        chat.id,
-                        f"Banned {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-                elif getmode == 7:
-                    await message.delete()
-                    mutetime = await extract_time(message, value)
-                    await bot.restrict_chat_member(
-                        chat.id,
-                        user.id,
-                        until_date=mutetime,
-                        permissions=ChatPermissions(can_send_messages=False),
-                    )
-                    await bot.sendMessage(
-                        chat.id,
-                        f"Muted {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-            except BadRequest as excp:
-                if excp.message != "Message to delete not found":
-                    LOGGER.exception("Error while deleting blacklist message.")
-            break
-
-
-async def __import_data__(chat_id, data, message):
-    # set chat blacklist
-    blacklist = data.get("blacklist", {})
-    for trigger in blacklist:
-        sql.add_to_blacklist(chat_id, trigger)
-
-
-def __migrate__(old_chat_id, new_chat_id):
-    sql.migrate_chat(old_chat_id, new_chat_id)
-
-
-def __chat_settings__(chat_id, user_id):
-    blacklisted = sql.num_blacklist_chat_filters(chat_id)
-    return "There are {} blacklisted words.".format(blacklisted)
-
-
-def __stats__():
-    return "• {} blacklist triggers, across {} chats.".format(
-        sql.num_blacklist_filters(),
-        sql.num_blacklist_filter_chats(),
-    )
-
-
-# <=================================================== HELP ====================================================>
-
-
-__mod_name__ = "BLACKLIST"
-
-__help__ = """
-
-➠ Blacklists are used to stop certain triggers from being said in a group. Any time the trigger is mentioned, the message will immediately be deleted. A good combo is sometimes to pair this up with warn filters!
-
-➠ *NOTE*: Blacklists do not affect group admins.
-
-» /blacklist: View the current blacklisted words.
-
-Admin only:
-» /addblacklist <triggers>: Add a trigger to the blacklist. Each line is considered one trigger, so using different lines will allow you to add multiple triggers.
-» /unblacklist <triggers>: Remove triggers from the blacklist. Same newline logic applies here, so you can remove multiple triggers at once.
-» /blacklistmode <off/del/warn/ban/kick/mute/tban/tmute>: Action to perform when someone sends blacklisted words.
-
-➠ Blacklist sticker is used to stop certain stickers. Whenever a sticker is sent, the message will be deleted immediately.
-➠ *NOTE:* Blacklist stickers do not affect the group admin
-» /blsticker: See current blacklisted sticker
-➠ *Only admin:*
-» /addblsticker <sticker link>: Add the sticker trigger to the black list. Can be added via reply sticker
-» /unblsticker <sticker link>: Remove triggers from blacklist. The same newline logic applies here, so you can delete multiple triggers at once
-» /rmblsticker <sticker link>: Same as above
-» /blstickermode <delete/ban/tban/mute/tmute>: sets up a default action on what to do if users use blacklisted stickers
-Note:
-» <sticker link> can be https://t.me/addstickers/<sticker> or just <sticker> or reply to the sticker message
-
-"""
-
-# <================================================ HANDLER =======================================================>
-BLACKLIST_HANDLER = DisableAbleCommandHandler(
-    "blacklist", blacklist, admin_ok=True, block=False
-)
-ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist, block=False)
-UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist, block=False)
-BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, block=False)
-BLACKLIST_DEL_HANDLER = MessageHandler(
-    (filters.TEXT | filters.COMMAND | filters.Sticker.ALL | filters.PHOTO)
-    & filters.ChatType.GROUPS,
-    del_blacklist,
-    block=False,
-)
-
-function(BLACKLIST_HANDLER)
-function(ADD_BLACKLIST_HANDLER)
-function(UNBLACKLIST_HANDLER)
-function(BLACKLISTMODE_HANDLER)
-function(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
-
-__handlers__ = [
-    BLACKLIST_HANDLER,
-    ADD_BLACKLIST_HANDLER,
-    UNBLACKLIST_HANDLER,
-    BLACKLISTMODE_HANDLER,
-    (BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP),
-]
-# <================================================ END =======================================================>

Mikobot/plugins/blacklist_stickers.py

@@ -1,581 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-
-from telegram import ChatPermissions, Update
-from telegram.constants import ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CommandHandler, ContextTypes, MessageHandler, filters
-from telegram.helpers import mention_html, mention_markdown
-
-import Database.sql.blsticker_sql as sql
-from Mikobot import LOGGER, dispatcher
-from Mikobot.plugins.connection import connected
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.alternate import send_message
-from Mikobot.plugins.helper_funcs.chat_status import check_admin, user_not_admin
-from Mikobot.plugins.helper_funcs.misc import split_message
-from Mikobot.plugins.helper_funcs.string_handling import extract_time
-from Mikobot.plugins.log_channel import loggable
-from Mikobot.plugins.warns import warn
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.effective_message  # type: Optional[Message]
-    chat = update.effective_chat  # type: Optional[Chat]
-    user = update.effective_user  # type: Optional[User]
-    bot, args = context.bot, context.args
-    conn = await connected(bot, update, chat, user.id, need_admin=False)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if chat.type == "private":
-            return
-        chat_id = update.effective_chat.id
-        chat_name = chat.title
-
-    sticker_list = "<b>List blacklisted stickers currently in {}:</b>\n".format(
-        chat_name,
-    )
-
-    all_stickerlist = sql.get_chat_stickers(chat_id)
-
-    if len(args) > 0 and args[0].lower() == "copy":
-        for trigger in all_stickerlist:
-            sticker_list += "<code>{}</code>\n".format(html.escape(trigger))
-    elif len(args) == 0:
-        for trigger in all_stickerlist:
-            sticker_list += " - <code>{}</code>\n".format(html.escape(trigger))
-
-    split_text = split_message(sticker_list)
-    for text in split_text:
-        if sticker_list == "<b>List blacklisted stickers currently in {}:</b>\n".format(
-            chat_name,
-        ).format(html.escape(chat_name)):
-            await send_message(
-                update.effective_message,
-                "There are no blacklist stickers in <b>{}</b>!".format(
-                    html.escape(chat_name),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-            return
-    await send_message(
-        update.effective_message,
-        text,
-        parse_mode=ParseMode.HTML,
-    )
-
-
-@check_admin(is_user=True)
-async def add_blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    msg = update.effective_message  # type: Optional[Message]
-    chat = update.effective_chat  # type: Optional[Chat]
-    user = update.effective_user  # type: Optional[User]
-    words = msg.text.split(None, 1)
-    bot = context.bot
-    conn = await connected(bot, update, chat, user.id)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        chat_id = update.effective_chat.id
-        if chat.type == "private":
-            return
-        else:
-            chat_name = chat.title
-
-    if len(words) > 1:
-        text = words[1].replace("https://t.me/addstickers/", "")
-        to_blacklist = list(
-            {trigger.strip() for trigger in text.split("\n") if trigger.strip()},
-        )
-
-        added = 0
-        for trigger in to_blacklist:
-            try:
-                get = await bot.getStickerSet(trigger)
-                sql.add_to_stickers(chat_id, trigger.lower())
-                added += 1
-            except BadRequest:
-                await send_message(
-                    update.effective_message,
-                    "Sticker `{}` can not be found!".format(trigger),
-                    parse_mode="markdown",
-                )
-
-        if added == 0:
-            return
-
-        if len(to_blacklist) == 1:
-            await send_message(
-                update.effective_message,
-                "Sticker <code>{}</code> added to blacklist stickers in <b>{}</b>!".format(
-                    html.escape(to_blacklist[0]),
-                    html.escape(chat_name),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-        else:
-            await send_message(
-                update.effective_message,
-                "<code>{}</code> stickers added to blacklist sticker in <b>{}</b>!".format(
-                    added,
-                    html.escape(chat_name),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-    elif msg.reply_to_message:
-        added = 0
-        trigger = msg.reply_to_message.sticker.set_name
-        if trigger is None:
-            await send_message(
-                update.effective_message,
-                "Sticker is invalid!",
-            )
-            return
-        try:
-            get = await bot.getStickerSet(trigger)
-            sql.add_to_stickers(chat_id, trigger.lower())
-            added += 1
-        except BadRequest:
-            await send_message(
-                update.effective_message,
-                "Sticker `{}` can not be found!".format(trigger),
-                parse_mode="markdown",
-            )
-
-        if added == 0:
-            return
-
-        await send_message(
-            update.effective_message,
-            "Sticker <code>{}</code> added to blacklist stickers in <b>{}</b>!".format(
-                trigger,
-                html.escape(chat_name),
-            ),
-            parse_mode=ParseMode.HTML,
-        )
-    else:
-        await send_message(
-            update.effective_message,
-            "Tell me what stickers you want to add to the blacklist.",
-        )
-
-
-@check_admin(is_user=True)
-async def unblackliststicker(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    msg = update.effective_message  # type: Optional[Message]
-    chat = update.effective_chat  # type: Optional[Chat]
-    user = update.effective_user  # type: Optional[User]
-    words = msg.text.split(None, 1)
-    bot = context.bot
-    conn = await connected(bot, update, chat, user.id)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        chat_id = update.effective_chat.id
-        if chat.type == "private":
-            return
-        else:
-            chat_name = chat.title
-
-    if len(words) > 1:
-        text = words[1].replace("https://t.me/addstickers/", "")
-        to_unblacklist = list(
-            {trigger.strip() for trigger in text.split("\n") if trigger.strip()},
-        )
-
-        successful = 0
-        for trigger in to_unblacklist:
-            success = sql.rm_from_stickers(chat_id, trigger.lower())
-            if success:
-                successful += 1
-
-        if len(to_unblacklist) == 1:
-            if successful:
-                await send_message(
-                    update.effective_message,
-                    "Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!".format(
-                        html.escape(to_unblacklist[0]),
-                        html.escape(chat_name),
-                    ),
-                    parse_mode=ParseMode.HTML,
-                )
-            else:
-                await send_message(
-                    update.effective_message,
-                    "This sticker is not on the blacklist...!",
-                )
-
-        elif successful == len(to_unblacklist):
-            await send_message(
-                update.effective_message,
-                "Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!".format(
-                    successful,
-                    html.escape(chat_name),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-
-        elif not successful:
-            await send_message(
-                update.effective_message,
-                "None of these stickers exist, so they cannot be removed.",
-                parse_mode=ParseMode.HTML,
-            )
-
-        else:
-            await send_message(
-                update.effective_message,
-                "Sticker <code>{}</code> deleted from blacklist. {} did not exist, so it's not deleted.".format(
-                    successful,
-                    len(to_unblacklist) - successful,
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-    elif msg.reply_to_message:
-        trigger = msg.reply_to_message.sticker.set_name
-        if trigger is None:
-            await send_message(
-                update.effective_message,
-                "Sticker is invalid!",
-            )
-            return
-        success = sql.rm_from_stickers(chat_id, trigger.lower())
-
-        if success:
-            await send_message(
-                update.effective_message,
-                "Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!".format(
-                    trigger,
-                    chat_name,
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-        else:
-            await send_message(
-                update.effective_message,
-                "{} not found on blacklisted stickers...!".format(trigger),
-            )
-    else:
-        await send_message(
-            update.effective_message,
-            "Tell me what stickers you want to add to the blacklist.",
-        )
-
-
-@loggable
-@check_admin(is_user=True)
-async def blacklist_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat  # type: Optional[Chat]
-    user = update.effective_user  # type: Optional[User]
-    msg = update.effective_message  # type: Optional[Message]
-    bot, args = context.bot, context.args
-    conn = await connected(bot, update, chat, user.id, need_admin=True)
-    if conn:
-        chat = await dispatcher.bot.getChat(conn)
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if update.effective_message.chat.type == "private":
-            await send_message(
-                update.effective_message,
-                "You can do this command in groups, not PM",
-            )
-            return ""
-        chat = update.effective_chat
-        chat_id = update.effective_chat.id
-        chat_name = update.effective_message.chat.title
-
-    if args:
-        if args[0].lower() in ["off", "nothing", "no"]:
-            settypeblacklist = "turn off"
-            sql.set_blacklist_strength(chat_id, 0, "0")
-        elif args[0].lower() in ["del", "delete"]:
-            settypeblacklist = "left, the message will be deleted"
-            sql.set_blacklist_strength(chat_id, 1, "0")
-        elif args[0].lower() == "warn":
-            settypeblacklist = "warned"
-            sql.set_blacklist_strength(chat_id, 2, "0")
-        elif args[0].lower() == "mute":
-            settypeblacklist = "muted"
-            sql.set_blacklist_strength(chat_id, 3, "0")
-        elif args[0].lower() == "kick":
-            settypeblacklist = "kicked"
-            sql.set_blacklist_strength(chat_id, 4, "0")
-        elif args[0].lower() == "ban":
-            settypeblacklist = "banned"
-            sql.set_blacklist_strength(chat_id, 5, "0")
-        elif args[0].lower() == "tban":
-            if len(args) == 1:
-                teks = """It looks like you are trying to set a temporary value to blacklist, but has not determined the time; use `/blstickermode tban <timevalue>`.
-                                          Examples of time values: 4m = 4 minute, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message,
-                    teks,
-                    parse_mode="markdown",
-                )
-                return
-            settypeblacklist = "temporary banned for {}".format(args[1])
-            sql.set_blacklist_strength(chat_id, 6, str(args[1]))
-        elif args[0].lower() == "tmute":
-            if len(args) == 1:
-                teks = """It looks like you are trying to set a temporary value to blacklist, but has not determined the time; use `/blstickermode tmute <timevalue>`.
-                                          Examples of time values: 4m = 4 minute, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message,
-                    teks,
-                    parse_mode="markdown",
-                )
-                return
-            settypeblacklist = "temporary muted for {}".format(args[1])
-            sql.set_blacklist_strength(chat_id, 7, str(args[1]))
-        else:
-            await send_message(
-                update.effective_message,
-                "I only understand off/del/warn/ban/kick/mute/tban/tmute!",
-            )
-            return
-        if conn:
-            text = "Blacklist sticker mode changed, users will be `{}` at *{}*!".format(
-                settypeblacklist,
-                chat_name,
-            )
-        else:
-            text = "Blacklist sticker mode changed, users will be `{}`!".format(
-                settypeblacklist,
-            )
-        await send_message(
-            update.effective_message,
-            text,
-            parse_mode="markdown",
-        )
-        return (
-            "<b>{}:</b>\n"
-            "<b>Admin:</b> {}\n"
-            "Changed sticker blacklist mode. users will be {}.".format(
-                html.escape(chat.title),
-                mention_html(user.id, html.escape(user.first_name)),
-                settypeblacklist,
-            )
-        )
-    else:
-        getmode, getvalue = sql.get_blacklist_setting(chat.id)
-        if getmode == 0:
-            settypeblacklist = "not active"
-        elif getmode == 1:
-            settypeblacklist = "delete"
-        elif getmode == 2:
-            settypeblacklist = "warn"
-        elif getmode == 3:
-            settypeblacklist = "mute"
-        elif getmode == 4:
-            settypeblacklist = "kick"
-        elif getmode == 5:
-            settypeblacklist = "ban"
-        elif getmode == 6:
-            settypeblacklist = "temporarily banned for {}".format(getvalue)
-        elif getmode == 7:
-            settypeblacklist = "temporarily muted for {}".format(getvalue)
-        if conn:
-            text = "Blacklist sticker mode is currently set to *{}* in *{}*.".format(
-                settypeblacklist,
-                chat_name,
-            )
-        else:
-            text = "Blacklist sticker mode is currently set to *{}*.".format(
-                settypeblacklist,
-            )
-        await send_message(
-            update.effective_message,
-            text,
-            parse_mode=ParseMode.MARKDOWN,
-        )
-    return ""
-
-
-@user_not_admin
-async def del_blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    chat = update.effective_chat  # type: Optional[Chat]
-    message = update.effective_message  # type: Optional[Message]
-    user = update.effective_user
-    to_match = message.sticker
-    if not to_match or not to_match.set_name:
-        return
-    bot = context.bot
-    getmode, value = sql.get_blacklist_setting(chat.id)
-
-    chat_filters = sql.get_chat_stickers(chat.id)
-    for trigger in chat_filters:
-        if to_match.set_name.lower() == trigger.lower():
-            try:
-                if getmode == 0:
-                    return
-                elif getmode == 1:
-                    await message.delete()
-                elif getmode == 2:
-                    await message.delete()
-                    warn(
-                        update.effective_user,
-                        chat,
-                        "Using sticker '{}' which in blacklist stickers".format(
-                            trigger,
-                        ),
-                        message,
-                        update.effective_user,
-                        # conn=False,
-                    )
-                    return
-                elif getmode == 3:
-                    await message.delete()
-                    await bot.restrict_chat_member(
-                        chat.id,
-                        update.effective_user.id,
-                        permissions=ChatPermissions(can_send_messages=False),
-                    )
-                    await bot.sendMessage(
-                        chat.id,
-                        "{} muted because using '{}' which in blacklist stickers".format(
-                            mention_markdown(user.id, user.first_name),
-                            trigger,
-                        ),
-                        parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-                elif getmode == 4:
-                    await message.delete()
-                    res = chat.unban_member(update.effective_user.id)
-                    if res:
-                        await bot.sendMessage(
-                            chat.id,
-                            "{} kicked because using '{}' which in blacklist stickers".format(
-                                mention_markdown(user.id, user.first_name),
-                                trigger,
-                            ),
-                            parse_mode="markdown",
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
-                        )
-                    return
-                elif getmode == 5:
-                    await message.delete()
-                    await chat.ban_member(user.id)
-                    await bot.sendMessage(
-                        chat.id,
-                        "{} banned because using '{}' which in blacklist stickers".format(
-                            mention_markdown(user.id, user.first_name),
-                            trigger,
-                        ),
-                        parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-                elif getmode == 6:
-                    await message.delete()
-                    bantime = await extract_time(message, value)
-                    await chat.ban_member(user.id, until_date=bantime)
-                    await bot.sendMessage(
-                        chat.id,
-                        "{} banned for {} because using '{}' which in blacklist stickers".format(
-                            mention_markdown(user.id, user.first_name),
-                            value,
-                            trigger,
-                        ),
-                        parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-                elif getmode == 7:
-                    await message.delete()
-                    mutetime = await extract_time(message, value)
-                    await bot.restrict_chat_member(
-                        chat.id,
-                        user.id,
-                        permissions=ChatPermissions(can_send_messages=False),
-                        until_date=mutetime,
-                    )
-                    await bot.sendMessage(
-                        chat.id,
-                        "{} muted for {} because using '{}' which in blacklist stickers".format(
-                            mention_markdown(user.id, user.first_name),
-                            value,
-                            trigger,
-                        ),
-                        parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                    return
-            except BadRequest as excp:
-                if excp.message != "Message to delete not found":
-                    LOGGER.exception("Error while deleting blacklist message.")
-                break
-
-
-async def __import_data__(chat_id, data, message):
-    # set chat blacklist
-    blacklist = data.get("sticker_blacklist", {})
-    for trigger in blacklist:
-        sql.add_to_stickers(chat_id, trigger)
-
-
-def __migrate__(old_chat_id, new_chat_id):
-    sql.migrate_chat(old_chat_id, new_chat_id)
-
-
-def __chat_settings__(chat_id, user_id):
-    blacklisted = sql.num_stickers_chat_filters(chat_id)
-    return "There are `{} `blacklisted stickers.".format(blacklisted)
-
-
-def __stats__():
-    return "• {} blacklist stickers, across {} chats.".format(
-        sql.num_stickers_filters(),
-        sql.num_stickers_filter_chats(),
-    )
-
-
-__mod_name__ = "Stickers Blacklist"
-
-# <================================================ HANDLER =======================================================>
-BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler(
-    "blsticker", blackliststicker, admin_ok=True, block=False
-)
-ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler(
-    "addblsticker", add_blackliststicker, block=False
-)
-UNBLACKLIST_STICKER_HANDLER = CommandHandler(
-    ["unblsticker", "rmblsticker"], unblackliststicker, block=False
-)
-BLACKLISTMODE_HANDLER = CommandHandler("blstickermode", blacklist_mode, block=False)
-BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(
-    filters.Sticker.ALL & filters.ChatType.GROUPS, del_blackliststicker, block=False
-)
-
-dispatcher.add_handler(BLACKLIST_STICKER_HANDLER)
-dispatcher.add_handler(ADDBLACKLIST_STICKER_HANDLER)
-dispatcher.add_handler(UNBLACKLIST_STICKER_HANDLER)
-dispatcher.add_handler(BLACKLISTMODE_HANDLER)
-dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
-# <================================================ END =======================================================>

Mikobot/plugins/botadmins.py

@@ -1,108 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# PROVIDED BY https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-
-from telegram import Update
-from telegram.constants import ParseMode
-from telegram.error import TelegramError
-from telegram.ext import CommandHandler, ContextTypes
-
-from Mikobot import DEMONS, DEV_USERS, DRAGONS, LOGGER, OWNER_ID, WOLVES, function
-from Mikobot.plugins.helper_funcs.chat_status import support_plus
-from Mikobot.utils.parser import mention_html
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def get_chat_member(context: ContextTypes.DEFAULT_TYPE, user_id):
-    try:
-        return await context.bot.get_chat_member(user_id, user_id)
-    except TelegramError as e:
-        LOGGER.error(f"Error getting chat member {user_id}: {e}")
-        return None
-
-
-async def get_user_info(context: ContextTypes.DEFAULT_TYPE, user_id):
-    user_info = await get_chat_member(context, user_id)
-    return user_info.user.first_name if user_info else "Unknown User"
-
-
-async def get_users_info(context: ContextTypes.DEFAULT_TYPE, user_ids):
-    return [(await get_user_info(context, user_id), user_id) for user_id in user_ids]
-
-
-async def get_users_list(context: ContextTypes.DEFAULT_TYPE, user_ids):
-    return [
-        f"• {await mention_html(name, user_id)} (<code>{user_id}</code>)"
-        for name, user_id in await get_users_info(context, user_ids)
-    ]
-
-
-@support_plus
-async def botstaff(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    try:
-        owner = await get_chat_member(context, OWNER_ID)
-        owner_info = await mention_html(owner.user.first_name, owner.user.id)
-        reply = f"✪ <b>CREATOR :</b> {owner_info} (<code>{OWNER_ID}</code>)\n"
-    except TelegramError as e:
-        LOGGER.error(f"Error getting owner information: {e}")
-        reply = ""
-
-    true_dev = list(set(DEV_USERS) - {OWNER_ID})
-    reply += "\n\n➪ <b>SPECIAL GRADE USERS :</b>\n"
-    reply += "\n".join(await get_users_list(context, true_dev)) or "No Dev Users"
-
-    true_sudo = list(set(DRAGONS) - set(DEV_USERS))
-    reply += "\n\n➪ <b>A GRADE USERS :</b>\n"
-    reply += "\n".join(await get_users_list(context, true_sudo)) or "No Sudo Users"
-
-    reply += "\n\n➪ <b>B GRADE USERS :</b>\n"
-    reply += "\n".join(await get_users_list(context, DEMONS)) or "No Demon Users"
-
-    reply += "\n\n➪ <b>NORMAL GRADE USERS :</b>\n"
-    reply += (
-        "\n".join(await get_users_list(context, WOLVES))
-        or "No additional whitelisted users"
-    )
-
-    await update.message.reply_text(reply, parse_mode=ParseMode.HTML)
-    LOGGER.info(
-        f"{update.message.from_user.id} fetched botstaff in {update.message.chat.id}"
-    )
-
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("botadmins", botstaff, block=False))
-# <================================================ END =======================================================>
-
-
-# <=================================================== HELP ====================================================>
-__help__ = """
-➠ *BOT ADMINS ONLY:*
-
-» /stats: Shows bot stats.
-
-» /ping: see ping.
-
-» /gban: Global ban.
-
-» /gbanlist: Shows gban list.
-
-» /botadmins: Opens Bot admin lists.
-
-» /gcast: Advance broadcast system. Just reply to any message.
-
-➠ *Write with text message*
-
-» /broadcastall
-
-» /broadcastusers
-
-» /broadcastgroups
-"""
-
-__mod_name__ = "BOT-ADMIN"
-# <================================================ HANDLER =======================================================>

Mikobot/plugins/chatbot.py

@@ -1,188 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import asyncio
-import html
-import json
-import re
-from typing import Optional
-
-import requests
-from telegram import (
-    CallbackQuery,
-    Chat,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Update,
-    User,
-)
-from telegram.constants import ParseMode
-from telegram.error import BadRequest, Forbidden, RetryAfter
-from telegram.ext import (
-    CallbackQueryHandler,
-    CommandHandler,
-    ContextTypes,
-    MessageHandler,
-    filters,
-)
-from telegram.helpers import mention_html
-
-import Database.sql.kuki_sql as sql
-from Mikobot import function
-from Mikobot.plugins.log_channel import gloggable
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-@gloggable
-async def kukirm(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query: Optional[CallbackQuery] = update.callback_query
-    user: Optional[User] = update.effective_user
-    if match := re.match(r"rm_chat\((.+?)\)", query.data):
-        user_id = match[1]
-        chat: Optional[Chat] = update.effective_chat
-        if is_kuki := sql.rem_kuki(chat.id):
-            sql.rem_kuki(user_id)
-            return (
-                f"<b>{html.escape(chat.title)}:</b>\n"
-                f"AI_DISABLED\n"
-                f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
-            )
-        else:
-            await update.effective_message.edit_text(
-                f"Chatbot disable by {mention_html(user.id, user.first_name)}.",
-                parse_mode=ParseMode.HTML,
-            )
-
-    return ""
-
-
-@gloggable
-async def kukiadd(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query: Optional[CallbackQuery] = update.callback_query
-    user: Optional[User] = update.effective_user
-    if match := re.match(r"add_chat\((.+?)\)", query.data):
-        user_id = match[1]
-        chat: Optional[Chat] = update.effective_chat
-        if is_kuki := sql.set_kuki(chat.id):
-            sql.set_kuki(user_id)
-            return (
-                f"<b>{html.escape(chat.title)}:</b>\n"
-                f"AI_ENABLE\n"
-                f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
-            )
-        else:
-            await update.effective_message.edit_text(
-                f"Hey Darling Chatbot enable by {mention_html(user.id, user.first_name)}.",
-                parse_mode=ParseMode.HTML,
-            )
-
-    return ""
-
-
-@gloggable
-async def kuki(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    update.effective_user
-    message = update.effective_message
-    msg = "Choose an option"
-    keyboard = InlineKeyboardMarkup(
-        [
-            [InlineKeyboardButton(text="Enable", callback_data="add_chat({})")],
-            [InlineKeyboardButton(text="Disable", callback_data="rm_chat({})")],
-        ]
-    )
-    await message.reply_text(
-        msg,
-        reply_markup=keyboard,
-        parse_mode=ParseMode.HTML,
-    )
-
-
-async def kuki_message(context: ContextTypes.DEFAULT_TYPE, message):
-    reply_message = message.reply_to_message
-    if message.text.lower() == "kuki":
-        return True
-    if reply_message:
-        if reply_message.from_user.id == (await context.bot.get_me()).id:
-            return True
-    else:
-        return False
-
-
-async def chatbot(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    update.effective_user
-    message = update.effective_message
-    chat_id = update.effective_chat.id
-    bot = context.bot
-    is_kuki = sql.is_kuki(chat_id)
-    if not is_kuki:
-        return
-
-    if message.text and not message.document:
-        if not await kuki_message(context, message):
-            return
-        Message = message.text
-        await bot.send_chat_action(chat_id, action="typing")
-        kukiurl = requests.get(
-            f"http://api.brainshop.ai/get?bid=176809&key=lbMN8CXTGzhn1NKG&uid=[user]&msg={Message}"
-        )
-
-        Kuki = json.loads(kukiurl.text)
-        kuki = Kuki["cnt"]
-
-        await asyncio.sleep(0.3)
-        await message.reply_text(kuki)
-
-
-async def list_all_chats(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chats = sql.get_all_kuki_chats()
-    text = "<b>Neko Enabled Chats</b>\n"
-    for chat in chats:
-        try:
-            x = await context.bot.get_chat(int(*chat))
-            name = x.title or x.first_name
-            text += f"• <code>{name}</code>\n"
-        except (BadRequest, Forbidden):
-            sql.rem_kuki(*chat)
-        except RetryAfter as e:
-            await asyncio.sleep(e.retry_after)
-    await update.effective_message.reply_text(text, parse_mode="HTML")
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-➠ *Admins only command*:
-
-» /chatbot: shows chatbot panel.
-"""
-
-__mod_name__ = "CHATBOT"
-
-
-# <================================================ HANDLER =======================================================>
-CHATBOTK_HANDLER = CommandHandler("chatbot", kuki, block=False)
-ADD_CHAT_HANDLER = CallbackQueryHandler(kukiadd, pattern=r"add_chat", block=False)
-RM_CHAT_HANDLER = CallbackQueryHandler(kukirm, pattern=r"rm_chat", block=False)
-CHATBOT_HANDLER = MessageHandler(
-    filters.TEXT
-    & (~filters.Regex(r"^#[^\s]+") & ~filters.Regex(r"^!") & ~filters.Regex(r"^\/")),
-    chatbot,
-    block=False,
-)
-LIST_ALL_CHATS_HANDLER = CommandHandler("allchats", list_all_chats, block=False)
-
-function(ADD_CHAT_HANDLER)
-function(CHATBOTK_HANDLER)
-function(RM_CHAT_HANDLER)
-function(LIST_ALL_CHATS_HANDLER)
-function(CHATBOT_HANDLER)
-
-__handlers__ = [
-    ADD_CHAT_HANDLER,
-    CHATBOTK_HANDLER,
-    RM_CHAT_HANDLER,
-    LIST_ALL_CHATS_HANDLER,
-    CHATBOT_HANDLER,
-]
-# <================================================ END =======================================================>

Mikobot/plugins/connection.py

@@ -1,441 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import re
-import time
-
-from telegram import Bot, InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.constants import ParseMode
-from telegram.error import BadRequest, Forbidden
-from telegram.ext import CallbackQueryHandler, CommandHandler, ContextTypes
-
-import Database.sql.connection_sql as sql
-from Mikobot import DEV_USERS, DRAGONS, dispatcher, function
-from Mikobot.plugins.helper_funcs import chat_status
-from Mikobot.plugins.helper_funcs.alternate import send_message, typing_action
-
-# <=======================================================================================================>
-
-check_admin = chat_status.check_admin
-
-
-# <================================================ FUNCTION =======================================================>
-@check_admin(is_user=True)
-@typing_action
-async def allow_connections(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    args = context.args
-
-    if chat.type != chat.PRIVATE:
-        if len(args) >= 1:
-            var = args[0]
-            if var == "no":
-                sql.set_allow_connect_to_chat(chat.id, False)
-                await send_message(
-                    update.effective_message,
-                    "Connection has been disabled for this chat.",
-                )
-            elif var == "yes":
-                sql.set_allow_connect_to_chat(chat.id, True)
-                await send_message(
-                    update.effective_message,
-                    "Connection has been enabled for this chat.",
-                )
-            else:
-                await send_message(
-                    update.effective_message,
-                    "Please enter 'yes' or 'no'!",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-        else:
-            get_settings = sql.allow_connect_to_chat(chat.id)
-            if get_settings:
-                await send_message(
-                    update.effective_message,
-                    "Connections to this group are *allowed* for members!",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-            else:
-                await send_message(
-                    update.effective_message,
-                    "Connection to this group is *not allowed* for members!",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-    else:
-        await send_message(
-            update.effective_message,
-            "This command is for groups only, not in PM!",
-        )
-
-
-@typing_action
-async def connection_chat(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-
-    conn = await connected(context.bot, update, chat, user.id, need_admin=True)
-
-    if conn:
-        chat = await dispatcher.bot.getChat(conn)
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if update.effective_message.chat.type != "private":
-            return
-        chat = update.effective_chat
-        chat_name = update.effective_message.chat.title
-
-    if conn:
-        message = "You are currently connected to {}.\n".format(chat_name)
-    else:
-        message = "You are currently not connected in any group.\n"
-    await send_message(update.effective_message, message, parse_mode="markdown")
-
-
-@typing_action
-async def connect_chat(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    args = context.args
-
-    if update.effective_chat.type == "private":
-        if args and len(args) >= 1:
-            try:
-                connect_chat = int(args[0])
-                getstatusadmin = await context.bot.get_chat_member(
-                    connect_chat,
-                    update.effective_message.from_user.id,
-                )
-            except ValueError:
-                try:
-                    connect_chat = str(args[0])
-                    get_chat = await context.bot.getChat(connect_chat)
-                    connect_chat = get_chat.id
-                    getstatusadmin = await context.bot.get_chat_member(
-                        connect_chat,
-                        update.effective_message.from_user.id,
-                    )
-                except BadRequest:
-                    await send_message(update.effective_message, "Invalid Chat ID!")
-                    return
-            except BadRequest:
-                await send_message(update.effective_message, "Invalid Chat ID!")
-                return
-
-            isadmin = getstatusadmin.status in ("administrator", "creator")
-            ismember = getstatusadmin.status in ("member")
-            isallow = sql.allow_connect_to_chat(connect_chat)
-
-            if (isadmin) or (isallow and ismember) or (user.id in DRAGONS):
-                connection_status = sql.connect(
-                    update.effective_message.from_user.id,
-                    connect_chat,
-                )
-                if connection_status:
-                    conn = await connected(
-                        context.bot, update, chat, user.id, need_admin=False
-                    )
-                    conn_chat = await dispatcher.bot.getChat(conn)
-                    chat_name = conn_chat.title
-                    await send_message(
-                        update.effective_message,
-                        "Successfully connected to *{}*. Use /helpconnect to check available commands.".format(
-                            chat_name,
-                        ),
-                        parse_mode=ParseMode.MARKDOWN,
-                    )
-                    sql.add_history_conn(user.id, str(conn_chat.id), chat_name)
-                else:
-                    await send_message(update.effective_message, "Connection failed!")
-            else:
-                await send_message(
-                    update.effective_message,
-                    "Connection to this chat is not allowed!",
-                )
-        else:
-            gethistory = sql.get_history_conn(user.id)
-            if gethistory:
-                buttons = [
-                    InlineKeyboardButton(
-                        text="❎ Close Button",
-                        callback_data="connect_close",
-                    ),
-                    InlineKeyboardButton(
-                        text="🧹 Clear History",
-                        callback_data="connect_clear",
-                    ),
-                ]
-            else:
-                buttons = []
-            conn = await connected(context.bot, update, chat, user.id, need_admin=False)
-            if conn:
-                connectedchat = await dispatcher.bot.getChat(conn)
-                text = "You are currently connected to *{}* (`{}`)".format(
-                    connectedchat.title,
-                    conn,
-                )
-                buttons.append(
-                    InlineKeyboardButton(
-                        text="🔌 Disconnect",
-                        callback_data="connect_disconnect",
-                    ),
-                )
-            else:
-                text = "Write the chat ID or tag to connect!"
-            if gethistory:
-                text += "\n\n*Connection History:*\n"
-                text += "╒═══「 *Info* 」\n"
-                text += "│  Sorted: `Newest`\n"
-                text += "│\n"
-                buttons = [buttons]
-                for x in sorted(gethistory.keys(), reverse=True):
-                    htime = time.strftime("%d/%m/%Y", time.localtime(x))
-                    text += "╞═「 *{}* 」\n│   `{}`\n│   `{}`\n".format(
-                        gethistory[x]["chat_name"],
-                        gethistory[x]["chat_id"],
-                        htime,
-                    )
-                    text += "│\n"
-                    buttons.append(
-                        [
-                            InlineKeyboardButton(
-                                text=gethistory[x]["chat_name"],
-                                callback_data="connect({})".format(
-                                    gethistory[x]["chat_id"],
-                                ),
-                            ),
-                        ],
-                    )
-                text += "╘══「 Total {} Chats 」".format(
-                    str(len(gethistory)) + " (max)"
-                    if len(gethistory) == 5
-                    else str(len(gethistory)),
-                )
-                conn_hist = InlineKeyboardMarkup(buttons)
-            elif buttons:
-                conn_hist = InlineKeyboardMarkup([buttons])
-            else:
-                conn_hist = None
-            await send_message(
-                update.effective_message,
-                text,
-                parse_mode="markdown",
-                reply_markup=conn_hist,
-            )
-
-    else:
-        getstatusadmin = await context.bot.get_chat_member(
-            chat.id,
-            update.effective_message.from_user.id,
-        )
-        isadmin = getstatusadmin.status in ("administrator", "creator")
-        ismember = getstatusadmin.status in ("member")
-        isallow = sql.allow_connect_to_chat(chat.id)
-        if (isadmin) or (isallow and ismember) or (user.id in DRAGONS):
-            connection_status = sql.connect(
-                update.effective_message.from_user.id,
-                chat.id,
-            )
-            if connection_status:
-                chat_obj = await dispatcher.bot.getChat(chat.id)
-                chat_name = chat_obj.title
-                await send_message(
-                    update.effective_message,
-                    "Successfully connected to *{}*.".format(chat_name),
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-                try:
-                    sql.add_history_conn(user.id, str(chat.id), chat_name)
-                    await context.bot.send_message(
-                        update.effective_message.from_user.id,
-                        "You are connected to *{}*. \nUse `/helpconnect` to check available commands.".format(
-                            chat_name,
-                        ),
-                        parse_mode="markdown",
-                    )
-                except BadRequest:
-                    pass
-                except Forbidden:
-                    pass
-            else:
-                await send_message(update.effective_message, "ᴄᴏɴɴᴇᴄᴛɪᴏɴ ғᴀɪʟᴇᴅ!")
-        else:
-            await send_message(
-                update.effective_message,
-                "Connection to this chat is not allowed!",
-            )
-
-
-async def disconnect_chat(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    if update.effective_chat.type == "private":
-        disconnection_status = sql.disconnect(update.effective_message.from_user.id)
-        if disconnection_status:
-            sql.disconnected_chat = await send_message(
-                update.effective_message,
-                "Disconnected from chat!",
-            )
-        else:
-            await send_message(update.effective_message, "You're not connected!")
-    else:
-        await send_message(
-            update.effective_message, "This command is only available in PM."
-        )
-
-
-async def connected(bot: Bot, update: Update, chat, user_id, need_admin=True):
-    user = update.effective_user
-
-    if chat.type == chat.PRIVATE and sql.get_connected_chat(user_id):
-        conn_id = sql.get_connected_chat(user_id).chat_id
-        getstatusadmin = await bot.get_chat_member(
-            conn_id,
-            update.effective_message.from_user.id,
-        )
-        isadmin = getstatusadmin.status in ("administrator", "creator")
-        ismember = getstatusadmin.status in ("member")
-        isallow = sql.allow_connect_to_chat(conn_id)
-
-        if (
-            (isadmin)
-            or (isallow and ismember)
-            or (user.id in DRAGONS)
-            or (user.id in DEV_USERS)
-        ):
-            if need_admin is True:
-                if (
-                    getstatusadmin.status in ("administrator", "creator")
-                    or user_id in DRAGONS
-                    or user.id in DEV_USERS
-                ):
-                    return conn_id
-                else:
-                    await send_message(
-                        update.effective_message,
-                        "You must be an admin in the connected group!",
-                    )
-            else:
-                return conn_id
-        else:
-            await send_message(
-                update.effective_message,
-                "The group changed the connection rights or you are no longer an admin.\nI've disconnected you.",
-            )
-            disconnect_chat(update, bot)
-    else:
-        return False
-
-
-CONN_HELP = """
-Actions are available with connected groups:
- • View and edit Notes.
- • View and edit Filters.
- • Get invite link of chat.
- • Set and control AntiFlood settings.
- • Set and control Blacklist settings.
- • Set Locks and Unlocks in chat.
- • Enable and Disable commands in chat.
- • Export and Imports of chat backup.
- """
-
-
-async def help_connect_chat(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    context.args
-
-    if update.effective_message.chat.type != "private":
-        await send_message(
-            update.effective_message, "PM me with that command to get help."
-        )
-        return
-    else:
-        await send_message(update.effective_message, CONN_HELP, parse_mode="markdown")
-
-
-async def connect_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    chat = update.effective_chat
-    user = update.effective_user
-
-    connect_match = re.match(r"connect\((.+?)\)", query.data)
-    disconnect_match = query.data == "connect_disconnect"
-    clear_match = query.data == "connect_clear"
-    connect_close = query.data == "connect_close"
-
-    if connect_match:
-        target_chat = connect_match.group(1)
-        getstatusadmin = await context.bot.get_chat_member(
-            target_chat, query.from_user.id
-        )
-        isadmin = getstatusadmin.status in ("administrator", "creator")
-        ismember = getstatusadmin.status in ("member")
-        isallow = sql.allow_connect_to_chat(target_chat)
-
-        if (isadmin) or (isallow and ismember) or (user.id in DRAGONS):
-            connection_status = sql.connect(query.from_user.id, target_chat)
-
-            if connection_status:
-                conn = await connected(
-                    context.bot, update, chat, user.id, need_admin=False
-                )
-                conn_chat = await dispatcher.bot.getChat(conn)
-                chat_name = conn_chat.title
-                await query.message.edit_text(
-                    "Successfully connected to *{}*. Use `/helpconnect` to check available commands.".format(
-                        chat_name,
-                    ),
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-                sql.add_history_conn(user.id, str(conn_chat.id), chat_name)
-            else:
-                await query.message.edit_text("Connection failed!")
-        else:
-            await context.bot.answer_callback_query(
-                query.id,
-                "Connection to this chat is not allowed!",
-                show_alert=True,
-            )
-    elif disconnect_match:
-        disconnection_status = sql.disconnect(query.from_user.id)
-        if disconnection_status:
-            sql.disconnected_chat = await query.message.edit_text(
-                "Disconnected from chat!"
-            )
-        else:
-            await context.bot.answer_callback_query(
-                query.id,
-                "You're not connected!",
-                show_alert=True,
-            )
-    elif clear_match:
-        sql.clear_history_conn(query.from_user.id)
-        await query.message.edit_text("History connected has been cleared!")
-    elif connect_close:
-        await query.message.edit_text("Closed. To open again, type /connect")
-    else:
-        connect_chat(update, context)
-
-
-# <=================================================== HELP ====================================================>
-__mod_name__ = "CONNECT"
-
-__help__ = """
-➠ *Sometimes, you just want to add some notes and filters to a group chat, but you don't want everyone to see; this is where connections come in. This allows you to connect to a chat's database and add things to it without the commands appearing in chat! For obvious reasons, you need to be an admin to add things, but any member in the group can view your data.*
-
-» /connect: Connects to chat (can be done in a group by /connect or /connect <chat id> in PM)
-
-» /connection: List connected chats
-
-» /disconnect: Disconnect from a chat
-
-» /helpconnect: List available commands that can be used remotely
-
-➠ *Admin Only:*
-
-» /allowconnect <yes/no>: Allow a user to connect to a chat
-"""
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("connect", connect_chat, block=False))
-function(CommandHandler("connection", connection_chat, block=False))
-function(CommandHandler("disconnect", disconnect_chat, block=False))
-function(CommandHandler("allowconnect", allow_connections, block=False))
-function(CommandHandler("helpconnect", help_connect_chat, block=False))
-function(CallbackQueryHandler(connect_button, pattern=r"connect", block=False))
-# <================================================ END =======================================================>

Mikobot/plugins/cosplay.py

@@ -1,37 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# API BY https://www.github.com/SOME-1HING
-# PROVIDED BY https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-from telegram import Update
-from telegram.ext import CommandHandler, ContextTypes
-
-from Mikobot import function
-from Mikobot.state import state
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTIONS =====================================================>
-async def get_cosplay_data():
-    cosplay_url = "https://sugoi-api.vercel.app/cosplay"
-    response = await state.get(cosplay_url)
-    return response.json()
-
-
-async def cosplay(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    try:
-        data = await get_cosplay_data()
-        photo_url = data.get("url")  # Corrected key: "url" instead of "cosplay_url"
-        if photo_url:
-            await update.message.reply_photo(photo=photo_url)
-        else:
-            await update.message.reply_text("Could not fetch photo URL.")
-    except state.FetchError:
-        await update.message.reply_text("Unable to fetch data.")
-
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("cosplay", cosplay, block=False))
-# <================================================ END =======================================================>

Mikobot/plugins/couple.py

@@ -1,124 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import random
-from datetime import datetime
-
-from pyrogram import filters
-
-from Database.mongodb.karma_mongo import get_couple, save_couple
-from Mikobot import app
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-def dt():
-    now = datetime.now()
-    dt_string = now.strftime("%d/%m/%Y %H:%M")
-    dt_list = dt_string.split(" ")
-    return dt_list
-
-
-def dt_tom():
-    a = (
-        str(int(dt()[0].split("/")[0]) + 1)
-        + "/"
-        + dt()[0].split("/")[1]
-        + "/"
-        + dt()[0].split("/")[2]
-    )
-    return a
-
-
-tomorrow = str(dt_tom())
-today = str(dt()[0])
-
-COUPLES_PIC = "https://telegra.ph/file/c6d0c884f559b9ed8a54e.jpg"
-C = """
-✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-{} + ( PGM🎀😶 (https://t.me/Chalnayaaaaaarr) + 花火 (https://t.me/zd_sr07) + ゼロツー (https://t.me/wewewe_x) ) = 💞
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {}
-"""
-CAP = """
-✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-{} + {} = 💞
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {}
-"""
-
-CAP2 = """
-✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-{} (tg://openmessage?user_id={}) + {} (tg://openmessage?user_id={}) = 💞\n
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {}
-"""
-
-
-@app.on_message(filters.command(["couple", "couples", "shipping"]) & ~filters.private)
-async def nibba_nibbi(_, message):
-    if message.from_user.id == 5540249238:
-        my_ = await _.get_users("rfxtuv")
-        me = await _.get_users(5540249238)
-        await message.reply_photo(
-            photo=COUPLES_PIC, caption=C.format(me.mention, tomorrow)
-        )
-    else:
-        try:
-            chat_id = message.chat.id
-            is_selected = await get_couple(chat_id, today)
-            if not is_selected:
-                list_of_users = []
-                async for i in _.get_chat_members(message.chat.id, limit=50):
-                    if not i.user.is_bot:
-                        list_of_users.append(i.user.id)
-                if len(list_of_users) < 2:
-                    return await message.reply_text("ɴᴏᴛ ᴇɴᴏᴜɢʜ ᴜsᴇʀs ɪɴ ᴛʜɪs ɢʀᴏᴜᴘ.")
-                c1_id = random.choice(list_of_users)
-                c2_id = random.choice(list_of_users)
-                while c1_id == c2_id:
-                    c1_id = random.choice(list_of_users)
-                c1_mention = (await _.get_users(c1_id)).mention
-                c2_mention = (await _.get_users(c2_id)).mention
-                await _.send_photo(
-                    message.chat.id,
-                    photo=COUPLES_PIC,
-                    caption=CAP.format(c1_mention, c2_mention, tomorrow),
-                )
-
-                couple = {"c1_id": c1_id, "c2_id": c2_id}
-                await save_couple(chat_id, today, couple)
-
-            elif is_selected:
-                c1_id = int(is_selected["c1_id"])
-                c2_id = int(is_selected["c2_id"])
-
-                c1_name = (await _.get_users(c1_id)).first_name
-                c2_name = (await _.get_users(c2_id)).first_name
-                print(c1_id, c2_id, c1_name, c2_name)
-                couple_selection_message = f"""✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-[{c1_name}](tg://openmessage?user_id={c1_id}) + [{c2_name}](tg://openmessage?user_id={c2_id}) = 💞
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {tomorrow}"""
-                await _.send_photo(
-                    message.chat.id, photo=COUPLES_PIC, caption=couple_selection_message
-                )
-        except Exception as e:
-            print(e)
-            await message.reply_text(str(e))
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-💘 *Choose couples in your chat*
-
-» /couple, /couples, /shipping *:* Choose 2 users and send their names as couples in your chat.
-"""
-
-__mod_name__ = "COUPLE"
-# <================================================ END =======================================================>

Mikobot/plugins/cust_filters.py

@@ -1,756 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import random
-import re
-from html import escape
-
-from pyrate_limiter import BucketFullException, Duration, InMemoryBucket, Limiter, Rate
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.constants import ChatMemberStatus, MessageLimit, ParseMode
-from telegram.error import BadRequest
-from telegram.ext import (
-    ApplicationHandlerStop,
-    CallbackQueryHandler,
-    CommandHandler,
-    ContextTypes,
-    MessageHandler,
-)
-from telegram.ext import filters as filters_module
-from telegram.helpers import escape_markdown, mention_html
-
-from Database.sql import cust_filters_sql as sql
-from Mikobot import DEV_USERS, DRAGONS, LOGGER, dispatcher, function
-from Mikobot.plugins.connection import connected
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.alternate import send_message, typing_action
-from Mikobot.plugins.helper_funcs.chat_status import check_admin
-from Mikobot.plugins.helper_funcs.extraction import extract_text
-from Mikobot.plugins.helper_funcs.misc import build_keyboard_parser
-from Mikobot.plugins.helper_funcs.msg_types import get_filter_type
-from Mikobot.plugins.helper_funcs.string_handling import (
-    button_markdown_parser,
-    escape_invalid_curly_brackets,
-    markdown_to_html,
-    split_quotes,
-)
-
-# <=======================================================================================================>
-
-HANDLER_GROUP = 10
-
-ENUM_FUNC_MAP = {
-    sql.Types.TEXT.value: dispatcher.bot.send_message,
-    sql.Types.BUTTON_TEXT.value: dispatcher.bot.send_message,
-    sql.Types.STICKER.value: dispatcher.bot.send_sticker,
-    sql.Types.DOCUMENT.value: dispatcher.bot.send_document,
-    sql.Types.PHOTO.value: dispatcher.bot.send_photo,
-    sql.Types.AUDIO.value: dispatcher.bot.send_audio,
-    sql.Types.VOICE.value: dispatcher.bot.send_voice,
-    sql.Types.VIDEO.value: dispatcher.bot.send_video,
-}
-
-
-class AntiSpam:
-    def __init__(self):
-        self.whitelist = (DEV_USERS or []) + (DRAGONS or [])
-        # Values are HIGHLY experimental, its recommended you pay attention to our commits as we will be adjusting the values over time with what suits best.
-        Duration.CUSTOM = 15  # Custom duration, 15 seconds
-        self.sec_limit = Rate(6, Duration.CUSTOM)  # 6 / Per 15 Seconds
-        self.min_limit = Rate(20, Duration.MINUTE)  # 20 / Per minute
-        self.hour_limit = Rate(100, Duration.HOUR)  # 100 / Per hour
-        self.daily_limit = Rate(1000, Duration.DAY)  # 1000 / Per day
-        self.limiter = Limiter(
-            InMemoryBucket(
-                [self.sec_limit, self.min_limit, self.hour_limit, self.daily_limit]
-            )
-        )
-
-    def check_user(self, user):
-        """
-        Return True if user is to be ignored else False
-        """
-        if user in self.whitelist:
-            return False
-        try:
-            self.limiter.try_acquire(user)
-            return False
-        except BucketFullException:
-            return True
-
-
-MessageHandlerChecker = AntiSpam()
-
-
-# <================================================ FUNCTION =======================================================>
-@typing_action
-async def list_handlers(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-
-    conn = await connected(context.bot, update, chat, user.id, need_admin=False)
-    if not conn is False:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-        filter_list = "*Filter in {}:*\n"
-    else:
-        chat_id = update.effective_chat.id
-        if chat.type == "private":
-            chat_name = "Local filters"
-            filter_list = "*local filters:*\n"
-        else:
-            chat_name = chat.title
-            filter_list = "*Filters in {}*:\n"
-
-    all_handlers = sql.get_chat_triggers(chat_id)
-
-    if not all_handlers:
-        await send_message(
-            update.effective_message,
-            "No filters saved in {}!".format(chat_name),
-        )
-        return
-
-    for keyword in all_handlers:
-        entry = " • `{}`\n".format(escape_markdown(keyword))
-        if len(entry) + len(filter_list) > MessageLimit.MAX_TEXT_LENGTH:
-            await send_message(
-                update.effective_message,
-                filter_list.format(chat_name),
-                parse_mode=ParseMode.MARKDOWN,
-            )
-            filter_list = entry
-        else:
-            filter_list += entry
-
-    await send_message(
-        update.effective_message,
-        filter_list.format(chat_name),
-        parse_mode=ParseMode.MARKDOWN,
-    )
-
-
-@typing_action
-@check_admin(is_user=True)
-async def filters(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-    args = msg.text.split(
-        None, 1
-    )  # use python's maxsplit to separate Cmd, keyword, and reply_text
-
-    buttons = None
-    conn = await connected(context.bot, update, chat, user.id)
-    if not conn is False:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        chat_id = update.effective_chat.id
-        if chat.type == "private":
-            chat_name = "local filters"
-        else:
-            chat_name = chat.title
-
-    if not msg.reply_to_message and len(args) < 2:
-        await send_message(
-            update.effective_message,
-            "Please provide keyboard keyword for this filter to reply with!",
-        )
-        return
-
-    if msg.reply_to_message and not msg.reply_to_message.forum_topic_created:
-        if len(args) < 2:
-            await send_message(
-                update.effective_message,
-                "Please provide keyword for this filter to reply with!",
-            )
-            return
-        else:
-            keyword = args[1]
-    else:
-        extracted = split_quotes(args[1])
-        if len(extracted) < 1:
-            return
-        # set trigger -> lower, so as to avoid adding duplicate filters with different cases
-        keyword = extracted[0].lower()
-
-    # Add the filter
-    # Note: perhaps handlers can be removed somehow using sql.get_chat_filters
-    for handler in dispatcher.handlers.get(HANDLER_GROUP, []):
-        if handler.filters == (keyword, chat_id):
-            dispatcher.remove_handler(handler, HANDLER_GROUP)
-
-    text, file_type, file_id, media_spoiler = get_filter_type(msg)
-    if not msg.reply_to_message and len(extracted) >= 2:
-        offset = len(extracted[1]) - len(
-            msg.text,
-        )  # set correct offset relative to command + notename
-        text, buttons = button_markdown_parser(
-            extracted[1],
-            entities=msg.parse_entities(),
-            offset=offset,
-        )
-        text = text.strip()
-        if not text:
-            await send_message(
-                update.effective_message,
-                "There is no note message - You can't JUST have buttons, you need a message to go with it!",
-            )
-            return
-
-    if len(args) >= 2:
-        if msg.reply_to_message:
-            if msg.reply_to_message.forum_topic_created:
-                offset = len(extracted[1]) - len(msg.text)
-
-                text, buttons = button_markdown_parser(
-                    extracted[1], entities=msg.parse_entities(), offset=offset
-                )
-
-                text = text.strip()
-                if not text:
-                    await send_message(
-                        update.effective_message,
-                        "There is no note message - You can't JUST have buttons, you need a message to go with it!",
-                    )
-                    return
-            else:
-                pass
-
-    elif msg.reply_to_message and len(args) >= 1:
-        if msg.reply_to_message.text:
-            text_to_parsing = msg.reply_to_message.text
-        elif msg.reply_to_message.caption:
-            text_to_parsing = msg.reply_to_message.caption
-        else:
-            text_to_parsing = ""
-        offset = len(
-            text_to_parsing,
-        )  # set correct offset relative to command + notename
-        text, buttons = button_markdown_parser(
-            text_to_parsing,
-            entities=msg.parse_entities(),
-            offset=offset,
-        )
-        text = text.strip()
-
-    elif not text and not file_type:
-        await send_message(
-            update.effective_message,
-            "Please provide keyword for this filter reply with!",
-        )
-        return
-
-    elif msg.reply_to_message:
-        if msg.reply_to_message.forum_topic_created:
-            return
-
-        if msg.reply_to_message.text:
-            text_to_parsing = msg.reply_to_message.text
-        elif msg.reply_to_message.caption:
-            text_to_parsing = msg.reply_to_message.caption
-        else:
-            text_to_parsing = ""
-        offset = len(
-            text_to_parsing,
-        )  # set correct offset relative to command + notename
-        text, buttons = button_markdown_parser(
-            text_to_parsing,
-            entities=msg.parse_entities(),
-            offset=offset,
-        )
-        text = text.strip()
-        if (msg.reply_to_message.text or msg.reply_to_message.caption) and not text:
-            await send_message(
-                update.effective_message,
-                "There is no note message - You can't JUST have buttons, you need a message to go with it!",
-            )
-            return
-
-    else:
-        await send_message(update.effective_message, "Invalid filter!")
-        return
-
-    add = await addnew_filter(
-        update, chat_id, keyword, text, file_type, file_id, buttons, media_spoiler
-    )
-    # This is an old method
-    # sql.add_filter(chat_id, keyword, content, is_sticker, is_document, is_image, is_audio, is_voice, is_video, buttons)
-
-    if add is True:
-        await send_message(
-            update.effective_message,
-            "Saved filter '{}' in *{}*!".format(keyword, chat_name),
-            parse_mode=ParseMode.MARKDOWN,
-        )
-    raise ApplicationHandlerStop
-
-
-@typing_action
-@check_admin(is_user=True)
-async def stop_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    args = update.effective_message.text.split(None, 1)
-
-    conn = await connected(context.bot, update, chat, user.id)
-    if not conn is False:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        chat_id = update.effective_chat.id
-        if chat.type == "private":
-            chat_name = "Local filters"
-        else:
-            chat_name = chat.title
-
-    if len(args) < 2:
-        await send_message(update.effective_message, "What should i stop?")
-        return
-
-    chat_filters = sql.get_chat_triggers(chat_id)
-
-    if not chat_filters:
-        await send_message(update.effective_message, "No filters active here!")
-        return
-
-    for keyword in chat_filters:
-        if keyword == args[1]:
-            sql.remove_filter(chat_id, args[1])
-            await send_message(
-                update.effective_message,
-                "Okay, I'll stop replying to that filter in *{}*.".format(chat_name),
-                parse_mode=ParseMode.MARKDOWN,
-            )
-            raise ApplicationHandlerStop
-
-    await send_message(
-        update.effective_message,
-        "That's not a filter - Click: /filters to get currently active filters.",
-    )
-
-
-async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    message = update.effective_message
-
-    if not update.effective_user or update.effective_user.id == 777000:
-        return
-    to_match = await extract_text(message)
-    if not to_match:
-        return
-
-    chat_filters = sql.get_chat_triggers(chat.id)
-    for keyword in chat_filters:
-        pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
-        if re.search(pattern, to_match, flags=re.IGNORECASE):
-            if MessageHandlerChecker.check_user(update.effective_user.id):
-                return
-            filt = sql.get_filter(chat.id, keyword)
-            if filt.reply == "there is should be a new reply":
-                buttons = sql.get_buttons(chat.id, filt.keyword)
-                keyb = build_keyboard_parser(context.bot, chat.id, buttons)
-                keyboard = InlineKeyboardMarkup(keyb)
-
-                VALID_WELCOME_FORMATTERS = [
-                    "first",
-                    "last",
-                    "fullname",
-                    "username",
-                    "id",
-                    "chatname",
-                    "mention",
-                ]
-                if filt.reply_text:
-                    if "%%%" in filt.reply_text:
-                        split = filt.reply_text.split("%%%")
-                        if all(split):
-                            text = random.choice(split)
-                        else:
-                            text = filt.reply_text
-                    else:
-                        text = filt.reply_text
-                    if text.startswith("~!") and text.endswith("!~"):
-                        sticker_id = text.replace("~!", "").replace("!~", "")
-                        try:
-                            await context.bot.send_sticker(
-                                chat.id,
-                                sticker_id,
-                                reply_to_message_id=message.message_id,
-                                message_thread_id=message.message_thread_id
-                                if chat.is_forum
-                                else None,
-                            )
-                            return
-                        except BadRequest as excp:
-                            if (
-                                excp.message
-                                == "Wrong remote file identifier specified: wrong padding in the string"
-                            ):
-                                await context.bot.send_message(
-                                    chat.id,
-                                    "Message couldn't be sent, Is the sticker id valid?",
-                                    message_thread_id=message.message_thread_id
-                                    if chat.is_forum
-                                    else None,
-                                )
-                                return
-                            else:
-                                LOGGER.exception("Error in filters: " + excp.message)
-                                return
-                    valid_format = escape_invalid_curly_brackets(
-                        text,
-                        VALID_WELCOME_FORMATTERS,
-                    )
-                    if valid_format:
-                        filtext = valid_format.format(
-                            first=escape(message.from_user.first_name),
-                            last=escape(
-                                message.from_user.last_name
-                                or message.from_user.first_name,
-                            ),
-                            fullname=" ".join(
-                                [
-                                    escape(message.from_user.first_name),
-                                    escape(message.from_user.last_name),
-                                ]
-                                if message.from_user.last_name
-                                else [escape(message.from_user.first_name)],
-                            ),
-                            username="@" + escape(message.from_user.username)
-                            if message.from_user.username
-                            else mention_html(
-                                message.from_user.id,
-                                message.from_user.first_name,
-                            ),
-                            mention=mention_html(
-                                message.from_user.id,
-                                message.from_user.first_name,
-                            ),
-                            chatname=escape(message.chat.title)
-                            if message.chat.type != "private"
-                            else escape(message.from_user.first_name),
-                            id=message.from_user.id,
-                        )
-                    else:
-                        filtext = ""
-                else:
-                    filtext = ""
-
-                if filt.file_type in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
-                    try:
-                        await message.reply_text(
-                            markdown_to_html(filtext),
-                            parse_mode=ParseMode.HTML,
-                            disable_web_page_preview=True,
-                            reply_markup=keyboard,
-                        )
-                    except BadRequest as excp:
-                        LOGGER.exception("Error in filters: " + excp.message)
-                        try:
-                            await send_message(
-                                update.effective_message,
-                                get_exception(excp, filt, chat),
-                            )
-                        except BadRequest as excp:
-                            LOGGER.exception(
-                                "Failed to send message: " + excp.message,
-                            )
-                else:
-                    try:
-                        if filt.file_type not in [
-                            sql.Types.PHOTO.value,
-                            sql.Types.VIDEO,
-                        ]:
-                            await ENUM_FUNC_MAP[filt.file_type](
-                                chat.id,
-                                filt.file_id,
-                                reply_markup=keyboard,
-                                reply_to_message_id=message.message_id,
-                                message_thread_id=message.message_thread_id
-                                if chat.is_forum
-                                else None,
-                            )
-                        else:
-                            await ENUM_FUNC_MAP[filt.file_type](
-                                chat.id,
-                                filt.file_id,
-                                reply_markup=keyboard,
-                                caption=filt.reply_text,
-                                reply_to_message_id=message.message_id,
-                                message_thread_id=message.message_thread_id
-                                if chat.is_forum
-                                else None,
-                                has_spoiler=filt.has_media_spoiler,
-                            )
-                    except BadRequest:
-                        await send_message(
-                            message,
-                            "I don't have the permission to send the content of the filter.",
-                        )
-                break
-            else:
-                if filt.is_sticker:
-                    await message.reply_sticker(filt.reply)
-                elif filt.is_document:
-                    await message.reply_document(filt.reply)
-                elif filt.is_image:
-                    await message.reply_photo(
-                        filt.reply, has_spoiler=filt.has_media_spoiler
-                    )
-                elif filt.is_audio:
-                    await message.reply_audio(filt.reply)
-                elif filt.is_voice:
-                    await message.reply_voice(filt.reply)
-                elif filt.is_video:
-                    await message.reply_video(
-                        filt.reply, has_spoiler=filt.has_media_spoiler
-                    )
-                elif filt.has_buttons:
-                    buttons = sql.get_buttons(chat.id, filt.keyword)
-                    keyb = build_keyboard_parser(context.bot, chat.id, buttons)
-                    keyboard = InlineKeyboardMarkup(keyb)
-
-                    try:
-                        await context.bot.send_message(
-                            chat.id,
-                            markdown_to_html(filt.reply),
-                            parse_mode=ParseMode.HTML,
-                            disable_web_page_preview=True,
-                            reply_markup=keyboard,
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
-                        )
-                    except BadRequest as excp:
-                        if excp.message == "Unsupported url protocol":
-                            try:
-                                await send_message(
-                                    update.effective_message,
-                                    "You seem to be trying to use an unsupported url protocol. "
-                                    "Telegram doesn't support buttons for some protocols, such as tg://. Please try "
-                                    "again...",
-                                )
-                            except BadRequest as excp:
-                                LOGGER.exception("Error in filters: " + excp.message)
-                        else:
-                            try:
-                                await send_message(
-                                    update.effective_message,
-                                    "This message couldn't be sent as it's incorrectly formatted.",
-                                )
-                            except BadRequest as excp:
-                                LOGGER.exception("Error in filters: " + excp.message)
-                            LOGGER.warning(
-                                "Message %s could not be parsed",
-                                str(filt.reply),
-                            )
-                            LOGGER.exception(
-                                "Could not parse filter %s in chat %s",
-                                str(filt.keyword),
-                                str(chat.id),
-                            )
-
-                else:
-                    # LEGACY - all new filters will have has_markdown set to True.
-                    try:
-                        await context.bot.send_message(
-                            chat.id,
-                            filt.reply,
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
-                        )
-                    except BadRequest as excp:
-                        LOGGER.exception("Error in filters: " + excp.message)
-                break
-
-
-async def rmall_filters(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    member = await chat.get_member(user.id)
-    if member.status != ChatMemberStatus.OWNER and user.id not in DRAGONS:
-        await update.effective_message.reply_text(
-            "Only the chat owner can clear all notes at once.",
-        )
-    else:
-        buttons = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        text="STOP ALL FILTERS",
-                        callback_data="filters_rmall",
-                    ),
-                ],
-                [InlineKeyboardButton(text="CANCEL", callback_data="filters_cancel")],
-            ],
-        )
-        await update.effective_message.reply_text(
-            f"Are you sure you would like to stop ALL filters in {chat.title}? This action cannot be undone.",
-            reply_markup=buttons,
-            parse_mode=ParseMode.MARKDOWN,
-        )
-
-
-async def rmall_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    chat = update.effective_chat
-    msg = update.effective_message
-    member = await chat.get_member(query.from_user.id)
-    if query.data == "filters_rmall":
-        if member.status == "creator" or query.from_user.id in DRAGONS:
-            allfilters = sql.get_chat_triggers(chat.id)
-            if not allfilters:
-                await msg.edit_text("No filters in this chat, nothing to stop!")
-                return
-
-            count = 0
-            filterlist = []
-            for x in allfilters:
-                count += 1
-                filterlist.append(x)
-
-            for i in filterlist:
-                sql.remove_filter(chat.id, i)
-
-            await msg.edit_text(f"Cleaned {count} filters in {chat.title}")
-
-        if member.status == "administrator":
-            await query.answer("Only owner of the chat can do this.")
-
-        if member.status == "member":
-            await query.answer("You need to be admin to do this.")
-    elif query.data == "filters_cancel":
-        if member.status == "creator" or query.from_user.id in DRAGONS:
-            await msg.edit_text("Clearing of all filters has been cancelled.")
-            return await query.answer()
-        if member.status == "administrator":
-            await query.answer("Only owner of the chat can do this.")
-        if member.status == "member":
-            await query.answer("You need to be admin to do this.")
-
-
-# NOT ASYNC NOT A HANDLER
-def get_exception(excp, filt, chat):
-    if excp.message == "Unsupported url protocol":
-        return "You seem to be trying to use the URL protocol which is not supported. Telegram does not support key for multiple protocols, such as tg: //. Please try again!"
-    elif excp.message == "Reply message not found":
-        return "noreply"
-    else:
-        LOGGER.warning("Message %s could not be parsed", str(filt.reply))
-        LOGGER.exception(
-            "Could not parse filter %s in chat %s",
-            str(filt.keyword),
-            str(chat.id),
-        )
-        return "This data could not be sent because it is incorrectly formatted."
-
-
-# NOT ASYNC NOT A HANDLER
-async def addnew_filter(
-    update, chat_id, keyword, text, file_type, file_id, buttons, has_spoiler
-):
-    msg = update.effective_message
-    totalfilt = sql.get_chat_triggers(chat_id)
-    if len(totalfilt) >= 150:  # Idk why i made this like function....
-        await msg.reply_text("This group has reached its max filters limit of 150.")
-        return False
-    else:
-        sql.new_add_filter(
-            chat_id, keyword, text, file_type, file_id, buttons, has_spoiler
-        )
-        return True
-
-
-def __stats__():
-    return "• {} filters, across {} chats.".format(sql.num_filters(), sql.num_chats())
-
-
-async def __import_data__(chat_id, data, message):
-    # set chat filters
-    filters = data.get("filters", {})
-    for trigger in filters:
-        sql.add_to_blacklist(chat_id, trigger)
-
-
-def __migrate__(old_chat_id, new_chat_id):
-    sql.migrate_chat(old_chat_id, new_chat_id)
-
-
-def __chat_settings__(chat_id, user_id):
-    cust_filters = sql.get_chat_triggers(chat_id)
-    return "There are `{}` custom filters here.".format(len(cust_filters))
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-» `/filters`*:* List all active filters saved in the chat.
-
-➠ *Admin only:*
-
-» `/filter <keyword> <reply message>`*:* Add a filter to this chat. The bot will now reply that message whenever 'keyword'\
-is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker. NOTE: all filter \
-keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \
-doin?
-
-➠ Separate diff replies by `%%%` to get random replies
-➠ *Example:*
-
-» `/filter "filtername"
- Reply 1
- %%%
- Reply 2
- %%%
- Reply 3`
-
-» `/stop <filter keyword>`*:* Stop that filter.
-
-➠ *Chat creator only:*
-» `/removeallfilters`*:* Remove all chat filters at once.
-
-➠ *Note*: Filters also support markdown formatters like: {first}, {last} etc.. and buttons.
-➠ Now Supports media spoilers too, and media caption.
-"""
-
-__mod_name__ = "FILTERS"
-
-# <================================================ HANDLER =======================================================>
-FILTER_HANDLER = CommandHandler("filter", filters, block=False)
-STOP_HANDLER = CommandHandler("stop", stop_filter, block=False)
-RMALLFILTER_HANDLER = CommandHandler(
-    "removeallfilters",
-    rmall_filters,
-    filters=filters_module.ChatType.GROUPS,
-    block=False,
-)
-RMALLFILTER_CALLBACK = CallbackQueryHandler(
-    rmall_callback, pattern=r"filters_.*", block=False
-)
-LIST_HANDLER = DisableAbleCommandHandler(
-    "filters", list_handlers, admin_ok=True, block=False
-)
-CUST_FILTER_HANDLER = MessageHandler(
-    filters_module.TEXT & ~filters_module.UpdateType.EDITED_MESSAGE,
-    reply_filter,
-    block=False,
-)
-
-function(FILTER_HANDLER)
-function(STOP_HANDLER)
-function(LIST_HANDLER)
-function(CUST_FILTER_HANDLER, HANDLER_GROUP)
-function(RMALLFILTER_HANDLER)
-function(RMALLFILTER_CALLBACK)
-
-__handlers__ = [
-    FILTER_HANDLER,
-    STOP_HANDLER,
-    LIST_HANDLER,
-    (CUST_FILTER_HANDLER, HANDLER_GROUP, RMALLFILTER_HANDLER),
-]
-# <================================================ END =======================================================>

Mikobot/plugins/disable.py

@@ -1,376 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import importlib
-import re
-from typing import Dict, List, Optional, Tuple, Union
-
-from future.utils import string_types
-from telegram import Update
-from telegram.constants import ParseMode
-from telegram.ext import CommandHandler, ContextTypes, MessageHandler
-from telegram.ext import filters as filters_module
-from telegram.helpers import escape_markdown
-
-from Mikobot import function
-from Mikobot.plugins.helper_funcs.misc import is_module_loaded
-from Mikobot.utils.cmdprefix import CMD_STARTERS
-
-# <=======================================================================================================>
-
-FILENAME = __name__.rsplit(".", 1)[-1]
-
-# If module is due to be loaded, then setup all the magical handlers
-if is_module_loaded(FILENAME):
-    from Database.sql import disable_sql as sql
-    from Mikobot.plugins.helper_funcs.chat_status import (
-        check_admin,
-        connection_status,
-        is_user_admin,
-    )
-
-    DISABLE_CMDS = []
-    DISABLE_OTHER = []
-    ADMIN_CMDS = []
-
-    # <================================================ CLASS =======================================================>
-    class DisableAbleCommandHandler(CommandHandler):
-        def __init__(
-            self,
-            command,
-            callback,
-            block: bool,
-            filters: filters_module.BaseFilter = None,
-            admin_ok=False,
-        ):
-            super().__init__(command, callback, block=block)
-            self.admin_ok = admin_ok
-
-            if isinstance(command, string_types):
-                commands = frozenset({command.lower()})
-                DISABLE_CMDS.append(command)
-                if admin_ok:
-                    ADMIN_CMDS.append(command)
-            else:
-                commands = frozenset(x.lower() for x in command)
-                DISABLE_CMDS.extend(command)
-                if admin_ok:
-                    ADMIN_CMDS.extend(command)
-            for comm in commands:
-                if not re.match(r"^[\da-z_]{1,32}$", comm):
-                    raise ValueError(f"Command `{comm}` is not a valid bot command")
-
-            self.commands = commands
-            self.filters = (
-                filters if filters is not None else filters_module.UpdateType.MESSAGES
-            )
-
-        def check_update(
-            self, update
-        ) -> Optional[Union[bool, Tuple[List[str], Optional[Union[bool, Dict]]]]]:
-            if isinstance(update, Update) and update.effective_message:
-                message = update.effective_message
-
-                if message.text and len(message.text) > 1:
-                    fst_word = message.text.split(None, 1)[0]
-                    if len(fst_word) > 1 and any(
-                        fst_word.startswith(start) for start in CMD_STARTERS
-                    ):
-                        args = message.text.split()[1:]
-                        command_parts = fst_word[1:].split("@")
-                        command_parts.append(message.get_bot().username)
-
-                        if not (
-                            command_parts[0].lower() in self.commands
-                            and command_parts[1].lower()
-                            == message.get_bot().username.lower()
-                        ):
-                            return None
-
-                        chat = update.effective_chat
-                        user = update.effective_user
-
-                        filter_result = self.filters.check_update(update)
-                        if filter_result:
-                            # disabled, admincmd, user admin
-                            if sql.is_command_disabled(
-                                chat.id, command_parts[0].lower()
-                            ):
-                                # check if command was disabled
-                                is_disabled = command_parts[
-                                    0
-                                ] in ADMIN_CMDS and is_user_admin(chat, user.id)
-                                if not is_disabled:
-                                    return None
-                                else:
-                                    return args, filter_result
-
-                            return args, filter_result
-                        return False
-                return None
-
-    class DisableAbleMessageHandler(MessageHandler):
-        def __init__(self, filters, callback, block: bool, friendly, **kwargs):
-            super().__init__(filters, callback, block=block, **kwargs)
-            DISABLE_OTHER.append(friendly)
-            self.friendly = friendly
-            if filters:
-                self.filters = filters_module.UpdateType.MESSAGES & filters
-            else:
-                self.filters = filters_module.UpdateType.MESSAGES
-
-        def check_update(self, update):
-            chat = update.effective_chat
-            message = update.effective_message
-            filter_result = self.filters.check_update(update)
-
-            try:
-                args = message.text.split()[1:]
-            except:
-                args = []
-
-            if super().check_update(update):
-                if sql.is_command_disabled(chat.id, self.friendly):
-                    return False
-                else:
-                    return args, filter_result
-
-    # <=======================================================================================================>
-
-    # <================================================ FUNCTION =======================================================>
-    @connection_status
-    @check_admin(is_user=True)
-    async def disable(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        args = context.args
-        chat = update.effective_chat
-        if len(args) >= 1:
-            disable_cmd = args[0]
-            if disable_cmd.startswith(CMD_STARTERS):
-                disable_cmd = disable_cmd[1:]
-
-            if disable_cmd in set(DISABLE_CMDS + DISABLE_OTHER):
-                sql.disable_command(chat.id, str(disable_cmd).lower())
-                await update.effective_message.reply_text(
-                    f"Disabled the use of `{disable_cmd}`",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-            else:
-                await update.effective_message.reply_text(
-                    "That command can't be disabled"
-                )
-
-        else:
-            await update.effective_message.reply_text("What should I disable?")
-
-    @connection_status
-    @check_admin(is_user=True)
-    async def disable_module(
-        update: Update, context: ContextTypes.DEFAULT_TYPE
-    ) -> None:
-        args = context.args
-        chat = update.effective_chat
-        if len(args) >= 1:
-            disable_module = "Mikobot.plugins." + args[0].rsplit(".", 1)[0]
-
-            try:
-                module = importlib.import_module(disable_module)
-            except:
-                await update.effective_message.reply_text(
-                    "Does that module even exsist?"
-                )
-                return
-
-            try:
-                command_list = module.__command_list__
-            except:
-                await update.effective_message.reply_text(
-                    "Module does not contain command list!",
-                )
-                return
-
-            disabled_cmds = []
-            failed_disabled_cmds = []
-
-            for disable_cmd in command_list:
-                if disable_cmd.startswith(CMD_STARTERS):
-                    disable_cmd = disable_cmd[1:]
-
-                if disable_cmd in set(DISABLE_CMDS + DISABLE_OTHER):
-                    sql.disable_command(chat.id, str(disable_cmd).lower())
-                    disabled_cmds.append(disable_cmd)
-                else:
-                    failed_disabled_cmds.append(disable_cmd)
-
-            if disabled_cmds:
-                disabled_cmds_string = ", ".join(disabled_cmds)
-                await update.effective_message.reply_text(
-                    f"Disabled the use of`{disabled_cmds_string}`",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-
-            if failed_disabled_cmds:
-                failed_disabled_cmds_string = ", ".join(failed_disabled_cmds)
-                await update.effective_message.reply_text(
-                    f"Commands `{failed_disabled_cmds_string}` can't be disabled",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-
-        else:
-            await update.effective_message.reply_text("What should I disable?")
-
-    @connection_status
-    @check_admin(is_user=True)
-    async def enable(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        args = context.args
-        chat = update.effective_chat
-        if len(args) >= 1:
-            enable_cmd = args[0]
-            if enable_cmd.startswith(CMD_STARTERS):
-                enable_cmd = enable_cmd[1:]
-
-            if sql.enable_command(chat.id, enable_cmd):
-                await update.effective_message.reply_text(
-                    f"Enabled the use of`{enable_cmd}`",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-            else:
-                await update.effective_message.reply_text("Is that even disabled?")
-
-        else:
-            await update.effective_message.reply_text("What sould I enable?")
-
-    @connection_status
-    @check_admin(is_user=True)
-    async def enable_module(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        args = context.args
-        chat = update.effective_chat
-
-        if len(args) >= 1:
-            enable_module = "Mikobot.plugins." + args[0].rsplit(".", 1)[0]
-
-            try:
-                module = importlib.import_module(enable_module)
-            except:
-                await update.effective_message.reply_text(
-                    "Does that module even exsist?"
-                )
-                return
-
-            try:
-                command_list = module.__command_list__
-            except:
-                await update.effective_message.reply_text(
-                    "Module does not contain command list!",
-                )
-                return
-
-            enabled_cmds = []
-            failed_enabled_cmds = []
-
-            for enable_cmd in command_list:
-                if enable_cmd.startswith(CMD_STARTERS):
-                    enable_cmd = enable_cmd[1:]
-
-                if sql.enable_command(chat.id, enable_cmd):
-                    enabled_cmds.append(enable_cmd)
-                else:
-                    failed_enabled_cmds.append(enable_cmd)
-
-            if enabled_cmds:
-                enabled_cmds_string = ", ".join(enabled_cmds)
-                await update.effective_message.reply_text(
-                    f"Enabled the use of`{enabled_cmds_string}`",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-
-            if failed_enabled_cmds:
-                failed_enabled_cmds_string = ", ".join(failed_enabled_cmds)
-                await update.effective_message.reply_text(
-                    f"Are the commands `{failed_enabled_cmds_string}` even disabled?",
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-
-        else:
-            await update.effective_message.reply_text("ᴡʜᴀᴛ sʜᴏᴜʟᴅ I ᴇɴᴀʙʟᴇ?")
-
-    @connection_status
-    @check_admin(is_user=True)
-    async def list_cmds(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        if DISABLE_CMDS + DISABLE_OTHER:
-            result = ""
-            for cmd in set(DISABLE_CMDS + DISABLE_OTHER):
-                result += f" - `{escape_markdown(cmd)}`\n"
-            await update.effective_message.reply_text(
-                f"The following commands are toggleable:\n{result}",
-                parse_mode=ParseMode.MARKDOWN,
-            )
-        else:
-            await update.effective_message.reply_text("No commands can be disabled.")
-
-    # do not async
-    def build_curr_disabled(chat_id: Union[str, int]) -> str:
-        disabled = sql.get_all_disabled(chat_id)
-        if not disabled:
-            return "No commands are disabled!"
-
-        result = ""
-        for cmd in disabled:
-            result += " - `{}`\n".format(escape_markdown(cmd))
-        return "The following commands are currently restricted:\n{}".format(result)
-
-    @connection_status
-    async def commands(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        chat = update.effective_chat
-        await update.effective_message.reply_text(
-            build_curr_disabled(chat.id),
-            parse_mode=ParseMode.MARKDOWN,
-        )
-
-    def __stats__():
-        return f"• {sql.num_disabled()} disabled items, across {sql.num_chats()} chats."
-
-    def __migrate__(old_chat_id, new_chat_id):
-        sql.migrate_chat(old_chat_id, new_chat_id)
-
-    def __chat_settings__(chat_id, user_id):
-        return build_curr_disabled(chat_id)
-
-    # <=================================================== HANDLER ====================================================>
-
-    DISABLE_HANDLER = CommandHandler("disable", disable, block=False)
-    DISABLE_MODULE_HANDLER = CommandHandler(
-        "disablemodule", disable_module, block=False
-    )
-    ENABLE_HANDLER = CommandHandler("enable", enable, block=False)
-    ENABLE_MODULE_HANDLER = CommandHandler("enablemodule", enable_module, block=False)
-    COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands, block=False)
-    TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds, block=False)
-
-    function(DISABLE_HANDLER)
-    function(DISABLE_MODULE_HANDLER)
-    function(ENABLE_HANDLER)
-    function(ENABLE_MODULE_HANDLER)
-    function(COMMANDS_HANDLER)
-    function(TOGGLE_HANDLER)
-
-    # <=================================================== HELP ====================================================>
-    __help__ = """
-» /cmds: Check the current status of disabled commands
-
-➠ *Admins only*:
-
-» /enable < cmd name >: Enable that command.
-
-» /disable < cmd name >: Disable that command.
-
-» /enablemodule < module name >: Enable all commands in that module.
-
-» /disablemodule < module name >: Disable all commands in that module.
-
-» /listcmds: List all possible toggleable commands.
-    """
-
-    __mod_name__ = "DISABLE"
-
-else:
-    DisableAbleCommandHandler = CommandHandler
-    DisableAbleMessageHandler = MessageHandler
-# <================================================ END =======================================================>

Mikobot/plugins/extra.py

@@ -1,137 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from time import gmtime, strftime, time
-
-from pyrogram import filters
-from pyrogram.types import Message
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.ext import CallbackQueryHandler, CommandHandler, ContextTypes
-
-from Mikobot import LOGGER, app, function
-from Mikobot.plugins.helper_funcs.chat_status import check_admin
-
-# <=======================================================================================================>
-
-UPTIME = time()  # Check bot uptime
-
-
-# <================================================ FUNCTION =======================================================>
-async def getid(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    your_id = update.message.from_user.id
-    message_id = update.message.message_id
-    reply = update.message.reply_to_message
-
-    text = f"[Message ID:](https://t.me/{chat.username}/{message_id}) `{message_id}`\n"
-    text += f"[Your ID:](tg://user?id={your_id}) `{your_id}`\n"
-
-    if context.args:
-        try:
-            user_id = context.args[0]
-            text += f"[User ID:](tg://user?id={user_id}) `{user_id}`\n"
-        except Exception:
-            await update.message.reply_text(
-                "This user doesn't exist.", parse_mode="Markdown"
-            )
-            return
-
-    text += f"[Chat ID:](https://t.me/{chat.username}) `{chat.id}`\n\n"
-
-    if reply:
-        text += f"[Replied Message ID:](https://t.me/{chat.username}/{reply.message_id}) `{reply.message_id}`\n"
-        text += f"[Replied User ID:](tg://user?id={reply.from_user.id}) `{reply.from_user.id}`\n\n"
-
-    if reply and reply.forward_from_chat:
-        text += f"The forwarded channel, {reply.forward_from_chat.title}, has an id of `{reply.forward_from_chat.id}`\n\n"
-
-    if reply and reply.sender_chat:
-        text += f"ID of the replied chat/channel, is `{reply.sender_chat.id}`"
-
-    # Sticker ID to be sent
-    sticker_id = (
-        "CAACAgIAAx0CanzPTAABASPCZQdU9NbQIol5TW1GU2zV4KfjDMEAAnccAALIWZhJPyYLf3FzPHswBA"
-    )
-
-    # Send the sticker
-    await update.message.reply_sticker(sticker=sticker_id)
-
-    # Send the text message as a caption
-    await update.message.reply_text(
-        text, parse_mode="Markdown", disable_web_page_preview=True
-    )
-
-
-# Function to handle the "logs" command
-@check_admin(only_dev=True)
-async def logs(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    user = update.effective_user
-    with open("Logs.txt", "rb") as f:
-        caption = "Here is your log"
-        reply_markup = InlineKeyboardMarkup(
-            [[InlineKeyboardButton("Close", callback_data="close")]]
-        )
-        message = await context.bot.send_document(
-            document=f,
-            filename=f.name,
-            caption=caption,
-            reply_markup=reply_markup,
-            chat_id=user.id,
-        )
-
-        # Store the message ID for later reference
-        context.user_data["log_message_id"] = message.message_id
-
-
-# Asynchronous callback query handler for the "close" button
-@check_admin(only_dev=True)
-async def close_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    message_id = context.user_data.get("log_message_id")
-    if message_id:
-        await context.bot.delete_message(
-            chat_id=query.message.chat_id, message_id=message_id
-        )
-
-
-@app.on_message(filters.command("pyroping"))
-async def ping(_, m: Message):
-    LOGGER.info(f"{m.from_user.id} used ping cmd in {m.chat.id}")
-    start = time()
-    replymsg = await m.reply_text(text="Pinging...", quote=True)
-    delta_ping = time() - start
-
-    up = strftime("%Hh %Mm %Ss", gmtime(time() - UPTIME))
-    image_url = "https://telegra.ph/file/f215a1c4adf25a5bad81b.jpg"
-
-    # Send the image as a reply
-    await replymsg.reply_photo(
-        photo=image_url,
-        caption=f"<b>Pyro-Pong!</b>\n{delta_ping * 1000:.3f} ms\n\nUptime: <code>{up}</code>",
-    )
-    await replymsg.delete()
-
-
-# <=======================================================================================================>
-
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("logs", logs, block=False))
-function(CommandHandler("id", getid, block=False))
-function(CallbackQueryHandler(close_callback, pattern="^close$", block=False))
-
-# <================================================= HELP ======================================================>
-__help__ = """
-➠ *Commands*:
-
-» /instadl, /insta <link>: Get instagram contents like reel video or images.
-
-» /pyroping: see pyroping.
-
-» /hyperlink <text> <link> : Creates a markdown hyperlink with the provided text and link.
-
-» /pickwinner <participant1> <participant2> ... : Picks a random winner from the provided list of participants.
-
-» /id: reply to get user id.
-"""
-
-__mod_name__ = "EXTRA"
-# <================================================ END =======================================================>

Mikobot/plugins/feds.py

@@ -1,2505 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import ast
-import csv
-import json
-import os
-import re
-import time
-import uuid
-from io import BytesIO
-
-from telegram import (
-    ChatMember,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    MessageEntity,
-    Update,
-)
-from telegram.constants import ParseMode
-from telegram.error import BadRequest, Forbidden, TelegramError
-from telegram.ext import CallbackQueryHandler, CommandHandler, ContextTypes
-from telegram.helpers import mention_html, mention_markdown
-
-import Database.sql.feds_sql as sql
-from Mikobot import (
-    DRAGONS,
-    EVENT_LOGS,
-    LOGGER,
-    OWNER_ID,
-    SUPPORT_CHAT,
-    dispatcher,
-    function,
-)
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.alternate import send_message
-from Mikobot.plugins.helper_funcs.chat_status import is_user_admin
-from Mikobot.plugins.helper_funcs.extraction import (
-    extract_unt_fedban,
-    extract_user,
-    extract_user_fban,
-)
-from Mikobot.plugins.helper_funcs.string_handling import markdown_parser
-
-# <=======================================================================================================>
-
-FBAN_ERRORS = {
-    "User is an administrator of the chat",
-    "Chat not found",
-    "Not enough rights to restrict/unrestrict chat member",
-    "User_not_participant",
-    "Peer_id_invalid",
-    "Group chat was deactivated",
-    "Need to be inviter of a user to kick it from a basic group",
-    "Chat_admin_required",
-    "Only the creator of a basic group can kick group administrators",
-    "Channel_private",
-    "Not in the chat",
-    "Have no rights to send a message",
-}
-
-UNFBAN_ERRORS = {
-    "User is an administrator of the chat",
-    "Chat not found",
-    "Not enough rights to restrict/unrestrict chat member",
-    "User_not_participant",
-    "Method is available for supergroup and channel chats only",
-    "Not in the chat",
-    "Channel_private",
-    "Chat_admin_required",
-    "Have no rights to send a message",
-}
-
-
-# <================================================ FUNCTION =======================================================>
-async def new_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-    bot = context.bot
-    if chat.type != "private":
-        await update.effective_message.reply_text(
-            "Federations can only be created by privately messaging me.",
-        )
-        return
-    if len(message.text) == 1:
-        await send_message(
-            update.effective_message,
-            "Please write the name of the federation!",
-        )
-        return
-    fednam = message.text.split(None, 1)[1]
-    if not fednam == "":
-        fed_id = str(uuid.uuid4())
-        fed_name = fednam
-        LOGGER.info(fed_id)
-
-        x = sql.new_fed(user.id, fed_name, fed_id)
-        if not x:
-            await update.effective_message.reply_text(
-                f"Can't federate! Please contact @{SUPPORT_CHAT} if the problem persist.",
-            )
-            return
-
-        await update.effective_message.reply_text(
-            "*You have succeeded in creating a new federation!*"
-            "\nName: `{}`"
-            "\nID: `{}`"
-            "\n\nUse the command below to join the federation:"
-            "\n`/joinfed {}`".format(fed_name, fed_id, fed_id),
-            parse_mode=ParseMode.MARKDOWN,
-        )
-        try:
-            await bot.send_message(
-                EVENT_LOGS,
-                "New Federation: <b>{}</b>\nID: <pre>{}</pre>".format(fed_name, fed_id),
-                parse_mode=ParseMode.HTML,
-            )
-        except:
-            LOGGER.warning("Cannot send a message to EVENT_LOGS")
-    else:
-        await update.effective_message.reply_text(
-            "Please write down the name of the federation",
-        )
-
-
-async def del_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    if chat.type != "private":
-        await update.effective_message.reply_text(
-            "Federations can only be deleted by privately messaging me.",
-        )
-        return
-    if args:
-        is_fed_id = args[0]
-        getinfo = sql.get_fed_info(is_fed_id)
-        if getinfo is False:
-            await update.effective_message.reply_text("This federation does not exist.")
-            return
-        if int(getinfo["owner"]) == int(user.id) or int(user.id) == OWNER_ID:
-            fed_id = is_fed_id
-        else:
-            await update.effective_message.reply_text(
-                "Only federation owners can do this!"
-            )
-            return
-    else:
-        await update.effective_message.reply_text("What should I delete?")
-        return
-
-    if is_user_fed_owner(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only federation owners can do this!")
-        return
-
-    await update.effective_message.reply_text(
-        "You sure you want to delete your federation? This cannot be reverted, you will lose your entire ban list, and '{}' will be permanently lost.".format(
-            getinfo["fname"],
-        ),
-        reply_markup=InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        text="⚠️ Delete Federation ⚠️",
-                        callback_data="rmfed_{}".format(fed_id),
-                    ),
-                ],
-                [InlineKeyboardButton(text="Cancel", callback_data="rmfed_cancel")],
-            ],
-        ),
-    )
-
-
-async def rename_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    user = update.effective_user
-    msg = update.effective_message
-    args = msg.text.split(None, 2)
-
-    if len(args) < 3:
-        return await msg.reply_text("usage: /renamefed <fed_id> <newname>")
-
-    fed_id, newname = args[1], args[2]
-    verify_fed = sql.get_fed_info(fed_id)
-
-    if not verify_fed:
-        return await msg.reply_text("This fed not exist in my database!")
-
-    if is_user_fed_owner(fed_id, user.id):
-        sql.rename_fed(fed_id, user.id, newname)
-        await msg.reply_text(f"Successfully renamed your fed name to {newname}!")
-    else:
-        await msg.reply_text("Only federation owner can do this!")
-
-
-async def fed_chat(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    fed_id = sql.get_fed_id(chat.id)
-
-    user_id = update.effective_message.from_user.id
-    if not await is_user_admin(update.effective_chat, user_id):
-        await update.effective_message.reply_text(
-            "You must be an admin to execute this command",
-        )
-        return
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not in any federation!"
-        )
-        return
-
-    user = update.effective_user
-    chat = update.effective_chat
-    info = sql.get_fed_info(fed_id)
-
-    text = "This group is part of the following federation:"
-    text += "\n{} (ID: <code>{}</code>)".format(info["fname"], fed_id)
-
-    await update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
-
-
-async def join_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    message = update.effective_message
-    administrators = await chat.get_administrators()
-    fed_id = sql.get_fed_id(chat.id)
-
-    if user.id in DRAGONS:
-        pass
-    else:
-        for admin in administrators:
-            status = admin.status
-            if status == "creator":
-                if str(admin.user.id) == str(user.id):
-                    pass
-                else:
-                    await update.effective_message.reply_text(
-                        "Only group creators can use this command!",
-                    )
-                    return
-    if fed_id:
-        await message.reply_text("You cannot join two federations from one chat")
-        return
-
-    if len(args) >= 1:
-        getfed = sql.search_fed_by_id(args[0])
-        if getfed is False:
-            await message.reply_text("Please enter a valid federation ID")
-            return
-
-        x = sql.chat_join_fed(args[0], chat.title, chat.id)
-        if not x:
-            await message.reply_text(
-                f"Failed to join federation! Please contact @{SUPPORT_CHAT} should this problem persist!",
-            )
-            return
-
-        get_fedlog = await sql.get_fed_log(args[0])
-        if get_fedlog:
-            if ast.literal_eval(get_fedlog):
-                await bot.send_message(
-                    get_fedlog,
-                    "Chat *{}* has joined the federation *{}*".format(
-                        chat.title,
-                        getfed["fname"],
-                    ),
-                    parse_mode="markdown",
-                    message_thread_id=message.message_thread_id
-                    if chat.is_forum
-                    else None,
-                )
-
-        await message.reply_text(
-            "This group has joined the federation: {}!".format(getfed["fname"]),
-        )
-
-
-async def leave_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our PM!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    fed_info = sql.get_fed_info(fed_id)
-
-    # administrators = await chat.get_administrators().status
-    getuser = await bot.get_chat_member(chat.id, user.id).status
-    if getuser in "creator" or user.id in DRAGONS:
-        if sql.chat_leave_fed(chat.id) is True:
-            get_fedlog = await sql.get_fed_log(fed_id)
-            if get_fedlog:
-                if ast.literal_eval(get_fedlog):
-                    await bot.send_message(
-                        get_fedlog,
-                        "Chat *{}* has left the federation *{}*".format(
-                            chat.title,
-                            fed_info["fname"],
-                        ),
-                        parse_mode="markdown",
-                        message_thread_id=update.effective_message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-            await send_message(
-                update.effective_message,
-                "This group has left the federation {}!".format(fed_info["fname"]),
-            )
-        else:
-            await update.effective_message.reply_text(
-                "How can you leave a federation that you never joined?!",
-            )
-    else:
-        await update.effective_message.reply_text(
-            "Only group creators can use this command!"
-        )
-
-
-async def user_join_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-
-    if is_user_fed_owner(fed_id, user.id) or user.id in DRAGONS:
-        user_id = await extract_user(msg, context, args)
-        if user_id:
-            user = await bot.get_chat(user_id)
-        elif not msg.reply_to_message and not args:
-            user = msg.from_user
-        elif not msg.reply_to_message and (
-            not args
-            or (
-                len(args) >= 1
-                and not args[0].startswith("@")
-                and not args[0].isdigit()
-                and not msg.parse_entities([MessageEntity.TEXT_MENTION])
-            )
-        ):
-            await msg.reply_text("I cannot extract user from this message")
-            return
-        else:
-            LOGGER.warning("error")
-        getuser = sql.search_user_in_fed(fed_id, user_id)
-        fed_id = sql.get_fed_id(chat.id)
-        info = sql.get_fed_info(fed_id)
-        get_owner = ast.literal_eval(info["fusers"])["owner"]
-        get_owner = await bot.get_chat(get_owner)
-        if isinstance(get_owner, ChatMember):
-            if user_id == get_owner.id:
-                await update.effective_message.reply_text(
-                    "You do know that the user is the federation owner, right? RIGHT?",
-                )
-                return
-        if getuser:
-            await update.effective_message.reply_text(
-                "I cannot promote users who are already federation admins! Can remove them if you want!",
-            )
-            return
-        if user_id == bot.id:
-            await update.effective_message.reply_text(
-                "I already am a federation admin in all federations!",
-            )
-            return
-        res = sql.user_join_fed(fed_id, user_id)
-        if res:
-            await update.effective_message.reply_text("Successfully Promoted!")
-        else:
-            await update.effective_message.reply_text("Failed to promote!")
-    else:
-        await update.effective_message.reply_text("Only federation owners can do this!")
-
-
-async def user_demote_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-
-    if is_user_fed_owner(fed_id, user.id):
-        msg = update.effective_message
-        user_id = await extract_user(msg, context, args)
-        if user_id:
-            user = await bot.get_chat(user_id)
-
-        elif not msg.reply_to_message and not args:
-            user = msg.from_user
-
-        elif not msg.reply_to_message and (
-            not args
-            or (
-                len(args) >= 1
-                and not args[0].startswith("@")
-                and not args[0].isdigit()
-                and not msg.parse_entities([MessageEntity.TEXT_MENTION])
-            )
-        ):
-            await msg.reply_text("I cannot extract user from this message")
-            return
-        else:
-            LOGGER.warning("error")
-
-        if user_id == bot.id:
-            await update.effective_message.reply_text(
-                "The thing you are trying to demote me from will fail to work without me! Just saying.",
-            )
-            return
-
-        if sql.search_user_in_fed(fed_id, user_id) is False:
-            await update.effective_message.reply_text(
-                "I cannot demote people who are not federation admins!",
-            )
-            return
-
-        res = sql.user_demote_fed(fed_id, user_id)
-        if res is True:
-            await update.effective_message.reply_text("Demoted from a Fed Admin!")
-        else:
-            await update.effective_message.reply_text("Demotion failed!")
-    else:
-        await update.effective_message.reply_text("Only federation owners can do this!")
-        return
-
-
-async def fed_info(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    if args:
-        fed_id = args[0]
-        info = sql.get_fed_info(fed_id)
-    else:
-        if chat.type == "private":
-            await send_message(
-                update.effective_message,
-                "You need to provide me a fedid to check fedinfo in my pm.",
-            )
-            return
-        fed_id = sql.get_fed_id(chat.id)
-        if not fed_id:
-            await send_message(
-                update.effective_message,
-                "This group is not in any federation!",
-            )
-            return
-        info = sql.get_fed_info(fed_id)
-
-    if is_user_fed_admin(fed_id, user.id) is False:
-        await update.effective_message.reply_text(
-            "Only a federation admin can do this!"
-        )
-        return
-
-    owner = await bot.get_chat(info["owner"])
-    try:
-        owner_name = owner.first_name + " " + owner.last_name
-    except:
-        owner_name = owner.first_name
-    FEDADMIN = sql.all_fed_users(fed_id)
-    TotalAdminFed = len(FEDADMIN)
-
-    user = update.effective_user
-    chat = update.effective_chat
-    info = sql.get_fed_info(fed_id)
-
-    text = "<b>ℹ️ Federation Information:</b>"
-    text += "\nFedID: <code>{}</code>".format(fed_id)
-    text += "\nName: {}".format(info["fname"])
-    text += "\nCreator: {}".format(mention_html(owner.id, owner_name))
-    text += "\nAll Admins: <code>{}</code>".format(TotalAdminFed)
-    getfban = sql.get_all_fban_users(fed_id)
-    text += "\nTotal banned users: <code>{}</code>".format(len(getfban))
-    getfchat = sql.all_fed_chats(fed_id)
-    text += "\nNumber of groups in this federation: <code>{}</code>".format(
-        len(getfchat),
-    )
-
-    await update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
-
-
-async def fed_admin(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not in any federation!"
-        )
-        return
-
-    if is_user_fed_admin(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only federation admins can do this!")
-        return
-
-    user = update.effective_user
-    chat = update.effective_chat
-    info = sql.get_fed_info(fed_id)
-
-    text = "<b>Federation Admin {}:</b>\n\n".format(info["fname"])
-    text += "👑 Owner:\n"
-    owner = await bot.get_chat(info["owner"])
-    try:
-        owner_name = owner.first_name + " " + owner.last_name
-    except:
-        owner_name = owner.first_name
-    text += " • {}\n".format(mention_html(owner.id, owner_name))
-
-    members = sql.all_fed_members(fed_id)
-    if len(members) == 0:
-        text += "\n🔱 There are no admins in this federation"
-    else:
-        text += "\n🔱 Admin:\n"
-        for x in members:
-            user = await bot.get_chat(x)
-            text += " • {}\n".format(mention_html(user.id, user.first_name))
-
-    await update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
-
-
-async def fed_ban(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not a part of any federation!",
-        )
-        return
-
-    info = sql.get_fed_info(fed_id)
-    getfednotif = sql.user_feds_report(info["owner"])
-
-    if is_user_fed_admin(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only federation admins can do this!")
-        return
-
-    message = update.effective_message
-
-    user_id, reason = extract_unt_fedban(message, context, args)
-
-    fban, fbanreason, fbantime = sql.get_fban_user(fed_id, user_id)
-
-    if not user_id:
-        await message.reply_text("You don't seem to be referring to a user")
-        return
-
-    if user_id == bot.id:
-        await message.reply_text(
-            "What is funnier than kicking the group creator? Self sacrifice.",
-        )
-        return
-
-    if is_user_fed_owner(fed_id, user_id) is True:
-        await message.reply_text("Why did you try the federation fban?")
-        return
-
-    if is_user_fed_admin(fed_id, user_id) is True:
-        await message.reply_text("He is a federation admin, I can't fban him.")
-        return
-
-    if user_id == OWNER_ID:
-        await message.reply_text("Disaster level God cannot be fed banned!")
-        return
-
-    if int(user_id) in DRAGONS:
-        await message.reply_text("Dragons cannot be fed banned!")
-        return
-
-    if user_id in [777000, 1087968824]:
-        await message.reply_text("Fool! You can't attack Telegram's native tech!")
-        return
-
-    try:
-        user_chat = await bot.get_chat(user_id)
-        isvalid = True
-        fban_user_id = user_chat.id
-        fban_user_name = user_chat.first_name
-        fban_user_lname = user_chat.last_name
-        fban_user_uname = user_chat.username
-    except BadRequest as excp:
-        if not str(user_id).isdigit():
-            await send_message(update.effective_message, excp.message)
-            return
-        elif len(str(user_id)) != 9:
-            await send_message(update.effective_message, "That's so not a user!")
-            return
-        isvalid = False
-        fban_user_id = int(user_id)
-        fban_user_name = "user({})".format(user_id)
-        fban_user_lname = None
-        fban_user_uname = None
-
-    if isvalid and user_chat.type != "private":
-        await send_message(update.effective_message, "That's so not a user!")
-        return
-
-    if isvalid:
-        user_target = mention_html(fban_user_id, fban_user_name)
-    else:
-        user_target = fban_user_name
-
-    if fban:
-        fed_name = info["fname"]
-        # https://t.me/OnePunchSupport/41606 // https://t.me/OnePunchSupport/41619
-        # starting = "The reason fban is replaced for {} in the Federation <b>{}</b>.".format(user_target, fed_name)
-        # await send_message(update.effective_message, starting, parse_mode=ParseMode.HTML)
-
-        # if reason == "":
-        #    reason = "No reason given."
-
-        temp = sql.un_fban_user(fed_id, fban_user_id)
-        if not temp:
-            await message.reply_text("Failed to update the reason for fedban!")
-            return
-        x = sql.fban_user(
-            fed_id,
-            fban_user_id,
-            fban_user_name,
-            fban_user_lname,
-            fban_user_uname,
-            reason,
-            int(time.time()),
-        )
-        if not x:
-            await message.reply_text(
-                f"Failed to ban from the federation! If this problem continues, contact @{SUPPORT_CHAT}.",
-            )
-            return
-
-        fed_chats = sql.all_fed_chats(fed_id)
-        # Will send to current chat
-        await bot.send_message(
-            chat.id,
-            "<b>FedBan reason updated</b>"
-            "\n<b>Federation:</b> {}"
-            "\n<b>Federation Admin:</b> {}"
-            "\n<b>User:</b> {}"
-            "\n<b>User ID:</b> <code>{}</code>"
-            "\n<b>Reason:</b> {}".format(
-                fed_name,
-                mention_html(user.id, user.first_name),
-                user_target,
-                fban_user_id,
-                reason,
-            ),
-            parse_mode="HTML",
-        )
-        # Send message to owner if fednotif is enabled
-        if getfednotif:
-            await bot.send_message(
-                info["owner"],
-                "<b>FedBan reason updated</b>"
-                "\n<b>Federation:</b> {}"
-                "\n<b>Federation Admin:</b> {}"
-                "\n<b>User:</b> {}"
-                "\n<b>User ID:</b> <code>{}</code>"
-                "\n<b>Reason:</b> {}".format(
-                    fed_name,
-                    mention_html(user.id, user.first_name),
-                    user_target,
-                    fban_user_id,
-                    reason,
-                ),
-                parse_mode="HTML",
-            )
-        # If fedlog is set, then send message, except fedlog is current chat
-        get_fedlog = await sql.get_fed_log(fed_id)
-        if get_fedlog:
-            if int(get_fedlog) != int(chat.id):
-                await bot.send_message(
-                    get_fedlog,
-                    "<b>FedBan reason updated</b>"
-                    "\n<b>Federation:</b> {}"
-                    "\n<b>Federation Admin:</b> {}"
-                    "\n<b>User:</b> {}"
-                    "\n<b>User ID:</b> <code>{}</code>"
-                    "\n<b>Reason:</b> {}".format(
-                        fed_name,
-                        mention_html(user.id, user.first_name),
-                        user_target,
-                        fban_user_id,
-                        reason,
-                    ),
-                    parse_mode="HTML",
-                )
-        for fedschat in fed_chats:
-            try:
-                # Do not spam all fed chats
-                """
-				bot.send_message(chat, "<b>FedBan reason updated</b>" \
-							 "\n<b>Federation:</b> {}" \
-							 "\n<b>Federation Admin:</b> {}" \
-							 "\n<b>User:</b> {}" \
-							 "\n<b>User ID:</b> <code>{}</code>" \
-							 "\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason), parse_mode="HTML")
-				"""
-                await bot.ban_chat_member(fedschat, fban_user_id)
-            except BadRequest as excp:
-                if excp.message in FBAN_ERRORS:
-                    try:
-                        await dispatcher.bot.getChat(fedschat)
-                    except Forbidden:
-                        sql.chat_leave_fed(fedschat)
-                        LOGGER.info(
-                            "Chat {} has leave fed {} because I was kicked".format(
-                                fedschat,
-                                info["fname"],
-                            ),
-                        )
-                        continue
-                elif excp.message == "User_id_invalid":
-                    break
-                else:
-                    LOGGER.warning(
-                        "Could not fban on {} because: {}".format(chat, excp.message),
-                    )
-            except TelegramError:
-                pass
-        # Also do not spam all fed admins
-        """
-		send_to_list(bot, FEDADMIN,
-				 "<b>FedBan reason updated</b>" \
-							 "\n<b>Federation:</b> {}" \
-							 "\n<b>Federation Admin:</b> {}" \
-							 "\n<b>User:</b> {}" \
-							 "\n<b>User ID:</b> <code>{}</code>" \
-							 "\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason),
-							html=True)
-		"""
-
-        # Fban for fed subscriber
-        subscriber = list(sql.get_subscriber(fed_id))
-        if len(subscriber) != 0:
-            for fedsid in subscriber:
-                all_fedschat = sql.all_fed_chats(fedsid)
-                for fedschat in all_fedschat:
-                    try:
-                        await bot.ban_chat_member(fedschat, fban_user_id)
-                    except BadRequest as excp:
-                        if excp.message in FBAN_ERRORS:
-                            try:
-                                await dispatcher.bot.getChat(fedschat)
-                            except Forbidden:
-                                targetfed_id = sql.get_fed_id(fedschat)
-                                sql.unsubs_fed(fed_id, targetfed_id)
-                                LOGGER.info(
-                                    "Chat {} has unsub fed {} because I was kicked".format(
-                                        fedschat,
-                                        info["fname"],
-                                    ),
-                                )
-                                continue
-                        elif excp.message == "User_id_invalid":
-                            break
-                        else:
-                            LOGGER.warning(
-                                "Unable to fban on {} because: {}".format(
-                                    fedschat,
-                                    excp.message,
-                                ),
-                            )
-                    except TelegramError:
-                        pass
-        # await send_message(update.effective_message, "Fedban Reason has been updated.")
-        return
-
-    fed_name = info["fname"]
-
-    # starting = "Starting a federation ban for {} in the Federation <b>{}</b>.".format(
-    #    user_target, fed_name)
-    # await update.effective_message.reply_text(starting, parse_mode=ParseMode.HTML)
-
-    # if reason == "":
-    #    reason = "No reason given."
-
-    x = sql.fban_user(
-        fed_id,
-        fban_user_id,
-        fban_user_name,
-        fban_user_lname,
-        fban_user_uname,
-        reason,
-        int(time.time()),
-    )
-    if not x:
-        await message.reply_text(
-            f"Failed to ban from the federation! If this problem continues, contact @{SUPPORT_CHAT}.",
-        )
-        return
-
-    fed_chats = sql.all_fed_chats(fed_id)
-    # Will send to current chat
-    await bot.send_message(
-        chat.id,
-        "<b>New FedBan</b>"
-        "\n<b>Federation:</b> {}"
-        "\n<b>Federation Admin:</b> {}"
-        "\n<b>User:</b> {}"
-        "\n<b>User ID:</b> <code>{}</code>"
-        "\n<b>Reason:</b> {}".format(
-            fed_name,
-            mention_html(user.id, user.first_name),
-            user_target,
-            fban_user_id,
-            reason,
-        ),
-        parse_mode="HTML",
-    )
-    # Send message to owner if fednotif is enabled
-    if getfednotif:
-        await bot.send_message(
-            info["owner"],
-            "<b>New FedBan</b>"
-            "\n<b>Federation:</b> {}"
-            "\n<b>Federation Admin:</b> {}"
-            "\n<b>User:</b> {}"
-            "\n<b>User ID:</b> <code>{}</code>"
-            "\n<b>Reason:</b> {}".format(
-                fed_name,
-                mention_html(user.id, user.first_name),
-                user_target,
-                fban_user_id,
-                reason,
-            ),
-            parse_mode="HTML",
-        )
-    # If fedlog is set, then send message, except fedlog is current chat
-    get_fedlog = await sql.get_fed_log(fed_id)
-    if get_fedlog:
-        if int(get_fedlog) != int(chat.id):
-            await bot.send_message(
-                get_fedlog,
-                "<b>New FedBan</b>"
-                "\n<b>Federation:</b> {}"
-                "\n<b>Federation Admin:</b> {}"
-                "\n<b>User:</b> {}"
-                "\n<b>User ID:</b> <code>{}</code>"
-                "\n<b>Reason:</b> {}".format(
-                    fed_name,
-                    mention_html(user.id, user.first_name),
-                    user_target,
-                    fban_user_id,
-                    reason,
-                ),
-                parse_mode="HTML",
-            )
-    chats_in_fed = 0
-    for fedschat in fed_chats:
-        chats_in_fed += 1
-        try:
-            # Do not spamming all fed chats
-            """
-			bot.send_message(chat, "<b>FedBan reason updated</b>" \
-							"\n<b>Federation:</b> {}" \
-							"\n<b>Federation Admin:</b> {}" \
-							"\n<b>User:</b> {}" \
-							"\n<b>User ID:</b> <code>{}</code>" \
-							"\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason), parse_mode="HTML")
-			"""
-            await bot.ban_chat_member(fedschat, fban_user_id)
-        except BadRequest as excp:
-            if excp.message in FBAN_ERRORS:
-                pass
-            elif excp.message == "User_id_invalid":
-                break
-            else:
-                LOGGER.warning(
-                    "Could not fban on {} because: {}".format(chat, excp.message),
-                )
-        except TelegramError:
-            pass
-
-        # Also do not spamming all fed admins
-        """
-		send_to_list(bot, FEDADMIN,
-				 "<b>FedBan reason updated</b>" \
-							 "\n<b>Federation:</b> {}" \
-							 "\n<b>Federation Admin:</b> {}" \
-							 "\n<b>User:</b> {}" \
-							 "\n<b>User ID:</b> <code>{}</code>" \
-							 "\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason),
-							html=True)
-		"""
-
-        # Fban for fed subscriber
-        subscriber = list(sql.get_subscriber(fed_id))
-        if len(subscriber) != 0:
-            for fedsid in subscriber:
-                all_fedschat = sql.all_fed_chats(fedsid)
-                for fedschat in all_fedschat:
-                    try:
-                        await bot.ban_chat_member(fedschat, fban_user_id)
-                    except BadRequest as excp:
-                        if excp.message in FBAN_ERRORS:
-                            try:
-                                await dispatcher.bot.getChat(fedschat)
-                            except Forbidden:
-                                targetfed_id = sql.get_fed_id(fedschat)
-                                sql.unsubs_fed(fed_id, targetfed_id)
-                                LOGGER.info(
-                                    "Chat {} has unsub fed {} because I was kicked".format(
-                                        fedschat,
-                                        info["fname"],
-                                    ),
-                                )
-                                continue
-                        elif excp.message == "User_id_invalid":
-                            break
-                        else:
-                            LOGGER.warning(
-                                "Unable to fban on {} because: {}".format(
-                                    fedschat,
-                                    excp.message,
-                                ),
-                            )
-                    except TelegramError:
-                        pass
-
-
-async def unfban(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not a part of any federation!",
-        )
-        return
-
-    info = sql.get_fed_info(fed_id)
-    getfednotif = sql.user_feds_report(info["owner"])
-
-    if is_user_fed_admin(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only federation admins can do this!")
-        return
-
-    user_id = extract_user_fban(message, context, args)
-    if not user_id:
-        await message.reply_text("You do not seem to be referring to a user.")
-        return
-
-    try:
-        user_chat = await bot.get_chat(user_id)
-        isvalid = True
-        fban_user_id = user_chat.id
-        fban_user_name = user_chat.first_name
-        fban_user_lname = user_chat.last_name
-        fban_user_uname = user_chat.username
-    except BadRequest as excp:
-        if not str(user_id).isdigit():
-            await send_message(update.effective_message, excp.message)
-            return
-        elif len(str(user_id)) != 9:
-            await send_message(update.effective_message, "That's so not a user!")
-            return
-        isvalid = False
-        fban_user_id = int(user_id)
-        fban_user_name = "user({})".format(user_id)
-        fban_user_lname = None
-        fban_user_uname = None
-
-    if isvalid and user_chat.type != "private":
-        await message.reply_text("That's so not a user!")
-        return
-
-    if isvalid:
-        user_target = mention_html(fban_user_id, fban_user_name)
-    else:
-        user_target = fban_user_name
-
-    fban, fbanreason, fbantime = sql.get_fban_user(fed_id, fban_user_id)
-    if fban is False:
-        await message.reply_text("This user is not fbanned!")
-        return
-
-    banner = update.effective_user
-
-    chat_list = sql.all_fed_chats(fed_id)
-    # Will send to current chat
-    await bot.send_message(
-        chat.id,
-        "<b>Un-FedBan</b>"
-        "\n<b>Federation:</b> {}"
-        "\n<b>Federation Admin:</b> {}"
-        "\n<b>User:</b> {}"
-        "\n<b>User ID:</b> <code>{}</code>".format(
-            info["fname"],
-            mention_html(user.id, user.first_name),
-            user_target,
-            fban_user_id,
-        ),
-        parse_mode="HTML",
-    )
-    # Send message to owner if fednotif is enabled
-    if getfednotif:
-        await bot.send_message(
-            info["owner"],
-            "<b>Un-FedBan</b>"
-            "\n<b>Federation:</b> {}"
-            "\n<b>Federation Admin:</b> {}"
-            "\n<b>User:</b> {}"
-            "\n<b>User ID:</b> <code>{}</code>".format(
-                info["fname"],
-                mention_html(user.id, user.first_name),
-                user_target,
-                fban_user_id,
-            ),
-            parse_mode="HTML",
-        )
-    # If fedlog is set, then send message, except fedlog is current chat
-    get_fedlog = await sql.get_fed_log(fed_id)
-    if get_fedlog:
-        if int(get_fedlog) != int(chat.id):
-            await bot.send_message(
-                get_fedlog,
-                "<b>Un-FedBan</b>"
-                "\n<b>Federation:</b> {}"
-                "\n<b>Federation Admin:</b> {}"
-                "\n<b>User:</b> {}"
-                "\n<b>User ID:</b> <code>{}</code>".format(
-                    info["fname"],
-                    mention_html(user.id, user.first_name),
-                    user_target,
-                    fban_user_id,
-                ),
-                parse_mode="HTML",
-            )
-    unfbanned_in_chats = 0
-    for fedchats in chat_list:
-        unfbanned_in_chats += 1
-        try:
-            member = await bot.get_chat_member(fedchats, user_id)
-            if member.status == "kicked":
-                await bot.unban_chat_member(fedchats, user_id)
-            # Do not spamming all fed chats
-            """
-			bot.send_message(chat, "<b>Un-FedBan</b>" \
-						 "\n<b>Federation:</b> {}" \
-						 "\n<b>Federation Admin:</b> {}" \
-						 "\n<b>User:</b> {}" \
-						 "\n<b>User ID:</b> <code>{}</code>".format(info['fname'], mention_html(user.id, user.first_name), user_target, fban_user_id), parse_mode="HTML")
-			"""
-        except BadRequest as excp:
-            if excp.message in UNFBAN_ERRORS:
-                pass
-            elif excp.message == "User_id_invalid":
-                break
-            else:
-                LOGGER.warning(
-                    "Could not fban on {} because: {}".format(chat, excp.message),
-                )
-        except TelegramError:
-            pass
-
-    try:
-        x = sql.un_fban_user(fed_id, user_id)
-        if not x:
-            await send_message(
-                update.effective_message,
-                "Un-fban failed, this user may already be un-fedbanned!",
-            )
-            return
-    except:
-        pass
-
-    # UnFban for fed subscriber
-    subscriber = list(sql.get_subscriber(fed_id))
-    if len(subscriber) != 0:
-        for fedsid in subscriber:
-            all_fedschat = sql.all_fed_chats(fedsid)
-            for fedschat in all_fedschat:
-                try:
-                    await bot.unban_chat_member(fedchats, user_id)
-                except BadRequest as excp:
-                    if excp.message in FBAN_ERRORS:
-                        try:
-                            await dispatcher.bot.getChat(fedschat)
-                        except Forbidden:
-                            targetfed_id = sql.get_fed_id(fedschat)
-                            sql.unsubs_fed(fed_id, targetfed_id)
-                            LOGGER.info(
-                                "Chat {} has unsub fed {} because I was kicked".format(
-                                    fedschat,
-                                    info["fname"],
-                                ),
-                            )
-                            continue
-                    elif excp.message == "User_id_invalid":
-                        break
-                    else:
-                        LOGGER.warning(
-                            "Unable to fban on {} because: {}".format(
-                                fedschat,
-                                excp.message,
-                            ),
-                        )
-                except TelegramError:
-                    pass
-
-    if unfbanned_in_chats == 0:
-        await send_message(
-            update.effective_message,
-            "This person has been un-fbanned in 0 chats.",
-        )
-    if unfbanned_in_chats > 0:
-        await send_message(
-            update.effective_message,
-            "This person has been un-fbanned in {} chats.".format(unfbanned_in_chats),
-        )
-    # Also do not spamming all fed admins
-    """
-	FEDADMIN = sql.all_fed_users(fed_id)
-	for x in FEDADMIN:
-		getreport = sql.user_feds_report(x)
-		if getreport is False:
-			FEDADMIN.remove(x)
-	send_to_list(bot, FEDADMIN,
-			 "<b>Un-FedBan</b>" \
-			 "\n<b>Federation:</b> {}" \
-			 "\n<b>Federation Admin:</b> {}" \
-			 "\n<b>User:</b> {}" \
-			 "\n<b>User ID:</b> <code>{}</code>".format(info['fname'], mention_html(user.id, user.first_name),
-												 mention_html(user_chat.id, user_chat.first_name),
-															  user_chat.id),
-			html=True)
-	"""
-
-
-async def set_frules(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not in any federation!"
-        )
-        return
-
-    if is_user_fed_admin(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only fed admins can do this!")
-        return
-
-    if len(args) >= 1:
-        msg = update.effective_message
-        raw_text = msg.text
-        args = raw_text.split(None, 1)  # use python's maxsplit to separate cmd and args
-        if len(args) == 2:
-            txt = args[1]
-            offset = len(txt) - len(raw_text)  # set correct offset relative to command
-            markdown_rules = markdown_parser(
-                txt,
-                entities=msg.parse_entities(),
-                offset=offset,
-            )
-        x = sql.set_frules(fed_id, markdown_rules)
-        if not x:
-            await update.effective_message.reply_text(
-                f"Whoa! There was an error while setting federation rules! If you wondered why please ask it in @{SUPPORT_CHAT}!",
-            )
-            return
-
-        rules = sql.get_fed_info(fed_id)["frules"]
-        getfed = sql.get_fed_info(fed_id)
-        get_fedlog = await sql.get_fed_log(fed_id)
-        if get_fedlog:
-            if ast.literal_eval(get_fedlog):
-                await bot.send_message(
-                    get_fedlog,
-                    "*{}* has updated federation rules for fed *{}*".format(
-                        user.first_name,
-                        getfed["fname"],
-                    ),
-                    parse_mode="markdown",
-                    message_thread_id=update.effective_message.message_thread_id
-                    if chat.is_forum
-                    else None,
-                )
-        await update.effective_message.reply_text(
-            f"Rules have been changed to :\n{rules}!"
-        )
-    else:
-        await update.effective_message.reply_text("Please write rules to set this up!")
-
-
-async def get_frules(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not in any federation!"
-        )
-        return
-
-    rules = sql.get_frules(fed_id)
-    text = "*Rules in this fed:*\n"
-    text += rules
-    await update.effective_message.reply_text(text, parse_mode=ParseMode.MARKDOWN)
-
-
-async def fed_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    msg = update.effective_message
-    user = update.effective_user
-    chat = update.effective_chat
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    if args:
-        chat = update.effective_chat
-        fed_id = sql.get_fed_id(chat.id)
-        fedinfo = sql.get_fed_info(fed_id)
-        if is_user_fed_owner(fed_id, user.id) is False:
-            await update.effective_message.reply_text(
-                "Only federation owners can do this!"
-            )
-            return
-        # Parsing md
-        raw_text = msg.text
-        args = raw_text.split(None, 1)  # use python's maxsplit to separate cmd and args
-        txt = args[1]
-        offset = len(txt) - len(raw_text)  # set correct offset relative to command
-        text_parser = markdown_parser(txt, entities=msg.parse_entities(), offset=offset)
-        text = text_parser
-        try:
-            broadcaster = user.first_name
-        except:
-            broadcaster = user.first_name + " " + user.last_name
-        text += "\n\n- {}".format(mention_markdown(user.id, broadcaster))
-        chat_list = sql.all_fed_chats(fed_id)
-        failed = 0
-        for chat in chat_list:
-            title = "*New broadcast from Fed {}*\n".format(fedinfo["fname"])
-            try:
-                await bot.sendMessage(
-                    chat,
-                    title + text,
-                    parse_mode="markdown",
-                    message_thread_id=msg.message_thread_id if chat.is_forum else None,
-                )
-            except TelegramError:
-                try:
-                    await dispatcher.bot.getChat(chat)
-                except Forbidden:
-                    failed += 1
-                    sql.chat_leave_fed(chat)
-                    LOGGER.info(
-                        "Chat {} has left fed {} because I was kicked".format(
-                            chat,
-                            fedinfo["fname"],
-                        ),
-                    )
-                    continue
-                failed += 1
-                LOGGER.warning("Couldn't send broadcast to {}".format(str(chat)))
-
-        send_text = "The federation broadcast is complete"
-        if failed >= 1:
-            send_text += "{} the group failed to receive the message, probably because it left the Federation.".format(
-                failed,
-            )
-        await update.effective_message.reply_text(send_text)
-
-
-async def fed_ban_list(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args, chat_data = context.bot, context.args, context.chat_data
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    info = sql.get_fed_info(fed_id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not a part of any federation!",
-        )
-        return
-
-    if is_user_fed_owner(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only Federation owners can do this!")
-        return
-
-    user = update.effective_user
-    chat = update.effective_chat
-    getfban = sql.get_all_fban_users(fed_id)
-    if len(getfban) == 0:
-        await update.effective_message.reply_text(
-            "The federation ban list of {} is empty".format(info["fname"]),
-            parse_mode=ParseMode.HTML,
-        )
-        return
-
-    if args:
-        if args[0] == "json":
-            jam = time.time()
-            new_jam = jam + 1800
-            cek = get_chat(chat.id, chat_data)
-            if cek.get("status"):
-                if jam <= int(cek.get("value")):
-                    waktu = time.strftime(
-                        "%H:%M:%S %d/%m/%Y",
-                        time.localtime(cek.get("value")),
-                    )
-                    await update.effective_message.reply_text(
-                        "You can backup your data once every 30 minutes!\nYou can back up data again at `{}`".format(
-                            waktu,
-                        ),
-                        parse_mode=ParseMode.MARKDOWN,
-                    )
-                    return
-                else:
-                    if user.id not in DRAGONS:
-                        put_chat(chat.id, new_jam, chat_data)
-            else:
-                if user.id not in DRAGONS:
-                    put_chat(chat.id, new_jam, chat_data)
-            backups = ""
-            for users in getfban:
-                getuserinfo = sql.get_all_fban_users_target(fed_id, users)
-                json_parser = {
-                    "user_id": users,
-                    "first_name": getuserinfo["first_name"],
-                    "last_name": getuserinfo["last_name"],
-                    "user_name": getuserinfo["user_name"],
-                    "reason": getuserinfo["reason"],
-                }
-                backups += json.dumps(json_parser)
-                backups += "\n"
-            with BytesIO(str.encode(backups)) as output:
-                output.name = "mikobot_fbanned_users.json"
-                await update.effective_message.reply_document(
-                    document=output,
-                    filename="mikobot_fbanned_users.json",
-                    caption="Total {} User are blocked by the Federation {}.".format(
-                        len(getfban),
-                        info["fname"],
-                    ),
-                )
-            return
-        elif args[0] == "csv":
-            jam = time.time()
-            new_jam = jam + 1800
-            cek = get_chat(chat.id, chat_data)
-            if cek.get("status"):
-                if jam <= int(cek.get("value")):
-                    waktu = time.strftime(
-                        "%H:%M:%S %d/%m/%Y",
-                        time.localtime(cek.get("value")),
-                    )
-                    await update.effective_message.reply_text(
-                        "You can back up data once every 30 minutes!\nYou can back up data again at `{}`".format(
-                            waktu,
-                        ),
-                        parse_mode=ParseMode.MARKDOWN,
-                    )
-                    return
-                else:
-                    if user.id not in DRAGONS:
-                        put_chat(chat.id, new_jam, chat_data)
-            else:
-                if user.id not in DRAGONS:
-                    put_chat(chat.id, new_jam, chat_data)
-            backups = "id,firstname,lastname,username,reason\n"
-            for users in getfban:
-                getuserinfo = sql.get_all_fban_users_target(fed_id, users)
-                backups += (
-                    "{user_id},{first_name},{last_name},{user_name},{reason}".format(
-                        user_id=users,
-                        first_name=getuserinfo["first_name"],
-                        last_name=getuserinfo["last_name"],
-                        user_name=getuserinfo["user_name"],
-                        reason=getuserinfo["reason"],
-                    )
-                )
-                backups += "\n"
-            with BytesIO(str.encode(backups)) as output:
-                output.name = "mikobot_fbanned_users.csv"
-                await update.effective_message.reply_document(
-                    document=output,
-                    filename="mikobot_fbanned_users.csv",
-                    caption="Total {} User are blocked by Federation {}.".format(
-                        len(getfban),
-                        info["fname"],
-                    ),
-                )
-            return
-
-    text = "<b>{} users have been banned from the federation {}:</b>\n".format(
-        len(getfban),
-        info["fname"],
-    )
-    for users in getfban:
-        getuserinfo = sql.get_all_fban_users_target(fed_id, users)
-        if getuserinfo is False:
-            text = "There are no users banned from the federation {}".format(
-                info["fname"],
-            )
-            break
-        user_name = getuserinfo["first_name"]
-        if getuserinfo["last_name"]:
-            user_name += " " + getuserinfo["last_name"]
-        text += " • {} (<code>{}</code>)\n".format(
-            mention_html(users, user_name),
-            users,
-        )
-
-    try:
-        await update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
-    except:
-        jam = time.time()
-        new_jam = jam + 1800
-        cek = get_chat(chat.id, chat_data)
-        if cek.get("status"):
-            if jam <= int(cek.get("value")):
-                waktu = time.strftime(
-                    "%H:%M:%S %d/%m/%Y",
-                    time.localtime(cek.get("value")),
-                )
-                await update.effective_message.reply_text(
-                    "You can back up data once every 30 minutes!\nYou can back up data again at `{}`".format(
-                        waktu,
-                    ),
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-                return
-            else:
-                if user.id not in DRAGONS:
-                    put_chat(chat.id, new_jam, chat_data)
-        else:
-            if user.id not in DRAGONS:
-                put_chat(chat.id, new_jam, chat_data)
-        cleanr = re.compile("<.*?>")
-        cleantext = re.sub(cleanr, "", text)
-        with BytesIO(str.encode(cleantext)) as output:
-            output.name = "fbanlist.txt"
-            await update.effective_message.reply_document(
-                document=output,
-                filename="fbanlist.txt",
-                caption="The following is a list of users who are currently fbanned in the Federation {}.".format(
-                    info["fname"],
-                ),
-            )
-
-
-async def fed_notif(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-    fed_id = sql.get_fed_id(chat.id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not a part of any federation!",
-        )
-        return
-
-    if args:
-        if args[0] in ("yes", "on"):
-            sql.set_feds_setting(user.id, True)
-            await msg.reply_text(
-                "Reporting Federation back up! Every user who is fban / unfban you will be notified via PM.",
-            )
-        elif args[0] in ("no", "off"):
-            sql.set_feds_setting(user.id, False)
-            await msg.reply_text(
-                "Reporting Federation has stopped! Every user who is fban / unfban you will not be notified via PM.",
-            )
-        else:
-            await msg.reply_text("Please enter `on`/`off`", parse_mode="markdown")
-    else:
-        getreport = sql.user_feds_report(user.id)
-        await msg.reply_text(
-            "Your current Federation report preferences: `{}`".format(getreport),
-            parse_mode="markdown",
-        )
-
-
-async def fed_chats(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    info = sql.get_fed_info(fed_id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not a part of any federation!",
-        )
-        return
-
-    if is_user_fed_admin(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only federation admins can do this!")
-        return
-
-    getlist = sql.all_fed_chats(fed_id)
-    if len(getlist) == 0:
-        await update.effective_message.reply_text(
-            "No users are fbanned from the federation {}".format(info["fname"]),
-            parse_mode=ParseMode.HTML,
-        )
-        return
-
-    text = "<b>New chat joined the federation {}:</b>\n".format(info["fname"])
-    for chats in getlist:
-        try:
-            chat_obj = await dispatcher.bot.getChat(chats)
-            chat_name = chat_obj.title
-        except Forbidden:
-            sql.chat_leave_fed(chats)
-            LOGGER.info(
-                "Chat {} has leave fed {} because I was kicked".format(
-                    chats,
-                    info["fname"],
-                ),
-            )
-            continue
-        text += " • {} (<code>{}</code>)\n".format(chat_name, chats)
-
-    try:
-        await update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
-    except:
-        cleanr = re.compile("<.*?>")
-        cleantext = re.sub(cleanr, "", text)
-        with BytesIO(str.encode(cleantext)) as output:
-            output.name = "fedchats.txt"
-            await update.effective_message.reply_document(
-                document=output,
-                filename="fedchats.txt",
-                caption="Here is a list of all the chats that joined the federation {}.".format(
-                    info["fname"],
-                ),
-            )
-
-
-async def fed_import_bans(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, chat_data = context.bot, context.chat_data
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    info = sql.get_fed_info(fed_id)
-    getfed = sql.get_fed_info(fed_id)
-
-    if not fed_id:
-        await update.effective_message.reply_text(
-            "This group is not a part of any federation!",
-        )
-        return
-
-    if is_user_fed_owner(fed_id, user.id) is False:
-        await update.effective_message.reply_text("Only Federation owners can do this!")
-        return
-
-    if msg.reply_to_message and msg.reply_to_message.document:
-        jam = time.time()
-        new_jam = jam + 1800
-        cek = get_chat(chat.id, chat_data)
-        if cek.get("status"):
-            if jam <= int(cek.get("value")):
-                waktu = time.strftime(
-                    "%H:%M:%S %d/%m/%Y",
-                    time.localtime(cek.get("value")),
-                )
-                await update.effective_message.reply_text(
-                    "You can get your data once every 30 minutes!\nYou can get data again at `{}`".format(
-                        waktu,
-                    ),
-                    parse_mode=ParseMode.MARKDOWN,
-                )
-                return
-            else:
-                if user.id not in DRAGONS:
-                    put_chat(chat.id, new_jam, chat_data)
-        else:
-            if user.id not in DRAGONS:
-                put_chat(chat.id, new_jam, chat_data)
-        # if int(int(msg.reply_to_message.document.file_size)/1024) >= 200:
-        # 	msg.reply_text("This file is too big!")
-        # 	return
-        success = 0
-        failed = 0
-        try:
-            file_info = await bot.get_file(msg.reply_to_message.document.file_id)
-        except BadRequest:
-            await msg.reply_text(
-                "Try downloading and re-uploading the file, this one seems broken!",
-            )
-            return
-        fileformat = msg.reply_to_message.document.file_name.split(".")[-1]
-        if fileformat == "json":
-            multi_fed_id = []
-            multi_import_userid = []
-            multi_import_firstname = []
-            multi_import_lastname = []
-            multi_import_username = []
-            multi_import_reason = []
-            with BytesIO() as file:
-                file_info.download_to_object(out=file)
-                file.seek(0)
-                reading = file.read().decode("UTF-8")
-                splitting = reading.split("\n")
-                for x in splitting:
-                    if x == "":
-                        continue
-                    try:
-                        data = json.loads(x)
-                    except json.decoder.JSONDecodeError as err:
-                        failed += 1
-                        continue
-                    try:
-                        import_userid = int(data["user_id"])  # Make sure it int
-                        import_firstname = str(data["first_name"])
-                        import_lastname = str(data["last_name"])
-                        import_username = str(data["user_name"])
-                        import_reason = str(data["reason"])
-                    except ValueError:
-                        failed += 1
-                        continue
-                    # Checking user
-                    if int(import_userid) == bot.id:
-                        failed += 1
-                        continue
-                    if is_user_fed_owner(fed_id, import_userid) is True:
-                        failed += 1
-                        continue
-                    if is_user_fed_admin(fed_id, import_userid) is True:
-                        failed += 1
-                        continue
-                    if str(import_userid) == str(OWNER_ID):
-                        failed += 1
-                        continue
-                    if int(import_userid) in DRAGONS:
-                        failed += 1
-                        continue
-                    multi_fed_id.append(fed_id)
-                    multi_import_userid.append(str(import_userid))
-                    multi_import_firstname.append(import_firstname)
-                    multi_import_lastname.append(import_lastname)
-                    multi_import_username.append(import_username)
-                    multi_import_reason.append(import_reason)
-                    success += 1
-                sql.multi_fban_user(
-                    multi_fed_id,
-                    multi_import_userid,
-                    multi_import_firstname,
-                    multi_import_lastname,
-                    multi_import_username,
-                    multi_import_reason,
-                )
-            text = "Blocks were successfully imported. {} people are blocked.".format(
-                success,
-            )
-            if failed >= 1:
-                text += " {} Failed to import.".format(failed)
-            get_fedlog = await sql.get_fed_log(fed_id)
-            if get_fedlog:
-                if ast.literal_eval(get_fedlog):
-                    teks = "Fed *{}* has successfully imported data. {} banned.".format(
-                        getfed["fname"],
-                        success,
-                    )
-                    if failed >= 1:
-                        teks += " {} Failed to import.".format(failed)
-                    await bot.send_message(
-                        get_fedlog,
-                        teks,
-                        parse_mode="markdown",
-                        message_thread_id=update.effective_message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-        elif fileformat == "csv":
-            multi_fed_id = []
-            multi_import_userid = []
-            multi_import_firstname = []
-            multi_import_lastname = []
-            multi_import_username = []
-            multi_import_reason = []
-            file_info.download_to_drive(
-                "fban_{}.csv".format(msg.reply_to_message.document.file_id),
-            )
-            with open(
-                "fban_{}.csv".format(msg.reply_to_message.document.file_id),
-                "r",
-                encoding="utf8",
-            ) as csvFile:
-                reader = csv.reader(csvFile)
-                for data in reader:
-                    try:
-                        import_userid = int(data[0])  # Make sure it int
-                        import_firstname = str(data[1])
-                        import_lastname = str(data[2])
-                        import_username = str(data[3])
-                        import_reason = str(data[4])
-                    except ValueError:
-                        failed += 1
-                        continue
-                    # Checking user
-                    if int(import_userid) == bot.id:
-                        failed += 1
-                        continue
-                    if is_user_fed_owner(fed_id, import_userid) is True:
-                        failed += 1
-                        continue
-                    if is_user_fed_admin(fed_id, import_userid) is True:
-                        failed += 1
-                        continue
-                    if str(import_userid) == str(OWNER_ID):
-                        failed += 1
-                        continue
-                    if int(import_userid) in DRAGONS:
-                        failed += 1
-                        continue
-
-                    multi_fed_id.append(fed_id)
-                    multi_import_userid.append(str(import_userid))
-                    multi_import_firstname.append(import_firstname)
-                    multi_import_lastname.append(import_lastname)
-                    multi_import_username.append(import_username)
-                    multi_import_reason.append(import_reason)
-                    success += 1
-                    # t = ThreadWithReturnValue(target=sql.fban_user, args=(fed_id, str(import_userid), import_firstname, import_lastname, import_username, import_reason,))
-                    # t.start()
-                sql.multi_fban_user(
-                    multi_fed_id,
-                    multi_import_userid,
-                    multi_import_firstname,
-                    multi_import_lastname,
-                    multi_import_username,
-                    multi_import_reason,
-                )
-            csvFile.close()
-            os.remove("fban_{}.csv".format(msg.reply_to_message.document.file_id))
-            text = "Files were imported successfully. {} people banned.".format(success)
-            if failed >= 1:
-                text += " {} Failed to import.".format(failed)
-            get_fedlog = await sql.get_fed_log(fed_id)
-            if get_fedlog:
-                if ast.literal_eval(get_fedlog):
-                    teks = "Fed *{}* has successfully imported data. {} banned.".format(
-                        getfed["fname"],
-                        success,
-                    )
-                    if failed >= 1:
-                        teks += " {} Failed to import.".format(failed)
-                    await bot.send_message(
-                        get_fedlog,
-                        teks,
-                        parse_mode="markdown",
-                        message_thread_id=update.effective_message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-        else:
-            await send_message(update.effective_message, "This file is not supported.")
-            return
-        await send_message(update.effective_message, text)
-
-
-async def del_fed_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    userid = query.message.chat.id
-    fed_id = query.data.split("_")[1]
-
-    if fed_id == "cancel":
-        await query.message.edit_text("Federation deletion cancelled")
-        return
-
-    getfed = sql.get_fed_info(fed_id)
-    if getfed:
-        delete = sql.del_fed(fed_id)
-        if delete:
-            await query.message.edit_text(
-                "You have removed your Federation! Now all the Groups that are connected with `{}` do not have a Federation.".format(
-                    getfed["fname"],
-                ),
-                parse_mode="markdown",
-            )
-
-
-async def fed_stat_user(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if args:
-        if args[0].isdigit():
-            user_id = args[0]
-        else:
-            user_id = await extract_user(msg, context, args)
-    else:
-        user_id = await extract_user(msg, context, args)
-
-    if user_id:
-        if len(args) == 2 and args[0].isdigit():
-            fed_id = args[1]
-            user_name, reason, fbantime = sql.get_user_fban(fed_id, str(user_id))
-            if fbantime:
-                fbantime = time.strftime("%d/%m/%Y", time.localtime(fbantime))
-            else:
-                fbantime = "Unavaiable"
-            if user_name is False:
-                await send_message(
-                    update.effective_message,
-                    "Fed {} not found!".format(fed_id),
-                    parse_mode="markdown",
-                )
-                return
-            if user_name == "" or user_name is None:
-                user_name = "He/she"
-            if not reason:
-                await send_message(
-                    update.effective_message,
-                    "{} is not banned in this federation!".format(user_name),
-                )
-            else:
-                teks = "{} banned in this federation because:\n`{}`\n*Banned at:* `{}`".format(
-                    user_name,
-                    reason,
-                    fbantime,
-                )
-                await send_message(
-                    update.effective_message, teks, parse_mode="markdown"
-                )
-            return
-        user_name, fbanlist = sql.get_user_fbanlist(str(user_id))
-        if user_name == "":
-            try:
-                user_first = await bot.get_chat(user_id)
-                if isinstance(user_first, ChatMember):
-                    user_name = user_id.first_name
-            except BadRequest:
-                user_name = "He/she"
-            if user_name == "" or user_name is None:
-                user_name = "He/she"
-        if len(fbanlist) == 0:
-            await send_message(
-                update.effective_message,
-                "{} is not banned in any federation!".format(user_name),
-            )
-            return
-        else:
-            teks = "{} has been banned in this federation:\n".format(user_name)
-            for x in fbanlist:
-                teks += "- `{}`: {}\n".format(x[0], x[1][:20])
-            teks += "\nIf you want to find out more about the reasons for Fedban specifically, use /fbanstat <FedID>"
-            await send_message(update.effective_message, teks, parse_mode="markdown")
-
-    elif not msg.reply_to_message and not args:
-        user_id = msg.from_user.id
-        user_name, fbanlist = sql.get_user_fbanlist(user_id)
-        if user_name == "":
-            user_name = msg.from_user.first_name
-        if len(fbanlist) == 0:
-            await send_message(
-                update.effective_message,
-                "{} is not banned in any federation!".format(user_name),
-            )
-        else:
-            teks = "{} has been banned in this federation:\n".format(user_name)
-            for x in fbanlist:
-                teks += "- `{}`: {}\n".format(x[0], x[1][:20])
-            teks += "\nIf you want to find out more about the reasons for Fedban specifically, use /fbanstat <FedID>"
-            await send_message(update.effective_message, teks, parse_mode="markdown")
-
-    else:
-        fed_id = args[0]
-        fedinfo = sql.get_fed_info(fed_id)
-        if not fedinfo:
-            await send_message(
-                update.effective_message, "Fed {} not found!".format(fed_id)
-            )
-            return
-        name, reason, fbantime = sql.get_user_fban(fed_id, msg.from_user.id)
-        if fbantime:
-            fbantime = time.strftime("%d/%m/%Y", time.localtime(fbantime))
-        else:
-            fbantime = "Unavaiable"
-        if not name:
-            name = msg.from_user.first_name
-        if not reason:
-            await send_message(
-                update.effective_message,
-                "{} is not banned in this federation".format(name),
-            )
-            return
-        await send_message(
-            update.effective_message,
-            "{} banned in this federation because:\n`{}`\n*Banned at:* `{}`".format(
-                name,
-                reason,
-                fbantime,
-            ),
-            parse_mode="markdown",
-        )
-
-
-async def set_fed_log(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    if args:
-        fedinfo = sql.get_fed_info(args[0])
-        if not fedinfo:
-            await send_message(
-                update.effective_message, "This Federation does not exist!"
-            )
-            return
-        isowner = is_user_fed_owner(args[0], user.id)
-        if not isowner:
-            await send_message(
-                update.effective_message,
-                "Only federation creator can set federation logs.",
-            )
-            return
-        setlog = sql.set_fed_log(args[0], chat.id)
-        if setlog:
-            await send_message(
-                update.effective_message,
-                "Federation log `{}` has been set to {}".format(
-                    fedinfo["fname"],
-                    chat.title,
-                ),
-                parse_mode="markdown",
-            )
-    else:
-        await send_message(
-            update.effective_message,
-            "You have not provided your federated ID!",
-        )
-
-
-async def unset_fed_log(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    if args:
-        fedinfo = sql.get_fed_info(args[0])
-        if not fedinfo:
-            await send_message(
-                update.effective_message, "This Federation does not exist!"
-            )
-            return
-        isowner = is_user_fed_owner(args[0], user.id)
-        if not isowner:
-            await send_message(
-                update.effective_message,
-                "Only federation creator can set federation logs.",
-            )
-            return
-        setlog = sql.set_fed_log(args[0], None)
-        if setlog:
-            await send_message(
-                update.effective_message,
-                "Federation log `{}` has been revoked on {}".format(
-                    fedinfo["fname"],
-                    chat.title,
-                ),
-                parse_mode="markdown",
-            )
-    else:
-        await send_message(
-            update.effective_message,
-            "You have not provided your federated ID!",
-        )
-
-
-async def subs_feds(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    fedinfo = sql.get_fed_info(fed_id)
-
-    if not fed_id:
-        await send_message(
-            update.effective_message, "This group is not in any federation!"
-        )
-        return
-
-    if is_user_fed_owner(fed_id, user.id) is False:
-        await send_message(update.effective_message, "Only fed owner can do this!")
-        return
-
-    if args:
-        getfed = sql.search_fed_by_id(args[0])
-        if getfed is False:
-            await send_message(
-                update.effective_message,
-                "Please enter a valid federation id.",
-            )
-            return
-        subfed = sql.subs_fed(args[0], fed_id)
-        if subfed:
-            await send_message(
-                update.effective_message,
-                "Federation `{}` has subscribe the federation `{}`. Every time there is a Fedban from that federation, this federation will also banned that user.".format(
-                    fedinfo["fname"],
-                    getfed["fname"],
-                ),
-                parse_mode="markdown",
-            )
-            get_fedlog = await sql.get_fed_log(args[0])
-            if get_fedlog:
-                if int(get_fedlog) != int(chat.id):
-                    await bot.send_message(
-                        get_fedlog,
-                        "Federation `{}` has subscribe the federation `{}`".format(
-                            fedinfo["fname"],
-                            getfed["fname"],
-                        ),
-                        parse_mode="markdown",
-                        message_thread_id=update.effective_message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-        else:
-            await send_message(
-                update.effective_message,
-                "Federation `{}` already subscribe the federation `{}`.".format(
-                    fedinfo["fname"],
-                    getfed["fname"],
-                ),
-                parse_mode="markdown",
-            )
-    else:
-        await send_message(
-            update.effective_message,
-            "You have not provided your federated ID!",
-        )
-
-
-async def unsubs_feds(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    fedinfo = sql.get_fed_info(fed_id)
-
-    if not fed_id:
-        await send_message(
-            update.effective_message, "This group is not in any federation!"
-        )
-        return
-
-    if is_user_fed_owner(fed_id, user.id) is False:
-        await send_message(update.effective_message, "Only fed owner can do this!")
-        return
-
-    if args:
-        getfed = sql.search_fed_by_id(args[0])
-        if getfed is False:
-            await send_message(
-                update.effective_message,
-                "Please enter a valid federation id.",
-            )
-            return
-        subfed = sql.unsubs_fed(args[0], fed_id)
-        if subfed:
-            await send_message(
-                update.effective_message,
-                "Federation `{}` now unsubscribe fed `{}`.".format(
-                    fedinfo["fname"],
-                    getfed["fname"],
-                ),
-                parse_mode="markdown",
-            )
-            get_fedlog = await sql.get_fed_log(args[0])
-            if get_fedlog:
-                if int(get_fedlog) != int(chat.id):
-                    await bot.send_message(
-                        get_fedlog,
-                        "Federation `{}` has unsubscribe fed `{}`.".format(
-                            fedinfo["fname"],
-                            getfed["fname"],
-                        ),
-                        parse_mode="markdown",
-                        message_thread_id=update.effective_message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-        else:
-            await send_message(
-                update.effective_message,
-                "Federation `{}` is not subscribing `{}`.".format(
-                    fedinfo["fname"],
-                    getfed["fname"],
-                ),
-                parse_mode="markdown",
-            )
-    else:
-        await send_message(
-            update.effective_message,
-            "You have not provided your federated ID!",
-        )
-
-
-async def get_myfedsubs(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    if chat.type == "private":
-        await send_message(
-            update.effective_message,
-            "This command is specific to the group, not to our pm!",
-        )
-        return
-
-    fed_id = sql.get_fed_id(chat.id)
-    fedinfo = sql.get_fed_info(fed_id)
-
-    if not fed_id:
-        await send_message(
-            update.effective_message, "This group is not in any federation!"
-        )
-        return
-
-    if is_user_fed_owner(fed_id, user.id) is False:
-        await send_message(update.effective_message, "Only fed owner can do this!")
-        return
-
-    try:
-        getmy = sql.get_mysubs(fed_id)
-    except:
-        getmy = []
-
-    if len(getmy) == 0:
-        await send_message(
-            update.effective_message,
-            "Federation `{}` is not subscribing any federation.".format(
-                fedinfo["fname"],
-            ),
-            parse_mode="markdown",
-        )
-        return
-    else:
-        listfed = "Federation `{}` is subscribing federation:\n".format(
-            fedinfo["fname"],
-        )
-        for x in getmy:
-            listfed += "- `{}`\n".format(x)
-        listfed += (
-            "\nTo get fed info `/fedinfo <fedid>`. To unsubscribe `/unsubfed <fedid>`."
-        )
-        await send_message(update.effective_message, listfed, parse_mode="markdown")
-
-
-async def get_myfeds_list(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    fedowner = sql.get_user_owner_fed_full(user.id)
-    if fedowner:
-        text = "*You are owner of feds:\n*"
-        for f in fedowner:
-            text += "- `{}`: *{}*\n".format(f["fed_id"], f["fed"]["fname"])
-    else:
-        text = "*You are not have any feds!*"
-    await send_message(update.effective_message, text, parse_mode="markdown")
-
-
-def is_user_fed_admin(fed_id, user_id):
-    fed_admins = sql.all_fed_users(fed_id)
-    if fed_admins is False:
-        return False
-    if int(user_id) in fed_admins or int(user_id) == OWNER_ID:
-        return True
-    else:
-        return False
-
-
-def is_user_fed_owner(fed_id, user_id):
-    getsql = sql.get_fed_info(fed_id)
-    if getsql is False:
-        return False
-    getfedowner = ast.literal_eval(getsql["fusers"])
-    if getfedowner is None or getfedowner is False:
-        return False
-    getfedowner = getfedowner["owner"]
-    if str(user_id) == getfedowner or int(user_id) == OWNER_ID:
-        return True
-    else:
-        return False
-
-
-# There's no handler for this yet, but updating for v12 in case its used
-
-
-async def welcome_fed(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    fed_id = sql.get_fed_id(chat.id)
-    fban, fbanreason, fbantime = sql.get_fban_user(fed_id, user.id)
-    if fban:
-        await update.effective_message.reply_text(
-            "This user is banned in current federation! I will remove him.",
-        )
-        await bot.ban_chat_member(chat.id, user.id)
-        return True
-    else:
-        return False
-
-
-def __stats__():
-    all_fbanned = sql.get_all_fban_users_global()
-    all_feds = sql.get_all_feds_users_global()
-    return "• {} banned users across {} Federations".format(
-        len(all_fbanned),
-        len(all_feds),
-    )
-
-
-def __user_info__(user_id, chat_id):
-    fed_id = sql.get_fed_id(chat_id)
-    if fed_id:
-        fban, fbanreason, fbantime = sql.get_fban_user(fed_id, user_id)
-        info = sql.get_fed_info(fed_id)
-        infoname = info["fname"]
-
-        if int(info["owner"]) == user_id:
-            text = "Federation owner of: <b>{}</b>.".format(infoname)
-        elif is_user_fed_admin(fed_id, user_id):
-            text = "Federation admin of: <b>{}</b>.".format(infoname)
-
-        elif fban:
-            text = "Federation banned: <b>Yes</b>"
-            text += "\n<b>Reason:</b> {}".format(fbanreason)
-        else:
-            text = "Federation banned: <b>No</b>"
-    else:
-        text = ""
-    return text
-
-
-# Temporary data
-def put_chat(chat_id, value, chat_data):
-    # print(chat_data)
-    if value is False:
-        status = False
-    else:
-        status = True
-    chat_data[chat_id] = {"federation": {"status": status, "value": value}}
-
-
-def get_chat(chat_id, chat_data):
-    # print(chat_data)
-    try:
-        value = chat_data[chat_id]["federation"]
-        return value
-    except KeyError:
-        return {"status": False, "value": False}
-
-
-async def fed_owner_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.effective_message.reply_text(
-        """*👑 Fed Owner Only:*
- » `/newfed <fed_name>`*:* Creates a Federation, One allowed per user
- » `/renamefed <fed_id> <new_fed_name>`*:* Renames the fed id to a new name
- » `/delfed <fed_id>`*:* Delete a Federation, and any information related to it. Will not cancel blocked users
- » `/fpromote <user>`*:* Assigns the user as a federation admin. Enables all commands for the user under `Fed Admins`
- » `/fdemote <user>`*:* Drops the User from the admin Federation to a normal User
- » `/subfed <fed_id>`*:* Subscribes to a given fed ID, bans from that subscribed fed will also happen in your fed
- » `/unsubfed <fed_id>`*:* Unsubscribes to a given fed ID
- » `/setfedlog <fed_id>`*:* Sets the group as a fed log report base for the federation
- » `/unsetfedlog <fed_id>`*:* Removed the group as a fed log report base for the federation
- » `/fbroadcast <message>`*:* Broadcasts a messages to all groups that have joined your fed
- » `/fedsubs`*:* Shows the feds your group is subscribed to `(broken rn)`""",
-        parse_mode=ParseMode.MARKDOWN,
-    )
-
-
-async def fed_admin_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.effective_message.reply_text(
-        """*🔱 Fed Admins:*
- » `/fban <user> <reason>`*:* Fed bans a user
- » `/unfban <user> <reason>`*:* Removes a user from a fed ban
- » `/fedinfo <fed_id>`*:* Information about the specified Federation
- » `/joinfed <fed_id>`*:* Join the current chat to the Federation. Only chat owners can do this. Every chat can only be in one Federation
- » `/leavefed <fed_id>`*:* Leave the Federation given. Only chat owners can do this
- » `/setfrules <rules>`*:* Arrange Federation rules
- » `/fedadmins`*:* Show Federation admin
- » `/fbanlist`*:* Displays all users who are victimized at the Federation at this time
- » `/fedchats`*:* Get all the chats that are connected in the Federation
- » `/chatfed `*:* See the Federation in the current chat\n""",
-        parse_mode=ParseMode.MARKDOWN,
-    )
-
-
-async def fed_user_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.effective_message.reply_text(
-        """*🎩 Any user:*
- » `/fbanstat`*:* Shows if you/or the user you are replying to or their username is fbanned somewhere or not
- » `/fednotif <on/off>`*:* Federation settings not in PM when there are users who are fbaned/unfbanned
- » `/frules`*:* See Federation regulations\n""",
-        parse_mode=ParseMode.MARKDOWN,
-    )
-
-
-# <=================================================== HELP ====================================================>
-
-
-__mod_name__ = "FEDS"
-
-__help__ = """
-➠ *Everything is fun, until a spammer starts entering your group, and you have to block it. Then you need to start banning more, and more, and it hurts*.
-*But then you have many groups, and you don't want this spammer to be in one of your groups - how can you deal? Do you have to manually block it, in all your groups*?\n
-*No longer!* *With Federation, you can make a ban in one chat overlap with all other chats*.\n
-*You can even designate federation admins, so your trusted admin can ban all the spammers from chats you want to protect*.\n
-
-➠ *Commands:*
-➠ Feds are now divided into 3 sections for your ease.
-
-» /fedownerhelp: Provides help for fed creation and owner only commands.
-
-» /fedadminhelp: Provides help for fed administration commands.
-
-» /feduserhelp: Provides help for commands anyone can use.
-
-"""
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("newfed", new_fed, block=False))
-function(CommandHandler("delfed", del_fed, block=False))
-function(CommandHandler("renamefed", rename_fed, block=False))
-function(CommandHandler("joinfed", join_fed, block=False))
-function(CommandHandler("leavefed", leave_fed, block=False))
-function(CommandHandler("fpromote", user_join_fed, block=False))
-function(CommandHandler("fdemote", user_demote_fed, block=False))
-function(CommandHandler("fedinfo", fed_info, block=False))
-function(DisableAbleCommandHandler("fban", fed_ban, block=False))
-function(CommandHandler("unfban", unfban, block=False))
-function(CommandHandler("fbroadcast", fed_broadcast, block=False))
-function(CommandHandler("setfrules", set_frules, block=False))
-function(CommandHandler("frules", get_frules, block=False))
-function(CommandHandler("chatfed", fed_chat, block=False))
-function(CommandHandler("fedadmins", fed_admin, block=False))
-function(CommandHandler("fbanlist", fed_ban_list, block=False))
-function(CommandHandler("fednotif", fed_notif, block=False))
-function(CommandHandler("fedchats", fed_chats, block=False))
-function(CommandHandler("importfbans", fed_import_bans, block=False))
-function(DisableAbleCommandHandler(["fedstat", "fbanstat"], fed_stat_user, block=False))
-function(CommandHandler("setfedlog", set_fed_log, block=False))
-function(CommandHandler("unsetfedlog", unset_fed_log, block=False))
-function(CommandHandler("subfed", subs_feds, block=False))
-function(CommandHandler("unsubfed", unsubs_feds, block=False))
-function(CommandHandler("fedsubs", get_myfedsubs, block=False))
-function(CommandHandler("myfeds", get_myfeds_list, block=False))
-function(CallbackQueryHandler(del_fed_button, pattern=r"rmfed_", block=False))
-function(CommandHandler("fedownerhelp", fed_owner_help, block=False))
-function(CommandHandler("fedadminhelp", fed_admin_help, block=False))
-function(CommandHandler("feduserhelp", fed_user_help, block=False))
-# <================================================ END =======================================================>

Mikobot/plugins/flood.py

@@ -1,457 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-import re
-
-from telegram import ChatPermissions, Update
-from telegram.error import BadRequest
-from telegram.ext import (
-    CallbackQueryHandler,
-    CommandHandler,
-    ContextTypes,
-    MessageHandler,
-    filters,
-)
-from telegram.helpers import mention_html
-
-from Database.sql import antiflood_sql as sql
-from Database.sql.approve_sql import is_approved
-from Mikobot import dispatcher, function
-from Mikobot.plugins.connection import connected
-from Mikobot.plugins.helper_funcs.alternate import send_message
-from Mikobot.plugins.helper_funcs.chat_status import check_admin, is_user_admin
-from Mikobot.plugins.helper_funcs.string_handling import extract_time
-from Mikobot.plugins.log_channel import loggable
-
-# <=======================================================================================================>
-
-FLOOD_GROUP = 3
-
-
-# <================================================ FUNCTION =======================================================>
-@loggable
-async def check_flood(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    user = update.effective_user
-    chat = update.effective_chat
-    msg = update.effective_message
-    if not user:
-        return ""
-
-    if await is_user_admin(chat, user.id):
-        sql.update_flood(chat.id, None)
-        return ""
-
-    if is_approved(chat.id, user.id):
-        sql.update_flood(chat.id, None)
-        return
-
-    should_ban = sql.update_flood(chat.id, user.id)
-    if not should_ban:
-        return ""
-
-    try:
-        getmode, getvalue = sql.get_flood_setting(chat.id)
-        if getmode == 1:
-            await chat.ban_member(user.id)
-            execstrings = "BANNED"
-            tag = "BANNED"
-        elif getmode == 2:
-            await chat.ban_member(user.id)
-            await chat.unban_member(user.id)
-            execstrings = "KICKED"
-            tag = "KICKED"
-        elif getmode == 3:
-            await context.bot.restrict_chat_member(
-                chat.id,
-                user.id,
-                permissions=ChatPermissions(can_send_messages=False),
-            )
-            execstrings = "MUTED"
-            tag = "MUTED"
-        elif getmode == 4:
-            bantime = await extract_time(msg, getvalue)
-            await chat.ban_member(user.id, until_date=bantime)
-            execstrings = "BANNED for {}".format(getvalue)
-            tag = "TBAN"
-        elif getmode == 5:
-            mutetime = await extract_time(msg, getvalue)
-            await context.bot.restrict_chat_member(
-                chat.id,
-                user.id,
-                until_date=mutetime,
-                permissions=ChatPermissions(can_send_messages=False),
-            )
-            execstrings = "MUTED for {}".format(getvalue)
-            tag = "TMUTE"
-        await send_message(
-            update.effective_message,
-            "Beep boop! Boop beep!\n{}!".format(execstrings),
-        )
-
-        return (
-            "<b>{}:</b>"
-            "\n#{}"
-            "\n<b>user:</b> {}"
-            "\nFlooded the group.".format(
-                tag,
-                html.escape(chat.title),
-                mention_html(user.id, html.escape(user.first_name)),
-            )
-        )
-
-    except BadRequest:
-        await msg.reply_text(
-            "I can't restrict people here, give me permissions first! Until then, I'll disable anti-flood.",
-        )
-        sql.set_flood(chat.id, 0)
-        return (
-            "<b>{}:</b>"
-            "\n#INFO"
-            "\nDon't have enough permission to restrict users so automatically disabled anti-flood.".format(
-                chat.title,
-            )
-        )
-
-
-@check_admin(permission="can_restrict_members", is_both=True, no_reply=True)
-async def flood_button(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot = context.bot
-    query = update.callback_query
-    user = update.effective_user
-    match = re.match(r"unmute_flooder\((.+?)\)", query.data)
-    if match:
-        user_id = match.group(1)
-        chat = update.effective_chat.id
-        try:
-            await bot.restrict_chat_member(
-                chat,
-                int(user_id),
-                permissions=ChatPermissions(
-                    can_send_messages=True,
-                    can_send_media_messages=True,
-                    can_send_other_messages=True,
-                    can_add_web_page_previews=True,
-                ),
-            )
-            await update.effective_message.edit_text(
-                f"Unmuted by {mention_html(user.id, html.escape(user.first_name))}.",
-                parse_mode="HTML",
-            )
-        except:
-            pass
-
-
-@loggable
-@check_admin(is_user=True)
-async def set_flood(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-    args = context.args
-
-    conn = await connected(context.bot, update, chat, user.id, need_admin=True)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if update.effective_message.chat.type == "private":
-            await send_message(
-                update.effective_message,
-                "This command is meant to use in a group, not in PM.",
-            )
-            return ""
-        chat_id = update.effective_chat.id
-        chat_name = update.effective_message.chat.title
-
-    if len(args) >= 1:
-        val = args[0].lower()
-        if val in ["off", "no", "0"]:
-            sql.set_flood(chat_id, 0)
-            if conn:
-                text = await message.reply_text(
-                    "Antiflood has been disabled in {}.".format(chat_name),
-                )
-            else:
-                text = await message.reply_text("Antiflood has been disabled.")
-
-        elif val.isdigit():
-            amount = int(val)
-            if amount <= 0:
-                sql.set_flood(chat_id, 0)
-                if conn:
-                    text = await message.reply_text(
-                        "Antiflood has been disabled in {}.".format(chat_name),
-                    )
-                else:
-                    text = await message.reply_text("Antiflood has been disabled.")
-                return (
-                    "<b>{}:</b>"
-                    "\n#SETFLOOD"
-                    "\n<b>Admin:</b> {}"
-                    "\nDisable Antiflood.".format(
-                        html.escape(chat_name),
-                        mention_html(user.id, html.escape(user.first_name)),
-                    )
-                )
-
-            elif amount <= 3:
-                await send_message(
-                    update.effective_message,
-                    "Antiflood must be either 0 (disabled) or a number greater than 3!",
-                )
-                return ""
-
-            else:
-                sql.set_flood(chat_id, amount)
-                if conn:
-                    text = await message.reply_text(
-                        "Antiflood limit has been set to {} in chat: {}".format(
-                            amount,
-                            chat_name,
-                        ),
-                    )
-                else:
-                    text = await message.reply_text(
-                        "Successfully updated antiflood limit to {}!".format(amount),
-                    )
-                return (
-                    "<b>{}:</b>"
-                    "\n#SETFLOOD"
-                    "\n<b>Admin:</b> {}"
-                    "\nSet Antiflood to <code>{}</code>.".format(
-                        html.escape(chat_name),
-                        mention_html(user.id, html.escape(user.first_name)),
-                        amount,
-                    )
-                )
-
-        else:
-            await message.reply_text(
-                "Invalid argument, please use a number, 'off', or 'no'."
-            )
-    else:
-        await message.reply_text(
-            (
-                "Use `/setflood number` to enable antiflood.\n"
-                "Or use `/setflood off` to disable antiflood."
-            ),
-            parse_mode="markdown",
-        )
-    return ""
-
-
-async def flood(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-
-    conn = await connected(context.bot, update, chat, user.id, need_admin=False)
-    if conn:
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if update.effective_message.chat.type == "private":
-            await send_message(
-                update.effective_message,
-                "This command is meant to use in a group, not in PM.",
-            )
-            return
-        chat_id = update.effective_chat.id
-        chat_name = update.effective_message.chat.title
-
-    limit = sql.get_flood_limit(chat_id)
-    if limit == 0:
-        if conn:
-            text = await msg.reply_text(
-                "I'm not enforcing any flood control in {}!".format(chat_name),
-            )
-        else:
-            text = await msg.reply_text("I'm not enforcing any flood control here!")
-    else:
-        if conn:
-            text = await msg.reply_text(
-                "I'm currently restricting members after {} consecutive messages in {}.".format(
-                    limit,
-                    chat_name,
-                ),
-            )
-        else:
-            text = await msg.reply_text(
-                "I'm currently restricting members after {} consecutive messages.".format(
-                    limit,
-                ),
-            )
-
-
-@check_admin(is_user=True)
-async def set_flood_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    msg = update.effective_message
-    args = context.args
-
-    conn = await connected(context.bot, update, chat, user.id, need_admin=True)
-    if conn:
-        chat = await dispatcher.bot.getChat(conn)
-        chat_id = conn
-        chat_obj = await dispatcher.bot.getChat(conn)
-        chat_name = chat_obj.title
-    else:
-        if update.effective_message.chat.type == "private":
-            await send_message(
-                update.effective_message,
-                "This command is meant to use in a group, not in PM.",
-            )
-            return ""
-        chat = update.effective_chat
-        chat_id = update.effective_chat.id
-        chat_name = update.effective_message.chat.title
-
-    if args:
-        if args[0].lower() == "ban":
-            settypeflood = "ban"
-            sql.set_flood_strength(chat_id, 1, "0")
-        elif args[0].lower() == "kick":
-            settypeflood = "kick"
-            sql.set_flood_strength(chat_id, 2, "0")
-        elif args[0].lower() == "mute":
-            settypeflood = "mute"
-            sql.set_flood_strength(chat_id, 3, "0")
-        elif args[0].lower() == "tban":
-            if len(args) == 1:
-                teks = """It looks like you tried to set time value for antiflood but you didn't specified time; Try, `/setfloodmode tban <timevalue>`.
-Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message, teks, parse_mode="markdown"
-                )
-                return
-            settypeflood = "tban for {}".format(args[1])
-            sql.set_flood_strength(chat_id, 4, str(args[1]))
-        elif args[0].lower() == "tmute":
-            if len(args) == 1:
-                teks = """It looks like you tried to set time value for antiflood but you didn't specified time; Try, `/setfloodmode tmute <timevalue>`.
-Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
-                await send_message(
-                    update.effective_message, teks, parse_mode="markdown"
-                )
-                return
-            settypeflood = "tmute for {}".format(args[1])
-            sql.set_flood_strength(chat_id, 5, str(args[1]))
-        else:
-            await send_message(
-                update.effective_message,
-                "I only understand ban/kick/mute/tban/tmute!",
-            )
-            return
-        if conn:
-            text = await msg.reply_text(
-                "Exceeding consecutive flood limit will result in {} in {}!".format(
-                    settypeflood,
-                    chat_name,
-                ),
-            )
-        else:
-            text = await msg.reply_text(
-                "Exceeding consecutive flood limit will result in {}!".format(
-                    settypeflood,
-                ),
-            )
-        return (
-            "<b>{}:</b>\n"
-            "<b>Admin:</b> {}\n"
-            "Has changed antiflood mode. User will {}.".format(
-                settypeflood,
-                html.escape(chat.title),
-                mention_html(user.id, html.escape(user.first_name)),
-            )
-        )
-    else:
-        getmode, getvalue = sql.get_flood_setting(chat.id)
-        if getmode == 1:
-            settypeflood = "ban"
-        elif getmode == 2:
-            settypeflood = "kick"
-        elif getmode == 3:
-            settypeflood = "mute"
-        elif getmode == 4:
-            settypeflood = "tban for {}".format(getvalue)
-        elif getmode == 5:
-            settypeflood = "tmute for {}".format(getvalue)
-        if conn:
-            text = await msg.reply_text(
-                "Sending more messages than flood limit will result in {} in {}.".format(
-                    settypeflood,
-                    chat_name,
-                ),
-            )
-        else:
-            text = await msg.reply_text(
-                "Sending more messages than flood limit will result in {}.".format(
-                    settypeflood,
-                ),
-            )
-    return ""
-
-
-def __migrate__(old_chat_id, new_chat_id):
-    sql.migrate_chat(old_chat_id, new_chat_id)
-
-
-def __chat_settings__(chat_id, user_id):
-    limit = sql.get_flood_limit(chat_id)
-    if limit == 0:
-        return "Not enforcing flood control."
-    else:
-        return "Antiflood has been set to `{}`.".format(limit)
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-➠ *Antiflood allows you to take action on users that send more than x messages in a row. Exceeding the set flood will result in restricting that user.*
-
-➠ *Admin Only*
-
-» /flood: Get the current antiflood settings.
-
-» /setflood <number/off/no>: Set the number of messages after which to take action on a user. Set to '0', 'off', or 'no' to disable.
-
-» /setfloodmode <action type>: Choose which action to take on a user who has been flooding. Options: ban/kick/mute/tban/tmute.
-"""
-
-__mod_name__ = "ANTI-FLOOD"
-
-# <================================================ HANDLER =======================================================>
-FLOOD_BAN_HANDLER = MessageHandler(
-    filters.ALL & ~filters.StatusUpdate.ALL & filters.ChatType.GROUPS,
-    check_flood,
-    block=False,
-)
-SET_FLOOD_HANDLER = CommandHandler(
-    "setflood", set_flood, filters=filters.ChatType.GROUPS, block=False
-)
-SET_FLOOD_MODE_HANDLER = CommandHandler(
-    "setfloodmode", set_flood_mode, block=False
-)  # , filters=filters.ChatType.GROUPS)
-FLOOD_QUERY_HANDLER = CallbackQueryHandler(
-    flood_button, pattern=r"unmute_flooder", block=False
-)
-FLOOD_HANDLER = CommandHandler(
-    "flood", flood, filters=filters.ChatType.GROUPS, block=False
-)
-
-function(FLOOD_BAN_HANDLER, FLOOD_GROUP)
-function(FLOOD_QUERY_HANDLER)
-function(SET_FLOOD_HANDLER)
-function(SET_FLOOD_MODE_HANDLER)
-function(FLOOD_HANDLER)
-
-__handlers__ = [
-    (FLOOD_BAN_HANDLER, FLOOD_GROUP),
-    SET_FLOOD_HANDLER,
-    FLOOD_HANDLER,
-    SET_FLOOD_MODE_HANDLER,
-]
-# <================================================ END =======================================================>

Mikobot/plugins/fsub.py

@@ -1,189 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from telethon import Button, events, types
-from telethon.errors import ChatAdminRequiredError, UserNotParticipantError
-from telethon.tl.functions.channels import GetParticipantRequest
-
-from Database.mongodb import fsub_db as db
-from Mikobot import BOT_ID
-from Mikobot import DRAGONS as DEVS
-from Mikobot import OWNER_ID, tbot
-from Mikobot.events import register
-
-# <=======================================================================================================>
-
-# Constants
-F_SUBSCRIBE_COMMAND = "/(fsub|Fsub|forcesubscribe|Forcesub|forcesub|Forcesubscribe)"
-FORCESUBSCRIBE_ON = ["on", "yes", "y"]
-FORCESUBSCRIBE_OFF = ["off", "no", "n"]
-
-
-# <================================================ FUNCTION =======================================================>
-def fsk_ck(**args):
-    def decorator(func):
-        tbot.add_event_handler(func, events.CallbackQuery(**args))
-        return func
-
-    return decorator
-
-
-# Helper functions
-async def is_admin(chat_id, user_id):
-    try:
-        p = await tbot(GetParticipantRequest(chat_id, user_id))
-    except UserNotParticipantError:
-        return False
-    return isinstance(
-        p.participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator)
-    )
-
-
-async def participant_check(channel, user_id):
-    try:
-        await tbot(GetParticipantRequest(channel, int(user_id)))
-        return True
-    except UserNotParticipantError:
-        return False
-    except Exception:
-        return False
-
-
-# Main command function
-@register(pattern=f"^{F_SUBSCRIBE_COMMAND} ?(.*)")
-async def force_subscribe(event):
-    """Handle the force subscribe command."""
-    if event.is_private:
-        return
-
-    if event.is_group:
-        perm = await event.client.get_permissions(event.chat_id, event.sender_id)
-        if not perm.is_admin:
-            return await event.reply("You need to be an admin to do this.")
-
-        if not perm.is_creator:
-            return await event.reply(
-                "❗ Group creator required\nYou have to be the group creator to do that."
-            )
-
-    try:
-        channel = event.text.split(None, 1)[1]
-    except IndexError:
-        channel = None
-
-    if not channel:
-        chat_db = db.fs_settings(event.chat_id)
-        if not chat_db:
-            await event.reply("Force subscribe is disabled in this chat.")
-        else:
-            await event.reply(
-                f"Force subscribe is currently enabled. Users are forced to join @{chat_db.channel} to speak here."
-            )
-    elif channel.lower() in FORCESUBSCRIBE_ON:
-        await event.reply("Please specify the channel username.")
-    elif channel.lower() in FORCESUBSCRIBE_OFF:
-        await event.reply("**Force subscribe is disabled successfully.**")
-        db.disapprove(event.chat_id)
-    else:
-        try:
-            channel_entity = await event.client.get_entity(channel)
-        except:
-            return await event.reply("Invalid channel username provided.")
-
-        channel = channel_entity.username
-        try:
-            if not channel_entity.broadcast:
-                return await event.reply("That's not a valid channel.")
-        except:
-            return await event.reply("That's not a valid channel.")
-
-        if not await participant_check(channel, BOT_ID):
-            return await event.reply(
-                f"**Not an admin in the channel**\nI am not an admin in the [channel](https://t.me/{channel}). Add me as an admin to enable force subscribe.",
-                link_preview=False,
-            )
-
-        db.add_channel(event.chat_id, str(channel))
-        await event.reply(f"Force subscribe is enabled to @{channel}.")
-
-
-# Event handler for new messages
-@tbot.on(events.NewMessage())
-async def force_subscribe_new_message(e):
-    """Handle new messages for force subscribe."""
-    if not db.fs_settings(e.chat_id):
-        return
-
-    if e.is_private or not e.from_id or e.sender_id in DEVS or e.sender_id == OWNER_ID:
-        return
-
-    if not e.chat.admin_rights or not e.chat.admin_rights.ban_users:
-        return
-
-    try:
-        channel = db.fs_settings(e.chat_id)["channel"]
-        check = await participant_check(channel, e.sender_id)
-    except (ChatAdminRequiredError, UserNotParticipantError):
-        return
-
-    if not check:
-        buttons = [
-            Button.url("Join Channel", f"t.me/{channel}"),
-            Button.inline("Unmute Me", data=f"fs_{e.sender_id}"),
-        ]
-
-        txt = f'<b><a href="tg://user?id={e.sender_id}">{e.sender.first_name}</a></b>, you have <b>not subscribed</b> to our <b><a href="t.me/{channel}">channel</a></b> yet. Please <b><a href="t.me/{channel}">join</a></b> and press the button below to unmute yourself.'
-        await e.reply(txt, buttons=buttons, parse_mode="html", link_preview=False)
-        await e.client.edit_permissions(e.chat_id, e.sender_id, send_messages=False)
-
-
-# Inline query handler
-@fsk_ck(pattern=r"fs(\_(.*))")
-async def unmute_force_subscribe(event):
-    """Handle inline query for unmuting force subscribe."""
-    user_id = int(((event.pattern_match.group(1)).decode()).split("_", 1)[1])
-
-    if not event.sender_id == user_id:
-        return await event.answer("This is not meant for you.", alert=True)
-
-    channel = db.fs_settings(event.chat_id)["channel"]
-    try:
-        check = await participant_check(channel, user_id)
-    except ChatAdminRequiredError:
-        check = False
-        return
-
-    if not check:
-        return await event.answer(
-            "You have to join the channel first, to get unmuted!", alert=True
-        )
-
-    try:
-        await event.client.edit_permissions(event.chat_id, user_id, send_messages=True)
-    except ChatAdminRequiredError:
-        pass
-
-    await event.delete()
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-➠ *Dazai has the capability to hush members who haven't yet subscribed to your channel until they decide to hit that subscribe button.*
-➠ *When activated, I'll silence those who are not subscribed and provide them with an option to unmute. Once they click the button, I'll lift the mute.*
-
-➠ Configuration Process
-➠ Exclusively for Creators
-➠ Grant me admin privileges in your group
-➠ Designate me as an admin in your channel
-
-➠ *Commands*
-» /fsub channel\_username - to initiate and customize settings for the channel.
-
-➠ *Kick things off with...*
-» /fsub - to review the current settings.
-» /fsub off - to deactivate the force subscription feature.
-
-➠ *If you disable fsub, you'll need to set it up again for it to take effect. Utilize /fsub channel\_username.*
-"""
-__mod_name__ = "F-SUB"
-# <================================================ END =======================================================>

Mikobot/plugins/fun.py

@@ -1,257 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import random
-
-from pyjokes import get_joke
-from telegram import Update
-from telegram.constants import ParseMode
-from telegram.ext import ContextTypes
-
-import Mikobot.utils.fun_strings as fun_strings
-from Mikobot import function
-from Mikobot.events import register
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.state import state
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def make_request(url: str) -> str:
-    response = await state.get(url)
-    response.raise_for_status()
-    return response.json()["question"]
-
-
-async def truth(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    truth_question = await make_request("https://api.truthordarebot.xyz/v1/truth")
-    await update.effective_message.reply_text(truth_question)
-
-
-async def dare(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    dare_question = await make_request("https://api.truthordarebot.xyz/v1/dare")
-    await update.effective_message.reply_text(dare_question)
-
-
-@register(pattern="^/joke ?(.*)")
-async def joke(event):
-    await event.reply(get_joke())
-
-
-async def roll(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.message.reply_text(random.choice(range(1, 7)))
-
-
-async def flirt(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    await update.effective_message.reply_text(random.choice(fun_strings.FLIRT))
-
-
-async def toss(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.message.reply_text(random.choice(fun_strings.TOSS))
-
-
-async def shrug(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.effective_message
-    reply_text = (
-        msg.reply_to_message.reply_text if msg.reply_to_message else msg.reply_text
-    )
-    await reply_text(r"¯\_(ツ)_/¯")
-
-
-async def bluetext(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.effective_message
-    reply_text = (
-        msg.reply_to_message.reply_text if msg.reply_to_message else msg.reply_text
-    )
-    await reply_text(
-        "/BLUE /TEXT\n/MUST /CLICK\n/I /AM /A /STUPID /ANIMAL /THAT /IS /ATTRACTED /TO /COLORS"
-    )
-
-
-async def rlg(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    eyes = random.choice(fun_strings.EYES)
-    mouth = random.choice(fun_strings.MOUTHS)
-    ears = random.choice(fun_strings.EARS)
-
-    if len(eyes) == 2:
-        repl = ears[0] + eyes[0] + mouth[0] + eyes[1] + ears[1]
-    else:
-        repl = ears[0] + eyes[0] + mouth[0] + eyes[0] + ears[1]
-    await update.message.reply_text(repl)
-
-
-async def decide(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    reply_text = (
-        update.effective_message.reply_to_message.reply_text
-        if update.effective_message.reply_to_message
-        else update.effective_message.reply_text
-    )
-    await reply_text(random.choice(fun_strings.DECIDE))
-
-
-normiefont = [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-]
-
-weebyfont = [
-    "卂",
-    "乃",
-    "匚",
-    "刀",
-    "乇",
-    "下",
-    "厶",
-    "卄",
-    "工",
-    "丁",
-    "长",
-    "乚",
-    "从",
-    "𠘨",
-    "口",
-    "尸",
-    "㔿",
-    "尺",
-    "丂",
-    "丅",
-    "凵",
-    "リ",
-    "山",
-    "乂",
-    "丫",
-    "乙",
-]
-
-
-async def webify(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    message = update.effective_message
-    string = ""
-
-    if message.reply_to_message:
-        string = message.reply_to_message.text.lower().replace(" ", "  ")
-
-    if args:
-        string = "  ".join(args).lower()
-
-    if not string:
-        await message.reply_text(
-            "Usage is `/weebify <text>`", parse_mode=ParseMode.MARKDOWN
-        )
-        return
-
-    for normiecharacter in string:
-        if normiecharacter in normiefont:
-            weebycharacter = weebyfont[normiefont.index(normiecharacter)]
-            string = string.replace(normiecharacter, weebycharacter)
-
-    if message.reply_to_message:
-        await message.reply_to_message.reply_text(string)
-    else:
-        await message.reply_text(string)
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-» /cosplay: sends cosplay images.
-
-» /decide: randomly answers yes/no/maybe.
-
-» /truth: sends a random truth string.
-
-» /dare: sends a random dare string.
-
-» /toss: tosses a coin.
-
-» /shrug: get shrug xd.
-
-» /bluetext: check yourself :V.
-
-�� /roll: roll a dice.
-
-» /rlg: join ears, nose, mouth and create an emo ;-;
-
-» /weebify <text>: returns a weebified text.
-
-» /flirt <text>: returns a flirt text.
-
-» /joke <text>: tells a random joke.
-"""
-
-# <================================================ HANDLER =======================================================>
-ROLL_HANDLER = DisableAbleCommandHandler("roll", roll, block=False)
-TOSS_HANDLER = DisableAbleCommandHandler("toss", toss, block=False)
-SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug, block=False)
-BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext, block=False)
-RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg, block=False)
-DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide, block=False)
-WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", webify, block=False)
-FLIRT_HANDLER = DisableAbleCommandHandler("flirt", flirt, block=False)
-TRUTH_HANDLER = DisableAbleCommandHandler("truth", truth, block=False)
-DARE_HANDLER = DisableAbleCommandHandler("dare", dare, block=False)
-
-function(WEEBIFY_HANDLER)
-function(ROLL_HANDLER)
-function(TOSS_HANDLER)
-function(SHRUG_HANDLER)
-function(BLUETEXT_HANDLER)
-function(RLG_HANDLER)
-function(DECIDE_HANDLER)
-function(FLIRT_HANDLER)
-function(TRUTH_HANDLER)
-function(DARE_HANDLER)
-
-__mod_name__ = "FUN"
-__command_list__ = [
-    "roll",
-    "toss",
-    "shrug",
-    "bluetext",
-    "rlg",
-    "decide",
-    "cosplay",
-    "weebify",
-    "flirt",
-    "truth",
-    "dare",
-]
-__handlers__ = [
-    ROLL_HANDLER,
-    TOSS_HANDLER,
-    SHRUG_HANDLER,
-    BLUETEXT_HANDLER,
-    RLG_HANDLER,
-    DECIDE_HANDLER,
-    WEEBIFY_HANDLER,
-    FLIRT_HANDLER,
-    TRUTH_HANDLER,
-    DARE_HANDLER,
-]
-# <================================================ END =======================================================>

Mikobot/plugins/gban.py

@@ -1,544 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-import time
-from datetime import datetime
-from io import BytesIO
-
-from telegram import ChatMemberAdministrator, Update
-from telegram.constants import ParseMode
-from telegram.error import BadRequest, Forbidden, TelegramError
-from telegram.ext import CommandHandler, ContextTypes, MessageHandler, filters
-from telegram.helpers import mention_html
-
-import Database.sql.global_bans_sql as sql
-from Database.sql.users_sql import get_user_com_chats
-from Mikobot import (
-    DEV_USERS,
-    DRAGONS,
-    EVENT_LOGS,
-    OWNER_ID,
-    STRICT_GBAN,
-    SUPPORT_CHAT,
-    dispatcher,
-    function,
-)
-from Mikobot.plugins.helper_funcs.chat_status import (
-    check_admin,
-    is_user_admin,
-    support_plus,
-)
-from Mikobot.plugins.helper_funcs.extraction import extract_user, extract_user_and_text
-from Mikobot.plugins.helper_funcs.misc import send_to_list
-
-# <=======================================================================================================>
-
-GBAN_ENFORCE_GROUP = 6
-
-GBAN_ERRORS = {
-    "User is an administrator of the chat",
-    "Chat not found",
-    "Not enough rights to restrict/unrestrict chat member",
-    "User_not_participant",
-    "Peer_id_invalid",
-    "Group chat was deactivated",
-    "Need to be inviter of a user to kick it from a basic group",
-    "Chat_admin_required",
-    "Only the creator of a basic group can kick group administrators",
-    "Channel_private",
-    "Not in the chat",
-    "Can't remove chat owner",
-}
-
-UNGBAN_ERRORS = {
-    "User is an administrator of the chat",
-    "Chat not found",
-    "Not enough rights to restrict/unrestrict chat member",
-    "User_not_participant",
-    "Method is available for supergroup and channel chats only",
-    "Not in the chat",
-    "Channel_private",
-    "Chat_admin_required",
-    "Peer_id_invalid",
-    "User not found",
-}
-
-
-# <================================================ FUNCTION =======================================================>
-@support_plus
-async def gban(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    message = update.effective_message
-    user = update.effective_user
-    chat = update.effective_chat
-    log_message = ""
-
-    user_id, reason = await extract_user_and_text(message, context, args)
-
-    if not user_id:
-        await message.reply_text(
-            "You don't seem to be referring to a user or the ID specified is incorrect..",
-        )
-        return
-
-    if int(user_id) in DEV_USERS:
-        await message.reply_text(
-            "That user is part of the Association\nI can't act against our own.",
-        )
-        return
-
-    if int(user_id) in DRAGONS:
-        await message.reply_text(
-            "I spy, with my little eye... a disaster! Why are you guys turning on each other?",
-        )
-        return
-
-    if user_id == bot.id:
-        await message.reply_text("You uhh...want me to kick myself?")
-        return
-
-    if user_id in [777000, 1087968824]:
-        await message.reply_text("Fool! You can't attack Telegram's native tech!")
-        return
-
-    try:
-        user_chat = await bot.get_chat(user_id)
-    except BadRequest as excp:
-        if excp.message == "User not found":
-            await message.reply_text("I can't seem to find this user.")
-            return ""
-        else:
-            return
-
-    if user_chat.type != "private":
-        await message.reply_text("That's not a user!")
-        return
-
-    if sql.is_user_gbanned(user_id):
-        if not reason:
-            await message.reply_text(
-                "This user is already gbanned; I'd change the reason, but you haven't given me one...",
-            )
-            return
-
-        old_reason = sql.update_gban_reason(
-            user_id,
-            user_chat.username or user_chat.first_name,
-            reason,
-        )
-        if old_reason:
-            await message.reply_text(
-                "This user is already gbanned, for the following reason:\n"
-                "<code>{}</code>\n"
-                "I've gone and updated it with your new reason!".format(
-                    html.escape(old_reason),
-                ),
-                parse_mode=ParseMode.HTML,
-            )
-
-        else:
-            await message.reply_text(
-                "This user is already gbanned, but had no reason set; I've gone and updated it!",
-            )
-
-        return
-
-    await message.reply_text("On it!")
-
-    start_time = time.time()
-    datetime_fmt = "%Y-%m-%dT%H:%M"
-    current_time = datetime.utcnow().strftime(datetime_fmt)
-
-    if chat.type != "private":
-        chat_origin = "<b>{} ({})</b>\n".format(html.escape(chat.title), chat.id)
-    else:
-        chat_origin = "<b>{}</b>\n".format(chat.id)
-
-    log_message = (
-        f"#GBANNED\n"
-        f"<b>Originated from:</b> <code>{chat_origin}</code>\n"
-        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
-        f"<b>Banned User:</b> {mention_html(user_chat.id, user_chat.first_name)}\n"
-        f"<b>Banned User ID:</b> <code>{user_chat.id}</code>\n"
-        f"<b>Event Stamp:</b> <code>{current_time}</code>"
-    )
-
-    if reason:
-        if chat.type == chat.SUPERGROUP and chat.username:
-            log_message += f'\n<b>Reason:</b> <a href="https://telegram.me/{chat.username}/{message.message_id}">{reason}</a>'
-        else:
-            log_message += f"\n<b>Reason:</b> <code>{reason}</code>"
-
-    if EVENT_LOGS:
-        try:
-            log = await bot.send_message(
-                EVENT_LOGS, log_message, parse_mode=ParseMode.HTML
-            )
-        except BadRequest as excp:
-            log = await bot.send_message(
-                EVENT_LOGS,
-                log_message
-                + "\n\nFormatting has been disabled due to an unexpected error.",
-            )
-
-    else:
-        send_to_list(bot, DRAGONS, log_message, html=True)
-
-    sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason)
-
-    chats = get_user_com_chats(user_id)
-    gbanned_chats = 0
-
-    for chat in chats:
-        chat_id = int(chat)
-
-        # Check if this group has disabled gbans
-        if not sql.does_chat_gban(chat_id):
-            continue
-
-        try:
-            await bot.ban_chat_member(chat_id, user_id)
-            gbanned_chats += 1
-
-        except BadRequest as excp:
-            if excp.message in GBAN_ERRORS:
-                pass
-            else:
-                await message.reply_text(f"Could not gban due to: {excp.message}")
-                if EVENT_LOGS:
-                    await bot.send_message(
-                        EVENT_LOGS,
-                        f"Could not gban due to {excp.message}",
-                        parse_mode=ParseMode.HTML,
-                    )
-                else:
-                    send_to_list(
-                        bot,
-                        DRAGONS,
-                        f"Could not gban due to: {excp.message}",
-                    )
-                sql.ungban_user(user_id)
-                return
-        except TelegramError:
-            pass
-
-    if EVENT_LOGS:
-        await log.edit_text(
-            log_message + f"\n<b>Chats affected:</b> <code>{gbanned_chats}</code>",
-            parse_mode=ParseMode.HTML,
-        )
-    else:
-        send_to_list(
-            bot,
-            DRAGONS,
-            f"Gban complete! (User banned in <code>{gbanned_chats}</code> chats)",
-            html=True,
-        )
-
-    end_time = time.time()
-    gban_time = round((end_time - start_time), 2)
-
-    if gban_time > 60:
-        gban_time = round((gban_time / 60), 2)
-        await message.reply_text("Done! Gbanned.", parse_mode=ParseMode.HTML)
-    else:
-        await message.reply_text("Done! Gbanned.", parse_mode=ParseMode.HTML)
-
-    try:
-        await bot.send_message(
-            user_id,
-            "#EVENT"
-            "You have been marked as Malicious and as such have been banned from any future groups we manage."
-            f"\n<b>Reason:</b> <code>{html.escape(user.reason)}</code>"
-            f"</b>Appeal Chat:</b> @{SUPPORT_CHAT}",
-            parse_mode=ParseMode.HTML,
-        )
-    except:
-        pass  # bot probably blocked by user
-
-
-@support_plus
-async def ungban(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    message = update.effective_message
-    user = update.effective_user
-    chat = update.effective_chat
-    log_message = ""
-
-    user_id = await extract_user(message, context, args)
-
-    if not user_id:
-        await message.reply_text(
-            "You don't seem to be referring to a user or the ID specified is incorrect..",
-        )
-        return
-
-    user_chat = await bot.get_chat(user_id)
-    if user_chat.type != "private":
-        await message.reply_text("That's not a user!")
-        return
-
-    if not sql.is_user_gbanned(user_id):
-        await message.reply_text("This user is not gbanned!")
-        return
-
-    await message.reply_text(
-        f"I'll give {user_chat.first_name} a second chance, globally."
-    )
-
-    start_time = time.time()
-    datetime_fmt = "%Y-%m-%dT%H:%M"
-    current_time = datetime.utcnow().strftime(datetime_fmt)
-
-    if chat.type != "private":
-        chat_origin = f"<b>{html.escape(chat.title)} ({chat.id})</b>\n"
-    else:
-        chat_origin = f"<b>{chat.id}</b>\n"
-
-    log_message = (
-        f"#UNGBANNED\n"
-        f"<b>Originated from:</b> <code>{chat_origin}</code>\n"
-        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
-        f"<b>Unbanned User:</b> {mention_html(user_chat.id, user_chat.first_name)}\n"
-        f"<b>Unbanned User ID:</b> <code>{user_chat.id}</code>\n"
-        f"<b>Event Stamp:</b> <code>{current_time}</code>"
-    )
-
-    if EVENT_LOGS:
-        try:
-            log = await bot.send_message(
-                EVENT_LOGS, log_message, parse_mode=ParseMode.HTML
-            )
-        except BadRequest as excp:
-            log = await bot.send_message(
-                EVENT_LOGS,
-                log_message
-                + "\n\nFormatting has been disabled due to an unexpected error.",
-            )
-    else:
-        send_to_list(bot, DRAGONS, log_message, html=True)
-
-    chats = get_user_com_chats(user_id)
-    ungbanned_chats = 0
-
-    for chat in chats:
-        chat_id = int(chat)
-
-        # Check if this group has disabled gbans
-        if not sql.does_chat_gban(chat_id):
-            continue
-
-        try:
-            member = await bot.get_chat_member(chat_id, user_id)
-            if member.status == "kicked":
-                await bot.unban_chat_member(chat_id, user_id)
-                ungbanned_chats += 1
-
-        except BadRequest as excp:
-            if excp.message in UNGBAN_ERRORS:
-                pass
-            else:
-                await message.reply_text(f"Could not un-gban due to: {excp.message}")
-                if EVENT_LOGS:
-                    await bot.send_message(
-                        EVENT_LOGS,
-                        f"Could not un-gban due to: {excp.message}",
-                        parse_mode=ParseMode.HTML,
-                    )
-                else:
-                    await bot.send_message(
-                        OWNER_ID,
-                        f"Could not un-gban due to: {excp.message}",
-                    )
-                return
-        except TelegramError:
-            pass
-
-    sql.ungban_user(user_id)
-
-    if EVENT_LOGS:
-        await log.edit_text(
-            log_message + f"\n<b>Chats affected:</b> {ungbanned_chats}",
-            parse_mode=ParseMode.HTML,
-        )
-    else:
-        send_to_list(bot, DRAGONS, "un-gban complete!")
-
-    end_time = time.time()
-    ungban_time = round((end_time - start_time), 2)
-
-    if ungban_time > 60:
-        ungban_time = round((ungban_time / 60), 2)
-        await message.reply_text(f"Person has been un-gbanned. Took {ungban_time} min")
-    else:
-        await message.reply_text(f"Person has been un-gbanned. Took {ungban_time} sec")
-
-
-@support_plus
-async def gbanlist(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    banned_users = sql.get_gban_list()
-
-    if not banned_users:
-        await update.effective_message.reply_text(
-            "There aren't any gbanned users! You're kinder than I expected...",
-        )
-        return
-
-    banfile = "Screw these guys.\n"
-    for user in banned_users:
-        banfile += f"[x] {user['name']} - {user['user_id']}\n"
-        if user["reason"]:
-            banfile += f"Reason: {user['reason']}\n"
-
-    with BytesIO(str.encode(banfile)) as output:
-        output.name = "gbanlist.txt"
-        await update.effective_message.reply_document(
-            document=output,
-            filename="gbanlist.txt",
-            caption="Here is the list of currently gbanned users.",
-        )
-
-
-async def check_and_ban(update, user_id, should_message=True):
-    if sql.is_user_gbanned(user_id):
-        await update.effective_chat.ban_member(user_id)
-        if should_message:
-            text = (
-                f"<b>Alert</b>: this user is globally banned.\n"
-                f"<code>*bans them from here*</code>.\n"
-                f"<b>Appeal chat</b>: @{SUPPORT_CHAT}\n"
-                f"<b>User ID</b>: <code>{user_id}</code>"
-            )
-            user = sql.get_gbanned_user(user_id)
-            if user.reason:
-                text += f"\n<b>Ban Reason:</b> <code>{html.escape(user.reason)}</code>"
-            await update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
-
-
-async def enforce_gban(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    # Not using @restrict handler to avoid spamming - just ignore if cant gban.
-    bot = context.bot
-    try:
-        get_member = await update.effective_chat.get_member(
-            bot.id,
-        )
-        if isinstance(get_member, ChatMemberAdministrator):
-            restrict_permission = get_member.can_restrict_members
-        else:
-            return
-    except Forbidden:
-        return
-    if sql.does_chat_gban(update.effective_chat.id) and restrict_permission:
-        user = update.effective_user
-        chat = update.effective_chat
-        msg = update.effective_message
-
-        if user and not await is_user_admin(chat, user.id):
-            await check_and_ban(update, user.id)
-            return
-
-        if msg.new_chat_members:
-            new_members = update.effective_message.new_chat_members
-            for mem in new_members:
-                await check_and_ban(update, mem.id)
-
-        if msg.reply_to_message:
-            user = msg.reply_to_message.from_user
-            if user and not await is_user_admin(chat, user.id):
-                await check_and_ban(update, user.id, should_message=False)
-
-
-@check_admin(is_user=True)
-async def gbanstat(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    if len(args) > 0:
-        if args[0].lower() in ["on", "yes"]:
-            sql.enable_gbans(update.effective_chat.id)
-            await update.effective_message.reply_text(
-                "Antispam is now enabled ✅ "
-                "I am now protecting your group from potential remote threats!",
-            )
-        elif args[0].lower() in ["off", "no"]:
-            sql.disable_gbans(update.effective_chat.id)
-            await update.effective_message.reply_text(
-                "I am not now protecting your group from potential remote threats!",
-            )
-    else:
-        await update.effective_message.reply_text(
-            "Give me some arguments to choose a setting! on/off, yes/no!\n\n"
-            "Your current setting is: {}\n"
-            "When True, any gbans that happen will also happen in your group. "
-            "When False, they won't, leaving you at the possible mercy of "
-            "spammers.".format(sql.does_chat_gban(update.effective_chat.id)),
-        )
-
-
-def __stats__():
-    return f"• {sql.num_gbanned_users()} gbanned users."
-
-
-def __user_info__(user_id):
-    is_gbanned = sql.is_user_gbanned(user_id)
-    text = "Malicious: <b>{}</b>"
-    if user_id in [777000, 1087968824]:
-        return ""
-    if user_id == dispatcher.bot.id:
-        return ""
-    if int(user_id) in DRAGONS:
-        return ""
-    if is_gbanned:
-        text = text.format("Yes")
-        user = sql.get_gbanned_user(user_id)
-        if user.reason:
-            text += f"\n<b>Reason:</b> <code>{html.escape(user.reason)}</code>"
-        text += f"\n<b>Appeal Chat:</b> @{SUPPORT_CHAT}"
-    else:
-        text = text.format("???")
-    return text
-
-
-def __migrate__(old_chat_id, new_chat_id):
-    sql.migrate_chat(old_chat_id, new_chat_id)
-
-
-def __chat_settings__(chat_id, user_id):
-    return f"This chat is enforcing *gbans*: `{sql.does_chat_gban(chat_id)}`."
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = f"""
-➠ *Admins only:*
-
-» /antispam <on/off/yes/no>: Will toggle our antispam tech or return your current settings.
-
-➠ Anti-Spam, used by bot devs to ban spammers across all groups. This helps protect \
-you and your groups by removing spam flooders as quickly as possible.
-➠ *Note:* Users can appeal gbans or report spammers at @hydraX2support
-"""
-
-# <================================================ HANDLER =======================================================>
-GBAN_HANDLER = CommandHandler("gban", gban, block=False)
-UNGBAN_HANDLER = CommandHandler("ungban", ungban, block=False)
-GBAN_LIST = CommandHandler("gbanlist", gbanlist, block=False)
-
-GBAN_STATUS = CommandHandler(
-    "antispam", gbanstat, filters=filters.ChatType.GROUPS, block=False
-)
-
-GBAN_ENFORCER = MessageHandler(
-    filters.ALL & filters.ChatType.GROUPS, enforce_gban, block=False
-)
-
-function(GBAN_HANDLER)
-function(UNGBAN_HANDLER)
-function(GBAN_LIST)
-function(GBAN_STATUS)
-
-__mod_name__ = "ANTI-SPAM"
-__handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS]
-
-if STRICT_GBAN:  # enforce GBANS if this is set
-    function(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
-    __handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
-# <================================================ END =======================================================>

Mikobot/plugins/helper_funcs/alternate.py

@@ -1,85 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from functools import wraps
-
-from telegram import Message, Update
-from telegram.constants import ChatAction
-from telegram.error import BadRequest
-from telegram.ext import ContextTypes
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def send_message(message: Message, text, *args, **kwargs):
-    try:
-        return await message.reply_text(text, *args, **kwargs)
-    except BadRequest as err:
-        if str(err) == "Reply message not found":
-            return await message.reply_text(text, quote=False, *args, **kwargs)
-
-
-def typing_action(func):
-    """Sends typing action while processing func command."""
-
-    @wraps(func)
-    async def command_func(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        await context.bot.send_chat_action(
-            chat_id=update.effective_chat.id,
-            action=ChatAction.TYPING,
-        )
-        return await func(update, context, *args, **kwargs)
-
-    return command_func
-
-
-def sticker_action(func):
-    """Sends typing action while processing func command."""
-
-    @wraps(func)
-    async def command_func(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        await context.bot.send_chat_action(
-            chat_id=update.effective_chat.id,
-            action=ChatAction.CHOOSE_STICKER,
-        )
-        return await func(update, context, *args, **kwargs)
-
-    return command_func
-
-
-def document_action(func):
-    """Sends typing action while processing func command."""
-
-    @wraps(func)
-    async def command_func(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        await context.bot.send_chat_action(
-            chat_id=update.effective_chat.id,
-            action=ChatAction.UPLOAD_DOCUMENT,
-        )
-        return await func(update, context, *args, **kwargs)
-
-    return command_func
-
-
-def photo_action(func):
-    """Sends typing action while processing func command."""
-
-    @wraps(func)
-    async def command_func(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        await context.bot.send_chat_action(
-            chat_id=update.effective_chat.id,
-            action=ChatAction.UPLOAD_PHOTO,
-        )
-        return await func(update, context, *args, **kwargs)
-
-    return command_func
-
-
-# <================================================ END =======================================================>

Mikobot/plugins/helper_funcs/chat_status.py

@@ -1,415 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from functools import wraps
-from threading import RLock
-from time import perf_counter
-
-from cachetools import TTLCache
-from telegram import Chat, ChatMember, ChatMemberAdministrator, ChatMemberOwner, Update
-from telegram.constants import ChatMemberStatus, ChatType
-from telegram.error import Forbidden
-from telegram.ext import ContextTypes
-
-from Mikobot import DEL_CMDS, DEV_USERS, DRAGONS, SUPPORT_CHAT, dispatcher
-
-# <=======================================================================================================>
-
-# stores admemes in memory for 10 min.
-ADMIN_CACHE = TTLCache(maxsize=512, ttl=60 * 10, timer=perf_counter)
-THREAD_LOCK = RLock()
-
-
-# <================================================ FUNCTION =======================================================>
-def check_admin(
-    permission: str = None,
-    is_bot: bool = False,
-    is_user: bool = False,
-    is_both: bool = False,
-    only_owner: bool = False,
-    only_sudo: bool = False,
-    only_dev: bool = False,
-    no_reply: object = False,
-) -> object:
-    """Check for permission level to perform some operations
-
-    Args:
-        permission (str, optional): permission type to check. Defaults to None.
-        is_bot (bool, optional): if bot can perform the action. Defaults to False.
-        is_user (bool, optional): if user can perform the action. Defaults to False.
-        is_both (bool, optional): if both user and bot can perform the action. Defaults to False.
-        only_owner (bool, optional): if only owner can perform the action. Defaults to False.
-        only_sudo (bool, optional): if only sudo users can perform the operation. Defaults to False.
-        only_dev (bool, optional): if only dev users can perform the operation. Defaults to False.
-        no_reply (boot, optional): if should not reply. Defaults to False.
-    """
-
-    def wrapper(func):
-        @wraps(func)
-        async def wrapped(
-            update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-        ):
-            nonlocal permission
-            chat = update.effective_chat
-            user = update.effective_user
-            message = update.effective_message
-
-            if chat.type == ChatType.PRIVATE and not (
-                only_dev or only_sudo or only_owner
-            ):
-                return await func(update, context, *args, **kwargs)
-
-            bot_member = (
-                await chat.get_member(context.bot.id) if is_bot or is_both else None
-            )
-            user_member = await chat.get_member(user.id) if is_user or is_both else None
-
-            if only_owner:
-                if isinstance(user_member, ChatMemberOwner) or user.id in DEV_USERS:
-                    return await func(update, context, *args, **kwargs)
-                else:
-                    return await message.reply_text(
-                        "Only chat owner can perform this action."
-                    )
-            if only_dev:
-                if user.id in DEV_USERS:
-                    return await func(update, context, *args, **kwargs)
-                else:
-                    return await update.effective_message.reply_text(
-                        "Hey little kid"
-                        "\nWho the hell are you to say me what to execute on my server?",
-                    )
-
-            if only_sudo:
-                if user.id in DRAGONS:
-                    return await func(update, context, *args, **kwargs)
-                else:
-                    return await update.effective_message.reply_text(
-                        "Who the hell are you to say me what to do?",
-                    )
-
-            if message.from_user.id == 1087968824:
-                return await func(update, context, *args, **kwargs)
-
-            if permission:
-                no_permission = permission.replace("_", " ").replace("can", "")
-                if is_bot:
-                    if (
-                        getattr(bot_member, permission)
-                        if isinstance(bot_member, ChatMemberAdministrator)
-                        else False
-                    ):
-                        return await func(update, context, *args, **kwargs)
-                    elif no_reply:
-                        return
-                    else:
-                        return await message.reply_text(
-                            f"I don't have permission to {no_permission}."
-                        )
-                if is_user:
-                    if isinstance(user_member, ChatMemberOwner):
-                        return await func(update, context, *args, **kwargs)
-                    elif (
-                        getattr(user_member, permission)
-                        if isinstance(user_member, ChatMemberAdministrator)
-                        else False or user.id in DRAGONS
-                    ):
-                        return await func(update, context, *args, **kwargs)
-                    elif no_reply:
-                        return
-                    else:
-                        return await message.reply_text(
-                            f"You don't have permission to {no_permission}."
-                        )
-                if is_both:
-                    if (
-                        getattr(bot_member, permission)
-                        if isinstance(bot_member, ChatMemberAdministrator)
-                        else False
-                    ):
-                        pass
-                    elif no_reply:
-                        return
-                    else:
-                        return await message.reply_text(
-                            f"I don't have permission to {no_permission}."
-                        )
-
-                    if isinstance(user_member, ChatMemberOwner) or user.id in DEV_USERS:
-                        pass
-                    elif (
-                        getattr(user_member, permission)
-                        if isinstance(user_member, ChatMemberAdministrator)
-                        else False or user.id in DRAGONS
-                    ):
-                        pass
-                    elif no_reply:
-                        return
-                    else:
-                        return await message.reply_text(
-                            f"You don't have permission to {no_permission}."
-                        )
-                    return await func(update, context, *args, **kwargs)
-            else:
-                if is_bot:
-                    if bot_member.status == ChatMemberStatus.ADMINISTRATOR:
-                        return await func(update, context, *args, **kwargs)
-                    else:
-                        return await message.reply_text("I'm not admin here.")
-                elif is_user:
-                    if user_member.status in [
-                        ChatMemberStatus.ADMINISTRATOR,
-                        ChatMemberStatus.OWNER,
-                    ]:
-                        return await func(update, context, *args, **kwargs)
-                    elif user.id in DRAGONS:
-                        return await func(update, context, *args, **kwargs)
-                    else:
-                        return await message.reply_text("You are not admin here.")
-                elif is_both:
-                    if bot_member.status == ChatMemberStatus.ADMINISTRATOR:
-                        pass
-                    else:
-                        return await message.reply_text("I'm not admin here.")
-
-                    if user_member.status in [
-                        ChatMemberStatus.ADMINISTRATOR,
-                        ChatMemberStatus.OWNER,
-                    ]:
-                        pass
-                    elif user.id in DRAGONS:
-                        pass
-                    else:
-                        return await message.reply_text("You are not admin here.")
-                    return await func(update, context, *args, **kwargs)
-
-        return wrapped
-
-    return wrapper
-
-
-def is_whitelist_plus(chat: Chat, user_id: int, member: ChatMember = None) -> bool:
-    return any(user_id in user for user in [DRAGONS, DEV_USERS])
-
-
-def is_support_plus(chat: Chat, user_id: int, member: ChatMember = None) -> bool:
-    return user_id in DRAGONS or user_id in DEV_USERS
-
-
-def is_sudo_plus(chat: Chat, user_id: int, member: ChatMember = None) -> bool:
-    return user_id in DRAGONS or user_id in DEV_USERS
-
-
-async def is_user_admin(chat: Chat, user_id: int, member: ChatMember = None) -> bool:
-    if (
-        chat.type == "private"
-        or user_id in DRAGONS
-        or user_id in DEV_USERS
-        or user_id in [777000, 1087968824]
-    ):  # Count telegram and Group Anonymous as admin
-        return True
-    if not member:
-        with THREAD_LOCK:
-            # try to fetch from cache first.
-            try:
-                return user_id in ADMIN_CACHE[chat.id]
-            except KeyError:
-                # keyerror happend means cache is deleted,
-                # so query bot api again and return user status
-                # while saving it in cache for future usage...
-                try:
-                    chat_admins = await dispatcher.bot.getChatAdministrators(chat.id)
-                except Forbidden:
-                    return False
-                admin_list = [x.user.id for x in chat_admins]
-                ADMIN_CACHE[chat.id] = admin_list
-
-                return user_id in admin_list
-    else:
-        return member.status in (ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER)
-
-
-async def is_bot_admin(chat: Chat, bot_id: int, bot_member: ChatMember = None) -> bool:
-    if chat.type == "private":
-        return True
-
-    if not bot_member:
-        bot_member = await chat.get_member(bot_id)
-
-    return bot_member.status in (ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER)
-
-
-async def can_delete(chat: Chat, bot_id: int) -> bool:
-    chat_member = await chat.get_member(bot_id)
-    if isinstance(chat_member, ChatMemberAdministrator):
-        return chat_member.can_delete_messages
-
-
-async def is_user_ban_protected(
-    chat: Chat, user_id: int, member: ChatMember = None
-) -> bool:
-    if (
-        chat.type == "private"
-        or user_id in DRAGONS
-        or user_id in DEV_USERS
-        or user_id in [777000, 1087968824]
-    ):  # Count telegram and Group Anonymous as admin
-        return True
-
-    if not member:
-        member = await chat.get_member(user_id)
-
-    return member.status in (ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER)
-
-
-async def is_user_in_chat(chat: Chat, user_id: int) -> bool:
-    member = await chat.get_member(user_id)
-    return member.status in (ChatMemberStatus.LEFT, ChatMemberStatus.RESTRICTED)
-
-
-def dev_plus(func):
-    @wraps(func)
-    def is_dev_plus_func(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        context.bot
-        user = update.effective_user
-
-        if user.id in DEV_USERS:
-            return func(update, context, *args, **kwargs)
-        elif not user:
-            pass
-        elif DEL_CMDS and " " not in update.effective_message.text:
-            try:
-                update.effective_message.delete()
-            except:
-                pass
-        else:
-            update.effective_message.reply_text(
-                "This is a developer restricted command."
-                " You do not have permissions to run this."
-            )
-
-    return is_dev_plus_func
-
-
-def sudo_plus(func):
-    @wraps(func)
-    def is_sudo_plus_func(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        context.bot
-        user = update.effective_user
-        chat = update.effective_chat
-
-        if user and is_sudo_plus(chat, user.id):
-            return func(update, context, *args, **kwargs)
-        elif not user:
-            pass
-        elif DEL_CMDS and " " not in update.effective_message.text:
-            try:
-                update.effective_message.delete()
-            except:
-                pass
-        else:
-            update.effective_message.reply_text(
-                "Who dis non-admin telling me what to do? You want a punch?"
-            )
-
-    return is_sudo_plus_func
-
-
-def support_plus(func):
-    @wraps(func)
-    async def is_support_plus_func(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        bot = context.bot
-        user = update.effective_user
-        chat = update.effective_chat
-
-        if user and is_support_plus(chat, user.id):
-            return await func(update, context, *args, **kwargs)
-        elif DEL_CMDS and " " not in update.effective_message.text:
-            try:
-                await update.effective_message.delete()
-            except:
-                pass
-
-    return is_support_plus_func
-
-
-def whitelist_plus(func):
-    @wraps(func)
-    async def is_whitelist_plus_func(
-        update: Update,
-        context: ContextTypes.DEFAULT_TYPE,
-        *args,
-        **kwargs,
-    ):
-        bot = context.bot
-        user = update.effective_user
-        chat = update.effective_chat
-
-        if user and is_whitelist_plus(chat, user.id):
-            return await func(update, context, *args, **kwargs)
-        else:
-            await update.effective_message.reply_text(
-                f"You don't have access to use this.\nVisit @{SUPPORT_CHAT}",
-            )
-
-    return is_whitelist_plus_func
-
-
-def user_not_admin(func):
-    @wraps(func)
-    async def is_not_admin(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        bot = context.bot
-        user = update.effective_user
-        chat = update.effective_chat
-
-        if user and not await is_user_admin(chat, user.id):
-            return await func(update, context, *args, **kwargs)
-        elif not user:
-            pass
-
-    return is_not_admin
-
-
-def connection_status(func):
-    @wraps(func)
-    async def connected_status(
-        update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-    ):
-        conn = await connected(
-            context.bot,
-            update,
-            update.effective_chat,
-            update.effective_user.id,
-            need_admin=False,
-        )
-
-        if conn:
-            chat = await dispatcher.bot.getChat(conn)
-            update.__setattr__("_effective_chat", chat)
-            return await func(update, context, *args, **kwargs)
-        else:
-            if update.effective_message.chat.type == "private":
-                await update.effective_message.reply_text(
-                    "Send /connect in a group that you and I have in common first.",
-                )
-                return connected_status
-
-            return await func(update, context, *args, **kwargs)
-
-    return connected_status
-
-
-# <=======================================================================================================>
-
-# <=======================================================================================================>
-# Workaround for circular import with connection.py
-from Mikobot.plugins import connection
-
-connected = connection.connected
-# <================================================ END =======================================================>

Mikobot/plugins/helper_funcs/extraction.py

@@ -1,190 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from typing import List, Optional, Union
-
-from telegram import Message, MessageEntity
-from telegram.error import BadRequest
-from telegram.ext import ContextTypes
-
-from Mikobot import LOGGER
-from Mikobot.plugins.users import get_user_id
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def id_from_reply(message: Message):
-    prev_message = message.reply_to_message
-    if not prev_message or prev_message.forum_topic_created:
-        return None, None
-    user_id = prev_message.from_user.id
-    # if user id is from channel bot, then fetch channel id from sender_chat
-    if user_id == 136817688:
-        user_id = message.reply_to_message.sender_chat.id
-    res = message.text.split(None, 1)
-    if len(res) < 2:
-        return user_id, ""
-    return user_id, res[1]
-
-
-async def extract_user(
-    message: Message,
-    context: ContextTypes.DEFAULT_TYPE,
-    args: List[str],
-) -> Optional[int]:
-    return (await extract_user_and_text(message, context, args))[0]
-
-
-async def extract_user_and_text(
-    message: Message,
-    context: ContextTypes.DEFAULT_TYPE,
-    args: List[str],
-) -> Union[(Optional[int], Optional[str])]:
-    prev_message = message.reply_to_message
-    split_text = message.text.split(None, 1)
-
-    if len(split_text) < 2:
-        return await id_from_reply(message)  # only option possible
-
-    text_to_parse = split_text[1]
-
-    text = ""
-
-    entities = list(message.parse_entities([MessageEntity.TEXT_MENTION]))
-    ent = entities[0] if entities else None
-    # if entity offset matches (command end/text start) then all good
-    if entities and ent and ent.offset == len(message.text) - len(text_to_parse):
-        ent = entities[0]
-        user_id = ent.user.id
-        text = message.text[ent.offset + ent.length :]
-
-    elif len(args) >= 1 and args[0][0] == "@":
-        user = args[0]
-        user_id = await get_user_id(user)
-        if not user_id:
-            await message.reply_text(
-                "No idea who this user is. You'll be able to interact with them if "
-                "you reply to that person's message instead, or forward one of that user's messages.",
-            )
-            return None, None
-
-        else:
-            user_id = user_id
-            res = message.text.split(None, 2)
-            if len(res) >= 3:
-                text = res[2]
-
-    elif len(args) >= 1 and args[0].isdigit():
-        user_id = int(args[0])
-        res = message.text.split(None, 2)
-        if len(res) >= 3:
-            text = res[2]
-
-    elif prev_message:
-        user_id, text = await id_from_reply(message)
-
-    else:
-        return None, None
-
-    try:
-        await context.bot.get_chat(user_id)
-    except BadRequest as excp:
-        if excp.message in ("User_id_invalid", "Chat not found"):
-            await message.reply_text(
-                "I don't seem to have interacted with this user before - please forward a message from "
-                "them to give me control! (like a voodoo doll, I need a piece of them to be able "
-                "to execute certain commands...)",
-            )
-        else:
-            LOGGER.exception("Exception %s on user %s", excp.message, user_id)
-
-        return None, None
-
-    return user_id, text
-
-
-async def extract_text(message) -> str:
-    return (
-        message.text
-        or message.caption
-        or (message.sticker.emoji if message.sticker else None)
-    )
-
-
-async def extract_unt_fedban(
-    message: Message, context: ContextTypes.DEFAULT_TYPE, args: List[str]
-) -> Union[(Optional[int], Optional[str])]:
-    prev_message = message.reply_to_message
-    split_text = message.text.split(None, 1)
-
-    if len(split_text) < 2:
-        return await id_from_reply(message)  # only option possible
-
-    text_to_parse = split_text[1]
-
-    text = ""
-
-    entities = list(message.parse_entities([MessageEntity.TEXT_MENTION]))
-    ent = entities[0] if entities else None
-    # if entity offset matches (command end/text start) then all good
-    if entities and ent and ent.offset == len(message.text) - len(text_to_parse):
-        ent = entities[0]
-        user_id = ent.user.id
-        text = message.text[ent.offset + ent.length :]
-
-    elif len(args) >= 1 and args[0][0] == "@":
-        user = args[0]
-        user_id = await get_user_id(user)
-        if not user_id and not isinstance(user_id, int):
-            await message.reply_text(
-                "I don't have that user in my db.  "
-                "You'll be able to interact with them if you reply to that person's message instead, or forward one of that user's messages.",
-            )
-            return None, None
-
-        else:
-            user_id = user_id
-            res = message.text.split(None, 2)
-            if len(res) >= 3:
-                text = res[2]
-
-    elif len(args) >= 1 and args[0].isdigit():
-        user_id = int(args[0])
-        res = message.text.split(None, 2)
-        if len(res) >= 3:
-            text = res[2]
-
-    elif prev_message:
-        user_id, text = await id_from_reply(message)
-
-    else:
-        return None, None
-
-    try:
-        await context.bot.get_chat(user_id)
-    except BadRequest as excp:
-        if excp.message in ("User_id_invalid", "Chat not found") and not isinstance(
-            user_id,
-            int,
-        ):
-            await message.reply_text(
-                "I don't seem to have interacted with this user before "
-                "please forward a message from them to give me control! "
-                "(like a voodoo doll, I need a piece of them to be able to execute certain commands...)",
-            )
-            return None, None
-        elif excp.message != "Chat not found":
-            LOGGER.exception("Exception %s on user %s", excp.message, user_id)
-            return None, None
-        elif not isinstance(user_id, int):
-            return None, None
-
-    return user_id, text
-
-
-async def extract_user_fban(
-    message: Message, context: ContextTypes.DEFAULT_TYPE, args: List[str]
-) -> Optional[int]:
-    return (await extract_unt_fedban(message, context, args))[0]
-
-
-# <================================================ END =======================================================>

Mikobot/plugins/helper_funcs/misc.py

@@ -1,263 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from math import ceil
-from typing import Dict, List
-from uuid import uuid4
-
-import cv2
-import ffmpeg
-from telegram import (
-    Bot,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    InlineQueryResultArticle,
-    InputTextMessageContent,
-)
-from telegram.constants import MessageLimit, ParseMode
-from telegram.error import TelegramError
-
-from Mikobot import NO_LOAD
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-class EqInlineKeyboardButton(InlineKeyboardButton):
-    def __eq__(self, other):
-        return self.text == other.text
-
-    def __lt__(self, other):
-        return self.text < other.text
-
-    def __gt__(self, other):
-        return self.text > other.text
-
-
-def split_message(msg: str) -> List[str]:
-    if len(msg) < MessageLimit.MAX_TEXT_LENGTH:
-        return [msg]
-
-    lines = msg.splitlines(True)
-    small_msg = ""
-    result = []
-    for line in lines:
-        if len(small_msg) + len(line) < MessageLimit.MAX_TEXT_LENGTH:
-            small_msg += line
-        else:
-            result.append(small_msg)
-            small_msg = line
-    else:
-        # Else statement at the end of the for loop, so append the leftover string.
-        result.append(small_msg)
-
-    return result
-
-
-def paginate_modules(page_n: int, module_dict: Dict, prefix, chat=None) -> List:
-    if not chat:
-        modules = sorted(
-            [
-                EqInlineKeyboardButton(
-                    x.__mod_name__,
-                    callback_data="{}_module({})".format(
-                        prefix, x.__mod_name__.lower()
-                    ),
-                )
-                for x in module_dict.values()
-            ]
-        )
-    else:
-        modules = sorted(
-            [
-                EqInlineKeyboardButton(
-                    x.__mod_name__,
-                    callback_data="{}_module({},{})".format(
-                        prefix, chat, x.__mod_name__.lower()
-                    ),
-                )
-                for x in module_dict.values()
-            ]
-        )
-
-    pairs = [modules[i * 3 : (i + 1) * 3] for i in range((len(modules) + 3 - 1) // 3)]
-
-    round_num = len(modules) / 3
-    calc = len(modules) - round(round_num)
-    if calc in [1, 2]:
-        pairs.append((modules[-1],))
-
-    max_num_pages = ceil(len(pairs) / 6)
-    modulo_page = page_n % max_num_pages
-
-    # can only have a certain amount of buttons side by side
-    if len(pairs) > 3:
-        pairs = pairs[modulo_page * 6 : 6 * (modulo_page + 1)] + [
-            (
-                EqInlineKeyboardButton(
-                    "◁", callback_data="{}_prev({})".format(prefix, modulo_page)
-                ),
-                EqInlineKeyboardButton("» 𝙃𝙊𝙈𝙀 «", callback_data="Miko_back"),
-                EqInlineKeyboardButton(
-                    "▷", callback_data="{}_next({})".format(prefix, modulo_page)
-                ),
-            )
-        ]
-
-    else:
-        pairs += [[EqInlineKeyboardButton("⇦ 𝘽𝘼𝘾𝙆", callback_data="Miko_back")]]
-
-    return pairs
-
-
-def article(
-    title: str = "",
-    description: str = "",
-    message_text: str = "",
-    thumb_url: str = None,
-    reply_markup: InlineKeyboardMarkup = None,
-    disable_web_page_preview: bool = False,
-) -> InlineQueryResultArticle:
-    return InlineQueryResultArticle(
-        id=uuid4(),
-        title=title,
-        description=description,
-        thumb_url=thumb_url,
-        input_message_content=InputTextMessageContent(
-            message_text=message_text,
-            disable_web_page_preview=disable_web_page_preview,
-        ),
-        reply_markup=reply_markup,
-    )
-
-
-def send_to_list(
-    bot: Bot, send_to: list, message: str, markdown=False, html=False
-) -> None:
-    if html and markdown:
-        raise Exception("Can only send with either markdown or HTML!")
-    for user_id in set(send_to):
-        try:
-            if markdown:
-                bot.send_message(user_id, message, parse_mode=ParseMode.MARKDOWN)
-            elif html:
-                bot.send_message(user_id, message, parse_mode=ParseMode.HTML)
-            else:
-                bot.send_message(user_id, message)
-        except TelegramError:
-            pass  # ignore users who fail
-
-
-def build_keyboard(buttons):
-    keyb = []
-    for btn in buttons:
-        if btn.same_line and keyb:
-            keyb[-1].append(InlineKeyboardButton(btn.name, url=btn.url))
-        else:
-            keyb.append([InlineKeyboardButton(btn.name, url=btn.url)])
-
-    return keyb
-
-
-def revert_buttons(buttons):
-    res = ""
-    for btn in buttons:
-        if btn.same_line:
-            res += "\n[{}](buttonurl://{}:same)".format(btn.name, btn.url)
-        else:
-            res += "\n[{}](buttonurl://{})".format(btn.name, btn.url)
-
-    return res
-
-
-def build_keyboard_parser(bot, chat_id, buttons):
-    keyb = []
-    for btn in buttons:
-        if btn.url == "{rules}":
-            btn.url = "http://t.me/{}?start={}".format(bot.username, chat_id)
-        if btn.same_line and keyb:
-            keyb[-1].append(InlineKeyboardButton(btn.name, url=btn.url))
-        else:
-            keyb.append([InlineKeyboardButton(btn.name, url=btn.url)])
-
-    return keyb
-
-
-def user_bot_owner(func):
-    @wraps(func)
-    def is_user_bot_owner(bot: Bot, update: Update, *args, **kwargs):
-        user = update.effective_user
-        if user and user.id == OWNER_ID:
-            return func(bot, update, *args, **kwargs)
-        else:
-            pass
-
-    return is_user_bot_owner
-
-
-def build_keyboard_alternate(buttons):
-    keyb = []
-    for btn in buttons:
-        if btn[2] and keyb:
-            keyb[-1].append(InlineKeyboardButton(btn[0], url=btn[1]))
-        else:
-            keyb.append([InlineKeyboardButton(btn[0], url=btn[1])])
-
-    return keyb
-
-
-def is_module_loaded(name):
-    return name not in NO_LOAD
-
-
-def convert_gif(input):
-    """Function to convert mp4 to webm(vp9)"""
-
-    vid = cv2.VideoCapture(input)
-    height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT)
-    width = vid.get(cv2.CAP_PROP_FRAME_WIDTH)
-
-    # check height and width to scale
-    if width > height:
-        width = 512
-        height = -1
-    elif height > width:
-        height = 512
-        width = -1
-    elif width == height:
-        width = 512
-        height = 512
-
-    converted_name = "kangsticker.webm"
-
-    (
-        ffmpeg.input(input)
-        .filter("fps", fps=30, round="up")
-        .filter("scale", width=width, height=height)
-        .trim(start="00:00:00", end="00:00:03", duration="3")
-        .output(
-            converted_name,
-            vcodec="libvpx-vp9",
-            **{
-                #'vf': 'scale=512:-1',
-                "crf": "30"
-            },
-        )
-        .overwrite_output()
-        .run()
-    )
-
-    return converted_name
-
-
-def mention_username(username: str, name: str) -> str:
-    """
-    Args:
-        username (:obj:`str`): The username of chat which you want to mention.
-        name (:obj:`str`): The name the mention is showing.
-
-    Returns:
-        :obj:`str`: The inline mention for the user as HTML.
-    """
-    return f'<a href="t.me/{username}">{escape(name)}</a>'
-
-
-# <================================================ END =======================================================>

Mikobot/plugins/helper_funcs/msg_types.py

@@ -1,251 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from enum import IntEnum, unique
-
-from telegram import Message
-
-from Mikobot.plugins.helper_funcs.string_handling import button_markdown_parser
-
-# <=======================================================================================================>
-
-
-# <================================================ CLASS =======================================================>
-@unique
-class Types(IntEnum):
-    TEXT = 0
-    BUTTON_TEXT = 1
-    STICKER = 2
-    DOCUMENT = 3
-    PHOTO = 4
-    AUDIO = 5
-    VOICE = 6
-    VIDEO = 7
-
-
-# <================================================ FUNCTION =======================================================>
-def get_note_type(msg: Message):
-    data_type = None
-    content = None
-    text = ""
-    raw_text = msg.text or msg.caption
-    args = raw_text.split(None, 2)  # use python's maxsplit to separate cmd and args
-    note_name = args[1]
-
-    buttons = []
-    # determine what the contents of the filter are - text, image, sticker, etc
-    if len(args) >= 3:
-        offset = len(args[2]) - len(
-            raw_text,
-        )  # set correct offset relative to command + notename
-        text, buttons = button_markdown_parser(
-            args[2],
-            entities=msg.parse_entities() or msg.parse_caption_entities(),
-            offset=offset,
-        )
-        if buttons:
-            data_type = Types.BUTTON_TEXT
-        else:
-            data_type = Types.TEXT
-
-    elif msg.reply_to_message and not msg.reply_to_message.forum_topic_created:
-        entities = msg.reply_to_message.parse_entities()
-        msgtext = msg.reply_to_message.text or msg.reply_to_message.caption
-        if len(args) >= 2 and msg.reply_to_message.text:  # not caption, text
-            text, buttons = button_markdown_parser(msgtext, entities=entities)
-            if buttons:
-                data_type = Types.BUTTON_TEXT
-            else:
-                data_type = Types.TEXT
-
-        elif msg.reply_to_message.sticker:
-            content = msg.reply_to_message.sticker.file_id
-            data_type = Types.STICKER
-
-        elif msg.reply_to_message.document:
-            content = msg.reply_to_message.document.file_id
-            text, buttons = button_markdown_parser(msgtext, entities=entities)
-            data_type = Types.DOCUMENT
-
-        elif msg.reply_to_message.photo:
-            content = msg.reply_to_message.photo[-1].file_id  # last elem = best quality
-            text, buttons = button_markdown_parser(msgtext, entities=entities)
-            data_type = Types.PHOTO
-
-        elif msg.reply_to_message.audio:
-            content = msg.reply_to_message.audio.file_id
-            text, buttons = button_markdown_parser(msgtext, entities=entities)
-            data_type = Types.AUDIO
-
-        elif msg.reply_to_message.voice:
-            content = msg.reply_to_message.voice.file_id
-            text, buttons = button_markdown_parser(msgtext, entities=entities)
-            data_type = Types.VOICE
-
-        elif msg.reply_to_message.video:
-            content = msg.reply_to_message.video.file_id
-            text, buttons = button_markdown_parser(msgtext, entities=entities)
-            data_type = Types.VIDEO
-
-    return note_name, text, data_type, content, buttons
-
-
-# note: add own args?
-def get_welcome_type(msg: Message):
-    data_type = None
-    content = None
-    text = ""
-
-    try:
-        if msg.reply_to_message and not msg.reply_to_message.forum_topic_created:
-            if msg.reply_to_message.text:
-                args = msg.reply_to_message.text
-            else:
-                args = msg.reply_to_message.caption
-        else:
-            args = msg.text.split(
-                None,
-                1,
-            )  # use python's maxsplit to separate cmd and args
-    except AttributeError:
-        args = False
-
-    if msg.reply_to_message and not msg.reply_to_message.forum_topic_created:
-        if msg.reply_to_message.sticker:
-            content = msg.reply_to_message.sticker.file_id
-            text = None
-            data_type = Types.STICKER
-
-        elif msg.reply_to_message.document:
-            content = msg.reply_to_message.document.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.DOCUMENT
-
-        elif msg.reply_to_message.photo:
-            content = msg.reply_to_message.photo[-1].file_id  # last elem = best quality
-            text = msg.reply_to_message.caption
-            data_type = Types.PHOTO
-
-        elif msg.reply_to_message.audio:
-            content = msg.reply_to_message.audio.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.AUDIO
-
-        elif msg.reply_to_message.voice:
-            content = msg.reply_to_message.voice.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.VOICE
-
-        elif msg.reply_to_message.video:
-            content = msg.reply_to_message.video.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.VIDEO
-
-        elif msg.reply_to_message and msg.reply_to_message.video_note:
-            content = msg.reply_to_message.video_note.file_id
-            text = None
-            data_type = Types.VIDEO_NOTE
-
-    buttons = []
-    # determine what the contents of the filter are - text, image, sticker, etc
-    if args:
-        if msg.reply_to_message and not msg.reply_to_message.forum_topic_created:
-            argumen = (
-                msg.reply_to_message.caption if msg.reply_to_message.caption else ""
-            )
-            offset = 0  # offset is no need since target was in reply
-            entities = msg.reply_to_message.parse_entities()
-        else:
-            argumen = args[1]
-            offset = len(argumen) - len(
-                msg.text,
-            )  # set correct offset relative to command + notename
-            entities = msg.parse_entities()
-        text, buttons = button_markdown_parser(
-            argumen,
-            entities=entities,
-            offset=offset,
-        )
-
-    if not data_type:
-        if text and buttons:
-            data_type = Types.BUTTON_TEXT
-        elif text:
-            data_type = Types.TEXT
-
-    return text, data_type, content, buttons
-
-
-def get_filter_type(msg: Message):
-    if not msg.reply_to_message and msg.text and len(msg.text.split()) >= 3:
-        content = None
-        text = msg.text.split(None, 2)[2]
-        data_type = Types.TEXT
-        media_spoiler = None
-    elif msg.reply_to_message and msg.reply_to_message.forum_topic_created:
-        content = None
-        text = msg.text.split(None, 2)[2]
-        data_type = Types.TEXT
-        media_spoiler = None
-    elif msg.reply_to_message and not msg.reply_to_message.forum_topic_created:
-        if msg.reply_to_message.text and len(msg.text.split()) >= 2:
-            content = None
-            text = msg.reply_to_message.text
-            data_type = Types.TEXT
-            media_spoiler = None
-
-        elif msg.reply_to_message.sticker:
-            content = msg.reply_to_message.sticker.file_id
-            text = None
-            data_type = Types.STICKER
-            media_spoiler = None
-
-        elif msg.reply_to_message.document:
-            content = msg.reply_to_message.document.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.DOCUMENT
-            media_spoiler = None
-
-        elif msg.reply_to_message.photo:
-            content = msg.reply_to_message.photo[-1].file_id  # last elem = best quality
-            text = msg.reply_to_message.caption
-            data_type = Types.PHOTO
-            media_spoiler = msg.reply_to_message.has_media_spoiler
-
-        elif msg.reply_to_message.audio:
-            content = msg.reply_to_message.audio.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.AUDIO
-            media_spoiler = None
-
-        elif msg.reply_to_message.voice:
-            content = msg.reply_to_message.voice.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.VOICE
-            media_spoiler = None
-
-        elif msg.reply_to_message.video:
-            content = msg.reply_to_message.video.file_id
-            text = msg.reply_to_message.caption
-            data_type = Types.VIDEO
-            media_spoiler = msg.reply_to_message.has_media_spoiler
-
-        elif msg.reply_to_message.video_note:
-            content = msg.reply_to_message.video_note.file_id
-            text = None
-            data_type = Types.VIDEO_NOTE
-            media_spoiler = None
-
-        else:
-            text = None
-            data_type = None
-            content = None
-            media_spoiler = None
-    else:
-        text = None
-        data_type = None
-        content = None
-        media_spoiler = None
-
-    return text, data_type, content, media_spoiler
-
-
-# <================================================ END =======================================================>

Mikobot/plugins/helper_funcs/string_handling.py

@@ -1,311 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import re
-import time
-from typing import Dict, List
-
-import bleach
-import markdown2
-from emoji import unicode_codes
-from telegram import MessageEntity
-from telegram.helpers import escape_markdown
-
-# <=======================================================================================================>
-
-MATCH_MD = re.compile(
-    r"\*(.*?)\*|"
-    r"_(.*?)_|"
-    r"`(.*?)`|"
-    r"(?<!\\)(\[.*?\])(\(.*?\))|"
-    r"(?P<esc>[*_`\[])",
-)
-
-LINK_REGEX = re.compile(r"(?<!\\)\[.+?\]\((.*?)\)")
-BTN_URL_REGEX = re.compile(r"(\[([^\[]+?)\]\(buttonurl:(?:/{0,2})(.+?)(:same)?\))")
-_EMOJI_REGEXP = None
-
-
-# <================================================ FUNCTION =======================================================>
-def get_emoji_regexp():
-    global _EMOJI_REGEXP
-    if _EMOJI_REGEXP is None:
-        emojis = sorted(unicode_codes.EMOJI_DATA, key=len, reverse=True)
-        pattern = "(" + "|".join(re.escape(u) for u in emojis) + ")"
-    return re.compile(pattern)
-
-
-def _selective_escape(to_parse: str) -> str:
-    """
-    Escape all invalid markdown
-
-    :param to_parse: text to escape
-    :return: valid markdown string
-    """
-    offset = 0  # offset to be used as adding a \ character causes the string to shift
-    for match in MATCH_MD.finditer(to_parse):
-        if match.group("esc"):
-            ent_start = match.start()
-            to_parse = (
-                to_parse[: ent_start + offset] + "\\" + to_parse[ent_start + offset :]
-            )
-            offset += 1
-    return to_parse
-
-
-# This is a fun one.
-def _calc_emoji_offset(to_calc) -> int:
-    # Get all emoji in text.
-    emoticons = get_emoji_regexp().finditer(to_calc)
-    # Check the utf16 length of the emoji to determine the offset it caused.
-    # Normal, 1 character emoji don't affect; hence sub 1.
-    # special, eg with two emoji characters (eg face, and skin col) will have length 2, so by subbing one we
-    # know we'll get one extra offset,
-    return sum(len(e.group(0).encode("utf-16-le")) // 2 - 1 for e in emoticons)
-
-
-def markdown_parser(
-    txt: str,
-    entities: Dict[MessageEntity, str] = None,
-    offset: int = 0,
-) -> str:
-    """
-    Parse a string, escaping all invalid markdown entities.
-
-    Escapes URL's so as to avoid URL mangling.
-    Re-adds any telegram code entities obtained from the entities object.
-
-    :param txt: text to parse
-    :param entities: dict of message entities in text
-    :param offset: message offset - command and notename length
-    :return: valid markdown string
-    """
-    if not entities:
-        entities = {}
-    if not txt:
-        return ""
-
-    prev = 0
-    res = ""
-    # Loop over all message entities, and:
-    # reinsert code
-    # escape free-standing urls
-    for ent, ent_text in entities.items():
-        if ent.offset < -offset:
-            continue
-
-        start = ent.offset + offset  # start of entity
-        end = ent.offset + offset + ent.length - 1  # end of entity
-
-        # we only care about code, url, text links
-        if ent.type in ("code", "url", "text_link", "spoiler"):
-            # count emoji to switch counter
-            count = _calc_emoji_offset(txt[:start])
-            start -= count
-            end -= count
-
-            # URL handling -> do not escape if in [](), escape otherwise.
-            if ent.type == "url":
-                if any(
-                    match.start(1) <= start and end <= match.end(1)
-                    for match in LINK_REGEX.finditer(txt)
-                ):
-                    continue
-                # else, check the escapes between the prev and last and forcefully escape the url to avoid mangling
-                else:
-                    # TODO: investigate possible offset bug when lots of emoji are present
-                    res += _selective_escape(txt[prev:start] or "") + escape_markdown(
-                        ent_text, 2
-                    )
-
-            # code handling
-            elif ent.type == "code":
-                res += _selective_escape(txt[prev:start]) + "`" + ent_text + "`"
-
-            # handle markdown/html links
-            elif ent.type == "text_link":
-                res += _selective_escape(txt[prev:start]) + "[{}]({})".format(
-                    ent_text,
-                    ent.url,
-                )
-            # handle spoiler
-            elif ent.type == "spoiler":
-                res += _selective_escape(txt[prev:start]) + "||" + ent_text + "||"
-
-            end += 1
-
-        # anything else
-        else:
-            continue
-
-        prev = end
-
-    res += _selective_escape(txt[prev:])  # add the rest of the text
-    return res
-
-
-def button_markdown_parser(
-    txt: str,
-    entities: Dict[MessageEntity, str] = None,
-    offset: int = 0,
-) -> (str, List):
-    markdown_note = markdown_parser(txt, entities, offset)
-    prev = 0
-    note_data = ""
-    buttons = []
-    for match in BTN_URL_REGEX.finditer(markdown_note):
-        # Check if btnurl is escaped
-        n_escapes = 0
-        to_check = match.start(1) - 1
-        while to_check > 0 and markdown_note[to_check] == "\\":
-            n_escapes += 1
-            to_check -= 1
-
-        # if even, not escaped -> create button
-        if n_escapes % 2 == 0:
-            # create a thruple with button label, url, and newline status
-            buttons.append((match.group(2), match.group(3), bool(match.group(4))))
-            note_data += markdown_note[prev : match.start(1)]
-            prev = match.end(1)
-        # if odd, escaped -> move along
-        else:
-            note_data += markdown_note[prev:to_check]
-            prev = match.start(1) - 1
-    else:
-        note_data += markdown_note[prev:]
-
-    return note_data, buttons
-
-
-def escape_invalid_curly_brackets(text: str, valids: List[str]) -> str:
-    new_text = ""
-    idx = 0
-    while idx < len(text):
-        if text[idx] == "{":
-            if idx + 1 < len(text) and text[idx + 1] == "{":
-                idx += 2
-                new_text += "{{{{"
-                continue
-            else:
-                success = False
-                for v in valids:
-                    if text[idx:].startswith("{" + v + "}"):
-                        success = True
-                        break
-                if success:
-                    new_text += text[idx : idx + len(v) + 2]
-                    idx += len(v) + 2
-                    continue
-                else:
-                    new_text += "{{"
-
-        elif text[idx] == "}":
-            if idx + 1 < len(text) and text[idx + 1] == "}":
-                idx += 2
-                new_text += "}}}}"
-                continue
-            else:
-                new_text += "}}"
-
-        else:
-            new_text += text[idx]
-        idx += 1
-
-    return new_text
-
-
-SMART_OPEN = "“"
-SMART_CLOSE = "”"
-START_CHAR = ("'", '"', SMART_OPEN)
-
-
-def split_quotes(text: str) -> List:
-    if not any(text.startswith(char) for char in START_CHAR):
-        return text.split(None, 1)
-    counter = 1  # ignore first char -> is some kind of quote
-    while counter < len(text):
-        if text[counter] == "\\":
-            counter += 1
-        elif text[counter] == text[0] or (
-            text[0] == SMART_OPEN and text[counter] == SMART_CLOSE
-        ):
-            break
-        counter += 1
-    else:
-        return text.split(None, 1)
-
-    # 1 to avoid starting quote, and counter is exclusive so avoids ending
-    key = remove_escapes(text[1:counter].strip())
-    # index will be in range, or `else` would have been executed and returned
-    rest = text[counter + 1 :].strip()
-    if not key:
-        key = text[0] + text[0]
-    return list(filter(None, [key, rest]))
-
-
-def remove_escapes(text: str) -> str:
-    res = ""
-    is_escaped = False
-    for counter in range(len(text)):
-        if is_escaped:
-            res += text[counter]
-            is_escaped = False
-        elif text[counter] == "\\":
-            is_escaped = True
-        else:
-            res += text[counter]
-    return res
-
-
-def escape_chars(text: str, to_escape: List[str]) -> str:
-    to_escape.append("\\")
-    new_text = ""
-    for x in text:
-        if x in to_escape:
-            new_text += "\\"
-        new_text += x
-    return new_text
-
-
-async def extract_time(message, time_val):
-    if any(time_val.endswith(unit) for unit in ("m", "h", "d")):
-        unit = time_val[-1]
-        time_num = time_val[:-1]  # type: str
-        if not time_num.isdigit():
-            await message.reply_text("Invalid time amount specified.")
-            return ""
-
-        if unit == "m":
-            bantime = int(time.time() + int(time_num) * 60)
-        elif unit == "h":
-            bantime = int(time.time() + int(time_num) * 60 * 60)
-        elif unit == "d":
-            bantime = int(time.time() + int(time_num) * 24 * 60 * 60)
-        else:
-            # how even...?
-            return ""
-        return bantime
-    else:
-        await message.reply_text(
-            "Invalid time type specified. Expected m,h, or d, got: {}".format(
-                time_val[-1],
-            ),
-        )
-        return ""
-
-
-def markdown_to_html(text: str):
-    text = text.replace("*", "**")
-    text = text.replace("`", "```")
-    text = text.replace("~", "~~")
-
-    spoiler_pattern = re.compile(r"\|\|(?=\S)(.+?)(?<=\S)\|\|", re.S)
-    text = spoiler_pattern.sub(r"<tg-spoiler>\1</tg-spoiler>", text)
-
-    _html = markdown2.markdown(text, extras=["strike", "underline"])
-    return bleach.clean(
-        _html,
-        tags=["strong", "em", "a", "code", "pre", "strike", "u", "tg-spoiler"],
-        strip=True,
-    )[:-1]
-
-
-# <================================================ END =======================================================>

Mikobot/plugins/hyperlink.py

@@ -1,63 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# PROVIDED BY https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import random
-import re
-
-from telegram import Update
-from telegram.constants import ParseMode
-from telegram.ext import CommandHandler, ContextTypes
-
-from Mikobot import function
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-# Define the command handler for the "/pickwinner" command
-async def pick_winner(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    # Get the list of participants
-    participants = context.args
-
-    if participants:
-        # Select a random winner
-        winner = random.choice(participants)
-
-        # Send the winner as a reply
-        await update.message.reply_text(f"🎉 The winner is: {winner}")
-    else:
-        # If no participants are provided
-        await update.message.reply_text("Please provide a list of participants.")
-
-
-# Define the command handler for the "/hyperlink" command
-async def hyperlink_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    if len(args) >= 2:
-        text = " ".join(args[:-1])
-        link = args[-1]
-        hyperlink = f"[{text}]({link})"
-        await update.message.reply_text(
-            text=hyperlink, parse_mode="Markdown", disable_web_page_preview=True
-        )
-    else:
-        match = re.search(r"/hyperlink ([^\s]+) (.+)", update.message.text)
-        if match:
-            text = match.group(1)
-            link = match.group(2)
-            hyperlink = f"[{text}]({link})"
-            await update.message.reply_text(
-                text=hyperlink, parse_mode=ParseMode.HTML, disable_web_page_preview=True
-            )
-        else:
-            await update.message.reply_text(
-                "❌ Invalid format! Please use the format: /hyperlink <text> <link>."
-            )
-
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("pickwinner", pick_winner, block=False))
-function(CommandHandler("hyperlink", hyperlink_command, block=False))
-# <================================================ END =======================================================>

Mikobot/plugins/imagegen.py

@@ -1,132 +0,0 @@
-# CREATED BY: https://t.me/O_oKarma
-# API CREDITS: @Qewertyy
-# PROVIDED BY: https://github.com/Team-ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import asyncio
-
-import aiohttp
-from telethon import events
-
-from Mikobot import tbot as client
-
-# <=======================================================================================================>
-
-BASE_URL = "https://lexica.qewertyy.me"
-SESSION_HEADERS = {"Host": "lexica.qewertyy.me"}
-
-
-# <=============================================== CLASS + FUNCTION ========================================================>
-class AsyncClient:
-    def __init__(self):
-        self.url = BASE_URL
-        self.session = aiohttp.ClientSession()
-
-    async def generate(self, model_id, prompt, negative_prompt):
-        data = {
-            "model_id": model_id,
-            "prompt": prompt,
-            "negative_prompt": negative_prompt if negative_prompt else "",
-            "num_images": 1,
-        }
-        try:
-            async with self.session.post(
-                f"{self.url}/models/inference", data=data, headers=SESSION_HEADERS
-            ) as resp:
-                return await resp.json()
-        except Exception as e:
-            print(f"Request failed: {str(e)}")
-
-    async def get_images(self, task_id, request_id):
-        data = {"task_id": task_id, "request_id": request_id}
-        try:
-            async with self.session.post(
-                f"{self.url}/models/inference/task", data=data, headers=SESSION_HEADERS
-            ) as resp:
-                return await resp.json()
-        except Exception as e:
-            print(f"Request failed: {str(e)}")
-
-
-async def generate_image_handler(event, model_id):
-    command_parts = event.text.split(" ", 1)
-    if len(command_parts) < 2:
-        await event.reply("Please provide a prompt.")
-        return
-
-    prompt = command_parts[1]
-    negative_prompt = ""
-
-    # Send the initial "Generating your image, wait sometime" message
-    reply_message = await event.reply("Generating your image, please wait...")
-
-    client = AsyncClient()
-    response = await client.generate(model_id, prompt, negative_prompt)
-    task_id = response["task_id"]
-    request_id = response["request_id"]
-
-    while True:
-        generated_images = await client.get_images(task_id, request_id)
-
-        if "img_urls" in generated_images:
-            for img_url in generated_images["img_urls"]:
-                # Delete the initial reply message
-                await reply_message.delete()
-
-                # Send the generated image
-                await event.reply(file=img_url)
-            break  # Exit the loop when images are available
-        else:
-            # Wait for a few seconds before checking again
-            await asyncio.sleep(5)
-
-        # Optionally, you can add a timeout to avoid an infinite loop
-        timeout_seconds = 600  # 10 minutes (adjust as needed)
-        if timeout_seconds <= 0:
-            await reply_message.edit("Image generation timed out.")
-            break
-
-        timeout_seconds -= 5  # Decrement timeout by 5 seconds
-
-
-@client.on(events.NewMessage(pattern=r"/meinamix"))
-async def meinamix_handler(event):
-    await generate_image_handler(event, model_id=2)
-
-
-@client.on(events.NewMessage(pattern=r"/sushi"))
-async def darksushi_handler(event):
-    await generate_image_handler(event, model_id=7)
-
-
-@client.on(events.NewMessage(pattern=r"/meinahentai"))
-async def meinahentai_handler(event):
-    await generate_image_handler(event, model_id=8)
-
-
-@client.on(events.NewMessage(pattern=r"/darksushimix"))
-async def darksushimix_handler(event):
-    await generate_image_handler(event, model_id=9)
-
-
-@client.on(events.NewMessage(pattern=r"/anylora"))
-async def anylora_handler(event):
-    await generate_image_handler(event, model_id=3)
-
-
-@client.on(events.NewMessage(pattern=r"/cetusmix"))
-async def cetusmix_handler(event):
-    await generate_image_handler(event, model_id=10)
-
-
-@client.on(events.NewMessage(pattern=r"/darkv2"))
-async def darkv_handler(event):
-    await generate_image_handler(event, model_id=14)
-
-
-@client.on(events.NewMessage(pattern=r"/creative"))
-async def creative_handler(event):
-    await generate_image_handler(event, model_id=12)
-
-
-# <================================================ END =======================================================>

Mikobot/plugins/info.py

@@ -1,221 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import os
-import re
-from html import escape
-from random import choice
-
-from telegram import ChatMemberAdministrator, Update
-from telegram.constants import ChatID, ChatType, ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CommandHandler, ContextTypes
-from telegram.helpers import mention_html
-
-from Database.sql.approve_sql import is_approved
-from Infamous.karma import START_IMG
-from Mikobot import DEV_USERS, DRAGONS, INFOPIC, OWNER_ID, function
-from Mikobot.__main__ import STATS, USER_INFO
-from Mikobot.plugins.helper_funcs.chat_status import support_plus, dev_plus
-from Mikobot.plugins.users import get_user_id
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def info(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    message = update.effective_message
-    args = context.args
-    bot = context.bot
-
-    def reply_with_text(text):
-        return message.reply_text(text, parse_mode=ParseMode.HTML)
-
-    head = ""
-    premium = False
-
-    reply = await reply_with_text("<code>Getting information...</code>")
-
-    user_id = None
-    user_name = None
-
-    if len(args) >= 1:
-        if args[0][0] == "@":
-            user_name = args[0]
-            user_id = await get_user_id(user_name)
-
-        if not user_id:
-            try:
-                chat_obj = await bot.get_chat(user_name)
-                userid = chat_obj.id
-            except BadRequest:
-                await reply_with_text(
-                    "I can't get information about this user/channel/group."
-                )
-                return
-        else:
-            userid = user_id
-    elif len(args) >= 1 and args[0].lstrip("-").isdigit():
-        userid = int(args[0])
-    elif message.reply_to_message and not message.reply_to_message.forum_topic_created:
-        if message.reply_to_message.sender_chat:
-            userid = message.reply_to_message.sender_chat.id
-        elif message.reply_to_message.from_user:
-            if message.reply_to_message.from_user.id == ChatID.FAKE_CHANNEL:
-                userid = message.reply_to_message.chat.id
-            else:
-                userid = message.reply_to_message.from_user.id
-                premium = message.reply_to_message.from_user.is_premium
-    elif not message.reply_to_message and not args:
-        if message.from_user.id == ChatID.FAKE_CHANNEL:
-            userid = message.sender_chat.id
-        else:
-            userid = message.from_user.id
-            premium = message.from_user.is_premium
-
-    try:
-        chat_obj = await bot.get_chat(userid)
-    except (BadRequest, UnboundLocalError):
-        await reply_with_text("I can't get information about this user/channel/group.")
-        return
-
-    if chat_obj.type == ChatType.PRIVATE:
-        if chat_obj.username:
-            head = f"⇨【 <b>USER INFORMATION</b> 】⇦\n\n"
-            if chat_obj.username.endswith("bot"):
-                head = f"⇨【 <b>BOT INFORMATION</b> 】⇦\n\n"
-
-        head += f"➲ <b>ID:</b> <code>{chat_obj.id}</code>"
-        head += f"\n➲ <b>First Name:</b> {chat_obj.first_name}"
-        if chat_obj.last_name:
-            head += f"\n➲ <b>Last Name:</b> {chat_obj.last_name}"
-        if chat_obj.username:
-            head += f"\n➲ <b>Username:</b> @{chat_obj.username}"
-        head += f"\n➲ <b>Permalink:</b> {mention_html(chat_obj.id, 'link')}"
-
-        if chat_obj.username and not chat_obj.username.endswith("bot"):
-            head += f"\n\n💎 <b>Premium User:</b> {premium}"
-
-        if chat_obj.bio:
-            head += f"\n\n<b>➲ Bio:</b> {chat_obj.bio}"
-
-        chat_member = await chat.get_member(chat_obj.id)
-        if isinstance(chat_member, ChatMemberAdministrator):
-            head += f"\n➲ <b>Presence:</b> {chat_member.status}"
-            if chat_member.custom_title:
-                head += f"\n➲ <b>Admin Title:</b> {chat_member.custom_title}"
-        else:
-            head += f"\n➲ <b>Presence:</b> {chat_member.status}"
-
-        if is_approved(chat.id, chat_obj.id):
-            head += f"\n➲ <b>Approved:</b> This user is approved in this chat."
-
-        disaster_level_present = False
-
-        if chat_obj.id == OWNER_ID:
-            head += "\n\n👑 <b>The disaster level of this person is My Owner.</b>"
-            disaster_level_present = True
-        elif chat_obj.id in DEV_USERS:
-            head += "\n\n🐉 <b>This user is a member of Infamous Hydra.</b>"
-            disaster_level_present = True
-        elif chat_obj.id in DRAGONS:
-            head += "\n\n🐲 <b>The disaster level of this person is Dragon.</b>"
-            disaster_level_present = True
-        if disaster_level_present:
-            head += " [?]"
-
-        for mod in USER_INFO:
-            try:
-                mod_info = mod.__user_info__(chat_obj.id).strip()
-            except TypeError:
-                mod_info = mod.__user_info__(chat_obj.id, chat.id).strip()
-
-            head += "\n\n" + mod_info if mod_info else ""
-
-    if chat_obj.type == ChatType.SENDER:
-        head = f"📨 Sender Chat Information:\n"
-        await reply_with_text("Found sender chat, getting information...")
-        head += f"<b>ID:</b> <code>{chat_obj.id}</code>"
-        if chat_obj.title:
-            head += f"\n🏷️ <b>Title:</b> {chat_obj.title}"
-        if chat_obj.username:
-            head += f"\n📧 <b>Username:</b> @{chat_obj.username}"
-        head += f"\n🔗 Permalink: {mention_html(chat_obj.id, 'link')}"
-        if chat_obj.description:
-            head += f"\n📝 <b>Description:</b> {chat_obj.description}"
-
-    elif chat_obj.type == ChatType.CHANNEL:
-        head = f"Channel Information:\n"
-        await reply_with_text("Found channel, getting information...")
-        head += f"<b>ID:</b> <code>{chat_obj.id}</code>"
-        if chat_obj.title:
-            head += f"\n<b>Title:</b> {chat_obj.title}"
-        if chat_obj.username:
-            head += f"\n<b>Username:</b> @{chat_obj.username}"
-        head += f"\nPermalink: {mention_html(chat_obj.id, 'link')}"
-        if chat_obj.description:
-            head += f"\n<b>Description:</b> {chat_obj.description}"
-        if chat_obj.linked_chat_id:
-            head += f"\n<b>Linked Chat ID:</b> <code>{chat_obj.linked_chat_id}</code>"
-
-    elif chat_obj.type in [ChatType.GROUP, ChatType.SUPERGROUP]:
-        head = f"Group Information:\n"
-        await reply_with_text("Found group, getting information...")
-        head += f"<b>ID:</b> <code>{chat_obj.id}</code>"
-        if chat_obj.title:
-            head += f"\n<b>Title:</b> {chat_obj.title}"
-        if chat_obj.username:
-            head += f"\n<b>Username:</b> @{chat_obj.username}"
-        head += f"\nPermalink: {mention_html(chat_obj.id, 'link')}"
-        if chat_obj.description:
-            head += f"\n<b>Description:</b> {chat_obj.description}"
-
-    if INFOPIC:
-        try:
-            if chat_obj.photo:
-                _file = await chat_obj.photo.get_big_file()
-                await _file.download_to_drive(f"{chat_obj.id}.png")
-                await message.reply_photo(
-                    photo=open(f"{chat_obj.id}.png", "rb"),
-                    caption=(head),
-                    parse_mode=ParseMode.HTML,
-                )
-                await reply.delete()
-                os.remove(f"{chat_obj.id}.png")
-            else:
-                await reply_with_text(escape(head))
-        except:
-            await reply_with_text(escape(head))
-
-
-@dev_plus
-async def stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    stats = "📊 <b>Miko-Bot's Statistics:</b>\n\n" + "\n".join(
-        [mod.__stats__() for mod in STATS]
-    )
-    result = re.sub(r"(\d+)", r"<code>\1</code>", stats)
-
-    await update.effective_message.reply_photo(
-        photo=str(choice(START_IMG)), caption=result, parse_mode=ParseMode.HTML
-    )
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-*Overall information about user:*
-
-» /info : Fetch information.
-"""
-
-# <================================================ HANDLER =======================================================>
-STATS_HANDLER = CommandHandler(["stats", "gstats"], stats, block=False)
-INFO_HANDLER = CommandHandler(("info", "book"), info, block=False)
-
-function(STATS_HANDLER)
-function(INFO_HANDLER)
-
-__mod_name__ = "INFO"
-__command_list__ = ["info"]
-__handlers__ = [INFO_HANDLER, STATS_HANDLER]
-# <================================================ END =======================================================>

Mikobot/plugins/instadl.py

@@ -1,66 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# PROVIDED BY https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-from telegram import Update
-from telegram.ext import CommandHandler, ContextTypes
-
-from Mikobot import function
-from Mikobot.state import state
-
-# <=======================================================================================================>
-
-DOWNLOADING_STICKER_ID = (
-    "CAACAgIAAxkBAAEDv_xlJWmh2-fKRwvLywJaFeGy9wmBKgACVQADr8ZRGmTn_PAl6RC_MAQ"
-)
-API_URL = "https://karma-api2.vercel.app/instadl"  # Replace with your actual API URL
-
-
-# <================================================ FUNCTION =======================================================>
-async def instadl_command_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    if len(context.args) < 1:
-        await update.message.reply_text("Usage: /instadl [Instagram URL]")
-        return
-
-    link = context.args[0]
-    try:
-        downloading_sticker = await update.message.reply_sticker(DOWNLOADING_STICKER_ID)
-
-        # Make an asynchronous GET request to the API using httpx
-        response = await state.get(API_URL, params={"url": link})
-        data = response.json()
-
-        # Check if the API request was successful
-        if "content_url" in data:
-            content_url = data["content_url"]
-
-            # Determine content type from the URL
-            content_type = "video" if "video" in content_url else "photo"
-
-            # Reply with either photo or video
-            if content_type == "photo":
-                await update.message.reply_photo(content_url)
-            elif content_type == "video":
-                await update.message.reply_video(content_url)
-            else:
-                await update.message.reply_text("Unsupported content type.")
-        else:
-            await update.message.reply_text(
-                "Unable to fetch content. Please check the Instagram URL or try with another Instagram link."
-            )
-
-    except Exception as e:
-        print(e)
-        await update.message.reply_text(
-            "An error occurred while processing the request."
-        )
-
-    finally:
-        await downloading_sticker.delete()
-
-
-function(
-    CommandHandler(["ig", "instagram", "insta", "instadl"], instadl_command_handler)
-)
-# <================================================ END =======================================================>

Mikobot/plugins/karma.py

@@ -1,182 +0,0 @@
-# https://github.com/Team-ProjectCodeX
-# UPDATED BY https://t.me/O_okarma
-# https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import asyncio
-
-from pyrogram import filters
-
-from Database.mongodb.karma_mongo import *
-from Mikobot import OWNER_ID, app
-from Mikobot.utils.can_restrict import can_restrict
-from Mikobot.utils.errors import capture_err
-
-# <=======================================================================================================>
-
-karma_positive_group = 3
-karma_negative_group = 4
-
-
-# <================================================ FUNCTION =======================================================>
-@app.on_message(
-    filters.text
-    & filters.group
-    & filters.incoming
-    & filters.reply
-    & filters.regex(
-        r"^(\+|\+\+|\+1|thx|tnx|ty|tq|thank you|thanx|thanks|pro|cool|good|agree|makasih|👍|\+\+ .+)$"
-    )
-    & ~filters.via_bot
-    & ~filters.bot,
-    group=karma_positive_group,
-)
-@capture_err
-async def upvote(_, message):
-    if not await is_karma_on(message.chat.id):
-        return
-    reply_user = message.reply_to_message.from_user
-    current_user = message.from_user
-    if not (reply_user and current_user):
-        return
-    if reply_user.id == OWNER_ID:
-        await message.reply_text("How so pro?")
-        return
-    if reply_user.id == current_user.id:
-        return
-
-    chat_id = message.chat.id
-    user_id = reply_user.id
-    user_mention = reply_user.mention
-    current_karma = await get_karma(chat_id, await int_to_alpha(user_id))
-    karma = current_karma["karma"] + 1 if current_karma else 1
-    new_karma = {"karma": karma}
-    await update_karma(chat_id, await int_to_alpha(user_id), new_karma)
-    await message.reply_text(
-        f"𝗜𝗻𝗰𝗿𝗲𝗺𝗲𝗻𝘁𝗲𝗱 𝗸𝗮𝗿𝗺𝗮 𝗼𝗳 {user_mention} 𝗯𝘆 1.\n**⭐️ 𝗧𝗢𝗧𝗔𝗟 𝗣𝗢𝗜𝗡𝗧𝗦:** {karma}"
-    )
-
-
-@app.on_message(
-    filters.text
-    & filters.group
-    & filters.incoming
-    & filters.reply
-    & filters.regex(r"^(-|--|-1|not cool|disagree|worst|bad|👎|-- .+)$")
-    & ~filters.via_bot
-    & ~filters.bot,
-    group=karma_negative_group,
-)
-@capture_err
-async def downvote(_, message):
-    if not await is_karma_on(message.chat.id):
-        return
-    reply_user = message.reply_to_message.from_user
-    current_user = message.from_user
-    if not (reply_user and current_user):
-        return
-    if reply_user.id == OWNER_ID:
-        await message.reply_text("I know him, so I'm not gonna do that, baby.")
-        return
-    if reply_user.id == current_user.id:
-        return
-
-    user_id = reply_user.id
-    user_mention = reply_user.mention
-    current_karma = await get_karma(message.chat.id, await int_to_alpha(user_id))
-    karma = current_karma["karma"] - 1 if current_karma else 0
-    new_karma = {"karma": karma}
-    await update_karma(message.chat.id, await int_to_alpha(user_id), new_karma)
-    await message.reply_text(
-        f"𝗗𝗲𝗰𝗿𝗲𝗺𝗲𝗻𝘁𝗲𝗱 𝗸𝗮𝗿𝗺𝗮 𝗼𝗳 {user_mention} 𝗯𝘆 1.\n**⭐️ 𝗧𝗢𝗧𝗔𝗟 𝗣𝗢𝗜𝗡𝗧𝗦:** {karma}"
-    )
-
-
-@app.on_message(filters.command("karmastat") & filters.group)
-@capture_err
-async def karma(_, message):
-    if not message.reply_to_message:
-        m = await message.reply_text("Analyzing karma... This may take a while.")
-        karma = await get_karmas(message.chat.id)
-        if not karma:
-            await m.edit_text("No karma in the database for this chat.")
-            return
-        msg = f"**🎖 𝗞𝗔𝗥𝗠𝗔 𝗟𝗜𝗦𝗧 𝗢𝗙 {message.chat.title} :**\n"
-        limit = 0
-        karma_dicc = {}
-        for i in karma:
-            user_id = await alpha_to_int(i)
-            user_karma = karma[i]["karma"]
-            karma_dicc[str(user_id)] = user_karma
-            karma_arranged = dict(
-                sorted(karma_dicc.items(), key=lambda item: item[1], reverse=True)
-            )
-        if not karma_dicc:
-            await m.edit_text("No karma in the database for this chat.")
-            return
-        for user_idd, karma_count in karma_arranged.items():
-            if limit > 9:
-                break
-            try:
-                user = await _.get_users(int(user_idd))
-                await asyncio.sleep(0.8)
-            except Exception:
-                continue
-            first_name = user.first_name
-            if not first_name:
-                continue
-            msg += f"`{karma_count}`  {(first_name[0:12] + '...') if len(first_name) > 12 else first_name}\n"
-            limit += 1
-        await m.edit_text(msg)
-    else:
-        user_id = message.reply_to_message.from_user.id
-        karma = await get_karma(message.chat.id, await int_to_alpha(user_id))
-        karma = karma["karma"] if karma else 0
-        await message.reply_text(f"**⭐️ 𝗧𝗢𝗧𝗔𝗟 𝗣𝗢𝗜𝗡𝗧𝗦:** {karma}")
-
-
-@app.on_message(filters.command("karma"))
-@can_restrict
-async def karma_toggle_xd(_, message):
-    usage = "**Usage:**\n/karma [ON|OFF]"
-    if len(message.command) != 2:
-        return await message.reply_text(usage)
-    chat_id = message.chat.id
-    state = message.text.split(None, 1)[1].strip().lower()
-
-    if state == "on":
-        disabled = karmadb.find_one({"chat_id_toggle": chat_id})
-        if disabled:
-            karmadb.delete_one({"chat_id_toggle": chat_id})
-            await message.reply_text("Enabled the karma system.")
-        else:
-            await message.reply_text("Karma system is already enabled.")
-    elif state == "off":
-        disabled = karmadb.find_one({"chat_id_toggle": chat_id})
-        if disabled:
-            await message.reply_text("Karma system is already disabled.")
-        else:
-            karmadb.insert_one({"chat_id_toggle": chat_id})
-            await message.reply_text("Disabled the karma system.")
-    else:
-        await message.reply_text(usage)
-
-
-# <=================================================== HELP ====================================================>
-
-
-__mod_name__ = "KARMA"
-__help__ = """
-
-➠ *UPVOTE* - Use upvote keywords like "+", "+1", "thanks", etc. to upvote a message.
-➠ *DOWNVOTE* - Use downvote keywords like "-", "-1", etc. to downvote a message.
-
-➠ *Commands*
-
-» /karmastat:- `Reply to a user to check that user's karma points`
-
-» /karmastat:- `Send without replying to any message to check karma point list of top 10`
-
-» /karma [OFF|ON] - `Enable or disable karma system in your chat.`
-"""
-# <================================================ END =======================================================>

Mikobot/plugins/log_channel.py

@@ -1,257 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from datetime import datetime
-from functools import wraps
-
-from telegram.constants import ChatType
-from telegram.ext import ContextTypes
-
-from Mikobot import function
-from Mikobot.plugins.helper_funcs.misc import is_module_loaded
-
-FILENAME = __name__.rsplit(".", 1)[-1]
-
-if is_module_loaded(FILENAME):
-    from telegram import Update
-    from telegram.constants import ParseMode
-    from telegram.error import BadRequest, Forbidden
-    from telegram.ext import CommandHandler, JobQueue
-    from telegram.helpers import escape_markdown
-
-    from Database.sql import log_channel_sql as sql
-    from Mikobot import EVENT_LOGS, LOGGER, dispatcher
-    from Mikobot.plugins.helper_funcs.chat_status import check_admin
-
-    # <=======================================================================================================>
-    # <================================================ FUNCTION =======================================================>
-    def loggable(func):
-        @wraps(func)
-        async def log_action(
-            update: Update,
-            context: ContextTypes.DEFAULT_TYPE,
-            job_queue: JobQueue = None,
-            *args,
-            **kwargs,
-        ):
-            if not job_queue:
-                result = await func(update, context, *args, **kwargs)
-            else:
-                result = await func(update, context, job_queue, *args, **kwargs)
-
-            chat = update.effective_chat
-            message = update.effective_message
-
-            if result and isinstance(result, str):
-                datetime_fmt = "%H:%M - %d-%m-%Y"
-                result += f"\nEvent stamp: {datetime.utcnow().strftime(datetime_fmt)}"
-
-                if chat.is_forum and chat.username:
-                    result += f"\nLink: https://t.me/{chat.username}/{message.message_thread_id}/{message.message_id}"
-
-                if message.chat.type == chat.SUPERGROUP and message.chat.username:
-                    result += (
-                        f"\nLink: https://t.me/{chat.username}/{message.message_id}"
-                    )
-                log_chat = sql.get_chat_log_channel(chat.id)
-                if log_chat:
-                    await send_log(context, log_chat, chat.id, result)
-
-            return result
-
-        return log_action
-
-    def gloggable(func):
-        @wraps(func)
-        async def glog_action(
-            update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs
-        ):
-            result = await func(update, context, *args, **kwargs)
-            chat = update.effective_chat
-            message = update.effective_message
-
-            if result:
-                datetime_fmt = "%H:%M - %d-%m-%Y"
-                result += f"\nEvent stamp: {datetime.utcnow().strftime(datetime_fmt)}"
-                if chat.is_forum and chat.username:
-                    result += f"\nLink: https://t.me/{chat.username}/{message.message_thread_id}/{message.message_id}"
-                elif message.chat.type == chat.SUPERGROUP and message.chat.username:
-                    result += (
-                        f"\nLink: https://t.me/{chat.username}/{message.message_id}"
-                    )
-                log_chat = str(EVENT_LOGS)
-                if log_chat:
-                    await send_log(context, log_chat, chat.id, result)
-
-            return result
-
-        return glog_action
-
-    async def send_log(
-        context: ContextTypes.DEFAULT_TYPE,
-        log_chat_id: str,
-        orig_chat_id: str,
-        result: str,
-    ):
-        bot = context.bot
-        try:
-            await bot.send_message(
-                log_chat_id,
-                result,
-                parse_mode=ParseMode.HTML,
-                disable_web_page_preview=True,
-            )
-        except BadRequest as excp:
-            if excp.message == "Chat not found":
-                try:
-                    await bot.send_message(
-                        orig_chat_id,
-                        "This log channel has been deleted - unsetting.",
-                        message_thread_id=1,
-                    )
-                except:
-                    await bot.send_message(
-                        orig_chat_id,
-                        "This log channel has been deleted - unsetting.",
-                    )
-                sql.stop_chat_logging(orig_chat_id)
-            else:
-                LOGGER.warning(excp.message)
-                LOGGER.warning(result)
-                LOGGER.exception("Could not parse")
-
-                await bot.send_message(
-                    log_chat_id,
-                    result
-                    + "\n\nFormatting has been disabled due to an unexpected error.",
-                )
-
-    @check_admin(is_user=True)
-    async def logging(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        bot = context.bot
-        message = update.effective_message
-        chat = update.effective_chat
-
-        log_channel = sql.get_chat_log_channel(chat.id)
-        if log_channel:
-            log_channel_info = await bot.get_chat(log_channel)
-            await message.reply_text(
-                f"This group has all its logs sent to: {escape_markdown(log_channel_info.title)} (`{log_channel}`)",
-                parse_mode=ParseMode.MARKDOWN,
-            )
-
-        else:
-            await message.reply_text("No log channel has been set for this group!")
-
-    @check_admin(is_user=True)
-    async def setlog(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        bot = context.bot
-        message = update.effective_message
-        chat = update.effective_chat
-        if chat.type == ChatType.CHANNEL:
-            await bot.send_message(
-                chat.id,
-                "Now, forward the /setlog to the group you want to tie this channel to!",
-            )
-
-        elif message.forward_from_chat:
-            sql.set_chat_log_channel(chat.id, message.forward_from_chat.id)
-
-            try:
-                await bot.send_message(
-                    message.forward_from_chat.id,
-                    f"This channel has been set as the log channel for {chat.title or chat.first_name}.",
-                )
-            except Forbidden as excp:
-                if excp.message == "Forbidden: Bot is not a member of the channel chat":
-                    if chat.is_forum:
-                        await bot.send_message(
-                            chat.id,
-                            "Successfully set log channel!",
-                            message_thread_id=message.message_thread_id,
-                        )
-                    else:
-                        await bot.send_message(chat.id, "Successfully set log channel!")
-                else:
-                    LOGGER.exception("Error in setting the log channel.")
-
-            if chat.is_forum:
-                await bot.send_message(
-                    chat.id,
-                    "Successfully set log channel!",
-                    message_thread_id=message.message_thread_id,
-                )
-            else:
-                await bot.send_message(chat.id, "Successfully set log channel!")
-
-        else:
-            await message.reply_text(
-                "The steps to set a log channel are:\n"
-                " - Add bot to the desired channel (as an admin!)\n"
-                " - Send /setlog in the channel\n"
-                " - Forward the /setlog to the group\n",
-            )
-
-    @check_admin(is_user=True)
-    async def unsetlog(update: Update, context: ContextTypes.DEFAULT_TYPE):
-        bot = context.bot
-        message = update.effective_message
-        chat = update.effective_chat
-
-        log_channel = sql.stop_chat_logging(chat.id)
-        if log_channel:
-            await bot.send_message(
-                log_channel,
-                f"Channel has been unlinked from {chat.title}",
-            )
-            await message.reply_text("Log channel has been un-set.")
-
-        else:
-            await message.reply_text("No log channel is set yet!")
-
-    def __stats__():
-        return f"• {sql.num_logchannels()} log channels set."
-
-    def __migrate__(old_chat_id, new_chat_id):
-        sql.migrate_chat(old_chat_id, new_chat_id)
-
-    async def __chat_settings__(chat_id, user_id):
-        log_channel = sql.get_chat_log_channel(chat_id)
-        if log_channel:
-            log_channel_info = await dispatcher.bot.get_chat(log_channel)
-            return f"This group has all its logs sent to: {escape_markdown(log_channel_info.title)} (`{log_channel}`)"
-        return "No log channel is set for this group!"
-
-    # <=================================================== HELP ====================================================>
-
-    __help__ = """
-➠ *Admins Only*:
-
-» /logchannel: Get log channel info.
-
-» /setlog: Set the log channel.
-
-» /unsetlog: Unset the log channel.
-
-➠ *Setting the log channel is done by:*
-➠ *Adding the bot to the desired channel (as an admin!)*
-
-» Sending /setlog in the channel
-» Forwarding the /setlog to the group
-"""
-
-    __mod_name__ = "LOG-SET"
-
-    # <================================================ HANDLER =======================================================>
-    function(CommandHandler("logchannel", logging, block=False))
-    function(CommandHandler("setlog", setlog, block=False))
-    function(CommandHandler("unsetlog", unsetlog, block=False))
-
-else:
-    # run anyway if module not loaded
-    def loggable(func):
-        return func
-
-    def gloggable(func):
-        return func
-
-
-# <================================================ END =======================================================>

Mikobot/plugins/mute.py

@@ -1,261 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import html
-from typing import Union
-
-from telegram import Bot, Chat, ChatMember, ChatPermissions, Update
-from telegram.constants import ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CommandHandler, ContextTypes
-from telegram.helpers import mention_html
-
-from Mikobot import LOGGER, function
-from Mikobot.plugins.helper_funcs.chat_status import (
-    check_admin,
-    connection_status,
-    is_user_admin,
-)
-from Mikobot.plugins.helper_funcs.extraction import extract_user, extract_user_and_text
-from Mikobot.plugins.helper_funcs.string_handling import extract_time
-from Mikobot.plugins.log_channel import loggable
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def check_user(user_id: int, bot: Bot, chat: Chat) -> Union[str, None]:
-    if not user_id:
-        reply = "You don't seem to be referring to a user or the ID specified is incorrect.."
-        return reply
-
-    try:
-        member = await chat.get_member(user_id)
-    except BadRequest as excp:
-        if excp.message == "User not found":
-            reply = "I can't seem to find this user"
-            return reply
-        else:
-            raise
-
-    if user_id == bot.id:
-        reply = "I'm not gonna MUTE myself, How high are you?"
-        return reply
-
-    if await is_user_admin(chat, user_id, member):
-        reply = "Sorry can't do that, this user is admin here."
-        return reply
-
-    return None
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_restrict_members", is_both=True)
-async def mute(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
-    bot = context.bot
-    args = context.args
-
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-
-    user_id, reason = await extract_user_and_text(message, context, args)
-    reply = await check_user(user_id, bot, chat)
-
-    if reply:
-        await message.reply_text(reply)
-        return ""
-
-    member = await chat.get_member(user_id)
-
-    log = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        f"#MUTE\n"
-        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
-        f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}"
-    )
-
-    if reason:
-        log += f"\n<b>Reason:</b> {reason}"
-
-    if member.status in [ChatMember.RESTRICTED, ChatMember.MEMBER]:
-        chat_permissions = ChatPermissions(can_send_messages=False)
-        await bot.restrict_chat_member(chat.id, user_id, chat_permissions)
-        await bot.sendMessage(
-            chat.id,
-            f"Muted <b>{html.escape(member.user.first_name)}</b> with no expiration date!",
-            parse_mode=ParseMode.HTML,
-            message_thread_id=message.message_thread_id if chat.is_forum else None,
-        )
-        return log
-
-    else:
-        await message.reply_text("This user is already muted!")
-
-    return ""
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_restrict_members", is_both=True)
-async def unmute(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-
-    user_id = await extract_user(message, context, args)
-    if not user_id:
-        await message.reply_text(
-            "You'll need to either give me a username to unmute, or reply to someone to be unmuted.",
-        )
-        return ""
-
-    member = await chat.get_member(int(user_id))
-
-    if member.status not in [ChatMember.LEFT, ChatMember.BANNED]:
-        if member.status != ChatMember.RESTRICTED:
-            await message.reply_text("This user already has the right to speak.")
-        else:
-            chat_permissions = ChatPermissions(
-                can_send_messages=True,
-                can_invite_users=True,
-                can_pin_messages=True,
-                can_send_polls=True,
-                can_change_info=True,
-                can_send_media_messages=True,
-                can_send_other_messages=True,
-                can_add_web_page_previews=True,
-            )
-            try:
-                await bot.restrict_chat_member(chat.id, int(user_id), chat_permissions)
-            except BadRequest:
-                pass
-            await bot.sendMessage(
-                chat.id,
-                f"I shall allow <b>{html.escape(member.user.first_name)}</b> to text!",
-                parse_mode=ParseMode.HTML,
-                message_thread_id=message.message_thread_id if chat.is_forum else None,
-            )
-            return (
-                f"<b>{html.escape(chat.title)}:</b>\n"
-                f"#UNMUTE\n"
-                f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
-                f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}"
-            )
-    else:
-        await message.reply_text(
-            "This user isn't even in the chat, unmuting them won't make them talk more than they "
-            "already do!",
-        )
-
-    return ""
-
-
-@connection_status
-@loggable
-@check_admin(permission="can_restrict_members", is_both=True)
-async def temp_mute(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
-    bot, args = context.bot, context.args
-    chat = update.effective_chat
-    user = update.effective_user
-    message = update.effective_message
-
-    user_id, reason = await extract_user_and_text(message, context, args)
-    reply = await check_user(user_id, bot, chat)
-
-    if reply:
-        await message.reply_text(reply)
-        return ""
-
-    member = await chat.get_member(user_id)
-
-    if not reason:
-        await message.reply_text("You haven't specified a time to mute this user for!")
-        return ""
-
-    split_reason = reason.split(None, 1)
-
-    time_val = split_reason[0].lower()
-    if len(split_reason) > 1:
-        reason = split_reason[1]
-    else:
-        reason = ""
-
-    mutetime = await extract_time(message, time_val)
-
-    if not mutetime:
-        return ""
-
-    log = (
-        f"<b>{html.escape(chat.title)}:</b>\n"
-        f"#TEMP MUTED\n"
-        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
-        f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}\n"
-        f"<b>Time:</b> {time_val}"
-    )
-    if reason:
-        log += f"\n<b>Reason:</b> {reason}"
-
-    try:
-        if member.status in [ChatMember.RESTRICTED, ChatMember.MEMBER]:
-            chat_permissions = ChatPermissions(can_send_messages=False)
-            await bot.restrict_chat_member(
-                chat.id,
-                user_id,
-                chat_permissions,
-                until_date=mutetime,
-            )
-            await bot.sendMessage(
-                chat.id,
-                f"Muted <b>{html.escape(member.user.first_name)}</b> for {time_val}!",
-                parse_mode=ParseMode.HTML,
-                message_thread_id=message.message_thread_id if chat.is_forum else None,
-            )
-            return log
-        else:
-            await message.reply_text("This user is already muted.")
-
-    except BadRequest as excp:
-        if excp.message == "Reply message not found":
-            # Do not reply
-            await message.reply_text(f"Muted for {time_val}!", quote=False)
-            return log
-        else:
-            LOGGER.warning(update)
-            LOGGER.exception(
-                "ERROR muting user %s in chat %s (%s) due to %s",
-                user_id,
-                chat.title,
-                chat.id,
-                excp.message,
-            )
-            await message.reply_text("Well damn, I can't mute that user.")
-
-    return ""
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-➠ *Admins only:*
-
-» /mute <userhandle>: silences a user. Can also be used as a reply, muting the replied to user.
-
-» /tmute <userhandle> x(m/h/d): mutes a user for x time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
-
-» /unmute <userhandle>: unmutes a user. Can also be used as a reply, muting the replied to user.
-"""
-
-# <================================================ HANDLER =======================================================>
-MUTE_HANDLER = CommandHandler("mute", mute, block=False)
-UNMUTE_HANDLER = CommandHandler("unmute", unmute, block=False)
-TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"], temp_mute, block=False)
-
-function(MUTE_HANDLER)
-function(UNMUTE_HANDLER)
-function(TEMPMUTE_HANDLER)
-
-__mod_name__ = "MUTE"
-__handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
-# <================================================ END =======================================================>

Mikobot/plugins/nekomode.py

@@ -1,131 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# PROVIDED BY https://t.me/ProjectCodeX
-# NEKOS
-
-# <============================================== IMPORTS =========================================================>
-import nekos
-from telethon import events
-
-from Database.mongodb.toggle_mongo import is_nekomode_on, nekomode_off, nekomode_on
-from Mikobot import tbot
-from Mikobot.state import state  # Import the state function
-
-# <=======================================================================================================>
-
-url_sfw = "https://api.waifu.pics/sfw/"
-
-allowed_commands = [
-    "waifu",
-    "neko",
-    "shinobu",
-    "megumin",
-    "bully",
-    "cuddle",
-    "cry",
-    "hug",
-    "awoo",
-    "kiss",
-    "lick",
-    "pat",
-    "smug",
-    "bonk",
-    "yeet",
-    "blush",
-    "smile",
-    "spank",
-    "wave",
-    "highfive",
-    "handhold",
-    "nom",
-    "bite",
-    "glomp",
-    "slap",
-    "hTojiy",
-    "wink",
-    "poke",
-    "dance",
-    "cringe",
-    "tickle",
-]
-
-
-# <================================================ FUNCTION =======================================================>
-@tbot.on(events.NewMessage(pattern="/wallpaper"))
-async def wallpaper(event):
-    chat_id = event.chat_id
-    nekomode_status = await is_nekomode_on(chat_id)
-    if nekomode_status:
-        target = "wallpaper"
-        img_url = nekos.img(
-            target
-        )  # Replace nekos.img(target) with the correct function call
-        await event.reply(file=img_url)
-
-
-@tbot.on(events.NewMessage(pattern="/nekomode on"))
-async def enable_nekomode(event):
-    chat_id = event.chat_id
-    await nekomode_on(chat_id)
-    await event.reply("Nekomode has been enabled.")
-
-
-@tbot.on(events.NewMessage(pattern="/nekomode off"))
-async def disable_nekomode(event):
-    chat_id = event.chat_id
-    await nekomode_off(chat_id)
-    await event.reply("Nekomode has been disabled.")
-
-
-@tbot.on(events.NewMessage(pattern=r"/(?:{})".format("|".join(allowed_commands))))
-async def nekomode_commands(event):
-    chat_id = event.chat_id
-    nekomode_status = await is_nekomode_on(chat_id)
-    if nekomode_status:
-        target = event.raw_text[1:].lower()  # Remove the slash before the command
-        if target in allowed_commands:
-            url = f"{url_sfw}{target}"
-
-            response = await state.get(url)
-            result = response.json()
-            animation_url = result["url"]
-
-            # Send animation
-            await event.respond(file=animation_url)
-
-
-__help__ = """
-*✨ Sends fun Gifs/Images*
-
-➥ /nekomode on : Enables fun neko mode.
-➥ /nekomode off : Disables fun neko mode
-
-» /bully: sends random bully gifs.
-» /neko: sends random neko gifs.
-» /wallpaper: sends random wallpapers.
-» /highfive: sends random highfive gifs.
-» /tickle: sends random tickle GIFs.
-» /wave: sends random wave GIFs.
-» /smile: sends random smile GIFs.
-» /feed: sends random feeding GIFs.
-» /blush: sends random blush GIFs.
-» /avatar: sends random avatar stickers.
-» /waifu: sends random waifu stickers.
-» /kiss: sends random kissing GIFs.
-» /cuddle: sends random cuddle GIFs.
-» /cry: sends random cry GIFs.
-» /bonk: sends random cuddle GIFs.
-» /smug: sends random smug GIFs.
-» /slap: sends random slap GIFs.
-» /hug: get hugged or hug a user.
-» /pat: pats a user or get patted.
-» /spank: sends a random spank gif.
-» /dance: sends a random dance gif.
-» /poke: sends a random poke gif.
-» /wink: sends a random wink gif.
-» /bite: sends random bite GIFs.
-» /handhold: sends random handhold GIFs.
-"""
-
-__mod_name__ = "NEKO"
-# <================================================ END =======================================================>

Mikobot/plugins/notes.py

@@ -1,629 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import ast
-import random
-import re
-from io import BytesIO
-
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Message, Update
-from telegram.constants import MessageLimit, ParseMode
-from telegram.error import BadRequest
-from telegram.ext import (
-    CallbackQueryHandler,
-    CommandHandler,
-    ContextTypes,
-    MessageHandler,
-    filters,
-)
-from telegram.helpers import escape_markdown, mention_markdown
-
-import Database.sql.notes_sql as sql
-from Mikobot import DRAGONS, LOGGER, MESSAGE_DUMP, SUPPORT_CHAT, dispatcher, function
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.chat_status import check_admin, connection_status
-from Mikobot.plugins.helper_funcs.misc import build_keyboard, revert_buttons
-from Mikobot.plugins.helper_funcs.msg_types import get_note_type
-from Mikobot.plugins.helper_funcs.string_handling import (
-    escape_invalid_curly_brackets,
-    markdown_to_html,
-)
-
-from .cust_filters import MessageHandlerChecker
-
-# <=======================================================================================================>
-
-FILE_MATCHER = re.compile(r"^###file_id(!photo)?###:(.*?)(?:\s|$)")
-STICKER_MATCHER = re.compile(r"^###sticker(!photo)?###:")
-BUTTON_MATCHER = re.compile(r"^###button(!photo)?###:(.*?)(?:\s|$)")
-MYFILE_MATCHER = re.compile(r"^###file(!photo)?###:")
-MYPHOTO_MATCHER = re.compile(r"^###photo(!photo)?###:")
-MYAUDIO_MATCHER = re.compile(r"^###audio(!photo)?###:")
-MYVOICE_MATCHER = re.compile(r"^###voice(!photo)?###:")
-MYVIDEO_MATCHER = re.compile(r"^###video(!photo)?###:")
-MYVIDEONOTE_MATCHER = re.compile(r"^###video_note(!photo)?###:")
-
-ENUM_FUNC_MAP = {
-    sql.Types.TEXT.value: dispatcher.bot.send_message,
-    sql.Types.BUTTON_TEXT.value: dispatcher.bot.send_message,
-    sql.Types.STICKER.value: dispatcher.bot.send_sticker,
-    sql.Types.DOCUMENT.value: dispatcher.bot.send_document,
-    sql.Types.PHOTO.value: dispatcher.bot.send_photo,
-    sql.Types.AUDIO.value: dispatcher.bot.send_audio,
-    sql.Types.VOICE.value: dispatcher.bot.send_voice,
-    sql.Types.VIDEO.value: dispatcher.bot.send_video,
-}
-
-
-# <================================================ FUNCTION =======================================================>
-async def get(
-    update: Update,
-    context: ContextTypes.DEFAULT_TYPE,
-    notename,
-    show_none=True,
-    no_format=False,
-):
-    bot = context.bot
-    chat_id = update.effective_message.chat.id
-    chat = update.effective_chat
-    note_chat_id = update.effective_chat.id
-    note = sql.get_note(note_chat_id, notename)
-    message = update.effective_message  # type: Optional[Message]
-
-    if note:
-        if MessageHandlerChecker.check_user(update.effective_user.id):
-            return
-        # If we're replying to a message, reply to that message (unless it's an error)
-        if (
-            message.reply_to_message
-            and not message.reply_to_message.forum_topic_created
-        ):
-            reply_id = message.reply_to_message.message_id
-        else:
-            reply_id = message.message_id
-        if note.is_reply:
-            if MESSAGE_DUMP:
-                try:
-                    await bot.forward_message(
-                        chat_id=chat_id,
-                        from_chat_id=MESSAGE_DUMP,
-                        message_id=note.value,
-                    )
-                except BadRequest as excp:
-                    if excp.message == "Message to forward not found":
-                        await message.reply_text(
-                            "This message seems to have been lost - I'll remove it "
-                            "from your notes list.",
-                        )
-                        sql.rm_note(note_chat_id, notename)
-                    else:
-                        raise
-            else:
-                try:
-                    await bot.forward_message(
-                        chat_id=chat_id,
-                        from_chat_id=chat_id,
-                        message_id=markdown_to_html(note.value),
-                    )
-                except BadRequest as excp:
-                    if excp.message == "Message to forward not found":
-                        await message.reply_text(
-                            "Looks like the original sender of this note has deleted "
-                            "their message - sorry! Get your bot admin to start using a "
-                            "message dump to avoid this. I'll remove this note from "
-                            "your saved notes.",
-                        )
-                        sql.rm_note(note_chat_id, notename)
-                    else:
-                        raise
-        else:
-            VALID_NOTE_FORMATTERS = [
-                "first",
-                "last",
-                "fullname",
-                "username",
-                "id",
-                "chatname",
-                "mention",
-            ]
-            valid_format = escape_invalid_curly_brackets(
-                note.value,
-                VALID_NOTE_FORMATTERS,
-            )
-            if valid_format:
-                if not no_format:
-                    if "%%%" in valid_format:
-                        split = valid_format.split("%%%")
-                        if all(split):
-                            text = random.choice(split)
-                        else:
-                            text = valid_format
-                    else:
-                        text = valid_format
-                else:
-                    text = valid_format
-                text = text.format(
-                    first=escape_markdown(message.from_user.first_name),
-                    last=escape_markdown(
-                        message.from_user.last_name or message.from_user.first_name,
-                    ),
-                    fullname=escape_markdown(
-                        " ".join(
-                            [message.from_user.first_name, message.from_user.last_name]
-                            if message.from_user.last_name
-                            else [message.from_user.first_name],
-                        ),
-                    ),
-                    username="@" + message.from_user.username
-                    if message.from_user.username
-                    else mention_markdown(
-                        message.from_user.id,
-                        message.from_user.first_name,
-                    ),
-                    mention=mention_markdown(
-                        message.from_user.id,
-                        message.from_user.first_name,
-                    ),
-                    chatname=escape_markdown(
-                        message.chat.title
-                        if message.chat.type != "private"
-                        else message.from_user.first_name,
-                    ),
-                    id=message.from_user.id,
-                )
-            else:
-                text = ""
-
-            keyb = []
-            parseMode = ParseMode.HTML
-            buttons = sql.get_buttons(note_chat_id, notename)
-            if no_format:
-                parseMode = None
-                text += revert_buttons(buttons)
-            else:
-                keyb = build_keyboard(buttons)
-
-            keyboard = InlineKeyboardMarkup(keyb)
-
-            try:
-                if note.msgtype in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
-                    await bot.send_message(
-                        chat_id,
-                        markdown_to_html(text),
-                        reply_to_message_id=reply_id,
-                        parse_mode=parseMode,
-                        disable_web_page_preview=True,
-                        reply_markup=keyboard,
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-                else:
-                    await ENUM_FUNC_MAP[note.msgtype](
-                        chat_id,
-                        note.file,
-                        caption=markdown_to_html(text),
-                        reply_to_message_id=reply_id,
-                        parse_mode=parseMode,
-                        disable_web_page_preview=True,
-                        reply_markup=keyboard,
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
-                    )
-
-            except BadRequest as excp:
-                if excp.message == "Entity_mention_user_invalid":
-                    await message.reply_text(
-                        "Looks like you tried to mention someone I've never seen before. If you really "
-                        "want to mention them, forward one of their messages to me, and I'll be able "
-                        "to tag them!",
-                    )
-                elif FILE_MATCHER.match(note.value):
-                    await message.reply_text(
-                        "This note was an incorrectly imported file from another bot - I can't use "
-                        "it. If you really need it, you'll have to save it again. In "
-                        "the meantime, I'll remove it from your notes list.",
-                    )
-                    sql.rm_note(note_chat_id, notename)
-                else:
-                    await message.reply_text(
-                        "This note could not be sent, as it is incorrectly formatted. Ask in "
-                        f"@{SUPPORT_CHAT} if you can't figure out why!",
-                    )
-                    LOGGER.exception(
-                        "Could not parse message #%s in chat %s",
-                        notename,
-                        str(note_chat_id),
-                    )
-                    LOGGER.warning("Message was: %s", str(note.value))
-        return
-    elif show_none:
-        await message.reply_text("This note doesn't exist")
-
-
-@connection_status
-async def cmd_get(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    bot, args = context.bot, context.args
-    if len(args) >= 2 and args[1].lower() == "noformat":
-        await get(update, context, args[0].lower(), show_none=True, no_format=True)
-    elif len(args) >= 1:
-        await get(update, context, args[0].lower(), show_none=True)
-    else:
-        await update.effective_message.reply_text("Get rekt")
-
-
-@connection_status
-async def hash_get(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    message = update.effective_message.text
-    fst_word = message.split()[0]
-    no_hash = fst_word[1:].lower()
-    await get(update, context, no_hash, show_none=False)
-
-
-@connection_status
-async def slash_get(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    message, chat_id = update.effective_message.text, update.effective_chat.id
-    no_slash = message[1:]
-    note_list = sql.get_all_chat_notes(chat_id)
-
-    try:
-        noteid = note_list[int(no_slash) - 1]
-        note_name = str(noteid).strip(">").split()[1]
-        await get(update, context, note_name, show_none=False)
-    except IndexError:
-        await update.effective_message.reply_text("Wrong Note ID 😾")
-
-
-@connection_status
-@check_admin(is_user=True)
-async def save(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat_id = update.effective_chat.id
-    msg = update.effective_message  # type: Optional[Message]
-    if len(context.args) < 1:
-        await msg.reply_text("You should give the note a name.")
-        return
-
-    note_name, text, data_type, content, buttons = get_note_type(msg)
-    note_name = note_name.lower()
-    if data_type is None:
-        await msg.reply_text("Dude, there's no note content")
-        return
-
-    sql.add_note_to_db(
-        chat_id,
-        note_name,
-        text,
-        data_type,
-        buttons=buttons,
-        file=content,
-    )
-
-    await msg.reply_text(
-        f"Yas! Added `{note_name}`.\nGet it with /get `{note_name}`, or `#{note_name}`",
-        parse_mode=ParseMode.MARKDOWN,
-    )
-
-    if (
-        msg.reply_to_message
-        and msg.reply_to_message.from_user.is_bot
-        and not msg.reply_to_message.forum_topic_created
-    ):
-        if text:
-            await msg.reply_text(
-                "Seems like you're trying to save a message from a bot. Unfortunately, "
-                "bots can't forward bot messages, so I can't save the exact message. "
-                "\nI'll save all the text I can, but if you want more, you'll have to "
-                "forward the message yourself, and then save it.",
-            )
-        else:
-            await msg.reply_text(
-                "Bots are kinda handicapped by telegram, making it hard for bots to "
-                "interact with other bots, so I can't save this message "
-                "like I usually would - do you mind forwarding it and "
-                "then saving that new message? Thanks!",
-            )
-        return
-
-
-@connection_status
-@check_admin(is_user=True)
-async def clear(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    args = context.args
-    chat_id = update.effective_chat.id
-    if len(args) >= 1:
-        notename = args[0].lower()
-
-        if sql.rm_note(chat_id, notename):
-            await update.effective_message.reply_text("Successfully removed note.")
-        else:
-            await update.effective_message.reply_text(
-                "That's not a note in my database!"
-            )
-
-
-async def clearall(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat = update.effective_chat
-    user = update.effective_user
-    member = await chat.get_member(user.id)
-    if member.status != "creator" and user.id not in DRAGONS:
-        await update.effective_message.reply_text(
-            "Only the chat owner can clear all notes at once.",
-        )
-    else:
-        buttons = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        text="Delete all notes",
-                        callback_data="notes_rmall",
-                    ),
-                ],
-                [InlineKeyboardButton(text="Cancel", callback_data="notes_cancel")],
-            ],
-        )
-        await update.effective_message.reply_text(
-            f"Are you sure you would like to clear ALL notes in {chat.title}? This action cannot be undone.",
-            reply_markup=buttons,
-            parse_mode=ParseMode.MARKDOWN,
-        )
-
-
-async def clearall_btn(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    chat = update.effective_chat
-    message = update.effective_message
-    member = await chat.get_member(query.from_user.id)
-    if query.data == "notes_rmall":
-        if member.status == "creator" or query.from_user.id in DRAGONS:
-            note_list = sql.get_all_chat_notes(chat.id)
-            try:
-                for notename in note_list:
-                    note = notename.name.lower()
-                    sql.rm_note(chat.id, note)
-                await message.edit_text("Deleted all notes.")
-            except BadRequest:
-                return
-
-        if member.status == "administrator":
-            await query.answer("Only owner of the chat can do this.")
-
-        if member.status == "member":
-            await query.answer("You need to be admin to do this.")
-    elif query.data == "notes_cancel":
-        if member.status == "creator" or query.from_user.id in DRAGONS:
-            await message.edit_text("Clearing of all notes has been cancelled.")
-            return
-        if member.status == "administrator":
-            await query.answer("Only owner of the chat can do this.")
-        if member.status == "member":
-            await query.answer("You need to be admin to do this.")
-
-
-@connection_status
-async def list_notes(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat_id = update.effective_chat.id
-    note_list = sql.get_all_chat_notes(chat_id)
-    notes = len(note_list) + 1
-    msg = "Get note by `/notenumber` or `#notename` \n\n  *ID*    *Note* \n"
-    for note_id, note in zip(range(1, notes), note_list):
-        if note_id < 10:
-            note_name = f"`{note_id:2}.`  `#{(note.name.lower())}`\n"
-        else:
-            note_name = f"`{note_id}.`  `#{(note.name.lower())}`\n"
-        if len(msg) + len(note_name) > MessageLimit.MAX_TEXT_LENGTH:
-            await update.effective_message.reply_text(
-                msg, parse_mode=ParseMode.MARKDOWN
-            )
-            msg = ""
-        msg += note_name
-
-    if not note_list:
-        try:
-            await update.effective_message.reply_text("No notes in this chat!")
-        except BadRequest:
-            await update.effective_message.reply_text(
-                "No notes in this chat!", quote=False
-            )
-
-    elif len(msg) != 0:
-        await update.effective_message.reply_text(msg, parse_mode=ParseMode.MARKDOWN)
-
-
-async def __import_data__(chat_id, data, message: Message):
-    failures = []
-    for notename, notedata in data.get("extra", {}).items():
-        match = FILE_MATCHER.match(notedata)
-        matchsticker = STICKER_MATCHER.match(notedata)
-        matchbtn = BUTTON_MATCHER.match(notedata)
-        matchfile = MYFILE_MATCHER.match(notedata)
-        matchphoto = MYPHOTO_MATCHER.match(notedata)
-        matchaudio = MYAUDIO_MATCHER.match(notedata)
-        matchvoice = MYVOICE_MATCHER.match(notedata)
-        matchvideo = MYVIDEO_MATCHER.match(notedata)
-        matchvn = MYVIDEONOTE_MATCHER.match(notedata)
-
-        if match:
-            failures.append(notename)
-            notedata = notedata[match.end() :].strip()
-            if notedata:
-                sql.add_note_to_db(chat_id, notename[1:], notedata, sql.Types.TEXT)
-        elif matchsticker:
-            content = notedata[matchsticker.end() :].strip()
-            if content:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.STICKER,
-                    file=content,
-                )
-        elif matchbtn:
-            parse = notedata[matchbtn.end() :].strip()
-            notedata = parse.split("<###button###>")[0]
-            buttons = parse.split("<###button###>")[1]
-            buttons = ast.literal_eval(buttons)
-            if buttons:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.BUTTON_TEXT,
-                    buttons=buttons,
-                )
-        elif matchfile:
-            file = notedata[matchfile.end() :].strip()
-            file = file.split("<###TYPESPLIT###>")
-            notedata = file[1]
-            content = file[0]
-            if content:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.DOCUMENT,
-                    file=content,
-                )
-        elif matchphoto:
-            photo = notedata[matchphoto.end() :].strip()
-            photo = photo.split("<###TYPESPLIT###>")
-            notedata = photo[1]
-            content = photo[0]
-            if content:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.PHOTO,
-                    file=content,
-                )
-        elif matchaudio:
-            audio = notedata[matchaudio.end() :].strip()
-            audio = audio.split("<###TYPESPLIT###>")
-            notedata = audio[1]
-            content = audio[0]
-            if content:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.AUDIO,
-                    file=content,
-                )
-        elif matchvoice:
-            voice = notedata[matchvoice.end() :].strip()
-            voice = voice.split("<###TYPESPLIT###>")
-            notedata = voice[1]
-            content = voice[0]
-            if content:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.VOICE,
-                    file=content,
-                )
-        elif matchvideo:
-            video = notedata[matchvideo.end() :].strip()
-            video = video.split("<###TYPESPLIT###>")
-            notedata = video[1]
-            content = video[0]
-            if content:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.VIDEO,
-                    file=content,
-                )
-        elif matchvn:
-            video_note = notedata[matchvn.end() :].strip()
-            video_note = video_note.split("<###TYPESPLIT###>")
-            notedata = video_note[1]
-            content = video_note[0]
-            if content:
-                sql.add_note_to_db(
-                    chat_id,
-                    notename[1:],
-                    notedata,
-                    sql.Types.VIDEO_NOTE,
-                    file=content,
-                )
-        else:
-            sql.add_note_to_db(chat_id, notename[1:], notedata, sql.Types.TEXT)
-
-    if failures:
-        with BytesIO(str.encode("\n".join(failures))) as output:
-            output.name = "failed_imports.txt"
-            await dispatcher.bot.send_document(
-                chat_id,
-                document=output,
-                filename="failed_imports.txt",
-                caption="These files/photos failed to import due to originating "
-                "from another bot. This is a telegram API restriction, and can't "
-                "be avoided. Sorry for the inconvenience!",
-                message_thread_id=message.message_thread_id
-                if message.chat.is_forum
-                else None,
-            )
-
-
-def __stats__():
-    return f"• {sql.num_notes()} notes, across {sql.num_chats()} chats."
-
-
-def __migrate__(old_chat_id, new_chat_id):
-    sql.migrate_chat(old_chat_id, new_chat_id)
-
-
-def __chat_settings__(chat_id, user_id):
-    notes = sql.get_all_chat_notes(chat_id)
-    return f"There are `{len(notes)}` notes in this chat."
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
- » /get <notename> : get the note with this notename
- » #<notename> : same as /get
- » /notes or /saved : list all saved notes in this chat
- » /number : Will pull the note of that number in the list
- ➠ If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \
-be useful when updating a current note
-
-*Admins only:*
- » /save <notename> <notedata> : saves notedata as a note with name notename
- ➠ A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \
-`buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check `/markdownhelp` for more info
- » /save <notename> : save the replied message as a note with name notename
- Separate diff replies by `%%%` to get random notes
- ➠ *Example:*
- `/save notename
- Reply 1
- %%%
- Reply 2
- %%%
- Reply 3`
- » /clear <notename>: clear note with this name
- » /removeallnotes: removes all notes from the group
- ➠ *Note:* Note names are case-insensitive, and they are automatically converted to lowercase before getting saved.
-
-"""
-
-__mod_name__ = "NOTES"
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("get", cmd_get))
-function(MessageHandler(filters.Regex(r"^#[^\s]+"), hash_get, block=False))
-function(MessageHandler(filters.Regex(r"^/\d+$"), slash_get, block=False))
-function(CommandHandler("save", save, block=False))
-function(CommandHandler("clear", clear, block=False))
-
-function(
-    DisableAbleCommandHandler(
-        ["notes", "saved"], list_notes, admin_ok=True, block=False
-    )
-)
-
-function(DisableAbleCommandHandler("removeallnotes", clearall, block=False))
-function(CallbackQueryHandler(clearall_btn, pattern=r"notes_.*", block=False))
-# <================================================ END =======================================================>

Mikobot/plugins/ping.py

@@ -1,39 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import time
-
-from telegram import Update
-from telegram.constants import ParseMode
-from telegram.ext import CommandHandler, ContextTypes
-
-from Mikobot import StartTime, function
-from Mikobot.__main__ import get_readable_time
-from Mikobot.plugins.helper_funcs.chat_status import check_admin
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-@check_admin(only_dev=True)
-async def ptb_ping(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.effective_message
-
-    start_time = time.time()
-    message = await msg.reply_text("Pining")
-    end_time = time.time()
-    telegram_ping = str(round((end_time - start_time) * 1000, 3)) + " ms"
-    uptime = get_readable_time((time.time() - StartTime))
-
-    await message.edit_text(
-        "🏓 <b>PONG</b>\n\n"
-        "<b>Time taken:</b> <code>{}</code>\n"
-        "<b>Uptime:</b> <code>{}</code>".format(telegram_ping, uptime),
-        parse_mode=ParseMode.HTML,
-    )
-
-
-# <=======================================================================================================>
-
-
-# <================================================ HANDLER =======================================================>
-function(CommandHandler("ping", ptb_ping, block=False))
-# <================================================ END =======================================================>

Mikobot/plugins/pokedex.py

@@ -1,143 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# API BY https://www.github.com/SOME-1HING
-# PROVIDED BY https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.ext import ContextTypes, CallbackQueryHandler, CommandHandler
-
-from Mikobot import function
-from Mikobot.state import state
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTIONS =====================================================>
-async def get_pokemon_info(name_or_id):
-    try:
-        response = await state.get(
-            f"https://sugoi-api.vercel.app/pokemon?name={name_or_id}"
-        )
-        if response.status_code == 200:
-            return response.json()
-
-        response = await state.get(
-            f"https://sugoi-api.vercel.app/pokemon?id={name_or_id}"
-        )
-        if response.status_code == 200:
-            return response.json()
-
-    except Exception as e:
-        print(f"An error occurred: {str(e)}")
-
-    return None
-
-
-async def pokedex(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    try:
-        if context.args:
-            name_or_id = context.args[0]
-            pokemon_info = await get_pokemon_info(name_or_id)
-
-            if pokemon_info:
-                reply_message = (
-                    f"🐾 𝗡𝗔𝗠𝗘: {pokemon_info['name']}\n"
-                    f"•➥ 𝗜𝗗: {pokemon_info['id']}\n"
-                    f"•➥ 𝗛𝗘𝗜𝗚𝗛𝗧: {pokemon_info['height']}\n"
-                    f"•➥ 𝗪𝗘𝗜𝗚𝗛𝗧: {pokemon_info['weight']}\n"
-                )
-
-                abilities = ", ".join(
-                    ability["ability"]["name"] for ability in pokemon_info["abilities"]
-                )
-                reply_message += f"•➥ 𝗔𝗕𝗜𝗟𝗜𝗧𝗜𝗘𝗦: {abilities}\n"
-
-                types = ", ".join(
-                    type_info["type"]["name"] for type_info in pokemon_info["types"]
-                )
-                reply_message += f"•➥ 𝗧𝗬𝗣𝗘𝗦: {types}\n"
-
-                image_url = f"https://img.pokemondb.net/artwork/large/{pokemon_info['name']}.jpg"
-
-                # Create inline buttons
-                keyboard = [
-                    [
-                        InlineKeyboardButton(text="🔖 STATS", callback_data="stats"),
-                        InlineKeyboardButton(text="⚜️ MOVES", callback_data="moves"),
-                    ]
-                ]
-
-                reply_markup = InlineKeyboardMarkup(keyboard)
-
-                await update.message.reply_photo(
-                    photo=image_url,
-                    caption=reply_message,
-                    reply_markup=reply_markup,
-                )
-            else:
-                await update.message.reply_text("Pokemon not found.")
-        else:
-            await update.message.reply_text("Please provide a Pokemon name or ID.")
-    except Exception as e:
-        await update.message.reply_text(f"An error occurred: {str(e)}")
-
-
-async def callback_query_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    await query.answer()
-
-    try:
-        name = query.message.caption.split("\n")[0].split(": ")[1]
-        pokemon_info = await get_pokemon_info(name)
-
-        if pokemon_info:
-            stats = "\n".join(
-                f"{stat['stat']['name'].upper()}: {stat['base_stat']}"
-                for stat in pokemon_info["stats"]
-            )
-            stats_message = f"•➥ STATS:\n{stats}\n"
-
-            moves = ", ".join(
-                move_info["move"]["name"] for move_info in pokemon_info["moves"]
-            )
-            moves_message = f"•➥ MOVES: {moves}"
-
-            if query.data == "stats":
-                await query.message.reply_text(stats_message)
-            elif query.data == "moves":
-                if len(moves_message) > 1000:
-                    with open("moves.txt", "w") as file:
-                        file.write(moves_message)
-                    await query.message.reply_text(
-                        "The moves exceed 1000 characters. Sending as a file.",
-                        disable_web_page_preview=True,
-                    )
-                    await query.message.reply_document(document=open("moves.txt", "rb"))
-                else:
-                    await query.message.reply_text(moves_message)
-        else:
-            await query.message.reply_text("Pokemon not found.")
-    except Exception as e:
-        await query.message.reply_text(f"An error occurred: {str(e)}")
-
-
-# <================================================ HANDLER =======================================================>
-# Add the command and callback query handlers to the dispatcher
-function(CommandHandler("pokedex", pokedex, block=False))
-function(
-    CallbackQueryHandler(callback_query_handler, pattern="^(stats|moves)$", block=False)
-)
-
-# <================================================ HANDLER =======================================================>
-__help__ = """
-
-🍥 *POKEMON SEARCH*
-
-➠ *Commands*:
-
-»  /pokedex < Search > : Gives that pokemon info.
-"""
-
-__mod_name__ = "POKEDEX"
-# <================================================ END =======================================================>

Mikobot/plugins/purge.py

@@ -1,135 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from asyncio import sleep
-
-from pyrogram import filters
-from pyrogram.enums import ChatType
-from pyrogram.errors import MessageDeleteForbidden, RPCError
-from pyrogram.types import Message
-
-from Mikobot import SUPPORT_CHAT, app
-from Mikobot.utils.can_restrict import can_restrict
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-@app.on_message(filters.command("purge"))
-@can_restrict
-async def purge(c: app, m: Message):
-    if m.chat.type != ChatType.SUPERGROUP:
-        await m.reply_text(text="Cannot purge messages in a basic group")
-        return
-
-    if m.reply_to_message:
-        message_ids = list(range(m.reply_to_message.id, m.id))
-
-        def divide_chunks(l: list, n: int = 100):
-            for i in range(0, len(l), n):
-                yield l[i : i + n]
-
-        # Dielete messages in chunks of 100 messages
-        m_list = list(divide_chunks(message_ids))
-
-        try:
-            for plist in m_list:
-                await c.delete_messages(
-                    chat_id=m.chat.id,
-                    message_ids=plist,
-                    revoke=True,
-                )
-            await m.delete()
-        except MessageDeleteForbidden:
-            await m.reply_text(
-                text="Cannot delete all messages. The messages may be too old, I might not have delete rights, or this might not be a supergroup."
-            )
-            return
-        except RPCError as ef:
-            await m.reply_text(
-                text=f"""Some error occured, report to @{SUPPORT_CHAT}
-
-      <b>Error:</b> <code>{ef}</code>"""
-            )
-
-        count_del_msg = len(message_ids)
-
-        z = await m.reply_text(text=f"Deleted <i>{count_del_msg}</i> messages")
-        await sleep(3)
-        await z.delete()
-        return
-    await m.reply_text("Reply to a message to start purge !")
-    return
-
-
-@app.on_message(filters.command("spurge"))
-@can_restrict
-async def spurge(c: app, m: Message):
-    if m.chat.type != ChatType.SUPERGROUP:
-        await m.reply_text(text="Cannot purge messages in a basic group")
-        return
-
-    if m.reply_to_message:
-        message_ids = list(range(m.reply_to_message.id, m.id))
-
-        def divide_chunks(l: list, n: int = 100):
-            for i in range(0, len(l), n):
-                yield l[i : i + n]
-
-        # Dielete messages in chunks of 100 messages
-        m_list = list(divide_chunks(message_ids))
-
-        try:
-            for plist in m_list:
-                await c.delete_messages(
-                    chat_id=m.chat.id,
-                    message_ids=plist,
-                    revoke=True,
-                )
-            await m.delete()
-        except MessageDeleteForbidden:
-            await m.reply_text(
-                text="Cannot delete all messages. The messages may be too old, I might not have delete rights, or this might not be a supergroup."
-            )
-            return
-        except RPCError as ef:
-            await m.reply_text(
-                text=f"""Some error occured, report to @{SUPPORT_CHAT}
-
-      <b>Error:</b> <code>{ef}</code>"""
-            )
-        return
-    await m.reply_text("Reply to a message to start spurge !")
-    return
-
-
-@app.on_message(
-    filters.command("del"),
-    group=9,
-)
-@can_restrict
-async def del_msg(c: app, m: Message):
-    if m.chat.type != ChatType.SUPERGROUP:
-        return
-
-    if m.reply_to_message:
-        await m.delete()
-        await c.delete_messages(
-            chat_id=m.chat.id,
-            message_ids=m.reply_to_message.id,
-        )
-    else:
-        await m.reply_text(text="What do you wanna delete?")
-    return
-
-
-# <=================================================== HELP ====================================================>
-__help__ = """
-❗️*Purge*
-
-» /purge: Deletes messages upto replied message.
-
-» /spurge: Deletes messages upto replied message without a success message.
-
-» /del: Deletes a single message, used as a reply to message."""
-
-__mod_name__ = "PURGE"
-# <================================================ END =======================================================>

Mikobot/plugins/quotely.py

@@ -1,294 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import base64
-import os
-from random import choice
-
-from aiohttp import ContentTypeError
-from PIL import Image
-from telethon.tl import types
-from telethon.utils import get_display_name, get_peer_id
-
-from Mikobot import DEV_USERS
-from Mikobot.events import register
-
-# <=======================================================================================================>
-
-
-# <================================================ CLASS & FUNCTION =======================================================>
-class Quotly:
-    _API = "https://bot.lyo.su/quote/generate"
-    _entities = {
-        types.MessageEntityPhone: "phone_number",
-        types.MessageEntityMention: "mention",
-        types.MessageEntityBold: "bold",
-        types.MessageEntityCashtag: "cashtag",
-        types.MessageEntityStrike: "strikethrough",
-        types.MessageEntityHashtag: "hashtag",
-        types.MessageEntityEmail: "email",
-        types.MessageEntityMentionName: "text_mention",
-        types.MessageEntityUnderline: "underline",
-        types.MessageEntityUrl: "url",
-        types.MessageEntityTextUrl: "text_link",
-        types.MessageEntityBotCommand: "bot_command",
-        types.MessageEntityCode: "code",
-        types.MessageEntityPre: "pre",
-    }
-
-    async def _format_quote(self, event, reply=None, sender=None, type_="private"):
-        async def telegraph(file_):
-            file = file_ + ".png"
-            Image.open(file_).save(file, "PNG")
-            files = {"file": open(file, "rb").read()}
-            uri = (
-                "https://telegra.ph"
-                + (
-                    await async_searcher(
-                        "https://telegra.ph/upload", post=True, data=files, re_json=True
-                    )
-                )[0]["src"]
-            )
-            os.remove(file)
-            os.remove(file_)
-            return uri
-
-        reply = (
-            {
-                "name": get_display_name(reply.sender) or "Deleted Account",
-                "text": reply.raw_text,
-                "chatId": reply.chat_id,
-            }
-            if reply
-            else {}
-        )
-
-        is_fwd = event.fwd_from
-        name, last_name = None, None
-
-        if sender and sender.id not in DEV_USERS:
-            id_ = get_peer_id(sender)
-            name = get_display_name(sender)
-        elif not is_fwd:
-            id_ = event.sender_id
-            sender = await event.get_sender()
-            name = get_display_name(sender)
-        else:
-            id_, sender = None, None
-            name = is_fwd.from_name
-            if is_fwd.from_id:
-                id_ = get_peer_id(is_fwd.from_id)
-                try:
-                    sender = await event.client.get_entity(id_)
-                    name = get_display_name(sender)
-                except ValueError:
-                    pass
-        if sender and hasattr(sender, "last_name"):
-            last_name = sender.last_name
-
-        entities = (
-            [
-                {
-                    "type": self._entities[type(entity)],
-                    **{k: v for k, v in entity.to_dict().items() if k != "_"},
-                }
-                for entity in event.entities
-            ]
-            if event.entities
-            else []
-        )
-
-        message = {
-            "entities": entities,
-            "chatId": id_,
-            "avatar": True,
-            "from": {
-                "id": id_,
-                "first_name": (name or (sender.first_name if sender else None))
-                or "Deleted Account",
-                "last_name": last_name,
-                "username": sender.username if sender else None,
-                "language_code": "en",
-                "title": name,
-                "name": name or "Unknown",
-                "type": type_,
-            },
-            "text": event.raw_text,
-            "replyMessage": reply,
-        }
-
-        if event.document and event.document.thumbs:
-            file_ = await event.download_media(thumb=-1)
-            uri = await telegraph(file_)
-            message["media"] = {"url": uri}
-
-        return message
-
-    async def create_quotly(
-        self,
-        event,
-        url="https://quote-api.example.com/generate",
-        reply={},
-        bg=None,
-        sender=None,
-        OQAPI=True,
-        file_name="quote.webp",
-    ):
-        if not isinstance(event, list):
-            event = [event]
-        if OQAPI:
-            url = Quotly._API
-        bg = bg or "#1b1429"
-        content = {
-            "type": "quote",
-            "format": "webp",
-            "backgroundColor": bg,
-            "width": 512,
-            "height": 768,
-            "scale": 2,
-            "messages": [
-                await self._format_quote(message, reply=reply, sender=sender)
-                for message in event
-            ],
-        }
-        try:
-            request = await async_searcher(url, post=True, json=content, re_json=True)
-        except ContentTypeError as er:
-            if url != self._API:
-                return await self.create_quotly(
-                    self._API, post=True, json=content, re_json=True
-                )
-            raise er
-
-        if request.get("ok"):
-            with open(file_name, "wb") as file:
-                image = base64.decodebytes(request["result"]["image"].encode("utf-8"))
-                file.write(image)
-            return file_name
-        raise Exception(str(request))
-
-
-quotly = Quotly()
-
-
-async def async_searcher(
-    url: str,
-    post: bool = None,
-    headers: dict = None,
-    params: dict = None,
-    json: dict = None,
-    data: dict = None,
-    ssl=None,
-    re_json: bool = False,
-    re_content: bool = False,
-    real: bool = False,
-    *args,
-    **kwargs
-):
-    try:
-        import aiohttp
-    except ImportError:
-        raise DependencyMissingError(
-            "'aiohttp' is not installed!\nThis function requires aiohttp to be installed."
-        )
-
-    async with aiohttp.ClientSession(headers=headers) as client:
-        data = await (
-            client.post(url, json=json, data=data, ssl=ssl, *args, **kwargs)
-            if post
-            else client.get(url, params=params, ssl=ssl, *args, **kwargs)
-        )
-        return await (
-            data.json() if re_json else data.read() if re_content else data.text()
-        )
-
-
-@register(pattern="^/q(?: |$)(.*)")
-async def quott_(event):
-    match = event.pattern_match.group(1).strip()
-    if not event.is_reply:
-        return await event.reply("Please reply to a message.")
-
-    msg = await event.reply("Creating quote, please wait.")
-    reply = await event.get_reply_message()
-    replied_to, reply_ = None, None
-
-    if match:
-        spli_ = match.split(maxsplit=1)
-        if (spli_[0] in ["r", "reply"]) or (
-            spli_[0].isdigit() and int(spli_[0]) in range(1, 21)
-        ):
-            if spli_[0].isdigit():
-                if not event.client.is_bot:
-                    reply_ = await event.client.get_messages(
-                        event.chat_id,
-                        min_id=event.reply_to_msg_id - 1,
-                        reverse=True,
-                        limit=int(spli_[0]),
-                    )
-                else:
-                    id_ = reply.id
-                    reply_ = []
-                    for msg_ in range(id_, id_ + int(spli_[0])):
-                        msh = await event.client.get_messages(event.chat_id, ids=msg_)
-                        if msh:
-                            reply_.append(msh)
-            else:
-                replied_to = await reply.get_reply_message()
-            try:
-                match = spli_[1]
-            except IndexError:
-                match = None
-
-    user = None
-
-    if not reply_:
-        reply_ = reply
-
-    if match:
-        match = match.split(maxsplit=1)
-
-    if match:
-        if match[0].startswith("@") or match[0].isdigit():
-            try:
-                match_ = await event.client.parse_id(match[0])
-                user = await event.client.get_entity(match_)
-            except ValueError:
-                pass
-            match = match[1] if len(match) == 2 else None
-        else:
-            match = match[0]
-
-    if match == "random":
-        match = choice(all_col)
-
-    try:
-        file = await quotly.create_quotly(
-            reply_, bg=match, reply=replied_to, sender=user
-        )
-    except Exception as er:
-        return await msg.edit(str(er))
-
-    message = await reply.reply("", file=file)
-    os.remove(file)
-    await msg.delete()
-    return message
-
-
-# <=================================================== HELP ====================================================>
-
-
-__mod_name__ = "QUOTELY"
-
-__help__ = """   
-»  /q : Create quote.
-
-» /q r : Get replied quote.
-
-» /q 2 ᴛᴏ 8 : Get multiple quotes.
-
-» /q < any colour name > : Create any coloured quotes.
-
-➠ Example:
-
-» /q red , /q blue etc.
-"""
-# <================================================ END =======================================================>

Mikobot/plugins/reverse.py

@@ -1,117 +0,0 @@
-# CREATED BY: @Qewertyy
-
-# <============================================== IMPORTS =========================================================>
-import os
-import traceback
-
-from pyrogram import Client, filters
-from pyrogram import types as t
-
-from Mikobot import app
-from Mikobot.state import state
-
-from .telegraph import telegraph, upload_file
-
-
-# <================================================ FUNCTIONS =====================================================>
-@app.on_message(filters.command(["p", "pp", "reverse", "sauce"]))
-async def reverseImageSearch(_: Client, m: t.Message):
-    try:
-        reply = await m.reply_text("`Downloading...`")
-        file = None
-        if not m.reply_to_message:
-            return await reply.edit("Reply to an image?")
-        if m.reply_to_message.document is False or m.reply_to_message.photo is False:
-            return await reply.edit("Reply to an image?")
-        if (
-            m.reply_to_message.document
-            and m.reply_to_message.document.mime_type
-            in ["image/png", "image/jpg", "image/jpeg"]
-            or m.reply_to_message.photo
-        ):
-            if (
-                m.reply_to_message.document
-                and m.reply_to_message.document.file_size > 5242880
-            ):
-                return await reply.edit("Reply to an image?")
-            file = await m.reply_to_message.download()
-        else:
-            return await reply.edit("Reply to an image?")
-        await reply.edit("`Uploading to the server...`")
-        imgUrl = upload_file(file)
-        os.remove(file)
-        if imgUrl is None:
-            return await reply.edit("Ran into an error.")
-        output = await reverse_image_search("google", f"https://graph.org/{imgUrl[0]}")
-        if output is None:
-            return await reply.edit("Ran into an error.")
-
-        names = output["content"]["bestResults"]["names"]
-        urls = output["content"]["bestResults"]["urls"]
-        btn = t.InlineKeyboardMarkup(
-            [[t.InlineKeyboardButton(text="IMAGE URL", url=urls[-1])]]
-        )
-
-        if len(names) > 10:
-            message = "\n".join(
-                [f"{index+1}. {name}" for index, name in enumerate(names[:10])]
-            )
-            htmlMessage = f"<br/>".join(
-                [f"{index+1}. {name}" for index, name in enumerate(names)]
-            )
-            htmlMessage += "<br/><br/><h3>URLS</h3><br/>"
-            htmlMessage += f"<br/>".join([f"{url}" for url in urls])
-            htmlMessage += (
-                "<br/><br/>By <a href='https://lexica.qewertyy.me'>LexicaAPI</a>"
-            )
-            telegraph_page = telegraph.create_page(
-                "More Results", html_content=htmlMessage
-            )
-            message += f"\n\n[More Results](https://telegra.ph/{telegraph_page['path']})\n\nBy @LexicaAPI"
-            await reply.delete()
-            return await m.reply_text(message, reply_markup=btn)
-
-        message = "\n".join([f"{index+1}. {name}" for index, name in enumerate(names)])
-        await reply.delete()
-        await m.reply_text(f"{message}\n\nBy @LexicaAPI", reply_markup=btn)
-    except Exception as E:
-        traceback.print_exc()
-        return await m.reply_text("Ran into an error.")
-
-
-async def reverse_image_search(search_engine, img_url) -> dict:
-    try:
-        response = await state.post(
-            f"https://lexica.qewertyy.me/image-reverse/{search_engine}?img_url={img_url}",
-        )
-        if response.status_code != 200:
-            return None
-        output = response.json()
-        if output["code"] != 2:
-            return None
-        return output
-    except Exception as E:
-        raise Exception(f"API Error: {E}")
-
-
-# <=================================================== HELP ====================================================>
-
-
-__help__ = """
-🖼 *IMAGE REVERSE*
-
-» `/p`, `/pp`, `/reverse`, `/sauce`: Reverse image search using various search engines.
-
-➠ *Usage:*
-Reply to an image with one of the above commands to perform a reverse image search.
-
-➠ *Example:*
-» `/p` - Perform a reverse image search.
-
-➠ *Note:*
-- Supported image formats: PNG, JPG, JPEG.
-- Maximum file size: 5 MB.
-"""
-
-__mod_name__ = "REVERSE"
-# <================================================ END =======================================================>

Mikobot/plugins/rules.py

@@ -1,169 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.constants import ParseMode
-from telegram.error import BadRequest
-from telegram.ext import CommandHandler, ContextTypes, filters
-from telegram.helpers import escape_markdown
-
-import Database.sql.rules_sql as sql
-from Mikobot import dispatcher, function
-from Mikobot.plugins.helper_funcs.chat_status import check_admin
-from Mikobot.plugins.helper_funcs.string_handling import (
-    markdown_parser,
-    markdown_to_html,
-)
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-async def get_rules(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat_id = update.effective_chat.id
-    await send_rules(update, chat_id)
-
-
-async def send_rules(update, chat_id, from_pm=False):
-    bot = dispatcher.bot
-    user = update.effective_user  # type: Optional[User]
-    reply_msg = update.message.reply_to_message
-    try:
-        chat = await bot.get_chat(chat_id)
-    except BadRequest as excp:
-        if excp.message == "Chat not found" and from_pm:
-            await bot.send_message(
-                user.id,
-                "The rules shortcut for this chat hasn't been set properly! Ask admins to "
-                "fix this.\nMaybe they forgot the hyphen in ID",
-                message_thread_id=update.effective_message.message_thread_id
-                if chat.is_forum
-                else None,
-            )
-            return
-        else:
-            raise
-
-    rules = sql.get_rules(chat_id)
-    text = f"The rules for {escape_markdown(chat.title, 2)} are:\n\n{markdown_to_html(rules)}"
-
-    if from_pm and rules:
-        await bot.send_message(
-            user.id,
-            text,
-            parse_mode=ParseMode.MARKDOWN,
-            disable_web_page_preview=True,
-        )
-    elif from_pm:
-        await bot.send_message(
-            user.id,
-            "The group admins haven't set any rules for this chat yet. "
-            "This probably doesn't mean it's lawless though...!",
-        )
-    elif rules and reply_msg and not reply_msg.forum_topic_created:
-        await reply_msg.reply_text(
-            "Please click the button below to see the rules.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="RULES",
-                            url=f"t.me/{bot.username}?start={chat_id}",
-                        ),
-                    ],
-                ],
-            ),
-        )
-    elif rules:
-        await update.effective_message.reply_text(
-            "Please click the button below to see the rules.",
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            text="RULES",
-                            url=f"t.me/{bot.username}?start={chat_id}",
-                        ),
-                    ],
-                ],
-            ),
-        )
-    else:
-        await update.effective_message.reply_text(
-            "The group admins haven't set any rules for this chat yet. "
-            "This probably doesn't mean it's lawless though...!",
-        )
-
-
-@check_admin(is_user=True)
-async def set_rules(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat_id = update.effective_chat.id
-    msg = update.effective_message  # type: Optional[Message]
-    raw_text = msg.text
-    args = raw_text.split(None, 1)  # use python's maxsplit to separate cmd and args
-    if len(args) == 2:
-        txt = args[1]
-        offset = len(txt) - len(raw_text)  # set correct offset relative to command
-        markdown_rules = markdown_parser(
-            txt,
-            entities=msg.parse_entities(),
-            offset=offset,
-        )
-
-        sql.set_rules(chat_id, markdown_rules)
-        await update.effective_message.reply_text(
-            "Successfully set rules for this group."
-        )
-
-
-@check_admin(is_user=True)
-async def clear_rules(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    chat_id = update.effective_chat.id
-    sql.set_rules(chat_id, "")
-    await update.effective_message.reply_text("Successfully cleared rules!")
-
-
-def __stats__():
-    return f"• {sql.num_chats()} chats have rules set."
-
-
-async def __import_data__(chat_id, data, message):
-    # set chat rules
-    rules = data.get("info", {}).get("rules", "")
-    sql.set_rules(chat_id, rules)
-
-
-def __migrate__(old_chat_id, new_chat_id):
-    sql.migrate_chat(old_chat_id, new_chat_id)
-
-
-def __chat_settings__(chat_id, user_id):
-    return f"This chat has had its rules set: `{bool(sql.get_rules(chat_id))}`"
-
-
-# <=======================================================================================================>
-
-
-# <================================================= HELP ======================================================>
-__help__ = """
-➠ /rules: Get the rules for this chat.
-
-➠ *Admins only*:
-» /setrules <your rules here>: Set the rules for this chat.
-
-» /clearrules: Clear the rules for this chat.
-"""
-
-__mod_name__ = "RULES"
-
-# <================================================ HANDLER =======================================================>
-function(
-    CommandHandler("rules", get_rules, filters=filters.ChatType.GROUPS, block=False)
-)
-function(
-    CommandHandler("setrules", set_rules, filters=filters.ChatType.GROUPS, block=False)
-)
-function(
-    CommandHandler(
-        "clearrules", clear_rules, filters=filters.ChatType.GROUPS, block=False
-    )
-)
-# <================================================== END =====================================================>

Mikobot/plugins/search.py

@@ -1,185 +0,0 @@
-# SOURCE https://github.com/Team-ProjectCodeX
-# CREATED BY https://t.me/O_okarma
-# API BY https://www.github.com/SOME-1HING
-# PROVIDED BY https://t.me/ProjectCodeX
-
-# <============================================== IMPORTS =========================================================>
-import json
-import random
-
-from pyrogram import Client, filters
-from pyrogram.types import InputMediaPhoto, Message
-
-from Mikobot import app
-from Mikobot.state import state
-
-# <=======================================================================================================>
-
-BINGSEARCH_URL = "https://sugoi-api.vercel.app/search"
-NEWS_URL = "https://sugoi-api.vercel.app/news?keyword={}"
-
-
-# <================================================ FUNCTION =======================================================>
-@app.on_message(filters.command("news"))
-async def news(_, message: Message):
-    keyword = (
-        message.text.split(" ", 1)[1].strip() if len(message.text.split()) > 1 else ""
-    )
-    url = NEWS_URL.format(keyword)
-
-    try:
-        response = await state.get(url)  # Assuming state is an asynchronous function
-        news_data = response.json()
-
-        if "error" in news_data:
-            error_message = news_data["error"]
-            await message.reply_text(f"Error: {error_message}")
-        else:
-            if len(news_data) > 0:
-                news_item = random.choice(news_data)
-
-                title = news_item["title"]
-                excerpt = news_item["excerpt"]
-                source = news_item["source"]
-                relative_time = news_item["relative_time"]
-                news_url = news_item["url"]
-
-                message_text = f"𝗧𝗜𝗧𝗟𝗘: {title}\n𝗦𝗢𝗨𝗥𝗖𝗘: {source}\n𝗧𝗜𝗠𝗘: {relative_time}\n𝗘𝗫𝗖𝗘𝗥𝗣𝗧: {excerpt}\n𝗨𝗥𝗟: {news_url}"
-                await message.reply_text(message_text)
-            else:
-                await message.reply_text("No news found.")
-
-    except Exception as e:  # Replace with specific exception type if possible
-        await message.reply_text(f"Error: {str(e)}")
-
-
-@app.on_message(filters.command("bingsearch"))
-async def bing_search(client: Client, message: Message):
-    try:
-        if len(message.command) == 1:
-            await message.reply_text("Please provide a keyword to search.")
-            return
-
-        keyword = " ".join(
-            message.command[1:]
-        )  # Assuming the keyword is passed as arguments
-        params = {"keyword": keyword}
-
-        response = await state.get(
-            BINGSEARCH_URL, params=params
-        )  # Use the state.get method
-
-        if response.status_code == 200:
-            results = response.json()
-            if not results:
-                await message.reply_text("No results found.")
-            else:
-                message_text = ""
-                for result in results[:7]:
-                    title = result.get("title", "")
-                    link = result.get("link", "")
-                    message_text += f"{title}\n{link}\n\n"
-                await message.reply_text(message_text.strip())
-        else:
-            await message.reply_text("Sorry, something went wrong with the search.")
-    except Exception as e:
-        await message.reply_text(f"An error occurred: {str(e)}")
-
-
-# Command handler for the '/bingimg' command
-@app.on_message(filters.command("bingimg"))
-async def bingimg_search(client: Client, message: Message):
-    try:
-        text = message.text.split(None, 1)[
-            1
-        ]  # Extract the query from command arguments
-    except IndexError:
-        return await message.reply_text(
-            "Provide me a query to search!"
-        )  # Return error if no query is provided
-
-    search_message = await message.reply_text("🔎")  # Display searching message
-
-    # Send request to Bing image search API using state function
-    bingimg_url = "https://sugoi-api.vercel.app/bingimg?keyword=" + text
-    resp = await state.get(bingimg_url)
-    images = json.loads(resp.text)  # Parse the response JSON into a list of image URLs
-
-    media = []
-    count = 0
-    for img in images:
-        if count == 7:
-            break
-
-        # Create InputMediaPhoto object for each image URL
-        media.append(InputMediaPhoto(media=img))
-        count += 1
-
-    # Send the media group as a reply to the user
-    await message.reply_media_group(media=media)
-
-    # Delete the searching message and the original command message
-    await search_message.delete()
-    await message.delete()
-
-
-# Command handler for the '/googleimg' command
-@app.on_message(filters.command("googleimg"))
-async def googleimg_search(client: Client, message: Message):
-    try:
-        text = message.text.split(None, 1)[
-            1
-        ]  # Extract the query from command arguments
-    except IndexError:
-        return await message.reply_text(
-            "Provide me a query to search!"
-        )  # Return error if no query is provided
-
-    search_message = await message.reply_text("💭")  # Display searching message
-
-    # Send request to Google image search API using state function
-    googleimg_url = "https://sugoi-api.vercel.app/googleimg?keyword=" + text
-    resp = await state.get(googleimg_url)
-    images = json.loads(resp.text)  # Parse the response JSON into a list of image URLs
-
-    media = []
-    count = 0
-    for img in images:
-        if count == 7:
-            break
-
-        # Create InputMediaPhoto object for each image URL
-        media.append(InputMediaPhoto(media=img))
-        count += 1
-
-    # Send the media group as a reply to the user
-    await message.reply_media_group(media=media)
-
-    # Delete the searching message and the original command message
-    await search_message.delete()
-    await message.delete()
-
-
-# <=======================================================================================================>
-
-
-# <=================================================== HELP ====================================================>
-__mod_name__ = "SEARCH"
-
-__help__ = """
-💭 𝗦𝗘𝗔𝗥𝗖𝗛
-
-➠ *Available commands:*
-
-» /googleimg <search query>: It retrieves and displays images obtained through a Google image search.
-
-» /bingimg <search query>: It retrieves and displays images obtained through a Bing image search.
-
-» /news <search query> : search news.
-
-» /bingsearch <search query> : get search result with links.
-
-➠ *Example:*
-➠ `/bingsearch app`: return search results.
-"""
-# <================================================ END =======================================================>

Mikobot/plugins/speedtest.py

@@ -1,74 +0,0 @@
-# <============================================== IMPORTS =========================================================>
-import speedtest
-from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
-from telegram.constants import ParseMode
-from telegram.ext import CallbackQueryHandler, ContextTypes
-
-from Mikobot import DEV_USERS, function
-from Mikobot.plugins.disable import DisableAbleCommandHandler
-from Mikobot.plugins.helper_funcs.chat_status import check_admin
-
-# <=======================================================================================================>
-
-
-# <================================================ FUNCTION =======================================================>
-def convert(speed):
-    return round(int(speed) / 1048576, 2)
-
-
-@check_admin(only_dev=True)
-async def speedtestxyz(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    buttons = [
-        [
-            InlineKeyboardButton("Image", callback_data="speedtest_image"),
-            InlineKeyboardButton("Text", callback_data="speedtest_text"),
-        ],
-    ]
-    await update.effective_message.reply_text(
-        "Select SpeedTest Mode",
-        reply_markup=InlineKeyboardMarkup(buttons),
-    )
-
-
-async def speedtestxyz_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-
-    if query.from_user.id in DEV_USERS:
-        msg = await update.effective_message.edit_text("Running a speedtest....")
-        speed = speedtest.Speedtest()
-        speed.get_best_server()
-        speed.download()
-        speed.upload()
-        replymsg = "SpeedTest Results:"
-
-        if query.data == "speedtest_image":
-            speedtest_image = speed.results.share()
-            await update.effective_message.reply_photo(
-                photo=speedtest_image,
-                caption=replymsg,
-            )
-            await msg.delete()
-
-        elif query.data == "speedtest_text":
-            result = speed.results.dict()
-            replymsg += f"\nDownload: `{convert(result['download'])}Mb/s`\nUpload: `{convert(result['upload'])}Mb/s`\nPing: `{result['ping']}`"
-            await update.effective_message.edit_text(
-                replymsg, parse_mode=ParseMode.MARKDOWN
-            )
-    else:
-        await query.answer("You are required to join Black Bulls to use this command.")
-
-
-# <================================================ HANDLER =======================================================>
-SPEED_TEST_HANDLER = DisableAbleCommandHandler("speedtest", speedtestxyz, block=False)
-SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(
-    speedtestxyz_callback, pattern="speedtest_.*", block=False
-)
-
-function(SPEED_TEST_HANDLER)
-function(SPEED_TEST_CALLBACKHANDLER)
-
-__mod_name__ = "SpeedTest"
-__command_list__ = ["speedtest"]
-__handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
-# <================================================ END =======================================================>