Temp fix

misskaty/core/decorator/errors.py

@@ -1,6 +1,7 @@
 import traceback, asyncio
 from functools import wraps
 from pyrogram.errors.exceptions.forbidden_403 import ChatWriteForbidden
+from pyrogram.errors.exceptions.flood_420 import FloodWait
 from misskaty.vars import LOG_CHANNEL
 from misskaty import app
 
@@ -52,8 +53,11 @@ def capture_err(func):
             )
 
             for x in error_feedback:
-                await app.send_message(LOG_CHANNEL, x)
+                try:
-                await message.reply(x)
+                    await app.send_message(LOG_CHANNEL, x)
+                    await message.reply(x)
+                except FloodWait as e:
+                    await asyncio.sleep(x.value)
             raise err
 
     return capture

misskaty/plugins/admin.py

@@ -57,36 +57,44 @@ __HELP__ = """
 @app.on_chat_member_updated()
 async def admin_cache_func(_, cmu):
     if cmu.old_chat_member and cmu.old_chat_member.promoted_by:
-        admins_in_chat[cmu.chat.id] = {
+        try:
-            "last_updated_at": time(),
+            admins_in_chat[cmu.chat.id] = {
-            "data": [member.user.id async for member in app.get_chat_members(cmu.chat.id, filter=enums.ChatMembersFilter.ADMINISTRATORS)],
+                "last_updated_at": time(),
-        }
+                "data": [
-        LOGGER.info(f"Updated admin cache for {cmu.chat.id} [{cmu.chat.title}]")
+                    member.user.id
+                    async for member in app.get_chat_members(
+                        cmu.chat.id, filter=enums.ChatMembersFilter.ADMINISTRATORS
+                    )
+                ],
+            }
+            LOGGER.info(f"Updated admin cache for {cmu.chat.id} [{cmu.chat.title}]")
+        except:
+            pass
 
 
 # Purge CMD
 @app.on_message(filters.command("purge", COMMAND_HANDLER) & ~filters.private)
 @adminsOnly("can_delete_messages")
 async def purge(_, message):
-    repliedmsg = message.reply_to_message
-    await message.delete()
-
-    if not repliedmsg:
-        return await message.reply_text("Reply to a message to purge from.")
-
-    cmd = message.command
-    if len(cmd) > 1 and cmd[1].isdigit():
-        purge_to = repliedmsg.id + int(cmd[1])
-        if purge_to > message.id:
-            purge_to = message.id
-    else:
-        purge_to = message.id
-
-    chat_id = message.chat.id
-    message_ids = []
-    del_total = 0
-
     try:
+        repliedmsg = message.reply_to_message
+        await message.delete()
+
+        if not repliedmsg:
+            return await message.reply_text("Reply to a message to purge from.")
+
+        cmd = message.command
+        if len(cmd) > 1 and cmd[1].isdigit():
+            purge_to = repliedmsg.id + int(cmd[1])
+            if purge_to > message.id:
+                purge_to = message.id
+        else:
+            purge_to = message.id
+
+        chat_id = message.chat.id
+        message_ids = []
+        del_total = 0
+
         for message_id in range(
             repliedmsg.id,
             purge_to,
@@ -120,11 +128,11 @@ async def purge(_, message):
 # Kick members
 @app.on_message(filters.command(["kick", "dkick"], COMMAND_HANDLER) & ~filters.private)
 @adminsOnly("can_restrict_members")
-async def kickFunc(_, message):
+async def kickFunc(client, message):
     user_id, reason = await extract_user_and_reason(message)
     if not user_id:
         return await message.reply_text("I can't find that user.")
-    if user_id == 1507530289:
+    if user_id == client.me.id:
         return await message.reply_text("I can't kick myself, i can leave if you want.")
     if user_id in SUDO:
         return await message.reply_text("Wow, you wanna kick my owner?")
@@ -147,26 +155,37 @@ async def kickFunc(_, message):
 
 
 # Ban/DBan/TBan User
-@app.on_message(filters.command(["ban", "dban", "tban"], COMMAND_HANDLER) & ~filters.private)
+@app.on_message(
+    filters.command(["ban", "dban", "tban"], COMMAND_HANDLER) & ~filters.private
+)
 @adminsOnly("can_restrict_members")
-async def banFunc(_, message):
+async def banFunc(client, message):
     user_id, reason = await extract_user_and_reason(message, sender_chat=True)
 
     if not user_id:
         return await message.reply_text("I can't find that user.")
-    if user_id == 1507530289:
+    if user_id == client.me.id:
         return await message.reply_text("I can't ban myself, i can leave if you want.")
     if user_id in SUDO:
         return await message.reply_text("You Wanna Ban The Elevated One?, RECONSIDER!")
     if user_id in (await list_admins(message.chat.id)):
-        return await message.reply_text("I can't ban an admin, You know the rules, so do i.")
+        return await message.reply_text(
+            "I can't ban an admin, You know the rules, so do i."
+        )
 
     try:
         mention = (await app.get_users(user_id)).mention
     except IndexError:
-        mention = message.reply_to_message.sender_chat.title if message.reply_to_message else "Anon"
+        mention = (
+            message.reply_to_message.sender_chat.title
+            if message.reply_to_message
+            else "Anon"
+        )
 
-    msg = f"**Banned User:** {mention}\n" f"**Banned By:** {message.from_user.mention if message.from_user else 'Anon'}\n"
+    msg = (
+        f"**Banned User:** {mention}\n"
+        f"**Banned By:** {message.from_user.mention if message.from_user else 'Anon'}\n"
+    )
     if message.command[0][0] == "d":
         await message.reply_to_message.delete()
     if message.command[0] == "tban":
@@ -189,8 +208,11 @@ async def banFunc(_, message):
     if reason:
         msg += f"**Reason:** {reason}"
     keyboard = ikb({"🚨 Unban 🚨": f"unban_{user_id}"})
-    await message.chat.ban_member(user_id)
+    try:
-    await message.reply_text(msg, reply_markup=keyboard)
+        await message.chat.ban_member(user_id)
+        await message.reply_text(msg, reply_markup=keyboard)
+    except Exception as err:
+        await message.reply(f"ERROR: {err}")
 
 
 # Unban members
@@ -211,34 +233,44 @@ async def unban_func(_, message):
     elif len(message.command) == 1 and reply:
         user = message.reply_to_message.from_user.id
     else:
-        return await message.reply_text("Provide a username or reply to a user's message to unban.")
+        return await message.reply_text(
+            "Provide a username or reply to a user's message to unban."
+        )
     await message.chat.unban_member(user)
     umention = (await app.get_users(user)).mention
     await message.reply_text(f"Unbanned! {umention}")
 
 
 # Ban users listed in a message
-@app.on_message(filters.user(SUDO) & filters.command("listban", COMMAND_HANDLER) & ~filters.private)
+@app.on_message(
+    filters.user(SUDO) & filters.command("listban", COMMAND_HANDLER) & ~filters.private
+)
 async def list_ban_(c, message):
     userid, msglink_reason = await extract_user_and_reason(message)
     if not userid or not msglink_reason:
-        return await message.reply_text("Provide a userid/username along with message link and reason to list-ban")
+        return await message.reply_text(
+            "Provide a userid/username along with message link and reason to list-ban"
+        )
     if len(msglink_reason.split(" ")) == 1:  # message link included with the reason
         return await message.reply_text("You must provide a reason to list-ban")
     # seperate messge link from reason
     lreason = msglink_reason.split()
     messagelink, reason = lreason[0], " ".join(lreason[1:])
 
-    if not re.search(r"(https?://)?t(elegram)?\.me/\w+/\d+", messagelink):  # validate link
+    if not re.search(
+        r"(https?://)?t(elegram)?\.me/\w+/\d+", messagelink
+    ):  # validate link
         return await message.reply_text("Invalid message link provided")
 
-    if userid == 1507530289:
+    if userid == c.me.id:
         return await message.reply_text("I can't ban myself.")
     if userid in SUDO:
         return await message.reply_text("You Wanna Ban The Elevated One?, RECONSIDER!")
     splitted = messagelink.split("/")
     uname, mid = splitted[-2], int(splitted[-1])
-    m = await message.reply_text("`Banning User from multiple groups. This may take some time`")
+    m = await message.reply_text(
+        "`Banning User from multiple groups. This may take some time`"
+    )
     try:
         msgtext = (await app.get_messages(uname, mid)).text
         gusernames = re.findall("@\w+", msgtext)
@@ -267,11 +299,17 @@ async def list_ban_(c, message):
 
 
 # Unban users listed in a message
-@app.on_message(filters.user(SUDO) & filters.command("listunban", COMMAND_HANDLER) & ~filters.private)
+@app.on_message(
+    filters.user(SUDO)
+    & filters.command("listunban", COMMAND_HANDLER)
+    & ~filters.private
+)
 async def list_unban_(c, message):
     userid, msglink = await extract_user_and_reason(message)
     if not userid or not msglink:
-        return await message.reply_text("Provide a userid/username along with message link to list-unban")
+        return await message.reply_text(
+            "Provide a userid/username along with message link to list-unban"
+        )
 
     if not re.search(r"(https?://)?t(elegram)?\.me/\w+/\d+", msglink):  # validate link
         return await message.reply_text("Invalid message link provided")
@@ -313,22 +351,27 @@ async def list_unban_(c, message):
 async def deleteFunc(_, message):
     if not message.reply_to_message:
         return await message.reply_text("Reply To A Message To Delete It")
-    await message.reply_to_message.delete()
+    try:
-    await message.delete()
+        await message.reply_to_message.delete()
+        await message.delete()
+    except:
+        await message.reply("Please give me delete message permission.")
 
 
 # Promote Members
-@app.on_message(filters.command(["promote", "fullpromote"], COMMAND_HANDLER) & ~filters.private)
+@app.on_message(
+    filters.command(["promote", "fullpromote"], COMMAND_HANDLER) & ~filters.private
+)
 @adminsOnly("can_promote_members")
 async def promoteFunc(_, message):
     user_id = await extract_user(message)
     umention = (await app.get_users(user_id)).mention
     if not user_id:
         return await message.reply_text("I can't find that user.")
-    bot = await app.get_chat_member(message.chat.id, 1507530289)
+    bot = await app.get_chat_member(message.chat.id, client.me.id)
-    if user_id == 1507530289:
+    if user_id == client.me.id:
         return await message.reply_text("I can't promote myself.")
-    if not bot.can_promote_members:
+    if not bot.privileges.can_promote_members:
         return await message.reply_text("I don't have enough permissions")
     if message.command[0][0] == "f":
         await message.chat.promote_member(
@@ -361,11 +404,11 @@ async def promoteFunc(_, message):
 # Demote Member
 @app.on_message(filters.command("demote", COMMAND_HANDLER) & ~filters.private)
 @adminsOnly("can_promote_members")
-async def demote(_, message):
+async def demote(client, message):
     user_id = await extract_user(message)
     if not user_id:
         return await message.reply_text("I can't find that user.")
-    if user_id == 1507530289:
+    if user_id == client.me.id:
         return await message.reply_text("I can't demote myself.")
     if user_id in SUDO:
         return await message.reply_text("You wanna demote the elevated one?")
@@ -413,19 +456,27 @@ async def pin(_, message):
 # Mute members
 @app.on_message(filters.command(["mute", "tmute"], COMMAND_HANDLER) & ~filters.private)
 @adminsOnly("can_restrict_members")
-async def mute(_, message):
+async def mute(client, message):
-    user_id, reason = await extract_user_and_reason(message)
+    try:
+        user_id, reason = await extract_user_and_reason(message)
+    except Exception as err:
+        return await message.reply(f"ERROR: {err}")
     if not user_id:
         return await message.reply_text("I can't find that user.")
-    if user_id == 1507530289:
+    if user_id == client.me.id:
         return await message.reply_text("I can't mute myself.")
     if user_id in SUDO:
         return await message.reply_text("You wanna mute the elevated one?, RECONSIDER!")
     if user_id in (await list_admins(message.chat.id)):
-        return await message.reply_text("I can't mute an admin, You know the rules, so do i.")
+        return await message.reply_text(
+            "I can't mute an admin, You know the rules, so do i."
+        )
     mention = (await app.get_users(user_id)).mention
     keyboard = ikb({"🚨   Unmute   🚨": f"unmute_{user_id}"})
-    msg = f"**Muted User:** {mention}\n" f"**Muted By:** {message.from_user.mention if message.from_user else 'Anon'}\n"
+    msg = (
+        f"**Muted User:** {mention}\n"
+        f"**Muted By:** {message.from_user.mention if message.from_user else 'Anon'}\n"
+    )
     if message.command[0] == "tmute":
         split = reason.split(None, 1)
         time_value = split[0]
@@ -491,17 +542,19 @@ async def ban_deleted_accounts(_, message):
 
 @app.on_message(filters.command(["warn", "dwarn"], COMMAND_HANDLER) & ~filters.private)
 @adminsOnly("can_restrict_members")
-async def warn_user(_, message):
+async def warn_user(client, message):
     user_id, reason = await extract_user_and_reason(message)
     chat_id = message.chat.id
     if not user_id:
         return await message.reply_text("I can't find that user.")
-    if user_id == 1507530289:
+    if user_id == client.me.id:
         return await message.reply_text("I can't warn myself, i can leave if you want.")
     if user_id in SUDO:
         return await message.reply_text("You Wanna Warn The Elevated One?, RECONSIDER!")
     if user_id in (await list_admins(chat_id)):
-        return await message.reply_text("I can't warn an admin, You know the rules, so do i.")
+        return await message.reply_text(
+            "I can't warn an admin, You know the rules, so do i."
+        )
     user, warns = await asyncio.gather(
         app.get_users(user_id),
         get_warn(chat_id, await int_to_alpha(user_id)),
@@ -534,7 +587,8 @@ async def remove_warning(_, cq):
     permission = "can_restrict_members"
     if permission not in permissions:
         return await cq.answer(
-            "You don't have enough permissions to perform this action.\n" + f"Permission needed: {permission}",
+            "You don't have enough permissions to perform this action.\n"
+            + f"Permission needed: {permission}",
             show_alert=True,
         )
     user_id = cq.data.split("_")[1]
@@ -559,7 +613,8 @@ async def unmute_user(_, cq):
     permission = "can_restrict_members"
     if permission not in permissions:
         return await cq.answer(
-            "You don't have enough permissions to perform this action.\n" + f"Permission needed: {permission}",
+            "You don't have enough permissions to perform this action.\n"
+            + f"Permission needed: {permission}",
             show_alert=True,
         )
     user_id = cq.data.split("_")[1]
@@ -578,7 +633,8 @@ async def unban_user(_, cq):
     permission = "can_restrict_members"
     if permission not in permissions:
         return await cq.answer(
-            "You don't have enough permissions to perform this action.\n" + f"Permission needed: {permission}",
+            "You don't have enough permissions to perform this action.\n"
+            + f"Permission needed: {permission}",
             show_alert=True,
         )
     user_id = cq.data.split("_")[1]
@@ -595,7 +651,9 @@ async def unban_user(_, cq):
 @adminsOnly("can_restrict_members")
 async def remove_warnings(_, message):
     if not message.reply_to_message:
-        return await message.reply_text("Reply to a message to remove a user's warnings.")
+        return await message.reply_text(
+            "Reply to a message to remove a user's warnings."
+        )
     user_id = message.reply_to_message.from_user.id
     mention = message.reply_to_message.from_user.mention
     chat_id = message.chat.id
@@ -626,7 +684,13 @@ async def check_warns(_, message):
 
 
 # Report User in Group
-@app.on_message((filters.command("report", COMMAND_HANDLER) | filters.command(["admins", "admin"], prefixes="@")) & ~filters.private)
+@app.on_message(
+    (
+        filters.command("report", COMMAND_HANDLER)
+        | filters.command(["admins", "admin"], prefixes="@")
+    )
+    & ~filters.private
+)
 @capture_err
 async def report_user(_, message):
     if not message.reply_to_message:
@@ -641,13 +705,28 @@ async def report_user(_, message):
     linked_chat = (await app.get_chat(message.chat.id)).linked_chat
     if linked_chat is None:
         if reply_id in list_of_admins or reply_id == message.chat.id:
-            return await message.reply_text("Do you know that the user you are replying is an admin ?")
+            return await message.reply_text(
+                "Do you know that the user you are replying is an admin ?"
+            )
 
-    elif reply_id in list_of_admins or reply_id == message.chat.id or reply_id == linked_chat.id:
+    elif (
-        return await message.reply_text("Do you know that the user you are replying is an admin ?")
+        reply_id in list_of_admins
-    user_mention = reply.from_user.mention if reply.from_user else reply.sender_chat.title
+        or reply_id == message.chat.id
+        or reply_id == linked_chat.id
+    ):
+        return await message.reply_text(
+            "Do you know that the user you are replying is an admin ?"
+        )
+    user_mention = (
+        reply.from_user.mention if reply.from_user else reply.sender_chat.title
+    )
     text = f"Reported {user_mention} to admins!"
-    admin_data = [m async for m in app.get_chat_members(message.chat.id, filter=enums.ChatMembersFilter.ADMINISTRATORS)]
+    admin_data = [
+        m
+        async for m in app.get_chat_members(
+            message.chat.id, filter=enums.ChatMembersFilter.ADMINISTRATORS
+        )
+    ]
     for admin in admin_data:
         if admin.user.is_bot or admin.user.is_deleted:
             # return bots or deleted admins

misskaty/plugins/genss.py

@@ -30,7 +30,19 @@ __HELP__ = """"
 @app.on_message(filters.command(["genss"], COMMAND_HANDLER))
 @capture_err
 async def genss(client, message):
