Merge pull request #149 from Infamous-Hydra/Miko3.0

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

@@ -7,7 +7,7 @@ from Database.sql import BASE, SESSION
 
 
 class AFK(BASE):
-    __tablename__ = "afk_users"
+    __tablename__ = "afk_user"
 
     user_id = Column(BigInteger, primary_key=True)
     is_afk = Column(Boolean)

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

@@ -1,6 +1,30 @@
+"""
+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, Integer, String, UnicodeText
+from sqlalchemy import BigInteger, Column, String, UnicodeText
 
 from Database.sql import BASE, SESSION
 
@@ -13,20 +37,20 @@ class FloodControl(BASE):
     __tablename__ = "antiflood"
     chat_id = Column(String(14), primary_key=True)
     user_id = Column(BigInteger)
-    count = Column(Integer, default=DEF_COUNT)
-    limit = Column(Integer, default=DEF_LIMIT)
+    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 "<flood control for %s>" % self.chat_id
+        return "<ғʟᴏᴏᴅ ᴄᴏɴᴛʀᴏʟ ғᴏʀ %s>" % self.chat_id
 
 
 class FloodSettings(BASE):
     __tablename__ = "antiflood_settings"
     chat_id = Column(String(14), primary_key=True)
-    flood_type = Column(Integer, default=1)
+    flood_type = Column(BigInteger, default=1)
     value = Column(UnicodeText, default="0")
 
     def __init__(self, chat_id, flood_type=1, value="0"):
@@ -35,7 +59,7 @@ class FloodSettings(BASE):
         self.value = value
 
     def __repr__(self):
-        return "<{} will executing {} for flood.>".format(self.chat_id, self.flood_type)
+        return "<{} ᴡɪʟʟ ᴇxᴇᴄᴜᴛɪɴɢ {} ғᴏʀ ғʟᴏᴏᴅ.>".format(self.chat_id, self.flood_type)
 
 
 FloodControl.__table__.create(checkfirst=True)
@@ -63,37 +87,40 @@ def set_flood(chat_id, amount):
 
 
 def update_flood(chat_id: str, user_id) -> bool:
-    if str(chat_id) in CHAT_FLOOD:
-        curr_user_id, count, limit = CHAT_FLOOD.get(str(chat_id), DEF_OBJ)
-
-        if limit == 0:  # no antiflood
-            return False
+    if str(chat_id) not in CHAT_FLOOD:
+        return
 
-        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
+    curr_user_id, count, limit = CHAT_FLOOD.get(str(chat_id), DEF_OBJ)
 
-        count += 1
-        if count > limit:  # too many msgs, kick
-            CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, limit)
-            return True
+    if limit == 0:  # no antiflood
+        return False
 
-        # default -> update
-        CHAT_FLOOD[str(chat_id)] = (user_id, count, limit)
+    if user_id != curr_user_id or user_id is None:  # other user
+        CHAT_FLOOD[str(chat_id)] = (user_id, DEF_COUNT, limit)
         return False
 
+    count += 1
+    if count > limit:  # too many msgs, kick
+        CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, limit)
+        return True
+
+    # default -> update
+    CHAT_FLOOD[str(chat_id)] = (user_id, count, limit)
+    return False
+
 
 def get_flood_limit(chat_id):
     return CHAT_FLOOD.get(str(chat_id), DEF_OBJ)[2]
 
 
 def set_flood_strength(chat_id, flood_type, value):
-    # for flood_type
+    # ғᴏʀ ғʟᴏᴏᴅ_ᴛʏᴘᴇ
     # 1 = ban
     # 2 = kick
     # 3 = mute
     # 4 = tban
     # 5 = tmute
+    # 6 = ᴅᴍᴜᴛᴇ sᴏᴏɴ
     with INSERTION_FLOOD_SETTINGS_LOCK:
         curr_setting = SESSION.query(FloodSettings).get(str(chat_id))
         if not curr_setting:
@@ -115,8 +142,7 @@ def get_flood_setting(chat_id):
         setting = SESSION.query(FloodSettings).get(str(chat_id))
         if setting:
             return setting.flood_type, setting.value
-        else:
-            return 1, "0"
+        return 1, "0"
 
     finally:
         SESSION.close()

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

@@ -1,3 +1,27 @@
+"""
+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
@@ -15,7 +39,7 @@ class Approvals(BASE):
         self.user_id = user_id
 
     def __repr__(self):
-        return "<Approve %s>" % self.user_id
+        return "<ᴀᴘᴘʀᴏᴠᴇ %s>" % self.user_id
 
 
 Approvals.__table__.create(checkfirst=True)

Database/sql/blacklist_sql.py

@@ -1,6 +1,30 @@
+"""
+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, Integer, String, UnicodeText, distinct, func
+from sqlalchemy import BigInteger, Column, String, UnicodeText, distinct, func
 
 from Database.sql import BASE, SESSION
 
@@ -15,7 +39,7 @@ class BlackListFilters(BASE):
         self.trigger = trigger
 
     def __repr__(self):
-        return "<Blacklist filter '%s' for %s>" % (self.trigger, self.chat_id)
+        return "<ʙʟᴀᴄᴋʟɪsᴛ ғɪʟᴛᴇʀ '%s' ғᴏʀ %s>" % (self.trigger, self.chat_id)
 
     def __eq__(self, other):
         return bool(
@@ -28,7 +52,7 @@ class BlackListFilters(BASE):
 class BlacklistSettings(BASE):
     __tablename__ = "blacklist_settings"
     chat_id = Column(String(14), primary_key=True)
-    blacklist_type = Column(Integer, default=1)
+    blacklist_type = Column(BigInteger, default=1)
     value = Column(UnicodeText, default="0")
 
     def __init__(self, chat_id, blacklist_type=1, value="0"):
@@ -37,7 +61,7 @@ class BlacklistSettings(BASE):
         self.value = value
 
     def __repr__(self):
-        return "<{} will executing {} for blacklist trigger.>".format(
+        return "<{} ᴡɪʟʟ ᴇxᴇᴄᴜᴛɪɴɢ {} ғᴏʀ ʙʟᴀᴄᴋʟɪsᴛ ᴛʀɪɢɢᴇʀ.>".format(
             self.chat_id,
             self.blacklist_type,
         )
@@ -146,8 +170,7 @@ def get_blacklist_setting(chat_id):
         setting = CHAT_SETTINGS_BLACKLISTS.get(str(chat_id))
         if setting:
             return setting["blacklist_type"], setting["value"]
-        else:
-            return 1, "0"
+        return 1, "0"
 
     finally:
         SESSION.close()

Database/sql/blacklistusers_sql.py

@@ -1,3 +1,27 @@
+"""
+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
@@ -46,10 +70,7 @@ def unblacklist_user(user_id):
 
 def get_reason(user_id):
     user = SESSION.query(BlacklistUsers).get(str(user_id))
-    rep = ""
-    if user:
-        rep = user.reason
-
+    rep = user.reason if user else ""
     SESSION.close()
     return rep
 

Database/sql/blsticker_sql.py

@@ -1,6 +1,30 @@
+"""
+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, Integer, String, UnicodeText, distinct, func
+from sqlalchemy import BigInteger, Column, String, UnicodeText, distinct, func
 
 from Database.sql import BASE, SESSION
 
@@ -15,7 +39,7 @@ class StickersFilters(BASE):
         self.trigger = trigger
 
     def __repr__(self):
-        return "<Stickers filter '%s' for %s>" % (self.trigger, self.chat_id)
+        return "<sᴛɪᴄᴋᴇʀs ғɪʟᴛᴇʀ '%s' ғᴏʀ %s>" % (self.trigger, self.chat_id)
 
     def __eq__(self, other):
         return bool(
@@ -28,7 +52,7 @@ class StickersFilters(BASE):
 class StickerSettings(BASE):
     __tablename__ = "blsticker_settings"
     chat_id = Column(String(14), primary_key=True)
-    blacklist_type = Column(Integer, default=1)
+    blacklist_type = Column(BigInteger, default=1)
     value = Column(UnicodeText, default="0")
 
     def __init__(self, chat_id, blacklist_type=1, value="0"):
@@ -37,7 +61,7 @@ class StickerSettings(BASE):
         self.value = value
 
     def __repr__(self):
-        return "<{} will executing {} for blacklist trigger.>".format(
+        return "<{} ᴡɪʟʟ ᴇxᴇᴄᴜᴛɪɴɢ {} ғᴏʀ ʙʟᴀᴄᴋʟɪsᴛ ᴛʀɪɢɢᴇʀ.>".format(
             self.chat_id,
             self.blacklist_type,
         )
@@ -146,8 +170,7 @@ def get_blacklist_setting(chat_id):
         setting = CHAT_BLSTICK_BLACKLISTS.get(str(chat_id))
         if setting:
             return setting["blacklist_type"], setting["value"]
-        else:
-            return 1, "0"
+        return 1, "0"
 
     finally:
         SESSION.close()

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

@@ -1,3 +1,27 @@
+"""
+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
@@ -17,8 +41,9 @@ class ChatAccessConnectionSettings(BASE):
         self.allow_connect_to_chat = str(allow_connect_to_chat)
 
     def __repr__(self):
-        return "<Chat access settings ({}) is {}>".format(
-            self.chat_id, self.allow_connect_to_chat
+        return "<ᴄʜᴀᴛ ᴀᴄᴄᴇss sᴇᴛᴛɪɴɢs ({}) is {}>".format(
+            self.chat_id,
+            self.allow_connect_to_chat,
         )
 
 
@@ -46,7 +71,7 @@ class ConnectionHistory(BASE):
         self.conn_time = int(conn_time)
 
     def __repr__(self):
-        return "<connection user {} history {}>".format(self.user_id, self.chat_id)
+        return "<ᴄᴏɴɴᴇᴄᴛɪᴏɴ ᴜsᴇʀ {} ʜɪsᴛᴏʀʏ {}>".format(self.user_id, self.chat_id)
 
 
 ChatAccessConnectionSettings.__table__.create(checkfirst=True)
@@ -113,9 +138,8 @@ def disconnect(user_id):
             SESSION.delete(disconnect)
             SESSION.commit()
             return True
-        else:
-            SESSION.close()
-            return False
+        SESSION.close()
+        return False
 
 
 def add_history_conn(user_id, chat_id, chat_name):
@@ -128,13 +152,15 @@ def add_history_conn(user_id, chat_id, chat_name):
                 .filter(ConnectionHistory.user_id == str(user_id))
                 .count()
             )
