Update plugins/query.py

plugins/query.py

@@ -29,59 +29,75 @@ from image.edit_5 import normalglitch_1, normalglitch_2, normalglitch_3, normalg
 from info import ADMINS, AUTH_CHANNEL, AUTH_USERS, CUSTOM_FILE_CAPTION, AUTH_GROUPS, P_TTI_SHOW_OFF, PICS, IMDB, PM_IMDB, SINGLE_BUTTON, PROTECT_CONTENT, \
     SPELL_CHECK_REPLY, IMDB_TEMPLATE, IMDB_DELET_TIME, START_MESSAGE, PMFILTER, G_FILTER, BUTTON_LOCK, BUTTON_LOCK_TEXT, SHORT_URL, SHORT_API
 
-
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.ERROR)
-
-
+logger.setLevel(logging.DEBUG)
 
 @Client.on_callback_query()
 async def cb_handler(client: Client, query: CallbackQuery):
+    logger.debug(f"Callback query received: {query.data} from user {query.from_user.id}")
     if query.data == "close_data":
+        logger.debug(f"Closing message for user {query.from_user.id}")
         await query.message.delete()
         
     elif query.data == "delallconfirm":
         userid = query.from_user.id
         chat_type = query.message.chat.type
         if chat_type == enums.ChatType.PRIVATE:
+            logger.debug(f"Checking active connection for user {userid}")
             grpid = await active_connection(str(userid))
             if grpid is not None:
                 grp_id = grpid
                 try:
                     chat = await client.get_chat(grpid)
                     title = chat.title
-                except:
+                except Exception as e:
+                    logger.error(f"Error fetching chat {grpid}: {e}")
                     return await query.message.edit_text("Make Sure I'm Present In Your Group!!", quote=True)
             else:
+                logger.debug(f"No active connection found for user {userid}")
                 return await query.message.edit_text("I'm Not Connected To Any Groups!\ncheck /Connections Or Connect To Any Groups", quote=True)
         elif chat_type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
             grp_id = query.message.chat.id
             title = query.message.chat.title
-        else: return
+        else: 
+            logger.debug(f"Unsupported chat type: {chat_type}")
+            return
         st = await client.get_chat_member(grp_id, userid)
-        if (st.status == enums.ChatMemberStatus.OWNER) or (str(userid) in ADMINS): await del_all(query.message, grp_id, title)
-        else: await query.answer("You Need To Be Group Owner Or An Auth User To Do That!", show_alert=True)
+        if (st.status == enums.ChatMemberStatus.OWNER) or (str(userid) in ADMINS): 
+            logger.debug(f"Deleting all filters for group {grp_id}")
+            await del_all(query.message, grp_id, title)
+        else: 
+            logger.debug(f"User {userid} is not authorized to delete all filters in group {grp_id}")
+            await query.answer("You Need To Be Group Owner Or An Auth User To Do That!", show_alert=True)
         
     elif query.data == "delallcancel":
         userid = query.from_user.id
         chat_type = query.message.chat.type
         if chat_type == enums.ChatType.PRIVATE:
+            logger.debug(f"Cancelling delall operation for user {userid}")
             await query.message.reply_to_message.delete()
             await query.message.delete()
         elif chat_type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
             grp_id = query.message.chat.id
             st = await client.get_chat_member(grp_id, userid)
             if (st.status == enums.ChatMemberStatus.OWNER) or (str(userid) in ADMINS):
+                logger.debug(f"Cancelling delall operation for user {userid} in group {grp_id}")
                 await query.message.delete()
                 try: await query.message.reply_to_message.delete()
                 except: pass
-            else: await query.answer("Buddy Don't Touch Others Property 😁", show_alert=True)
+            else: 
+                logger.debug(f"User {userid} is not authorized to cancel delall in group {grp_id}")
+                await query.answer("Buddy Don't Touch Others Property 😁", show_alert=True)
             
     elif "groupcb" in query.data:
         group_id = query.data.split(":")[1]
         act = query.data.split(":")[2]
-        hr = await client.get_chat(int(group_id))
-        title = hr.title
+        try:
+            hr = await client.get_chat(int(group_id))
+            title = hr.title
+        except Exception as e:
+            logger.error(f"Error fetching chat {group_id}: {e}")
+            return await query.message.edit_text("Error fetching chat details", parse_mode=enums.ParseMode.MARKDOWN)
         user_id = query.from_user.id
         if act == "":
             stat = "Connect"