-    if message.reply_to_message is not None:
+    replied = message.reply_to_message
+    if replied is not None:
+        media = None
+        if replied is not None:
+            vid = [replied.video, replied.document]
+            for v in vid:
+                if v is not None:
+                    media = v
+                    break
+        if media is None:
+            return await message.reply(
+                "Reply to a Telegram Video or document as video to generate screenshoot!"
+            )
         process = await message.reply_text("`Processing, please wait..`")
         c_time = time.time()
         the_real_download_location = await client.download_media(
@@ -52,12 +64,16 @@ async def genss(client, message):
                     chat_id=message.chat.id,
                     message_id=process.id,
                 )
-                await client.send_chat_action(chat_id=message.chat.id, action=enums.ChatAction.UPLOAD_PHOTO)
+                await client.send_chat_action(
+                    chat_id=message.chat.id, action=enums.ChatAction.UPLOAD_PHOTO
+                )
 
                 try:
                     await gather(
                         *[
-                            message.reply_document(images, reply_to_message_id=message.id),
+                            message.reply_document(
+                                images, reply_to_message_id=message.id
+                            ),
                             message.reply_photo(images, reply_to_message_id=message.id),
                         ]
                     )
@@ -65,7 +81,9 @@ async def genss(client, message):
                     await sleep(e.value)
                     await gather(
                         *[
-                            message.reply_document(images, reply_to_message_id=message.id),
+                            message.reply_document(
+                                images, reply_to_message_id=message.id
+                            ),
                             message.reply_photo(images, reply_to_message_id=message.id),
                         ]
                     )
