Add files via upload

Database/mongodb/db.py

@@ -0,0 +1,6 @@
+from motor.motor_asyncio import AsyncIOMotorClient as MongoClient
+
+from Mikobot import DB_NAME, MONGO_DB_URI
+
+mongo = MongoClient(MONGO_DB_URI)
+dbname = mongo[DB_NAME]

Database/mongodb/karma_mongo.py

@@ -0,0 +1,122 @@
+from typing import Dict, Union
+
+from pymongo import MongoClient
+
+from Mikobot import DB_NAME, MONGO_DB_URI
+
+client = MongoClient(MONGO_DB_URI)
+db = client[DB_NAME]
+
+coupledb = db.couple
+karmadb = db.karma
+
+
+async def _get_lovers(chat_id: int):
+    lovers = coupledb.find_one({"chat_id": chat_id})
+    if lovers:
+        lovers = lovers["couple"]
+    else:
+        lovers = {}
+    return lovers
+
+
+async def get_couple(chat_id: int, date: str):
+    lovers = await _get_lovers(chat_id)
+    if date in lovers:
+        return lovers[date]
+    else:
+        return False
+
+
+async def save_couple(chat_id: int, date: str, couple: dict):
+    lovers = await _get_lovers(chat_id)
+    lovers[date] = couple
+    coupledb.update_one({"chat_id": chat_id}, {"$set": {"couple": lovers}}, upsert=True)
+
+
+async def get_karmas_count() -> dict:
+    chats = karmadb.find({"chat_id": {"$lt": 0}})
+    if not chats:
+        return {}
+    chats_count = 0
+    karmas_count = 0
+    for chat in await chats.to_list(length=1000000):
+        for i in chat["karma"]:
+            karma_ = chat["karma"][i]["karma"]
+            if karma_ > 0:
+                karmas_count += karma_
+        chats_count += 1
+    return {"chats_count": chats_count, "karmas_count": karmas_count}
+
+
+async def user_global_karma(user_id) -> int:
+    chats = karmadb.find({"chat_id": {"$lt": 0}})
+    if not chats:
+        return 0
+    total_karma = 0
+    for chat in await chats.to_list(length=1000000):
+        karma = await get_karma(chat["chat_id"], await int_to_alpha(user_id))
+        if karma and (int(karma["karma"]) > 0):
+            total_karma += int(karma["karma"])
+    return total_karma
+
+
+async def get_karmas(chat_id: int) -> Dict[str, int]:
+    karma = karmadb.find_one({"chat_id": chat_id})
+    if not karma:
+        return {}
+    return karma["karma"]
+
+
+async def get_karma(chat_id: int, name: str) -> Union[bool, dict]:
+    name = name.lower().strip()
+    karmas = await get_karmas(chat_id)
+    if name in karmas:
+        return karmas[name]
+
+
+async def update_karma(chat_id: int, name: str, karma: dict):
+    name = name.lower().strip()
+    karmas = await get_karmas(chat_id)
+    karmas[name] = karma
+    karmadb.update_one({"chat_id": chat_id}, {"$set": {"karma": karmas}}, upsert=True)
+
+
+async def is_karma_on(chat_id: int) -> bool:
+    chat = karmadb.find_one({"chat_id_toggle": chat_id})
+    if not chat:
+        return True
+    return False
+
+
+async def karma_on(chat_id: int):
+    is_karma = await is_karma_on(chat_id)
+    if is_karma:
+        return
+    return karmadb.delete_one({"chat_id_toggle": chat_id})
+
+
+async def karma_off(chat_id: int):
+    is_karma = await is_karma_on(chat_id)
+    if not is_karma:
+        return
+    return karmadb.insert_one({"chat_id_toggle": chat_id})
+
+
+async def int_to_alpha(user_id: int) -> str:
+    alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+    text = ""
+    user_id = str(user_id)
+    for i in user_id:
+        text += alphabet[int(i)]
+    return text
+
+
+async def alpha_to_int(user_id_alphabet: str) -> int:
+    alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+    user_id = ""
+    for i in user_id_alphabet:
+        index = alphabet.index(i)
+        user_id += str(index)
+    user_id = int(user_id)
+    return user_id

Database/mongodb/mongodb.py

@@ -0,0 +1,75 @@
+from sys import exit as exiter
+
+from pymongo import MongoClient
+from pymongo.errors import PyMongoError
+
+from Mikobot import DB_NAME, LOGGER, MONGO_DB_URI
+
+try:
+    Mikobot_db_client = MongoClient(MONGO_DB_URI)
+except PyMongoError as f:
+    LOGGER.error(f"Error in Mongodb: {f}")
+    exiter(1)
+Mikobot_main_db = Mikobot_db_client[DB_NAME]
+
+
+class MongoDB:
+    """Class for interacting with Bot database."""
+
+    def __init__(self, collection) -> None:
+        self.collection = Mikobot_main_db[collection]
+
+    # Insert one entry into collection
+    def insert_one(self, document):
+        result = self.collection.insert_one(document)
+        return repr(result.inserted_id)
+
+    # Find one entry from collection
+    def find_one(self, query):
+        result = self.collection.find_one(query)
+        if result:
+            return result
+        return False
+
+    # Find entries from collection
+    def find_all(self, query=None):
+        if query is None:
+            query = {}
+        return list(self.collection.find(query))
+
+    # Count entries from collection
+    def count(self, query=None):
+        if query is None:
+            query = {}
+        return self.collection.count_documents(query)
+
+    # Delete entry/entries from collection
+    def delete_one(self, query):
+        self.collection.delete_many(query)
+        return self.collection.count_documents({})
+
+    # Replace one entry in collection
+    def replace(self, query, new_data):
+        old = self.collection.find_one(query)
+        _id = old["_id"]
+        self.collection.replace_one({"_id": _id}, new_data)
+        new = self.collection.find_one({"_id": _id})
+        return old, new
+
+    # Update one entry from collection
+    def update(self, query, update):
+        result = self.collection.update_one(query, {"$set": update})
+        new_document = self.collection.find_one(query)
+        return result.modified_count, new_document
+
+    @staticmethod
+    def close():
+        return Mikobot_db_client.close()
+
+
+def __connect_first():
+    _ = MongoDB("test")
+    LOGGER.info("Initialized Mongo Database!\n")
+
+
+__connect_first()

Database/mongodb/toggle_mongo.py

@@ -0,0 +1,50 @@
+from Database.mongodb.db import *
+
+dwelcomedb = dbname.dwelcome
+nsfwdb = dbname.nsfw
+nekomodedb = dbname.nekomode
+
+
+async def is_dwelcome_on(chat_id: int) -> bool:
+    chat = await dwelcomedb.find_one({"chat_id_toggle": chat_id})
+    return not bool(chat)
+
+
+async def dwelcome_on(chat_id: int):
+    await dwelcomedb.delete_one({"chat_id_toggle": chat_id})
+
+
+async def dwelcome_off(chat_id: int):
+    await dwelcomedb.insert_one({"chat_id_toggle": chat_id})
+
+
+async def is_nsfw_on(chat_id: int) -> bool:
+    chat = await nsfwdb.find_one({"chat_id": chat_id})
+    return chat
+
+
+async def nsfw_on(chat_id: int):
+    is_nsfw = await is_nsfw_on(chat_id)
+    if is_nsfw:
+        return
+    return await nsfwdb.insert_one({"chat_id": chat_id})
+
+
+async def nsfw_off(chat_id: int):
+    is_nsfw = await is_nsfw_on(chat_id)
+    if not is_nsfw:
+        return
+    return await nsfwdb.delete_one({"chat_id": chat_id})
+
+
+async def is_nekomode_on(chat_id: int) -> bool:
+    chat = await nekomodedb.find_one({"chat_id_toggle": chat_id})
+    return not bool(chat)
+
+
+async def nekomode_on(chat_id: int):
+    await nekomodedb.delete_one({"chat_id_toggle": chat_id})
+
+
+async def nekomode_off(chat_id: int):
+    await nekomodedb.insert_one({"chat_id_toggle": chat_id})

Database/mongodb/users_db.py

@@ -0,0 +1,102 @@
+from threading import RLock
+from time import time
+
+from Database.mongodb.mongodb import MongoDB
+from Mikobot import LOGGER
+
+INSERTION_LOCK = RLock()
+
+
+class Users(MongoDB):
+    """Class to manage users for bot."""
+
+    db_name = "users"
+
+    def __init__(self, user_id: int) -> None:
+        super().__init__(self.db_name)
+        self.user_id = user_id
+        self.user_info = self.__ensure_in_db()
+
+    def update_user(self, name: str, username: str = None):
+        with INSERTION_LOCK:
+            if name != self.user_info["name"] or username != self.user_info["username"]:
+                return self.update(
+                    {"_id": self.user_id},
+                    {"username": username, "name": name},
+                )
+            return True
+
+    def delete_user(self):
+        with INSERTION_LOCK:
+            return self.delete_one({"_id": self.user_id})
+
+    @staticmethod
+    def count_users():
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            return collection.count()
+
+    def get_my_info(self):
+        with INSERTION_LOCK:
+            return self.user_info
+
+    @staticmethod
+    def list_users():
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            return collection.find_all()
+
+    @staticmethod
+    def get_user_info(user_id: int or str):
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            if isinstance(user_id, int):
+                curr = collection.find_one({"_id": user_id})
+            elif isinstance(user_id, str):
+                # user_id[1:] because we don't want the '@' in the username
+                # search!
+                curr = collection.find_one({"username": user_id[1:]})
+            else:
+                curr = None
+
+            if curr:
+                return curr
+
+            return {}
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.user_id})
+        if not chat_data:
+            new_data = {"_id": self.user_id, "username": "", "name": "unknown_till_now"}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized User Document for {self.user_id}")
+            return new_data
+        return chat_data
+
+    @staticmethod
+    def load_from_db():
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            return collection.find_all()
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"username": "", "name": "unknown_till_now"}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Users Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_users():
+    start = time()
+    LOGGER.info("Starting Users Database Repair...")
+    collection = MongoDB(Users.db_name)
+    Users.repair_db(collection)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Database/mongodb/whispers.py

@@ -0,0 +1,19 @@
+from Database.mongodb.db import dbname
+
+collection = dbname["whisper"]
+
+
+class Whispers:
+    @staticmethod
+    async def add_whisper(WhisperId, WhisperData):
+        whisper = {"WhisperId": WhisperId, "whisperData": WhisperData}
+        await collection.insert_one(whisper)
+
+    @staticmethod
+    async def del_whisper(WhisperId):
+        await collection.delete_one({"WhisperId": WhisperId})
+
+    @staticmethod
+    async def get_whisper(WhisperId):
+        whisper = await collection.find_one({"WhisperId": WhisperId})
+        return whisper["whisperData"] if whisper else None

Database/sql/__init__.py

@@ -0,0 +1,27 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import scoped_session, sessionmaker
+
+from Mikobot import DB_URI
+from Mikobot import LOGGER as log
+
+if DB_URI and DB_URI.startswith("postgres://"):
+    DB_URI = DB_URI.replace("postgres://", "postgresql://", 1)
+
+
+def start() -> scoped_session:
+    engine = create_engine(DB_URI, client_encoding="utf8")
+    log.info("[PostgreSQL] Connecting to database......")
+    BASE.metadata.bind = engine
+    BASE.metadata.create_all(engine)
+    return scoped_session(sessionmaker(bind=engine, autoflush=False))
+
+
+BASE = declarative_base()
+try:
+    SESSION = start()
+except Exception as e:
+    log.exception(f"[PostgreSQL] Failed to connect due to {e}")
+    exit()
+
+log.info("[PostgreSQL] Connection successful, session started.")

Database/sql/antiflood_sql.py