@@ -99,32 +115,68 @@ async def cb_handler(client: Client, query: CallbackQuery):
       
     elif "connectcb" in query.data:
         group_id = query.data.split(":")[1]
-        hr = await client.get_chat(int(group_id))
-        title = hr.title
+        try:
+            hr = await client.get_chat(int(group_id))
+            title = hr.title
+        except Exception as e:
+            logger.error(f"Error fetching chat {group_id}: {e}")
+            return await query.message.edit_text("Error fetching chat details", parse_mode=enums.ParseMode.MARKDOWN)
         user_id = query.from_user.id
-        mkact = await make_active(str(user_id), str(group_id))
-        if mkact: await query.message.edit_text(f"Connected To: **{title}**", parse_mode=enums.ParseMode.MARKDOWN,)
-        else: await query.message.edit_text('Some Error Occurred!!', parse_mode="md")
+        try:
+            mkact = await make_active(str(user_id), str(group_id))
+            if mkact: 
+                logger.debug(f"User {user_id} connected to group {group_id}")
+                await query.message.edit_text(f"Connected To: **{title}**", parse_mode=enums.ParseMode.MARKDOWN,)
+            else: 
+                logger.debug(f"Failed to connect user {user_id} to group {group_id}")
+                await query.message.edit_text('Some Error Occurred!!', parse_mode="md")
+        except Exception as e:
+            logger.error(f"Error connecting user {user_id} to group {group_id}: {e}")
+            await query.message.edit_text('Some Error Occurred!!', parse_mode="md")
        
     elif "disconnect" in query.data:
         group_id = query.data.split(":")[1]
-        hr = await client.get_chat(int(group_id))
-        title = hr.title
+        try:
+            hr = await client.get_chat(int(group_id))
+            title = hr.title
+        except Exception as e:
+            logger.error(f"Error fetching chat {group_id}: {e}")
+            return await query.message.edit_text("Error fetching chat details", parse_mode=enums.ParseMode.MARKDOWN)
         user_id = query.from_user.id
-        mkinact = await make_inactive(str(user_id))
-        if mkinact: await query.message.edit_text(f"Disconnected From **{title}**", parse_mode=enums.ParseMode.MARKDOWN)
-        else: await query.message.edit_text(f"Some Error Occurred!!", parse_mode=enums.ParseMode.MARKDOWN)
+        try:
+            mkinact = await make_inactive(str(user_id))
+            if mkinact: 
+                logger.debug(f"User {user_id} disconnected from group {group_id}")
+                await query.message.edit_text(f"Disconnected From **{title}**", parse_mode=enums.ParseMode.MARKDOWN)
+            else: 
+                logger.debug(f"Failed to disconnect user {user_id} from group {group_id}")
+                await query.message.edit_text(f"Some Error Occurred!!", parse_mode=enums.ParseMode.MARKDOWN)
+        except Exception as e:
+            logger.error(f"Error disconnecting user {user_id} from group {group_id}: {e}")
+            await query.message.edit_text(f"Some Error Occurred!!", parse_mode=enums.ParseMode.MARKDOWN)
       
     elif "deletecb" in query.data:
         user_id = query.from_user.id
         group_id = query.data.split(":")[1]
-        delcon = await delete_connection(str(user_id), str(group_id))
-        if delcon: await query.message.edit_text("Successfully Deleted Connection")
-        else: await query.message.edit_text(f"Some Error Occurred!!", parse_mode=enums.ParseMode.MARKDOWN)
+        try:
+            delcon = await delete_connection(str(user_id), str(group_id))
+            if delcon: 
+                logger.debug(f"Connection deleted for user {user_id} from group {group_id}")
+                await query.message.edit_text("Successfully Deleted Connection")
+            else: 
+                logger.debug(f"Failed to delete connection for user {user_id} from group {group_id}")
+                await query.message.edit_text(f"Some Error Occurred!!", parse_mode=enums.ParseMode.MARKDOWN)
+        except Exception as e:
+            logger.error(f"Error deleting connection for user {user_id} from group {group_id}: {e}")
+            await query.message.edit_text(f"Some Error Occurred!!", parse_mode=enums.ParseMode.MARKDOWN)
        
     elif query.data == "backcb":
         userid = query.from_user.id