@@ -88,7 +106,7 @@ async def genss(client, message):
                 except:
                     pass
     else:
-        await message.reply("Reply to a Telegram media to get screenshots..")
+        await message.reply("Reply to a Telegram media to get screenshots from media..")
 
 
 @app.on_message(filters.command(["genss_link"], COMMAND_HANDLER))
@@ -97,9 +115,13 @@ async def genss_link(client, message):
     try:
         link = message.text.split(" ")[1]
         if link.startswith("https://file.yasirweb.my.id"):
-            link = link.replace("https://file.yasirweb.my.id", "https://file.yasiraris.workers.dev")
+            link = link.replace(
+                "https://file.yasirweb.my.id", "https://file.yasiraris.workers.dev"
+            )
         if link.startswith("https://link.yasirweb.my.id"):
-            link = link.replace("https://link.yasirweb.my.id", "https://yasirrobot.herokuapp.com")
+            link = link.replace(
+                "https://link.yasirweb.my.id", "https://yasirrobot.herokuapp.com"
+            )
         process = await message.reply_text("`Processing, please wait..`")
         tmp_directory_for_each_user = f"./MissKaty_Genss/{str(message.from_user.id)}"
         if not os.path.isdir(tmp_directory_for_each_user):
@@ -111,7 +133,9 @@ async def genss_link(client, message):
             chat_id=message.chat.id,
             message_id=process.id,
         )