-            getchat_id = {}
-            for x in HISTORY_CONNECT[int(user_id)]:
-                getchat_id[HISTORY_CONNECT[int(user_id)][x]["chat_id"]] = x
+            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))
+                    (int(user_id), str(chat_id)),
                 )
                 if delold:
                     SESSION.delete(delold)
@@ -146,7 +172,7 @@ def add_history_conn(user_id, chat_id, chat_name):
                 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))
+                        (int(user_id), str(chat_old)),
                     )
                     if delold:
                         SESSION.delete(delold)

Database/sql/cust_filters_sql.py

@@ -11,30 +11,80 @@ class CustomFilters(BASE):
     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)
-    has_buttons = Column(Boolean, nullable=False, default=False)
-    # NOTE: Here for legacy purposes, to ensure older filters don't mess up.
-    has_media_spoiler = Column(Boolean, nullable=False, default=False)
 
     def __init__(
         self,
-        chat_id: int | str,
-        keyword: str,
-        reply: str,
-        reply_text: str,
-        has_buttons: bool,
-        has_media_spoiler: bool,
-        file_type: int,
-        file_id: str,
+        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.reply_text = reply_text
+        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_media_spoiler = has_media_spoiler
+        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
 
@@ -45,7 +95,7 @@ class CustomFilters(BASE):
         return bool(
             isinstance(other, CustomFilters)
             and self.chat_id == other.chat_id
-            and self.keyword == other.keyword,
+            and self.keyword == other.keyword
         )
 
 
@@ -81,6 +131,62 @@ def get_all_filters():
         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
 ):
@@ -106,8 +212,13 @@ def new_add_filter(
             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),
-            has_media_spoiler=media_spoiler,
             reply_text=reply_text,
             file_type=file_type.value,
             file_id=file_id,
@@ -168,7 +279,7 @@ def get_chat_filters(chat_id):
         SESSION.close()
 
 
-def get_filter(chat_id, keyword) -> CustomFilters:
+def get_filter(chat_id, keyword):
     try:
         return SESSION.query(CustomFilters).get((str(chat_id), keyword))
     finally:
@@ -248,21 +359,14 @@ def __migrate_filters():
             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,
+                    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,
+                    str(x.chat_id), x.keyword, None, file_type.value, x.reply
                 )
 
             SESSION.add(filt)
@@ -282,10 +386,11 @@ def migrate_chat(old_chat_id, new_chat_id):
         for filt in chat_filters:
             filt.chat_id = str(new_chat_id)
         SESSION.commit()
-        old_filt = CHAT_FILTERS.get(str(old_chat_id))
-        if old_filt:
-            CHAT_FILTERS[str(new_chat_id)] = old_filt
-            del CHAT_FILTERS[str(old_chat_id)]
+        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 = (

Database/sql/disable_sql.py

@@ -1,3 +1,27 @@
+"""
+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
@@ -15,7 +39,7 @@ class Disable(BASE):
         self.command = command
 
     def __repr__(self):
-        return "Disabled cmd {} in {}".format(self.command, self.chat_id)
+        return "ᴅɪsᴀʙʟᴇᴅ ᴄᴍᴅ {} in {}".format(self.command, self.chat_id)
 
 
 Disable.__table__.create(checkfirst=True)

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/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

@@ -1,3 +1,27 @@
+"""
+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
 

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

@@ -1,6 +1,31 @@
+"""
+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 Boolean, Column, Integer, String, UnicodeText, distinct, func
+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
@@ -14,7 +39,7 @@ class Notes(BASE):
     file = Column(UnicodeText)
     is_reply = Column(Boolean, default=False)
     has_buttons = Column(Boolean, default=False)
-    msgtype = Column(Integer, default=Types.BUTTON_TEXT.value)
+    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
@@ -24,12 +49,12 @@ class Notes(BASE):
         self.file = file
 
     def __repr__(self):
-        return "<Note %s>" % self.name
+        return "<ɴᴏᴛᴇ %s>" % self.name
 
 
 class Buttons(BASE):
     __tablename__ = "note_urls"
-    id = Column(Integer, primary_key=True, autoincrement=True)
+    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)
@@ -118,10 +143,8 @@ def rm_note(chat_id, note_name):
             SESSION.delete(note)
             SESSION.commit()
             return True
-
-        else:
-            SESSION.close()
-            return False
+        SESSION.close()
+        return False
 
 
 def get_all_chat_notes(chat_id):

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

@@ -1,3 +1,27 @@
+"""
+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
@@ -15,7 +39,7 @@ class UserInfo(BASE):
         self.info = info
 
     def __repr__(self):
-        return "<User info %d>" % self.user_id
+        return "<ᴜsᴇʀ ɪɴғᴏ %d>" % self.user_id
 
 
 class UserBio(BASE):
@@ -28,7 +52,7 @@ class UserBio(BASE):
         self.bio = bio
 
     def __repr__(self):
-        return "<User info %d>" % self.user_id
+        return "<ᴜsᴇʀ ɪɴғᴏ %d>" % self.user_id
 
 
 UserInfo.__table__.create(checkfirst=True)

Database/sql/users_sql.py

@@ -1,10 +1,33 @@
+"""
+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,
-    Integer,
     String,
     UnicodeText,
     UniqueConstraint,
@@ -25,7 +48,7 @@ class Users(BASE):
         self.username = username
 
     def __repr__(self):
-        return "<User {} ({})>".format(self.username, self.user_id)
+        return "<ᴜsᴇʀ {} ({})>".format(self.username, self.user_id)
 
 
 class Chats(BASE):
@@ -38,12 +61,12 @@ class Chats(BASE):
         self.chat_name = chat_name
 
     def __repr__(self):
-        return "<Chat {} ({})>".format(self.chat_name, self.chat_id)
+        return "<ᴄʜᴀᴛ {} ({})>".format(self.chat_name, self.chat_id)
 
 
 class ChatMembers(BASE):
     __tablename__ = "chat_members"
-    priv_chat_id = Column(Integer, primary_key=True)
+    priv_chat_id = Column(BigInteger, primary_key=True)
     # NOTE: Use dual primary key instead of private primary key?
     chat = Column(
         String(14),
@@ -62,7 +85,7 @@ class ChatMembers(BASE):
         self.user = user
 
     def __repr__(self):
-        return "<Chat user {} ({}) in chat {} ({})>".format(
+        return "<ᴄʜᴀᴛ ᴜsᴇʀ {} ({}) ɪɴ ᴄʜᴀᴛ {} ({})>".format(
             self.user.username,
             self.user.user_id,
             self.chat.chat_name,

Database/sql/warns_sql.py

@@ -1,15 +1,30 @@
+"""
+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,
-    Integer,
-    String,
-    UnicodeText,
-    distinct,
-    func,
-)
+from sqlalchemy import BigInteger, Boolean, Column, String, UnicodeText, distinct, func
 from sqlalchemy.dialects import postgresql
 
 from Database.sql import BASE, SESSION
@@ -20,7 +35,7 @@ class Warns(BASE):
 
     user_id = Column(BigInteger, primary_key=True)
     chat_id = Column(String(14), primary_key=True)
-    num_warns = Column(Integer, default=0)
+    num_warns = Column(BigInteger, default=0)
     reasons = Column(postgresql.ARRAY(UnicodeText))
 
     def __init__(self, user_id, chat_id):
@@ -30,7 +45,7 @@ class Warns(BASE):
         self.reasons = []
 
     def __repr__(self):
