Add files via upload

Database/mongodb/afk_db.py

@@ -0,0 +1,53 @@
+from Database.mongodb.db import dbname
+
+usersdb = dbname.users
+cleandb = dbname.cleanmode
+cleanmode = {}
+
+
+async def is_cleanmode_on(chat_id: int) -> bool:
+    mode = cleanmode.get(chat_id)
+    if not mode:
+        user = await cleandb.find_one({"chat_id": chat_id})
+        if not user:
+            cleanmode[chat_id] = True
+            return True
+        cleanmode[chat_id] = False
+        return False
+    return mode
+
+
+async def cleanmode_on(chat_id: int):
+    cleanmode[chat_id] = True
+    user = await cleandb.find_one({"chat_id": chat_id})
+    if user:
+        return await cleandb.delete_one({"chat_id": chat_id})
+
+
+async def cleanmode_off(chat_id: int):
+    cleanmode[chat_id] = False
+    user = await cleandb.find_one({"chat_id": chat_id})
+    if not user:
+        return await cleandb.insert_one({"chat_id": chat_id})
+
+
+async def is_afk(user_id: int) -> bool:
+    user = await usersdb.find_one({"user_id": user_id})
+    return (True, user["reason"]) if user else (False, {})
+
+
+async def add_afk(user_id: int, mode):
+    await usersdb.update_one(
+        {"user_id": user_id}, {"$set": {"reason": mode}}, upsert=True
+    )
+
+
+async def remove_afk(user_id: int):
+    user = await usersdb.find_one({"user_id": user_id})
+    if user:
+        return await usersdb.delete_one({"user_id": user_id})
+
+
+async def get_afk_users() -> list:
+    users = usersdb.find({"user_id": {"$gt": 0}})
+    return list(await users.to_list(length=1000000000)) if users else []

Database/mongodb/blacklistdb.py

@@ -0,0 +1,51 @@
+import codecs
+import pickle
+from typing import List
+
+from Database.mongodb.db import dbname
+
+blacklist_filtersdb = dbname.blacklistFilters
+
+
+def obj_to_str(obj):
+    if not obj:
+        return False
+    string = codecs.encode(pickle.dumps(obj), "base64").decode()
+    return string
+
+
+def str_to_obj(string: str):
+    obj = pickle.loads(codecs.decode(string.encode(), "base64"))
+    return obj
+
+
+async def get_blacklisted_words(chat_id: int) -> List[str]:
+    _filters = await blacklist_filtersdb.find_one({"chat_id": chat_id})
+    if not _filters:
+        return []
+    return _filters["filters"]
+
+
+async def save_blacklist_filter(chat_id: int, word: str):
+    word = word.lower().strip()
+    _filters = await get_blacklisted_words(chat_id)
+    _filters.append(word)
+    await blacklist_filtersdb.update_one(
+        {"chat_id": chat_id},
+        {"$set": {"filters": _filters}},
+        upsert=True,
+    )
+
+
+async def delete_blacklist_filter(chat_id: int, word: str) -> bool:
+    filtersd = await get_blacklisted_words(chat_id)
+    word = word.lower().strip()
+    if word in filtersd:
+        filtersd.remove(word)
+        await blacklist_filtersdb.update_one(
+            {"chat_id": chat_id},
+            {"$set": {"filters": filtersd}},
+            upsert=True,
+        )
+        return True
+    return False

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/fsub_db.py

@@ -0,0 +1,18 @@
+from Infamous.temp import dbname
+
+fsub = dbname.force_sub
+
+
+def fs_settings(chat_id: int):
+    _x = fsub.find_one({"chat_id": chat_id})
+    if _x:
+        return _x
+    return None
+
+
+def add_channel(chat_id: int, channel):
+    fsub.update_one({"chat_id": chat_id}, {"$set": {"channel": channel}}, upsert=True)
+
+
+def disapprove(chat_id: int):
+    fsub.delete_one({"chat_id": chat_id})

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/locale_db.py

@@ -0,0 +1,22 @@
+from typing import Iterable
+
+from pyrogram.enums import ChatType
+
+from Database.mongodb.db import dbname
+
+localesdb = dbname.locale  # DB for localization
+
+group_types: Iterable[ChatType] = (ChatType.GROUP, ChatType.SUPERGROUP)
+
+
+async def set_db_lang(chat_id: int, chat_type: str, lang_code: str):
+    await localesdb.update_one(
+        {"chat_id": chat_id},
+        {"$set": {"lang": lang_code, "chat_type": chat_type.value}},
+        upsert=True,
+    )
+
+
+async def get_db_lang(chat_id: int) -> str:
+    ul = await localesdb.find_one({"chat_id": chat_id})
+    return ul["lang"] if ul else {}

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/sangmata_db.py

@@ -0,0 +1,42 @@
+from Database.mongodb.db import dbname
+
+matadb = dbname["sangmata"]
+
+
+# Get Data User
+async def cek_userdata(user_id: int) -> bool:
+    user = await matadb.find_one({"user_id": user_id})
+    return bool(user)
+
+
+async def get_userdata(user_id: int) -> bool:
+    user = await matadb.find_one({"user_id": user_id})
+    return user["username"], user["first_name"], user["last_name"]
+
+
+async def add_userdata(user_id: int, username, first_name, last_name):
+    await matadb.update_one(
+        {"user_id": user_id},
+        {
+            "$set": {
+                "username": username,
+                "first_name": first_name,
+                "last_name": last_name,
+            }
+        },
+        upsert=True,
+    )
+
+
+# Enable Mata MissKaty in Selected Chat
+async def is_sangmata_on(chat_id: int) -> bool:
+    chat = await matadb.find_one({"chat_id_toggle": chat_id})
+    return bool(chat)
+
+
+async def sangmata_on(chat_id: int) -> bool:
+    await matadb.insert_one({"chat_id_toggle": chat_id})
+
+
+async def sangmata_off(chat_id: int):
+    await matadb.delete_one({"chat_id_toggle": chat_id})

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_chats_db.py

@@ -0,0 +1,111 @@
+from async_pymongo import AsyncClient
+
+from Mikobot import DB_NAME, MONGO_DB_URI
+
+
+class UsersData:
+    def __init__(self, uri, database_name):
+        self._client = AsyncClient(uri)
+        self.db = self._client[database_name]
+        self.col = self.db["userlist"]
+        self.grp = self.db["groups"]
+
+    @staticmethod
+    def new_user(id, name):
+        return dict(
+            id=id,
+            name=name,
+            ban_status=dict(
+                is_banned=False,
+                ban_reason="",
+            ),
+        )
+
+    @staticmethod
+    def new_group(id, title):
+        return dict(
+            id=id,
+            title=title,
+            chat_status=dict(
+                is_disabled=False,
+                reason="",
+            ),
+        )
+
+    async def add_user(self, id, name):
+        user = self.new_user(id, name)
+        await self.col.insert_one(user)
+
+    async def is_user_exist(self, id):
+        user = await self.col.find_one({"id": int(id)})
+        return bool(user)
+
+    async def total_users_count(self):
+        return await self.col.count_documents({})
+
+    async def remove_ban(self, id):
+        return await self.col.delete_one({"_id": id})
+
+    async def ban_user(self, user_id, ban_reason="No Reason"):
+        return await self.col.insert_one({"_id": user_id, "reason": ban_reason})
+
+    async def get_ban_status(self, id):
+        user = await self.col.find_one({"_id": int(id)})
+        if user:
+            return True, user
+        return False, None
+
+    async def get_all_users(self):
+        return self.col.find({})
+
+    async def delete_user(self, user_id):
+        await self.col.delete_many({"id": int(user_id)})
+
+    async def is_chat_exist(self, id):
+        user = await self.grp.find_one({"id": int(id)})
+        return bool(user)
+
+    async def get_banned(self):
+        users = self.col.find({"ban_status.is_banned": True})
+        chats = self.grp.find({"chat_status.is_disabled": True})
+        b_chats = [chat["id"] async for chat in chats]
+        b_users = [user["id"] async for user in users]
+        return b_users, b_chats
+
+    async def add_chat(self, chat, title):
+        chat = self.new_group(chat, title)
+        await self.grp.insert_one(chat)
+
+    async def get_chat(self, chat):
+        chat = await self.grp.find_one({"id": int(chat)})
+        return chat.get("chat_status") if chat else False
+
+    async def re_enable_chat(self, id):
+        chat_status = dict(
+            is_disabled=False,
+            reason="",
+        )
+        await self.grp.update_one(
+            {"id": int(id)}, {"$set": {"chat_status": chat_status}}
+        )
+
+    async def disable_chat(self, chat, reason="No Reason"):
+        chat_status = dict(
+            is_disabled=True,
+            reason=reason,
+        )
+        await self.grp.update_one(
+            {"id": int(chat)}, {"$set": {"chat_status": chat_status}}
+        )
+
+    async def total_chat_count(self):
+        return await self.grp.count_documents({})
+
+    async def get_all_chats(self):
+        return self.grp.find({})
+
+    async def get_db_size(self):
+        return (await self.db.command("dbstats"))["dataSize"]
+
+
+db = UsersData(MONGO_DB_URI, DB_NAME)

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/afk_sql.py

@@ -0,0 +1,99 @@
+import threading
+from datetime import datetime
+
+from sqlalchemy import BigInteger, Boolean, Column, DateTime, UnicodeText
+
+from Database.sql import BASE, SESSION
+
+
+class AFK(BASE):
+    __tablename__ = "afk_user"
+
+    user_id = Column(BigInteger, primary_key=True)
+    is_afk = Column(Boolean)
+    reason = Column(UnicodeText)
+    time = Column(DateTime)
+
+    def __init__(self, user_id: int, reason: str = "", is_afk: bool = True):
+        self.user_id = user_id
+        self.reason = reason
+        self.is_afk = is_afk
+        self.time = datetime.now()
+
+    def __repr__(self):
+        return "afk_status for {}".format(self.user_id)
+
+
+AFK.__table__.create(checkfirst=True)
+INSERTION_LOCK = threading.RLock()
+
+AFK_USERS = {}
+
+
+def is_afk(user_id):
+    return user_id in AFK_USERS
+
+
+def check_afk_status(user_id):
+    try:
+        return SESSION.query(AFK).get(user_id)
+    finally:
+        SESSION.close()
+
+
+def set_afk(user_id, reason=""):
+    with INSERTION_LOCK:
+        curr = SESSION.query(AFK).get(user_id)
+        if not curr:
+            curr = AFK(user_id, reason, True)
+        else:
+            curr.is_afk = True
+
+        AFK_USERS[user_id] = {"reason": reason, "time": curr.time}
+
+        SESSION.add(curr)
+        SESSION.commit()
+
+
+def rm_afk(user_id):
+    with INSERTION_LOCK:
+        curr = SESSION.query(AFK).get(user_id)
+        if curr:
+            if user_id in AFK_USERS:  # sanity check
+                del AFK_USERS[user_id]
+
+            SESSION.delete(curr)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def toggle_afk(user_id, reason=""):
+    with INSERTION_LOCK:
+        curr = SESSION.query(AFK).get(user_id)
+        if not curr:
+            curr = AFK(user_id, reason, True)
+        elif curr.is_afk:
+            curr.is_afk = False
+        elif not curr.is_afk:
+            curr.is_afk = True
+        SESSION.add(curr)
+        SESSION.commit()
+
+
+def __load_afk_users():
+    global AFK_USERS
+    try:
+        all_afk = SESSION.query(AFK).all()
+        AFK_USERS = {
+            user.user_id: {"reason": user.reason, "time": user.time}
+            for user in all_afk
+            if user.is_afk
+        }
+    finally:
+        SESSION.close()
+
+
+__load_afk_users()

Database/sql/antichannel_sql.py

@@ -0,0 +1,88 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import Boolean, Column
+from sqlalchemy.sql.sqltypes import String
+
+from Database.sql import BASE, SESSION
+
+
+class AntiChannelSettings(BASE):
+    __tablename__ = "anti_channel_settings"
+
+    chat_id = Column(String(14), primary_key=True)
+    setting = Column(Boolean, default=False, nullable=False)
+
+    def __init__(self, chat_id: int, disabled: bool):
+        self.chat_id = str(chat_id)
+        self.setting = disabled
+
+    def __repr__(self):
+        return "<ᴀɴᴛɪғʟᴏᴏᴅ sᴇᴛᴛɪɴɢ {} ({})>".format(self.chat_id, self.setting)
+
+
+AntiChannelSettings.__table__.create(checkfirst=True)
+ANTICHANNEL_SETTING_LOCK = threading.RLock()
+
+
+def enable_antichannel(chat_id: int):
+    with ANTICHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiChannelSettings).get(str(chat_id))
+        if not chat:
+            chat = AntiChannelSettings(str(chat_id), True)
+
+        chat.setting = True
+        SESSION.add(chat)
+        SESSION.commit()
+
+
+def disable_antichannel(chat_id: int):
+    with ANTICHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiChannelSettings).get(str(chat_id))
+        if not chat:
+            chat = AntiChannelSettings(str(chat_id), False)
+
+        chat.setting = False
+        SESSION.add(chat)
+        SESSION.commit()
+
+
+def antichannel_status(chat_id: int) -> bool:
+    with ANTICHANNEL_SETTING_LOCK:
+        d = SESSION.query(AntiChannelSettings).get(str(chat_id))
+        if not d:
+            return False
+        return d.setting
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with ANTICHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiChannelSettings).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = new_chat_id
+            SESSION.add(chat)
+
+        SESSION.commit()

Database/sql/antiflood_sql.py

@@ -0,0 +1,171 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import BigInteger, Column, 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(BigInteger, default=DEF_COUNT)
+    limit = Column(BigInteger, default=DEF_LIMIT)
+
+    def __init__(self, chat_id):
+        self.chat_id = str(chat_id)  # ensure string
+
+    def __repr__(self):
+        return "<ғʟᴏᴏᴅ ᴄᴏɴᴛʀᴏʟ ғᴏʀ %s>" % self.chat_id
+
+
+class FloodSettings(BASE):
+    __tablename__ = "antiflood_settings"
+    chat_id = Column(String(14), primary_key=True)
+    flood_type = Column(BigInteger, 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 "<{} ᴡɪʟʟ ᴇxᴇᴄᴜᴛɪɴɢ {} ғᴏʀ ғʟᴏᴏᴅ.>".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) not in CHAT_FLOOD:
+        return
+
+    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):
+    # ғᴏʀ ғʟᴏᴏᴅ_ᴛʏᴘᴇ
+    # 1 = ban
+    # 2 = kick
+    # 3 = mute
+    # 4 = tban
+    # 5 = tmute
+    # 6 = ᴅᴍᴜᴛᴇ sᴏᴏɴ
+    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
+        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/antilinkedchannel_sql.py

@@ -0,0 +1,142 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import Boolean, Column
+from sqlalchemy.sql.sqltypes import String
+
+from Database.sql import BASE, SESSION
+
+
+class AntiLinkedChannelSettings(BASE):
+    __tablename__ = "anti_linked_channel_settings"
+
+    chat_id = Column(String(14), primary_key=True)
+    setting = Column(Boolean, default=False, nullable=False)
+
+    def __init__(self, chat_id: int, disabled: bool):
+        self.chat_id = str(chat_id)
+        self.setting = disabled
+
+    def __repr__(self):
+        return "<Antilinked setting {} ({})>".format(self.chat_id, self.setting)
+
+
+class AntiPinChannelSettings(BASE):
+    __tablename__ = "anti_pin_channel_settings"
+
+    chat_id = Column(String(14), primary_key=True)
+    setting = Column(Boolean, default=False, nullable=False)
+
+    def __init__(self, chat_id: int, disabled: bool):
+        self.chat_id = str(chat_id)
+        self.setting = disabled
+
+    def __repr__(self):
+        return "<ᴀɴᴛɪᴘɪɴ sᴇᴛᴛɪɴɢ {} ({})>".format(self.chat_id, self.setting)
+
+
+AntiLinkedChannelSettings.__table__.create(checkfirst=True)
+ANTI_LINKED_CHANNEL_SETTING_LOCK = threading.RLock()
+
+AntiPinChannelSettings.__table__.create(checkfirst=True)
+ANTI_PIN_CHANNEL_SETTING_LOCK = threading.RLock()
+
+
+def enable_linked(chat_id: int):
+    with ANTI_LINKED_CHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiLinkedChannelSettings).get(str(chat_id))
+        if not chat:
+            chat = AntiLinkedChannelSettings(chat_id, True)
+
+        chat.setting = True
+        SESSION.add(chat)
+        SESSION.commit()
+
+
+def enable_pin(chat_id: int):
+    with ANTI_PIN_CHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiPinChannelSettings).get(str(chat_id))
+        if not chat:
+            chat = AntiPinChannelSettings(chat_id, True)
+
+        chat.setting = True
+        SESSION.add(chat)
+        SESSION.commit()
+
+
+def disable_linked(chat_id: int):
+    with ANTI_LINKED_CHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiLinkedChannelSettings).get(str(chat_id))
+        if not chat:
+            chat = AntiLinkedChannelSettings(chat_id, False)
+
+        chat.setting = False
+        SESSION.add(chat)
+        SESSION.commit()
+
+
+def disable_pin(chat_id: int):
+    with ANTI_PIN_CHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiPinChannelSettings).get(str(chat_id))
+        if not chat:
+            chat = AntiPinChannelSettings(chat_id, False)
+
+        chat.setting = False
+        SESSION.add(chat)
+        SESSION.commit()
+
+
+def status_linked(chat_id: int) -> bool:
+    with ANTI_LINKED_CHANNEL_SETTING_LOCK:
+        d = SESSION.query(AntiLinkedChannelSettings).get(str(chat_id))
+        if not d:
+            return False
+        return d.setting
+
+
+def status_pin(chat_id: int) -> bool:
+    with ANTI_PIN_CHANNEL_SETTING_LOCK:
+        d = SESSION.query(AntiPinChannelSettings).get(str(chat_id))
+        if not d:
+            return False
+        return d.setting
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with ANTI_LINKED_CHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiLinkedChannelSettings).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = new_chat_id
+            SESSION.add(chat)
+
+        SESSION.commit()
+    with ANTI_PIN_CHANNEL_SETTING_LOCK:
+        chat = SESSION.query(AntiPinChannelSettings).get(str(old_chat_id))
+        if chat:
+            chat.chat_id = new_chat_id
+            SESSION.add(chat)
+
+        SESSION.commit()

Database/sql/approve_sql.py

@@ -0,0 +1,85 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+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 "<ᴀᴘᴘʀᴏᴠᴇ %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/blacklist_sql.py