-        await client.send_chat_action(chat_id=message.chat.id, action=enums.ChatAction.UPLOAD_PHOTO)
+        await client.send_chat_action(
+            chat_id=message.chat.id, action=enums.ChatAction.UPLOAD_PHOTO
+        )
         try:
             await message.reply_media_group(images, reply_to_message_id=message.id)
         except FloodWait as e:

misskaty/plugins/grup_tools.py

@@ -234,7 +234,7 @@ async def save_group(bot, message):
                     photo=welcomeimg,
                     caption=f"Hai {u.mention}, Selamat datang digrup {message.chat.title}.",
                 )
-            except (ChatSendMediaForbidden, SlowmodeWait, TopicClosed):
+            except (ChatSendMediaForbidden, SlowmodeWait):
                 await app.leave_chat(message.chat.id)
             try:
                 os.remove(f"downloads/welcome#{u.id}.png")

misskaty/plugins/mediainfo.py

@@ -8,9 +8,11 @@
 import io
 from os import remove as osremove
 import time
+import asyncio
 import subprocess
 from pyrogram import filters
 from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from pyrogram.errors import FloodWait
 from misskaty.vars import COMMAND_HANDLER
 from utils import get_file_id
 from misskaty import app
@@ -51,7 +53,10 @@ async def mediainfo(client, message):
         text_ = file_info.message_type
         link = post_to_telegraph(title, body_text)
         markup = InlineKeyboardMarkup([[InlineKeyboardButton(text=text_, url=link)]])