-        return "<{} warns for {} in {} for reasons {}>".format(
+        return "<{} ᴡᴀʀɴs ғᴏʀ {} ɪɴ {} ғᴏʀ ʀᴇᴀsᴏɴs {}>".format(
             self.num_warns,
             self.user_id,
             self.chat_id,
@@ -50,7 +65,7 @@ class WarnFilters(BASE):
         self.reply = reply
 
     def __repr__(self):
-        return "<Permissions for %s>" % self.chat_id
+        return "<ᴘᴇʀᴍɪssɪᴏɴs ғᴏʀ %s>" % self.chat_id
 
     def __eq__(self, other):
         return bool(
@@ -63,7 +78,7 @@ class WarnFilters(BASE):
 class WarnSettings(BASE):
     __tablename__ = "warn_settings"
     chat_id = Column(String(14), primary_key=True)
-    warn_limit = Column(Integer, default=3)
+    warn_limit = Column(BigInteger, default=3)
     soft_warn = Column(Boolean, default=False)
 
     def __init__(self, chat_id, warn_limit=3, soft_warn=False):
@@ -72,7 +87,7 @@ class WarnSettings(BASE):
         self.soft_warn = soft_warn
 
     def __repr__(self):
-        return "<{} has {} possible warns.>".format(self.chat_id, self.warn_limit)
+        return "<{} ʜᴀs {} ᴘᴏssɪʙʟᴇ ᴡᴀʀɴs.>".format(self.chat_id, self.warn_limit)
 
 
 Warns.__table__.create(checkfirst=True)
@@ -224,8 +239,7 @@ def get_warn_setting(chat_id):
         setting = SESSION.query(WarnSettings).get(str(chat_id))
         if setting:
             return setting.warn_limit, setting.soft_warn
-        else:
-            return 3, False
+        return 3, False
 
     finally:
         SESSION.close()

Database/sql/welcome_sql.py

@@ -1,3 +1,27 @@
+"""
+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
@@ -7,20 +31,19 @@ from sqlalchemy import BigInteger, Boolean, Column, Integer, String, UnicodeText
 from Database.sql import BASE, SESSION
 from Mikobot.plugins.helper_funcs.msg_types import Types
 
-DEFAULT_WELCOME = "Hey {first}, how are you?"
-DEFAULT_GOODBYE = "Nice knowing you!"
+DEFAULT_WELCOME = "ʜᴇʏ {first}, ʜᴏᴡ ᴀʀᴇ ʏᴏᴜ?"
+DEFAULT_GOODBYE = "ɴɪᴄᴇ ᴋɴᴏᴡɪɴɢ ʏᴀ!"
 
 DEFAULT_WELCOME_MESSAGES = [
-    "{first} is here!",  # Discord welcome messages copied
-    "Ready player {first}",
-    "Welcome bro {first}",
+    "{first} ɪs ʜᴇʀᴇ!",  # Discord welcome messages copied
+    "ʀᴇᴀᴅʏ ᴘʟᴀʏᴇʀ {first}",
+    "ᴡᴇʟᴄᴏᴍᴇ ʙʀᴏ {first}",
 ]
 
 DEFAULT_GOODBYE_MESSAGES = [
-    "{first} will be missed.",
-    "{first} when back ?",
+    "{first} ᴡɪʟʟ ʙᴇ ᴍɪssᴇᴅ.",
+    "{first} ᴡʜᴇɴ ʙᴀᴄᴋ ?.",
 ]
-# Line 111 to 152 are references from https://bindingofisaac.fandom.com/wiki/Fortune_Telling_Machine
 
 
 class Welcome(BASE):
@@ -31,8 +54,7 @@ class Welcome(BASE):
     custom_content = Column(UnicodeText, default=None)
 
     custom_welcome = Column(
-        UnicodeText,
-        default=random.choice(DEFAULT_WELCOME_MESSAGES),
+        UnicodeText, default=random.choice(DEFAULT_WELCOME_MESSAGES)
     )
     welcome_type = Column(Integer, default=Types.TEXT.value)
 
@@ -47,9 +69,8 @@ class Welcome(BASE):
         self.should_goodbye = should_goodbye
 
     def __repr__(self):
-        return "<Chat {} should Welcome new users: {}>".format(
-            self.chat_id,
-            self.should_welcome,
+        return "<ᴄʜᴀᴛ {} sʜᴏᴜʟᴅ sʜᴏᴜʟᴅ ɴᴇᴡ ᴜsᴇʀs: {}>".format(
+            self.chat_id, self.should_welcome
         )
 
 
@@ -114,7 +135,23 @@ class CleanServiceSetting(BASE):
         self.chat_id = str(chat_id)
 
     def __repr__(self):
-        return "<Chat used clean service ({})>".format(self.chat_id)
+        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)
@@ -123,12 +160,14 @@ 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):
@@ -260,11 +299,7 @@ def set_gdbye_preference(chat_id, should_goodbye):
 
 
 def set_custom_welcome(
-    chat_id,
-    custom_content,
-    custom_welcome,
-    welcome_type,
-    buttons=None,
+    chat_id, custom_content, custom_welcome, welcome_type, buttons=None
 ):
     if buttons is None:
         buttons = []
@@ -426,3 +461,47 @@ def migrate_chat(old_chat_id, new_chat_id):
                 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

@@ -9,4 +9,4 @@ RUN pip3 install --upgrade pip setuptools
 
 RUN pip install -U -r requirements.txt
 
-CMD python3 -m Mikobot
+CMD python3 -m Mikobot

Infamous/karma.py

@@ -44,11 +44,10 @@ START_BTN = [
         ),
     ],
     [
-        InlineKeyboardButton(text="HELP", callback_data="help_back"),
+        InlineKeyboardButton(text="HELP", callback_data="extra_command_handler"),
     ],
     [
         InlineKeyboardButton(text="DETAILS", callback_data="Miko_"),
-        InlineKeyboardButton(text="AI", callback_data="ai_handler"),
         InlineKeyboardButton(text="SOURCE", callback_data="git_source"),
     ],
     [
@@ -83,7 +82,7 @@ ALIVE_BTN = [
 ]
 
 HELP_STRINGS = """
-🫧 *Yae-Miko* 🫧
+🫧 *Yae-Miko* 🫧 [ㅤ](https://telegra.ph/file/b05535884267a19ee5c93.jpg)
 
 ☉ *Here, you will find a list of all the available commands.*
 

Mikobot/__init__.py

@@ -17,7 +17,7 @@ from telegram import Bot, InlineKeyboardButton, InlineKeyboardMarkup, Update
 from telegram.constants import ParseMode
 from telegram.ext import Application, ApplicationBuilder
 from telethon import TelegramClient, events
-from telethon.sessions import MemorySession
+from telethon.sessions import MemorySession, StringSession
 
 # <=======================================================================================================>
 
@@ -120,12 +120,12 @@ else:
     ALLOW_EXCL = Config.ALLOW_EXCL
     DB_NAME = Config.DB_NAME
     DB_URI = Config.DATABASE_URL
+    BAN_STICKER = Config.BAN_STICKER
     MESSAGE_DUMP = Config.MESSAGE_DUMP
     SUPPORT_ID = Config.SUPPORT_ID
     DEL_CMDS = Config.DEL_CMDS
     EVENT_LOGS = Config.EVENT_LOGS
     INFOPIC = Config.INFOPIC
-    BAN_STICKER = Config.BAN_STICKER
     LOAD = Config.LOAD
     MONGO_DB_URI = Config.MONGO_DB_URI
     NO_LOAD = Config.NO_LOAD
@@ -230,7 +230,7 @@ loop.run_until_complete(
 # <=============================================== CLIENT SETUP ========================================================>
 # Create the Mikobot and TelegramClient instances
 app = Client("Mikobot", api_id=API_ID, api_hash=API_HASH, bot_token=TOKEN)
-tbot = TelegramClient(MemorySession(), API_ID, API_HASH)
+tbot = TelegramClient("Yaebot", API_ID, API_HASH)
 # <=======================================================================================================>
 
 # <=============================================== GETTING BOT INFO ========================================================>

Mikobot/__main__.py

@@ -36,7 +36,6 @@ from telegram.ext import (
 )
 from telegram.helpers import escape_markdown
 
-import Database.sql.users_sql as sql
 from Infamous.karma import *
 from Mikobot import (
     BOT_NAME,
@@ -64,65 +63,6 @@ TELETHON_VERSION = telethon.__version__
 
 
 # <============================================== FUNCTIONS =========================================================>
-async def ai_handler_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    if query.data == "ai_handler":
-        await query.answer()
-        await query.message.edit_text(
-            "🧠 *Artificial Intelligence Functions*:\n\n"
-            "All Commands:\n"
-            "➽ /askgpt <write query>: A chatbot using GPT for responding to user queries.\n\n"
-            "➽ /palm <write prompt>: Performs a Palm search using a chatbot.\n\n"
-            "➽ /upscale <reply to image>: Upscales your image quality.",
-            parse_mode=ParseMode.MARKDOWN,
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton(
-                            "𝙈𝙊𝙍𝙀 𝙄𝙈𝘼𝙂𝙀 𝙂𝙀𝙉 ➪", callback_data="more_ai_handler"
-                        ),
-                    ],
-                    [
-                        InlineKeyboardButton("» 𝙃𝙊𝙈𝙀 «", callback_data="Miko_back"),
-                    ],
-                ],
-            ),
-        )
-
-
-async def more_ai_handler_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    if query.data == "more_ai_handler":
-        await query.answer()
-        await query.message.edit_text(
-            "*Here's more image gen-related commands*:\n\n"
-            "Command: /meinamix\n"
-            "  • Description: Generates an image using the meinamix model.\n\n"
-            "Command: /darksushi\n"
-            "  • Description: Generates an image using the darksushi model.\n\n"
-            "Command: /meinahentai\n"
-            "  • Description: Generates an image using the meinahentai model.\n\n"
-            "Command: /darksushimix\n"
-            "  • Description: Generates an image using the darksushimix model.\n\n"
-            "Command: /anylora\n"
-            "  • Description: Generates an image using the anylora model.\n\n"
-            "Command: /cetsumix\n"
-            "  • Description: Generates an image using the cetus-mix model.\n\n"
-            "Command: /darkv2\n"
-            "  • Description: Generates an image using the darkv2 model.\n\n"
-            "Command: /creative\n"
-            "  • Description: Generates an image using the creative model.",
-            parse_mode=ParseMode.MARKDOWN,
-            reply_markup=InlineKeyboardMarkup(
-                [
-                    [
-                        InlineKeyboardButton("⇦ 𝘽𝘼𝘾𝙆", callback_data="ai_handler"),
-                    ],
-                ],
-            ),
-        )
-
-
 def get_readable_time(seconds: int) -> str:
     count = 0
     ping_time = ""
@@ -269,6 +209,270 @@ async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
         )
 
 
+async def extra_command_handlered(update: Update, context: ContextTypes.DEFAULT_TYPE):
+
+    keyboard = [
+        [
+            InlineKeyboardButton("MANAGEMENT", callback_data="help_back"),
+            InlineKeyboardButton("AI", callback_data="ai_command_handler"),
+        ],
+        [
+            InlineKeyboardButton("ANIME", callback_data="anime_command_handler"),
+            InlineKeyboardButton("GENSHIN", callback_data="genshin_command_handler"),
+        ],
+        [
+            InlineKeyboardButton("HOME", callback_data="Miko_back"),
+        ],
+    ]
+
+    reply_markup = InlineKeyboardMarkup(keyboard)
+
+    await update.message.reply_text(
+        "𝙎𝙚𝙡𝙚𝙘𝙩 𝙩𝙝𝙚 [𝙨𝙚𝙘𝙩𝙞𝙤𝙣](https://telegra.ph/file/8c092f4e9d303f9497c83.jpg) 𝙩𝙝𝙖𝙩 𝙮𝙤𝙪 𝙬𝙖𝙣𝙩 𝙩𝙤 𝙤𝙥𝙚𝙣",
+        reply_markup=reply_markup,
+        parse_mode="Markdown",
+    )
+
+
+async def extra_command_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    if query.data == "extra_command_handler":
+        await query.answer()  # Use 'await' for asynchronous calls
+        await query.message.edit_text(
+            "𝙎𝙚𝙡𝙚𝙘𝙩 𝙩𝙝𝙚 [𝙨𝙚𝙘𝙩𝙞𝙤𝙣](https://telegra.ph/file/8c092f4e9d303f9497c83.jpg) 𝙩𝙝𝙖𝙩 𝙮𝙤𝙪 𝙬𝙖𝙣𝙩 𝙩𝙤 𝙤𝙥𝙚𝙣",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton("MANAGEMENT", callback_data="help_back"),
+                        InlineKeyboardButton("AI", callback_data="ai_command_handler"),
+                    ],
+                    [
+                        InlineKeyboardButton(
+                            "ANIME", callback_data="anime_command_handler"
+                        ),
+                        InlineKeyboardButton(
+                            "GENSHIN", callback_data="genshin_command_handler"
+                        ),
+                    ],
+                    [
+                        InlineKeyboardButton("HOME", callback_data="Miko_back"),
+                    ],
+                ]
+            ),
+            parse_mode="Markdown",  # Added this line to explicitly specify Markdown parsing
+        )
+
+
+async def ai_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    keyboard = [
+        [
+            InlineKeyboardButton("AI", callback_data="ai_handler"),
+            InlineKeyboardButton("IMAGEGEN", callback_data="more_aihandlered"),
+        ],
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+
+    await update.message.reply_text(
+        "🧠 *Here are the options for* [𝗬𝗔𝗘 𝗠𝗜𝗞𝗢](https://telegra.ph/file/ed2d9c3693cacc9b0464e.jpg):",
+        reply_markup=reply_markup,
+        parse_mode="Markdown",
+    )
+
+
+async def ai_command_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    if query.data == "ai_command_handler":
+        await query.answer()
+        await query.message.edit_text(
+            "🧠 *Here are the options for* [𝗬𝗔𝗘 𝗠𝗜𝗞𝗢](https://telegra.ph/file/ed2d9c3693cacc9b0464e.jpg):",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton("AI", callback_data="ai_handler"),
+                        InlineKeyboardButton(
+                            "IMAGEGEN", callback_data="more_aihandlered"
+                        ),
+                    ],
+                    [
+                        InlineKeyboardButton(
+                            "» 𝘽𝘼𝘾𝙆 «", callback_data="extra_command_handler"
+                        ),
+                    ],
+                ]
+            ),
+            parse_mode="Markdown",
+        )
+
+
+async def ai_handler_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    if query.data == "ai_handler":
+        await query.answer()
+        await query.message.edit_text(
+            "[𝗔𝗿𝘁𝗶𝗳𝗶𝗰𝗶𝗮𝗹 𝗜𝗻𝘁𝗲𝗹𝗹𝗶𝗴𝗲𝗻𝘁 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀](https://telegra.ph/file/01a2e0cd1b9d03808c546.jpg):\n\n"
+            "All Commands:\n"
+            "➽ /askgpt <write query>: A chatbot using GPT for responding to user queries.\n\n"
+            "➽ /palm <write prompt>: Performs a Palm search using a chatbot.\n\n"
+            "➽ /upscale <reply to image>: Upscales your image quality.",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            "More Image Gen ➪", callback_data="more_ai_handler"
+                        ),
+                    ],
+                    [
+                        InlineKeyboardButton(
+                            "⇦ BACK", callback_data="ai_command_handler"
+                        ),
+                    ],
+                ],
+            ),
+            parse_mode="Markdown",
+        )
+
+
+async def more_ai_handler_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    if query.data == "more_ai_handler":
+        await query.answer()
+        await query.message.edit_text(
+            "*Here's more image gen related commands*:\n\n"
+            "Command: /meinamix\n"
+            "  • Description: Generates an image using the meinamix model.\n\n"
+            "Command: /darksushi\n"
+            "  • Description: Generates an image using the darksushi model.\n\n"
+            "Command: /meinahentai\n"
+            "  • Description: Generates an image using the meinahentai model.\n\n"
+            "Command: /darksushimix\n"
+            "  • Description: Generates an image using the darksushimix model.\n\n"
+            "Command: /anylora\n"
+            "  • Description: Generates an image using the anylora model.\n\n"
+            "Command: /cetsumix\n"
+            "  • Description: Generates an image using the cetsumix model.\n\n"
+            "Command: /anything\n"
+            "  • Description: Generates an image using the anything model.\n\n"
+            "Command: /absolute\n"
+            "  • Description: Generates an image using the absolute model.\n\n"
+            "Command: /darkv2\n"
+            "  • Description: Generates an image using the darkv2 model.\n\n"
+            "Command: /creative\n"
+            "  • Description: Generates an image using the creative model.",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton("⇦ BACK", callback_data="ai_handler"),
+                    ],
+                ],
+            ),
+        )
+
+
+async def more_aihandlered_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    if query.data == "more_aihandlered":
+        await query.answer()
+        await query.message.edit_text(
+            "*Here's more image gen related commands*:\n\n"
+            "*Command*: /meinamix\n"
+            "  • Description: Generates an image using the meinamix model.\n\n"
+            "*Command*: /darksushi\n"
+            "  • Description: Generates an image using the darksushi model.\n\n"
+            "*Command*: /meinahentai\n"
+            "  • Description: Generates an image using the meinahentai model.\n\n"
+            "*Command*: /darksushimix\n"
+            "  • Description: Generates an image using the darksushimix model.\n\n"
+            "*Command*: /anylora\n"
+            "  • Description: Generates an image using the anylora model.\n\n"
+            "*Command*: /cetsumix\n"
+            "  • Description: Generates an image using the cetsumix model.\n\n"
+            "*Command*: /anything\n"
+            "  • Description: Generates an image using the anything model.\n\n"
+            "*Command*: /absolute\n"
+            "  • Description: Generates an image using the absolute model.\n\n"
+            "*Command*: /darkv2\n"
+            "  • Description: Generates an image using the darkv2 model.\n\n"
+            "*Command*: /creative\n"
+            "  • Description: Generates an image using the creative model.",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            "⇦ BACK", callback_data="ai_command_handler"
+                        ),
+                    ],
+                ],
+            ),
+        )
+
+
+async def anime_command_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    if query.data == "anime_command_handler":
+        await query.answer()
+        await query.message.edit_text(
+            "⛩[𝗔𝗻𝗶𝗺𝗲 𝗨𝗽𝗱𝗮𝘁𝗲𝘀](https://telegra.ph//file/59d93fede8bf12fec1a51.jpg) :\n\n"
+            "**╔ /anime: **fetches info on single anime (includes buttons to look up for prequels and sequels)\n"
+            "**╠ /character: **fetches info on multiple possible characters related to query\n"
+            "**╠ /manga: **fetches info on multiple possible mangas related to query\n"
+            "**╠ /airing: **fetches info on airing data for anime\n"
+            "**╠ /studio: **fetches info on multiple possible studios related to query\n"
+            "**╠ /schedule: **fetches scheduled animes\n"
+            "**╠ /browse: **get popular, trending or upcoming animes\n"
+            "**╠ /top: **to retrieve top animes for a genre or tag\n"
+            "**╠ /watch: **fetches watch order for anime series\n"
+            "**╠ /fillers: **to get a list of anime fillers\n"
+            "**╠ /gettags: **get a list of available tags\n"
+            "**╠ /animequotes: **get random anime quotes\n"
+            "**╚ /getgenres: **Get list of available Genres\n\n"
+            "**⚙️ Group Settings:**\n"
+            "**╔**\n"
+            "**╠ /anisettings: **to toggle NSFW lock and airing notifications and other settings in groups (anime news)\n"
+            "**╚**",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton("More Info", url="https://anilist.co/"),
+                        InlineKeyboardButton(
+                            "㊋Infamous•Hydra", url="https://t.me/Infamous_Hydra"
+                        ),
+                    ],
+                    [
+                        InlineKeyboardButton(
+                            "» 𝘽𝘼𝘾𝙆 «", callback_data="extra_command_handler"
+                        ),
+                    ],
+                ]
+            ),
+            parse_mode="Markdown",  # Added this line to explicitly specify Markdown parsing
+        )
+
+
+async def genshin_command_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    if query.data == "genshin_command_handler":
+        await query.answer()
+        await query.message.edit_text(
+            "⛩ [𝗚𝗲𝗻𝘀𝗵𝗶𝗻 𝗜𝗺𝗽𝗮𝗰𝘁](https://telegra.ph/file/cd03348a4a357624e70db.jpg) ⛩\n\n"
+            "*UNDER DEVELOPMENT*",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            "More Info", url="https://genshin.mihoyo.com/"
+                        ),
+                    ],
+                    [
+                        InlineKeyboardButton(
+                            "» 𝘽𝘼𝘾𝙆 «", callback_data="extra_command_handler"
+                        ),
+                    ],
+                ]
+            ),
+            parse_mode="Markdown",  # Added this line to explicitly specify Markdown parsing
+        )
+
+
 async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
     """Log the error and send a telegram message to notify the developer."""
     # Log the error before we do anything else, so we can see it even if something breaks.