@@ -0,0 +1,145 @@
+import threading
+
+from sqlalchemy import BigInteger, Column, Integer, String, UnicodeText
+
+from Database.sql import BASE, SESSION
+
+DEF_COUNT = 1
+DEF_LIMIT = 0
+DEF_OBJ = (None, DEF_COUNT, DEF_LIMIT)
+
+
+class FloodControl(BASE):
+    __tablename__ = "antiflood"
+    chat_id = Column(String(14), primary_key=True)
+    user_id = Column(BigInteger)
+    count = Column(Integer, default=DEF_COUNT)
+    limit = Column(Integer, default=DEF_LIMIT)
+
+    def __init__(self, chat_id):
+        self.chat_id = str(chat_id)  # ensure string
+
+    def __repr__(self):
+        return "<flood control for %s>" % self.chat_id
+
+
+class FloodSettings(BASE):
+    __tablename__ = "antiflood_settings"
+    chat_id = Column(String(14), primary_key=True)
+    flood_type = Column(Integer, default=1)
+    value = Column(UnicodeText, default="0")
+
+    def __init__(self, chat_id, flood_type=1, value="0"):
+        self.chat_id = str(chat_id)
+        self.flood_type = flood_type
+        self.value = value
+
+    def __repr__(self):
+        return "<{} will executing {} for flood.>".format(self.chat_id, self.flood_type)
+
+
+FloodControl.__table__.create(checkfirst=True)
+FloodSettings.__table__.create(checkfirst=True)
+
+INSERTION_FLOOD_LOCK = threading.RLock()
+INSERTION_FLOOD_SETTINGS_LOCK = threading.RLock()
+
+CHAT_FLOOD = {}
+
+
+def set_flood(chat_id, amount):
+    with INSERTION_FLOOD_LOCK:
+        flood = SESSION.query(FloodControl).get(str(chat_id))
+        if not flood:
+            flood = FloodControl(str(chat_id))
+
+        flood.user_id = None
+        flood.limit = amount
+
+        CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, amount)
+
+        SESSION.add(flood)
+        SESSION.commit()
+
+
+def update_flood(chat_id: str, user_id) -> bool:
+    if str(chat_id) in CHAT_FLOOD:
+        curr_user_id, count, limit = CHAT_FLOOD.get(str(chat_id), DEF_OBJ)
+
+        if limit == 0:  # no antiflood
+            return False
+
+        if user_id != curr_user_id or user_id is None:  # other user
+            CHAT_FLOOD[str(chat_id)] = (user_id, DEF_COUNT, limit)
+            return False
+
+        count += 1
+        if count > limit:  # too many msgs, kick
+            CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, limit)
+            return True
+
+        # default -> update
+        CHAT_FLOOD[str(chat_id)] = (user_id, count, limit)
+        return False
+
+
+def get_flood_limit(chat_id):
+    return CHAT_FLOOD.get(str(chat_id), DEF_OBJ)[2]
+
+
+def set_flood_strength(chat_id, flood_type, value):
+    # for flood_type
+    # 1 = ban
+    # 2 = kick
+    # 3 = mute
+    # 4 = tban
+    # 5 = tmute
+    with INSERTION_FLOOD_SETTINGS_LOCK:
+        curr_setting = SESSION.query(FloodSettings).get(str(chat_id))
+        if not curr_setting:
+            curr_setting = FloodSettings(
+                chat_id,
+                flood_type=int(flood_type),
+                value=value,
+            )
+
+        curr_setting.flood_type = int(flood_type)
+        curr_setting.value = str(value)
+
+        SESSION.add(curr_setting)
+        SESSION.commit()
+
+
+def get_flood_setting(chat_id):
+    try:
+        setting = SESSION.query(FloodSettings).get(str(chat_id))
+        if setting:
+            return setting.flood_type, setting.value
+        else:
+            return 1, "0"
+
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with INSERTION_FLOOD_LOCK:
+        flood = SESSION.query(FloodControl).get(str(old_chat_id))
+        if flood:
+            CHAT_FLOOD[str(new_chat_id)] = CHAT_FLOOD.get(str(old_chat_id), DEF_OBJ)
+            flood.chat_id = str(new_chat_id)
+            SESSION.commit()
+
+        SESSION.close()
+
+
+def __load_flood_settings():
+    global CHAT_FLOOD
+    try:
+        all_chats = SESSION.query(FloodControl).all()
+        CHAT_FLOOD = {chat.chat_id: (None, DEF_COUNT, chat.limit) for chat in all_chats}
+    finally:
+        SESSION.close()
+
+
+__load_flood_settings()

Database/sql/approve_sql.py

@@ -0,0 +1,61 @@
+import threading
+
+from sqlalchemy import BigInteger, Column, String
+
+from Database.sql import BASE, SESSION
+
+
+class Approvals(BASE):
+    __tablename__ = "approval"
+    chat_id = Column(String(14), primary_key=True)
+    user_id = Column(BigInteger, primary_key=True)
+
+    def __init__(self, chat_id, user_id):
+        self.chat_id = str(chat_id)  # ensure string
+        self.user_id = user_id
+
+    def __repr__(self):
+        return "<Approve %s>" % self.user_id
+
+
+Approvals.__table__.create(checkfirst=True)
+
+APPROVE_INSERTION_LOCK = threading.RLock()
+
+
+def approve(chat_id, user_id):
+    with APPROVE_INSERTION_LOCK:
+        approve_user = Approvals(str(chat_id), user_id)
+        SESSION.add(approve_user)
+        SESSION.commit()
+
+
+def is_approved(chat_id, user_id):
+    try:
+        return SESSION.query(Approvals).get((str(chat_id), user_id))
+    finally:
+        SESSION.close()
+
+
+def disapprove(chat_id, user_id):
+    with APPROVE_INSERTION_LOCK:
+        disapprove_user = SESSION.query(Approvals).get((str(chat_id), user_id))
+        if disapprove_user:
+            SESSION.delete(disapprove_user)
+            SESSION.commit()
+            return True
+        else:
+            SESSION.close()
+            return False
+
+
+def list_approved(chat_id):
+    try:
+        return (
+            SESSION.query(Approvals)
+            .filter(Approvals.chat_id == str(chat_id))
+            .order_by(Approvals.user_id.asc())
+            .all()
+        )
+    finally:
+        SESSION.close()

Database/sql/blacklistusers_sql.py

@@ -0,0 +1,69 @@
+import threading
+
+from sqlalchemy import Column, String, UnicodeText
+
+from Database.sql import BASE, SESSION
+
+
+class BlacklistUsers(BASE):
+    __tablename__ = "blacklistusers"
+    user_id = Column(String(14), primary_key=True)
+    reason = Column(UnicodeText)
+
+    def __init__(self, user_id, reason=None):
+        self.user_id = user_id
+        self.reason = reason
+
+
+BlacklistUsers.__table__.create(checkfirst=True)
+
+BLACKLIST_LOCK = threading.RLock()
+BLACKLIST_USERS = set()
+
+
+def blacklist_user(user_id, reason=None):
+    with BLACKLIST_LOCK:
+        user = SESSION.query(BlacklistUsers).get(str(user_id))
+        if not user:
+            user = BlacklistUsers(str(user_id), reason)
+        else:
+            user.reason = reason
+
+        SESSION.add(user)
+        SESSION.commit()
+        __load_blacklist_userid_list()
+
+
+def unblacklist_user(user_id):
+    with BLACKLIST_LOCK:
+        user = SESSION.query(BlacklistUsers).get(str(user_id))
+        if user:
+            SESSION.delete(user)
+
+        SESSION.commit()
+        __load_blacklist_userid_list()
+
+
+def get_reason(user_id):
+    user = SESSION.query(BlacklistUsers).get(str(user_id))
+    rep = ""
+    if user:
+        rep = user.reason
+
+    SESSION.close()
+    return rep
+
+
+def is_user_blacklisted(user_id):
+    return user_id in BLACKLIST_USERS
+
+
+def __load_blacklist_userid_list():
+    global BLACKLIST_USERS
+    try:
+        BLACKLIST_USERS = {int(x.user_id) for x in SESSION.query(BlacklistUsers).all()}
+    finally:
+        SESSION.close()
+
+
+__load_blacklist_userid_list()

Database/sql/connection_sql.py

@@ -0,0 +1,204 @@
+import threading
+import time
+from typing import Union
+
+from sqlalchemy import BigInteger, Boolean, Column, String, UnicodeText
+
+from Database.sql import BASE, SESSION
+
+
+class ChatAccessConnectionSettings(BASE):
+    __tablename__ = "access_connection"
+    chat_id = Column(String(14), primary_key=True)
+    allow_connect_to_chat = Column(Boolean, default=True)
+
+    def __init__(self, chat_id, allow_connect_to_chat):
+        self.chat_id = str(chat_id)
+        self.allow_connect_to_chat = str(allow_connect_to_chat)
+
+    def __repr__(self):
+        return "<Chat access settings ({}) is {}>".format(
+            self.chat_id, self.allow_connect_to_chat
+        )
+
+
+class Connection(BASE):
+    __tablename__ = "connection"
+    user_id = Column(BigInteger, primary_key=True)
+    chat_id = Column(String(14))
+
+    def __init__(self, user_id, chat_id):
+        self.user_id = user_id
+        self.chat_id = str(chat_id)  # Ensure String
+
+
+class ConnectionHistory(BASE):
+    __tablename__ = "connection_history"
+    user_id = Column(BigInteger, primary_key=True)
+    chat_id = Column(String(14), primary_key=True)
+    chat_name = Column(UnicodeText)
+    conn_time = Column(BigInteger)
+
+    def __init__(self, user_id, chat_id, chat_name, conn_time):
+        self.user_id = user_id
+        self.chat_id = str(chat_id)
+        self.chat_name = str(chat_name)
+        self.conn_time = int(conn_time)
+
+    def __repr__(self):
+        return "<connection user {} history {}>".format(self.user_id, self.chat_id)
+
+
+ChatAccessConnectionSettings.__table__.create(checkfirst=True)
+Connection.__table__.create(checkfirst=True)
+ConnectionHistory.__table__.create(checkfirst=True)
+
+CHAT_ACCESS_LOCK = threading.RLock()
+CONNECTION_INSERTION_LOCK = threading.RLock()
+CONNECTION_HISTORY_LOCK = threading.RLock()
+
+HISTORY_CONNECT = {}
+
+
+def allow_connect_to_chat(chat_id: Union[str, int]) -> bool:
+    try:
+        chat_setting = SESSION.query(ChatAccessConnectionSettings).get(str(chat_id))
+        if chat_setting:
+            return chat_setting.allow_connect_to_chat
+        return False
+    finally:
+        SESSION.close()
+
+
+def set_allow_connect_to_chat(chat_id: Union[int, str], setting: bool):
+    with CHAT_ACCESS_LOCK:
+        chat_setting = SESSION.query(ChatAccessConnectionSettings).get(str(chat_id))
+        if not chat_setting:
+            chat_setting = ChatAccessConnectionSettings(chat_id, setting)
+
+        chat_setting.allow_connect_to_chat = setting
+        SESSION.add(chat_setting)
+        SESSION.commit()
+
+
+def connect(user_id, chat_id):
+    with CONNECTION_INSERTION_LOCK:
+        prev = SESSION.query(Connection).get((int(user_id)))
+        if prev:
+            SESSION.delete(prev)
+        connect_to_chat = Connection(int(user_id), chat_id)
+        SESSION.add(connect_to_chat)
+        SESSION.commit()
+        return True
+
+
+def get_connected_chat(user_id):
+    try:
+        return SESSION.query(Connection).get((int(user_id)))
+    finally:
+        SESSION.close()
+
+
+def curr_connection(chat_id):
+    try:
+        return SESSION.query(Connection).get((str(chat_id)))
+    finally:
+        SESSION.close()
+
+
+def disconnect(user_id):
+    with CONNECTION_INSERTION_LOCK:
+        disconnect = SESSION.query(Connection).get((int(user_id)))
+        if disconnect:
+            SESSION.delete(disconnect)
+            SESSION.commit()
+            return True
+        else:
+            SESSION.close()
+            return False
+
+
+def add_history_conn(user_id, chat_id, chat_name):
+    global HISTORY_CONNECT
+    with CONNECTION_HISTORY_LOCK:
+        conn_time = int(time.time())
+        if HISTORY_CONNECT.get(int(user_id)):
+            counting = (
+                SESSION.query(ConnectionHistory.user_id)
+                .filter(ConnectionHistory.user_id == str(user_id))
+                .count()
+            )
+            getchat_id = {}
+            for x in HISTORY_CONNECT[int(user_id)]:
+                getchat_id[HISTORY_CONNECT[int(user_id)][x]["chat_id"]] = x
+            if chat_id in getchat_id:
+                todeltime = getchat_id[str(chat_id)]
+                delold = SESSION.query(ConnectionHistory).get(
+                    (int(user_id), str(chat_id))
+                )
+                if delold:
+                    SESSION.delete(delold)
+                    HISTORY_CONNECT[int(user_id)].pop(todeltime)
+            elif counting >= 5:
+                todel = list(HISTORY_CONNECT[int(user_id)])
+                todel.reverse()
+                todel = todel[4:]
+                for x in todel:
+                    chat_old = HISTORY_CONNECT[int(user_id)][x]["chat_id"]
+                    delold = SESSION.query(ConnectionHistory).get(
+                        (int(user_id), str(chat_old))
+                    )
+                    if delold:
+                        SESSION.delete(delold)
+                        HISTORY_CONNECT[int(user_id)].pop(x)
+        else:
+            HISTORY_CONNECT[int(user_id)] = {}
+        delold = SESSION.query(ConnectionHistory).get((int(user_id), str(chat_id)))
+        if delold:
+            SESSION.delete(delold)
+        history = ConnectionHistory(int(user_id), str(chat_id), chat_name, conn_time)
+        SESSION.add(history)
+        SESSION.commit()
+        HISTORY_CONNECT[int(user_id)][conn_time] = {
+            "chat_name": chat_name,
+            "chat_id": str(chat_id),
+        }
+
+
+def get_history_conn(user_id):
+    if not HISTORY_CONNECT.get(int(user_id)):
+        HISTORY_CONNECT[int(user_id)] = {}
+    return HISTORY_CONNECT[int(user_id)]
+
+
+def clear_history_conn(user_id):
+    global HISTORY_CONNECT
+    todel = list(HISTORY_CONNECT[int(user_id)])
+    for x in todel:
+        chat_old = HISTORY_CONNECT[int(user_id)][x]["chat_id"]
+        delold = SESSION.query(ConnectionHistory).get((int(user_id), str(chat_old)))
+        if delold:
+            SESSION.delete(delold)
+            HISTORY_CONNECT[int(user_id)].pop(x)
+    SESSION.commit()
+    return True
+
+
+def __load_user_history():
+    global HISTORY_CONNECT
+    try:
+        qall = SESSION.query(ConnectionHistory).all()
+        HISTORY_CONNECT = {}
+        for x in qall:
+            check = HISTORY_CONNECT.get(x.user_id)
+            if check is None:
+                HISTORY_CONNECT[x.user_id] = {}
+            HISTORY_CONNECT[x.user_id][x.conn_time] = {
+                "chat_name": x.chat_name,
+                "chat_id": x.chat_id,
+            }
+    finally:
+        SESSION.close()
+
+
+__load_user_history()