-        await message.reply("ℹ️ **MEDIA INFO**", reply_markup=markup, quote=True)
+        try:
+            await message.reply("ℹ️ **MEDIA INFO**", reply_markup=markup, quote=True)
+        except FloodWait as f:
+            await asyncio.sleep(f.value)
         await process.delete()
         try:
             osremove(file_path)
@@ -60,10 +65,6 @@ async def mediainfo(client, message):
     else:
         try:
             link = message.text.split(" ", maxsplit=1)[1]
-            if link.startswith("https://file.yasirweb.my.id"):
-                link = link.replace("https://file.yasirweb.my.id", "https://file.yasiraris.workers.dev")
-            if link.startswith("https://link.yasirweb.my.id"):
-                link = link.replace("https://link.yasirweb.my.id", "https://yasirrobot.herokuapp.com")
             process = await message.reply_text("`Mohon tunggu sejenak...`")
             try:
                 output = subprocess.check_output(["mediainfo", f"{link}"]).decode("utf-8")

misskaty/plugins/misc_tools.py

@@ -188,7 +188,7 @@ async def tts(_, message):
     else:
         if len(message.text.split()) <= 2:
             await message.reply_text(
-                "Berikan Kode bahasa yang valid.\n[Available options](https://telegra.ph/Lang-Codes-11-08).\n<b>Usage:</b> <code>/tts en <text></code>",
+                "Berikan Kode bahasa yang valid.\n[Available options](https://telegra.ph/Lang-Codes-11-08).\n*Usage:* /tts en [text]",
             )
             return
         target_lang = message.text.split(None, 2)[1]