-        groupids = await all_connections(str(userid))
+        try:
+            groupids = await all_connections(str(userid))
+        except Exception as e:
+            logger.error(f"Error fetching all connections for user {userid}: {e}")
+            return await query.message.edit_text("Error fetching connections")
         if groupids is None:
             return await query.message.edit_text("There Are No Active Connections!! Connect To Some Groups First.")
         buttons = []
@@ -135,93 +187,149 @@ async def cb_handler(client: Client, query: CallbackQuery):
                 active = await if_active(str(userid), str(groupid))
                 act = " - ACTIVE" if active else ""
                 buttons.append([InlineKeyboardButton(f"{title}{act}", callback_data=f"groupcb:{groupid}:{act}")])
-            except: pass
-        if buttons: await query.message.edit_text("Your Connected Group Details ;\n\n", reply_markup=InlineKeyboardMarkup(buttons))
+            except Exception as e:
+                logger.error(f"Error fetching chat {groupid}: {e}")
+                pass
+        if buttons: 
+            logger.debug(f"Editing message with connections for user {userid}")
+            await query.message.edit_text("Your Connected Group Details ;\n\n", reply_markup=InlineKeyboardMarkup(buttons))
             
     elif "alertmessage" in query.data:
         grp_id = query.message.chat.id
         i = query.data.split(":")[1]
         keyword = query.data.split(":")[2]        
-        reply_text, btn, alerts, fileid = await find_filter(grp_id, keyword)       
-        if alerts is not None:
-            alerts = ast.literal_eval(alerts)
-            alert = alerts[int(i)]
-            alert = alert.replace("\\n", "\n").replace("\\t", "\t")
-            await query.answer(alert, show_alert=True)
+        try:
+            reply_text, btn, alerts, fileid = await find_filter(grp_id, keyword)       
+            if alerts is not None:
+                alerts = ast.literal_eval(alerts)
+                alert = alerts[int(i)]
+                alert = alert.replace("\\n", "\n").replace("\\t", "\t")
+                await query.answer(alert, show_alert=True)
+        except Exception as e:
+            logger.error(f"Error fetching alert message for keyword {keyword} in group {grp_id}: {e}")
+            await query.answer("Error fetching alert message", show_alert=True)
             
     elif "galert" in query.data:
         i = query.data.split(":")[1]
         keyword = query.data.split(":")[2]             
-        reply_text, btn, alerts, fileid = await find_gfilter("gfilters", keyword)
-        if alerts is not None:
-            alerts = ast.literal_eval(alerts)
-            alert = alerts[int(i)]
-            alert = alert.replace("\\n", "\n").replace("\\t", "\t")
-            await query.answer(alert, show_alert=True)
+        try:
+            reply_text, btn, alerts, fileid = await find_gfilter("gfilters", keyword)
+            if alerts is not None:
+                alerts = ast.literal_eval(alerts)
+                alert = alerts[int(i)]
+                alert = alert.replace("\\n", "\n").replace("\\t", "\t")
+                await query.answer(alert, show_alert=True)
+        except Exception as e:
+            logger.error(f"Error fetching global alert message for keyword {keyword}: {e}")
+            await query.answer("Error fetching global alert message", show_alert=True)
     
     if query.data.startswith("pmfile"):
         ident, file_id = query.data.split("#")
-        files_ = await get_file_details(file_id)
-        if not files_: return await query.answer('No Such File Exist.')
+        try:
+            files_ = await get_file_details(file_id)
+        except Exception as e:
+            logger.error(f"Error fetching file details for file_id {file_id}: {e}")
+            return await query.answer('No Such File Exist.', show_alert=True)
+        if not files_: 
+            logger.debug(f"No file details found for file_id {file_id}")
+            return await query.answer('No Such File Exist.', show_alert=True)
         files = files_[0]
         title = files.file_name
         size = get_size(files.file_size)
-        f_caption = f_caption = f"{title}"
+        f_caption = f"{title}"
         if CUSTOM_FILE_CAPTION:
-            try: f_caption = CUSTOM_FILE_CAPTION.format(mention=query.from_user.mention, file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)                                                                                                      
-            except Exception as e: logger.exception(e)
+            try: 
+                f_caption = CUSTOM_FILE_CAPTION.format(mention=query.from_user.mention, file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)                                                                                                      
+            except Exception as e: 
+                logger.error(f"Error formatting custom file caption: {e}")
         try:                  
             if AUTH_CHANNEL and not await is_subscribed(client, query):
+                logger.debug(f"User {query.from_user.id} is not subscribed to AUTH_CHANNEL")
                 return await query.answer(url=f"https://t.me/{temp.U_NAME}?start={ident}_{file_id}")
             else:
+                logger.debug(f"Sending file {file_id} to user {query.from_user.id}")
                 await client.send_cached_media(chat_id=query.from_user.id, file_id=file_id, caption=f_caption, protect_content=True if ident == "pmfilep" else False)                       
         except Exception as e:
-            await query.answer(f"⚠️ Eʀʀᴏʀ {e}", show_alert=True)
+            logger.error(f"Error sending file {file_id} to user {query.from_user.id}: {e}")
+            await query.answer(f"⚠️ Error {e}", show_alert=True)
         
     if query.data.startswith("file"):        
         ident, req, file_id = query.data.split("#")
         if BUTTON_LOCK:
             if int(req) not in [query.from_user.id, 0]:
+                logger.debug(f"Button lock triggered for user {query.from_user.id}")
                 return await query.answer(BUTTON_LOCK_TEXT.format(query=query.from_user.first_name), show_alert=True)
-        files_ = await get_file_details(file_id)
-        if not files_: return await query.answer('No Such File Exist.')
+        try:
+            files_ = await get_file_details(file_id)
+        except Exception as e:
+            logger.error(f"Error fetching file details for file_id {file_id}: {e}")
+            return await query.answer('No Such File Exist.', show_alert=True)
+        if not files_: 
+            logger.debug(f"No file details found for file_id {file_id}")
+            return await query.answer('No Such File Exist.', show_alert=True)
         files = files_[0]
         title = files.file_name
         size = get_size(files.file_size)
-        f_caption = f_caption = f"{title}"
+        f_caption = f"{title}"
         settings = await get_settings(query.message.chat.id)
         if CUSTOM_FILE_CAPTION:
-            try: f_caption = CUSTOM_FILE_CAPTION.format(mention=query.from_user.mention, file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)                               
-            except Exception as e: logger.exception(e)
+            try: 
+                f_caption = CUSTOM_FILE_CAPTION.format(mention=query.from_user.mention, file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)                               
+            except Exception as e: 
+                logger.error(f"Error formatting custom file caption: {e}")
         try:
             if AUTH_CHANNEL and not await is_subscribed(client, query):
+                logger.debug(f"User {query.from_user.id} is not subscribed to AUTH_CHANNEL")
                 return await query.answer(url=f"https://t.me/{temp.U_NAME}?start={ident}_{file_id}")
             elif settings['botpm']:
+                logger.debug(f"Redirecting user {query.from_user.id} to PM for file {file_id}")
                 return await query.answer(url=f"https://t.me/{temp.U_NAME}?start={ident}_{file_id}")
             else:
+                logger.debug(f"Sending file {file_id} to user {query.from_user.id}")
                 await client.send_cached_media(chat_id=query.from_user.id, file_id=file_id, caption=f_caption, protect_content=True if ident == "filep" else False)
                 await query.answer('Cʜᴇᴄᴋ PM, I Hᴀᴠᴇ Sᴇɴᴛ Fɪʟᴇs Iɴ Pᴍ', show_alert=True)
         except UserIsBlocked:
+            logger.debug(f"User {query.from_user.id} has blocked the bot")
             await query.answer('Uɴʙʟᴏᴄᴋ Tʜᴇ Bᴏᴛ Mᴀʜɴ !', show_alert=True)
         except PeerIdInvalid:
+            logger.debug(f"Invalid peer ID for user {query.from_user.id}")
             await query.answer(url=f"https://t.me/{temp.U_NAME}?start={ident}_{file_id}")
         except Exception as e:
+            logger.error(f"Error sending file {file_id} to user {query.from_user.id}: {e}")
             await query.answer(url=f"https://t.me/{temp.U_NAME}?start={ident}_{file_id}")
      
     elif query.data.startswith("checksub"):
         if AUTH_CHANNEL and not await is_subscribed(client, query):
-            return await query.answer("I Lɪᴋᴇ Yᴏᴜʀ Sᴍᴀʀᴛɴᴇss, Bᴜᴛ Dᴏɴ'ᴛ Bᴇ Oᴠᴇʀsᴍᴀʀᴛ Oᴋᴀʏ 😏", show_alert=True)
+            logger.debug(f"User {query.from_user.id} is not subscribed to AUTH_CHANNEL")
+            return await query.answer("I Lɪᴋᴇ Yᴏᴜʀ Sᴍᴀʀᴛɴᴇꜱꜱ, Bᴜᴛ Dᴏɴ'ᴛ Bᴇ Oᴠᴇʀꜱᴍᴀʀᴛ Oᴋᴀʏ 😏", show_alert=True)
         ident, file_id = query.data.split("#")