@@ -455,8 +659,6 @@ async def Miko_about_callback(update: Update, context: ContextTypes.DEFAULT_TYPE
             f"➲ <b>Ai integration.</b>"
             f"\n➲ <b>Advance management capability.</b>"
             f"\n➲ <b>Anime bot functionality.</b>"
-            f"\n\n<b>USERS</b> » {sql.num_users()}"
-            f"\n<b>CHATS</b> » {sql.num_chats()}"
             f"\n\n<b>Click on the buttons below for getting help and info about</b> {BOT_NAME}."
         )
         await query.message.edit_text(
@@ -540,7 +742,7 @@ async def get_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
             )
             return
         await update.effective_message.reply_text(
-            "» Choose an option for getting help.",
+            "» *Choose an option for getting* [𝗵𝗲𝗹𝗽](https://telegra.ph/file/cce9038f6a9b88eb409b5.jpg)",
             reply_markup=InlineKeyboardMarkup(
                 [
                     [
@@ -554,11 +756,12 @@ async def get_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
                     [
                         InlineKeyboardButton(
                             text="OPEN HERE",
-                            callback_data="help_back",
+                            callback_data="extra_command_handler",
                         )
                     ],
                 ]
             ),
+            parse_mode="Markdown",  # Added this line to explicitly specify Markdown parsing
         )
         return
 
@@ -763,7 +966,7 @@ async def migrate_chats(update: Update, context: ContextTypes.DEFAULT_TYPE):
 def main():
     function(CommandHandler("start", start))
 
-    function(CommandHandler("help", get_help))
+    function(CommandHandler("help", extra_command_handlered))
     function(CallbackQueryHandler(help_button, pattern=r"help_.*"))
 
     function(CommandHandler("settings", get_settings))
@@ -773,9 +976,26 @@ def main():
     function(CallbackQueryHandler(Miko_about_callback, pattern=r"Miko_"))
     function(CallbackQueryHandler(gitsource_callback, pattern=r"git_source"))
     function(CallbackQueryHandler(stats_back, pattern=r"insider_"))
+    function(MessageHandler(filters.StatusUpdate.MIGRATE, migrate_chats))
     function(CallbackQueryHandler(ai_handler_callback, pattern=r"ai_handler"))
     function(CallbackQueryHandler(more_ai_handler_callback, pattern=r"more_ai_handler"))
-    function(MessageHandler(filters.StatusUpdate.MIGRATE, migrate_chats))
+    function(CallbackQueryHandler(ai_command_callback, pattern="ai_command_handler"))
+    function(
+        CallbackQueryHandler(anime_command_callback, pattern="anime_command_handler")
+    )
+    function(
+        CallbackQueryHandler(more_aihandlered_callback, pattern="more_aihandlered")
+    )
+    function(
+        CallbackQueryHandler(extra_command_callback, pattern="extra_command_handler")
+    )
+
+    function(CommandHandler("ai", ai_command))
+    function(
+        CallbackQueryHandler(
+            genshin_command_callback, pattern="genshin_command_handler"
+        )
+    )
 
     dispatcher.add_error_handler(error_callback)
 

Mikobot/elevated_users.json

@@ -0,0 +1,8 @@
+{
+    "devs": [5907205317, 5978107653, 2093473332],
+    "supports": [],
+    "whitelists": [],
+    "sudos": [6864672519],
+    "tigers": [],
+    "spammers": []
+}

Mikobot/plugins/afk.py

@@ -184,6 +184,12 @@ __help__ = """
 
 » brb , !afk <reason>*:* same as the afk command - but not a command.
 
+» /bye [Reason > Optional] - Tell others that you are AFK (Away From Keyboard).
+
+» /bye [reply to media] - AFK with media.
+
+» /byedel - Enable auto delete AFK message in group (Only for group admin). Default is **Enable**.
+
 ➠ *When marked as AFK, any mentions will be replied to with a message to say you're not available!*
 """
 

Mikobot/plugins/ai.py

@@ -16,7 +16,7 @@ from Mikobot.state import state
 # <=======================================================================================================>
 
 # <================================================ CONSTANTS =====================================================>
-API_URL = "https://lexica.qewertyy.me/models"
+API_URL = "https://lexica.qewertyy.dev/models"
 PALM_MODEL_ID = 0
 GPT_MODEL_ID = 5
 
@@ -103,7 +103,7 @@ async def upscale_image(update: Update, context: ContextTypes.DEFAULT_TYPE):
             b = base64.b64encode(f).decode("utf-8")
 
             response = await state.post(
-                "https://lexica.qewertyy.me/upscale",
+                "https://lexica.qewertyy.dev/upscale",
                 data={"image_data": b},
             )
 

Mikobot/plugins/alive.py

@@ -34,12 +34,12 @@ async def alive(_, message: Message):
     caption = f"""**HEY, I AM {BOT_NAME}**
 
 ━━━━━━ 🌟✿🌟 ━━━━━━
-✪ **CREATOR:** [🄺🄰🅁🄼🄰](https://t.me/anime_Freakz)
+✪ **CREATOR:** [🄺🄰🅁🄼🄰](https://t.me/O_oKarma)
 
 {library_versions_text}
 
 ➲ **PYTHON:** `{version_info[0]}.{version_info[1]}.{version_info[2]}`
-➲ **BOT VERSION:** `2.0`
+➲ **BOT VERSION:** `2.1 Rx`
 ━━━━━━ 🌟✿🌟 ━━━━━━"""
 
     await message.reply_animation(

Mikobot/plugins/anime.py

@@ -2253,11 +2253,11 @@ async def get_top_animes(gnr: str, page, user):
 async def get_user_favourites(id_, user, req, page, sighs, duser=None):
     vars_ = {"id": int(id_), "page": int(page)}
     result = await return_json_senpai(
-        FAV_ANI_QUERY
-        if req == "ANIME"
-        else FAV_CHAR_QUERY
-        if req == "CHAR"
-        else FAV_MANGA_QUERY,
+        (
+            FAV_ANI_QUERY
+            if req == "ANIME"
+            else FAV_CHAR_QUERY if req == "CHAR" else FAV_MANGA_QUERY
+        ),
         vars_,
         auth=True,
         user=int(user),
@@ -2268,9 +2268,7 @@ async def get_user_favourites(id_, user, req, page, sighs, duser=None):
     msg = (
         "Favourite Animes:\n\n"
         if req == "ANIME"
-        else "Favourite Characters:\n\n"
-        if req == "CHAR"
-        else "Favourite Manga:\n\n"
+        else "Favourite Characters:\n\n" if req == "CHAR" else "Favourite Manga:\n\n"
     )
     for i in data["edges"]:
         node_name = (
@@ -2373,9 +2371,7 @@ async def get_additional_info(
             (
                 DES_INFO_QUERY
                 if req == "desc"
-                else CHA_INFO_QUERY
-                if req == "char"
-                else REL_INFO_QUERY
+                else CHA_INFO_QUERY if req == "char" else REL_INFO_QUERY
             )
             if ctgry == "ANI"
             else DESC_INFO_QUERY
@@ -2817,11 +2813,11 @@ async def toggle_favourites(id_: int, media: str, user: int):
     query = (
         ANIME_MUTATION
         if media == "ANIME" or media == "AIRING"
-        else CHAR_MUTATION
-        if media == "CHARACTER"
-        else MANGA_MUTATION
-        if media == "MANGA"
-        else STUDIO_MUTATION
+        else (
+            CHAR_MUTATION
+            if media == "CHARACTER"
+            else MANGA_MUTATION if media == "MANGA" else STUDIO_MUTATION
+        )
     )
     k = await return_json_senpai(query=query, vars_=vars_, auth=True, user=int(user))
     try:
@@ -2890,9 +2886,7 @@ async def update_anilist(id_, req, user, eid: int = None, status: str = None):
         query=(
             ANILIST_MUTATION
             if req == "lsas"
-            else ANILIST_MUTATION_UP
-            if req == "lsus"
-            else ANILIST_MUTATION_DEL
+            else ANILIST_MUTATION_UP if req == "lsus" else ANILIST_MUTATION_DEL
         ),
         vars_=vars_,
         auth=True,
@@ -2902,9 +2896,11 @@ async def update_anilist(id_, req, user, eid: int = None, status: str = None):
         (
             k["data"]["SaveMediaListEntry"]
             if req == "lsas"
-            else k["data"]["UpdateMediaListEntries"]
-            if req == "lsus"
-            else k["data"]["DeleteMediaListEntry"]
+            else (
+                k["data"]["UpdateMediaListEntries"]
+                if req == "lsus"
+                else k["data"]["DeleteMediaListEntry"]
+            )
         )
         return "ok"
     except KeyError:
@@ -4007,32 +4003,52 @@ async def toggle_favourites_btn(client: Client, cq: CallbackQuery, cdata: dict):
         )
         if query[1] == "ANIME" and len(query) == 3
         else (
-            await get_anilist(
-                query[3],
-                page=int(query[4]),
-                auth=True,
-                user=auser,
-                cid=gid if gid != user else None,
-            )
-        )
-        if query[1] == "ANIME" and len(query) != 3
-        else (
-            await get_manga(
-                query[3],
-                page=int(query[4]),
-                auth=True,
-                user=auser,
-                cid=gid if gid != user else None,
+            (
+                await get_anilist(
+                    query[3],
+                    page=int(query[4]),
+                    auth=True,
+                    user=auser,
+                    cid=gid if gid != user else None,
+                )
             )
-        )
-        if query[1] == "MANGA"
-        else (await get_airing(query[3], auth=True, user=auser, ind=int(query[4])))
-        if query[1] == "AIRING"
-        else (await get_character(query[3], int(query[4]), auth=True, user=auser))
-        if query[1] == "CHARACTER"
-        else (
-            await get_studios(
-                query[3], int(query[4]), user=auser, auth=True, duser=user
+            if query[1] == "ANIME" and len(query) != 3
+            else (
+                (
+                    await get_manga(
+                        query[3],
+                        page=int(query[4]),
+                        auth=True,
+                        user=auser,
+                        cid=gid if gid != user else None,
+                    )
+                )
+                if query[1] == "MANGA"
+                else (
+                    (
+                        await get_airing(
+                            query[3], auth=True, user=auser, ind=int(query[4])
+                        )
+                    )
+                    if query[1] == "AIRING"
+                    else (
+                        (
+                            await get_character(
+                                query[3], int(query[4]), auth=True, user=auser
+                            )
+                        )
+                        if query[1] == "CHARACTER"
+                        else (
+                            await get_studios(
+                                query[3],
+                                int(query[4]),
+                                user=auser,
+                                auth=True,
+                                duser=user,
+                            )
+                        )
+                    )
+                )
             )
         )
     )
@@ -4041,9 +4057,7 @@ async def toggle_favourites_btn(client: Client, cq: CallbackQuery, cdata: dict):
     pic, msg = (
         (result[0], result[1])
         if query[1] == "ANIME" and len(query) == 3
-        else (result[0])
-        if query[1] == "AIRING"
-        else (result[0], result[1][0])
+        else (result[0]) if query[1] == "AIRING" else (result[0], result[1][0])
     )
     btns = get_btns(
         query[1],
@@ -4075,9 +4089,11 @@ async def list_update_anilist_btn(client: Client, cq: CallbackQuery, cdata: dict
         row.append(
             InlineKeyboardButton(
                 text=i,
-                callback_data=cq.data.replace("lsadd", f"lsas_{i}")
-                if query[0] == "lsadd"
-                else cq.data.replace("lsupdt", f"lsus_{i}"),
+                callback_data=(
+                    cq.data.replace("lsadd", f"lsas_{i}")
+                    if query[0] == "lsadd"
+                    else cq.data.replace("lsupdt", f"lsus_{i}")
+                ),
             )
         )
         if len(row) == 3:
@@ -4179,60 +4195,66 @@ async def update_anilist_btn(client: Client, cq: CallbackQuery, cdata: dict):
         )
         if query[2] == "ANIME" and (len(query) == 4 or len(query) == 5)
         else (
-            await get_anilist(
-                query[4],
-                page=int(query[5]),
-                auth=True,
-                user=auser,
-                cid=gid if gid != user else None,
-            )
-        )
-        if query[2] == "ANIME" and len(query) == 6
-        else (
-            await get_anilist(
-                query[5],
-                page=int(query[6]),
-                auth=True,
-                user=auser,
-                cid=gid if gid != user else None,
-            )
-        )
-        if query[2] == "ANIME" and len(query) == 7
-        else (
-            await get_manga(
-                query[4],
-                page=int(query[5]),
-                auth=True,
-                user=auser,
-                cid=gid if gid != user else None,
-            )
-        )
-        if query[2] == "MANGA" and len(query) == 6
-        else (
-            await get_manga(
-                query[5],
-                page=int(query[6]),
-                auth=True,
-                user=auser,
-                cid=gid if gid != user else None,
+            (
+                await get_anilist(
+                    query[4],
+                    page=int(query[5]),
+                    auth=True,
+                    user=auser,
+                    cid=gid if gid != user else None,
+                )
             )
-        )
-        if query[2] == "MANGA" and len(query) == 7
-        else (
-            await get_airing(
-                query[4] if eid is None else query[5],
-                auth=True,
-                user=auser,
-                ind=int(query[5] if eid is None else query[6]),
+            if query[2] == "ANIME" and len(query) == 6
+            else (
+                (
+                    await get_anilist(
+                        query[5],
+                        page=int(query[6]),
+                        auth=True,
+                        user=auser,
+                        cid=gid if gid != user else None,
+                    )
+                )
+                if query[2] == "ANIME" and len(query) == 7
+                else (
+                    (
+                        await get_manga(
+                            query[4],
+                            page=int(query[5]),
+                            auth=True,
+                            user=auser,
+                            cid=gid if gid != user else None,
+                        )
+                    )
+                    if query[2] == "MANGA" and len(query) == 6
+                    else (
+                        (
+                            await get_manga(
+                                query[5],
+                                page=int(query[6]),
+                                auth=True,
+                                user=auser,
+                                cid=gid if gid != user else None,
+                            )
+                        )
+                        if query[2] == "MANGA" and len(query) == 7
+                        else (
+                            await get_airing(
+                                query[4] if eid is None else query[5],
+                                auth=True,
+                                user=auser,
+                                ind=int(query[5] if eid is None else query[6]),
+                            )
+                        )
+                    )
+                )
             )
         )
     )
     pic, msg = (
         (result[0], result[1])
         if query[2] == "ANIME" and (len(query) == 4 or len(query) == 5)
-        else (result[0])
-        if query[2] == "AIRING"
-        else (result[0], result[1][0])
+        else (result[0]) if query[2] == "AIRING" else (result[0], result[1][0])
     )
     btns = get_btns(
         query[2],
@@ -4240,11 +4262,11 @@ async def update_anilist_btn(client: Client, cq: CallbackQuery, cdata: dict):
         user=user,
         auth=True,
         lsqry=query[4] if len(query) == 6 else query[5] if len(query) == 7 else None,
-        lspage=int(query[5])
-        if len(query) == 6
-        else int(query[6])
-        if len(query) == 7
-        else None,
+        lspage=(
+            int(query[5])
+            if len(query) == 6
+            else int(query[6]) if len(query) == 7 else None
+        ),
     )
     try:
         await cq.edit_message_media(
@@ -4265,9 +4287,7 @@ async def additional_info_btn(client: Client, cq: CallbackQuery, cdata: dict):
     info = (
         "<b>Description</b>"
         if kek == "desc"
-        else "<b>Series List</b>"
-        if kek == "ls"
-        else "<b>Characters List</b>"
+        else "<b>Series List</b>" if kek == "ls" else "<b>Characters List</b>"
     )
     page = 0
     lsqry = f"_{q[3]}" if len(q) > 6 else ""
@@ -4329,9 +4349,11 @@ async def additional_info_btn(client: Client, cq: CallbackQuery, cdata: dict):
     cbd = (
         f"btn_{qry}_{q[3]}_{user}"
         if len(q) <= 5
-        else f"page_ANIME{lsqry}{lspg}_{q[5]}_{user}"
-        if ctgry == "ANI"
-        else f"page_CHARACTER{lsqry}{lspg}_{q[5]}_{user}"
+        else (
+            f"page_ANIME{lsqry}{lspg}_{q[5]}_{user}"
+            if ctgry == "ANI"
+            else f"page_CHARACTER{lsqry}{lspg}_{q[5]}_{user}"
+        )
     )
     button.append([InlineKeyboardButton(text="BACK", callback_data=cbd)])
     try:
@@ -5112,7 +5134,7 @@ QUOTES_IMG = [
 __help__ = """
 ⛩ *Anime:*
 
-➠ *Mikobot provides you the best anime-based commands including anime news and much more!*
+➠ *Dazai provides you the best anime-based commands including anime news and much more!*
 
 ➠ *Commands:*
 

Mikobot/plugins/approve.py

@@ -1,4 +1,3 @@
-# <============================================== IMPORTS =========================================================>
 import html
 
 from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
@@ -14,10 +13,7 @@ from Mikobot.plugins.helper_funcs.chat_status import check_admin
 from Mikobot.plugins.helper_funcs.extraction import extract_user
 from Mikobot.plugins.log_channel import loggable
 
-# <=======================================================================================================>
 
-
-# <================================================ FUNCTION =======================================================>
 @loggable
 @check_admin(is_user=True)
 async def approve(update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -214,9 +210,6 @@ async def unapproveall_btn(update: Update, context: ContextTypes.DEFAULT_TYPE):
             await query.answer("You need to be admin to do this.")
 
 
-# <=================================================== HELP ====================================================>
-
-
 __help__ = """
 ➠ Sometimes, you might trust a user not to send unwanted content.
 Maybe not enough to make them admin, but you might be ok with locks, blacklists, and antiflood not applying to them.
@@ -236,7 +229,6 @@ Maybe not enough to make them admin, but you might be ok with locks, blacklists,
 » /unapproveall: Unapprove *ALL* users in a chat. This cannot be undone.
 """
 
-# <================================================ HANDLER =======================================================>
 APPROVE = DisableAbleCommandHandler("approve", approve, block=False)
 DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove, block=False)
 APPROVED = DisableAbleCommandHandler("approved", approved, block=False)
@@ -256,4 +248,3 @@ dispatcher.add_handler(UNAPPROVEALL_BTN)
 __mod_name__ = "APPROVALS"
 __command_list__ = ["approve", "unapprove", "approved", "approval"]
 __handlers__ = [APPROVE, DISAPPROVE, APPROVED, APPROVAL]
-# <================================================ END =======================================================>

Mikobot/plugins/ban.py

@@ -1,4 +1,3 @@
-# <============================================== IMPORTS =========================================================>
 import html
 
 from telegram import (
@@ -13,7 +12,6 @@ from telegram.ext import CallbackQueryHandler, CommandHandler, ContextTypes, fil
 from telegram.helpers import mention_html
 
 from Mikobot import DEV_USERS, DRAGONS, LOGGER, OWNER_ID, function
-from Mikobot.utils.can_restrict import BAN_STICKER
 from Mikobot.plugins.disable import DisableAbleCommandHandler
 from Mikobot.plugins.helper_funcs.chat_status import (
     can_delete,
@@ -28,10 +26,9 @@ from Mikobot.plugins.helper_funcs.misc import mention_username
 from Mikobot.plugins.helper_funcs.string_handling import extract_time
 from Mikobot.plugins.log_channel import gloggable, loggable
 
-# <=======================================================================================================>
+BAN_STICKER = "CAACAgUAAxkBAAEGWC5lloYv1tiI3-KPguoH5YX-RveWugACoQ4AAi4b2FQGdUhawbi91DQE"
 
 
-# <================================================ FUNCTION =======================================================>
 @connection_status
 @loggable
 @check_admin(permission="can_restrict_members", is_both=True)
@@ -693,9 +690,6 @@ async def bans_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
         return log
 
 
-# <================================================ HELP =======================================================>
-
-
 __help__ = """
 » /kickme: kicks the user who issued the command
 
@@ -714,7 +708,6 @@ __help__ = """
     Banning or UnBanning channels only work if you reply to their message, so don't use their username to ban/unban.
 """
 
-# <================================================ HANDLER =======================================================>
 BAN_HANDLER = CommandHandler(["ban", "sban"], ban, block=False)
 TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban, block=False)
 KICK_HANDLER = CommandHandler("kick", kick, block=False)
@@ -745,4 +738,3 @@ __handlers__ = [
     KICKME_HANDLER,
     BAN_CALLBACK_HANDLER,
 ]
-# <================================================ END =======================================================>

Mikobot/plugins/blacklist.py

@@ -1,4 +1,3 @@
-# <============================================== IMPORTS =========================================================>
 import html
 import re
 
@@ -21,12 +20,9 @@ from Mikobot.plugins.helper_funcs.string_handling import extract_time
 from Mikobot.plugins.log_channel import loggable
 from Mikobot.plugins.warns import warn
 
-# <=======================================================================================================>
-
 BLACKLIST_GROUP = 11
 
 
-# <================================================ FUNCTION =======================================================>
 @check_admin(is_user=True)
 @typing_action
 async def blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -401,9 +397,9 @@ async def del_blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
                     await bot.sendMessage(
                         chat.id,
                         f"Muted {user.first_name} for using Blacklisted word: {trigger}!",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
                 elif getmode == 4:
@@ -413,9 +409,9 @@ async def del_blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
                         await bot.sendMessage(
                             chat.id,
                             f"Kicked {user.first_name} for using Blacklisted word: {trigger}!",
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
+                            message_thread_id=(
+                                message.message_thread_id if chat.is_forum else None
+                            ),
                         )
                     return
                 elif getmode == 5:
@@ -424,9 +420,9 @@ async def del_blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
                     await bot.sendMessage(
                         chat.id,
                         f"Banned {user.first_name} for using Blacklisted word: {trigger}",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
                 elif getmode == 6:
@@ -436,9 +432,9 @@ async def del_blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
                     await bot.sendMessage(
                         chat.id,
                         f"Banned {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
                 elif getmode == 7:
@@ -453,9 +449,9 @@ async def del_blacklist(update: Update, context: ContextTypes.DEFAULT_TYPE):
                     await bot.sendMessage(
                         chat.id,
                         f"Muted {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
             except BadRequest as excp:
@@ -487,9 +483,6 @@ def __stats__():
     )
 
 
-# <=================================================== HELP ====================================================>
-
-
 __mod_name__ = "BLACKLIST"
 
 __help__ = """
@@ -517,8 +510,6 @@ Note:
 » <sticker link> can be https://t.me/addstickers/<sticker> or just <sticker> or reply to the sticker message
 
 """
-
-# <================================================ HANDLER =======================================================>
 BLACKLIST_HANDLER = DisableAbleCommandHandler(
     "blacklist", blacklist, admin_ok=True, block=False
 )
@@ -545,4 +536,3 @@ __handlers__ = [
     BLACKLISTMODE_HANDLER,
     (BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP),
 ]
-# <================================================ END =======================================================>

Mikobot/plugins/blacklist_stickers.py

@@ -1,4 +1,3 @@
-# <============================================== IMPORTS =========================================================>
 import html
 
 from telegram import ChatPermissions, Update
@@ -18,10 +17,7 @@ from Mikobot.plugins.helper_funcs.string_handling import extract_time
 from Mikobot.plugins.log_channel import loggable
 from Mikobot.plugins.warns import warn
 
-# <=======================================================================================================>
 
-
-# <================================================ FUNCTION =======================================================>
 async def blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYPE):
     msg = update.effective_message  # type: Optional[Message]
     chat = update.effective_chat  # type: Optional[Chat]
@@ -452,9 +448,9 @@ async def del_blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYP
                             trigger,
                         ),
                         parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
                 elif getmode == 4:
@@ -468,9 +464,9 @@ async def del_blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYP
                                 trigger,
                             ),
                             parse_mode="markdown",
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
+                            message_thread_id=(
+                                message.message_thread_id if chat.is_forum else None
+                            ),
                         )
                     return
                 elif getmode == 5:
@@ -483,9 +479,9 @@ async def del_blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYP
                             trigger,
                         ),
                         parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
                 elif getmode == 6:
@@ -500,9 +496,9 @@ async def del_blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYP
                             trigger,
                         ),
                         parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
                 elif getmode == 7:
@@ -522,9 +518,9 @@ async def del_blackliststicker(update: Update, context: ContextTypes.DEFAULT_TYP
                             trigger,
                         ),
                         parse_mode="markdown",
-                        message_thread_id=message.message_thread_id
-                        if chat.is_forum
-                        else None,
+                        message_thread_id=(
+                            message.message_thread_id if chat.is_forum else None
+                        ),
                     )
                     return
             except BadRequest as excp:
@@ -558,7 +554,6 @@ def __stats__():
 
 __mod_name__ = "Stickers Blacklist"
 
-# <================================================ HANDLER =======================================================>
 BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler(
     "blsticker", blackliststicker, admin_ok=True, block=False
 )
@@ -578,4 +573,3 @@ dispatcher.add_handler(ADDBLACKLIST_STICKER_HANDLER)
 dispatcher.add_handler(UNBLACKLIST_STICKER_HANDLER)
 dispatcher.add_handler(BLACKLISTMODE_HANDLER)
 dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
-# <================================================ END =======================================================>

Mikobot/plugins/botadmins.py

@@ -46,7 +46,7 @@ async def botstaff(update: Update, context: ContextTypes.DEFAULT_TYPE):
     try:
         owner = await get_chat_member(context, OWNER_ID)
         owner_info = await mention_html(owner.user.first_name, owner.user.id)
-        reply = f"✪ <b>CREATOR :</b> {owner_info} (<code>{OWNER_ID}</code>)\n"
+        reply = f"✪ <b>OWNER :</b> {owner_info} (<code>{OWNER_ID}</code>)\n"
     except TelegramError as e:
         LOGGER.error(f"Error getting owner information: {e}")
         reply = ""

Mikobot/plugins/bug.py

@@ -0,0 +1,45 @@
+from pyrogram import filters
+from pyrogram.enums import ParseMode
+
+# Chat IDs where bug reports should be sent
+BUG_REPORT_CHAT_IDS = [-1001989832800, -1001823656633]
+
+from Mikobot import app
+
+
+# Define a handler for the /bug command
+@app.on_message(filters.command("bug", prefixes="/"))
+def bug_command_handler(client, message):
+    # Check if the command is a reply
+    if message.reply_to_message:
+        # Get the message being replied to
+        replied_message = message.reply_to_message
+
+        # Extract message content
+        content = replied_message.text or replied_message.caption
+
+        # Check if there is media content
+        media_type = (
+            "**Media content included**"
+            if replied_message.photo
+            or replied_message.document
+            or replied_message.video
+            or replied_message.audio
+            or replied_message.animation
+            else "**No media content included**"
+        )
+
+        # Prepare the report message with message link and media content info
+        report_message = f"**Bug reported by @{message.from_user.username}:**\n\n{content}\n\n{media_type}\n\n**Message Link:** {replied_message.link}"
+
+        # Send the report message
+        client.send_message(
+            BUG_REPORT_CHAT_IDS[0], report_message, parse_mode=ParseMode.MARKDOWN
+        )
+    else:
+        # If not a reply, send a message to reply with /bug command to report a bug
+        client.send_message(
+            message.chat.id,
+            "To report a bug, please reply to the message with **/ bug** cmd.",
+            parse_mode=ParseMode.MARKDOWN,
+        )

Mikobot/plugins/connection.py

@@ -205,9 +205,11 @@ async def connect_chat(update: Update, context: ContextTypes.DEFAULT_TYPE):
                         ],
                     )
                 text += "╘══「 Total {} Chats 」".format(
-                    str(len(gethistory)) + " (max)"
-                    if len(gethistory) == 5
-                    else str(len(gethistory)),
+                    (
+                        str(len(gethistory)) + " (max)"
+                        if len(gethistory) == 5
+                        else str(len(gethistory))
+                    ),
                 )
                 conn_hist = InlineKeyboardMarkup(buttons)
             elif buttons:

Mikobot/plugins/couple.py

@@ -9,6 +9,14 @@ from Mikobot import app
 
 # <=======================================================================================================>
 
+# List of additional images
+ADDITIONAL_IMAGES = [
+    "https://telegra.ph/file/7ef6006ed6e452a6fd871.jpg",
+    "https://telegra.ph/file/16ede7c046f35e699ed3c.jpg",
+    "https://telegra.ph/file/f16b555b2a66853cc594e.jpg",
+    "https://telegra.ph/file/7ef6006ed6e452a6fd871.jpg",
+]
+
 
 # <================================================ FUNCTION =======================================================>
 def dt():
@@ -32,33 +40,42 @@ def dt_tom():
 tomorrow = str(dt_tom())
 today = str(dt()[0])
 
-COUPLES_PIC = "https://telegra.ph/file/c6d0c884f559b9ed8a54e.jpg"
 C = """
-✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-{} + ( PGM🎀😶 (https://t.me/Chalnayaaaaaarr) + 花火 (https://t.me/zd_sr07) + ゼロツー (https://t.me/wewewe_x) ) = 💞
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {}
+•➵💞࿐ 𝐇𝐚𝐩𝐩𝐲 𝐜𝐨𝐮𝐩𝐥𝐞 𝐨𝐟 𝐭𝐡𝐞 𝐝𝐚𝐲
+╭──────────────
+┊•➢ {} + ( PGM🎀😶 (https://t.me/Chalnayaaaaaarr) + 花火 (https://t.me/zd_sr07) + ゼロツー (https://t.me/wewewe_x) ) = 💞
+╰───•➢♡
+╭──────────────
+┊•➢ 𝗡𝗲𝘄 𝗰𝗼𝘂𝗽𝗹𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗱𝗮𝘆 𝗺𝗮𝘆𝗯𝗲
+┊ 𝗰𝗵𝗼𝘀𝗲𝗻 𝗮𝘁 12AM {}
+╰───•➢♡
 """
 CAP = """
-✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-{} + {} = 💞
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {}
+•➵💞࿐ 𝐇𝐚𝐩𝐩𝐲 𝐜𝐨𝐮𝐩𝐥𝐞 𝐨𝐟 𝐭𝐡𝐞 𝐝𝐚𝐲
+╭──────────────
+┊•➢ {} + {} = 💞
+╰───•➢♡
+╭──────────────
+┊•➢ 𝗡𝗲𝘄 𝗰𝗼𝘂𝗽𝗹𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗱𝗮𝘆 𝗺𝗮𝘆𝗯𝗲
+┊ 𝗰𝗵𝗼𝘀𝗲𝗻 𝗮𝘁 12AM {}
+╰───•➢♡
 """
 
 CAP2 = """
-✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-{} (tg://openmessage?user_id={}) + {} (tg://openmessage?user_id={}) = 💞\n
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {}
+•➵💞࿐ 𝐇𝐚𝐩𝐩𝐲 𝐜𝐨𝐮𝐩𝐥𝐞 𝐨𝐟 𝐭𝐡𝐞 𝐝𝐚𝐲
+╭──────────────
+┊{} (tg://openmessage?user_id={}) + {} (tg://openmessage?user_id={}) = 💞\n
+╰───•➢♡
+╭──────────────
+┊•➢ 𝗡𝗲𝘄 𝗰𝗼𝘂𝗽𝗹𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗱𝗮𝘆 𝗺𝗮𝘆𝗯𝗲
+┊ 𝗰𝗵𝗼𝘀𝗲𝗻 𝗮𝘁 12AM {}
+╰───•➢♡
 """
 
 
 @app.on_message(filters.command(["couple", "couples", "shipping"]) & ~filters.private)
 async def nibba_nibbi(_, message):
+    COUPLES_PIC = random.choice(ADDITIONAL_IMAGES)  # Move inside the command function
     if message.from_user.id == 5540249238:
         my_ = await _.get_users("rfxtuv")
         me = await _.get_users(5540249238)
@@ -75,7 +92,7 @@ async def nibba_nibbi(_, message):
                     if not i.user.is_bot:
                         list_of_users.append(i.user.id)
                 if len(list_of_users) < 2:
-                    return await message.reply_text("ɴᴏᴛ ᴇɴᴏᴜɢʜ ᴜsᴇʀs ɪɴ ᴛʜɪs ɢʀᴏᴜᴘ.")
+                    return await message.reply_text("Not enough users in the group.")
                 c1_id = random.choice(list_of_users)
                 c2_id = random.choice(list_of_users)
                 while c1_id == c2_id:
@@ -98,11 +115,14 @@ async def nibba_nibbi(_, message):
                 c1_name = (await _.get_users(c1_id)).first_name
                 c2_name = (await _.get_users(c2_id)).first_name
                 print(c1_id, c2_id, c1_name, c2_name)
-                couple_selection_message = f"""✧ 𝗖𝗢𝗨𝗣𝗟𝗘𝗦 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 ✧
-➖➖➖➖➖➖➖➖➖➖➖➖
-[{c1_name}](tg://openmessage?user_id={c1_id}) + [{c2_name}](tg://openmessage?user_id={c2_id}) = 💞
-➖➖➖➖➖➖➖➖➖➖➖➖
-𝗡𝗘𝗪 𝗖𝗢𝗨𝗣𝗟𝗘 𝗢𝗙 𝗧𝗛𝗘 𝗗𝗔𝗬 𝗖𝗔𝗡 𝗕𝗘 𝗖𝗛𝗢𝗦𝗘𝗡 𝗔𝗧 12AM {tomorrow}"""
+                couple_selection_message = f"""•➵💞࿐ 𝐇𝐚𝐩𝐩𝐲 𝐜𝐨𝐮𝐩𝐥𝐞 𝐨𝐟 𝐭𝐡𝐞 𝐝𝐚𝐲
+╭──────────────
+┊•➢ [{c1_name}](tg://openmessage?user_id={c1_id}) + [{c2_name}](tg://openmessage?user_id={c2_id}) = 💞
+╰───•➢♡
+╭──────────────
+┊•➢ 𝗡𝗲𝘄 𝗰𝗼𝘂𝗽𝗹𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗱𝗮𝘆 𝗺𝗮𝘆𝗯𝗲
+┊ 𝗰𝗵𝗼𝘀𝗲𝗻 𝗮𝘁 12AM {tomorrow}
+╰───•➢♡"""
                 await _.send_photo(
                     message.chat.id, photo=COUPLES_PIC, caption=couple_selection_message
                 )
@@ -112,12 +132,10 @@ async def nibba_nibbi(_, message):
 
 
 # <=================================================== HELP ====================================================>
-
-
 __help__ = """
 💘 *Choose couples in your chat*
 
-» /couple, /couples, /shipping *:* Choose 2 users and send their names as couples in your chat.
+➦ /couple, /couples, /shipping *:* Choose 2 users and send their names as couples in your chat.
 """
 
 __mod_name__ = "COUPLE"

Mikobot/plugins/cust_filters.py

@@ -14,6 +14,7 @@ from telegram.ext import (
     ContextTypes,
     MessageHandler,
 )
+from telegram.ext import filters
 from telegram.ext import filters as filters_module
 from telegram.helpers import escape_markdown, mention_html
 
@@ -379,9 +380,9 @@ async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
                                 chat.id,
                                 sticker_id,
                                 reply_to_message_id=message.message_id,
-                                message_thread_id=message.message_thread_id
-                                if chat.is_forum
-                                else None,
+                                message_thread_id=(
+                                    message.message_thread_id if chat.is_forum else None
+                                ),
                             )
                             return
                         except BadRequest as excp:
@@ -392,9 +393,11 @@ async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
                                 await context.bot.send_message(
                                     chat.id,
                                     "Message couldn't be sent, Is the sticker id valid?",
-                                    message_thread_id=message.message_thread_id
-                                    if chat.is_forum
-                                    else None,
+                                    message_thread_id=(
+                                        message.message_thread_id
+                                        if chat.is_forum
+                                        else None
+                                    ),
                                 )
                                 return
                             else:
@@ -412,26 +415,32 @@ async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
                                 or message.from_user.first_name,
                             ),
                             fullname=" ".join(
-                                [
-                                    escape(message.from_user.first_name),
-                                    escape(message.from_user.last_name),
-                                ]
-                                if message.from_user.last_name
-                                else [escape(message.from_user.first_name)],
+                                (
+                                    [
+                                        escape(message.from_user.first_name),
+                                        escape(message.from_user.last_name),
+                                    ]
+                                    if message.from_user.last_name
+                                    else [escape(message.from_user.first_name)]
+                                ),
                             ),