@@ -515,7 +515,18 @@ async def imdb1_search(client, message):
 
 @app.on_callback_query(filters.regex("^imdbid"))
 async def imdbcb_backup(bot: Client, query: CallbackQuery):
-    i, userid, movie = query.data.split("#")
+    # ValueError: not enough values to unpack (expected 3, got 2)
+    # Idk how to reproduce it, so wait people report to me
+    try:
+        i, userid, movie = query.data.split("#")
+    except:
+        LOGGER.error(
+            f"ERROR IMDB Callback: {query.data} - {query.from_user.first_name} [{query.from_user.id}]"
+        )
+        return await query.answer(
+            "⚠️ Invalid callback query, silahkan laporkan ke pemilik bot atau buka issue baru di repository MissKaty dengan alasan yang jelas.",
+            True,
+        )
     if query.from_user.id != int(userid):
         return await query.answer("⚠️ Akses Ditolak!", True)
     try:
@@ -749,7 +760,16 @@ async def imdb_en_search(client, message):
 @app.on_callback_query(filters.regex("^imdben"))
 @capture_err
 async def imdb_en_callback(bot: Client, query: CallbackQuery):
-    i, userid, movie = query.data.split("#")
+    try:
+        i, userid, movie = query.data.split("#")
+    except:
+        LOGGER.error(
+            f"ERROR IMDB Callback: {query.data} - {query.from_user.first_name} [{query.from_user.id}]"
+        )
+        return await query.answer(
+            "⚠️ Invalid callback query, please report to bot owner or open issue in MissKaty repository with relevant details.",
+            True,
+        )
     if query.from_user.id != int(userid):
         return await query.answer("⚠️ Access Denied!", True)
     await query.message.edit_caption("<i>⏳ Processing your request..</i>")