-        files_ = await get_file_details(file_id)
-        if not files_: return await query.answer('NO SUCH FILE EXIST....')
+        try:
+            files_ = await get_file_details(file_id)
+        except Exception as e:
+            logger.error(f"Error fetching file details for file_id {file_id}: {e}")
+            return await query.answer('NO SUCH FILE EXIST....', show_alert=True)
+        if not files_: 
+            logger.debug(f"No file details found for file_id {file_id}")
+            return await query.answer('NO SUCH FILE EXIST....', show_alert=True)
         files = files_[0]
         title = files.file_name
         size = get_size(files.file_size)
-        f_caption = f_caption = f"{title}"
+        f_caption = f"{title}"
         if CUSTOM_FILE_CAPTION:
-            try: f_caption = CUSTOM_FILE_CAPTION.format(mention=query.from_user.mention, file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)  
-            except Exception as e: logger.exception(e)
-        await client.send_cached_media(chat_id=query.from_user.id, file_id=file_id, caption=f_caption, protect_content=True if ident == 'checksubp' else False)
+            try: 
+                f_caption = CUSTOM_FILE_CAPTION.format(mention=query.from_user.mention, file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)  
+            except Exception as e: 
+                logger.error(f"Error formatting custom file caption: {e}")
+        try:
+            if AUTH_CHANNEL and not await is_subscribed(client, query):
+                logger.debug(f"User {query.from_user.id} is not subscribed to AUTH_CHANNEL")
+                return await query.answer(url=f"https://t.me/{temp.U_NAME}?start={ident}_{file_id}")
+            else:
+                logger.debug(f"Sending file {file_id} to user {query.from_user.id}")
+                await client.send_cached_media(chat_id=query.from_user.id, file_id=file_id, caption=f_caption, protect_content=True if ident == 'checksubp' else False)
+        except Exception as e:
+            logger.error(f"Error sending file {file_id} to user {query.from_user.id}: {e}")
+            await query.answer(f"⚠️ Error {e}", show_alert=True)
 
     elif query.data == "removebg":
         buttons = [[
@@ -243,7 +351,7 @@ async def cb_handler(client: Client, query: CallbackQuery):
             ],[
             InlineKeyboardButton('𝙱𝙰𝙲𝙺', callback_data='photo')
         ]]              
-        await query.message.edit("**Select A Type**", reply_markup=InlineKeyboardMarkup(buttons))          
+        await query.message.edit_text("**Select A Type**", reply_markup=InlineKeyboardMarkup(buttons))          
             
     elif query.data == "rotate":
         buttons = [[
@@ -300,7 +408,7 @@ async def cb_handler(client: Client, query: CallbackQuery):
             ],[
             InlineKeyboardButton('𝙱𝙰𝙲𝙺', callback_data='photo')
         ]]
-        await query.message.edit("**Select A Type**", reply_markup=InlineKeyboardMarkup(buttons))
+        await query.message.edit_text("**Select A Type**", reply_markup=InlineKeyboardMarkup(buttons))
             
     elif query.data == "circle":
         buttons = [[
@@ -321,7 +429,7 @@ async def cb_handler(client: Client, query: CallbackQuery):
             ],[                    
             InlineKeyboardButton('𝙱𝙰𝙲𝙺', callback_data='photo')   
         ]]           