@@ -0,0 +1,223 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import BigInteger, Column, String, UnicodeText, distinct, func
+
+from Database.sql import BASE, SESSION
+
+
+class BlackListFilters(BASE):
+    __tablename__ = "blacklist"
+    chat_id = Column(String(14), primary_key=True)
+    trigger = Column(UnicodeText, primary_key=True, nullable=False)
+
+    def __init__(self, chat_id, trigger):
+        self.chat_id = str(chat_id)  # ensure string
+        self.trigger = trigger
+
+    def __repr__(self):
+        return "<ʙʟᴀᴄᴋʟɪsᴛ ғɪʟᴛᴇʀ '%s' ғᴏʀ %s>" % (self.trigger, self.chat_id)
+
+    def __eq__(self, other):
+        return bool(
+            isinstance(other, BlackListFilters)
+            and self.chat_id == other.chat_id
+            and self.trigger == other.trigger,
+        )
+
+
+class BlacklistSettings(BASE):
+    __tablename__ = "blacklist_settings"
+    chat_id = Column(String(14), primary_key=True)
+    blacklist_type = Column(BigInteger, default=1)
+    value = Column(UnicodeText, default="0")
+
+    def __init__(self, chat_id, blacklist_type=1, value="0"):
+        self.chat_id = str(chat_id)
+        self.blacklist_type = blacklist_type
+        self.value = value
+
+    def __repr__(self):
+        return "<{} ᴡɪʟʟ ᴇxᴇᴄᴜᴛɪɴɢ {} ғᴏʀ ʙʟᴀᴄᴋʟɪsᴛ ᴛʀɪɢɢᴇʀ.>".format(
+            self.chat_id,
+            self.blacklist_type,
+        )
+
+
+BlackListFilters.__table__.create(checkfirst=True)
+BlacklistSettings.__table__.create(checkfirst=True)
+
+BLACKLIST_FILTER_INSERTION_LOCK = threading.RLock()
+BLACKLIST_SETTINGS_INSERTION_LOCK = threading.RLock()
+
+CHAT_BLACKLISTS = {}
+CHAT_SETTINGS_BLACKLISTS = {}
+
+
+def add_to_blacklist(chat_id, trigger):
+    with BLACKLIST_FILTER_INSERTION_LOCK:
+        blacklist_filt = BlackListFilters(str(chat_id), trigger)
+
+        SESSION.merge(blacklist_filt)  # merge to avoid duplicate key issues
+        SESSION.commit()
+        global CHAT_BLACKLISTS
+        if CHAT_BLACKLISTS.get(str(chat_id), set()) == set():
+            CHAT_BLACKLISTS[str(chat_id)] = {trigger}
+        else:
+            CHAT_BLACKLISTS.get(str(chat_id), set()).add(trigger)
+
+
+def rm_from_blacklist(chat_id, trigger):
+    with BLACKLIST_FILTER_INSERTION_LOCK:
+        blacklist_filt = SESSION.query(BlackListFilters).get((str(chat_id), trigger))
+        if blacklist_filt:
+            if trigger in CHAT_BLACKLISTS.get(str(chat_id), set()):  # sanity check
+                CHAT_BLACKLISTS.get(str(chat_id), set()).remove(trigger)
+
+            SESSION.delete(blacklist_filt)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def get_chat_blacklist(chat_id):
+    return CHAT_BLACKLISTS.get(str(chat_id), set())
+
+
+def num_blacklist_filters():
+    try:
+        return SESSION.query(BlackListFilters).count()
+    finally:
+        SESSION.close()
+
+
+def num_blacklist_chat_filters(chat_id):
+    try:
+        return (
+            SESSION.query(BlackListFilters.chat_id)
+            .filter(BlackListFilters.chat_id == str(chat_id))
+            .count()
+        )
+    finally:
+        SESSION.close()
+
+
+def num_blacklist_filter_chats():
+    try:
+        return SESSION.query(func.count(distinct(BlackListFilters.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def set_blacklist_strength(chat_id, blacklist_type, value):
+    # for blacklist_type
+    # 0 = nothing
+    # 1 = delete
+    # 2 = warn
+    # 3 = mute
+    # 4 = kick
+    # 5 = ban
+    # 6 = tban
+    # 7 = tmute
+    with BLACKLIST_SETTINGS_INSERTION_LOCK:
+        global CHAT_SETTINGS_BLACKLISTS
+        curr_setting = SESSION.query(BlacklistSettings).get(str(chat_id))
+        if not curr_setting:
+            curr_setting = BlacklistSettings(
+                chat_id,
+                blacklist_type=int(blacklist_type),
+                value=value,
+            )
+
+        curr_setting.blacklist_type = int(blacklist_type)
+        curr_setting.value = str(value)
+        CHAT_SETTINGS_BLACKLISTS[str(chat_id)] = {
+            "blacklist_type": int(blacklist_type),
+            "value": value,
+        }
+
+        SESSION.add(curr_setting)
+        SESSION.commit()
+
+
+def get_blacklist_setting(chat_id):
+    try:
+        setting = CHAT_SETTINGS_BLACKLISTS.get(str(chat_id))
+        if setting:
+            return setting["blacklist_type"], setting["value"]
+        return 1, "0"
+
+    finally:
+        SESSION.close()
+
+
+def __load_chat_blacklists():
+    global CHAT_BLACKLISTS
+    try:
+        chats = SESSION.query(BlackListFilters.chat_id).distinct().all()
+        for (chat_id,) in chats:  # remove tuple by ( ,)
+            CHAT_BLACKLISTS[chat_id] = []
+
+        all_filters = SESSION.query(BlackListFilters).all()
+        for x in all_filters:
+            CHAT_BLACKLISTS[x.chat_id] += [x.trigger]
+
+        CHAT_BLACKLISTS = {x: set(y) for x, y in CHAT_BLACKLISTS.items()}
+
+    finally:
+        SESSION.close()
+
+
+def __load_chat_settings_blacklists():
+    global CHAT_SETTINGS_BLACKLISTS
+    try:
+        chats_settings = SESSION.query(BlacklistSettings).all()
+        for x in chats_settings:  # remove tuple by ( ,)
+            CHAT_SETTINGS_BLACKLISTS[x.chat_id] = {
+                "blacklist_type": x.blacklist_type,
+                "value": x.value,
+            }
+
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with BLACKLIST_FILTER_INSERTION_LOCK:
+        chat_filters = (
+            SESSION.query(BlackListFilters)
+            .filter(BlackListFilters.chat_id == str(old_chat_id))
+            .all()
+        )
+        for filt in chat_filters:
+            filt.chat_id = str(new_chat_id)
+        SESSION.commit()
+
+
+__load_chat_blacklists()
+__load_chat_settings_blacklists()

Database/sql/blacklistusers_sql.py

@@ -0,0 +1,90 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+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 = user.reason if user else ""
+    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/blsticker_sql.py

@@ -0,0 +1,223 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import BigInteger, Column, String, UnicodeText, distinct, func
+
+from Database.sql import BASE, SESSION
+
+
+class StickersFilters(BASE):
+    __tablename__ = "blacklist_stickers"
+    chat_id = Column(String(14), primary_key=True)
+    trigger = Column(UnicodeText, primary_key=True, nullable=False)
+
+    def __init__(self, chat_id, trigger):
+        self.chat_id = str(chat_id)  # ensure string
+        self.trigger = trigger
+
+    def __repr__(self):
+        return "<sᴛɪᴄᴋᴇʀs ғɪʟᴛᴇʀ '%s' ғᴏʀ %s>" % (self.trigger, self.chat_id)
+
+    def __eq__(self, other):
+        return bool(
+            isinstance(other, StickersFilters)
+            and self.chat_id == other.chat_id
+            and self.trigger == other.trigger,
+        )
+
+
+class StickerSettings(BASE):
+    __tablename__ = "blsticker_settings"
+    chat_id = Column(String(14), primary_key=True)
+    blacklist_type = Column(BigInteger, default=1)
+    value = Column(UnicodeText, default="0")
+
+    def __init__(self, chat_id, blacklist_type=1, value="0"):
+        self.chat_id = str(chat_id)
+        self.blacklist_type = blacklist_type
+        self.value = value
+
+    def __repr__(self):
+        return "<{} ᴡɪʟʟ ᴇxᴇᴄᴜᴛɪɴɢ {} ғᴏʀ ʙʟᴀᴄᴋʟɪsᴛ ᴛʀɪɢɢᴇʀ.>".format(
+            self.chat_id,
+            self.blacklist_type,
+        )
+
+
+StickersFilters.__table__.create(checkfirst=True)
+StickerSettings.__table__.create(checkfirst=True)
+
+STICKERS_FILTER_INSERTION_LOCK = threading.RLock()
+STICKSET_FILTER_INSERTION_LOCK = threading.RLock()
+
+CHAT_STICKERS = {}
+CHAT_BLSTICK_BLACKLISTS = {}
+
+
+def add_to_stickers(chat_id, trigger):
+    with STICKERS_FILTER_INSERTION_LOCK:
+        stickers_filt = StickersFilters(str(chat_id), trigger)
+
+        SESSION.merge(stickers_filt)  # merge to avoid duplicate key issues
+        SESSION.commit()
+        global CHAT_STICKERS
+        if CHAT_STICKERS.get(str(chat_id), set()) == set():
+            CHAT_STICKERS[str(chat_id)] = {trigger}
+        else:
+            CHAT_STICKERS.get(str(chat_id), set()).add(trigger)
+
+
+def rm_from_stickers(chat_id, trigger):
+    with STICKERS_FILTER_INSERTION_LOCK:
+        stickers_filt = SESSION.query(StickersFilters).get((str(chat_id), trigger))
+        if stickers_filt:
+            if trigger in CHAT_STICKERS.get(str(chat_id), set()):  # sanity check
+                CHAT_STICKERS.get(str(chat_id), set()).remove(trigger)
+
+            SESSION.delete(stickers_filt)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def get_chat_stickers(chat_id):
+    return CHAT_STICKERS.get(str(chat_id), set())
+
+
+def num_stickers_filters():
+    try:
+        return SESSION.query(StickersFilters).count()
+    finally:
+        SESSION.close()
+
+
+def num_stickers_chat_filters(chat_id):
+    try:
+        return (
+            SESSION.query(StickersFilters.chat_id)
+            .filter(StickersFilters.chat_id == str(chat_id))
+            .count()
+        )
+    finally:
+        SESSION.close()
+
+
+def num_stickers_filter_chats():
+    try:
+        return SESSION.query(func.count(distinct(StickersFilters.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def set_blacklist_strength(chat_id, blacklist_type, value):
+    # for blacklist_type
+    # 0 = nothing
+    # 1 = delete
+    # 2 = warn
+    # 3 = mute
+    # 4 = kick
+    # 5 = ban
+    # 6 = tban
+    # 7 = tmute
+    with STICKSET_FILTER_INSERTION_LOCK:
+        global CHAT_BLSTICK_BLACKLISTS
+        curr_setting = SESSION.query(StickerSettings).get(str(chat_id))
+        if not curr_setting:
+            curr_setting = StickerSettings(
+                chat_id,
+                blacklist_type=int(blacklist_type),
+                value=value,
+            )
+
+        curr_setting.blacklist_type = int(blacklist_type)
+        curr_setting.value = str(value)
+        CHAT_BLSTICK_BLACKLISTS[str(chat_id)] = {
+            "blacklist_type": int(blacklist_type),
+            "value": value,
+        }
+
+        SESSION.add(curr_setting)
+        SESSION.commit()
+
+
+def get_blacklist_setting(chat_id):
+    try:
+        setting = CHAT_BLSTICK_BLACKLISTS.get(str(chat_id))
+        if setting:
+            return setting["blacklist_type"], setting["value"]
+        return 1, "0"
+
+    finally:
+        SESSION.close()
+
+
+def __load_CHAT_STICKERS():
+    global CHAT_STICKERS
+    try:
+        chats = SESSION.query(StickersFilters.chat_id).distinct().all()
+        for (chat_id,) in chats:  # remove tuple by ( ,)
+            CHAT_STICKERS[chat_id] = []
+
+        all_filters = SESSION.query(StickersFilters).all()
+        for x in all_filters:
+            CHAT_STICKERS[x.chat_id] += [x.trigger]
+
+        CHAT_STICKERS = {x: set(y) for x, y in CHAT_STICKERS.items()}
+
+    finally:
+        SESSION.close()
+
+
+def __load_chat_stickerset_blacklists():
+    global CHAT_BLSTICK_BLACKLISTS
+    try:
+        chats_settings = SESSION.query(StickerSettings).all()
+        for x in chats_settings:  # remove tuple by ( ,)
+            CHAT_BLSTICK_BLACKLISTS[x.chat_id] = {
+                "blacklist_type": x.blacklist_type,
+                "value": x.value,
+            }
+
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with STICKERS_FILTER_INSERTION_LOCK:
+        chat_filters = (
+            SESSION.query(StickersFilters)
+            .filter(StickersFilters.chat_id == str(old_chat_id))
+            .all()
+        )
+        for filt in chat_filters:
+            filt.chat_id = str(new_chat_id)
+        SESSION.commit()
+
+
+__load_CHAT_STICKERS()
+__load_chat_stickerset_blacklists()

Database/sql/cleaner_sql.py

@@ -0,0 +1,225 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import Boolean, Column, UnicodeText
+
+from Database.sql import BASE, SESSION
+
+
+class CleanerBlueTextChatSettings(BASE):
+    __tablename__ = "cleaner_bluetext_chat_setting"
+    chat_id = Column(UnicodeText, primary_key=True)
+    is_enable = Column(Boolean, default=False)
+
+    def __init__(self, chat_id, is_enable):
+        self.chat_id = chat_id
+        self.is_enable = is_enable
+
+    def __repr__(self):
+        return "ᴄʟᴇᴀɴ ʙʟᴜᴇ ᴛᴇxᴛ ғᴏʀ {}".format(self.chat_id)
+
+
+class CleanerBlueTextChat(BASE):
+    __tablename__ = "cleaner_bluetext_chat_ignore_commands"
+    chat_id = Column(UnicodeText, primary_key=True)
+    command = Column(UnicodeText, primary_key=True)
+
+    def __init__(self, chat_id, command):
+        self.chat_id = chat_id
+        self.command = command
+
+
+class CleanerBlueTextGlobal(BASE):
+    __tablename__ = "cleaner_bluetext_global_ignore_commands"
+    command = Column(UnicodeText, primary_key=True)
+
+    def __init__(self, command):
+        self.command = command
+
+
+CleanerBlueTextChatSettings.__table__.create(checkfirst=True)
+CleanerBlueTextChat.__table__.create(checkfirst=True)
+CleanerBlueTextGlobal.__table__.create(checkfirst=True)
+
+CLEANER_CHAT_SETTINGS = threading.RLock()
+CLEANER_CHAT_LOCK = threading.RLock()
+CLEANER_GLOBAL_LOCK = threading.RLock()
+
+CLEANER_CHATS = {}
+GLOBAL_IGNORE_COMMANDS = set()
+
+
+def set_cleanbt(chat_id, is_enable):
+    with CLEANER_CHAT_SETTINGS:
+        curr = SESSION.query(CleanerBlueTextChatSettings).get(str(chat_id))
+
+        if not curr:
+            curr = CleanerBlueTextChatSettings(str(chat_id), is_enable)
+        else:
+            curr.is_enabled = is_enable
+
+        if str(chat_id) not in CLEANER_CHATS:
+            CLEANER_CHATS.setdefault(
+                str(chat_id), {"setting": False, "commands": set()}
+            )
+
+        CLEANER_CHATS[str(chat_id)]["setting"] = is_enable
+
+        SESSION.add(curr)
+        SESSION.commit()
+
+
+def chat_ignore_command(chat_id, ignore):
+    ignore = ignore.lower()
+    with CLEANER_CHAT_LOCK:
+        ignored = SESSION.query(CleanerBlueTextChat).get((str(chat_id), ignore))
+
+        if not ignored:
+            if str(chat_id) not in CLEANER_CHATS:
+                CLEANER_CHATS.setdefault(
+                    str(chat_id), {"setting": False, "commands": set()}
+                )
+
+            CLEANER_CHATS[str(chat_id)]["commands"].add(ignore)
+
+            ignored = CleanerBlueTextChat(str(chat_id), ignore)
+            SESSION.add(ignored)
+            SESSION.commit()
+            return True
+        SESSION.close()
+        return False
+
+
+def chat_unignore_command(chat_id, unignore):
+    unignore = unignore.lower()
+    with CLEANER_CHAT_LOCK:
+        unignored = SESSION.query(CleanerBlueTextChat).get((str(chat_id), unignore))
+
+        if unignored:
+            if str(chat_id) not in CLEANER_CHATS:
+                CLEANER_CHATS.setdefault(
+                    str(chat_id), {"setting": False, "commands": set()}
+                )
+            if unignore in CLEANER_CHATS.get(str(chat_id)).get("commands"):
+                CLEANER_CHATS[str(chat_id)]["commands"].remove(unignore)
+
+            SESSION.delete(unignored)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def global_ignore_command(command):
+    command = command.lower()
+    with CLEANER_GLOBAL_LOCK:
+        ignored = SESSION.query(CleanerBlueTextGlobal).get(str(command))
+
+        if not ignored:
+            GLOBAL_IGNORE_COMMANDS.add(command)
+
+            ignored = CleanerBlueTextGlobal(str(command))
+            SESSION.add(ignored)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def global_unignore_command(command):
+    command = command.lower()
+    with CLEANER_GLOBAL_LOCK:
+        unignored = SESSION.query(CleanerBlueTextGlobal).get(str(command))
+
+        if unignored:
+            if command in GLOBAL_IGNORE_COMMANDS:
+                GLOBAL_IGNORE_COMMANDS.remove(command)
+
+            SESSION.delete(command)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def is_command_ignored(chat_id, command):
+    if command.lower() in GLOBAL_IGNORE_COMMANDS:
+        return True
+
+    if str(chat_id) in CLEANER_CHATS and command.lower() in CLEANER_CHATS.get(
+        str(chat_id)
+    ).get("commands"):
+        return True
+
+    return False
+
+
+def is_enabled(chat_id):
+    if str(chat_id) in CLEANER_CHATS:
+        return CLEANER_CHATS.get(str(chat_id)).get("setting")
+
+    return False
+
+
+def get_all_ignored(chat_id):
+    if str(chat_id) in CLEANER_CHATS:
+        LOCAL_IGNORE_COMMANDS = CLEANER_CHATS.get(str(chat_id)).get("commands")
+    else:
+        LOCAL_IGNORE_COMMANDS = set()
+
+    return GLOBAL_IGNORE_COMMANDS, LOCAL_IGNORE_COMMANDS
+
+
+def __load_cleaner_list():
+    global GLOBAL_IGNORE_COMMANDS
+    global CLEANER_CHATS
+
+    try:
+        GLOBAL_IGNORE_COMMANDS = {
+            x.command for x in SESSION.query(CleanerBlueTextGlobal).all()
+        }
+    finally:
+        SESSION.close()
+
+    try:
+        for x in SESSION.query(CleanerBlueTextChatSettings).all():
+            CLEANER_CHATS.setdefault(x.chat_id, {"setting": False, "commands": set()})
+            CLEANER_CHATS[x.chat_id]["setting"] = x.is_enable
+    finally:
+        SESSION.close()
+
+    try:
+        for x in SESSION.query(CleanerBlueTextChat).all():
+            CLEANER_CHATS.setdefault(x.chat_id, {"setting": False, "commands": set()})
+            CLEANER_CHATS[x.chat_id]["commands"].add(x.command)
+    finally:
+        SESSION.close()
+
+
+__load_cleaner_list()

Database/sql/connection_sql.py

@@ -0,0 +1,230 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+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 "<ᴄʜᴀᴛ ᴀᴄᴄᴇss sᴇᴛᴛɪɴɢs ({}) 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 "<ᴄᴏɴɴᴇᴄᴛɪᴏɴ ᴜsᴇʀ {} ʜɪsᴛᴏʀʏ {}>".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
+        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 = {
+                HISTORY_CONNECT[int(user_id)][x]["chat_id"]: x
+                for x in HISTORY_CONNECT[int(user_id)]
+            }
+
+            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,404 @@
+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)
+    is_sticker = Column(Boolean, nullable=False, default=False)
+    is_document = Column(Boolean, nullable=False, default=False)
+    is_image = Column(Boolean, nullable=False, default=False)
+    is_audio = Column(Boolean, nullable=False, default=False)
+    is_voice = Column(Boolean, nullable=False, default=False)
+    is_video = Column(Boolean, nullable=False, default=False)
+
+    has_buttons = Column(Boolean, nullable=False, default=False)
+    # NOTE: Here for legacy purposes, to ensure older filters don't mess up.
+    has_markdown = Column(Boolean, nullable=False, default=False)
+
+    # NEW FILTER
+    # alter table cust_filters add column reply_text text;
+    # alter table cust_filters add column file_type integer default 1;
+    # alter table cust_filters add column file_id text;
+    reply_text = Column(UnicodeText)
+    file_type = Column(Integer, nullable=False, default=1)
+    file_id = Column(UnicodeText, default=None)
+
+    def __init__(
+        self,
+        chat_id,
+        keyword,
+        reply,
+        is_sticker=False,
+        is_document=False,
+        is_image=False,
+        is_audio=False,
+        is_voice=False,
+        is_video=False,
+        has_buttons=False,
+        reply_text=None,
+        file_type=1,
+        file_id=None,
+    ):
+        self.chat_id = str(chat_id)  # ensure string
+        self.keyword = keyword
+        self.reply = reply
+        self.is_sticker = is_sticker
+        self.is_document = is_document
+        self.is_image = is_image
+        self.is_audio = is_audio
+        self.is_voice = is_voice
+        self.is_video = is_video
+        self.has_buttons = has_buttons
+        self.has_markdown = True
+
+        self.reply_text = reply_text
+        self.file_type = file_type
+        self.file_id = file_id
+
+    def __repr__(self):
+        return "<Permissions 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 NewCustomFilters(BASE):
+    __tablename__ = "cust_filters_new"
+    chat_id = Column(String(14), primary_key=True)
+    keyword = Column(UnicodeText, primary_key=True, nullable=False)
+    text = Column(UnicodeText)
+    file_type = Column(Integer, nullable=False, default=1)
+    file_id = Column(UnicodeText, default=None)
+
+    def __init__(self, chat_id, keyword, text, file_type, file_id):
+        self.chat_id = str(chat_id)  # ensure string
+        self.keyword = keyword
+        self.text = text
+        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 add_filter(
+    chat_id,
+    keyword,
+    reply,
+    is_sticker=False,
+    is_document=False,
+    is_image=False,
+    is_audio=False,
+    is_voice=False,
+    is_video=False,
+    buttons=None,
+):
+    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,
+            is_sticker,
+            is_document,
+            is_image,
+            is_audio,
+            is_voice,
+            is_video,
+            bool(buttons),
+        )
+
+        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 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",
+            is_sticker=False,
+            is_document=False,
+            is_image=False,
+            is_audio=False,
+            is_voice=False,
+            is_video=False,
+            has_buttons=bool(buttons),
+            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):
+    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
+
+            print(str(x.chat_id), x.keyword, x.reply, file_type.value)
+            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()
+        try:
+            CHAT_FILTERS[str(new_chat_id)] = CHAT_FILTERS[str(old_chat_id)]
+        except KeyError:
+            pass
+        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,129 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+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 "ᴅɪsᴀʙʟᴇᴅ ᴄᴍᴅ {} 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/feds_sql.py

@@ -0,0 +1,931 @@
+import ast
+import threading
+
+from sqlalchemy import BigInteger, Boolean, Column, Integer, String, UnicodeText
+from telegram.error import BadRequest, Forbidden
+
+from Database.sql import BASE, SESSION
+from Mikobot import dispatcher
+
+
+class Federations(BASE):
+    __tablename__ = "feds"
+    owner_id = Column(String(14))
+    fed_name = Column(UnicodeText)
+    fed_id = Column(UnicodeText, primary_key=True)
+    fed_rules = Column(UnicodeText)
+    fed_log = Column(UnicodeText)
+    fed_users = Column(UnicodeText)
+
+    def __init__(self, owner_id, fed_name, fed_id, fed_rules, fed_log, fed_users):
+        self.owner_id = owner_id
+        self.fed_name = fed_name
+        self.fed_id = fed_id
+        self.fed_rules = fed_rules
+        self.fed_log = fed_log
+        self.fed_users = fed_users
+
+
+class ChatF(BASE):
+    __tablename__ = "chat_feds"
+    chat_id = Column(String(14), primary_key=True)
+    chat_name = Column(UnicodeText)
+    fed_id = Column(UnicodeText)
+
+    def __init__(self, chat_id, chat_name, fed_id):
+        self.chat_id = chat_id
+        self.chat_name = chat_name
+        self.fed_id = fed_id
+
+
+class BansF(BASE):
+    __tablename__ = "bans_feds"
+    fed_id = Column(UnicodeText, primary_key=True)
+    user_id = Column(String(14), primary_key=True)
+    first_name = Column(UnicodeText, nullable=False)
+    last_name = Column(UnicodeText)
+    user_name = Column(UnicodeText)
+    reason = Column(UnicodeText, default="")
+    time = Column(Integer, default=0)
+
+    def __init__(self, fed_id, user_id, first_name, last_name, user_name, reason, time):
+        self.fed_id = fed_id
+        self.user_id = user_id
+        self.first_name = first_name
+        self.last_name = last_name
+        self.user_name = user_name
+        self.reason = reason
+        self.time = time
+
+
+class FedsUserSettings(BASE):
+    __tablename__ = "feds_settings"
+    user_id = Column(BigInteger, primary_key=True)
+    should_report = Column(Boolean, default=True)
+
+    def __init__(self, user_id):
+        self.user_id = user_id
+
+    def __repr__(self):
+        return "<Feds report settings ({})>".format(self.user_id)
+
+
+class FedSubs(BASE):
+    __tablename__ = "feds_subs"
+    fed_id = Column(UnicodeText, primary_key=True)
+    fed_subs = Column(UnicodeText, primary_key=True, nullable=False)
+
+    def __init__(self, fed_id, fed_subs):
+        self.fed_id = fed_id
+        self.fed_subs = fed_subs
+
+    def __repr__(self):
+        return "<Fed {} subscribes for {}>".format(self.fed_id, self.fed_subs)
+
+
+# Dropping db
+# Federations.__table__.drop()
+# ChatF.__table__.drop()
+# BansF.__table__.drop()
+# FedSubs.__table__.drop()
+
+Federations.__table__.create(checkfirst=True)
+ChatF.__table__.create(checkfirst=True)
+BansF.__table__.create(checkfirst=True)
+FedsUserSettings.__table__.create(checkfirst=True)
+FedSubs.__table__.create(checkfirst=True)
+
+FEDS_LOCK = threading.RLock()
+CHAT_FEDS_LOCK = threading.RLock()
+FEDS_SETTINGS_LOCK = threading.RLock()
+FEDS_SUBSCRIBER_LOCK = threading.RLock()
+
+FEDERATION_BYNAME = {}
+FEDERATION_BYOWNER = {}
+FEDERATION_BYFEDID = {}
+
+FEDERATION_CHATS = {}
+FEDERATION_CHATS_BYID = {}
+
+FEDERATION_BANNED_FULL = {}
+FEDERATION_BANNED_USERID = {}
+
+FEDERATION_NOTIFICATION = {}
+FEDS_SUBSCRIBER = {}
+MYFEDS_SUBSCRIBER = {}
+
+
+def get_fed_info(fed_id):
+    get = FEDERATION_BYFEDID.get(str(fed_id))
+    if get is None:
+        return False
+    return get
+
+
+def get_fed_id(chat_id):
+    get = FEDERATION_CHATS.get(str(chat_id))
+    if get is None:
+        return False
+    else:
+        return get["fid"]
+
+
+def get_fed_name(chat_id):
+    get = FEDERATION_CHATS.get(str(chat_id))
+    if get is None:
+        return False
+    else:
+        return get["chat_name"]
+
+
+def get_user_fban(fed_id, user_id):
+    if not FEDERATION_BANNED_FULL.get(fed_id):
+        return False, False, False
+    user_info = FEDERATION_BANNED_FULL[fed_id].get(user_id)
+    if not user_info:
+        return None, None, None
+    return user_info["first_name"], user_info["reason"], user_info["time"]
+
+
+def get_user_admin_fed_name(user_id):
+    user_feds = []
+    for f in FEDERATION_BYFEDID:
+        if int(user_id) in ast.literal_eval(
+            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["members"]
+        ):
+            user_feds.append(FEDERATION_BYFEDID[f]["fname"])
+    return user_feds
+
+
+def get_user_owner_fed_name(user_id):
+    user_feds = []
+    for f in FEDERATION_BYFEDID:
+        if int(user_id) == int(
+            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["owner"]
+        ):
+            user_feds.append(FEDERATION_BYFEDID[f]["fname"])
+    return user_feds
+
+
+def get_user_admin_fed_full(user_id):
+    user_feds = []
+    for f in FEDERATION_BYFEDID:
+        if int(user_id) in ast.literal_eval(
+            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["members"]
+        ):
+            user_feds.append({"fed_id": f, "fed": FEDERATION_BYFEDID[f]})
+    return user_feds
+
+
+def get_user_owner_fed_full(user_id):
+    user_feds = []
+    for f in FEDERATION_BYFEDID:
+        if int(user_id) == int(
+            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["owner"]
+        ):
+            user_feds.append({"fed_id": f, "fed": FEDERATION_BYFEDID[f]})
+    return user_feds
+
+
+def get_user_fbanlist(user_id):
+    banlist = FEDERATION_BANNED_FULL
+    user_name = ""
+    fedname = []
+    for x in banlist:
+        if banlist[x].get(user_id):
+            if user_name == "":
+                user_name = banlist[x][user_id].get("first_name")
+            fedname.append([x, banlist[x][user_id].get("reason")])
+    return user_name, fedname
+
+
+def new_fed(owner_id, fed_name, fed_id):
+    with FEDS_LOCK:
+        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
+        fed = Federations(
+            str(owner_id),
+            fed_name,
+            str(fed_id),
+            "Rules is not set in this federation.",
+            None,
+            str({"owner": str(owner_id), "members": "[]"}),
+        )
+        SESSION.add(fed)
+        SESSION.commit()
+        FEDERATION_BYOWNER[str(owner_id)] = {
+            "fid": str(fed_id),
+            "fname": fed_name,
+            "frules": "Rules is not set in this federation.",
+            "flog": None,
+            "fusers": str({"owner": str(owner_id), "members": "[]"}),
+        }
+        FEDERATION_BYFEDID[str(fed_id)] = {
+            "owner": str(owner_id),
+            "fname": fed_name,
+            "frules": "Rules is not set in this federation.",
+            "flog": None,
+            "fusers": str({"owner": str(owner_id), "members": "[]"}),
+        }
+        FEDERATION_BYNAME[fed_name] = {
+            "fid": str(fed_id),
+            "owner": str(owner_id),
+            "frules": "Rules is not set in this federation.",
+            "flog": None,
+            "fusers": str({"owner": str(owner_id), "members": "[]"}),
+        }
+        return fed
+
+
+def del_fed(fed_id):
+    with FEDS_LOCK:
+        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME, FEDERATION_CHATS, FEDERATION_CHATS_BYID, FEDERATION_BANNED_USERID, FEDERATION_BANNED_FULL
+        getcache = FEDERATION_BYFEDID.get(fed_id)
+        if getcache is None:
+            return False
+        # Variables
+        getfed = FEDERATION_BYFEDID.get(fed_id)
+        owner_id = getfed["owner"]
+        fed_name = getfed["fname"]
+        # Delete from cache
+        FEDERATION_BYOWNER.pop(owner_id)
+        FEDERATION_BYFEDID.pop(fed_id)
+        FEDERATION_BYNAME.pop(fed_name)
+        if FEDERATION_CHATS_BYID.get(fed_id):
+            for x in FEDERATION_CHATS_BYID[fed_id]:
+                delchats = SESSION.query(ChatF).get(str(x))
+                if delchats:
+                    SESSION.delete(delchats)
+                    SESSION.commit()
+                FEDERATION_CHATS.pop(x)
+            FEDERATION_CHATS_BYID.pop(fed_id)
+        # Delete fedban users
+        getall = FEDERATION_BANNED_USERID.get(fed_id)
+        if getall:
+            for x in getall:
+                banlist = SESSION.query(BansF).get((fed_id, str(x)))
+                if banlist:
+                    SESSION.delete(banlist)
+                    SESSION.commit()
+        if FEDERATION_BANNED_USERID.get(fed_id):
+            FEDERATION_BANNED_USERID.pop(fed_id)
+        if FEDERATION_BANNED_FULL.get(fed_id):
+            FEDERATION_BANNED_FULL.pop(fed_id)
+        # Delete fedsubs
+        getall = MYFEDS_SUBSCRIBER.get(fed_id)
+        if getall:
+            for x in getall:
+                getsubs = SESSION.query(FedSubs).get((fed_id, str(x)))
+                if getsubs:
+                    SESSION.delete(getsubs)
+                    SESSION.commit()
+        if FEDS_SUBSCRIBER.get(fed_id):
+            FEDS_SUBSCRIBER.pop(fed_id)
+        if MYFEDS_SUBSCRIBER.get(fed_id):
+            MYFEDS_SUBSCRIBER.pop(fed_id)
+        # Delete from database
+        curr = SESSION.query(Federations).get(fed_id)
+        if curr:
+            SESSION.delete(curr)
+            SESSION.commit()
+        return True
+
+
+def rename_fed(fed_id, owner_id, newname):
+    with FEDS_LOCK:
+        global FEDERATION_BYFEDID, FEDERATION_BYOWNER, FEDERATION_BYNAME
+        fed = SESSION.query(Federations).get(fed_id)
+        if not fed:
+            return False
+        fed.fed_name = newname
+        SESSION.commit()
+
+        # Update the dicts
+        oldname = FEDERATION_BYFEDID[str(fed_id)]["fname"]
+        tempdata = FEDERATION_BYNAME[oldname]
+        FEDERATION_BYNAME.pop(oldname)
+
+        FEDERATION_BYOWNER[str(owner_id)]["fname"] = newname
+        FEDERATION_BYFEDID[str(fed_id)]["fname"] = newname
+        FEDERATION_BYNAME[newname] = tempdata
+        return True
+
+
+def chat_join_fed(fed_id, chat_name, chat_id):
+    with FEDS_LOCK:
+        global FEDERATION_CHATS, FEDERATION_CHATS_BYID
+        r = ChatF(chat_id, chat_name, fed_id)
+        SESSION.add(r)
+        FEDERATION_CHATS[str(chat_id)] = {"chat_name": chat_name, "fid": fed_id}
+        checkid = FEDERATION_CHATS_BYID.get(fed_id)
+        if checkid is None:
+            FEDERATION_CHATS_BYID[fed_id] = []
+        FEDERATION_CHATS_BYID[fed_id].append(str(chat_id))
+        SESSION.commit()
+        return r
+
+
+def search_fed_by_name(fed_name):
+    allfed = FEDERATION_BYNAME.get(fed_name)
+    if allfed is None:
+        return False
+    return allfed
+
+
+def search_user_in_fed(fed_id, user_id):
+    getfed = FEDERATION_BYFEDID.get(fed_id)
+    if getfed is None:
+        return False
+    getfed = ast.literal_eval(getfed["fusers"])["members"]
+    if user_id in ast.literal_eval(getfed):
+        return True
+    else:
+        return False
+
+
+def user_demote_fed(fed_id, user_id):
+    with FEDS_LOCK:
+        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
+        # Variables
+        getfed = FEDERATION_BYFEDID.get(str(fed_id))
+        owner_id = getfed["owner"]
+        fed_name = getfed["fname"]
+        fed_rules = getfed["frules"]
+        fed_log = getfed["flog"]
+        # Temp set
+        try:
+            members = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
+        except ValueError:
+            return False
+        members.remove(user_id)
+        # Set user
+        FEDERATION_BYOWNER[str(owner_id)]["fusers"] = str(
+            {"owner": str(owner_id), "members": str(members)},
+        )
+        FEDERATION_BYFEDID[str(fed_id)]["fusers"] = str(
+            {"owner": str(owner_id), "members": str(members)},
+        )
+        FEDERATION_BYNAME[fed_name]["fusers"] = str(
+            {"owner": str(owner_id), "members": str(members)},
+        )
+        # Set on database
+        fed = Federations(
+            str(owner_id),
+            fed_name,
+            str(fed_id),
+            fed_rules,
+            fed_log,
+            str({"owner": str(owner_id), "members": str(members)}),
+        )
+        SESSION.merge(fed)
+        SESSION.commit()
+        return True
+
+        curr = SESSION.query(UserF).all()
+        result = False
+        for r in curr:
+            if int(r.user_id) == int(user_id):
+                if r.fed_id == fed_id:
+                    SESSION.delete(r)
+                    SESSION.commit()
+                    result = True
+
+        SESSION.close()
+        return result
+
+
+def user_join_fed(fed_id, user_id):
+    with FEDS_LOCK:
+        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
+        # Variables
+        getfed = FEDERATION_BYFEDID.get(str(fed_id))
+        owner_id = getfed["owner"]
+        fed_name = getfed["fname"]
+        fed_rules = getfed["frules"]
+        fed_log = getfed["flog"]
+        # Temp set
+        members = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
+        members.append(user_id)
+        # Set user
+        FEDERATION_BYOWNER[str(owner_id)]["fusers"] = str(
+            {"owner": str(owner_id), "members": str(members)},
+        )
+        FEDERATION_BYFEDID[str(fed_id)]["fusers"] = str(
+            {"owner": str(owner_id), "members": str(members)},
+        )
+        FEDERATION_BYNAME[fed_name]["fusers"] = str(
+            {"owner": str(owner_id), "members": str(members)},
+        )
+        # Set on database
+        fed = Federations(
+            str(owner_id),
+            fed_name,
+            str(fed_id),
+            fed_rules,
+            fed_log,
+            str({"owner": str(owner_id), "members": str(members)}),
+        )
+        SESSION.merge(fed)
+        SESSION.commit()
+        __load_all_feds_chats()
+        return True
+
+
+def chat_leave_fed(chat_id):
+    with FEDS_LOCK:
+        global FEDERATION_CHATS, FEDERATION_CHATS_BYID
+        # Set variables
+        fed_info = FEDERATION_CHATS.get(str(chat_id))
+        if fed_info is None:
+            return False
+        fed_id = fed_info["fid"]
+        # Delete from cache
+        FEDERATION_CHATS.pop(str(chat_id))
+        FEDERATION_CHATS_BYID[str(fed_id)].remove(str(chat_id))
+        # Delete from db
+        curr = SESSION.query(ChatF).all()
+        for U in curr:
+            if int(U.chat_id) == int(chat_id):
+                SESSION.delete(U)
+                SESSION.commit()
+        return True
+
+
+def all_fed_chats(fed_id):
+    with FEDS_LOCK:
+        getfed = FEDERATION_CHATS_BYID.get(fed_id)
+        if getfed is None:
+            return []
+        else:
+            return getfed
+
+
+def all_fed_users(fed_id):
+    with FEDS_LOCK:
+        getfed = FEDERATION_BYFEDID.get(str(fed_id))
+        if getfed is None:
+            return False
+        fed_owner = ast.literal_eval(ast.literal_eval(getfed["fusers"])["owner"])
+        fed_admins = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
+        fed_admins.append(fed_owner)
+        return fed_admins
+
+
+def all_fed_members(fed_id):
+    with FEDS_LOCK:
+        getfed = FEDERATION_BYFEDID.get(str(fed_id))
+        fed_admins = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
+        return fed_admins
+
+
+def set_frules(fed_id, rules):
+    with FEDS_LOCK:
+        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
+        # Variables
+        getfed = FEDERATION_BYFEDID.get(str(fed_id))
+        owner_id = getfed["owner"]
+        fed_name = getfed["fname"]
+        fed_members = getfed["fusers"]
+        fed_rules = str(rules)
+        fed_log = getfed["flog"]
+        # Set user
+        FEDERATION_BYOWNER[str(owner_id)]["frules"] = fed_rules
+        FEDERATION_BYFEDID[str(fed_id)]["frules"] = fed_rules
+        FEDERATION_BYNAME[fed_name]["frules"] = fed_rules
+        # Set on database
+        fed = Federations(
+            str(owner_id),
+            fed_name,
+            str(fed_id),
+            fed_rules,
+            fed_log,
+            str(fed_members),
+        )
+        SESSION.merge(fed)
+        SESSION.commit()
+        return True
+
+
+def get_frules(fed_id):
+    with FEDS_LOCK:
+        rules = FEDERATION_BYFEDID[str(fed_id)]["frules"]
+        return rules
+
+
+def fban_user(fed_id, user_id, first_name, last_name, user_name, reason, time):
+    with FEDS_LOCK:
+        r = SESSION.query(BansF).all()
+        for I in r:
+            if I.fed_id == fed_id:
+                if int(I.user_id) == int(user_id):
+                    SESSION.delete(I)
+
+        r = BansF(
+            str(fed_id),
+            str(user_id),
+            first_name,
+            last_name,
+            user_name,
+            reason,
+            time,
+        )
+
+        SESSION.add(r)
+        try:
+            SESSION.commit()
+        except:
+            SESSION.rollback()
+            return False
+        finally:
+            SESSION.commit()
+        __load_all_feds_banned()
+        return r
+
+
+def multi_fban_user(
+    multi_fed_id,
+    multi_user_id,
+    multi_first_name,
+    multi_last_name,
+    multi_user_name,
+    multi_reason,
+):
+    if True:  # with FEDS_LOCK:
+        counter = 0
+        time = 0
+        for x in range(len(multi_fed_id)):
+            fed_id = multi_fed_id[x]
+            user_id = multi_user_id[x]
+            first_name = multi_first_name[x]
+            last_name = multi_last_name[x]
+            user_name = multi_user_name[x]
+            reason = multi_reason[x]
+            r = SESSION.query(BansF).all()
+            for I in r:
+                if I.fed_id == fed_id:
+                    if int(I.user_id) == int(user_id):
+                        SESSION.delete(I)
+
+            r = BansF(
+                str(fed_id),
+                str(user_id),
+                first_name,
+                last_name,
+                user_name,
+                reason,
+                time,
+            )
+
+            SESSION.add(r)
+            counter += 1
+        try:
+            SESSION.commit()
+        except:
+            SESSION.rollback()
+            return False
+        finally:
+            SESSION.commit()
+        __load_all_feds_banned()
+        return counter
+
+
+def un_fban_user(fed_id, user_id):
+    with FEDS_LOCK:
+        r = SESSION.query(BansF).all()
+        for I in r:
+            if I.fed_id == fed_id:
+                if int(I.user_id) == int(user_id):
+                    SESSION.delete(I)
+        try:
+            SESSION.commit()
+        except:
+            SESSION.rollback()
+            return False
+        finally:
+            SESSION.commit()
+        __load_all_feds_banned()
+        return I
+
+
+def get_fban_user(fed_id, user_id):
+    list_fbanned = FEDERATION_BANNED_USERID.get(fed_id)
+    if list_fbanned is None:
+        FEDERATION_BANNED_USERID[fed_id] = []
+    if user_id in FEDERATION_BANNED_USERID[fed_id]:
+        r = SESSION.query(BansF).all()
+        reason = None
+        for I in r:
+            if I.fed_id == fed_id:
+                if int(I.user_id) == int(user_id):
+                    reason = I.reason
+                    time = I.time
+        return True, reason, time
+    else:
+        return False, None, None
+
+
+def get_all_fban_users(fed_id):
+    list_fbanned = FEDERATION_BANNED_USERID.get(fed_id)
+    if list_fbanned is None:
+        FEDERATION_BANNED_USERID[fed_id] = []
+    return FEDERATION_BANNED_USERID[fed_id]
+
+
+def get_all_fban_users_target(fed_id, user_id):
+    list_fbanned = FEDERATION_BANNED_FULL.get(fed_id)
+    if list_fbanned is None:
+        FEDERATION_BANNED_FULL[fed_id] = []
+        return False
+    getuser = list_fbanned[str(user_id)]
+    return getuser
+
+
+def get_all_fban_users_global():
+    list_fbanned = FEDERATION_BANNED_USERID
+    total = []
+    for x in list(FEDERATION_BANNED_USERID):
+        for y in FEDERATION_BANNED_USERID[x]:
+            total.append(y)
+    return total
+
+
+def get_all_feds_users_global():
+    list_fed = FEDERATION_BYFEDID
+    total = []
+    for x in list(FEDERATION_BYFEDID):
+        total.append(FEDERATION_BYFEDID[x])
+    return total
+
+
+def search_fed_by_id(fed_id):
+    get = FEDERATION_BYFEDID.get(fed_id)
+    if get is None:
+        return False
+    else:
+        return get
+    result = False
+    for Q in curr:
+        if Q.fed_id == fed_id:
+            result = Q.fed_id
+
+    return result
+
+
+def user_feds_report(user_id: int) -> bool:
+    user_setting = FEDERATION_NOTIFICATION.get(str(user_id))
+    if user_setting is None:
+        user_setting = True
+    return user_setting
+
+
+def set_feds_setting(user_id: int, setting: bool):
+    with FEDS_SETTINGS_LOCK:
+        global FEDERATION_NOTIFICATION
+        user_setting = SESSION.query(FedsUserSettings).get(user_id)
+        if not user_setting:
+            user_setting = FedsUserSettings(user_id)
+
+        user_setting.should_report = setting
+        FEDERATION_NOTIFICATION[str(user_id)] = setting
+        SESSION.add(user_setting)
+        SESSION.commit()
+
+
+async def get_fed_log(fed_id):
+    fed_setting = FEDERATION_BYFEDID.get(str(fed_id))
+    if fed_setting is None:
+        fed_setting = False
+        return fed_setting
+    if fed_setting.get("flog") is None:
+        return False
+    elif fed_setting.get("flog"):
+        try:
+            await dispatcher.bot.get_chat(fed_setting.get("flog"))
+        except BadRequest:
+            set_fed_log(fed_id, None)
+            return False
+        except Forbidden:
+            set_fed_log(fed_id, None)
+            return False
+        return fed_setting.get("flog")
+    else:
+        return False
+
+
+def set_fed_log(fed_id, chat_id):
+    with FEDS_LOCK:
+        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
+        # Variables
+        getfed = FEDERATION_BYFEDID.get(str(fed_id))
+        owner_id = getfed["owner"]
+        fed_name = getfed["fname"]
+        fed_members = getfed["fusers"]
+        fed_rules = getfed["frules"]
+        fed_log = str(chat_id)
+        # Set user
+        FEDERATION_BYOWNER[str(owner_id)]["flog"] = fed_log
+        FEDERATION_BYFEDID[str(fed_id)]["flog"] = fed_log
+        FEDERATION_BYNAME[fed_name]["flog"] = fed_log
+        # Set on database
+        fed = Federations(
+            str(owner_id),
+            fed_name,
+            str(fed_id),
+            fed_rules,
+            fed_log,
+            str(fed_members),
+        )
+        SESSION.merge(fed)
+        SESSION.commit()
+        return True
+
+
+def subs_fed(fed_id, my_fed):
+    check = get_spec_subs(fed_id, my_fed)
+    if check:
+        return False
+    with FEDS_SUBSCRIBER_LOCK:
+        subsfed = FedSubs(fed_id, my_fed)
+
+        SESSION.merge(subsfed)  # merge to avoid duplicate key issues
+        SESSION.commit()
+        global FEDS_SUBSCRIBER, MYFEDS_SUBSCRIBER
+        # Temporary Data For Subbed Feds
+        if FEDS_SUBSCRIBER.get(fed_id, set()) == set():
+            FEDS_SUBSCRIBER[fed_id] = {my_fed}
+        else:
+            FEDS_SUBSCRIBER.get(fed_id, set()).add(my_fed)
+        # Temporary data for Fed Subs
+        if MYFEDS_SUBSCRIBER.get(my_fed, set()) == set():
+            MYFEDS_SUBSCRIBER[my_fed] = {fed_id}
+        else:
+            MYFEDS_SUBSCRIBER.get(my_fed, set()).add(fed_id)
+        return True
+
+
+def unsubs_fed(fed_id, my_fed):
+    with FEDS_SUBSCRIBER_LOCK:
+        getsubs = SESSION.query(FedSubs).get((fed_id, my_fed))
+        if getsubs:
+            if my_fed in FEDS_SUBSCRIBER.get(fed_id, set()):  # sanity check
+                FEDS_SUBSCRIBER.get(fed_id, set()).remove(my_fed)
+            if fed_id in MYFEDS_SUBSCRIBER.get(my_fed, set()):  # sanity check
+                MYFEDS_SUBSCRIBER.get(my_fed, set()).remove(fed_id)
+
+            SESSION.delete(getsubs)
+            SESSION.commit()
+            return True
+
+        SESSION.close()
+        return False
+
+
+def get_all_subs(fed_id):
+    return FEDS_SUBSCRIBER.get(fed_id, set())
+
+
+def get_spec_subs(fed_id, fed_target):
+    if FEDS_SUBSCRIBER.get(fed_id, set()) == set():
+        return {}
+    else:
+        return FEDS_SUBSCRIBER.get(fed_id, fed_target)
+
+
+def get_mysubs(my_fed):
+    return list(MYFEDS_SUBSCRIBER.get(my_fed))
+
+
+def get_subscriber(fed_id):
+    return FEDS_SUBSCRIBER.get(fed_id, set())
+
+
+def __load_all_feds():
+    global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
+    try:
+        feds = SESSION.query(Federations).all()
+        for x in feds:  # remove tuple by ( ,)
+            # Fed by Owner
+            check = FEDERATION_BYOWNER.get(x.owner_id)
+            if check is None:
+                FEDERATION_BYOWNER[x.owner_id] = []
+            FEDERATION_BYOWNER[str(x.owner_id)] = {
+                "fid": str(x.fed_id),
+                "fname": x.fed_name,
+                "frules": x.fed_rules,
+                "flog": x.fed_log,
+                "fusers": str(x.fed_users),
+            }
+            # Fed By FedId
+            check = FEDERATION_BYFEDID.get(x.fed_id)
+            if check is None:
+                FEDERATION_BYFEDID[x.fed_id] = []
+            FEDERATION_BYFEDID[str(x.fed_id)] = {
+                "owner": str(x.owner_id),
+                "fname": x.fed_name,
+                "frules": x.fed_rules,
+                "flog": x.fed_log,
+                "fusers": str(x.fed_users),
+            }
+            # Fed By Name
+            check = FEDERATION_BYNAME.get(x.fed_name)
+            if check is None:
+                FEDERATION_BYNAME[x.fed_name] = []
+            FEDERATION_BYNAME[x.fed_name] = {
+                "fid": str(x.fed_id),
+                "owner": str(x.owner_id),
+                "frules": x.fed_rules,
+                "flog": x.fed_log,
+                "fusers": str(x.fed_users),
+            }
+    finally:
+        SESSION.close()
+
+
+def __load_all_feds_chats():
+    global FEDERATION_CHATS, FEDERATION_CHATS_BYID
+    try:
+        qall = SESSION.query(ChatF).all()
+        FEDERATION_CHATS = {}
+        FEDERATION_CHATS_BYID = {}
+        for x in qall:
+            # Federation Chats
+            check = FEDERATION_CHATS.get(x.chat_id)
+            if check is None:
+                FEDERATION_CHATS[x.chat_id] = {}
+            FEDERATION_CHATS[x.chat_id] = {"chat_name": x.chat_name, "fid": x.fed_id}
+            # Federation Chats By ID
+            check = FEDERATION_CHATS_BYID.get(x.fed_id)
+            if check is None:
+                FEDERATION_CHATS_BYID[x.fed_id] = []
+            FEDERATION_CHATS_BYID[x.fed_id].append(x.chat_id)
+    finally:
+        SESSION.close()
+
+
+def __load_all_feds_banned():
+    global FEDERATION_BANNED_USERID, FEDERATION_BANNED_FULL
+    try:
+        FEDERATION_BANNED_USERID = {}
+        FEDERATION_BANNED_FULL = {}
+        qall = SESSION.query(BansF).all()
+        for x in qall:
+            check = FEDERATION_BANNED_USERID.get(x.fed_id)
+            if check is None:
+                FEDERATION_BANNED_USERID[x.fed_id] = []
+            if int(x.user_id) not in FEDERATION_BANNED_USERID[x.fed_id]:
+                FEDERATION_BANNED_USERID[x.fed_id].append(int(x.user_id))
+            check = FEDERATION_BANNED_FULL.get(x.fed_id)
+            if check is None:
+                FEDERATION_BANNED_FULL[x.fed_id] = {}
+            FEDERATION_BANNED_FULL[x.fed_id][x.user_id] = {
+                "first_name": x.first_name,
+                "last_name": x.last_name,
+                "user_name": x.user_name,
+                "reason": x.reason,
+                "time": x.time,
+            }
+    finally:
+        SESSION.close()
+
+
+def __load_all_feds_settings():
+    global FEDERATION_NOTIFICATION
+    try:
+        getuser = SESSION.query(FedsUserSettings).all()
+        for x in getuser:
+            FEDERATION_NOTIFICATION[str(x.user_id)] = x.should_report
+    finally:
+        SESSION.close()
+
+
+def __load_feds_subscriber():
+    global FEDS_SUBSCRIBER
+    global MYFEDS_SUBSCRIBER
+    try:
+        feds = SESSION.query(FedSubs.fed_id).distinct().all()
+        for (fed_id,) in feds:  # remove tuple by ( ,)
+            FEDS_SUBSCRIBER[fed_id] = []
+            MYFEDS_SUBSCRIBER[fed_id] = []
+
+        all_fedsubs = SESSION.query(FedSubs).all()
+        for x in all_fedsubs:
+            FEDS_SUBSCRIBER[x.fed_id] += [x.fed_subs]
+            try:
+                MYFEDS_SUBSCRIBER[x.fed_subs] += [x.fed_id]
+            except KeyError:
+                getsubs = SESSION.query(FedSubs).get((x.fed_id, x.fed_subs))
+                if getsubs:
+                    SESSION.delete(getsubs)
+                    SESSION.commit()
+
+        FEDS_SUBSCRIBER = {x: set(y) for x, y in FEDS_SUBSCRIBER.items()}
+        MYFEDS_SUBSCRIBER = {x: set(y) for x, y in MYFEDS_SUBSCRIBER.items()}
+
+    finally:
+        SESSION.close()
+
+
+__load_all_feds()
+__load_all_feds_chats()
+__load_all_feds_banned()
+__load_all_feds_settings()
+__load_feds_subscriber()

Database/sql/fontsql.py

@@ -0,0 +1,2361 @@
+class Fonts:
+    def typewriter(text):
+        style = {
+            "a": "𝚊",
+            "b": "𝚋",
+            "c": "𝚌",
+            "d": "𝚍",
+            "e": "𝚎",
+            "f": "𝚏",
+            "g": "𝚐",
+            "h": "𝚑",
+            "i": "𝚒",
+            "j": "𝚓",
+            "k": "𝚔",
+            "l": "𝚕",
+            "m": "𝚖",
+            "n": "𝚗",
+            "o": "𝚘",
+            "p": "𝚙",
+            "q": "𝚚",
+            "r": "𝚛",
+            "s": "𝚜",
+            "t": "𝚝",
+            "u": "𝚞",
+            "v": "𝚟",
+            "w": "𝚠",
+            "x": "𝚡",
+            "y": "𝚢",
+            "z": "𝚣",
+            "A": "𝙰",
+            "B": "𝙱",
+            "C": "𝙲",
+            "D": "𝙳",
+            "E": "𝙴",
+            "F": "𝙵",
+            "G": "𝙶",
+            "H": "𝙷",
+            "I": "𝙸",
+            "J": "𝙹",
+            "K": "𝙺",
+            "L": "𝙻",
+            "M": "𝙼",
+            "N": "𝙽",
+            "O": "𝙾",
+            "P": "𝙿",
+            "Q": "𝚀",
+            "R": "𝚁",
+            "S": "𝚂",
+            "T": "𝚃",
+            "U": "𝚄",
+            "V": "𝚅",
+            "W": "𝚆",
+            "X": "𝚇",
+            "Y": "𝚈",
+            "Z": "𝚉",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def outline(text):
+        style = {
+            "a": "𝕒",
+            "b": "𝕓",
+            "c": "𝕔",
+            "d": "𝕕",
+            "e": "𝕖",
+            "f": "𝕗",
+            "g": "𝕘",
+            "h": "𝕙",
+            "i": "𝕚",
+            "j": "𝕛",
+            "k": "𝕜",
+            "l": "𝕝",
+            "m": "𝕞",
+            "n": "𝕟",
+            "o": "𝕠",
+            "p": "𝕡",
+            "q": "𝕢",
+            "r": "𝕣",
+            "s": "𝕤",
+            "t": "𝕥",
+            "u": "𝕦",
+            "v": "𝕧",
+            "w": "𝕨",
+            "x": "𝕩",
+            "y": "𝕪",
+            "z": "𝕫",
+            "A": "𝔸",
+            "B": "𝔹",
+            "C": "ℂ",
+            "D": "𝔻",
+            "E": "𝔼",
+            "F": "𝔽",
+            "G": "𝔾",
+            "H": "ℍ",
+            "I": "𝕀",
+            "J": "𝕁",
+            "K": "𝕂",
+            "L": "𝕃",
+            "M": "𝕄",
+            "N": "ℕ",
+            "O": "𝕆",
+            "P": "ℙ",
+            "Q": "ℚ",
+            "R": "ℝ",
+            "S": "𝕊",
+            "T": "𝕋",
+            "U": "𝕌",
+            "V": "𝕍",
+            "W": "𝕎",
+            "X": "𝕏",
+            "Y": "𝕐",
+            "Z": "ℤ",
+            "0": "𝟘",
+            "1": "𝟙",
+            "2": "𝟚",
+            "3": "𝟛",
+            "4": "𝟜",
+            "5": "𝟝",
+            "6": "𝟞",
+            "7": "𝟟",
+            "8": "𝟠",
+            "9": "𝟡",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def serief(text):
+        style = {
+            "a": "𝐚",
+            "b": "𝐛",
+            "c": "𝐜",
+            "d": "𝐝",
+            "e": "𝐞",
+            "f": "𝐟",
+            "g": "𝐠",
+            "h": "𝐡",
+            "i": "𝐢",
+            "j": "𝐣",
+            "k": "𝐤",
+            "l": "𝐥",
+            "m": "𝐦",
+            "n": "𝐧",
+            "o": "𝐨",
+            "p": "𝐩",
+            "q": "𝐪",
+            "r": "𝐫",
+            "s": "𝐬",
+            "t": "𝐭",
+            "u": "𝐮",
+            "v": "𝐯",
+            "w": "𝐰",
+            "x": "𝐱",
+            "y": "𝐲",
+            "z": "𝐳",
+            "A": "𝐀",
+            "B": "𝐁",
+            "C": "𝐂",
+            "D": "𝐃",
+            "E": "𝐄",
+            "F": "𝐅",
+            "G": "𝐆",
+            "H": "𝐇",
+            "I": "𝐈",
+            "J": "𝐉",
+            "K": "𝐊",
+            "L": "𝐋",
+            "M": "𝐌",
+            "N": "𝐍",
+            "O": "𝐎",
+            "P": "𝐏",
+            "Q": "𝐐",
+            "R": "𝐑",
+            "S": "𝐒",
+            "T": "𝐓",
+            "U": "𝐔",
+            "V": "𝐕",
+            "W": "𝐖",
+            "X": "𝐗",
+            "Y": "𝐘",
+            "Z": "𝐙",
+            "0": "𝟎",
+            "1": "𝟏",
+            "2": "𝟐",
+            "3": "𝟑",
+            "4": "𝟒",
+            "5": "𝟓",
+            "6": "𝟔",
+            "7": "𝟕",
+            "8": "𝟖",
+            "9": "𝟗",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def bold_cool(text):
+        style = {
+            "a": "𝒂",
+            "b": "𝒃",
+            "c": "𝒄",
+            "d": "𝒅",
+            "e": "𝒆",
+            "f": "𝒇",
+            "g": "𝒈",
+            "h": "𝒉",
+            "i": "𝒊",
+            "j": "𝒋",
+            "k": "𝒌",
+            "l": "𝒍",
+            "m": "𝒎",
+            "n": "𝒏",
+            "o": "𝒐",
+            "p": "𝒑",
+            "q": "𝒒",
+            "r": "𝒓",
+            "s": "𝒔",
+            "t": "𝒕",
+            "u": "𝒖",
+            "v": "𝒗",
+            "w": "𝒘",
+            "x": "𝒙",
+            "y": "𝒚",
+            "z": "𝒛",
+            "A": "𝑨",
+            "B": "𝑩",
+            "C": "𝑪",
+            "D": "𝑫",
+            "E": "𝑬",
+            "F": "𝑭",
+            "G": "𝑮",
+            "H": "𝑯",
+            "I": "𝑰",
+            "J": "𝑱",
+            "K": "𝑲",
+            "L": "𝑳",
+            "M": "𝑴",
+            "N": "𝑵",
+            "O": "𝑶",
+            "P": "𝑷",
+            "Q": "𝑸",
+            "R": "𝑹",
+            "S": "𝑺",
+            "T": "𝑻",
+            "U": "𝑼",
+            "V": "𝑽",
+            "W": "𝑾",
+            "X": "𝑿",
+            "Y": "𝒀",
+            "Z": "𝒁",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def cool(text):
+        style = {
+            "a": "𝑎",
+            "b": "𝑏",
+            "c": "𝑐",
+            "d": "𝑑",
+            "e": "𝑒",
+            "f": "𝑓",
+            "g": "𝑔",
+            "h": "ℎ",
+            "i": "𝑖",
+            "j": "𝑗",
+            "k": "𝑘",
+            "l": "𝑙",
+            "m": "𝑚",
+            "n": "𝑛",
+            "o": "𝑜",
+            "p": "𝑝",
+            "q": "𝑞",
+            "r": "𝑟",
+            "s": "𝑠",
+            "t": "𝑡",
+            "u": "𝑢",
+            "v": "𝑣",
+            "w": "𝑤",
+            "x": "𝑥",
+            "y": "𝑦",
+            "z": "𝑧",
+            "A": "𝐴",
+            "B": "𝐵",
+            "C": "𝐶",
+            "D": "𝐷",
+            "E": "𝐸",
+            "F": "𝐹",
+            "G": "𝐺",
+            "H": "𝐻",
+            "I": "𝐼",
+            "J": "𝐽",
+            "K": "𝐾",
+            "L": "𝐿",
+            "M": "𝑀",
+            "N": "𝑁",
+            "O": "𝑂",
+            "P": "𝑃",
+            "Q": "𝑄",
+            "R": "𝑅",
+            "S": "𝑆",
+            "T": "𝑇",
+            "U": "𝑈",
+            "V": "𝑉",
+            "W": "𝑊",
+            "X": "𝑋",
+            "Y": "𝑌",
+            "Z": "𝑍",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def smallcap(text):
+        style = {
+            "a": "ᴀ",
+            "b": "ʙ",
+            "c": "ᴄ",
+            "d": "ᴅ",
+            "e": "ᴇ",
+            "f": "ғ",
+            "g": "ɢ",
+            "h": "ʜ",
+            "i": "ɪ",
+            "j": "J",
+            "k": "ᴋ",
+            "l": "ʟ",
+            "m": "ᴍ",
+            "n": "ɴ",
+            "o": "ᴏ",
+            "p": "ᴘ",
+            "q": "ǫ",
+            "r": "ʀ",
+            "s": "s",
+            "t": "ᴛ",
+            "u": "ᴜ",
+            "v": "ᴠ",
+            "w": "ᴡ",
+            "x": "x",
+            "y": "ʏ",
+            "z": "ᴢ",
+            "A": "A",
+            "B": "B",
+            "C": "C",
+            "D": "D",
+            "E": "E",
+            "F": "F",
+            "G": "G",
+            "H": "H",
+            "I": "I",
+            "J": "J",
+            "K": "K",
+            "L": "L",
+            "M": "M",
+            "N": "N",
+            "O": "O",
+            "P": "P",
+            "Q": "Q",
+            "R": "R",
+            "S": "S",
+            "T": "T",
+            "U": "U",
+            "V": "V",
+            "W": "W",
+            "X": "X",
+            "Y": "Y",
+            "Z": "Z",
+            "0": "𝟶",
+            "1": "𝟷",
+            "2": "𝟸",
+            "3": "𝟹",
+            "4": "𝟺",
+            "5": "𝟻",
+            "6": "𝟼",
+            "7": "𝟽",
+            "8": "𝟾",
+            "9": "𝟿",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def script(text):
+        style = {
+            "a": "𝒶",
+            "b": "𝒷",
+            "c": "𝒸",
+            "d": "𝒹",
+            "e": "ℯ",
+            "f": "𝒻",
+            "g": "ℊ",
+            "h": "𝒽",
+            "i": "𝒾",
+            "j": "𝒿",
+            "k": "𝓀",
+            "l": "𝓁",
+            "m": "𝓂",
+            "n": "𝓃",
+            "o": "ℴ",
+            "p": "𝓅",
+            "q": "𝓆",
+            "r": "𝓇",
+            "s": "��",
+            "t": "𝓉",
+            "u": "𝓊",
+            "v": "𝓋",
+            "w": "𝓌",
+            "x": "𝓍",
+            "y": "𝓎",
+            "z": "𝓏",
+            "A": "𝒜",
+            "B": "ℬ",
+            "C": "𝒞",
+            "D": "𝒟",
+            "E": "ℰ",
+            "F": "ℱ",
+            "G": "𝒢",
+            "H": "ℋ",
+            "I": "ℐ",
+            "J": "𝒥",
+            "K": "𝒦",
+            "L": "ℒ",
+            "M": "ℳ",
+            "N": "𝒩",
+            "O": "𝒪",
+            "P": "𝒫",
+            "Q": "𝒬",
+            "R": "ℛ",
+            "S": "𝒮",
+            "T": "𝒯",
+            "U": "𝒰",
+            "V": "𝒱",
+            "W": "𝒲",
+            "X": "𝒳",
+            "Y": "𝒴",
+            "Z": "𝒵",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def bold_script(text):
+        style = {
+            "a": "𝓪",
+            "b": "𝓫",
+            "c": "𝓬",
+            "d": "𝓭",
+            "e": "𝓮",
+            "f": "𝓯",
+            "g": "𝓰",
+            "h": "𝓱",
+            "i": "𝓲",
+            "j": "𝓳",
+            "k": "𝓴",
+            "l": "𝓵",
+            "m": "𝓶",
+            "n": "𝓷",
+            "o": "𝓸",
+            "p": "𝓹",
+            "q": "𝓺",
+            "r": "𝓻",
+            "s": "𝓼",
+            "t": "𝓽",
+            "u": "𝓾",
+            "v": "𝓿",
+            "w": "𝔀",
+            "x": "𝔁",
+            "y": "𝔂",
+            "z": "𝔃",
+            "A": "𝓐",
+            "B": "𝓑",
+            "C": "𝓒",
+            "D": "𝓓",
+            "E": "𝓔",
+            "F": "𝓕",
+            "G": "𝓖",
+            "H": "𝓗",
+            "I": "𝓘",
+            "J": "𝓙",
+            "K": "𝓚",
+            "L": "𝓛",
+            "M": "𝓜",
+            "N": "𝓝",
+            "O": "𝓞",
+            "P": "𝓟",
+            "Q": "𝓠",
+            "R": "𝓡",
+            "S": "𝓢",
+            "T": "𝓣",
+            "U": "𝓤",
+            "V": "𝓥",
+            "W": "𝓦",
+            "X": "𝓧",
+            "Y": "𝓨",
+            "Z": "𝓩",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def tiny(text):
+        style = {
+            "a": "ᵃ",
+            "b": "ᵇ",
+            "c": "ᶜ",
+            "d": "ᵈ",
+            "e": "ᵉ",
+            "f": "ᶠ",
+            "g": "ᵍ",
+            "h": "ʰ",
+            "i": "ⁱ",
+            "j": "ʲ",
+            "k": "ᵏ",
+            "l": "ˡ",
+            "m": "ᵐ",
+            "n": "ⁿ",
+            "o": "ᵒ",
+            "p": "ᵖ",
+            "q": "ᵠ",
+            "r": "ʳ",
+            "s": "ˢ",
+            "t": "ᵗ",
+            "u": "ᵘ",
+            "v": "ᵛ",
+            "w": "ʷ",
+            "x": "ˣ",
+            "y": "ʸ",
+            "z": "ᶻ",
+            "A": "ᵃ",
+            "B": "ᵇ",
+            "C": "ᶜ",
+            "D": "ᵈ",
+            "E": "ᵉ",
+            "F": "ᶠ",
+            "G": "ᵍ",
+            "H": "ʰ",
+            "I": "ⁱ",
+            "J": "ʲ",
+            "K": "ᵏ",
+            "L": "ˡ",
+            "M": "ᵐ",
+            "N": "ⁿ",
+            "O": "ᵒ",
+            "P": "ᵖ",
+            "Q": "ᵠ",
+            "R": "ʳ",
+            "S": "ˢ",
+            "T": "ᵗ",
+            "U": "ᵘ",
+            "V": "ᵛ",
+            "W": "ʷ",
+            "X": "ˣ",
+            "Y": "ʸ",
+            "Z": "ᶻ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def comic(text):
+        style = {
+            "a": "ᗩ",
+            "b": "ᗷ",
+            "c": "ᑕ",
+            "d": "ᗪ",
+            "e": "ᗴ",
+            "f": "ᖴ",
+            "g": "ᘜ",
+            "h": "ᕼ",
+            "i": "I",
+            "j": "ᒍ",
+            "k": "K",
+            "l": "ᒪ",
+            "m": "ᗰ",
+            "n": "ᑎ",
+            "o": "O",
+            "p": "ᑭ",
+            "q": "ᑫ",
+            "r": "ᖇ",
+            "s": "Տ",
+            "t": "T",
+            "u": "ᑌ",
+            "v": "ᐯ",
+            "w": "ᗯ",
+            "x": "᙭",
+            "y": "Y",
+            "z": "ᘔ",
+            "A": "ᗩ",
+            "B": "ᗷ",
+            "C": "ᑕ",
+            "D": "ᗪ",
+            "E": "ᗴ",
+            "F": "ᖴ",
+            "G": "ᘜ",
+            "H": "ᕼ",
+            "I": "I",
+            "J": "ᒍ",
+            "K": "K",
+            "L": "ᒪ",
+            "M": "ᗰ",
+            "N": "ᑎ",
+            "O": "O",
+            "P": "ᑭ",
+            "Q": "ᑫ",
+            "R": "ᖇ",
+            "S": "Տ",
+            "T": "T",
+            "U": "ᑌ",
+            "V": "���",
+            "W": "ᗯ",
+            "X": "᙭",
+            "Y": "Y",
+            "Z": "ᘔ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def san(text):
+        style = {
+            "a": "𝗮",
+            "b": "𝗯",
+            "c": "𝗰",
+            "d": "𝗱",
+            "e": "𝗲",
+            "f": "𝗳",
+            "g": "𝗴",
+            "h": "𝗵",
+            "i": "𝗶",
+            "j": "𝗷",
+            "k": "𝗸",
+            "l": "𝗹",
+            "m": "𝗺",
+            "n": "𝗻",
+            "o": "𝗼",
+            "p": "𝗽",
+            "q": "𝗾",
+            "r": "𝗿",
+            "s": "𝘀",
+            "t": "𝘁",
+            "u": "𝘂",
+            "v": "𝘃",
+            "w": "𝘄",
+            "x": "𝘅",
+            "y": "𝘆",
+            "z": "𝘇",
+            "A": "𝗔",
+            "B": "𝗕",
+            "C": "𝗖",
+            "D": "𝗗",
+            "E": "𝗘",
+            "F": "𝗙",
+            "G": "𝗚",
+            "H": "𝗛",
+            "I": "𝗜",
+            "J": "𝗝",
+            "K": "𝗞",
+            "L": "𝗟",
+            "M": "𝗠",
+            "N": "𝗡",
+            "O": "𝗢",
+            "P": "𝗣",
+            "Q": "𝗤",
+            "R": "𝗥",
+            "S": "𝗦",
+            "T": "𝗧",
+            "U": "𝗨",
+            "V": "𝗩",
+            "W": "𝗪",
+            "X": "𝗫",
+            "Y": "𝗬",
+            "Z": "𝗭",
+            "0": "𝟬",
+            "1": "𝟭",
+            "2": "𝟮",
+            "3": "𝟯",
+            "4": "𝟰",
+            "5": "𝟱",
+            "6": "𝟲",
+            "7": "𝟳",
+            "8": "𝟴",
+            "9": "𝟵",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def slant_san(text):
+        style = {
+            "a": "𝙖",
+            "b": "𝙗",
+            "c": "𝙘",
+            "d": "𝙙",
+            "e": "𝙚",
+            "f": "𝙛",
+            "g": "𝙜",
+            "h": "𝙝",
+            "i": "𝙞",
+            "j": "𝙟",
+            "k": "𝙠",
+            "l": "𝙡",
+            "m": "𝙢",
+            "n": "𝙣",
+            "o": "𝙤",
+            "p": "𝙥",
+            "q": "𝙦",
+            "r": "𝙧",
+            "s": "𝙨",
+            "t": "𝙩",
+            "u": "𝙪",
+            "v": "𝙫",
+            "w": "𝙬",
+            "x": "𝙭",
+            "y": "𝙮",
+            "z": "𝙯",
+            "A": "𝘼",
+            "B": "𝘽",
+            "C": "𝘾",
+            "D": "𝘿",
+            "E": "𝙀",
+            "F": "𝙁",
+            "G": "𝙂",
+            "H": "𝙃",
+            "I": "𝙄",
+            "J": "𝙅",
+            "K": "𝙆",
+            "L": "𝙇",
+            "M": "𝙈",
+            "N": "𝙉",
+            "O": "𝙊",
+            "P": "𝙋",
+            "Q": "𝙌",
+            "R": "𝙍",
+            "S": "𝙎",
+            "T": "𝙏",
+            "U": "𝙐",
+            "V": "𝙑",
+            "W": "𝙒",
+            "X": "𝙓",
+            "Y": "𝙔",
+            "Z": "𝙕",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def slant(text):
+        style = {
+            "a": "𝘢",
+            "b": "𝘣",
+            "c": "𝘤",
+            "d": "𝘥",
+            "e": "𝘦",
+            "f": "𝘧",
+            "g": "𝘨",
+            "h": "𝘩",
+            "i": "𝘪",
+            "j": "𝘫",
+            "k": "𝘬",
+            "l": "𝘭",
+            "m": "𝘮",
+            "n": "𝘯",
+            "o": "𝘰",
+            "p": "𝘱",
+            "q": "𝘲",
+            "r": "𝘳",
+            "s": "𝘴",
+            "t": "𝘵",
+            "u": "𝘶",
+            "v": "𝘷",
+            "w": "𝘸",
+            "x": "𝘹",
+            "y": "𝘺",
+            "z": "𝘻",
+            "A": "𝘈",
+            "B": "𝘉",
+            "C": "𝘊",
+            "D": "𝘋",
+            "E": "𝘌",
+            "F": "𝘍",
+            "G": "𝘎",
+            "H": "𝘏",
+            "I": "𝘐",
+            "J": "𝘑",
+            "K": "𝘒",
+            "L": "𝘓",
+            "M": "𝘔",
+            "N": "𝘕",
+            "O": "𝘖",
+            "P": "𝘗",
+            "Q": "𝘘",
+            "R": "𝘙",
+            "S": "𝘚",
+            "T": "𝘛",
+            "U": "𝘜",
+            "V": "𝘝",
+            "W": "𝘞",
+            "X": "𝘟",
+            "Y": "𝘠",
+            "Z": "𝘡",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def sim(text):
+        style = {
+            "a": "𝖺",
+            "b": "𝖻",
+            "c": "𝖼",
+            "d": "𝖽",
+            "e": "𝖾",
+            "f": "𝖿",
+            "g": "𝗀",
+            "h": "𝗁",
+            "i": "𝗂",
+            "j": "𝗃",
+            "k": "𝗄",
+            "l": "𝗅",
+            "m": "𝗆",
+            "n": "𝗇",
+            "o": "𝗈",
+            "p": "𝗉",
+            "q": "𝗊",
+            "r": "𝗋",
+            "s": "𝗌",
+            "t": "𝗍",
+            "u": "𝗎",
+            "v": "𝗏",
+            "w": "𝗐",
+            "x": "𝗑",
+            "y": "𝗒",
+            "z": "𝗓",
+            "A": "𝖠",
+            "B": "𝖡",
+            "C": "𝖢",
+            "D": "𝖣",
+            "E": "𝖤",
+            "F": "𝖥",
+            "G": "𝖦",
+            "H": "𝖧",
+            "I": "𝖨",
+            "J": "𝖩",
+            "K": "𝖪",
+            "L": "𝖫",
+            "M": "𝖬",
+            "N": "𝖭",
+            "O": "𝖮",
+            "P": "𝖯",
+            "Q": "𝖰",
+            "R": "𝖱",
+            "S": "𝖲",
+            "T": "𝖳",
+            "U": "𝖴",
+            "V": "𝖵",
+            "W": "𝖶",
+            "X": "𝖷",
+            "Y": "𝖸",
+            "Z": "𝖹",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def circles(text):
+        style = {
+            "a": "Ⓐ︎",
+            "b": "Ⓑ︎",
+            "c": "Ⓒ︎",
+            "d": "Ⓓ︎",
+            "e": "Ⓔ︎",
+            "f": "Ⓕ︎",
+            "g": "Ⓖ︎",
+            "h": "Ⓗ︎",
+            "i": "Ⓘ︎",
+            "j": "Ⓙ︎",
+            "k": "Ⓚ︎",
+            "l": "Ⓛ︎",
+            "m": "Ⓜ︎",
+            "n": "Ⓝ︎",
+            "o": "Ⓞ︎",
+            "p": "Ⓟ︎",
+            "q": "Ⓠ︎",
+            "r": "Ⓡ︎",
+            "s": "Ⓢ︎",
+            "t": "Ⓣ︎",
+            "u": "Ⓤ︎",
+            "v": "Ⓥ︎",
+            "w": "Ⓦ︎",
+            "x": "Ⓧ︎",
+            "y": "Ⓨ︎",
+            "z": "Ⓩ︎",
+            "A": "Ⓐ︎",
+            "B": "Ⓑ︎",
+            "C": "Ⓒ︎",
+            "D": "Ⓓ︎",
+            "E": "Ⓔ︎",
+            "F": "Ⓕ︎",
+            "G": "Ⓖ︎",
+            "H": "Ⓗ︎",
+            "I": "Ⓘ︎",
+            "J": "Ⓙ︎",
+            "K": "Ⓚ︎",
+            "L": "Ⓛ︎",
+            "M": "Ⓜ︎",
+            "N": "Ⓝ︎",
+            "O": "Ⓞ︎",
+            "P": "Ⓟ︎",
+            "Q": "Ⓠ︎",
+            "R": "Ⓡ︎",
+            "S": "Ⓢ︎",
+            "T": "Ⓣ︎",
+            "U": "Ⓤ︎",
+            "V": "Ⓥ︎",
+            "W": "Ⓦ︎",
+            "X": "Ⓧ︎",
+            "Y": "Ⓨ︎",
+            "Z": "Ⓩ︎",
+            "0": "⓪",
+            "1": "①",
+            "2": "②",
+            "3": "③",
+            "4": "④",
+            "5": "⑤",
+            "6": "⑥",
+            "7": "⑦",
+            "8": "⑧",
+            "9": "⑨",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def dark_circle(text):
+        style = {
+            "a": "🅐︎",
+            "b": "🅑︎",
+            "c": "🅒︎",
+            "d": "🅓︎",
+            "e": "🅔︎",
+            "f": "🅕︎",
+            "g": "🅖︎",
+            "h": "🅗︎",
+            "i": "🅘︎",
+            "j": "🅙︎",
+            "k": "🅚︎",
+            "l": "🅛︎",
+            "m": "🅜︎",
+            "n": "🅝︎",
+            "o": "🅞︎",
+            "p": "🅟︎",
+            "q": "🅠︎",
+            "r": "🅡︎",
+            "s": "🅢︎",
+            "t": "🅣︎",
+            "u": "🅤︎",
+            "v": "🅥︎",
+            "w": "🅦︎",
+            "x": "🅧︎",
+            "y": "🅨︎",
+            "z": "🅩︎",
+            "A": "🅐︎",
+            "B": "🅑︎",
+            "C": "🅒︎",
+            "D": "🅓︎",
+            "E": "🅔︎",
+            "F": "🅕︎",
+            "G": "🅖︎",
+            "H": "🅗︎",
+            "I": "🅘︎",
+            "J": "🅙︎",
+            "K": "🅚︎",
+            "L": "🅛︎",
+            "M": "🅜︎",
+            "N": "🅝︎",
+            "O": "🅞︎",
+            "P": "🅟︎",
+            "Q": "🅠︎",
+            "R": "🅡︎",
+            "S": "🅢︎",
+            "T": "🅣︎",
+            "U": "🅤︎",
+            "V": "🅥︎",
+            "W": "🅦︎",
+            "X": "🅧︎",
+            "Y": "🅨︎",
+            "Z": "🅩",
+            "0": "⓿",
+            "1": "➊",
+            "2": "➋",
+            "3": "➌",
+            "4": "➍",
+            "5": "➎",
+            "6": "➏",
+            "7": "➐",
+            "8": "➑",
+            "9": "➒",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def gothic(text):
+        style = {
+            "a": "𝔞",
+            "b": "𝔟",
+            "c": "𝔠",
+            "d": "𝔡",
+            "e": "𝔢",
+            "f": "𝔣",
+            "g": "𝔤",
+            "h": "𝔥",
+            "i": "𝔦",
+            "j": "𝔧",
+            "k": "𝔨",
+            "l": "𝔩",
+            "m": "𝔪",
+            "n": "𝔫",
+            "o": "𝔬",
+            "p": "𝔭",
+            "q": "𝔮",
+            "r": "𝔯",
+            "s": "𝔰",
+            "t": "𝔱",
+            "u": "𝔲",
+            "v": "𝔳",
+            "w": "𝔴",
+            "x": "𝔵",
+            "y": "𝔶",
+            "z": "𝔷",
+            "A": "𝔄",
+            "B": "𝔅",
+            "C": "ℭ",
+            "D": "𝔇",
+            "E": "𝔈",
+            "F": "𝔉",
+            "G": "𝔊",
+            "H": "ℌ",
+            "I": "ℑ",
+            "J": "𝔍",
+            "K": "𝔎",
+            "L": "𝔏",
+            "M": "𝔐",
+            "N": "𝔑",
+            "O": "𝔒",
+            "P": "𝔓",
+            "Q": "𝔔",
+            "R": "ℜ",
+            "S": "𝔖",
+            "T": "𝔗",
+            "U": "𝔘",
+            "V": "𝔙",
+            "W": "𝔚",
+            "X": "𝔛",
+            "Y": "𝔜",
+            "Z": "ℨ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def bold_gothic(text):
+        style = {
+            "a": "𝖆",
+            "b": "𝖇",
+            "c": "𝖈",
+            "d": "𝖉",
+            "e": "𝖊",
+            "f": "𝖋",
+            "g": "𝖌",
+            "h": "𝖍",
+            "i": "𝖎",
+            "j": "𝖏",
+            "k": "𝖐",
+            "l": "𝖑",
+            "m": "𝖒",
+            "n": "𝖓",
+            "o": "𝖔",
+            "p": "𝖕",
+            "q": "𝖖",
+            "r": "𝖗",
+            "s": "𝖘",
+            "t": "𝖙",
+            "u": "𝖚",
+            "v": "𝖛",
+            "w": "𝖜",
+            "x": "𝖝",
+            "y": "𝖞",
+            "z": "𝖟",
+            "A": "𝕬",
+            "B": "𝕭",
+            "C": "𝕮",
+            "D": "𝕺",
+            "E": "𝕰",
+            "F": "𝕱",
+            "G": "𝕲",
+            "H": "𝕳",
+            "I": "𝕴",
+            "J": "𝕵",
+            "K": "𝕶",
+            "L": "𝕷",
+            "M": "𝕸",
+            "N": "𝕹",
+            "O": "𝕺",
+            "P": "𝕻",
+            "Q": "𝕼",
+            "R": "𝕽",
+            "S": "𝕾",
+            "T": "𝕿",
+            "U": "𝖀",
+            "V": "𝖁",
+            "W": "𝖂",
+            "X": "𝖃",
+            "Y": "𝖄",
+            "Z": "𝖅",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def cloud(text):
+        style = {
+            "a": "a͜͡",
+            "b": "b͜͡",
+            "c": "c͜͡",
+            "d": "d͜͡",
+            "e": "e͜͡",
+            "f": "f͜͡",
+            "g": "g͜͡",
+            "h": "h͜͡",
+            "i": "i͜͡",
+            "j": "j͜͡",
+            "k": "k͜͡",
+            "l": "l͜͡",
+            "m": "m͜͡",
+            "n": "n͜͡",
+            "o": "o͜͡",
+            "p": "p͜͡",
+            "q": "q͜͡",
+            "r": "r͜͡",
+            "s": "s͜͡",
+            "t": "t͜͡",
+            "u": "u͜͡",
+            "v": "v͜͡",
+            "w": "w͜͡",
+            "x": "x͜͡",
+            "y": "y͜͡",
+            "z": "z͜͡",
+            "A": "A͜͡",
+            "B": "B͜͡",
+            "C": "C͜͡",
+            "D": "D͜͡",
+            "E": "E͜͡",
+            "F": "F͜͡",
+            "G": "G͜͡",
+            "H": "H͜͡",
+            "I": "I͜͡",
+            "J": "J͜͡",
+            "K": "K͜͡",
+            "L": "L͜͡",
+            "M": "M͜͡",
+            "N": "N͜͡",
+            "O": "O͜͡",
+            "P": "P͜͡",
+            "Q": "Q͜͡",
+            "R": "R͜͡",
+            "S": "S͜͡",
+            "T": "T͜͡",
+            "U": "U͜͡",
+            "V": "V͜͡",
+            "W": "W͜͡",
+            "X": "X͜͡",
+            "Y": "Y͜͡",
+            "Z": "Z͜͡",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def happy(text):
+        style = {
+            "a": "ă̈",
+            "b": "b̆̈",
+            "c": "c̆̈",
+            "d": "d̆̈",
+            "e": "ĕ̈",
+            "f": "f̆̈",
+            "g": "ğ̈",
+            "h": "h̆̈",
+            "i": "ĭ̈",
+            "j": "j̆̈",
+            "k": "k̆̈",
+            "l": "l̆̈",
+            "m": "m̆̈",
+            "n": "n̆̈",
+            "o": "ŏ̈",
+            "p": "p̆̈",
+            "q": "q̆̈",
+            "r": "r̆̈",
+            "s": "s̆̈",
+            "t": "t̆̈",
+            "u": "ŭ̈",
+            "v": "v̆̈",
+            "w": "w̆̈",
+            "x": "x̆̈",
+            "y": "y̆̈",
+            "z": "z̆̈",
+            "A": "Ă̈",
+            "B": "B̆̈",
+            "C": "C̆̈",
+            "D": "D̆̈",
+            "E": "Ĕ̈",
+            "F": "F̆̈",
+            "G": "Ğ̈",
+            "H": "H̆̈",
+            "I": "Ĭ̈",
+            "J": "J̆̈",
+            "K": "K̆̈",
+            "L": "L̆̈",
+            "M": "M̆̈",
+            "N": "N̆̈",
+            "O": "Ŏ̈",
+            "P": "P̆̈",
+            "Q": "Q̆̈",
+            "R": "R̆̈",
+            "S": "S̆̈",
+            "T": "T̆̈",
+            "U": "Ŭ̈",
+            "V": "V̆̈",
+            "W": "W̆̈",
+            "X": "X̆̈",
+            "Y": "Y̆̈",
+            "Z": "Z̆̈",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def sad(text):
+        style = {
+            "a": "ȃ̈",
+            "b": "b̑̈",
+            "c": "c̑̈",
+            "d": "d̑̈",
+            "e": "ȇ̈",
+            "f": "f̑̈",
+            "g": "g̑̈",
+            "h": "h̑̈",
+            "i": "ȋ̈",
+            "j": "j̑̈",
+            "k": "k̑̈",
+            "l": "l̑̈",
+            "m": "m̑̈",
+            "n": "n̑̈",
+            "o": "ȏ̈",
+            "p": "p̑̈",
+            "q": "q̑̈",
+            "r": "ȓ̈",
+            "s": "s̑̈",
+            "t": "t̑̈",
+            "u": "ȗ̈",
+            "v": "v̑̈",
+            "w": "w̑̈",
+            "x": "x̑̈",
+            "y": "y̑̈",
+            "z": "z̑̈",
+            "A": "Ȃ̈",
+            "B": "B̑̈",
+            "C": "C̑̈",
+            "D": "D̑̈",
+            "E": "Ȇ̈",
+            "F": "F̑̈",
+            "G": "G̑̈",
+            "H": "H̑̈",
+            "I": "Ȋ̈",
+            "J": "J̑̈",
+            "K": "K̑̈",
+            "L": "L̑̈",
+            "M": "M̑̈",
+            "N": "N̑̈",
+            "O": "Ȏ̈",
+            "P": "P̑̈",
+            "Q": "Q̑̈",
+            "R": "Ȓ̈",
+            "S": "S̑̈",
+            "T": "T̑̈",
+            "U": "Ȗ̈",
+            "V": "V̑̈",
+            "W": "W̑̈",
+            "X": "X̑̈",
+            "Y": "Y̑̈",
+            "Z": "Z̑̈",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def special(text):
+        style = {
+            "a": "🇦 ",
+            "b": "🇧 ",
+            "c": "🇨 ",
+            "d": "🇩 ",
+            "e": "🇪 ",
+            "f": "🇫 ",
+            "g": "🇬 ",
+            "h": "🇭 ",
+            "i": "🇮 ",
+            "j": "🇯 ",
+            "k": "🇰 ",
+            "l": "🇱 ",
+            "m": "🇲 ",
+            "n": "🇳 ",
+            "o": "🇴 ",
+            "p": "🇵 ",
+            "q": "🇶 ",
+            "r": "🇷 ",
+            "s": "🇸 ",
+            "t": "🇹 ",
+            "u": "🇺 ",
+            "v": "🇻 ",
+            "w": "🇼 ",
+            "x": "🇽 ",
+            "y": "🇾 ",
+            "z": "🇿 ",
+            "A": "🇦 ",
+            "B": "🇧 ",
+            "C": "🇨 ",
+            "D": "🇩 ",
+            "E": "🇪 ",
+            "F": "🇫 ",
+            "G": "🇬 ",
+            "H": "🇭 ",
+            "I": "🇮 ",
+            "J": "🇯 ",
+            "K": "🇰 ",
+            "L": "🇱 ",
+            "M": "🇲 ",
+            "N": "🇳 ",
+            "O": "🇴 ",
+            "P": "🇵 ",
+            "Q": "🇶 ",
+            "R": "🇷 ",
+            "S": "🇸 ",
+            "T": "🇹 ",
+            "U": "🇺 ",
+            "V": "🇻 ",
+            "W": "🇼 ",
+            "X": "🇽 ",
+            "Y": "🇾 ",
+            "Z": "🇿 ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def square(text):
+        style = {
+            "a": "🄰",
+            "b": "🄱",
+            "c": "🄲",
+            "d": "🄳",
+            "e": "🄴",
+            "f": "🄵",
+            "g": "🄶",
+            "h": "🄷",
+            "i": "🄸",
+            "j": "🄹",
+            "k": "🄺",
+            "l": "🄻",
+            "m": "🄼",
+            "n": "🄽",
+            "o": "🄾",
+            "p": "🄿",
+            "q": "🅀",
+            "r": "🅁",
+            "s": "🅂",
+            "t": "🅃",
+            "u": "🅄",
+            "v": "🅅",
+            "w": "🅆",
+            "x": "🅇",
+            "y": "🅈",
+            "z": "🅉",
+            "A": "🄰",
+            "B": "🄱",
+            "C": "🄲",
+            "D": "🄳",
+            "E": "🄴",
+            "F": "🄵",
+            "G": "🄶",
+            "H": "🄷",
+            "I": "🄸",
+            "J": "🄹",
+            "K": "🄺",
+            "L": "🄻",
+            "M": "🄼",
+            "N": "🄽",
+            "O": "🄾",
+            "P": "🄿",
+            "Q": "🅀",
+            "R": "🅁",
+            "S": "🅂",
+            "T": "🅃",
+            "U": "🅄",
+            "V": "🅅",
+            "W": "🅆",
+            "X": "🅇",
+            "Y": "🅈",
+            "Z": "🅉",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def dark_square(text):
+        style = {
+            "a": "🅰︎",
+            "b": "🅱︎",
+            "c": "🅲︎",
+            "d": "🅳︎",
+            "e": "🅴︎",
+            "f": "🅵︎",
+            "g": "🅶︎",
+            "h": "🅷︎",
+            "i": "🅸︎",
+            "j": "🅹︎",
+            "k": "🅺︎",
+            "l": "🅻︎",
+            "m": "🅼︎",
+            "n": "🅽︎",
+            "o": "🅾︎",
+            "p": "🅿︎",
+            "q": "🆀︎",
+            "r": "🆁︎",
+            "s": "🆂︎",
+            "t": "🆃︎",
+            "u": "🆄︎",
+            "v": "🆅︎",
+            "w": "🆆︎",
+            "x": "🆇︎",
+            "y": "🆈︎",
+            "z": "🆉︎",
+            "A": "🅰︎",
+            "B": "🅱︎",
+            "C": "🅲︎",
+            "D": "🅳︎",
+            "E": "🅴︎",
+            "F": "🅵︎",
+            "G": "🅶︎",
+            "H": "🅷︎",
+            "I": "🅸︎",
+            "J": "🅹︎",
+            "K": "🅺︎",
+            "L": "🅻︎",
+            "M": "🅼︎",
+            "N": "🅽︎",
+            "O": "🅾︎",
+            "P": "🅿︎",
+            "Q": "🆀︎",
+            "R": "🆁︎",
+            "S": "🆂︎",
+            "T": "🆃︎",
+            "U": "🆄︎",
+            "V": "🆅︎",
+            "W": "🆆︎",
+            "X": "🆇︎",
+            "Y": "🆈︎",
+            "Z": "🆉︎",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def andalucia(text):
+        style = {
+            "a": "ꪖ",
+            "b": "᥇",
+            "c": "ᥴ",
+            "d": "ᦔ",
+            "e": "ꫀ",
+            "f": "ᠻ",
+            "g": "ᧁ",
+            "h": "ꫝ",
+            "i": "𝓲",
+            "j": "𝓳",
+            "k": "𝘬",
+            "l": "ꪶ",
+            "m": "ꪑ",
+            "n": "ꪀ",
+            "o": "ꪮ",
+            "p": "ρ",
+            "q": "𝘲",
+            "r": "𝘳",
+            "s": "𝘴",
+            "t": "𝓽",
+            "u": "ꪊ",
+            "v": "ꪜ",
+            "w": "᭙",
+            "x": "᥊",
+            "y": "ꪗ",
+            "z": "ɀ",
+            "A": "ꪖ",
+            "B": "᥇",
+            "C": "ᥴ",
+            "D": "ᦔ",
+            "E": "ꫀ",
+            "F": "ᠻ",
+            "G": "ᧁ",
+            "H": "ꫝ",
+            "I": "𝓲",
+            "J": "𝓳",
+            "K": "𝘬",
+            "L": "ꪶ",
+            "M": "ꪑ",
+            "N": "ꪀ",
+            "O": "ꪮ",
+            "P": "ρ",
+            "Q": "𝘲",
+            "R": "𝘳",
+            "S": "𝘴",
+            "T": "𝓽",
+            "U": "ꪊ",
+            "V": "ꪜ",
+            "W": "᭙",
+            "X": "᥊",
+            "Y": "ꪗ",
+            "Z": "ɀ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def manga(text):
+        style = {
+            "a": "卂",
+            "b": "乃",
+            "c": "匚",
+            "d": "ᗪ",
+            "e": "乇",
+            "f": "千",
+            "g": "ᘜ",
+            "h": "卄",
+            "i": "|",
+            "j": "ﾌ",
+            "k": "Ҝ",
+            "l": "ㄥ",
+            "m": "爪",
+            "n": "几",
+            "o": "ㄖ",
+            "p": "卩",
+            "q": "Ҩ",
+            "r": "尺",
+            "s": "丂",
+            "t": "ㄒ",
+            "u": "ㄩ",
+            "v": "ᐯ",
+            "w": "山",
+            "x": "乂",
+            "y": "ㄚ",
+            "z": "乙",
+            "A": "卂",
+            "B": "乃",
+            "C": "匚",
+            "D": "ᗪ",
+            "E": "乇",
+            "F": "千",
+            "G": "ᘜ",
+            "H": "卄",
+            "I": "|",
+            "J": "ﾌ",
+            "K": "Ҝ",
+            "L": "ㄥ",
+            "M": "爪",
+            "N": "几",
+            "O": "ㄖ",
+            "P": "卩",
+            "Q": "Ҩ",
+            "R": "尺",
+            "S": "丂",
+            "T": "ㄒ",
+            "U": "ㄩ",
+            "V": "ᐯ",
+            "W": "山",
+            "X": "乂",
+            "Y": "ㄚ",
+            "Z": "乙",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def stinky(text):
+        style = {
+            "a": "a̾",
+            "b": "b̾",
+            "c": "c̾",
+            "d": "d̾",
+            "e": "e̾",
+            "f": "f̾",
+            "g": "g̾",
+            "h": "h̾",
+            "i": "i̾",
+            "j": "j̾",
+            "k": "k̾",
+            "l": "l̾",
+            "m": "m̾",
+            "n": "n̾",
+            "o": "o̾",
+            "p": "p̾",
+            "q": "q̾",
+            "r": "r̾",
+            "s": "s̾",
+            "t": "t̾",
+            "u": "u̾",
+            "v": "v̾",
+            "w": "w̾",
+            "x": "x̾",
+            "y": "y̾",
+            "z": "z̾",
+            "A": "A̾",
+            "B": "B̾",
+            "C": "C̾",
+            "D": "D̾",
+            "E": "E̾",
+            "F": "F̾",
+            "G": "G̾",
+            "H": "H̾",
+            "I": "I̾",
+            "J": "J̾",
+            "K": "K̾",
+            "L": "L̾",
+            "M": "M̾",
+            "N": "N̾",
+            "O": "O̾",
+            "P": "P̾",
+            "Q": "Q̾",
+            "R": "R̾",
+            "S": "S̾",
+            "T": "T̾",
+            "U": "U̾",
+            "V": "V̾",
+            "W": "W̾",
+            "X": "X̾",
+            "Y": "Y̾",
+            "Z": "Z̾",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def bubbles(text):
+        style = {
+            "a": "ḁͦ",
+            "b": "b̥ͦ",
+            "c": "c̥ͦ",
+            "d": "d̥ͦ",
+            "e": "e̥ͦ",
+            "f": "f̥ͦ",
+            "g": "g̥ͦ",
+            "h": "h̥ͦ",
+            "i": "i̥ͦ",
+            "j": "j̥ͦ",
+            "k": "k̥ͦ",
+            "l": "l̥ͦ",
+            "m": "m̥ͦ",
+            "n": "n̥ͦ",
+            "o": "o̥ͦ",
+            "p": "p̥ͦ",
+            "q": "q̥ͦ",
+            "r": "r̥ͦ",
+            "s": "s̥ͦ",
+            "t": "t̥ͦ",
+            "u": "u̥ͦ",
+            "v": "v̥ͦ",
+            "w": "w̥ͦ",
+            "x": "x̥ͦ",
+            "y": "y̥ͦ",
+            "z": "z̥ͦ",
+            "A": "Ḁͦ",
+            "B": "B̥ͦ",
+            "C": "C̥ͦ",
+            "D": "D̥ͦ",
+            "E": "E̥ͦ",
+            "F": "F̥ͦ",
+            "G": "G̥ͦ",
+            "H": "H̥ͦ",
+            "I": "I̥ͦ",
+            "J": "J̥ͦ",
+            "K": "K̥ͦ",
+            "L": "L̥ͦ",
+            "M": "M̥ͦ",
+            "N": "N̥ͦ",
+            "O": "O̥ͦ",
+            "P": "P̥ͦ",
+            "Q": "Q̥ͦ",
+            "R": "R̥ͦ",
+            "S": "S̥ͦ",
+            "T": "T̥ͦ",
+            "U": "U̥ͦ",
+            "V": "V̥ͦ",
+            "W": "W̥ͦ",
+            "X": "X̥ͦ",
+            "Y": "Y̥ͦ",
+            "Z": "Z̥ͦ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def underline(text):
+        style = {
+            "a": "a͟",
+            "b": "b͟",
+            "c": "c͟",
+            "d": "d͟",
+            "e": "e͟",
+            "f": "f͟",
+            "g": "g͟",
+            "h": "h͟",
+            "i": "i͟",
+            "j": "j͟",
+            "k": "k͟",
+            "l": "l͟",
+            "m": "m͟",
+            "n": "n͟",
+            "o": "o͟",
+            "p": "p͟",
+            "q": "q͟",
+            "r": "r͟",
+            "s": "s͟",
+            "t": "t͟",
+            "u": "u͟",
+            "v": "v͟",
+            "w": "w͟",
+            "x": "x͟",
+            "y": "y͟",
+            "z": "z͟",
+            "A": "A͟",
+            "B": "B͟",
+            "C": "C͟",
+            "D": "D͟",
+            "E": "E͟",
+            "F": "F͟",
+            "G": "G͟",
+            "H": "H͟",
+            "I": "I͟",
+            "J": "J͟",
+            "K": "K͟",
+            "L": "L͟",
+            "M": "M͟",
+            "N": "N͟",
+            "O": "O͟",
+            "P": "P͟",
+            "Q": "Q͟",
+            "R": "R͟",
+            "S": "S͟",
+            "T": "T͟",
+            "U": "U͟",
+            "V": "V͟",
+            "W": "W͟",
+            "X": "X͟",
+            "Y": "Y͟",
+            "Z": "Z͟",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def ladybug(text):
+        style = {
+            "a": "ꍏ",
+            "b": "ꌃ",
+            "c": "ꏳ",
+            "d": "ꀷ",
+            "e": "ꏂ",
+            "f": "ꎇ",
+            "g": "ꁅ",
+            "h": "ꀍ",
+            "i": "ꀤ",
+            "j": "꒻",
+            "k": "ꀘ",
+            "l": "꒒",
+            "m": "ꎭ",
+            "n": "ꈤ",
+            "o": "ꂦ",
+            "p": "ᖘ",
+            "q": "ꆰ",
+            "r": "ꋪ",
+            "s": "ꌚ",
+            "t": "꓄",
+            "u": "ꀎ",
+            "v": "꒦",
+            "w": "ꅐ",
+            "x": "ꉧ",
+            "y": "ꌩ",
+            "z": "ꁴ",
+            "A": "ꍏ",
+            "B": "ꌃ",
+            "C": "ꏳ",
+            "D": "ꀷ",
+            "E": "ꏂ",
+            "F": "ꎇ",
+            "G": "ꁅ",
+            "H": "ꀍ",
+            "I": "ꀤ",
+            "J": "꒻",
+            "K": "ꀘ",
+            "L": "꒒",
+            "M": "ꎭ",
+            "N": "ꈤ",
+            "O": "ꂦ",
+            "P": "ᖘ",
+            "Q": "ꆰ",
+            "R": "ꋪ",
+            "S": "ꌚ",
+            "T": "꓄",
+            "U": "ꀎ",
+            "V": "꒦",
+            "W": "ꅐ",
+            "X": "ꉧ",
+            "Y": "ꌩ",
+            "Z": "ꁴ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def rays(text):
+        style = {
+            "a": "a҉",
+            "b": "b҉",
+            "c": "c҉",
+            "d": "d҉",
+            "e": "e҉",
+            "f": "f҉",
+            "g": "g҉",
+            "h": "h҉",
+            "i": "i҉",
+            "j": "j҉",
+            "k": "k҉",
+            "l": "l҉",
+            "m": "m҉",
+            "n": "n҉",
+            "o": "o҉",
+            "p": "p҉",
+            "q": "q҉",
+            "r": "r҉",
+            "s": "s҉",
+            "t": "t҉",
+            "u": "u҉",
+            "v": "v҉",
+            "w": "w҉",
+            "x": "x҉",
+            "y": "y҉",
+            "z": "z҉",
+            "A": "A҉",
+            "B": "B҉",
+            "C": "C҉",
+            "D": "D҉",
+            "E": "E҉",
+            "F": "F҉",
+            "G": "G҉",
+            "H": "H҉",
+            "I": "I҉",
+            "J": "J҉",
+            "K": "K҉",
+            "L": "L҉",
+            "M": "M҉",
+            "N": "N҉",
+            "O": "O҉",
+            "P": "P҉",
+            "Q": "Q҉",
+            "R": "R҉",
+            "S": "S҉",
+            "T": "T҉",
+            "U": "U҉",
+            "V": "V҉",
+            "W": "W҉",
+            "X": "X҉",
+            "Y": "Y҉",
+            "Z": "Z҉",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def birds(text):
+        style = {
+            "a": "a҈",
+            "b": "b҈",
+            "c": "c҈",
+            "d": "d҈",
+            "e": "e҈",
+            "f": "f҈",
+            "g": "g҈",
+            "h": "h҈",
+            "i": "i҈",
+            "j": "j҈",
+            "k": "k҈",
+            "l": "l҈",
+            "m": "m҈",
+            "n": "n҈",
+            "o": "o҈",
+            "p": "p҈",
+            "q": "q҈",
+            "r": "r҈",
+            "s": "s҈",
+            "t": "t҈",
+            "u": "u҈",
+            "v": "v҈",
+            "w": "w҈",
+            "x": "x҈",
+            "y": "y҈",
+            "z": "z҈",
+            "A": "A҈",
+            "B": "B҈",
+            "C": "C҈",
+            "D": "D҈",
+            "E": "E҈",
+            "F": "F҈",
+            "G": "G҈",
+            "H": "H҈",
+            "I": "I҈",
+            "J": "J҈",
+            "K": "K҈",
+            "L": "L҈",
+            "M": "M҈",
+            "N": "N҈",
+            "O": "O҈",
+            "P": "P҈",
+            "Q": "Q҈",
+            "R": "R҈",
+            "S": "S҈",
+            "T": "T҈",
+            "U": "U҈",
+            "V": "V҈",
+            "W": "W҈",
+            "X": "X҈",
+            "Y": "Y҈",
+            "Z": "Z҈",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def slash(text):
+        style = {
+            "a": "a̸",
+            "b": "b̸",
+            "c": "c̸",
+            "d": "d̸",
+            "e": "e̸",
+            "f": "f̸",
+            "g": "g̸",
+            "h": "h̸",
+            "i": "i̸",
+            "j": "j̸",
+            "k": "k̸",
+            "l": "l̸",
+            "m": "m̸",
+            "n": "n̸",
+            "o": "o̸",
+            "p": "p̸",
+            "q": "q̸",
+            "r": "r̸",
+            "s": "s̸",
+            "t": "t̸",
+            "u": "u̸",
+            "v": "v̸",
+            "w": "w̸",
+            "x": "x̸",
+            "y": "y̸",
+            "z": "z̸",
+            "A": "A̸",
+            "B": "B̸",
+            "C": "C̸",
+            "D": "D̸",
+            "E": "E̸",
+            "F": "F̸",
+            "G": "G̸",
+            "H": "H̸",
+            "I": "I̸",
+            "J": "J̸",
+            "K": "K̸",
+            "L": "L̸",
+            "M": "M̸",
+            "N": "N̸",
+            "O": "O̸",
+            "P": "P̸",
+            "Q": "Q̸",
+            "R": "R̸",
+            "S": "S̸",
+            "T": "T̸",
+            "U": "U̸",
+            "V": "V̸",
+            "W": "W̸",
+            "X": "X̸",
+            "Y": "Y̸",
+            "Z": "Z̸",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def stop(text):
+        style = {
+            "a": "a⃠",
+            "b": "b⃠",
+            "c": "c⃠",
+            "d": "d⃠",
+            "e": "e⃠",
+            "f": "f⃠",
+            "g": "g⃠",
+            "h": "h⃠",
+            "i": "i⃠",
+            "j": "j⃠",
+            "k": "k⃠",
+            "l": "l⃠",
+            "m": "m⃠",
+            "n": "n⃠",
+            "o": "o⃠",
+            "p": "p⃠",
+            "q": "q⃠",
+            "r": "r⃠",
+            "s": "s⃠",
+            "t": "t⃠",
+            "u": "u⃠",
+            "v": "v⃠",
+            "w": "w⃠",
+            "x": "x⃠",
+            "y": "y⃠",
+            "z": "z⃠",
+            "A": "A⃠",
+            "B": "B⃠",
+            "C": "C⃠",
+            "D": "D⃠",
+            "E": "E⃠",
+            "F": "F⃠",
+            "G": "G⃠",
+            "H": "H⃠",
+            "I": "I⃠",
+            "J": "J⃠",
+            "K": "K⃠",
+            "L": "L⃠",
+            "M": "M⃠",
+            "N": "N⃠",
+            "O": "O⃠",
+            "P": "P⃠",
+            "Q": "Q⃠",
+            "R": "R⃠",
+            "S": "S⃠",
+            "T": "T⃠",
+            "U": "U⃠",
+            "V": "V⃠",
+            "W": "W⃠",
+            "X": "X⃠",
+            "Y": "Y⃠",
+            "Z": "Z⃠",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def skyline(text):
+        style = {
+            "a": "a̺͆",
+            "b": "b̺͆",
+            "c": "c̺͆",
+            "d": "d̺͆",
+            "e": "e̺͆",
+            "f": "f̺͆",
+            "g": "g̺͆",
+            "h": "h̺͆",
+            "i": "i̺͆",
+            "j": "j̺͆",
+            "k": "k̺͆",
+            "l": "l̺͆",
+            "m": "m̺͆",
+            "n": "n̺͆",
+            "o": "o̺͆",
+            "p": "p̺͆",
+            "q": "q̺͆",
+            "r": "r̺͆",
+            "s": "s̺͆",
+            "t": "t̺͆",
+            "u": "u̺͆",
+            "v": "v̺͆",
+            "w": "w̺͆",
+            "x": "x̺͆",
+            "y": "y̺͆",
+            "z": "z̺͆",
+            "A": "A̺͆",
+            "B": "B̺͆",
+            "C": "C̺͆",
+            "D": "D̺͆",
+            "E": "E̺͆",
+            "F": "F̺͆",
+            "G": "G̺͆",
+            "H": "H̺͆",
+            "I": "I̺͆",
+            "J": "J̺͆",
+            "K": "K̺͆",
+            "L": "L̺͆",
+            "M": "M̺͆",
+            "N": "N̺͆",
+            "O": "O̺͆",
+            "P": "P̺͆",
+            "Q": "Q̺͆",
+            "R": "R̺͆",
+            "S": "S̺͆",
+            "T": "T̺͆",
+            "U": "U̺͆",
+            "V": "V̺͆",
+            "W": "W̺͆",
+            "X": "X̺͆",
+            "Y": "Y̺͆",
+            "Z": "Z̺͆",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def arrows(text):
+        style = {
+            "a": "a͎",
+            "b": "b͎",
+            "c": "c͎",
+            "d": "d͎",
+            "e": "e͎",
+            "f": "f͎",
+            "g": "g͎",
+            "h": "h͎",
+            "i": "i͎",
+            "j": "j͎",
+            "k": "k͎",
+            "l": "l͎",
+            "m": "m͎",
+            "n": "n͎",
+            "o": "o͎",
+            "p": "p͎",
+            "q": "q͎",
+            "r": "r͎",
+            "s": "s͎",
+            "t": "t͎",
+            "u": "u͎",
+            "v": "v͎",
+            "w": "w͎",
+            "x": "x͎",
+            "y": "y͎",
+            "z": "z͎",
+            "A": "A͎",
+            "B": "B͎",
+            "C": "C͎",
+            "D": "D͎",
+            "E": "E͎",
+            "F": "F͎",
+            "G": "G͎",
+            "H": "H͎",
+            "I": "I͎",
+            "J": "J͎",
+            "K": "K͎",
+            "L": "L͎",
+            "M": "M͎",
+            "N": "N͎",
+            "O": "O͎",
+            "P": "P͎",
+            "Q": "Q͎",
+            "R": "R͎",
+            "S": "S͎",
+            "T": "T͎",
+            "U": "U͎",
+            "V": "V͎",
+            "W": "W͎",
+            "X": "X͎",
+            "Y": "Y͎",
+            "Z": "Z͎",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def rvnes(text):
+        style = {
+            "a": "ል",
+            "b": "ጌ",
+            "c": "ር",
+            "d": "ዕ",
+            "e": "ቿ",
+            "f": "ቻ",
+            "g": "ኗ",
+            "h": "ዘ",
+            "i": "ጎ",
+            "j": "ጋ",
+            "k": "ጕ",
+            "l": "ረ",
+            "m": "ጠ",
+            "n": "ክ",
+            "o": "ዐ",
+            "p": "የ",
+            "q": "ዒ",
+            "r": "ዪ",
+            "s": "ነ",
+            "t": "ፕ",
+            "u": "ሁ",
+            "v": "ሀ",
+            "w": "ሠ",
+            "x": "ሸ",
+            "y": "ሃ",
+            "z": "ጊ",
+            "A": "ል",
+            "B": "ጌ",
+            "C": "ር",
+            "D": "ዕ",
+            "E": "ቿ",
+            "F": "ቻ",
+            "G": "ኗ",
+            "H": "ዘ",
+            "I": "ጎ",
+            "J": "ጋ",
+            "K": "ጕ",
+            "L": "ረ",
+            "M": "ጠ",
+            "N": "ክ",
+            "O": "ዐ",
+            "P": "የ",
+            "Q": "ዒ",
+            "R": "ዪ",
+            "S": "ነ",
+            "T": "ፕ",
+            "U": "ሁ",
+            "V": "ሀ",
+            "W": "ሠ",
+            "X": "ሸ",
+            "Y": "ሃ",
+            "Z": "ጊ",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def strike(text):
+        style = {
+            "a": "a̶",
+            "b": "b̶",
+            "c": "c̶",
+            "d": "d̶",
+            "e": "e̶",
+            "f": "f̶",
+            "g": "g̶",
+            "h": "h̶",
+            "i": "i̶",
+            "j": "j̶",
+            "k": "k̶",
+            "l": "l̶",
+            "m": "m̶",
+            "n": "n̶",
+            "o": "o̶",
+            "p": "p̶",
+            "q": "q̶",
+            "r": "r̶",
+            "s": "s̶",
+            "t": "t̶",
+            "u": "u̶",
+            "v": "v̶",
+            "w": "w̶",
+            "x": "x̶",
+            "y": "y̶",
+            "z": "z̶",
+            "A": "A̶",
+            "B": "B̶",
+            "C": "C̶",
+            "D": "D̶",
+            "E": "E̶",
+            "F": "F̶",
+            "G": "G̶",
+            "H": "H̶",
+            "I": "I̶",
+            "J": "J̶",
+            "K": "K̶",
+            "L": "L̶",
+            "M": "M̶",
+            "N": "N̶",
+            "O": "O̶",
+            "P": "P̶",
+            "Q": "Q̶",
+            "R": "R̶",
+            "S": "S̶",
+            "T": "T̶",
+            "U": "U̶",
+            "V": "V̶",
+            "W": "W̶",
+            "X": "X̶",
+            "Y": "Y̶",
+            "Z": "Z̶",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text
+
+    def frozen(text):
+        style = {
+            "a": "a༙",
+            "b": "b༙",
+            "c": "c༙",
+            "d": "d༙",
+            "e": "e༙",
+            "f": "f༙",
+            "g": "g༙",
+            "h": "h༙",
+            "i": "i༙",
+            "j": "j༙",
+            "k": "k༙",
+            "l": "l༙",
+            "m": "m༙",
+            "n": "n༙",
+            "o": "o༙",
+            "p": "p༙",
+            "q": "q༙",
+            "r": "r༙",
+            "s": "s༙",
+            "t": "t༙",
+            "u": "u༙",
+            "v": "v༙",
+            "w": "w༙",
+            "x": "x༙",
+            "y": "y༙",
+            "z": "z༙",
+            "A": "A༙",
+            "B": "B༙",
+            "C": "C༙",
+            "D": "D༙",
+            "E": "E༙",
+            "F": "F༙",
+            "G": "G༙",
+            "H": "H༙",
+            "I": "I༙",
+            "J": "J༙",
+            "K": "K༙",
+            "L": "L༙",
+            "M": "M༙",
+            "N": "N༙",
+            "O": "O༙",
+            "P": "P༙",
+            "Q": "Q༙",
+            "R": "R༙",
+            "S": "S༙",
+            "T": "T༙",
+            "U": "U༙",
+            "V": "V༙",
+            "W": "W༙",
+            "X": "X༙",
+            "Y": "Y༙",
+            "Z": "Z༙",
+        }
+        for i, j in style.items():
+            text = text.replace(i, j)
+        return text

Database/sql/forceSubscribe_sql.py

@@ -0,0 +1,46 @@
+from sqlalchemy import Column, Numeric, String
+
+from Database.sql import BASE, SESSION
+
+
+class forceSubscribe(BASE):
+    __tablename__ = "forceSubscribe"
+    chat_id = Column(Numeric, primary_key=True)
+    channel = Column(String)
+
+    def __init__(self, chat_id, channel):
+        self.chat_id = chat_id
+        self.channel = channel
+
+
+forceSubscribe.__table__.create(checkfirst=True)
+
+
+def fs_settings(chat_id):
+    try:
+        return (
+            SESSION.query(forceSubscribe)
+            .filter(forceSubscribe.chat_id == chat_id)
+            .one()
+        )
+    except:
+        return None
+    finally:
+        SESSION.close()
+
+
+def add_channel(chat_id, channel):
+    adder = SESSION.query(forceSubscribe).get(chat_id)
+    if adder:
+        adder.channel = channel
+    else:
+        adder = forceSubscribe(chat_id, channel)
+    SESSION.add(adder)
+    SESSION.commit()
+
+
+def disapprove(chat_id):
+    rem = SESSION.query(forceSubscribe).get(chat_id)
+    if rem:
+        SESSION.delete(rem)
+        SESSION.commit()

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/locks_sql.py

@@ -0,0 +1,292 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+# New chat added -> setup permissions
+import threading
+
+from sqlalchemy import Boolean, Column, String
+
+from Database.sql import BASE, SESSION
+
+
+class Permissions(BASE):
+    __tablename__ = "permissions"
+    chat_id = Column(String(14), primary_key=True)
+    # Booleans are for "is this locked", _NOT_ "is this allowed"
+    audio = Column(Boolean, default=False)
+    voice = Column(Boolean, default=False)
+    contact = Column(Boolean, default=False)
+    video = Column(Boolean, default=False)
+    document = Column(Boolean, default=False)
+    photo = Column(Boolean, default=False)
+    sticker = Column(Boolean, default=False)
+    gif = Column(Boolean, default=False)
+    url = Column(Boolean, default=False)
+    bots = Column(Boolean, default=False)
+    forward = Column(Boolean, default=False)
+    game = Column(Boolean, default=False)
+    location = Column(Boolean, default=False)
+    rtl = Column(Boolean, default=False)
+    button = Column(Boolean, default=False)
+    egame = Column(Boolean, default=False)
+    inline = Column(Boolean, default=False)
+
+    def __init__(self, chat_id):
+        self.chat_id = str(chat_id)  # ensure string
+        self.audio = False
+        self.voice = False
+        self.contact = False
+        self.video = False
+        self.document = False
+        self.photo = False
+        self.sticker = False
+        self.gif = False
+        self.url = False
+        self.bots = False
+        self.forward = False
+        self.game = False
+        self.location = False
+        self.rtl = False
+        self.button = False
+        self.egame = False
+        self.inline = False
+
+    def __repr__(self):
+        return "<ᴘᴇʀᴍɪssɪᴏɴs ғᴏʀ %s>" % self.chat_id
+
+
+class Restrictions(BASE):
+    __tablename__ = "restrictions"
+    chat_id = Column(String(14), primary_key=True)
+    # Booleans are for "is this restricted", _NOT_ "is this allowed"
+    messages = Column(Boolean, default=False)
+    media = Column(Boolean, default=False)
+    other = Column(Boolean, default=False)
+    preview = Column(Boolean, default=False)
+
+    def __init__(self, chat_id):
+        self.chat_id = str(chat_id)  # ensure string
+        self.messages = False
+        self.media = False
+        self.other = False
+        self.preview = False
+
+    def __repr__(self):
+        return "<ʀᴇsᴛʀɪᴄᴛɪᴏɴs ғᴏʀ %s>" % self.chat_id
+
+
+# For those who faced database error, Just uncomment the
+# line below and run bot for 1 time & remove that line!
+
+Permissions.__table__.create(checkfirst=True)
+# Permissions.__table__.drop()
+Restrictions.__table__.create(checkfirst=True)
+
+PERM_LOCK = threading.RLock()
+RESTR_LOCK = threading.RLock()
+
+
+def init_permissions(chat_id, reset=False):
+    curr_perm = SESSION.query(Permissions).get(str(chat_id))
+    if reset:
+        SESSION.delete(curr_perm)
+        SESSION.flush()
+    perm = Permissions(str(chat_id))
+    SESSION.add(perm)
+    SESSION.commit()
+    return perm
+
+
+def init_restrictions(chat_id, reset=False):
+    curr_restr = SESSION.query(Restrictions).get(str(chat_id))
+    if reset:
+        SESSION.delete(curr_restr)
+        SESSION.flush()
+    restr = Restrictions(str(chat_id))
+    SESSION.add(restr)
+    SESSION.commit()
+    return restr
+
+
+def update_lock(chat_id, lock_type, locked):
+    with PERM_LOCK:
+        curr_perm = SESSION.query(Permissions).get(str(chat_id))
+        if not curr_perm:
+            curr_perm = init_permissions(chat_id)
+
+        if lock_type == "audio":
+            curr_perm.audio = locked
+        elif lock_type == "voice":
+            curr_perm.voice = locked
+        elif lock_type == "contact":
+            curr_perm.contact = locked
+        elif lock_type == "video":
+            curr_perm.video = locked
+        elif lock_type == "document":
+            curr_perm.document = locked
+        elif lock_type == "photo":
+            curr_perm.photo = locked
+        elif lock_type == "sticker":
+            curr_perm.sticker = locked
+        elif lock_type == "gif":
+            curr_perm.gif = locked
+        elif lock_type == "url":
+            curr_perm.url = locked
+        elif lock_type == "bots":
+            curr_perm.bots = locked
+        elif lock_type == "forward":
+            curr_perm.forward = locked
+        elif lock_type == "game":
+            curr_perm.game = locked
+        elif lock_type == "location":
+            curr_perm.location = locked
+        elif lock_type == "rtl":
+            curr_perm.rtl = locked
+        elif lock_type == "button":
+            curr_perm.button = locked
+        elif lock_type == "egame":
+            curr_perm.egame = locked
+        elif lock_type == "inline":
+            curr_perm.inline = locked
+
+        SESSION.add(curr_perm)
+        SESSION.commit()
+
+
+def update_restriction(chat_id, restr_type, locked):
+    with RESTR_LOCK:
+        curr_restr = SESSION.query(Restrictions).get(str(chat_id))
+        if not curr_restr:
+            curr_restr = init_restrictions(chat_id)
+
+        if restr_type == "messages":
+            curr_restr.messages = locked
+        elif restr_type == "media":
+            curr_restr.media = locked
+        elif restr_type == "other":
+            curr_restr.other = locked
+        elif restr_type == "previews":
+            curr_restr.preview = locked
+        elif restr_type == "all":
+            curr_restr.messages = locked
+            curr_restr.media = locked
+            curr_restr.other = locked
+            curr_restr.preview = locked
+        SESSION.add(curr_restr)
+        SESSION.commit()
+
+
+def is_locked(chat_id, lock_type):
+    curr_perm = SESSION.query(Permissions).get(str(chat_id))
+    SESSION.close()
+
+    if not curr_perm:
+        return False
+
+    if lock_type == "sticker":
+        return curr_perm.sticker
+    if lock_type == "photo":
+        return curr_perm.photo
+    if lock_type == "audio":
+        return curr_perm.audio
+    if lock_type == "voice":
+        return curr_perm.voice
+    if lock_type == "contact":
+        return curr_perm.contact
+    if lock_type == "video":
+        return curr_perm.video
+    if lock_type == "document":
+        return curr_perm.document
+    if lock_type == "gif":
+        return curr_perm.gif
+    if lock_type == "url":
+        return curr_perm.url
+    if lock_type == "bots":
+        return curr_perm.bots
+    if lock_type == "forward":
+        return curr_perm.forward
+    if lock_type == "game":
+        return curr_perm.game
+    if lock_type == "location":
+        return curr_perm.location
+    if lock_type == "rtl":
+        return curr_perm.rtl
+    if lock_type == "button":
+        return curr_perm.button
+    if lock_type == "egame":
+        return curr_perm.egame
+    if lock_type == "inline":
+        return curr_perm.inline
+
+
+def is_restr_locked(chat_id, lock_type):
+    curr_restr = SESSION.query(Restrictions).get(str(chat_id))
+    SESSION.close()
+
+    if not curr_restr:
+        return False
+
+    if lock_type == "messages":
+        return curr_restr.messages
+    if lock_type == "media":
+        return curr_restr.media
+    if lock_type == "other":
+        return curr_restr.other
+    if lock_type == "previews":
+        return curr_restr.preview
+    if lock_type == "all":
+        return (
+            curr_restr.messages
+            and curr_restr.media
+            and curr_restr.other
+            and curr_restr.preview
+        )
+
+
+def get_locks(chat_id):
+    try:
+        return SESSION.query(Permissions).get(str(chat_id))
+    finally:
+        SESSION.close()
+
+
+def get_restr(chat_id):
+    try:
+        return SESSION.query(Restrictions).get(str(chat_id))
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with PERM_LOCK:
+        perms = SESSION.query(Permissions).get(str(old_chat_id))
+        if perms:
+            perms.chat_id = str(new_chat_id)
+        SESSION.commit()
+
+    with RESTR_LOCK:
+        rest = SESSION.query(Restrictions).get(str(old_chat_id))
+        if rest:
+            rest.chat_id = str(new_chat_id)
+        SESSION.commit()

Database/sql/log_channel_sql.py

@@ -0,0 +1,180 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+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/nightmode_sql.py

@@ -0,0 +1,42 @@
+from sqlalchemy import Column, String
+
+from Database.sql import BASE, SESSION
+
+
+class Nightmode(BASE):
+    __tablename__ = "nightmode"
+    chat_id = Column(String(14), primary_key=True)
+
+    def __init__(self, chat_id):
+        self.chat_id = chat_id
+
+
+Nightmode.__table__.create(checkfirst=True)
+
+
+def add_nightmode(chat_id: str):
+    nightmoddy = Nightmode(str(chat_id))
+    SESSION.add(nightmoddy)
+    SESSION.commit()
+
+
+def rmnightmode(chat_id: str):
+    rmnightmoddy = SESSION.query(Nightmode).get(str(chat_id))
+    if rmnightmoddy:
+        SESSION.delete(rmnightmoddy)
+        SESSION.commit()
+
+
+def get_all_chat_id():
+    stark = SESSION.query(Nightmode).all()
+    SESSION.close()
+    return stark
+
+
+def is_nightmode_indb(chat_id: str):
+    try:
+        s__ = SESSION.query(Nightmode).get(str(chat_id))
+        if s__:
+            return str(s__.chat_id)
+    finally:
+        SESSION.close()

Database/sql/notes_sql.py

@@ -0,0 +1,210 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏ
+
+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.
+"""
+
+# Note: chat_id's are stored as strings because the int is too large to be stored in a PSQL database.
+import threading
+
+from sqlalchemy import BigInteger, Boolean, Column, String, UnicodeText, distinct, func
+
+from Database.sql import BASE, SESSION
+from Mikobot.plugins.helper_funcs.msg_types import Types
+
+
+class Notes(BASE):
+    __tablename__ = "notes"
+    chat_id = Column(String(14), primary_key=True)
+    name = Column(UnicodeText, primary_key=True)
+    value = Column(UnicodeText, nullable=False)
+    file = Column(UnicodeText)
+    is_reply = Column(Boolean, default=False)
+    has_buttons = Column(Boolean, default=False)
+    msgtype = Column(BigInteger, default=Types.BUTTON_TEXT.value)
+
+    def __init__(self, chat_id, name, value, msgtype, file=None):
+        self.chat_id = str(chat_id)  # ensure string
+        self.name = name
+        self.value = value
+        self.msgtype = msgtype
+        self.file = file
+
+    def __repr__(self):
+        return "<ɴᴏᴛᴇ %s>" % self.name
+
+
+class Buttons(BASE):
+    __tablename__ = "note_urls"
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    chat_id = Column(String(14), primary_key=True)
+    note_name = 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, note_name, name, url, same_line=False):
+        self.chat_id = str(chat_id)
+        self.note_name = note_name
+        self.name = name
+        self.url = url
+        self.same_line = same_line
+
+
+Notes.__table__.create(checkfirst=True)
+Buttons.__table__.create(checkfirst=True)
+
+NOTES_INSERTION_LOCK = threading.RLock()
+BUTTONS_INSERTION_LOCK = threading.RLock()
+
+
+def add_note_to_db(chat_id, note_name, note_data, msgtype, buttons=None, file=None):
+    if not buttons:
+        buttons = []
+
+    with NOTES_INSERTION_LOCK:
+        prev = SESSION.query(Notes).get((str(chat_id), note_name))
+        if prev:
+            with BUTTONS_INSERTION_LOCK:
+                prev_buttons = (
+                    SESSION.query(Buttons)
+                    .filter(
+                        Buttons.chat_id == str(chat_id),
+                        Buttons.note_name == note_name,
+                    )
+                    .all()
+                )
+                for btn in prev_buttons:
+                    SESSION.delete(btn)
+            SESSION.delete(prev)
+        note = Notes(
+            str(chat_id),
+            note_name,
+            note_data or "",
+            msgtype=msgtype.value,
+            file=file,
+        )
+        SESSION.add(note)
+        SESSION.commit()
+
+    for b_name, url, same_line in buttons:
+        add_note_button_to_db(chat_id, note_name, b_name, url, same_line)
+
+
+def get_note(chat_id, note_name):
+    try:
+        return (
+            SESSION.query(Notes)
+            .filter(func.lower(Notes.name) == note_name, Notes.chat_id == str(chat_id))
+            .first()
+        )
+    finally:
+        SESSION.close()
+
+
+def rm_note(chat_id, note_name):
+    with NOTES_INSERTION_LOCK:
+        note = (
+            SESSION.query(Notes)
+            .filter(func.lower(Notes.name) == note_name, Notes.chat_id == str(chat_id))
+            .first()
+        )
+        if note:
+            with BUTTONS_INSERTION_LOCK:
+                buttons = (
+                    SESSION.query(Buttons)
+                    .filter(
+                        Buttons.chat_id == str(chat_id),
+                        Buttons.note_name == note_name,
+                    )
+                    .all()
+                )
+                for btn in buttons:
+                    SESSION.delete(btn)
+
+            SESSION.delete(note)
+            SESSION.commit()
+            return True
+        SESSION.close()
+        return False
+
+
+def get_all_chat_notes(chat_id):
+    try:
+        return (
+            SESSION.query(Notes)
+            .filter(Notes.chat_id == str(chat_id))
+            .order_by(Notes.name.asc())
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def add_note_button_to_db(chat_id, note_name, b_name, url, same_line):
+    with BUTTONS_INSERTION_LOCK:
+        button = Buttons(chat_id, note_name, b_name, url, same_line)
+        SESSION.add(button)
+        SESSION.commit()
+
+
+def get_buttons(chat_id, note_name):
+    try:
+        return (
+            SESSION.query(Buttons)
+            .filter(Buttons.chat_id == str(chat_id), Buttons.note_name == note_name)
+            .order_by(Buttons.id)
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def num_notes():
+    try:
+        return SESSION.query(Notes).count()
+    finally:
+        SESSION.close()
+
+
+def num_chats():
+    try:
+        return SESSION.query(func.count(distinct(Notes.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with NOTES_INSERTION_LOCK:
+        chat_notes = (
+            SESSION.query(Notes).filter(Notes.chat_id == str(old_chat_id)).all()
+        )
+        for note in chat_notes:
+            note.chat_id = str(new_chat_id)
+
+        with BUTTONS_INSERTION_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()

Database/sql/raid_sql.py

@@ -0,0 +1,73 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import Column, String
+
+from Database.sql import BASE, SESSION
+
+
+class RaidChats(BASE):
+    __tablename__ = "raid_chats"
+    chat_id = Column(String(14), primary_key=True)
+
+    def __init__(self, chat_id):
+        self.chat_id = chat_id
+
+
+RaidChats.__table__.create(checkfirst=True)
+INSERTION_LOCK = threading.RLock()
+
+
+def is_raid(chat_id):
+    try:
+        chat = SESSION.query(RaidChats).get(str(chat_id))
+        return bool(chat)
+    finally:
+        SESSION.close()
+
+
+def set_raid(chat_id):
+    with INSERTION_LOCK:
+        raidchat = SESSION.query(RaidChats).get(str(chat_id))
+        if not raidchat:
+            raidchat = RaidChats(str(chat_id))
+        SESSION.add(raidchat)
+        SESSION.commit()
+
+
+def rem_raid(chat_id):
+    with INSERTION_LOCK:
+        raidchat = SESSION.query(RaidChats).get(str(chat_id))
+        if raidchat:
+            SESSION.delete(raidchat)
+        SESSION.commit()
+
+
+def get_all_raid_chats():
+    try:
+        return SESSION.query(RaidChats.chat_id).all()
+    finally:
+        SESSION.close()

Database/sql/remind_sql.py

@@ -0,0 +1,140 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+import time
+
+from sqlalchemy import Column, Integer, String, UnicodeText
+from sqlalchemy.sql.sqltypes import BigInteger
+
+from Database.sql import BASE, SESSION
+
+
+class Reminds(BASE):
+    __tablename__ = "reminds"
+    chat_id = Column(String(14), primary_key=True)
+    time_seconds = Column(Integer, primary_key=True)
+    remind_message = Column(UnicodeText, default="")
+    user_id = Column(BigInteger, default=0)
+
+    def __init__(self, chat_id, time_seconds):
+        self.chat_id = str(chat_id)
+        self.time_seconds = int(time_seconds)
+
+    def __repr__(self):
+        return "<ʀᴇᴍɪɴᴅ ɪɴ {} ғᴏʀ ᴛɪᴍᴇ {}>".format(
+            self.chat_id,
+            self.time_seconds,
+        )
+
+
+# Reminds.__table__.drop()
+Reminds.__table__.create(checkfirst=True)
+
+INSERTION_LOCK = threading.RLock()
+
+REMINDERS = {}
+
+
+def set_remind(chat_id, time_sec, remind_message, user_id):
+    with INSERTION_LOCK:
+        reminds = SESSION.query(Reminds).get((str(chat_id), time_sec))
+        if not reminds:
+            reminds = Reminds(chat_id, time_sec)
+        reminds.remind_message = remind_message
+        reminds.user_id = user_id
+        SESSION.add(reminds)
+        SESSION.commit()
+        if not time_sec in REMINDERS:
+            REMINDERS[time_sec] = []
+        REMINDERS[time_sec].append(
+            {"chat_id": str(chat_id), "message": remind_message, "user_id": user_id}
+        )
+
+
+def rem_remind(chat_id, time_sec, remind_message, user_id):
+    with INSERTION_LOCK:
+        reminds = SESSION.query(Reminds).get((str(chat_id), time_sec))
+        if reminds:
+            SESSION.delete(reminds)
+            SESSION.commit()
+            REMINDERS[time_sec].remove(
+                {"chat_id": str(chat_id), "message": remind_message, "user_id": user_id}
+            )
+            return True
+        SESSION.close()
+        return False
+
+
+def get_remind_in_chat(chat_id, timestamp):
+    return (
+        SESSION.query(Reminds)
+        .filter(Reminds.chat_id == str(chat_id), Reminds.time_seconds == timestamp)
+        .first()
+    )
+
+
+def num_reminds_in_chat(chat_id):
+    return SESSION.query(Reminds).filter(Reminds.chat_id == str(chat_id)).count()
+
+
+def get_reminds_in_chat(chat_id):
+    try:
+        return (
+            SESSION.query(Reminds)
+            .filter(Reminds.chat_id == str(chat_id))
+            .order_by(Reminds.time_seconds.asc())
+            .all()
+        )
+    finally:
+        SESSION.close()
+
+
+def __get_all_reminds():
+    try:
+        chats = SESSION.query(Reminds).all()
+        for chat in chats:
+            if (chat.time_seconds <= round(time.time())) or chat.user_id == 0:
+                try:
+                    rem_remind(
+                        chat.chat_id,
+                        chat.time_seconds,
+                        chat.remind_message,
+                        chat.user_id,
+                    )
+                except:
+                    pass
+                continue
+            REMINDERS[chat.time_seconds] = [
+                {
+                    "chat_id": chat.chat_id,
+                    "message": chat.remind_message,
+                    "user_id": chat.user_id,
+                }
+            ]
+    finally:
+        SESSION.close()
+
+
+__get_all_reminds()

Database/sql/reporting_sql.py

@@ -0,0 +1,115 @@
+"""
+MIT License
+
+Copyright (c) 2022 Arsh
+
+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.
+"""
+
+import threading
+from typing import Union
+
+from sqlalchemy import BigInteger, Boolean, Column, String
+
+from Database.sql import BASE, SESSION
+
+
+class ReportingUserSettings(BASE):
+    __tablename__ = "user_report_settings"
+    user_id = Column(BigInteger, primary_key=True)
+    should_report = Column(Boolean, default=True)
+
+    def __init__(self, user_id):
+        self.user_id = user_id
+
+    def __repr__(self):
+        return "<ᴜsᴇʀ ʀᴇᴘᴏʀᴛ sᴇᴛᴛɪɴɢs ({})>".format(self.user_id)
+
+
+class ReportingChatSettings(BASE):
+    __tablename__ = "chat_report_settings"
+    chat_id = Column(String(14), primary_key=True)
+    should_report = Column(Boolean, default=True)
+
+    def __init__(self, chat_id):
+        self.chat_id = str(chat_id)
+
+    def __repr__(self):
+        return "<ᴄʜᴀᴛ ʀᴇᴘᴏʀᴛ sᴇᴛᴛɪɴɢs ({})>".format(self.chat_id)
+
+
+ReportingUserSettings.__table__.create(checkfirst=True)
+ReportingChatSettings.__table__.create(checkfirst=True)
+
+CHAT_LOCK = threading.RLock()
+USER_LOCK = threading.RLock()
+
+
+def chat_should_report(chat_id: Union[str, int]) -> bool:
+    try:
+        chat_setting = SESSION.query(ReportingChatSettings).get(str(chat_id))
+        if chat_setting:
+            return chat_setting.should_report
+        return False
+    finally:
+        SESSION.close()
+
+
+def user_should_report(user_id: int) -> bool:
+    try:
+        user_setting = SESSION.query(ReportingUserSettings).get(user_id)
+        if user_setting:
+            return user_setting.should_report
+        return True
+    finally:
+        SESSION.close()
+
+
+def set_chat_setting(chat_id: Union[int, str], setting: bool):
+    with CHAT_LOCK:
+        chat_setting = SESSION.query(ReportingChatSettings).get(str(chat_id))
+        if not chat_setting:
+            chat_setting = ReportingChatSettings(chat_id)
+
+        chat_setting.should_report = setting
+        SESSION.add(chat_setting)
+        SESSION.commit()
+
+
+def set_user_setting(user_id: int, setting: bool):
+    with USER_LOCK:
+        user_setting = SESSION.query(ReportingUserSettings).get(user_id)
+        if not user_setting:
+            user_setting = ReportingUserSettings(user_id)
+
+        user_setting.should_report = setting
+        SESSION.add(user_setting)
+        SESSION.commit()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with CHAT_LOCK:
+        chat_notes = (
+            SESSION.query(ReportingChatSettings)
+            .filter(ReportingChatSettings.chat_id == str(old_chat_id))
+            .all()
+        )
+        for note in chat_notes:
+            note.chat_id = str(new_chat_id)
+        SESSION.commit()

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,100 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏᴏ
+
+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.
+"""
+
+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 "<ᴜsᴇʀ ɪɴғᴏ %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 "<ᴜsᴇʀ ɪɴғᴏ %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,258 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import (
+    BigInteger,
+    Column,
+    ForeignKey,
+    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 "<ᴜsᴇʀ {} ({})>".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 "<ᴄʜᴀᴛ {} ({})>".format(self.chat_name, self.chat_id)
+
+
+class ChatMembers(BASE):
+    __tablename__ = "chat_members"
+    priv_chat_id = Column(BigInteger, 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 "<ᴄʜᴀᴛ ᴜsᴇʀ {} ({}) ɪɴ ᴄʜᴀᴛ {} ({})>".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/warns_sql.py

@@ -0,0 +1,341 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+import threading
+
+from sqlalchemy import BigInteger, Boolean, Column, String, UnicodeText, distinct, func
+from sqlalchemy.dialects import postgresql
+
+from Database.sql import BASE, SESSION
+
+
+class Warns(BASE):
+    __tablename__ = "warns"
+
+    user_id = Column(BigInteger, primary_key=True)
+    chat_id = Column(String(14), primary_key=True)
+    num_warns = Column(BigInteger, default=0)
+    reasons = Column(postgresql.ARRAY(UnicodeText))
+
+    def __init__(self, user_id, chat_id):
+        self.user_id = user_id
+        self.chat_id = str(chat_id)
+        self.num_warns = 0
+        self.reasons = []
+
+    def __repr__(self):
+        return "<{} ᴡᴀʀɴs ғᴏʀ {} ɪɴ {} ғᴏʀ ʀᴇᴀsᴏɴs {}>".format(
+            self.num_warns,
+            self.user_id,
+            self.chat_id,
+            self.reasons,
+        )
+
+
+class WarnFilters(BASE):
+    __tablename__ = "warn_filters"
+    chat_id = Column(String(14), primary_key=True)
+    keyword = Column(UnicodeText, primary_key=True, nullable=False)
+    reply = Column(UnicodeText, nullable=False)
+
+    def __init__(self, chat_id, keyword, reply):
+        self.chat_id = str(chat_id)  # ensure string
+        self.keyword = keyword
+        self.reply = reply
+
+    def __repr__(self):
+        return "<ᴘᴇʀᴍɪssɪᴏɴs ғᴏʀ %s>" % self.chat_id
+
+    def __eq__(self, other):
+        return bool(
+            isinstance(other, WarnFilters)
+            and self.chat_id == other.chat_id
+            and self.keyword == other.keyword,
+        )
+
+
+class WarnSettings(BASE):
+    __tablename__ = "warn_settings"
+    chat_id = Column(String(14), primary_key=True)
+    warn_limit = Column(BigInteger, default=3)
+    soft_warn = Column(Boolean, default=False)
+
+    def __init__(self, chat_id, warn_limit=3, soft_warn=False):
+        self.chat_id = str(chat_id)
+        self.warn_limit = warn_limit
+        self.soft_warn = soft_warn
+
+    def __repr__(self):
+        return "<{} ʜᴀs {} ᴘᴏssɪʙʟᴇ ᴡᴀʀɴs.>".format(self.chat_id, self.warn_limit)
+
+
+Warns.__table__.create(checkfirst=True)
+WarnFilters.__table__.create(checkfirst=True)
+WarnSettings.__table__.create(checkfirst=True)
+
+WARN_INSERTION_LOCK = threading.RLock()
+WARN_FILTER_INSERTION_LOCK = threading.RLock()
+WARN_SETTINGS_LOCK = threading.RLock()
+
+WARN_FILTERS = {}
+
+
+def warn_user(user_id, chat_id, reason=None):
+    with WARN_INSERTION_LOCK:
+        warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
+        if not warned_user:
+            warned_user = Warns(user_id, str(chat_id))
+
+        warned_user.num_warns += 1
+        if reason:
+            warned_user.reasons = warned_user.reasons + [
+                reason,
+            ]  # TODO:: double check this wizardry
+
+        reasons = warned_user.reasons
+        num = warned_user.num_warns
+
+        SESSION.add(warned_user)
+        SESSION.commit()
+
+        return num, reasons
+
+
+def remove_warn(user_id, chat_id):
+    with WARN_INSERTION_LOCK:
+        removed = False
+        warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
+
+        if warned_user and warned_user.num_warns > 0:
+            warned_user.num_warns -= 1
+            warned_user.reasons = warned_user.reasons[:-1]
+            SESSION.add(warned_user)
+            SESSION.commit()
+            removed = True
+
+        SESSION.close()
+        return removed
+
+
+def reset_warns(user_id, chat_id):
+    with WARN_INSERTION_LOCK:
+        warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
+        if warned_user:
+            warned_user.num_warns = 0
+            warned_user.reasons = []
+
+            SESSION.add(warned_user)
+            SESSION.commit()
+        SESSION.close()
+
+
+def get_warns(user_id, chat_id):
+    try:
+        user = SESSION.query(Warns).get((user_id, str(chat_id)))
+        if not user:
+            return None
+        reasons = user.reasons
+        num = user.num_warns
+        return num, reasons
+    finally:
+        SESSION.close()
+
+
+def add_warn_filter(chat_id, keyword, reply):
+    with WARN_FILTER_INSERTION_LOCK:
+        warn_filt = WarnFilters(str(chat_id), keyword, reply)
+
+        if keyword not in WARN_FILTERS.get(str(chat_id), []):
+            WARN_FILTERS[str(chat_id)] = sorted(
+                WARN_FILTERS.get(str(chat_id), []) + [keyword],
+                key=lambda x: (-len(x), x),
+            )
+
+        SESSION.merge(warn_filt)  # merge to avoid duplicate key issues
+        SESSION.commit()
+
+
+def remove_warn_filter(chat_id, keyword):
+    with WARN_FILTER_INSERTION_LOCK:
+        warn_filt = SESSION.query(WarnFilters).get((str(chat_id), keyword))
+        if warn_filt:
+            if keyword in WARN_FILTERS.get(str(chat_id), []):  # sanity check
+                WARN_FILTERS.get(str(chat_id), []).remove(keyword)
+
+            SESSION.delete(warn_filt)
+            SESSION.commit()
+            return True
+        SESSION.close()
+        return False
+
+
+def get_chat_warn_triggers(chat_id):
+    return WARN_FILTERS.get(str(chat_id), set())
+
+
+def get_chat_warn_filters(chat_id):
+    try:
+        return (
+            SESSION.query(WarnFilters).filter(WarnFilters.chat_id == str(chat_id)).all()
+        )
+    finally:
+        SESSION.close()
+
+
+def get_warn_filter(chat_id, keyword):
+    try:
+        return SESSION.query(WarnFilters).get((str(chat_id), keyword))
+    finally:
+        SESSION.close()
+
+
+def set_warn_limit(chat_id, warn_limit):
+    with WARN_SETTINGS_LOCK:
+        curr_setting = SESSION.query(WarnSettings).get(str(chat_id))
+        if not curr_setting:
+            curr_setting = WarnSettings(chat_id, warn_limit=warn_limit)
+
+        curr_setting.warn_limit = warn_limit
+
+        SESSION.add(curr_setting)
+        SESSION.commit()
+
+
+def set_warn_strength(chat_id, soft_warn):
+    with WARN_SETTINGS_LOCK:
+        curr_setting = SESSION.query(WarnSettings).get(str(chat_id))
+        if not curr_setting:
+            curr_setting = WarnSettings(chat_id, soft_warn=soft_warn)
+
+        curr_setting.soft_warn = soft_warn
+
+        SESSION.add(curr_setting)
+        SESSION.commit()
+
+
+def get_warn_setting(chat_id):
+    try:
+        setting = SESSION.query(WarnSettings).get(str(chat_id))
+        if setting:
+            return setting.warn_limit, setting.soft_warn
+        return 3, False
+
+    finally:
+        SESSION.close()
+
+
+def num_warns():
+    try:
+        return SESSION.query(func.sum(Warns.num_warns)).scalar() or 0
+    finally:
+        SESSION.close()
+
+
+def num_warn_chats():
+    try:
+        return SESSION.query(func.count(distinct(Warns.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def num_warn_filters():
+    try:
+        return SESSION.query(WarnFilters).count()
+    finally:
+        SESSION.close()
+
+
+def num_warn_chat_filters(chat_id):
+    try:
+        return (
+            SESSION.query(WarnFilters.chat_id)
+            .filter(WarnFilters.chat_id == str(chat_id))
+            .count()
+        )
+    finally:
+        SESSION.close()
+
+
+def num_warn_filter_chats():
+    try:
+        return SESSION.query(func.count(distinct(WarnFilters.chat_id))).scalar()
+    finally:
+        SESSION.close()
+
+
+def __load_chat_warn_filters():
+    global WARN_FILTERS
+    try:
+        chats = SESSION.query(WarnFilters.chat_id).distinct().all()
+        for (chat_id,) in chats:  # remove tuple by ( ,)
+            WARN_FILTERS[chat_id] = []
+
+        all_filters = SESSION.query(WarnFilters).all()
+        for x in all_filters:
+            WARN_FILTERS[x.chat_id] += [x.keyword]
+
+        WARN_FILTERS = {
+            x: sorted(set(y), key=lambda i: (-len(i), i))
+            for x, y in WARN_FILTERS.items()
+        }
+
+    finally:
+        SESSION.close()
+
+
+def migrate_chat(old_chat_id, new_chat_id):
+    with WARN_INSERTION_LOCK:
+        chat_notes = (
+            SESSION.query(Warns).filter(Warns.chat_id == str(old_chat_id)).all()
+        )
+        for note in chat_notes:
+            note.chat_id = str(new_chat_id)
+        SESSION.commit()
+
+    with WARN_FILTER_INSERTION_LOCK:
+        chat_filters = (
+            SESSION.query(WarnFilters)
+            .filter(WarnFilters.chat_id == str(old_chat_id))
+            .all()
+        )
+        for filt in chat_filters:
+            filt.chat_id = str(new_chat_id)
+        SESSION.commit()
+        old_warn_filt = WARN_FILTERS.get(str(old_chat_id))
+        if old_warn_filt is not None:
+            WARN_FILTERS[str(new_chat_id)] = old_warn_filt
+            del WARN_FILTERS[str(old_chat_id)]
+
+    with WARN_SETTINGS_LOCK:
+        chat_settings = (
+            SESSION.query(WarnSettings)
+            .filter(WarnSettings.chat_id == str(old_chat_id))
+            .all()
+        )
+        for setting in chat_settings:
+            setting.chat_id = str(new_chat_id)
+        SESSION.commit()
+
+
+__load_chat_warn_filters()

Database/sql/welcome_sql.py

@@ -0,0 +1,507 @@
+"""
+MIT License
+
+Copyright (c) 2022 Aʙɪsʜɴᴏɪ
+
+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.
+"""
+
+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 = "ʜᴇʏ {first}, ʜᴏᴡ ᴀʀᴇ ʏᴏᴜ?"
+DEFAULT_GOODBYE = "ɴɪᴄᴇ ᴋɴᴏᴡɪɴɢ ʏᴀ!"
+
+DEFAULT_WELCOME_MESSAGES = [
+    "{first} ɪs ʜᴇʀᴇ!",  # Discord welcome messages copied
+    "ʀᴇᴀᴅʏ ᴘʟᴀʏᴇʀ {first}",
+    "ᴡᴇʟᴄᴏᴍᴇ ʙʀᴏ {first}",
+]
+
+DEFAULT_GOODBYE_MESSAGES = [
+    "{first} ᴡɪʟʟ ʙᴇ ᴍɪssᴇᴅ.",
+    "{first} ᴡʜᴇɴ ʙᴀᴄᴋ ?.",
+]
+
+
+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 "<ᴄʜᴀᴛ {} sʜᴏᴜʟᴅ sʜᴏᴜʟᴅ ɴᴇᴡ ᴜsᴇʀs: {}>".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 "<ᴄʜᴀᴛ ᴜsᴇᴅ ᴄʟᴇᴀɴ sᴇʀᴠɪᴄᴇ ({})>".format(self.chat_id)
+
+
+class RaidMode(BASE):
+    __tablename__ = "raid_mode"
+    chat_id = Column(String(14), primary_key=True)
+    status = Column(Boolean, default=False)
+    time = Column(Integer, default=21600)
+    acttime = Column(Integer, default=3600)
+    # permanent = Column(Boolean, default=False)
+
+    def __init__(self, chat_id, status, time, acttime):
+        self.chat_id = str(chat_id)
+        self.status = status
+        self.time = time
+        self.acttime = acttime
+        # self.permanent = permanent
+
+
+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)
+RaidMode.__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()
+RAID_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()
+
+
+def getRaidStatus(chat_id):
+    try:
+        if stat := SESSION.query(RaidMode).get(str(chat_id)):
+            return stat.status, stat.time, stat.acttime
+        return False, 21600, 3600  # default
+    finally:
+        SESSION.close()
+
+
+def setRaidStatus(chat_id, status, time=21600, acttime=3600):
+    with RAID_LOCK:
+        if prevObj := SESSION.query(RaidMode).get(str(chat_id)):
+            SESSION.delete(prevObj)
+        newObj = RaidMode(str(chat_id), status, time, acttime)
+        SESSION.add(newObj)
+        SESSION.commit()
+
+
+def toggleRaidStatus(chat_id):
+    newObj = True
+    with RAID_LOCK:
+        prevObj = SESSION.query(RaidMode).get(str(chat_id))
+        if prevObj:
+            newObj = not prevObj.status
+        stat = RaidMode(
+            str(chat_id), newObj, prevObj.time or 21600, prevObj.acttime or 3600
+        )
+        SESSION.add(stat)
+        SESSION.commit()
+        return newObj
+
+
+def _ResetRaidOnRestart():
+    with RAID_LOCK:
+        raid = SESSION.query(RaidMode).all()
+        for r in raid:
+            r.status = False
+        SESSION.commit()
+
+
+# it uses a cron job to turn off so if the bot restarts and there is a pending raid disable job then raid will stay on
+_ResetRaidOnRestart()

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11.9
+
+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,90 @@
+# 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",
+]
+
+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="extra_command_handler"),
+    ],
+    [
+        InlineKeyboardButton(text="DETAILS", callback_data="Miko_"),
+        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* 🫧 [ㅤ](https://telegra.ph/file/b05535884267a19ee5c93.jpg)
+
+☉ *Here, you will find a list of all the available commands.*
+
+ᴀʟʟ ᴄᴏᴍᴍᴀɴᴅs ᴄᴀɴ ʙᴇ ᴜsᴇᴅ ᴡɪᴛʜ : /
+"""