-                            username="@" + escape(message.from_user.username)
-                            if message.from_user.username
-                            else mention_html(
-                                message.from_user.id,
-                                message.from_user.first_name,
+                            username=(
+                                "@" + escape(message.from_user.username)
+                                if message.from_user.username
+                                else mention_html(
+                                    message.from_user.id,
+                                    message.from_user.first_name,
+                                )
                             ),
                             mention=mention_html(
                                 message.from_user.id,
                                 message.from_user.first_name,
                             ),
-                            chatname=escape(message.chat.title)
-                            if message.chat.type != "private"
-                            else escape(message.from_user.first_name),
+                            chatname=(
+                                escape(message.chat.title)
+                                if message.chat.type != "private"
+                                else escape(message.from_user.first_name)
+                            ),
                             id=message.from_user.id,
                         )
                     else:
@@ -469,9 +478,9 @@ async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
                                 filt.file_id,
                                 reply_markup=keyboard,
                                 reply_to_message_id=message.message_id,
-                                message_thread_id=message.message_thread_id
-                                if chat.is_forum
-                                else None,
+                                message_thread_id=(
+                                    message.message_thread_id if chat.is_forum else None
+                                ),
                             )
                         else:
                             await ENUM_FUNC_MAP[filt.file_type](
@@ -480,10 +489,10 @@ async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
                                 reply_markup=keyboard,
                                 caption=filt.reply_text,
                                 reply_to_message_id=message.message_id,
-                                message_thread_id=message.message_thread_id
-                                if chat.is_forum
-                                else None,
-                                has_spoiler=filt.has_media_spoiler,
+                                message_thread_id=(
+                                    message.message_thread_id if chat.is_forum else None
+                                ),
+                                has_spoiler=filters.HAS_MEDIA_SPOILER,
                             )
                     except BadRequest:
                         await send_message(
@@ -520,9 +529,9 @@ async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
                             parse_mode=ParseMode.HTML,
                             disable_web_page_preview=True,
                             reply_markup=keyboard,
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
+                            message_thread_id=(
+                                message.message_thread_id if chat.is_forum else None
+                            ),
                         )
                     except BadRequest as excp:
                         if excp.message == "Unsupported url protocol":