Database/sql/cust_filters_sql.py

@@ -0,0 +1,299 @@
+import threading
+
+from sqlalchemy import Boolean, Column, Integer, String, UnicodeText, distinct, func
+
+from Database.sql import BASE, SESSION
+from Mikobot.plugins.helper_funcs.msg_types import Types
+
+
+class CustomFilters(BASE):
+    __tablename__ = "cust_filters"
+    chat_id = Column(String(14), primary_key=True)
+    keyword = Column(UnicodeText, primary_key=True, nullable=False)
+    reply = Column(UnicodeText, nullable=False)
+    reply_text = Column(UnicodeText)
+    file_type = Column(Integer, nullable=False, default=1)
+    file_id = Column(UnicodeText, default=None)
+    has_buttons = Column(Boolean, nullable=False, default=False)
+    # NOTE: Here for legacy purposes, to ensure older filters don't mess up.
+    has_media_spoiler = Column(Boolean, nullable=False, default=False)
+
+    def __init__(
+        self,
+        chat_id: int | str,
+        keyword: str,
+        reply: str,
+        reply_text: str,
+        has_buttons: bool,
+        has_media_spoiler: bool,
+        file_type: int,
+        file_id: str,
+    ):
+        self.chat_id = str(chat_id)  # ensure string
+        self.keyword = keyword
+        self.reply = reply
+        self.reply_text = reply_text
+        self.has_buttons = has_buttons
+        self.has_media_spoiler = has_media_spoiler
+        self.file_type = file_type
+        self.file_id = file_id
+
+    def __repr__(self):
+        return "<Filter for %s>" % self.chat_id
+
+    def __eq__(self, other):
+        return bool(
+            isinstance(other, CustomFilters)
+            and self.chat_id == other.chat_id
+            and self.keyword == other.keyword,
+        )
+
+
+class Buttons(BASE):
+    __tablename__ = "cust_filter_urls"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    chat_id = Column(String(14), primary_key=True)
+    keyword = Column(UnicodeText, primary_key=True)
+    name = Column(UnicodeText, nullable=False)
+    url = Column(UnicodeText, nullable=False)
+    same_line = Column(Boolean, default=False)
+
+    def __init__(self, chat_id, keyword, name, url, same_line=False):
+        self.chat_id = str(chat_id)
+        self.keyword = keyword
+        self.name = name
+        self.url = url
+        self.same_line = same_line
+
+
+CustomFilters.__table__.create(checkfirst=True)
+Buttons.__table__.create(checkfirst=True)
+
+CUST_FILT_LOCK = threading.RLock()
+BUTTON_LOCK = threading.RLock()
+CHAT_FILTERS = {}
+
+
+def get_all_filters():
+    try:
+        return SESSION.query(CustomFilters).all()
+    finally:
+        SESSION.close()
+
+
+def new_add_filter(
+    chat_id, keyword, reply_text, file_type, file_id, buttons, media_spoiler
+):
+    global CHAT_FILTERS
+
+    if buttons is None:
+        buttons = []
+
+    with CUST_FILT_LOCK:
+        prev = SESSION.query(CustomFilters).get((str(chat_id), keyword))
+        if prev:
+            with BUTTON_LOCK:
+                prev_buttons = (
+                    SESSION.query(Buttons)
+                    .filter(Buttons.chat_id == str(chat_id), Buttons.keyword == keyword)
+                    .all()
+                )
+                for btn in prev_buttons:
+                    SESSION.delete(btn)
+            SESSION.delete(prev)
+
+        filt = CustomFilters(
+            str(chat_id),
+            keyword,
+            reply="there is should be a new reply",
+            has_buttons=bool(buttons),
+            has_media_spoiler=media_spoiler,
+            reply_text=reply_text,
+            file_type=file_type.value,
+            file_id=file_id,
+        )
+
+        if keyword not in CHAT_FILTERS.get(str(chat_id), []):
+            CHAT_FILTERS[str(chat_id)] = sorted(
+                CHAT_FILTERS.get(str(chat_id), []) + [keyword],
+                key=lambda x: (-len(x), x),
+            )
+
+        SESSION.add(filt)
+        SESSION.commit()
+
+    for b_name, url, same_line in buttons:
+        add_note_button_to_db(chat_id, keyword, b_name, url, same_line)
+
+
+def remove_filter(chat_id, keyword):
+    global CHAT_FILTERS
+    with CUST_FILT_LOCK:
+        filt = SESSION.query(CustomFilters).get((str(chat_id), keyword))
+        if filt:
+            if keyword in CHAT_FILTERS.get(str(chat_id), []):  # Sanity check
+                CHAT_FILTERS.get(str(chat_id), []).remove(keyword)
+
+            with BUTTON_LOCK:
+                prev_buttons = (
+                    SESSION.query(Buttons)
+                    .filter(Buttons.chat_id == str(chat_id), Buttons.keyword == keyword)
+                    .all()
+                )
+                for btn in prev_buttons:
+                    SESSION.delete(btn)
+
+            SESSION.delete(filt)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def get_chat_triggers(chat_id):
+    return CHAT_FILTERS.get(str(chat_id), set())
+
+
+def get_chat_filters(chat_id):
+    try:
+        return (
+            SESSION.query(CustomFilters)
+            .filter(CustomFilters.chat_id == str(chat_id))
+            .order_by(func.length(CustomFilters.keyword).desc())
+            .order_by(CustomFilters.keyword.asc())
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def get_filter(chat_id, keyword) -> CustomFilters:
+    try:
+        return SESSION.query(CustomFilters).get((str(chat_id), keyword))
+    finally:
+        SESSION.close()
+
+
+def add_note_button_to_db(chat_id, keyword, b_name, url, same_line):
+    with BUTTON_LOCK:
+        button = Buttons(chat_id, keyword, b_name, url, same_line)
+        SESSION.add(button)
+        SESSION.commit()
+
+
+def get_buttons(chat_id, keyword):
+    try:
+        return (
+            SESSION.query(Buttons)
+            .filter(Buttons.chat_id == str(chat_id), Buttons.keyword == keyword)
+            .order_by(Buttons.id)
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def num_filters():
+    try:
+        return SESSION.query(CustomFilters).count()
+    finally:
+        SESSION.close()
+
+
+def num_chats():
+    try:
+        return SESSION.query(func.count(distinct(CustomFilters.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def __load_chat_filters():
+    global CHAT_FILTERS
+    try:
+        chats = SESSION.query(CustomFilters.chat_id).distinct().all()
+        for (chat_id,) in chats:  # remove tuple by ( ,)
+            CHAT_FILTERS[chat_id] = []
+
+        all_filters = SESSION.query(CustomFilters).all()
+        for x in all_filters:
+            CHAT_FILTERS[x.chat_id] += [x.keyword]
+
+        CHAT_FILTERS = {
+            x: sorted(set(y), key=lambda i: (-len(i), i))
+            for x, y in CHAT_FILTERS.items()
+        }
+
+    finally:
+        SESSION.close()
+
+
+# ONLY USE FOR MIGRATE OLD FILTERS TO NEW FILTERS
+def __migrate_filters():
+    try:
+        all_filters = SESSION.query(CustomFilters).distinct().all()
+        for x in all_filters:
+            if x.is_document:
+                file_type = Types.DOCUMENT
+            elif x.is_image:
+                file_type = Types.PHOTO
+            elif x.is_video:
+                file_type = Types.VIDEO
+            elif x.is_sticker:
+                file_type = Types.STICKER
+            elif x.is_audio:
+                file_type = Types.AUDIO
+            elif x.is_voice:
+                file_type = Types.VOICE
+            else:
+                file_type = Types.TEXT
+
+            if file_type == Types.TEXT:
+                filt = CustomFilters(
+                    str(x.chat_id),
+                    x.keyword,
+                    x.reply,
+                    file_type.value,
+                    None,
+                )
+            else:
+                filt = CustomFilters(
+                    str(x.chat_id),
+                    x.keyword,
+                    None,
+                    file_type.value,
+                    x.reply,
+                )
+
+            SESSION.add(filt)
+            SESSION.commit()
+
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with CUST_FILT_LOCK:
+        chat_filters = (
+            SESSION.query(CustomFilters)
+            .filter(CustomFilters.chat_id == str(old_chat_id))
+            .all()
+        )
+        for filt in chat_filters:
+            filt.chat_id = str(new_chat_id)
+        SESSION.commit()
+        old_filt = CHAT_FILTERS.get(str(old_chat_id))
+        if old_filt:
+            CHAT_FILTERS[str(new_chat_id)] = old_filt
+            del CHAT_FILTERS[str(old_chat_id)]
+
+        with BUTTON_LOCK:
+            chat_buttons = (
+                SESSION.query(Buttons).filter(Buttons.chat_id == str(old_chat_id)).all()
+            )
+            for btn in chat_buttons:
+                btn.chat_id = str(new_chat_id)
+            SESSION.commit()
+
+
+__load_chat_filters()

Database/sql/disable_sql.py

@@ -0,0 +1,105 @@
+import threading
+
+from sqlalchemy import Column, String, UnicodeText, distinct, func
+
+from Database.sql import BASE, SESSION
+
+
+class Disable(BASE):
+    __tablename__ = "disabled_commands"
+    chat_id = Column(String(14), primary_key=True)
+    command = Column(UnicodeText, primary_key=True)
+
+    def __init__(self, chat_id, command):
+        self.chat_id = chat_id
+        self.command = command
+
+    def __repr__(self):
+        return "Disabled cmd {} in {}".format(self.command, self.chat_id)
+
+
+Disable.__table__.create(checkfirst=True)
+DISABLE_INSERTION_LOCK = threading.RLock()
+
+DISABLED = {}
+
+
+def disable_command(chat_id, disable):
+    with DISABLE_INSERTION_LOCK:
+        disabled = SESSION.query(Disable).get((str(chat_id), disable))
+
+        if not disabled:
+            DISABLED.setdefault(str(chat_id), set()).add(disable)
+
+            disabled = Disable(str(chat_id), disable)
+            SESSION.add(disabled)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def enable_command(chat_id, enable):
+    with DISABLE_INSERTION_LOCK:
+        disabled = SESSION.query(Disable).get((str(chat_id), enable))
+
+        if disabled:
+            if enable in DISABLED.get(str(chat_id)):  # sanity check
+                DISABLED.setdefault(str(chat_id), set()).remove(enable)
+
+            SESSION.delete(disabled)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def is_command_disabled(chat_id, cmd):
+    return str(cmd).lower() in DISABLED.get(str(chat_id), set())
+
+
+def get_all_disabled(chat_id):
+    return DISABLED.get(str(chat_id), set())
+
+
+def num_chats():
+    try:
+        return SESSION.query(func.count(distinct(Disable.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def num_disabled():
+    try:
+        return SESSION.query(Disable).count()
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with DISABLE_INSERTION_LOCK:
+        chats = SESSION.query(Disable).filter(Disable.chat_id == str(old_chat_id)).all()
+        for chat in chats:
+            chat.chat_id = str(new_chat_id)
+            SESSION.add(chat)
+
+        if str(old_chat_id) in DISABLED:
+            DISABLED[str(new_chat_id)] = DISABLED.get(str(old_chat_id), set())
+
+        SESSION.commit()
+
+
+def __load_disabled_commands():
+    global DISABLED
+    try:
+        all_chats = SESSION.query(Disable).all()
+        for chat in all_chats:
+            DISABLED.setdefault(chat.chat_id, set()).add(chat.command)
+
+    finally:
+        SESSION.close()
+
+
+__load_disabled_commands()

Database/sql/global_bans_sql.py

@@ -0,0 +1,167 @@
+import threading
+
+from sqlalchemy import BigInteger, Boolean, Column, String, UnicodeText
+
+from Database.sql import BASE, SESSION
+
+
+class GloballyBannedUsers(BASE):
+    __tablename__ = "gbans"
+    user_id = Column(BigInteger, primary_key=True)
+    name = Column(UnicodeText, nullable=False)
+    reason = Column(UnicodeText)
+
+    def __init__(self, user_id, name, reason=None):
+        self.user_id = user_id
+        self.name = name
+        self.reason = reason
+
+    def __repr__(self):
+        return "<GBanned User {} ({})>".format(self.name, self.user_id)
+
+    def to_dict(self):
+        return {"user_id": self.user_id, "name": self.name, "reason": self.reason}
+
+
+class GbanSettings(BASE):
+    __tablename__ = "gban_settings"
+    chat_id = Column(String(14), primary_key=True)
+    setting = Column(Boolean, default=True, nullable=False)
+
+    def __init__(self, chat_id, enabled):
+        self.chat_id = str(chat_id)
+        self.setting = enabled
+
+    def __repr__(self):
+        return "<Gban setting {} ({})>".format(self.chat_id, self.setting)
+
+
+GloballyBannedUsers.__table__.create(checkfirst=True)
+GbanSettings.__table__.create(checkfirst=True)
+
+GBANNED_USERS_LOCK = threading.RLock()
+GBAN_SETTING_LOCK = threading.RLock()
+GBANNED_LIST = set()
+GBANSTAT_LIST = set()
+
+
+def gban_user(user_id, name, reason=None):
+    with GBANNED_USERS_LOCK:
+        user = SESSION.query(GloballyBannedUsers).get(user_id)
+        if not user:
+            user = GloballyBannedUsers(user_id, name, reason)
+        else:
+            user.name = name
+            user.reason = reason
+
+        SESSION.merge(user)
+        SESSION.commit()
+        __load_gbanned_userid_list()
+
+
+def update_gban_reason(user_id, name, reason=None):
+    with GBANNED_USERS_LOCK:
+        user = SESSION.query(GloballyBannedUsers).get(user_id)
+        if not user:
+            return None
+        old_reason = user.reason
+        user.name = name
+        user.reason = reason
+
+        SESSION.merge(user)
+        SESSION.commit()
+        return old_reason
+
+
+def ungban_user(user_id):
+    with GBANNED_USERS_LOCK:
+        user = SESSION.query(GloballyBannedUsers).get(user_id)
+        if user:
+            SESSION.delete(user)
+
+        SESSION.commit()
+        __load_gbanned_userid_list()
+
+
+def is_user_gbanned(user_id):
+    return user_id in GBANNED_LIST
+
+
+def get_gbanned_user(user_id):
+    try:
+        return SESSION.query(GloballyBannedUsers).get(user_id)
+    finally:
+        SESSION.close()
+
+
+def get_gban_list():
+    try:
+        return [x.to_dict() for x in SESSION.query(GloballyBannedUsers).all()]
+    finally:
+        SESSION.close()
+
+
+def enable_gbans(chat_id):
+    with GBAN_SETTING_LOCK:
+        chat = SESSION.query(GbanSettings).get(str(chat_id))
+        if not chat:
+            chat = GbanSettings(chat_id, True)
+
+        chat.setting = True
+        SESSION.add(chat)
+        SESSION.commit()
+        if str(chat_id) in GBANSTAT_LIST:
+            GBANSTAT_LIST.remove(str(chat_id))
+
+
+def disable_gbans(chat_id):
+    with GBAN_SETTING_LOCK:
+        chat = SESSION.query(GbanSettings).get(str(chat_id))
+        if not chat:
+            chat = GbanSettings(chat_id, False)
+
+        chat.setting = False
+        SESSION.add(chat)
+        SESSION.commit()
+        GBANSTAT_LIST.add(str(chat_id))
+
+
+def does_chat_gban(chat_id):
+    return str(chat_id) not in GBANSTAT_LIST
+
+
+def num_gbanned_users():
+    return len(GBANNED_LIST)
+
+
+def __load_gbanned_userid_list():
+    global GBANNED_LIST
+    try:
+        GBANNED_LIST = {x.user_id for x in SESSION.query(GloballyBannedUsers).all()}
+    finally:
+        SESSION.close()
+
+
+def __load_gban_stat_list():
+    global GBANSTAT_LIST
+    try:
+        GBANSTAT_LIST = {
+            x.chat_id for x in SESSION.query(GbanSettings).all() if not x.setting
+        }
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with GBAN_SETTING_LOCK:
+        chat = SESSION.query(GbanSettings).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = new_chat_id
+            SESSION.add(chat)
+
+        SESSION.commit()
+
+
+# Create in memory userid to avoid disk access
+__load_gbanned_userid_list()
+__load_gban_stat_list()

Database/sql/kuki_sql.py

@@ -0,0 +1,42 @@
+import threading
+
+from sqlalchemy import Column, String
+
+from Database.sql import BASE, SESSION
+
+
+class KukiChats(BASE):
+    __tablename__ = "kuki_chats"
+    chat_id = Column(String(14), primary_key=True)
+
+    def __init__(self, chat_id):
+        self.chat_id = chat_id
+
+
+KukiChats.__table__.create(checkfirst=True)
+INSERTION_LOCK = threading.RLock()
+
+
+def is_kuki(chat_id):
+    try:
+        chat = SESSION.query(KukiChats).get(str(chat_id))
+        return bool(chat)
+    finally:
+        SESSION.close()
+
+
+def set_kuki(chat_id):
+    with INSERTION_LOCK:
+        kukichat = SESSION.query(KukiChats).get(str(chat_id))
+        if not kukichat:
+            kukichat = KukiChats(str(chat_id))
+        SESSION.add(kukichat)
+        SESSION.commit()
+
+
+def rem_kuki(chat_id):
+    with INSERTION_LOCK:
+        kukichat = SESSION.query(KukiChats).get(str(chat_id))
+        if kukichat:
+            SESSION.delete(kukichat)
+        SESSION.commit()

Database/sql/log_channel_sql.py

@@ -0,0 +1,156 @@
+import threading
+import typing
+
+from sqlalchemy import BigInteger, Boolean, Column, String, distinct, func
+
+from Database.sql import BASE, SESSION
+
+
+class GroupLogs(BASE):
+    __tablename__ = "log_channels"
+    chat_id = Column(String(14), primary_key=True)
+    log_channel = Column(String(14), nullable=False)
+
+    def __init__(self, chat_id, log_channel):
+        self.chat_id = str(chat_id)
+        self.log_channel = str(log_channel)
+
+
+class LogChannelSettings(BASE):
+    __tablename__ = "log_channel_setting"
+    chat_id = Column(BigInteger, primary_key=True)
+    log_joins = Column(Boolean, default=True)
+    log_leave = Column(Boolean, default=True)
+    log_warn = Column(Boolean, default=True)
+    log_action = Column(Boolean, default=True)
+    # log_media = Column(Boolean)
+    log_report = Column(Boolean, default=True)
+
+    def __init__(
+        self,
+        chat_id: int,
+        log_join: bool,
+        log_leave: bool,
+        log_warn: bool,
+        log_action: bool,
+        log_report: bool,
+    ):
+        self.chat_id = chat_id
+        self.log_warn = log_warn
+        self.log_joins = log_join
+        self.log_leave = log_leave
+        self.log_report = log_report
+        self.log_action = log_action
+
+    def toggle_warn(self) -> bool:
+        self.log_warn = not self.log_warn
+        SESSION.commit()
+        return self.log_warn
+
+    def toggle_joins(self) -> bool:
+        self.log_joins = not self.log_joins
+        SESSION.commit()
+        return self.log_joins
+
+    def toggle_leave(self) -> bool:
+        self.log_leave = not self.log_leave
+        SESSION.commit()
+        return self.log_leave
+
+    def toggle_report(self) -> bool:
+        self.log_report = not self.log_report
+        SESSION.commit()
+        return self.log_report
+
+    def toggle_action(self) -> bool:
+        self.log_action = not self.log_action
+        SESSION.commit()
+        return self.log_action
+
+
+GroupLogs.__table__.create(checkfirst=True)
+LogChannelSettings.__table__.create(checkfirst=True)
+
+LOGS_INSERTION_LOCK = threading.RLock()
+LOG_SETTING_LOCK = threading.RLock()
+CHANNELS = {}
+
+
+def get_chat_setting(chat_id: int) -> typing.Optional[LogChannelSettings]:
+    with LOG_SETTING_LOCK:
+        return SESSION.query(LogChannelSettings).get(chat_id)
+
+
+def set_chat_setting(setting: LogChannelSettings):
+    with LOGS_INSERTION_LOCK:
+        res: LogChannelSettings = SESSION.query(LogChannelSettings).get(setting.chat_id)
+        if res:
+            res.log_warn = setting.log_warn
+            res.log_action = setting.log_action
+            res.log_report = setting.log_report
+            res.log_joins = setting.log_joins
+            res.log_leave = setting.log_leave
+        else:
+            SESSION.add(setting)
+    SESSION.commit()
+
+
+def set_chat_log_channel(chat_id, log_channel):
+    with LOGS_INSERTION_LOCK:
+        res = SESSION.query(GroupLogs).get(str(chat_id))
+        if res:
+            res.log_channel = log_channel
+        else:
+            res = GroupLogs(chat_id, log_channel)
+            SESSION.add(res)
+
+        CHANNELS[str(chat_id)] = log_channel
+        SESSION.commit()
+
+
+def get_chat_log_channel(chat_id):
+    return CHANNELS.get(str(chat_id))
+
+
+def stop_chat_logging(chat_id):
+    with LOGS_INSERTION_LOCK:
+        res = SESSION.query(GroupLogs).get(str(chat_id))
+        if res:
+            if str(chat_id) in CHANNELS:
+                del CHANNELS[str(chat_id)]
+
+            log_channel = res.log_channel
+            SESSION.delete(res)
+            SESSION.commit()
+            return log_channel
+
+
+def num_logchannels():
+    try:
+        return SESSION.query(func.count(distinct(GroupLogs.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with LOGS_INSERTION_LOCK:
+        chat = SESSION.query(GroupLogs).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = str(new_chat_id)
+            SESSION.add(chat)
+            if str(old_chat_id) in CHANNELS:
+                CHANNELS[str(new_chat_id)] = CHANNELS.get(str(old_chat_id))
+
+        SESSION.commit()
+
+
+def __load_log_channels():
+    global CHANNELS
+    try:
+        all_chats = SESSION.query(GroupLogs).all()
+        CHANNELS = {chat.chat_id: chat.log_channel for chat in all_chats}
+    finally:
+        SESSION.close()
+
+
+__load_log_channels()

Database/sql/rules_sql.py

@@ -0,0 +1,58 @@
+import threading
+
+from sqlalchemy import Column, String, UnicodeText, distinct, func
+
+from Database.sql import BASE, SESSION
+
+
+class Rules(BASE):
+    __tablename__ = "rules"
+    chat_id = Column(String(14), primary_key=True)
+    rules = Column(UnicodeText, default="")
+
+    def __init__(self, chat_id):
+        self.chat_id = chat_id
+
+    def __repr__(self):
+        return "<Chat {} rules: {}>".format(self.chat_id, self.rules)
+
+
+Rules.__table__.create(checkfirst=True)
+
+INSERTION_LOCK = threading.RLock()
+
+
+def set_rules(chat_id, rules_text):
+    with INSERTION_LOCK:
+        rules = SESSION.query(Rules).get(str(chat_id))
+        if not rules:
+            rules = Rules(str(chat_id))
+        rules.rules = rules_text
+
+        SESSION.add(rules)
+        SESSION.commit()
+
+
+def get_rules(chat_id):
+    rules = SESSION.query(Rules).get(str(chat_id))
+    ret = ""
+    if rules:
+        ret = rules.rules
+
+    SESSION.close()
+    return ret
+
+
+def num_chats():
+    try:
+        return SESSION.query(func.count(distinct(Rules.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with INSERTION_LOCK:
+        chat = SESSION.query(Rules).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = str(new_chat_id)
+        SESSION.commit()

Database/sql/userinfo_sql.py

@@ -0,0 +1,76 @@
+import threading
+
+from sqlalchemy import BigInteger, Column, UnicodeText
+
+from Database.sql import BASE, SESSION
+
+
+class UserInfo(BASE):
+    __tablename__ = "userinfo"
+    user_id = Column(BigInteger, primary_key=True)
+    info = Column(UnicodeText)
+
+    def __init__(self, user_id, info):
+        self.user_id = user_id
+        self.info = info
+
+    def __repr__(self):
+        return "<User info %d>" % self.user_id
+
+
+class UserBio(BASE):
+    __tablename__ = "userbio"
+    user_id = Column(BigInteger, primary_key=True)
+    bio = Column(UnicodeText)
+
+    def __init__(self, user_id, bio):
+        self.user_id = user_id
+        self.bio = bio
+
+    def __repr__(self):
+        return "<User info %d>" % self.user_id
+
+
+UserInfo.__table__.create(checkfirst=True)
+UserBio.__table__.create(checkfirst=True)
+
+INSERTION_LOCK = threading.RLock()
+
+
+def get_user_me_info(user_id):
+    userinfo = SESSION.query(UserInfo).get(user_id)
+    SESSION.close()
+    if userinfo:
+        return userinfo.info
+    return None
+
+
+def set_user_me_info(user_id, info):
+    with INSERTION_LOCK:
+        userinfo = SESSION.query(UserInfo).get(user_id)
+        if userinfo:
+            userinfo.info = info
+        else:
+            userinfo = UserInfo(user_id, info)
+        SESSION.add(userinfo)
+        SESSION.commit()
+
+
+def get_user_bio(user_id):
+    userbio = SESSION.query(UserBio).get(user_id)
+    SESSION.close()
+    if userbio:
+        return userbio.bio
+    return None
+
+
+def set_user_bio(user_id, bio):
+    with INSERTION_LOCK:
+        userbio = SESSION.query(UserBio).get(user_id)
+        if userbio:
+            userbio.bio = bio
+        else:
+            userbio = UserBio(user_id, bio)
+
+        SESSION.add(userbio)
+        SESSION.commit()

Database/sql/users_sql.py

@@ -0,0 +1,235 @@
+import threading
+
+from sqlalchemy import (
+    BigInteger,
+    Column,
+    ForeignKey,
+    Integer,
+    String,
+    UnicodeText,
+    UniqueConstraint,
+    func,
+)
+
+from Database.sql import BASE, SESSION
+from Mikobot import dispatcher
+
+
+class Users(BASE):
+    __tablename__ = "users"
+    user_id = Column(BigInteger, primary_key=True)
+    username = Column(UnicodeText)
+
+    def __init__(self, user_id, username=None):
+        self.user_id = user_id
+        self.username = username
+
+    def __repr__(self):
+        return "<User {} ({})>".format(self.username, self.user_id)
+
+
+class Chats(BASE):
+    __tablename__ = "chats"
+    chat_id = Column(String(14), primary_key=True)
+    chat_name = Column(UnicodeText, nullable=False)
+
+    def __init__(self, chat_id, chat_name):
+        self.chat_id = str(chat_id)
+        self.chat_name = chat_name
+
+    def __repr__(self):
+        return "<Chat {} ({})>".format(self.chat_name, self.chat_id)
+
+
+class ChatMembers(BASE):
+    __tablename__ = "chat_members"
+    priv_chat_id = Column(Integer, primary_key=True)
+    # NOTE: Use dual primary key instead of private primary key?
+    chat = Column(
+        String(14),
+        ForeignKey("chats.chat_id", onupdate="CASCADE", ondelete="CASCADE"),
+        nullable=False,
+    )
+    user = Column(
+        BigInteger,
+        ForeignKey("users.user_id", onupdate="CASCADE", ondelete="CASCADE"),
+        nullable=False,
+    )
+    __table_args__ = (UniqueConstraint("chat", "user", name="_chat_members_uc"),)
+
+    def __init__(self, chat, user):
+        self.chat = chat
+        self.user = user
+
+    def __repr__(self):
+        return "<Chat user {} ({}) in chat {} ({})>".format(
+            self.user.username,
+            self.user.user_id,
+            self.chat.chat_name,
+            self.chat.chat_id,
+        )
+
+
+Users.__table__.create(checkfirst=True)
+Chats.__table__.create(checkfirst=True)
+ChatMembers.__table__.create(checkfirst=True)
+
+INSERTION_LOCK = threading.RLock()
+
+
+def ensure_bot_in_db():
+    with INSERTION_LOCK:
+        bot = Users(dispatcher.bot.id, dispatcher.bot.username)
+        SESSION.merge(bot)
+        SESSION.commit()
+
+
+def update_user(user_id, username, chat_id=None, chat_name=None):
+    with INSERTION_LOCK:
+        user = SESSION.query(Users).get(user_id)
+        if not user:
+            user = Users(user_id, username)
+            SESSION.add(user)
+            SESSION.flush()
+        else:
+            user.username = username
+
+        if not chat_id or not chat_name:
+            SESSION.commit()
+            return
+
+        chat = SESSION.query(Chats).get(str(chat_id))
+        if not chat:
+            chat = Chats(str(chat_id), chat_name)
+            SESSION.add(chat)
+            SESSION.flush()
+
+        else:
+            chat.chat_name = chat_name
+
+        member = (
+            SESSION.query(ChatMembers)
+            .filter(ChatMembers.chat == chat.chat_id, ChatMembers.user == user.user_id)
+            .first()
+        )
+        if not member:
+            chat_member = ChatMembers(chat.chat_id, user.user_id)
+            SESSION.add(chat_member)
+
+        SESSION.commit()
+
+
+def get_userid_by_name(username):
+    try:
+        return (
+            SESSION.query(Users)
+            .filter(func.lower(Users.username) == username.lower())
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def get_name_by_userid(user_id):
+    try:
+        return SESSION.query(Users).get(Users.user_id == int(user_id)).first()
+    finally:
+        SESSION.close()
+
+
+def get_chat_members(chat_id):
+    try:
+        return SESSION.query(ChatMembers).filter(ChatMembers.chat == str(chat_id)).all()
+    finally:
+        SESSION.close()
+
+
+def get_all_chats():
+    try:
+        return SESSION.query(Chats).all()
+    finally:
+        SESSION.close()
+
+
+def get_all_users():
+    try:
+        return SESSION.query(Users).all()
+    finally:
+        SESSION.close()
+
+
+def get_user_num_chats(user_id):
+    try:
+        return (
+            SESSION.query(ChatMembers).filter(ChatMembers.user == int(user_id)).count()
+        )
+    finally:
+        SESSION.close()
+
+
+def get_user_com_chats(user_id):
+    try:
+        chat_members = (
+            SESSION.query(ChatMembers).filter(ChatMembers.user == int(user_id)).all()
+        )
+        return [i.chat for i in chat_members]
+    finally:
+        SESSION.close()
+
+
+def num_chats():
+    try:
+        return SESSION.query(Chats).count()
+    finally:
+        SESSION.close()
+
+
+def num_users():
+    try:
+        return SESSION.query(Users).count()
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with INSERTION_LOCK:
+        chat = SESSION.query(Chats).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = str(new_chat_id)
+        SESSION.commit()
+
+        chat_members = (
+            SESSION.query(ChatMembers)
+            .filter(ChatMembers.chat == str(old_chat_id))
+            .all()
+        )
+        for member in chat_members:
+            member.chat = str(new_chat_id)
+        SESSION.commit()
+
+
+ensure_bot_in_db()
+
+
+def del_user(user_id):
+    with INSERTION_LOCK:
+        curr = SESSION.query(Users).get(user_id)
+        if curr:
+            SESSION.delete(curr)
+            SESSION.commit()
+            return True
+
+        ChatMembers.query.filter(ChatMembers.user == user_id).delete()
+        SESSION.commit()
+        SESSION.close()
+    return False
+
+
+def rem_chat(chat_id):
+    with INSERTION_LOCK:
+        chat = SESSION.query(Chats).get(str(chat_id))
+        if chat:
+            SESSION.delete(chat)
+            SESSION.commit()
+        else:
+            SESSION.close()

Database/sql/welcome_sql.py

@@ -0,0 +1,428 @@
+import random
+import threading
+from typing import Union
+
+from sqlalchemy import BigInteger, Boolean, Column, Integer, String, UnicodeText
+
+from Database.sql import BASE, SESSION
+from Mikobot.plugins.helper_funcs.msg_types import Types
+
+DEFAULT_WELCOME = "Hey {first}, how are you?"
+DEFAULT_GOODBYE = "Nice knowing you!"
+
+DEFAULT_WELCOME_MESSAGES = [
+    "{first} is here!",  # Discord welcome messages copied
+    "Ready player {first}",
+    "Welcome bro {first}",
+]
+
+DEFAULT_GOODBYE_MESSAGES = [
+    "{first} will be missed.",
+    "{first} when back ?",
+]
+# Line 111 to 152 are references from https://bindingofisaac.fandom.com/wiki/Fortune_Telling_Machine
+
+
+class Welcome(BASE):
+    __tablename__ = "welcome_pref"
+    chat_id = Column(String(14), primary_key=True)
+    should_welcome = Column(Boolean, default=True)
+    should_goodbye = Column(Boolean, default=True)
+    custom_content = Column(UnicodeText, default=None)
+
+    custom_welcome = Column(
+        UnicodeText,
+        default=random.choice(DEFAULT_WELCOME_MESSAGES),
+    )
+    welcome_type = Column(Integer, default=Types.TEXT.value)
+
+    custom_leave = Column(UnicodeText, default=random.choice(DEFAULT_GOODBYE_MESSAGES))
+    leave_type = Column(Integer, default=Types.TEXT.value)
+
+    clean_welcome = Column(BigInteger)
+
+    def __init__(self, chat_id, should_welcome=True, should_goodbye=True):
+        self.chat_id = chat_id
+        self.should_welcome = should_welcome
+        self.should_goodbye = should_goodbye
+
+    def __repr__(self):
+        return "<Chat {} should Welcome new users: {}>".format(
+            self.chat_id,
+            self.should_welcome,
+        )
+
+
+class WelcomeButtons(BASE):
+    __tablename__ = "welcome_urls"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    chat_id = Column(String(14), primary_key=True)
+    name = Column(UnicodeText, nullable=False)
+    url = Column(UnicodeText, nullable=False)
+    same_line = Column(Boolean, default=False)
+
+    def __init__(self, chat_id, name, url, same_line=False):
+        self.chat_id = str(chat_id)
+        self.name = name
+        self.url = url
+        self.same_line = same_line
+
+
+class GoodbyeButtons(BASE):
+    __tablename__ = "leave_urls"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    chat_id = Column(String(14), primary_key=True)
+    name = Column(UnicodeText, nullable=False)
+    url = Column(UnicodeText, nullable=False)
+    same_line = Column(Boolean, default=False)
+
+    def __init__(self, chat_id, name, url, same_line=False):
+        self.chat_id = str(chat_id)
+        self.name = name
+        self.url = url
+        self.same_line = same_line
+
+
+class WelcomeMute(BASE):
+    __tablename__ = "welcome_mutes"
+    chat_id = Column(String(14), primary_key=True)
+    welcomemutes = Column(UnicodeText, default=False)
+
+    def __init__(self, chat_id, welcomemutes):
+        self.chat_id = str(chat_id)  # ensure string
+        self.welcomemutes = welcomemutes
+
+
+class WelcomeMuteUsers(BASE):
+    __tablename__ = "human_checks"
+    user_id = Column(BigInteger, primary_key=True)
+    chat_id = Column(String(14), primary_key=True)
+    human_check = Column(Boolean)
+
+    def __init__(self, user_id, chat_id, human_check):
+        self.user_id = user_id  # ensure string
+        self.chat_id = str(chat_id)
+        self.human_check = human_check
+
+
+class CleanServiceSetting(BASE):
+    __tablename__ = "clean_service"
+    chat_id = Column(String(14), primary_key=True)
+    clean_service = Column(Boolean, default=True)
+
+    def __init__(self, chat_id):
+        self.chat_id = str(chat_id)
+
+    def __repr__(self):
+        return "<Chat used clean service ({})>".format(self.chat_id)
+
+
+Welcome.__table__.create(checkfirst=True)
+WelcomeButtons.__table__.create(checkfirst=True)
+GoodbyeButtons.__table__.create(checkfirst=True)
+WelcomeMute.__table__.create(checkfirst=True)
+WelcomeMuteUsers.__table__.create(checkfirst=True)
+CleanServiceSetting.__table__.create(checkfirst=True)
+
+INSERTION_LOCK = threading.RLock()
+WELC_BTN_LOCK = threading.RLock()
+LEAVE_BTN_LOCK = threading.RLock()
+WM_LOCK = threading.RLock()
+CS_LOCK = threading.RLock()
+
+
+def welcome_mutes(chat_id):
+    try:
+        welcomemutes = SESSION.query(WelcomeMute).get(str(chat_id))
+        if welcomemutes:
+            return welcomemutes.welcomemutes
+        return False
+    finally:
+        SESSION.close()
+
+
+def set_welcome_mutes(chat_id, welcomemutes):
+    with WM_LOCK:
+        prev = SESSION.query(WelcomeMute).get((str(chat_id)))
+        if prev:
+            SESSION.delete(prev)
+        welcome_m = WelcomeMute(str(chat_id), welcomemutes)
+        SESSION.add(welcome_m)
+        SESSION.commit()
+
+
+def set_human_checks(user_id, chat_id):
+    with INSERTION_LOCK:
+        human_check = SESSION.query(WelcomeMuteUsers).get((user_id, str(chat_id)))
+        if not human_check:
+            human_check = WelcomeMuteUsers(user_id, str(chat_id), True)
+
+        else:
+            human_check.human_check = True
+
+        SESSION.add(human_check)
+        SESSION.commit()
+
+        return human_check
+
+
+def get_human_checks(user_id, chat_id):
+    try:
+        human_check = SESSION.query(WelcomeMuteUsers).get((user_id, str(chat_id)))
+        if not human_check:
+            return None
+        human_check = human_check.human_check
+        return human_check
+    finally:
+        SESSION.close()
+
+
+def get_welc_mutes_pref(chat_id):
+    welcomemutes = SESSION.query(WelcomeMute).get(str(chat_id))
+    SESSION.close()
+
+    if welcomemutes:
+        return welcomemutes.welcomemutes
+
+    return False
+
+
+def get_welc_pref(chat_id):
+    welc = SESSION.query(Welcome).get(str(chat_id))
+    SESSION.close()
+    if welc:
+        return (
+            welc.should_welcome,
+            welc.custom_welcome,
+            welc.custom_content,
+            welc.welcome_type,
+        )
+
+    else:
+        # Welcome by default.
+        return True, DEFAULT_WELCOME, None, Types.TEXT
+
+
+def get_gdbye_pref(chat_id):
+    welc = SESSION.query(Welcome).get(str(chat_id))
+    SESSION.close()
+    if welc:
+        return welc.should_goodbye, welc.custom_leave, welc.leave_type
+    else:
+        # Welcome by default.
+        return True, DEFAULT_GOODBYE, Types.TEXT
+
+
+def set_clean_welcome(chat_id, clean_welcome):
+    with INSERTION_LOCK:
+        curr = SESSION.query(Welcome).get(str(chat_id))
+        if not curr:
+            curr = Welcome(str(chat_id))
+
+        curr.clean_welcome = int(clean_welcome)
+
+        SESSION.add(curr)
+        SESSION.commit()
+
+
+def get_clean_pref(chat_id):
+    welc = SESSION.query(Welcome).get(str(chat_id))
+    SESSION.close()
+
+    if welc:
+        return welc.clean_welcome
+
+    return False
+
+
+def set_welc_preference(chat_id, should_welcome):
+    with INSERTION_LOCK:
+        curr = SESSION.query(Welcome).get(str(chat_id))
+        if not curr:
+            curr = Welcome(str(chat_id), should_welcome=should_welcome)
+        else:
+            curr.should_welcome = should_welcome
+
+        SESSION.add(curr)
+        SESSION.commit()
+
+
+def set_gdbye_preference(chat_id, should_goodbye):
+    with INSERTION_LOCK:
+        curr = SESSION.query(Welcome).get(str(chat_id))
+        if not curr:
+            curr = Welcome(str(chat_id), should_goodbye=should_goodbye)
+        else:
+            curr.should_goodbye = should_goodbye
+
+        SESSION.add(curr)
+        SESSION.commit()
+
+
+def set_custom_welcome(
+    chat_id,
+    custom_content,
+    custom_welcome,
+    welcome_type,
+    buttons=None,
+):
+    if buttons is None:
+        buttons = []
+
+    with INSERTION_LOCK:
+        welcome_settings = SESSION.query(Welcome).get(str(chat_id))
+        if not welcome_settings:
+            welcome_settings = Welcome(str(chat_id), True)
+
+        if custom_welcome or custom_content:
+            welcome_settings.custom_content = custom_content
+            welcome_settings.custom_welcome = custom_welcome
+            welcome_settings.welcome_type = welcome_type.value
+
+        else:
+            welcome_settings.custom_welcome = DEFAULT_WELCOME
+            welcome_settings.welcome_type = Types.TEXT.value
+
+        SESSION.add(welcome_settings)
+
+        with WELC_BTN_LOCK:
+            prev_buttons = (
+                SESSION.query(WelcomeButtons)
+                .filter(WelcomeButtons.chat_id == str(chat_id))
+                .all()
+            )
+            for btn in prev_buttons:
+                SESSION.delete(btn)
+
+            for b_name, url, same_line in buttons:
+                button = WelcomeButtons(chat_id, b_name, url, same_line)
+                SESSION.add(button)
+
+        SESSION.commit()
+
+
+def get_custom_welcome(chat_id):
+    welcome_settings = SESSION.query(Welcome).get(str(chat_id))
+    ret = DEFAULT_WELCOME
+    if welcome_settings and welcome_settings.custom_welcome:
+        ret = welcome_settings.custom_welcome
+
+    SESSION.close()
+    return ret
+
+
+def set_custom_gdbye(chat_id, custom_goodbye, goodbye_type, buttons=None):
+    if buttons is None:
+        buttons = []
+
+    with INSERTION_LOCK:
+        welcome_settings = SESSION.query(Welcome).get(str(chat_id))
+        if not welcome_settings:
+            welcome_settings = Welcome(str(chat_id), True)
+
+        if custom_goodbye:
+            welcome_settings.custom_leave = custom_goodbye
+            welcome_settings.leave_type = goodbye_type.value
+
+        else:
+            welcome_settings.custom_leave = DEFAULT_GOODBYE
+            welcome_settings.leave_type = Types.TEXT.value
+
+        SESSION.add(welcome_settings)
+
+        with LEAVE_BTN_LOCK:
+            prev_buttons = (
+                SESSION.query(GoodbyeButtons)
+                .filter(GoodbyeButtons.chat_id == str(chat_id))
+                .all()
+            )
+            for btn in prev_buttons:
+                SESSION.delete(btn)
+
+            for b_name, url, same_line in buttons:
+                button = GoodbyeButtons(chat_id, b_name, url, same_line)
+                SESSION.add(button)
+
+        SESSION.commit()
+
+
+def get_custom_gdbye(chat_id):
+    welcome_settings = SESSION.query(Welcome).get(str(chat_id))
+    ret = DEFAULT_GOODBYE
+    if welcome_settings and welcome_settings.custom_leave:
+        ret = welcome_settings.custom_leave
+
+    SESSION.close()
+    return ret
+
+
+def get_welc_buttons(chat_id):
+    try:
+        return (
+            SESSION.query(WelcomeButtons)
+            .filter(WelcomeButtons.chat_id == str(chat_id))
+            .order_by(WelcomeButtons.id)
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def get_gdbye_buttons(chat_id):
+    try:
+        return (
+            SESSION.query(GoodbyeButtons)
+            .filter(GoodbyeButtons.chat_id == str(chat_id))
+            .order_by(GoodbyeButtons.id)
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def clean_service(chat_id: Union[str, int]) -> bool:
+    try:
+        chat_setting = SESSION.query(CleanServiceSetting).get(str(chat_id))
+        if chat_setting:
+            return chat_setting.clean_service
+        return False
+    finally:
+        SESSION.close()
+
+
+def set_clean_service(chat_id: Union[int, str], setting: bool):
+    with CS_LOCK:
+        chat_setting = SESSION.query(CleanServiceSetting).get(str(chat_id))
+        if not chat_setting:
+            chat_setting = CleanServiceSetting(chat_id)
+
+        chat_setting.clean_service = setting
+        SESSION.add(chat_setting)
+        SESSION.commit()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with INSERTION_LOCK:
+        chat = SESSION.query(Welcome).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = str(new_chat_id)
+
+        with WELC_BTN_LOCK:
+            chat_buttons = (
+                SESSION.query(WelcomeButtons)
+                .filter(WelcomeButtons.chat_id == str(old_chat_id))
+                .all()
+            )
+            for btn in chat_buttons:
+                btn.chat_id = str(new_chat_id)
+
+        with LEAVE_BTN_LOCK:
+            chat_buttons = (
+                SESSION.query(GoodbyeButtons)
+                .filter(GoodbyeButtons.chat_id == str(old_chat_id))
+                .all()
+            )
+            for btn in chat_buttons:
+                btn.chat_id = str(new_chat_id)
+
+        SESSION.commit()

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11.6
+
+WORKDIR /root/Mikobot
+
+COPY . .
+
+RUN apt-get install -y ffmpeg python3-pip curl
+RUN pip3 install --upgrade pip setuptools
+
+RUN pip install -U -r requirements.txt
+
+CMD python3 -m Mikobot

Infamous/karma.py

@@ -0,0 +1,105 @@
+# https://github.com/Infamous-Hydra/YaeMiko
+# https://github.com/Team-ProjectCodeX
+# https://t.me/O_okarma
+
+# <============================================== IMPORTS =========================================================>
+from pyrogram.types import InlineKeyboardButton as ib
+from telegram import InlineKeyboardButton
+
+from Mikobot import BOT_USERNAME, OWNER_ID, SUPPORT_CHAT
+
+# <============================================== CONSTANTS =========================================================>
+START_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",
+]
+
+HEY_IMG = "https://telegra.ph/file/33a8d97739a2a4f81ddde.jpg"
+
+ALIVE_ANIMATION = [
+    "https://telegra.ph//file/f9e2b9cdd9324fc39970a.mp4",
+    "https://telegra.ph//file/8d4d7d06efebe2f8becd0.mp4",
+    "https://telegra.ph//file/c4c2759c5fc04cefd207a.mp4",
+    "https://telegra.ph//file/b1fa6609b1c4807255927.mp4",
+    "https://telegra.ph//file/f3c7147da6511fbe27c25.mp4",
+    "https://telegra.ph//file/39071b73c02e3ff5945ca.mp4",
+    "https://telegra.ph//file/8d4d7d06efebe2f8becd0.mp4",
+    "https://telegra.ph//file/6efdd8e28756bc2f6e53e.mp4",
+]
+
+BAN_GIFS = [
+    "https://telegra.ph//file/85ac1ab12c833afa1a5dd.mp4",
+]
+
+
+KICK_GIFS = [
+    "https://telegra.ph//file/79a6c527e6e6d530bcdc8.mp4",
+]
+
+
+MUTE_GIFS = [
+    "https://telegra.ph//file/b4faf6e390d72d286abdf.mp4",
+]
+
+FIRST_PART_TEXT = "✨ *ʜᴇʟʟᴏ* `{}` . . ."
+
+PM_START_TEXT = "✨ *ɪ ᴀᴍ ᴍɪᴋᴏ, ᴀ ɢᴇɴꜱʜɪɴ ɪᴍᴘᴀᴄᴛ ᴛʜᴇᴍᴇᴅ ʀᴏʙᴏᴛ ᴡʜɪᴄʜ ᴄᴀɴ ʜᴇʟᴘ ʏᴏᴜ ᴛᴏ ᴍᴀɴᴀɢᴇ ᴀɴᴅ ꜱᴇᴄᴜʀᴇ ʏᴏᴜʀ ɢʀᴏᴜᴘ ᴡɪᴛʜ ʜᴜɢᴇ ɢʀᴏᴜᴘ ᴍᴀɴᴀɢᴇᴍᴇɴᴛ*"
+
+START_BTN = [
+    [
+        InlineKeyboardButton(
+            text="⇦ ADD ME ⇨",
+            url=f"https://t.me/{BOT_USERNAME}?startgroup=true",
+        ),
+    ],
+    [
+        InlineKeyboardButton(text="HELP", callback_data="help_back"),
+    ],
+    [
+        InlineKeyboardButton(text="DETAILS", callback_data="Miko_"),
+        InlineKeyboardButton(text="AI", callback_data="ai_handler"),
+        InlineKeyboardButton(text="SOURCE", callback_data="git_source"),
+    ],
+    [
+        InlineKeyboardButton(text="CREATOR", url=f"tg://user?id={OWNER_ID}"),
+    ],
+]
+
+GROUP_START_BTN = [
+    [
+        InlineKeyboardButton(
+            text="⇦ ADD ME ⇨",
+            url=f"https://t.me/{BOT_USERNAME}?startgroup=true",
+        ),
+    ],
+    [
+        InlineKeyboardButton(text="SUPPORT", url=f"https://t.me/{SUPPORT_CHAT}"),
+        InlineKeyboardButton(text="CREATOR", url=f"tg://user?id={OWNER_ID}"),
+    ],
+]
+
+ALIVE_BTN = [
+    [
+        ib(text="UPDATES", url="https://t.me/Hydra_Updates"),
+        ib(text="SUPPORT", url="https://t.me/hydraXsupport"),
+    ],
+    [
+        ib(
+            text="⇦ ADD ME ⇨",
+            url=f"https://t.me/{BOT_USERNAME}?startgroup=true",
+        ),
+    ],
+]
+
+HELP_STRINGS = """
+🫧 *Yae-Miko* 🫧
+
+☉ *Here, you will find a list of all the available commands.*
+
+ᴀʟʟ ᴄᴏᴍᴍᴀɴᴅs ᴄᴀɴ ʙᴇ ᴜsᴇᴅ ᴡɪᴛʜ : /
+"""

Infamous/temp.py

@@ -0,0 +1,122 @@
+# <============================================== IMPORTS =========================================================>
+import asyncio
+import os
+from logging import getLogger
+from typing import Union
+
+from pymongo import MongoClient
+from pyrogram.errors import (
+    FloodWait,
+    InputUserDeactivated,
+    PeerIdInvalid,
+    UserIsBlocked,
+)
+from pyrogram.types import Message
+
+from Mikobot import DB_NAME, MONGO_DB_URI
+
+client = MongoClient(MONGO_DB_URI)
+dbname = client[DB_NAME]
+
+LOGGER = getLogger(__name__)
+BANNED = {}
+# <=======================================================================================================>
+
+
+# <=================================================== CLASS ====================================================>
+# temp db for banned
+class temp(object):
+    BANNED_USERS = []
+    BANNED_CHATS = []
+    ME = None
+    CURRENT = int(os.environ.get("SKIP", 2))
+    CANCEL = False
+    MELCOW = {}
+    U_NAME = None
+    B_NAME = None
+
+
+# <=======================================================================================================>
+
+
+# <================================================ FUNCTION =======================================================>
+def broadcast_messages(user_id, message):
+    try:
+        message.copy(chat_id=user_id)
+        return True, "Succes"
+    except FloodWait as e:
+        asyncio.sleep(e.x)
+        return broadcast_messages(user_id, message)
+    except InputUserDeactivated:
+        dbname.delete_user(int(user_id))
+        LOGGER.info(f"{user_id}-Removed from Database, since deleted account.")
+        return False, "Deleted"
+    except UserIsBlocked:
+        LOGGER.info(f"{user_id} -Blocked the bot.")
+        return False, "Blocked"
+    except PeerIdInvalid:
+        dbname.delete_user(int(user_id))
+        LOGGER.info(f"{user_id} - PeerIdInvalid")
+        return False, "Error"
+    except Exception:
+        return False, "Error"
+
+
+def get_size(size):
+    """Get size in readable format"""
+
+    units = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB"]
+    size = float(size)
+    i = 0
+    while size >= 1024.0 and i < len(units):
+        i += 1
+        size /= 1024.0
+    return "%.2f %s" % (size, units[i])
+
+
+def get_file_id(msg: Message):
+    if msg.media:
+        for message_type in (
+            "photo",
+            "animation",
+            "audio",
+            "document",
+            "video",
+            "video_note",
+            "voice",
+            "sticker",
+        ):
+            if obj := getattr(msg, message_type):
+                setattr(obj, "message_type", message_type)
+                return obj
+
+
+def extract_user(message: Message) -> Union[int, str]:
+    """extracts the user from a message"""
+    # https://github.com/SpEcHiDe/PyroGramBot/blob/f30e2cca12002121bad1982f68cd0ff9814ce027/pyrobot/helper_functions/extract_user.py#L7
+    user_id = None
+    user_first_name = None
+    if message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+        user_first_name = message.reply_to_message.from_user.first_name
+
+    elif len(message.command) > 1:
+        if len(message.entities) > 1 and message.entities[1].type == "text_mention":
+            required_entity = message.entities[1]
+            user_id = required_entity.user.id
+            user_first_name = required_entity.user.first_name
+        else:
+            user_id = message.command[1]
+            # don't want to make a request -_-
+            user_first_name = user_id
+        try:
+            user_id = int(user_id)
+        except ValueError:
+            pass
+    else:
+        user_id = message.from_user.id
+        user_first_name = message.from_user.first_name
+    return (user_id, user_first_name)
+
+
+# <================================================ END =======================================================>

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Infamous-Hydra & ProjectCodeX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Mikobot/__init__.py

@@ -0,0 +1,254 @@
+# 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
+    BAN_STICKER = Config.BAN_STICKER
+    MESSAGE_DUMP = Config.MESSAGE_DUMP
+    SUPPORT_ID = Config.SUPPORT_ID
+    DEL_CMDS = Config.DEL_CMDS
+    EVENT_LOGS = Config.EVENT_LOGS
+    INFOPIC = Config.INFOPIC
+    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

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

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

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

@@ -0,0 +1,1148 @@
+# <============================================== 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/ai.py

@@ -0,0 +1,142 @@
+# 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 =====================================================>
+PALM_API_URL = "https://lexica.qewertyy.me/models"
+GPT_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, PALM_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, GPT_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

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

@@ -0,0 +1,189 @@
+# <============================================== 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/ban.py

@@ -0,0 +1,1045 @@
+# <============================================== IMPORTS =========================================================>
+from random import choice
+from traceback import format_exc
+
+from pyrogram import enums
+from pyrogram.errors import (
+    ChatAdminRequired,
+    PeerIdInvalid,
+    RightForbidden,
+    RPCError,
+    UserAdminInvalid,
+)
+from pyrogram.filters import regex
+from pyrogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+)
+
+from Infamous.karma import BAN_GIFS, KICK_GIFS
+from Mikobot import BOT_ID, LOGGER, MESSAGE_DUMP, OWNER_ID, SUPPORT_STAFF, app
+from Mikobot.utils.caching import ADMIN_CACHE, admin_cache_reload
+from Mikobot.utils.custom_filters import command, restrict_filter
+from Mikobot.utils.extract_user import extract_user
+from Mikobot.utils.parser import mention_html
+from Mikobot.utils.string import extract_time
+
+# <=======================================================================================================>
+
+
+# <================================================ FUNCTION =======================================================>
+@app.on_message(command("tban") & restrict_filter)
+async def tban_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't ban nothing!")
+        await m.stop_propagation()
+
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == BOT_ID:
+        await m.reply_text("WTF??  Why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    r_id = m.reply_to_message.id if m.reply_to_message else m.id
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 1)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to ban this user for!")
+        return
+
+    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(m, time_val)
+
+    if not bantime:
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
+        await m.stop_propagation()
+
+    try:
+        admin = await mention_html(m.from_user.first_name, m.from_user.id)
+        banned = await mention_html(user_first_name, user_id)
+        chat_title = m.chat.title
+        LOGGER.info(f"{m.from_user.id} tbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id, until_date=bantime)
+        t_t = (f"{admin} banned {banned} in <b>{chat_title}</b>!",)
+        txt = t_t
+        if type(t_t) is tuple:
+            txt = t_t[
+                0
+            ]  # Done this bcuz idk why t_t is tuple type data. SO now if it is tuple this will get text from it
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        else:
+            txt += "\n<b>Reason</b>: Not Specified"
+        if time_val:
+            txt += f"\n<b>Banned for</b>:{time_val}"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "UNBAN",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        anim = choice(BAN_GIFS)
+        try:
+            await m.reply_animation(
+                reply_to_message_id=r_id,
+                animation=str(anim),
+                caption=txt,
+                reply_markup=keyboard,
+                parse_mode=enums.ParseMode.HTML,
+            )
+        except Exception:
+            await m.reply_text(
+                reply_to_message_id=r_id,
+                text=txt,
+                reply_markup=keyboard,
+                parse_mode=enums.ParseMode.HTML,
+            )
+            await c.send_message(MESSAGE_DUMP, f"#REMOVE from BAN_GFIS\n{anim}")
+    # await m.reply_text(txt, reply_markup=keyboard,
+    # reply_to_message_id=r_id)
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to ban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            (
+                f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+            )
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@app.on_message(command("stban") & restrict_filter)
+async def stban_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't ban nothing!")
+        await m.stop_propagation()
+
+    try:
+        user_id, _, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == BOT_ID:
+        await m.reply_text("What the heck? Why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 1)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to ban this user for!")
+        return
+
+    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(m, time_val)
+
+    if not bantime:
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} stbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id, until_date=bantime)
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+            return
+        return
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to ban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@app.on_message(command("dtban") & restrict_filter)
+async def dtban_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't ban nothing!")
+        await m.stop_propagation()
+
+    if not m.reply_to_message:
+        await m.reply_text(
+            "Reply to a message with this command to temp ban and delete the message.",
+        )
+        await m.stop_propagation()
+
+    user_id = m.reply_to_message.from_user.id
+    user_first_name = m.reply_to_message.from_user.first_name
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(text="I am not going to ban one of my support staff")
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 1)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to ban this user for!")
+        return
+
+    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(m, time_val)
+
+    if not bantime:
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
+        await m.stop_propagation()
+
+    try:
+        admin = await mention_html(m.from_user.first_name, m.from_user.id)
+        banned = await mention_html(user_first_name, user_id)
+        chat_title = m.chat.title
+        LOGGER.info(f"{m.from_user.id} dtbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id, until_date=bantime)
+        await m.reply_to_message.delete()
+        txt = f"{admin} banned {banned} in <b>{chat_title}</b>!"
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        else:
+            txt += "\n<b>Reason</b>: Not Specified"
+
+        if bantime:
+            txt += f"\n<b>Banned for</b>: {time_val}"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "UNBAN",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        anim = choice(BAN_GIFS)
+        try:
+            await m.reply_animation(
+                animation=str(anim),
+                caption=txt,
+                reply_markup=keyboard,
+                parse_mode=enums.ParseMode.HTML,
+            )
+        except Exception:
+            await m.reply_text(
+                txt,
+                reply_markup=keyboard,
+                parse_mode=enums.ParseMode.HTML,
+            )
+            await c.send_message(MESSAGE_DUMP, f"#REMOVE from BAN_GFIS\n{anim}")
+        # await c.send_message(m.chat.id, txt, reply_markup=keyboard)
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to ban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@app.on_message(command("kick") & restrict_filter)
+async def kick_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't kick nothing!")
+        return
+
+    reason = None
+
+    if m.reply_to_message:
+        r_id = m.reply_to_message.id
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+    else:
+        r_id = m.id
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to kick")
+        return
+
+    if user_id == BOT_ID:
+        await m.reply_text("Huh, why would I kick myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to kick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "kick")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot kick them!")
+        await m.stop_propagation()
+
+    try:
+        admin = await mention_html(m.from_user.first_name, m.from_user.id)
+        kicked = await mention_html(user_first_name, user_id)
+        chat_title = m.chat.title
+        LOGGER.info(f"{m.from_user.id} kicked {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        txt = f"{admin} kicked {kicked} in <b>{chat_title}</b>!"
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        else:
+            txt += "\n<b>Reason</b>: Not Specified"
+        # await m.reply_text(txt, reply_to_message_id=r_id)
+        kickk = choice(KICK_GIFS)
+        try:
+            await m.reply_animation(
+                reply_to_message_id=r_id,
+                animation=str(kickk),
+                caption=txt,
+                parse_mode=enums.ParseMode.HTML,
+            )
+        except:
+            await m.reply_text(
+                reply_to_message_id=r_id,
+                text=txt,
+                parse_mode=enums.ParseMode.HTML,
+            )
+            await c.send_message(MESSAGE_DUMP, f"#REMOVE from KICK_GFIS\n{kickk}")
+        await m.chat.unban_member(user_id)
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to ban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@app.on_message(command("skick") & restrict_filter)
+async def skick_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't kick nothing!")
+        return
+
+    try:
+        user_id, _, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to kick")
+        return
+
+    if user_id == BOT_ID:
+        await m.reply_text("Huh, why would I kick myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to skick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "kick")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot kick them!")
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} skicked {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+        await m.chat.unban_member(user_id)
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to kick this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@app.on_message(command("dkick") & restrict_filter)
+async def dkick_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't ban nothing!")
+        return
+    if not m.reply_to_message:
+        return await m.reply_text("Reply to a message to delete it and kick the user!")
+
+    reason = None
+
+    user_id = m.reply_to_message.from_user.id
+    user_first_name = m.reply_to_message.from_user.first_name
+
+    if not user_id:
+        await m.reply_text("Cannot find user to kick")
+        return
+
+    if user_id == BOT_ID:
+        await m.reply_text("Huh, why would I kick myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to dkick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "kick")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot kick them!")
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} dkicked {user_id} in {m.chat.id}")
+        await m.reply_to_message.delete()
+        await m.chat.ban_member(user_id)
+        admin = await mention_html(m.from_user.first_name, m.from_user.id)
+        kicked = await mention_html(user_first_name, user_id)
+        chat_title = m.chat.title
+        txt = f"{admin} kicked {kicked} in <b>{chat_title}</b>!"
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        else:
+            txt += "\n<b>Reason</b>: Not Specified"
+        kickk = choice(KICK_GIFS)
+        try:
+            await m.reply_animation(
+                animation=str(kickk),
+                caption=txt,
+                parse_mode=enums.ParseMode.HTML,
+            )
+        except:
+            await m.reply_text(
+                txt,
+                parse_mode=enums.ParseMode.HTML,
+            )
+            await c.send_message(MESSAGE_DUMP, f"#REMOVE from KICK_GFIS\n{kickk}")
+        await m.chat.unban_member(user_id)
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to kick this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@app.on_message(command("unban") & restrict_filter)
+async def unban_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't unban nothing!")
+        await m.stop_propagation()
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id, user_first_name = (
+            m.reply_to_message.sender_chat.id,
+            m.reply_to_message.sender_chat.title,
+        )
+    else:
+        try:
+            user_id, user_first_name, _ = await extract_user(c, m)
+        except Exception:
+            return
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        reason = None
+
+    try:
+        statu = (await m.chat.get_member(user_id)).status
+        if statu not in [
+            enums.ChatMemberStatus.BANNED,
+            enums.ChatMemberStatus.RESTRICTED,
+        ]:
+            await m.reply_text(
+                "User is not banned in this chat\nOr using this command as reply to his message"
+            )
+            return
+    except Exception as e:
+        LOGGER.error(e)
+        LOGGER.exception(format_exc())
+    try:
+        await m.chat.unban_member(user_id)
+        admin = m.from_user.mention
+        unbanned = await mention_html(user_first_name, user_id)
+        chat_title = (m.chat.title,)
+        txt = f"{admin} unbanned {unbanned} in chat <b>{chat_title}</b>!"
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        else:
+            txt += "\n<b>Reason</b>: Not Specified"
+        await m.reply_text(txt)
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to unban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@app.on_message(command("sban") & restrict_filter)
+async def sban_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't ban nothing!")
+        await m.stop_propagation()
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id = m.reply_to_message.sender_chat.id
+    else:
+        try:
+            user_id, _, _ = await extract_user(c, m)
+        except Exception:
+            return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == m.chat.id:
+        await m.reply_text("That's an admin!")
+        await m.stop_propagation()
+    if user_id == BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to sban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} sbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to ban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@app.on_message(command("dban") & restrict_filter)
+async def dban_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't ban nothing!")
+        await m.stop_propagation()
+
+    if not m.reply_to_message:
+        return await m.reply_text("Reply to a message to delete it and ban the user!")
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id, user_first_name = (
+            m.reply_to_message.sender_chat.id,
+            m.reply_to_message.sender_chat.title,
+        )
+    else:
+        user_id, user_first_name = (
+            m.reply_to_message.from_user.id,
+            m.reply_to_message.from_user.first_name,
+        )
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == m.chat.id:
+        await m.reply_text("That's an admin!")
+        await m.stop_propagation()
+    if user_id == BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to dban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
+        await m.stop_propagation()
+
+    reason = None
+    if len(m.text.split()) >= 2:
+        reason = m.text.split(None, 1)[1]
+
+    try:
+        LOGGER.info(f"{m.from_user.id} dbanned {user_id} in {m.chat.id}")
+        await m.reply_to_message.delete()
+        await m.chat.ban_member(user_id)
+        txt = f"{m.from_user.mention} banned {m.reply_to_message.from_user.mention} in <b>{m.chat.title}</b>!"
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        else:
+            txt += "\n<b>Reason</b>: Not Specified"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "UNBAN",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        animm = choice(BAN_GIFS)
+        try:
+            await c.send_animation(
+                m.chat.id, animation=str(animm), caption=txt, reply_markup=keyboard
+            )
+        except Exception:
+            await c.send_message(
+                m.chat.id, txt, enums.ParseMode.HTML, reply_markup=keyboard
+            )
+            await c.send_messagea(MESSAGE_DUMP, f"#REMOVE from BAN_GIFS\n{animm}")
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to ban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@app.on_message(command("ban") & restrict_filter)
+async def ban_usr(c: app, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(text="I can't ban nothing!")
+        await m.stop_propagation()
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id, user_first_name = (
+            m.reply_to_message.sender_chat.id,
+            m.reply_to_message.sender_chat.title,
+        )
+    else:
+        try:
+            user_id, user_first_name, _ = await extract_user(c, m)
+        except Exception:
+            return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        await m.stop_propagation()
+    if user_id == m.chat.id:
+        await m.reply_text("That's an admin!")
+        await m.stop_propagation()
+    if user_id == BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            text="This user is in my support staff, cannot restrict them."
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
+        await m.stop_propagation()
+
+    reason = None
+    if m.reply_to_message:
+        r_id = m.reply_to_message.id
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+    else:
+        r_id = m.id
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+
+    try:
+        LOGGER.info(f"{m.from_user.id} banned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        banned = await mention_html(user_first_name, user_id)
+        txt = f"{m.from_user.mention} banned {banned} in <b>{m.chat.title}</b>!"
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        else:
+            txt += "\n<b>Reason</b>: Not Specified"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "UNBAN",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        anim = choice(BAN_GIFS)
+        try:
+            await m.reply_animation(
+                reply_to_message_id=r_id,
+                animation=str(anim),
+                caption=txt,
+                reply_markup=keyboard,
+                parse_mode=enums.ParseMode.HTML,
+            )
+        except Exception:
+            await m.reply_text(
+                reply_to_message_id=r_id,
+                text=txt,
+                reply_markup=keyboard,
+                parse_mode=enums.ParseMode.HTML,
+            )
+            await c.send_message(MESSAGE_DUMP, f"#REMOVE from BAN_GFIS\n{anim}")
+    except ChatAdminRequired:
+        await m.reply_text(text="I'm not admin or I don't have rights.")
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(
+            text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
+        )
+    except RightForbidden:
+        await m.reply_text(text="I don't have enough rights to ban this user.")
+    except RPCError as ef:
+        await m.reply_text(
+            text=f"""Some error occured, report it using `/bug`
+
+      <b>Error:</b> <code>{ef}</code>"""
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@app.on_callback_query(regex("^unban_"))
+async def unbanbutton(c: app, q: CallbackQuery):
+    splitter = (str(q.data).replace("unban_", "")).split("=")
+    user_id = int(splitter[1])
+    user = await q.message.chat.get_member(q.from_user.id)
+
+    if not user:
+        await q.answer(
+            "You don't have enough permission to do this!\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+
+    if not user.privileges.can_restrict_members and q.from_user.id != OWNER_ID:
+        await q.answer(
+            "You don't have enough permission to do this!\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    whoo = await c.get_chat(user_id)
+    doneto = whoo.first_name if whoo.first_name else whoo.title
+    try:
+        await q.message.chat.unban_member(user_id)
+    except RPCError as e:
+        await q.message.edit_text(f"Error: {e}")
+        return
+    await q.message.edit_text(f"{q.from_user.mention} unbanned {doneto}!")
+    return
+
+
+# <=================================================== HELP ====================================================>
+
+
+__help__ = """
+➠ *Admin only:*
+
+» /kick: Kick the user replied or tagged.
+
+» /skick: Kick the user replied or tagged and delete your messsage.
+
+» /dkick: Kick the user replied and delete their message.
+
+» /ban: Bans the user replied to or tagged.
+
+» /sban: Bans the user replied or tagged and delete your messsage.
+
+» /dban: Bans the user replied and delete their message.
+
+» /tban <userhandle> x(m/h/d): Bans a user for x time. (via handle, or reply). m = minutes, h = hours, d = days.
+
+» /stban <userhandle> x(m/h/d): Silently bans a user for x time. (via handle, or reply). m = minutes, h = hours, d = days.
+
+» /dtban <userhandle> x(m/h/d): Silently bans a user for x time and delete the replied message. (via reply). m = minutes, h = hours, d = days.
+
+» /unban: Unbans the user replied to or tagged.
+
+
+➠ **Example:**
+» `/ban @username`: this bans a user in the chat."""
+
+__mod_name__ = "BANS"
+# <================================================ END =======================================================>

Mikobot/plugins/botadmins.py

@@ -0,0 +1,106 @@
+# 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 check_admin
+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)
+    ]
+
+
+@check_admin(only_dev=True)
+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.
+
+» /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

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

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

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

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

@@ -0,0 +1,756 @@
+# <============================================== 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.consume(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

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

@@ -0,0 +1,131 @@
+# <============================================== 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*:
+
+» /ping: see ping.
+
+» /id: reply to get user id.
+"""
+
+__mod_name__ = "EXTRA"
+# <================================================ END =======================================================>

Mikobot/plugins/flood.py

@@ -0,0 +1,457 @@
+# <============================================== 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/gban.py

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