-        await query.message.edit("**Select Border**", reply_markup=InlineKeyboardMarkup(buttons))
+        await query.message.edit_text("**Select Border**", reply_markup=InlineKeyboardMarkup(buttons))
    
     elif query.data == "photo":
         buttons = [[
@@ -424,8 +532,11 @@ async def cb_handler(client: Client, query: CallbackQuery):
     elif query.data == "pages":
         await query.answer("🤨 Cᴜʀɪᴏsɪᴛʏ Is A Lɪᴛᴛʟᴇ Mᴏʀᴇ, Isɴ'ᴛ Iᴛ? 😁", show_alert=True)
     elif query.data == "howdl":
-        try: await query.answer(script.HOW_TO_DOWNLOAD.format(query.from_user.first_name), show_alert=True)
-        except: await query.message.edit(script.HOW_TO_DOWNLOAD.format(query.from_user.first_name))
+        try: 
+            await query.answer(script.HOW_TO_DOWNLOAD.format(query.from_user.first_name), show_alert=True)
+        except Exception as e:
+            logger.error(f"Error answering howdl callback: {e}")
+            await query.message.edit_text(script.HOW_TO_DOWNLOAD.format(query.from_user.first_name))
 
     elif query.data == "start":                        
         buttons = [[
@@ -480,12 +591,18 @@ async def cb_handler(client: Client, query: CallbackQuery):
             InlineKeyboardButton('« Bᴀᴄᴋ', 'help')           
         ]]
         if query.from_user.id not in ADMINS:
+            logger.debug(f"User {query.from_user.id} is not an admin")
             return await query.answer("Sᴏʀʀʏ Tʜɪs Mᴇɴᴜ Oɴʟʏ Fᴏʀ Mʏ Aᴅᴍɪɴs ⚒️", show_alert=True)
-        await query.message.edit("Pʀᴏᴄᴇꜱꜱɪɴɢ Wᴀɪᴛ Fᴏʀ 15 ꜱᴇᴄ...")
-        total, used, free = shutil.disk_usage(".")
-        stats = script.SERVER_STATS.format(get_time(time.time() - client.uptime), psutil.cpu_percent(), psutil.virtual_memory().percent, humanbytes(total), humanbytes(used), psutil.disk_usage('/').percent, humanbytes(free))            
-        stats_pic = await make_carbon(stats, True)
-        await query.edit_message_media(InputMediaPhoto(stats_pic, script.ADMIN_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+        await query.message.edit_text("Pʀᴏᴄᴇꜱꜱɪɴɢ...")
+        try:
+            total, used, free = shutil.disk_usage(".")
+            stats = script.SERVER_STATS.format(get_time(time.time() - client.uptime), psutil.cpu_percent(), psutil.virtual_memory().percent, humanbytes(total), humanbytes(used), psutil.disk_usage('/').percent, humanbytes(free))            
+            stats_pic = await make_carbon(stats, True)
+            await query.edit_message_media(InputMediaPhoto(stats_pic, script.ADMIN_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+            logger.debug(f"Admin panel processed successfully for user {query.from_user.id}")
+        except Exception as e:
+            logger.error(f"Error processing admin panel callback for user {query.from_user.id}: {e}")
+            await query.message.edit_text("An error occurred while processing your request. Please try again later.")
         
     elif query.data == "openfilter":
         buttons = [[
@@ -523,6 +640,56 @@ async def cb_handler(client: Client, query: CallbackQuery):
             InlineKeyboardButton('« Bᴀᴄᴋ', 'openfilter')           
         ]]
         if query.from_user.id not in ADMINS:
+            logger.debug(f"User {query.from_user.id} is not an admin")
+            return await query.answer("Sᴏʀʀʏ Tʜɪs Mᴇɴᴜ Oɴʟʏ Fᴏʀ Mʏ Aᴅᴍɪɴs ⚒️", show_alert=True)
+        await query.message.edit_text("Pʀᴏᴄᴇꜱꜱɪɴɢ...")
+        try:
+            total, used, free = shutil.disk_usage(".")
+            stats = script.SERVER_STATS.format(get_time(time.time() - client.uptime), psutil.cpu_percent(), psutil.virtual_memory().percent, humanbytes(total), humanbytes(used), psutil.disk_usage('/').percent, humanbytes(free))            
+            stats_pic = await make_carbon(stats, True)
+            await query.edit_message_media(InputMediaPhoto(stats_pic, script.ADMIN_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+            logger.debug(f"Admin panel processed successfully for user {query.from_user.id}")
+        except Exception as e:
+            logger.error(f"Error processing admin panel callback for user {query.from_user.id}: {e}")
+            await query.message.edit_text("An error occurred while processing your request. Please try again later.")
+        
+    elif query.data == "openfilter":
+        buttons = [[
+            InlineKeyboardButton('AᴜᴛᴏFɪʟᴛᴇʀ', 'autofilter'),
+            InlineKeyboardButton('MᴀɴᴜᴀʟFɪʟᴛᴇʀ', 'manuelfilter')
+            ],[
+            InlineKeyboardButton('GʟᴏʙᴀʟFɪʟᴛᴇʀ', 'globalfilter')
+            ],[
+            InlineKeyboardButton('✘ Cʟᴏꜱᴇ', 'close_data'),
+            InlineKeyboardButton('« Bᴀᴄᴋ', 'help')           
+        ]]
+        await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.FILTER_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+        
+    elif query.data == "autofilter":
+        buttons = [[
+            InlineKeyboardButton('✘ Cʟᴏꜱᴇ', 'close_data'),
+            InlineKeyboardButton('« Bᴀᴄᴋ', 'openfilter')           
+        ]]
+        await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.AUTOFILTER_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+        
+    elif query.data == "manuelfilter":
+        buttons = [[
+            InlineKeyboardButton('Bᴜᴛᴛᴏɴ Fᴏʀᴍᴀᴛ', 'button')
+            ],[
+            InlineKeyboardButton('✘ Cʟᴏꜱᴇ', 'close_data'),
+            InlineKeyboardButton('« Bᴀᴄᴋ', 'openfilter')           
+        ]]
+        await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.MANUELFILTER_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+        
+    elif query.data == "globalfilter":
+        buttons = [[
+            InlineKeyboardButton('Bᴜᴛᴛᴏɴ Fᴏʀᴍᴀᴛ', 'buttong')
+            ],[
+            InlineKeyboardButton('✘ Cʟᴏꜱᴇ', 'close_data'),
+            InlineKeyboardButton('« Bᴀᴄᴋ', 'openfilter')           
+        ]]
+        if query.from_user.id not in ADMINS:
+            logger.debug(f"User {query.from_user.id} is not an admin")
             return await query.answer("Sᴏʀʀʏ Tʜɪs Mᴇɴᴜ Oɴʟʏ Fᴏʀ Mʏ Aᴅᴍɪɴs ⚒️", show_alert=True)
         await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.GLOBALFILTER_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
         
@@ -552,7 +719,7 @@ async def cb_handler(client: Client, query: CallbackQuery):
             InlineKeyboardButton('✘ Cʟᴏꜱᴇ', 'close_data'),
             InlineKeyboardButton('« Bᴀᴄᴋ', 'help')           
         ]]
-        await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.EXTRAMOD_TXT, enums.ParseMode.HTML),             reply_markup=InlineKeyboardMarkup(buttons))
+        await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.EXTRAMOD_TXT, enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
         
     elif query.data == "gpmanager":
         buttons = [[
@@ -566,36 +733,48 @@ async def cb_handler(client: Client, query: CallbackQuery):
             InlineKeyboardButton('⟳ Rᴇꜰʀᴇꜱʜ', 'stats'),
             InlineKeyboardButton('« Bᴀᴄᴋ', 'help')           
         ]]
-        total = await Media.count_documents()
-        users = await db.total_users_count()
-        chats = await db.total_chat_count()
-        monsize = await db.get_db_size()
-        free = 536870912 - monsize
-        monsize = get_size(monsize)
-        free = get_size(free)
-        await query.message.edit('ʟᴏᴀᴅɪɴɢ....')
-        await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.STATUS_TXT.format(total, users, chats, monsize, free), enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+        try:
+            total = await Media.count_documents()
+            users = await db.total_users_count()
+            chats = await db.total_chat_count()
+            monsize = await db.get_db_size()
+            free = 536870912 - monsize
+            monsize = get_size(monsize)
+            free = get_size(free)
+            await query.message.edit('ʟᴏᴀᴅɪɴɢ....')
+            await query.edit_message_media(InputMediaPhoto(random.choice(PICS), script.STATUS_TXT.format(total, users, chats, monsize, free), enums.ParseMode.HTML), reply_markup=InlineKeyboardMarkup(buttons))
+            logger.debug(f"Stats refreshed for user {query.from_user.id}")
+        except Exception as e:
+            logger.error(f"Error refreshing stats for user {query.from_user.id}: {e}")
+            await query.message.edit_text("An error occurred while refreshing stats. Please try again later.")
     
     elif query.data.startswith("setgs"):
         ident, set_type, status, grp_id = query.data.split("#")
         grpid = await active_connection(str(query.from_user.id))
         if str(grp_id) != str(grpid):
+            logger.debug(f"Active connection mismatch for user {query.from_user.id}")
             return await query.message.edit("Yᴏᴜʀ Aᴄᴛɪᴠᴇ Cᴏɴɴᴇᴄᴛɪᴏɴ Hᴀs Bᴇᴇɴ Cʜᴀɴɢᴇᴅ. Gᴏ Tᴏ /settings")
-        if status == "True": await save_group_settings(grpid, set_type, False)
-        else: await save_group_settings(grpid, set_type, True)
+        if status == "True": 
+            logger.debug(f"Setting {set_type} to False for group {grp_id}")
+            await save_group_settings(grpid, set_type, False)
+        else: 
+            logger.debug(f"Setting {set_type} to True for group {grp_id}")
+            await save_group_settings(grpid, set_type, True)
         settings = await get_settings(grpid)
         if settings is not None:
             buttons = [[
-                InlineKeyboardButton(f"ꜰɪʟᴛᴇʀ ʙᴜᴛᴛᴏɴ : {'sɪɴɢʟᴇ' if settings['button'] else 'ᴅᴏᴜʙʟᴇ'}", f'setgs#button#{settings["button"]}#{str(grp_id)}')
+                InlineKeyboardButton(f"ꜰɪʟᴛᴇʀ ʙᴜᴛᴛᴏɴ : {'sɪɴɢʟᴇ' if settings['button'] else 'ᴅᴏᴜʙʟᴇ'}", f'setgs#button#{settings["button"]}#{str(grpid)}')
                 ],[
-                InlineKeyboardButton(f"ꜰɪʟᴇ ɪɴ ᴩᴍ ꜱᴛᴀʀᴛ: {'ᴏɴ' if settings['botpm'] else 'ᴏꜰꜰ'}", f'setgs#botpm#{settings["botpm"]}#{str(grp_id)}')
+                InlineKeyboardButton(f"ꜰɪʟᴇ ɪɴ ᴩᴍ ꜱᴛᴀʀᴛ: {'ᴏɴ' if settings['botpm'] else 'ᴏꜰꜰ'}", f'setgs#botpm#{settings["botpm"]}#{str(grpid)}')
                 ],[                
-                InlineKeyboardButton(f"ʀᴇꜱᴛʀɪᴄᴛ ᴄᴏɴᴛᴇɴᴛ : {'ᴏɴ' if settings['file_secure'] else 'ᴏꜰꜰ'}", f'setgs#file_secure#{settings["file_secure"]}#{str(grp_id)}')
+                InlineKeyboardButton(f"ʀᴇꜱᴛʀɪᴄᴛ ᴄᴏɴᴛᴇɴᴛ : {'ᴏɴ' if settings['file_secure'] else 'ᴏꜰꜰ'}", f'setgs#file_secure#{settings["file_secure"]}#{str(grpid)}')
                 ],[
-                InlineKeyboardButton(f"ɪᴍᴅʙ ɪɴ ꜰɪʟᴛᴇʀ : {'ᴏɴ' if settings['imdb'] else 'ᴏꜰꜰ'}", f'setgs#imdb#{settings["imdb"]}#{str(grp_id)}')
+                InlineKeyboardButton(f"ɪᴍᴅʙ ɪɴ ꜰɪʟᴛᴇʀ : {'ᴏɴ' if settings['imdb'] else 'ᴏꜰꜰ'}", f'setgs#imdb#{settings["imdb"]}#{str(grpid)}')
                 ],[
-                InlineKeyboardButton(f"ꜱᴩᴇʟʟɪɴɢ ᴄʜᴇᴄᴋ : {'ᴏɴ' if settings['spell_check'] else 'ᴏꜰꜰ'}", f'setgs#spell_check#{settings["spell_check"]}#{str(grp_id)}')
+                InlineKeyboardButton(f"ꜱᴩᴇʟʟɪɴɢ ᴄʜᴇᴄᴋ : {'ᴏɴ' if settings['spell_check'] else 'ᴏꜰꜰ'}", f'setgs#spell_check#{settings["spell_check"]}#{str(grpid)}')
                 ],[
-                InlineKeyboardButton(f"ᴡᴇʟᴄᴏᴍᴇ ᴍᴇꜱꜱᴀɢᴇ : {'ᴏɴ' if settings['welcome'] else 'ᴏꜰꜰ'}", f'setgs#welcome#{settings["welcome"]}#{str(grp_id)}')
+                InlineKeyboardButton(f"ᴡᴇʟᴄᴏᴍᴇ ᴍᴇꜱꜱᴀɢᴇ : {'ᴏɴ' if settings['welcome'] else 'ᴏꜰꜰ'}", f'setgs#welcome#{settings["welcome"]}#{str(grpid)}')
             ]]
-            await query.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
+            await query.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
+            logger.debug(f"Settings updated for user {query.from_user.id} in group {grp_id}")
+