@@ -559,9 +568,9 @@ async def reply_filter(update: Update, context: ContextTypes.DEFAULT_TYPE):
                         await context.bot.send_message(
                             chat.id,
                             filt.reply,
-                            message_thread_id=message.message_thread_id
-                            if chat.is_forum
-                            else None,
+                            message_thread_id=(
+                                message.message_thread_id if chat.is_forum else None
+                            ),
                         )
                     except BadRequest as excp:
                         LOGGER.exception("Error in filters: " + excp.message)

Mikobot/plugins/disasters.py

@@ -0,0 +1,129 @@
+import html
+import json
+import os
+from typing import Optional
+
+from telegram import Update
+from telegram.ext import CommandHandler
+
+from Mikobot import dispatcher
+from Mikobot.plugins.helper_funcs.chat_status import dev_plus, sudo_plus
+from Mikobot.plugins.helper_funcs.extraction import extract_user
+from Mikobot.plugins.log_channel import gloggable
+
+ELEVATED_USERS_FILE = os.path.join(os.getcwd(), "Mikobot/elevated_users.json")
+
+DISASTER_LEVELS = {
+    "Dragon": "DRAGONS",
+    "Demon": "DEMONS",
+    "Wolf": "WOLVES",
+    "Tiger": "TIGERS",
+}
+
+
+async def check_user_id(user_id: int) -> Optional[str]:
+    if not user_id:
+        return "That...is a chat! baka ka omae?"
+    return None
+
+
+async def update_elevated_users(data):
+    with open(ELEVATED_USERS_FILE, "w") as outfile:
+        json.dump(data, outfile, indent=4)
+
+
+async def add_disaster_level(update: Update, level: str, context) -> str:
+    message = update.effective_message
+    user = update.effective_user
+    chat = update.effective_chat
+    bot, args = context.bot, context.args
+    user_id = await extract_user(message, context, args)
+    user_member = await bot.get_chat(user_id)
+    rt = ""
+
+    reply = await check_user_id(user_id)
+    if reply:
+        await message.reply_text(reply)
+        return ""
+
+    with open(ELEVATED_USERS_FILE, "r") as infile:
+        data = json.load(infile)
+
+    disaster_list = getattr(DISASTER_LEVELS, level)
+    if user_id in disaster_list:
+        await message.reply_text(f"This user is already a {level} Disaster.")
+        return ""
+
+    for disaster_level, disaster_users in DISASTER_LEVELS.items():
+        if user_id in disaster_users:
+            rt += f"Requested HA to promote this {disaster_level} to {level}."
+            data[disaster_users].remove(user_id)
+            setattr(DISASTER_LEVELS, disaster_level, disaster_users)
+
+    data[DISASTER_LEVELS[level]].append(user_id)
+    setattr(DISASTER_LEVELS, level, user_id)
+
+    await update_effective_message.reply_text(
+        rt
+        + f"\nSuccessfully set Disaster level of {user_member.first_name} to {level}!"
+    )
+
+    log_message = (
+        f"#{level.upper()}\n"
+        f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
+        f"<b>User:</b> {mention_html(user_member.id, html.escape(user_member.first_name))}"
+    )
+
+    if chat.type != "private":
+        log_message = f"<b>{html.escape(chat.title)}:</b>\n" + log_message
+
+    await update.effective_message.reply_text(log_message)
+
+    await update_elevated_users(data)
+
+
+@dev_plus
+@gloggable
+async def addsudo(update: Update, context) -> str:
+    await add_disaster_level(update, "Dragon", context)
+
+
+@sudo_plus
+@gloggable
+async def addsupport(update: Update, context) -> str:
+    await add_disaster_level(update, "Demon", context)
+
+
+@sudo_plus
+@gloggable
+async def addwhitelist(update: Update, context) -> str:
+    await add_disaster_level(update, "Wolf", context)
+
+
+@sudo_plus
+@gloggable
+async def addtiger(update: Update, context) -> str:
+    await add_disaster_level(update, "Tiger", context)
+
+
+# Other functions can be refactored similarly...
+
+SUDO_HANDLER = CommandHandler("addsudo", addsudo, block=False)
+SUPPORT_HANDLER = CommandHandler(("addsupport", "adddemon"), addsupport, block=False)
+TIGER_HANDLER = CommandHandler("addtiger", addtiger, block=False)
+WHITELIST_HANDLER = CommandHandler(
+    ("addwhitelist", "addwolf"), addwhitelist, block=False
+)
+
+dispatcher.add_handler(SUDO_HANDLER)
+dispatcher.add_handler(SUPPORT_HANDLER)
+dispatcher.add_handler(TIGER_HANDLER)
+dispatcher.add_handler(WHITELIST_HANDLER)
+
+__mod_name__ = "Devs"
+__handlers__ = [
+    SUDO_HANDLER,
+    SUPPORT_HANDLER,
+    TIGER_HANDLER,
+    WHITELIST_HANDLER,
+]