Fixed Timeout

Thunder/bot/plugins/admin.py

@@ -1,6 +1,4 @@
-"""
-Thunder/bot/plugins/admin.py - Administrative commands and functionality
-"""
+# Thunder/bot/plugins/admin.py
 
 import os
 import sys
@@ -12,10 +10,7 @@ import random
 import string
 import html
 import uuid
-
 from datetime import datetime
-from typing import List, Dict
-
 from pyrogram.client import Client
 from pyrogram import filters, StopPropagation
 from pyrogram.enums import ParseMode
@@ -32,7 +27,8 @@ from pyrogram.errors import (
     UserIsBlocked,
     PeerIdInvalid,
     FileReferenceExpired,
-    FileReferenceInvalid
+    FileReferenceInvalid,
+    BadRequest
 )
 
 from Thunder.bot import StreamBot, multi_clients, work_loads
@@ -44,9 +40,36 @@ from Thunder.utils.logger import logger, LOG_FILE
 from Thunder.utils.tokens import authorize, deauthorize, list_allowed
 from Thunder.utils.database import db
 from Thunder.utils.messages import *
+from Thunder.utils.retry_api import retry_send_message
 
 broadcast_ids = {}
-MAX_CONCURRENT_TASKS = 10
+RATE_LIMIT = 25
+BATCH_SIZE = 30
+MAX_CONCURRENT = 10
+
+class RateLimiter:
+    def __init__(self, rate=RATE_LIMIT):
+        self.rate = rate
+        self.tokens = rate
+        self.last_update = time.time()
+        self.lock = asyncio.Lock()
+    
+    async def acquire(self):
+        async with self.lock:
+            now = time.time()
+            elapsed = now - self.last_update
+            self.tokens = min(self.rate, self.tokens + elapsed * self.rate)
+            self.last_update = now
+            
+            if self.tokens >= 1:
+                self.tokens -= 1
+                return
+            
+            wait_time = (1 - self.tokens) / self.rate
+            await asyncio.sleep(wait_time)
+            self.tokens = 0
+
+rate_limiter = RateLimiter()
 
 def generate_unique_id(length=6):
     while True:
@@ -54,7 +77,7 @@ def generate_unique_id(length=6):
         if random_id not in broadcast_ids:
             return random_id
 
-async def get_users_in_batches(batch_size=100):
+async def get_users_in_batches(batch_size=BATCH_SIZE):
     users_cursor = await db.get_all_users()
     current_batch = []
     async for user in users_cursor:
@@ -65,28 +88,10 @@ async def get_users_in_batches(batch_size=100):
     if current_batch:
         yield current_batch
 
-async def handle_broadcast_completion(message, output, failures, successes, total_users, start_time, broadcast_id):
-    elapsed_time = get_readable_time(time.time() - start_time)
-    try:
-        await output.delete()
-    except:
-        pass
-    message_text = MSG_BROADCAST_COMPLETE.format(
-        elapsed_time=elapsed_time,
-        total_users=total_users,
-        successes=successes,
-        failures=failures,
-        deleted_accounts=broadcast_ids[broadcast_id]['deleted']
-    )
-    reply_markup = InlineKeyboardMarkup([
-        [InlineKeyboardButton(MSG_ADMIN_RESTART_BROADCAST, callback_data="restart_broadcast")]
-    ])
-    await message.reply_text(
-        message_text,
-        parse_mode=ParseMode.MARKDOWN,
-        link_preview_options=LinkPreviewOptions(is_disabled=True),
-        reply_markup=reply_markup
-    )
+async def handle_flood_wait(e, attempt=0):
+    wait_time = max(e.value, 1) * (1.5 ** attempt)
+    wait_time = min(wait_time, 300)
+    await asyncio.sleep(wait_time + random.uniform(0.1, 0.5))
 
 @StreamBot.on_message(filters.command("users") & filters.private & filters.user(Var.OWNER_ID))
 async def get_total_users(client, message):
@@ -101,7 +106,7 @@ async def get_total_users(client, message):
             parse_mode=ParseMode.MARKDOWN,
             reply_markup=reply_markup
         )
-    except:
+    except Exception:
         await message.reply_text(MSG_DB_ERROR)
 
 @StreamBot.on_message(filters.command("broadcast") & filters.private & filters.user(Var.OWNER_ID))
@@ -109,109 +114,119 @@ async def broadcast_message(client, message):
     if not message.reply_to_message:
         await message.reply_text(MSG_INVALID_BROADCAST_CMD, quote=True)
         return
+
+    broadcast_id = generate_unique_id()
+    broadcast_ids[broadcast_id] = {
+        "total": 0,
+        "processed": 0,
+        "success": 0,
+        "failed": 0,
+        "deleted": 0,
+        "start_time": time.time(),
+        "is_cancelled": False,
+        "last_update": 0
+    }
+
+    reply_markup = InlineKeyboardMarkup([
+        [InlineKeyboardButton(MSG_BUTTON_CANCEL_BROADCAST, callback_data=f"cancel_broadcast_{broadcast_id}")]
+    ])
+    output = await message.reply_text(MSG_BROADCAST_START, reply_markup=reply_markup)
+
     try:
-        broadcast_id = generate_unique_id()
-        broadcast_ids[broadcast_id] = {
-            "total": 0,
-            "current": 0,
-            "success": 0,
-            "failed": 0,
-            "deleted": 0,
-            "start_time": time.time(),
-            "is_cancelled": False
-        }
-        reply_markup = InlineKeyboardMarkup([
-            [InlineKeyboardButton(MSG_BUTTON_CANCEL_BROADCAST, callback_data=f"cancel_broadcast_{broadcast_id}")]
-        ])
-        output = await message.reply_text(MSG_BROADCAST_START, reply_markup=reply_markup)
-        self_id = client.me.id
         start_time = time.time()
         total_users = await db.total_users_count()
-        processed = 0
-        successes = 0
-        failures = 0
         broadcast_ids[broadcast_id]["total"] = total_users
-        semaphore = asyncio.Semaphore(MAX_CONCURRENT_TASKS)
-        broadcast_lock = asyncio.Lock()
-        processed_lock = asyncio.Lock()
+        
+        stats = broadcast_ids[broadcast_id]
+        self_id = client.me.id
 
         async def update_progress():
-            while processed < total_users and not broadcast_ids[broadcast_id]["is_cancelled"]:
-                try:
-                    await output.edit_text(
-                        MSG_BROADCAST_PROGRESS.format(
-                            total_users=total_users,
-                            processed=processed,
-                            elapsed_time=get_readable_time(int(time.time() - start_time)),
-                            successes=successes,
-                            failures=failures
+            while stats["processed"] < stats["total"] and not stats["is_cancelled"]:
+                current_time = time.time()
+                if current_time - stats["last_update"] >= 5:
+                    try:
+                        progress_text = MSG_BROADCAST_PROGRESS.format(
+                            total_users=stats["total"],
+                            processed=stats["processed"],
+                            elapsed_time=get_readable_time(int(current_time - start_time)),
+                            successes=stats["success"],
+                            failures=stats["failed"]
                         )
-                    )
-                except:
-                    pass
-                await asyncio.sleep(3)
+                        await output.edit_text(progress_text)
+                        stats["last_update"] = current_time
+                    except BadRequest as e:
+                        if "Message is not modified" not in str(e):
+                            break
+                    except Exception:
+                        break
+                await asyncio.sleep(2)
 
         progress_task = asyncio.create_task(update_progress())
 
-        async def send_message_to_user(user_id):
-            nonlocal successes, failures, processed
-            if not isinstance(user_id, int) or user_id == self_id:
+        async def send_to_user(user_id: int):
+            if stats["is_cancelled"] or user_id == self_id:
                 return
-            async with semaphore:
-                retries = 0
-                for attempt in range(3):
-                    if broadcast_ids[broadcast_id]["is_cancelled"]:
-                        return
+
+            await rate_limiter.acquire()
+            
+            for attempt in range(3):
+                if stats["is_cancelled"]:
+                    return
+                
+                try:
+                    if message.reply_to_message.text or message.reply_to_message.caption:
+                        await client.send_message(
+                            chat_id=user_id,
+                            text=message.reply_to_message.text or message.reply_to_message.caption,
+                            parse_mode=ParseMode.MARKDOWN,
+                            link_preview_options=LinkPreviewOptions(is_disabled=True)
+                        )
+                    elif message.reply_to_message.media:
+                        await message.reply_to_message.copy(chat_id=user_id)
+                    
+                    stats["success"] += 1
+                    break
+                    
+                except FloodWait as e:
+                    await handle_flood_wait(e, attempt)
+                    continue
+                    
+                except (UserDeactivated, ChatWriteForbidden, UserIsBlocked, PeerIdInvalid):
                     try:
-                        if message.reply_to_message.text or message.reply_to_message.caption:
-                            await client.send_message(
-                                chat_id=user_id,
-                                text=message.reply_to_message.text or message.reply_to_message.caption,
-                                parse_mode=ParseMode.MARKDOWN,
-                                link_preview_options=LinkPreviewOptions(is_disabled=True)
-                            )
-                        elif message.reply_to_message.media:
-                            await message.reply_to_message.copy(chat_id=user_id)
-                        async with broadcast_lock:
-                            successes += 1
-                        async with processed_lock:
-                            processed += 1
-                            broadcast_ids[broadcast_id]["current"] = processed
-                        break
-                    except FloodWait as e:
-                        await asyncio.sleep(e.value + 1)
-                        continue
-                    except (FileReferenceExpired, FileReferenceInvalid):
-                        retries += 1
-                        if retries >= 3:
-                            break
-                    except (UserDeactivated, ChatWriteForbidden, UserIsBlocked, PeerIdInvalid):
-                        try:
-                            await db.delete_user(user_id)
-                            async with broadcast_lock:
-                                failures += 1
-                                broadcast_ids[broadcast_id]["deleted"] += 1
-                            async with processed_lock:
-                                processed += 1
-                                broadcast_ids[broadcast_id]["current"] = processed
-                        except:
-                            pass
-                        break
+                        await db.delete_user(user_id)
+                        stats["deleted"] += 1
                     except Exception:
-                        async with broadcast_lock:
-                            failures += 1
-                        async with processed_lock:
-                            processed += 1
-                            broadcast_ids[broadcast_id]["current"] = processed
-                        if attempt == 2:
-                            break
-                        await asyncio.sleep(1)
+                        pass
+                    stats["failed"] += 1
+                    break
+                    
+                except (FileReferenceExpired, FileReferenceInvalid):
+                    if attempt == 2:
+                        stats["failed"] += 1
+                        break
+                    await asyncio.sleep(1)
+                    
+                except Exception:
+                    stats["failed"] += 1
+                    break
+            
+            stats["processed"] += 1
+
+        semaphore = asyncio.Semaphore(MAX_CONCURRENT)
+        
+        async def process_user(user_id):
+            async with semaphore:
+                await send_to_user(int(user_id))
 
         async for user_batch in get_users_in_batches():
-            if broadcast_ids[broadcast_id]["is_cancelled"]:
+            if stats["is_cancelled"]:
                 break
-            batch_tasks = [send_message_to_user(int(user['id'])) for user in user_batch]
-            await asyncio.gather(*batch_tasks)
+            
+            batch_tasks = [process_user(user['id']) for user in user_batch]
+            await asyncio.gather(*batch_tasks, return_exceptions=True)
+            
+            if not stats["is_cancelled"]:
+                await asyncio.sleep(1)
 
         progress_task.cancel()
         try:
@@ -219,40 +234,61 @@ async def broadcast_message(client, message):
         except asyncio.CancelledError:
             pass
 
-        await handle_broadcast_completion(
-            message, output, failures, successes, total_users, start_time, broadcast_id
-        )
-        broadcast_ids.pop(broadcast_id, None)
+        elapsed_time = get_readable_time(time.time() - start_time)
+        
+        try:
+            await output.delete()
+        except Exception:
+            pass
 
+        completion_text = MSG_BROADCAST_COMPLETE.format(
+            elapsed_time=elapsed_time,
+            total_users=stats["total"],
+            successes=stats["success"],
+            failures=stats["failed"],
+            deleted_accounts=stats["deleted"]
+        )
+        
+        reply_markup = InlineKeyboardMarkup([
+            [InlineKeyboardButton(MSG_ADMIN_RESTART_BROADCAST, callback_data="restart_broadcast")]
+        ])
+        await message.reply_text(
+            completion_text,
+            parse_mode=ParseMode.MARKDOWN,
+            link_preview_options=LinkPreviewOptions(is_disabled=True),
+            reply_markup=reply_markup
+        )
+        
     except Exception as e:
         await message.reply_text(
             MSG_BROADCAST_FAILED.format(error=str(e), error_id=uuid.uuid4().hex[:8])
         )
+    finally:
+        broadcast_ids.pop(broadcast_id, None)
 
 @StreamBot.on_message(filters.command("cancel_broadcast") & filters.private & filters.user(Var.OWNER_ID))
 async def cancel_broadcast(client, message):
     if not broadcast_ids:
         await message.reply_text(MSG_NO_ACTIVE_BROADCASTS)
         return
+
     if len(broadcast_ids) == 1:
         broadcast_id = list(broadcast_ids.keys())[0]
         broadcast_ids[broadcast_id]["is_cancelled"] = True
         await message.reply_text(MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id))
         return
+
     keyboard = []
     for broadcast_id, info in broadcast_ids.items():
-        progress = f"{info['current']}/{info['total']}" if info['total'] else "Unknown"
+        progress = f"{info['processed']}/{info['total']}" if info['total'] else "Unknown"
         elapsed = get_readable_time(time.time() - info['start_time'])
         keyboard.append([
             InlineKeyboardButton(
-                MSG_ADMIN_BROADCAST_PROGRESS_ITEM.format(
-                    broadcast_id=broadcast_id,
-                    progress=progress,
-                    elapsed=elapsed
-                ),
+                f"Cancel {broadcast_id} ({progress}) - {elapsed}",
                 callback_data=f"cancel_broadcast_{broadcast_id}"
             )
         ])
+    
     await message.reply_text(
         MSG_MULTIPLE_BROADCASTS,
         reply_markup=InlineKeyboardMarkup(keyboard)
@@ -280,19 +316,22 @@ async def show_status(client, message):
                 sorted(work_loads.items(), key=lambda x: x[1], reverse=True)
             )
         }
+        
         for bot_name, load in workloads.items():
             workloads_text += MSG_ADMIN_BOT_WORKLOAD_ITEM.format(bot_name=bot_name, load=load)
+        
         stats_text = MSG_SYSTEM_STATUS.format(
             uptime=uptime,
             active_bots=len(multi_clients),
             workloads=workloads_text,
             version=__version__
         )
+        
         reply_markup = InlineKeyboardMarkup([
             [InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
         ])
         await message.reply_text(stats_text, parse_mode=ParseMode.MARKDOWN, reply_markup=reply_markup)
-    except:
+    except Exception:
         await message.reply_text(MSG_STATUS_ERROR)
 
 @StreamBot.on_message(filters.command("stats") & filters.private & filters.user(Var.OWNER_ID))
@@ -300,6 +339,7 @@ async def show_stats(client, message):
     try:
         current_time = get_readable_time(int(time.time() - StartTime))
         total, used, free = shutil.disk_usage('.')
+        
         stats_text = MSG_SYSTEM_STATS.format(
             uptime=current_time,
             total=humanbytes(total),
@@ -308,16 +348,18 @@ async def show_stats(client, message):
             upload=humanbytes(psutil.net_io_counters().bytes_sent),
             download=humanbytes(psutil.net_io_counters().bytes_recv)
         )
+        
         stats_text += MSG_PERFORMANCE_STATS.format(
             cpu_percent=psutil.cpu_percent(interval=0.5),
             ram_percent=psutil.virtual_memory().percent,
             disk_percent=psutil.disk_usage('.').percent
         )
+        
         reply_markup = InlineKeyboardMarkup([
             [InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
         ])
         await message.reply_text(stats_text, parse_mode=ParseMode.MARKDOWN, reply_markup=reply_markup)
-    except:
+    except Exception:
         await message.reply_text(MSG_STATUS_ERROR)
 
 @StreamBot.on_message(filters.command("restart") & filters.private & filters.user(Var.OWNER_ID))
@@ -326,20 +368,16 @@ async def restart_bot(client, message):
         sent_message = await message.reply_text(MSG_RESTARTING)
         await db.add_restart_message(sent_message.id, message.chat.id)
         os.execv(sys.executable, [sys.executable, "-m", "Thunder"])
-    except Exception as e:
-        logger.error(f"Error during restart: {e}")
+    except Exception:
         await message.reply_text(MSG_RESTART_FAILED)
 
 @StreamBot.on_message(filters.command("log") & filters.private & filters.user(Var.OWNER_ID))
 async def send_logs(client, message):
     try:
-        if not os.path.exists(LOG_FILE):
-            await message.reply_text(MSG_LOG_FILE_MISSING)
-            return
-        file_size = os.path.getsize(LOG_FILE)
-        if file_size == 0:
-            await message.reply_text(MSG_LOG_FILE_EMPTY)
+        if not os.path.exists(LOG_FILE) or os.path.getsize(LOG_FILE) == 0:
+            await message.reply_text(MSG_LOG_FILE_MISSING if not os.path.exists(LOG_FILE) else MSG_LOG_FILE_EMPTY)
             return
+        
         await client.send_document(
             chat_id=message.chat.id,
             document=LOG_FILE,
@@ -354,16 +392,17 @@ async def authorize_command(client, message):
     if len(message.command) < 2:
         await message.reply_text(MSG_AUTHORIZE_USAGE)
         return
+    
     try:
         user_id_to_authorize = int(message.command[1])
         authorized = await authorize(user_id_to_authorize, authorized_by=message.from_user.id)
-        if authorized:
-            await message.reply_text(MSG_AUTHORIZE_SUCCESS.format(user_id=user_id_to_authorize))
-        else:
-            await message.reply_text(MSG_AUTHORIZE_FAILED.format(user_id=user_id_to_authorize))
+        await message.reply_text(
+            MSG_AUTHORIZE_SUCCESS.format(user_id=user_id_to_authorize) if authorized 
+            else MSG_AUTHORIZE_FAILED.format(user_id=user_id_to_authorize)
+        )
     except ValueError:
         await message.reply_text(MSG_INVALID_USER_ID)
-    except:
+    except Exception:
         await message.reply_text(MSG_ERROR_GENERIC)
 
 @StreamBot.on_message(filters.command("deauthorize") & filters.private & filters.user(Var.OWNER_ID))
@@ -371,16 +410,17 @@ async def deauthorize_command(client, message):
     if len(message.command) < 2:
         await message.reply_text(MSG_DEAUTHORIZE_USAGE)
         return
+    
     try:
         user_id_to_deauthorize = int(message.command[1])
         deauthorized = await deauthorize(user_id_to_deauthorize)
-        if deauthorized:
-            await message.reply_text(MSG_DEAUTHORIZE_SUCCESS.format(user_id=user_id_to_deauthorize))
-        else:
-            await message.reply_text(MSG_DEAUTHORIZE_FAILED.format(user_id=user_id_to_deauthorize))
+        await message.reply_text(
+            MSG_DEAUTHORIZE_SUCCESS.format(user_id=user_id_to_deauthorize) if deauthorized 
+            else MSG_DEAUTHORIZE_FAILED.format(user_id=user_id_to_deauthorize)
+        )
     except ValueError:
         await message.reply_text(MSG_INVALID_USER_ID)
-    except:
+    except Exception:
         await message.reply_text(MSG_ERROR_GENERIC)
 
 @StreamBot.on_message(filters.command("listauth") & filters.private & filters.user(Var.OWNER_ID))
@@ -390,6 +430,7 @@ async def list_authorized_command(client, message):
         if not authorized_users:
             await message.reply_text(MSG_NO_AUTH_USERS)
             return
+
         message_text = MSG_ADMIN_AUTH_LIST_HEADER
         for i, user in enumerate(authorized_users, 1):
             message_text += MSG_AUTH_USER_INFO.format(
@@ -398,6 +439,7 @@ async def list_authorized_command(client, message):
                 authorized_by=user['authorized_by'],
                 auth_time=user['authorized_at']
             )
+        
         reply_markup = InlineKeyboardMarkup([
             [InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
         ])
@@ -407,68 +449,67 @@ async def list_authorized_command(client, message):
             link_preview_options=LinkPreviewOptions(is_disabled=True),
             reply_markup=reply_markup
         )
-    except:
+    except Exception:
         await message.reply_text(MSG_ERROR_GENERIC)
 
 @StreamBot.on_message(filters.command("ban") & filters.private & filters.user(Var.OWNER_ID))
 async def ban_user_command(client, message):
+    if len(message.command) < 2:
+        await message.reply_text(MSG_BAN_USAGE)
+        return
+
     try:
-        if len(message.command) < 2:
-            await message.reply_text(MSG_BAN_USAGE)
-            return
-        try:
-            user_id_to_ban = int(message.command[1])
-        except ValueError:
-            await message.reply_text(MSG_INVALID_USER_ID)
-            return
+        user_id_to_ban = int(message.command[1])
         if user_id_to_ban in (Var.OWNER_ID if isinstance(Var.OWNER_ID, list) else [Var.OWNER_ID]):
             await message.reply_text(MSG_CANNOT_BAN_OWNER)
             return
+
         reason = " ".join(message.command[2:]) if len(message.command) > 2 else MSG_ADMIN_NO_BAN_REASON
         ban_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
         await db.add_banned_user(
             user_id=user_id_to_ban,
             reason=reason,
             ban_time=ban_time,
             banned_by=message.from_user.id
         )
+        
         reply_text = MSG_ADMIN_USER_BANNED.format(user_id=user_id_to_ban)
         if reason != MSG_ADMIN_NO_BAN_REASON:
             reply_text += MSG_BAN_REASON_SUFFIX.format(reason=reason)
         await message.reply_text(reply_text)
+        
         try:
-            await client.send_message(
-                chat_id=user_id_to_ban,
-                text=MSG_USER_BANNED_NOTIFICATION
-            )
-        except:
+            await retry_send_message(client, chat_id=user_id_to_ban, text=MSG_USER_BANNED_NOTIFICATION)
+        except Exception:
             pass
+            
+    except ValueError:
+        await message.reply_text(MSG_INVALID_USER_ID)
     except Exception as e:
         await message.reply_text(MSG_BAN_ERROR.format(error=str(e)))
 
 @StreamBot.on_message(filters.command("unban") & filters.private & filters.user(Var.OWNER_ID))
 async def unban_user_command(client, message):
+    if len(message.command) < 2:
+        await message.reply_text(MSG_UNBAN_USAGE)
+        return
+
     try:
-        if len(message.command) < 2:
-            await message.reply_text(MSG_UNBAN_USAGE)
-            return
-        try:
-            user_id_to_unban = int(message.command[1])
-        except ValueError:
-            await message.reply_text(MSG_INVALID_USER_ID)
-            return
+        user_id_to_unban = int(message.command[1])
         removed = await db.remove_banned_user(user_id=user_id_to_unban)
+        
         if removed:
             await message.reply_text(MSG_ADMIN_USER_UNBANNED.format(user_id=user_id_to_unban))
             try:
-                await client.send_message(
-                    chat_id=user_id_to_unban,
-                    text=MSG_USER_UNBANNED_NOTIFICATION
-                )
-            except:
+                await retry_send_message(client, chat_id=user_id_to_unban, text=MSG_USER_UNBANNED_NOTIFICATION)
+            except Exception:
                 pass
         else:
             await message.reply_text(MSG_USER_NOT_IN_BAN_LIST.format(user_id=user_id_to_unban))
+            
+    except ValueError:
+        await message.reply_text(MSG_INVALID_USER_ID)
     except Exception as e:
         await message.reply_text(MSG_UNBAN_ERROR.format(error=str(e)))
 
@@ -477,12 +518,14 @@ async def run_shell_command(client: Client, message: Message):
     if len(message.command) < 2:
         await message.reply_text(MSG_SHELL_USAGE, parse_mode=ParseMode.HTML)
         return
+
     command_to_run = " ".join(message.command[1:])
     reply_msg = await message.reply_text(
         MSG_SHELL_EXECUTING.format(command=html.escape(command_to_run)),
         parse_mode=ParseMode.HTML,
         quote=True
     )
+
     try:
         process = await asyncio.create_subprocess_shell(
             command_to_run,
@@ -490,6 +533,7 @@ async def run_shell_command(client: Client, message: Message):
             stderr=asyncio.subprocess.PIPE
         )
         stdout, stderr = await process.communicate()
+        
         output = ""
         if stdout:
             output += MSG_SHELL_OUTPUT_STDOUT.format(output=html.escape(stdout.decode().strip()))
@@ -497,8 +541,10 @@ async def run_shell_command(client: Client, message: Message):
             output += MSG_SHELL_OUTPUT_STDERR.format(error=html.escape(stderr.decode().strip()))
         if not output:
             output = MSG_SHELL_NO_OUTPUT
+            
     except Exception as e:
         output = MSG_SHELL_ERROR.format(error=html.escape(str(e)))
+
     if len(output) > 4096:
         try:
             filename = f"shell_output_{int(time.time())}.txt"
@@ -507,6 +553,7 @@ async def run_shell_command(client: Client, message: Message):
                     file.write(f"STDOUT:\n{stdout.decode()}\n\n")
                 if stderr:
                     file.write(f"STDERR:\n{stderr.decode()}")
+            
             await client.send_document(
                 chat_id=message.chat.id,
                 document=filename,
@@ -514,35 +561,33 @@ async def run_shell_command(client: Client, message: Message):
                 parse_mode=ParseMode.HTML
             )
             os.remove(filename)
-        except Exception as e:
-            await message.reply_text(
-                MSG_SHELL_LARGE_OUTPUT.format(error=html.escape(str(e))),
-                parse_mode=ParseMode.HTML
-            )
+        except Exception:
+            await message.reply_text("Output too large and file creation failed", parse_mode=ParseMode.HTML)
     else:
         await message.reply_text(output, parse_mode=ParseMode.HTML)
+
     try:
         await reply_msg.delete()
-    except:
+    except Exception:
         pass
 
 @StreamBot.on_callback_query(filters.regex("close_panel"))
 async def close_panel(client, callback_query):
-    """Handler for Close button - deletes current panel and command message."""
     try:
         await callback_query.answer()
         await callback_query.message.delete()
-        logger.debug(f"User {callback_query.from_user.id} closed panel")
+        
         if callback_query.message.reply_to_message:
             try:
                 ctx = callback_query.message.reply_to_message
                 await ctx.delete()
                 if ctx.reply_to_message:
                     await ctx.reply_to_message.delete()
-            except Exception as e:
-                logger.warning(f"Error deleting command messages: {e}")
-    except Exception as e:
-        logger.error(f"Error in close_panel: {e}")
+            except Exception:
+                pass
+                
+    except Exception:
+        pass
     finally:
         raise StopPropagation
 
@@ -553,5 +598,5 @@ async def restart_broadcast(client, callback_query):
             MSG_ERROR_BROADCAST_INSTRUCTION,
             parse_mode=ParseMode.MARKDOWN
         )
-    except:
+    except Exception:
         pass

Thunder/bot/plugins/callbacks.py

@@ -1,8 +1,7 @@
-"""
-Thunder/bot/plugins/callbacks.py - Callback query handlers for Thunder bot.
-"""
+# Thunder/bot/plugins/callbacks.py
 
 import uuid
+
 from pyrogram import Client, filters, StopPropagation
 from pyrogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, LinkPreviewOptions
 from pyrogram.errors import MessageNotModified
@@ -11,29 +10,25 @@ from Thunder.vars import Var
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import *
 from Thunder.utils.decorators import owner_only
+from Thunder.utils.retry_api import retry_get_chat
 
-# Helper Functions
 async def handle_callback_error(callback_query, error, operation="callback"):
-    """Standardized error handling for callback queries."""
     error_id = uuid.uuid4().hex[:8]
     logger.error(f"Error in {operation}: {error}")
     await callback_query.answer(
-        MSG_ERROR_GENERIC_CALLBACK.format(error_id=error_id), 
+        MSG_ERROR_GENERIC_CALLBACK.format(error_id=error_id),
         show_alert=True
     )
 
 async def get_force_channel_button(client):
-    """Get force channel button if configured."""
     if not Var.FORCE_CHANNEL_ID:
         return None
-    
     try:
-        chat = await client.get_chat(Var.FORCE_CHANNEL_ID)
+        chat = await retry_get_chat(client, Var.FORCE_CHANNEL_ID)
         invite_link = chat.invite_link or (f"https://t.me/{chat.username}" if chat.username else None)
-        
         if invite_link:
             return [InlineKeyboardButton(
-                MSG_BUTTON_JOIN_CHANNEL.format(channel_title=chat.title), 
+                MSG_BUTTON_JOIN_CHANNEL.format(channel_title=chat.title),
                 url=invite_link
             )]
         else:
@@ -43,32 +38,21 @@ async def get_force_channel_button(client):
         logger.error(f"Error creating force channel button: {e}")
         return None
 
-# Callback Handlers
 @StreamBot.on_callback_query(filters.regex(r"^help_command$"))
 async def help_callback(client: Client, callback_query: CallbackQuery):
-    """Handler for Help button."""
     try:
         await callback_query.answer()
-        
-        # Build buttons list - About button first
         buttons = [[InlineKeyboardButton(MSG_BUTTON_ABOUT, callback_data="about_command")]]
-        
-        # Add force channel button if configured
         force_button = await get_force_channel_button(client)
         if force_button:
             buttons.append(force_button)
-        
-        # Add close button at the end
         buttons.append([InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")])
-        
         await callback_query.message.edit_text(
             text=MSG_HELP,
             reply_markup=InlineKeyboardMarkup(buttons),
             link_preview_options=LinkPreviewOptions(is_disabled=True)
         )
-        
         logger.debug(f"User {callback_query.from_user.id} accessed help panel.")
-        
     except MessageNotModified:
         logger.debug(f"Help panel already displayed for user {callback_query.from_user.id}")
     except Exception as e:
@@ -78,24 +62,19 @@ async def help_callback(client: Client, callback_query: CallbackQuery):
 
 @StreamBot.on_callback_query(filters.regex(r"^about_command$"))
 async def about_callback(client: Client, callback_query: CallbackQuery):
-    """Handler for About button."""
     try:
         await callback_query.answer()
-
         buttons = [
             [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")],
             [InlineKeyboardButton(MSG_BUTTON_GITHUB, url="https://github.com/fyaz05/FileToLink"),
              InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
         ]
-        
         await callback_query.message.edit_text(
             text=MSG_ABOUT,
             reply_markup=InlineKeyboardMarkup(buttons),
             link_preview_options=LinkPreviewOptions(is_disabled=True)
         )
-        
         logger.debug(f"User {callback_query.from_user.id} accessed about panel.")
-        
     except MessageNotModified:
         logger.debug(f"About panel already displayed for user {callback_query.from_user.id}")
     except Exception as e:
@@ -106,24 +85,18 @@ async def about_callback(client: Client, callback_query: CallbackQuery):
 @StreamBot.on_callback_query(filters.regex(r"^restart_broadcast$"))
 @owner_only
 async def restart_broadcast_callback(client: Client, callback_query: CallbackQuery):
-    """Handler for Restart Broadcast button."""
     try:
         await callback_query.answer(MSG_ERROR_BROADCAST_RESTART, show_alert=True)
-        
-        # Create back and close buttons
         buttons = [
             [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command"),
              InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
         ]
-        
         await callback_query.message.edit_text(
             MSG_ERROR_BROADCAST_INSTRUCTION,
             reply_markup=InlineKeyboardMarkup(buttons),
             link_preview_options=LinkPreviewOptions(is_disabled=True)
         )
-        
         logger.debug(f"User {callback_query.from_user.id} viewed broadcast restart instruction.")
-        
     except Exception as e:
         await handle_callback_error(callback_query, e, "restart_broadcast_callback")
     finally:
@@ -131,15 +104,10 @@ async def restart_broadcast_callback(client: Client, callback_query: CallbackQue
 
 @StreamBot.on_callback_query(filters.regex(r"^close_panel$"))
 async def close_panel_callback(client: Client, callback_query: CallbackQuery):
-    """Handler for Close button - deletes current panel and command message."""
     try:
         await callback_query.answer()
-        
-        # Delete the current panel message
         await callback_query.message.delete()
         logger.debug(f"User {callback_query.from_user.id} closed panel")
-        
-        # Clean up original command message and replies
         if callback_query.message.reply_to_message:
             try:
                 ctx = callback_query.message.reply_to_message
@@ -148,16 +116,13 @@ async def close_panel_callback(client: Client, callback_query: CallbackQuery):
                     await ctx.reply_to_message.delete()
             except Exception as e:
                 logger.warning(f"Error deleting command messages: {e}")
-                
     except Exception as e:
         await handle_callback_error(callback_query, e, "close_panel_callback")
     finally:
         raise StopPropagation
 
-# Fallback handler for unmatched callback queries
 @StreamBot.on_callback_query(group=999)
 async def fallback_callback(client: Client, callback_query: CallbackQuery):
-    """Fallback handler for any unmatched callback query."""
     try:
         logger.debug(f"Unhandled callback query: {callback_query.data} from user {callback_query.from_user.id}")
         await callback_query.answer(MSG_ERROR_CALLBACK_UNSUPPORTED, show_alert=True)

Thunder/bot/plugins/common.py

@@ -1,25 +1,21 @@
-"""
-Thunder/bot/plugins/common.py - Common plugin handlers and helpers for Thunder bot.
-"""
+# Thunder/bot/plugins/common.py
 
 import time
 import asyncio
 import uuid
 from typing import Tuple, Optional
 from urllib.parse import quote_plus
-
 from pyrogram import filters, StopPropagation
 from pyrogram.client import Client
 from pyrogram.errors import RPCError, MessageNotModified
 from pyrogram.types import (
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Message,
-    User,
-    CallbackQuery,
-    LinkPreviewOptions
+InlineKeyboardButton,
+InlineKeyboardMarkup,
+Message,
+User,
+CallbackQuery,
+LinkPreviewOptions
 )
-
 from Thunder.bot import StreamBot
 from Thunder.vars import Var
 from Thunder.utils.database import db
@@ -31,33 +27,29 @@ from Thunder.utils.logger import logger
 from Thunder.utils.tokens import get, check, validate_activation_token
 from Thunder.utils.decorators import check_banned
 from Thunder.utils.bot_utils import (
-    notify_channel,
-    log_new_user,
-    generate_media_links,
-    handle_user_error,
-    generate_dc_text,
-    get_user_safely
+notify_channel,
+log_new_user,
+generate_media_links,
+handle_user_error,
+generate_dc_text,
+get_user_safely
 )
 
 def has_media(message):
-    """Check if message contains media"""
     return any(
         hasattr(message, attr) and getattr(message, attr)
         for attr in ["document", "photo", "video", "audio", "voice",
                     "sticker", "animation", "video_note"]
     )
 
-# ====== COMMAND HANDLERS ======
-
 @check_banned
 @StreamBot.on_message(filters.command("start") & filters.private)
 async def start_command(bot: Client, message: Message):
     try:
         user_id_str = str(message.from_user.id) if message.from_user else 'unknown'
-        
         if message.from_user:
             await log_new_user(bot, message.from_user.id, message.from_user.first_name)
-
+        
         if len(message.command) == 2:
             token = message.command[1]
             try:
@@ -117,7 +109,6 @@ async def start_command(bot: Client, message: Message):
                     else:
                         logger.warning(f"(ID: {error_id_context}) Could not retrieve invite link for FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID} for /start message text (Channel: {chat_title}, User: {user_id_str}).")
                         welcome_text += f"\n\n{MSG_COMMUNITY_CHANNEL.format(channel_title=chat_title)}"
-                        
                 except asyncio.TimeoutError as e_timeout:
                     logger.error(f"(ID: {error_id_context}) Timeout fetching Force Channel details for /start text (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_timeout}")
                     welcome_text += f"\n\n{MSG_DEFAULT_WELCOME}"
@@ -154,7 +145,6 @@ async def start_command(bot: Client, message: Message):
                         reply_markup.inline_keyboard.append([InlineKeyboardButton(MSG_BUTTON_JOIN_CHANNEL.format(channel_title=chat_title), url=invite_link)])
                     else:
                         logger.warning(f"(ID: {error_id_context_button}) Could not retrieve invite link for FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID} for /start message button (Channel: {chat_title}, User: {user_id_str}).")
-                        
                 except asyncio.TimeoutError as e_timeout_btn:
                     logger.error(f"(ID: {error_id_context_button}) Timeout fetching Force Channel details for /start button (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_timeout_btn}")
                 except RPCError as e_rpc_btn:
@@ -168,22 +158,17 @@ async def start_command(bot: Client, message: Message):
         payload = parts[1]
         try:
             msg_id = int(payload)
-            
-            # Ensure file_msg is a single Message object
             retrieved_messages = await bot.get_messages(chat_id=Var.BIN_CHANNEL, message_ids=msg_id)
             if not retrieved_messages:
                 await handle_user_error(message, MSG_ERROR_FILE_INVALID)
                 return
             
-            # If get_messages returns a list, take the first one.
             file_msg = retrieved_messages[0] if isinstance(retrieved_messages, list) else retrieved_messages
-            
             if not file_msg:
                 await handle_user_error(message, MSG_ERROR_FILE_INVALID)
                 return
 
             stream_link, download_link, file_name, file_size = await generate_media_links(file_msg)
-            
             reply_text = MSG_LINKS.format(
                 file_name=file_name,
                 file_size=file_size,
@@ -202,13 +187,11 @@ async def start_command(bot: Client, message: Message):
                 quote=True,
                 link_preview_options=LinkPreviewOptions(is_disabled=True)
             )
-
         except ValueError:
             await handle_user_error(message, MSG_ERROR_FILE_INVALID_ID)
         except Exception as e:
             logger.error(f"Error processing /start with payload: {e}")
             await handle_user_error(message, MSG_FILE_ACCESS_ERROR)
-
     except Exception as e:
         logger.error(f"Error in start_command: {e}")
         await handle_user_error(message, MSG_ERROR_GENERIC)
@@ -218,7 +201,6 @@ async def start_command(bot: Client, message: Message):
 async def help_command(bot: Client, message: Message):
     try:
         user_id_str = str(message.from_user.id) if message.from_user else 'unknown'
-        
         if message.from_user:
             await log_new_user(bot, message.from_user.id, message.from_user.first_name)
 
@@ -244,7 +226,6 @@ async def help_command(bot: Client, message: Message):
                     ])
                 else:
                     logger.warning(f"(ID: {error_id_context_help}) Could not retrieve or construct invite link for FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID} for /help command (User: {user_id_str}).")
-                    
             except Exception as e_help:
                 logger.error(f"(ID: {error_id_context_help}) Error adding force channel button to /help command (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_help}")
 
@@ -257,7 +238,6 @@ async def help_command(bot: Client, message: Message):
             quote=True,
             link_preview_options=LinkPreviewOptions(is_disabled=True)
         )
-
     except Exception as e:
         logger.error(f"Error in help_command: {e}")
         await handle_user_error(message, MSG_ERROR_GENERIC)
@@ -275,7 +255,6 @@ async def about_command(bot: Client, message: Message):
             [InlineKeyboardButton(MSG_BUTTON_GITHUB, url="https://github.com/fyaz05/FileToLink"),
              InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
         ]
-
         reply_markup = InlineKeyboardMarkup(buttons)
 
         await message.reply_text(
@@ -284,7 +263,6 @@ async def about_command(bot: Client, message: Message):
             quote=True,
             link_preview_options=LinkPreviewOptions(is_disabled=True)
         )
-
     except Exception as e:
         logger.error(f"Error in about_command: {e}")
         await handle_user_error(message, MSG_ERROR_GENERIC)
@@ -294,7 +272,6 @@ async def about_command(bot: Client, message: Message):
 @StreamBot.on_message(filters.command("dc"))
 async def dc_command(bot: Client, message: Message):
     try:
-        # Early exit conditions
         if not message.from_user and not message.reply_to_message:
             await handle_user_error(message, MSG_DC_ANON_ERROR)
             return
@@ -302,18 +279,20 @@ async def dc_command(bot: Client, message: Message):
         async def process_dc_info(user: User):
             dc_text = await generate_dc_text(user)
             buttons = []
+            
             if user.username:
                 profile_url = f"https://t.me/{user.username}"
             else:
                 profile_url = f"tg://user?id={user.id}"
+            
             buttons.append([
                 InlineKeyboardButton(MSG_BUTTON_VIEW_PROFILE, url=profile_url)
             ])
             buttons.append([
                 InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")
             ])
+            
             dc_keyboard = InlineKeyboardMarkup(buttons)
-
             await message.reply_text(
                 dc_text,
                 reply_markup=dc_keyboard,
@@ -325,6 +304,7 @@ async def dc_command(bot: Client, message: Message):
             try:
                 file_name = get_name(file_msg) or "Untitled File"
                 file_size = humanbytes(get_media_file_size(file_msg))
+                
                 file_type_map = {
                     "document": MSG_FILE_TYPE_DOCUMENT,
                     "photo": MSG_FILE_TYPE_PHOTO,
@@ -335,10 +315,10 @@ async def dc_command(bot: Client, message: Message):
                     "animation": MSG_FILE_TYPE_ANIMATION,
                     "video_note": MSG_FILE_TYPE_VIDEO_NOTE
                 }
-
+                
                 file_type_attr = next((attr for attr in file_type_map if getattr(file_msg, attr, None)), "unknown")
                 file_type_display = file_type_map.get(file_type_attr, MSG_FILE_TYPE_UNKNOWN)
-
+                
                 actual_media = None
                 if file_type_attr == "photo" and file_msg.photo and file_msg.photo.sizes:
                     actual_media = file_msg.photo.sizes[-1]
@@ -346,18 +326,19 @@ async def dc_command(bot: Client, message: Message):
                     potential = getattr(file_msg, file_type_attr, None)
                     if potential:
                         actual_media = potential
-
+                
                 dc_id = MSG_DC_UNKNOWN
                 if hasattr(file_msg, 'raw') and hasattr(file_msg.raw, 'media'):
                     if hasattr(file_msg.raw.media, 'document') and hasattr(file_msg.raw.media.document, 'dc_id'):
                         dc_id = file_msg.raw.media.document.dc_id
-
+                
                 dc_text = MSG_DC_FILE_INFO.format(
                     file_name=file_name,
                     file_size=file_size,
                     file_type=file_type_display,
                     dc_id=dc_id
                 )
+                
                 await message.reply_text(
                     dc_text,
                     quote=True,
@@ -367,7 +348,6 @@ async def dc_command(bot: Client, message: Message):
                 logger.error(f"Error processing file info for DC command: {e}")
                 await handle_user_error(message, MSG_DC_FILE_ERROR)
 
-        # If DC command has an argument, treat it as user lookup
         args = message.text.strip().split(maxsplit=1)
         if len(args) > 1:
             query = args[1].strip()
@@ -378,7 +358,6 @@ async def dc_command(bot: Client, message: Message):
                 await handle_user_error(message, MSG_ERROR_USER_INFO)
             return
 
-        # Handle replied message cases
         if message.reply_to_message:
             if has_media(message.reply_to_message):
                 await process_file_dc_info(message.reply_to_message)
@@ -390,12 +369,10 @@ async def dc_command(bot: Client, message: Message):
                 await handle_user_error(message, MSG_DC_INVALID_USAGE)
                 return
 
-        # Otherwise, show info for the command sender
         if message.from_user:
             await process_dc_info(message.from_user)
         else:
             await handle_user_error(message, MSG_DC_ANON_ERROR)
-
     except Exception as e:
         logger.error(f"Error in dc_command: {e}")
         await handle_user_error(message, MSG_ERROR_GENERIC)
@@ -409,6 +386,7 @@ async def ping_command(bot: Client, message: Message):
         sent_msg = await message.reply_text(MSG_PING_START, quote=True, link_preview_options=LinkPreviewOptions(is_disabled=True))
         end_time = time.time()
         time_taken_ms = (end_time - start_time) * 1000
+        
         buttons = [
             [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command"),
              InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
@@ -423,10 +401,7 @@ async def ping_command(bot: Client, message: Message):
         logger.error(f"Error in ping_command: {e}")
         await handle_user_error(message, MSG_ERROR_GENERIC)
 
-# ====== CALLBACK HANDLERS ======
-
 async def handle_callback_error(callback_query, error, operation="callback"):
-    """Standardized error handling for callback queries."""
     error_id = uuid.uuid4().hex[:8]
     logger.error(f"Error in {operation}: {error}")
     try:
@@ -439,7 +414,6 @@ async def handle_callback_error(callback_query, error, operation="callback"):
 
 @StreamBot.on_callback_query(filters.regex(r"^close_panel$"))
 async def close_panel_callback(client: Client, callback_query: CallbackQuery):
-    """Handler for Close button - deletes current panel and command message."""
     try:
         await callback_query.answer()
         await callback_query.message.delete()
@@ -451,7 +425,6 @@ async def close_panel_callback(client: Client, callback_query: CallbackQuery):
                     await ctx.reply_to_message.delete()
             except Exception as e:
                 logger.warning(f"Error deleting command messages: {e}")
-                
     except Exception as e:
         await handle_callback_error(callback_query, e, "close_panel_callback")
     finally:

Thunder/bot/plugins/stream.py

@@ -1,6 +1,4 @@
-"""
-Thunder/bot/plugins/stream.py - Streaming and file link plugin handlers for Thunder bot.
-"""
+# Thunder/bot/plugins/stream.py
 
 import time
 import asyncio
@@ -9,9 +7,7 @@ import uuid
 from urllib.parse import quote
 from typing import Optional, Tuple, Dict, Union, List, Set
 from datetime import datetime, timedelta
-
-from pyrogram.client import Client
-from pyrogram import filters, enums
+from pyrogram import Client, filters, enums
 from pyrogram.errors import (
     FloodWait,
     RPCError,
@@ -20,15 +16,14 @@ from pyrogram.errors import (
     FileReferenceInvalid,
     MessageNotModified
 )
-
 from pyrogram.types import (
     InlineKeyboardMarkup,
     InlineKeyboardButton,
+    InlineKeyboardMarkup,
     Message,
     CallbackQuery,
     LinkPreviewOptions
 )
-
 from pyrogram.enums import ChatMemberStatus
 from Thunder.bot import StreamBot
 from Thunder.utils.database import db
@@ -49,7 +44,6 @@ from Thunder.utils.bot_utils import (
     check_admin_privileges
 )
 
-
 class LRUCache:
     def __init__(self, max_size=1000, ttl=86400):
         self.cache = {}
@@ -59,205 +53,105 @@ class LRUCache:
         self._lock = asyncio.Lock()
 
     async def get(self, key):
-        if key is None:
-            return None
-        
         async with self._lock:
             if key not in self.cache:
                 return None
-            
             item = self.cache[key]
             if time.time() - item['timestamp'] > self.ttl:
-                self._remove_item(key)
+                del self.cache[key]
+                self.access_order.remove(key)
                 return None
-            
-            self._update_access_order(key)
-            return item
-
-    def _update_access_order(self, key):
-        try:
             self.access_order.remove(key)
-        except ValueError:
-            pass
-        self.access_order.append(key)
-
-    def _remove_item(self, key):
-        try:
-            del self.cache[key]
-            self.access_order.remove(key)
-        except (KeyError, ValueError):
-            pass
+            self.access_order.append(key)
+            return item
 
     async def set(self, key, value):
-        if key is None or not isinstance(value, dict):
-            return
-        
         async with self._lock:
             if key in self.cache:
-                self._update_access_order(key)
+                self.access_order.remove(key)
             elif len(self.cache) >= self.max_size:
-                lru_key = self.access_order[0]
-                self._remove_item(lru_key)
-            
+                lru_key = self.access_order.pop(0)
+                del self.cache[lru_key]
             self.cache[key] = value
-            self._update_access_order(key)
+            self.access_order.append(key)
+
+    async def delete(self, key):
+        async with self._lock:
+            if key in self.cache:
+                del self.cache[key]
+                self.access_order.remove(key)
 
     async def clean_expired(self):
         count = 0
         current_time = time.time()
-        
         async with self._lock:
-            keys_to_remove = []
-            for key in self.cache:
+            for key in list(self.cache.keys()):
                 if current_time - self.cache[key]['timestamp'] > self.ttl:
-                    keys_to_remove.append(key)
-            
-            for key in keys_to_remove:
-                self._remove_item(key)
-                count += 1
-        
+                    del self.cache[key]
+                    self.access_order.remove(key)
+                    count += 1
         return count
 
-
-# Initialize cache
 CACHE = LRUCache(max_size=getattr(Var, "CACHE_SIZE", 1000), ttl=86400)
 
-
-async def clean_cache_task():
-    while True:
-        try:
-            cleaned_count = await CACHE.clean_expired()
-            if cleaned_count > 0:
-                logger.info(f"Cache cleanup: Removed {cleaned_count} expired items")
-            await asyncio.sleep(3600)
-        except Exception as e:
-            logger.error(f"Error in cache cleaning task: {e}")
-            await asyncio.sleep(60)
-
-
 class RateLimiter:
     def __init__(self, max_calls, time_period):
         self.max_calls = max_calls
         self.time_period = time_period
         self.calls = {}
         self._lock = asyncio.Lock()
-        self._cleanup_task = None
-        self._stopping = False
-
-    def start_cleanup_task(self):
-        if self._cleanup_task is None or self._cleanup_task.done():
-            self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
-            self._cleanup_task.add_done_callback(self._cleanup_task_done)
-
-    def stop_cleanup_task(self):
-        self._stopping = True
-        if self._cleanup_task and not self._cleanup_task.done():
-            self._cleanup_task.cancel()
-
-    def _cleanup_task_done(self, task):
-        try:
-            task.result()
-        except asyncio.CancelledError:
-            pass
-        except Exception as e:
-            logger.error(f"Error in rate limiter cleanup task: {e}")
-            if not self._stopping:
-                asyncio.create_task(self._delayed_restart())
-
-    async def _delayed_restart(self):
-        await asyncio.sleep(5)
-        if not self._stopping:
-            self.start_cleanup_task()
-
-    async def _periodic_cleanup(self):
-        while not self._stopping:
-            try:
-                await asyncio.sleep(60)
-                await self._cleanup_old_entries()
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.error(f"Error in periodic cleanup: {e}")
-                await asyncio.sleep(30)
-
-    async def _cleanup_old_entries(self):
-        now = time.time()
-        async with self._lock:
-            for user_id in list(self.calls.keys()):
-                self.calls[user_id] = [ts for ts in self.calls[user_id]
-                                     if now - ts <= self.time_period]
-                if not self.calls[user_id]:
-                    del self.calls[user_id]
 
     async def is_rate_limited(self, user_id):
-        if user_id is None:
-            return False
-        
         async with self._lock:
             now = time.time()
             if user_id not in self.calls:
                 self.calls[user_id] = []
-            
             self.calls[user_id] = [
                 ts for ts in self.calls[user_id]
                 if now - ts <= self.time_period
             ]
-            
             if len(self.calls[user_id]) >= self.max_calls:
                 return True
-            
             self.calls[user_id].append(now)
             return False
 
     async def get_reset_time(self, user_id):
-        if user_id is None:
-            return 0
-        
         async with self._lock:
             if user_id not in self.calls or not self.calls[user_id]:
                 return 0
-            
             now = time.time()
             oldest_call = min(self.calls[user_id])
             return max(0, self.time_period - (now - oldest_call))
 
-
-# Initialize rate limiter
 rate_limiter = RateLimiter(max_calls=20, time_period=60)
 
-
-# Helper Functions
 async def handle_flood_wait(e):
     wait_time = e.value
-    logger.debug(f"FloodWait encountered. Sleeping for {wait_time} seconds.")
-    jitter = random.uniform(0, 0.05 * wait_time)
-    await asyncio.sleep(wait_time + jitter)
-
+    logger.warning(f"FloodWait encountered. Sleeping for {wait_time} seconds.")
+    jitter = random.uniform(0, 0.1 * wait_time)
+    await asyncio.sleep(wait_time + jitter + 1)
 
 def get_file_unique_id(media_message):
     media_types = [
         'document', 'video', 'audio', 'photo', 'animation',
         'voice', 'video_note', 'sticker'
     ]
-    
     for media_type in media_types:
         media = getattr(media_message, media_type, None)
         if media:
             return media.file_unique_id
-    
     return None
 
-
 async def forward_media(media_message):
     for retry in range(3):
         try:
             result = await media_message.copy(chat_id=Var.BIN_CHANNEL)
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(0.2)
             return result
         except Exception:
             try:
                 result = await media_message.forward(chat_id=Var.BIN_CHANNEL)
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(0.2)
                 return result
             except FloodWait as flood_error:
                 if retry < 2:
@@ -269,17 +163,22 @@ async def forward_media(media_message):
                     logger.error(f"Error forwarding media: {forward_error}")
                     raise
                 await asyncio.sleep(0.5)
-    
     raise Exception("Failed to forward media after multiple attempts")
 
-
 async def log_request(log_msg, user, stream_link, online_link):
     try:
-        user_name = user.first_name if hasattr(user, 'first_name') else user.title
+        if getattr(user, 'title', None):
+            source_info = f"{user.title} (Chat/Channel)"
+        else:
+            first = getattr(user, 'first_name', '') or ''
+            last = getattr(user, 'last_name', '') or ''
+            display_name = f"{first} {last}".strip() or "Unknown"
+            source_info = f"{display_name}"
+        id_ = user.id
         await log_msg.reply_text(
             MSG_NEW_FILE_REQUEST.format(
-                user_name=user_name,
-                user_id=user.id,
+                source_info=source_info,
+                id_=id_,
                 online_link=online_link,
                 stream_link=stream_link
             ),
@@ -290,17 +189,14 @@ async def log_request(log_msg, user, stream_link, online_link):
     except Exception:
         pass
 
-
 async def process_media_message(client, command_message, media_message, notify=True, shortener=True):
     retries = 0
     max_retries = 3
     cache_key = get_file_unique_id(media_message)
-    
     if cache_key is None:
         if notify:
             await command_message.reply_text(MSG_ERROR_FILE_ID_EXTRACT, quote=True)
         return None
-
     cached_data = await CACHE.get(cache_key)
     if cached_data:
         if notify:
@@ -313,12 +209,10 @@ async def process_media_message(client, command_message, media_message, notify=T
                 cached_data['online_link']
             )
         return cached_data['online_link']
-
     while retries < max_retries:
         try:
             log_msg = await forward_media(media_message)
             stream_link, online_link, media_name, media_size = await generate_media_links(log_msg, shortener=shortener)
-            
             await CACHE.set(cache_key, {
                 'media_name': media_name,
                 'media_size': media_size,
@@ -327,7 +221,6 @@ async def process_media_message(client, command_message, media_message, notify=T
                 'message_id': log_msg.id,
                 'timestamp': time.time()
             })
-            
             if notify:
                 await send_links_to_user(
                     client,
@@ -337,10 +230,8 @@ async def process_media_message(client, command_message, media_message, notify=T
                     stream_link,
                     online_link
                 )
-            
             await log_request(log_msg, command_message.from_user, stream_link, online_link)
             return online_link
-            
         except FloodWait as e:
             await handle_flood_wait(e)
             retries += 1
@@ -359,22 +250,18 @@ async def process_media_message(client, command_message, media_message, notify=T
                 retries += 1
                 await asyncio.sleep(0.3)
                 continue
-            
             if notify:
                 await handle_user_error(
                     command_message,
                     MSG_ERROR_PROCESSING_MEDIA
                 )
-            
             await notify_owner(
                 client,
                 MSG_CRITICAL_ERROR.format(error=e, error_id=uuid.uuid4().hex[:8])
             )
             return None
-    
     return None
 
-
 async def retry_failed_media(client, command_message, media_messages, status_msg=None, shortener=True):
     results = []
     for i, msg in enumerate(media_messages):
@@ -382,7 +269,6 @@ async def retry_failed_media(client, command_message, media_messages, status_msg
             result = await process_media_message(client, command_message, msg, notify=False, shortener=shortener)
             if result:
                 results.append(result)
-            
             if status_msg and i % 2 == 0:
                 try:
                     await status_msg.edit(f"🔄 **Retrying Failed Files:** {len(results)}/{len(media_messages)} processed")
@@ -390,24 +276,36 @@ async def retry_failed_media(client, command_message, media_messages, status_msg
                     pass
         except Exception as e:
             logger.error(f"Error retrying media: {e}")
-    
     return results
 
-
 async def process_multiple_messages(client, command_message, reply_msg, num_files, status_msg, shortener=True):
     chat_id = command_message.chat.id
     start_message_id = reply_msg.id
     end_message_id = start_message_id + num_files - 1
     message_ids = list(range(start_message_id, end_message_id + 1))
-    
-    batch_size = 10
-    processed_count = 0
-    failed_count = 0
-    download_links = []
-    failed_messages = []
     last_status_text = ""
-
     try:
+        batch_size = 5
+        processed_count = 0
+        failed_count = 0
+        download_links = []
+        failed_messages = []
+
+        async def process_single_message(msg):
+            try:
+                return await process_media_message(
+                    client,
+                    command_message,
+                    msg,
+                    notify=False
+                )
+            except FloodWait as e:
+                await handle_flood_wait(e)
+                return await process_media_message(client, command_message, msg, notify=False)
+            except Exception as e:
+                logger.error(f"Message {msg.id} error: {e}")
+                return None
+
         for i in range(0, len(message_ids), batch_size):
             batch_ids = message_ids[i:i+batch_size]
             new_status_text = MSG_PROCESSING_BATCH.format(
@@ -415,16 +313,13 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
                 total_batches=(len(message_ids)+batch_size-1)//batch_size,
                 file_count=len(batch_ids)
             )
-            
             if new_status_text != last_status_text:
                 try:
                     await status_msg.edit(new_status_text)
                     last_status_text = new_status_text
                 except MessageNotModified:
                     pass
-            
             await asyncio.sleep(1.0)
-            
             messages = []
             for retry in range(3):
                 try:
@@ -439,14 +334,12 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
                     if retry == 2:
                         logger.error(f"Failed to get batch {i//batch_size+1}: {e}")
                     await asyncio.sleep(0.5)
-            
             for msg in messages:
                 if msg and msg.media:
                     try:
                         result = await process_media_message(
                             client, command_message, msg, notify=False, shortener=shortener
                         )
-                        
                         if result:
                             download_links.append(result)
                             processed_count += 1
@@ -457,16 +350,13 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
                         failed_count += 1
                         failed_messages.append(msg)
                         logger.error(f"Failed to process {msg.id}: {e}")
-                
                 await asyncio.sleep(1.0)
-            
             if processed_count % 5 == 0 or processed_count + failed_count == len(message_ids):
                 new_status_text = MSG_PROCESSING_STATUS.format(
                     processed=processed_count,
                     total=num_files,
                     failed=failed_count
                 )
-                
                 if new_status_text != last_status_text:
                     try:
                         await status_msg.edit(new_status_text)
@@ -474,7 +364,6 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
                     except MessageNotModified:
                         pass
 
-        # Handle retries for failed messages
         if failed_messages and len(failed_messages) < num_files / 2:
             new_status_text = MSG_RETRYING_FILES.format(count=len(failed_messages))
             if new_status_text != last_status_text:
@@ -483,32 +372,23 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
                     last_status_text = new_status_text
                 except MessageNotModified:
                     pass
-            
             retry_results = await retry_failed_media(
                 client, command_message, failed_messages, status_msg, shortener
             )
-            
             if retry_results:
                 download_links.extend(retry_results)
                 processed_count += len(retry_results)
                 failed_count -= len(retry_results)
 
-        # Send batch links to user
         def chunk_list(lst, n):
             for i in range(0, len(lst), n):
                 yield lst[i:i + n]
 
         for chunk in chunk_list(download_links, 20):
             links_text = "\n".join(chunk)
-            
-            # Message for the group chat
             group_message_content = MSG_BATCH_LINKS_READY.format(count=len(chunk)) + f"\n\n`{links_text}`"
-            
-            # Message for the user's DM
             dm_prefix = MSG_DM_BATCH_PREFIX.format(chat_title=command_message.chat.title)
             dm_message_text = f"{dm_prefix}\n{group_message_content}"
-
-            # Send to original chat (group/supergroup)
             try:
                 await command_message.reply_text(
                     group_message_content,
@@ -518,8 +398,6 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
                 )
             except Exception as e:
                 logger.error(f"Error sending batch links to original chat {command_message.chat.id}: {e}")
-
-            # Send to user's DM (if in a group/supergroup)
             if command_message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
                 try:
                     await client.send_message(
@@ -534,24 +412,20 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
                         MSG_ERROR_DM_FAILED,
                         quote=True
                     )
-            
             if len(chunk) > 10:
                 await asyncio.sleep(0.5)
 
-        # Update final status
         new_status_text = MSG_PROCESSING_RESULT.format(
             processed=processed_count,
             total=num_files,
             failed=failed_count
         )
-        
         if new_status_text != last_status_text:
             try:
                 await status_msg.edit(new_status_text)
                 last_status_text = new_status_text
             except MessageNotModified:
                 pass
-
     except Exception as e:
         logger.error(f"Error in batch processing: {e}")
         new_status_text = MSG_PROCESSING_ERROR.format(
@@ -560,7 +434,6 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
             total=num_files,
             error_id=uuid.uuid4().hex[:8]
         )
-        
         if new_status_text != last_status_text:
             try:
                 await status_msg.edit(new_status_text)
@@ -568,7 +441,6 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
             except MessageNotModified:
                 pass
 
-
 @StreamBot.on_message(filters.command("link") & ~filters.private)
 @check_banned
 @require_token
@@ -576,7 +448,6 @@ async def process_multiple_messages(client, command_message, reply_msg, num_file
 @force_channel_check
 async def link_handler(client, message, shortener=True):
     user_id = message.from_user.id
-    
     if not await db.is_user_exist(user_id):
         try:
             invite_link = f"https://t.me/{client.me.username}?start=start"
@@ -590,7 +461,6 @@ async def link_handler(client, message, shortener=True):
         except Exception:
             pass
         return
-
     if await rate_limiter.is_rate_limited(user_id):
         reset_time = await rate_limiter.get_reset_time(user_id)
         await message.reply_text(
@@ -598,7 +468,6 @@ async def link_handler(client, message, shortener=True):
             quote=True
         )
         return
-
     if message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
         is_admin = await check_admin_privileges(client, message.chat.id)
         if not is_admin:
@@ -607,14 +476,12 @@ async def link_handler(client, message, shortener=True):
                 quote=True
             )
             return
-
     if not message.reply_to_message:
         await message.reply_text(
             MSG_ERROR_REPLY_FILE,
             quote=True
         )
         return
-
     reply_msg = message.reply_to_message
     if not reply_msg.media:
         await message.reply_text(
@@ -622,10 +489,8 @@ async def link_handler(client, message, shortener=True):
             quote=True
         )
         return
-
     command_parts = message.text.strip().split()
     num_files = 1
-    
     if len(command_parts) > 1:
         try:
             num_files = int(command_parts[1])
@@ -641,12 +506,10 @@ async def link_handler(client, message, shortener=True):
                 quote=True
             )
             return
-
     processing_msg = await message.reply_text(
         MSG_PROCESSING_REQUEST,
         quote=True
     )
-
     try:
         if num_files == 1:
             result = await process_media_message(client, message, reply_msg, shortener=shortener)
@@ -684,7 +547,6 @@ async def link_handler(client, message, shortener=True):
                             MSG_ERROR_DM_FAILED,
                             quote=True
                         )
-                
                 await processing_msg.delete()
             else:
                 try:
@@ -693,7 +555,6 @@ async def link_handler(client, message, shortener=True):
                     pass
         else:
             await process_multiple_messages(client, message, reply_msg, num_files, processing_msg, shortener)
-
     except Exception as e:
         logger.error(f"Error handling link command: {e}")
         try:
@@ -701,7 +562,6 @@ async def link_handler(client, message, shortener=True):
         except MessageNotModified:
             pass
 
-
 @StreamBot.on_message(
     filters.private & filters.incoming & (
         filters.document | filters.video | filters.photo | filters.audio |
@@ -716,7 +576,6 @@ async def link_handler(client, message, shortener=True):
 async def private_receive_handler(client, message, shortener=True):
     if not message.from_user:
         return
-
     if await rate_limiter.is_rate_limited(message.from_user.id):
         reset_time = await rate_limiter.get_reset_time(message.from_user.id)
         await message.reply_text(
@@ -724,18 +583,15 @@ async def private_receive_handler(client, message, shortener=True):
             quote=True
         )
         return
-
     await log_new_user(
         bot=client,
         user_id=message.from_user.id,
         first_name=message.from_user.first_name
     )
-
     processing_msg = await message.reply_text(
         MSG_PROCESSING_FILE,
         quote=True
     )
-
     try:
         result = await process_media_message(client, message, message, shortener=shortener)
         if result:
@@ -752,12 +608,11 @@ async def private_receive_handler(client, message, shortener=True):
         except MessageNotModified:
             pass
 
-
 @StreamBot.on_message(
     filters.channel & filters.incoming & (
         filters.document | filters.video | filters.photo | filters.audio |
         filters.voice | filters.animation | filters.video_note
-    ),
+    ) & ~filters.chat(Var.BIN_CHANNEL),
     group=-1
 )
 @shorten_link
@@ -765,7 +620,6 @@ async def channel_receive_handler(client, broadcast, shortener=True):
     if hasattr(Var, 'BANNED_CHANNELS') and int(broadcast.chat.id) in Var.BANNED_CHANNELS:
         await client.leave_chat(broadcast.chat.id)
         return
-
     can_edit = False
     try:
         member = await client.get_chat_member(broadcast.chat.id, client.me.id)
@@ -775,17 +629,13 @@ async def channel_receive_handler(client, broadcast, shortener=True):
         ]
     except Exception:
         can_edit = False
-
     retries = 0
     max_retries = 3
-    
     while retries < max_retries:
         try:
             log_msg = await forward_media(broadcast)
             stream_link, online_link, media_name, media_size = await generate_media_links(log_msg, shortener=shortener)
-            
             await log_request(log_msg, broadcast.chat, stream_link, online_link)
-            
             if can_edit:
                 try:
                     await client.edit_message_reply_markup(
@@ -800,9 +650,7 @@ async def channel_receive_handler(client, broadcast, shortener=True):
                     )
                 except Exception:
                     pass
-            
             break
-            
         except FloodWait as e:
             await handle_flood_wait(e)
             retries += 1
@@ -817,13 +665,18 @@ async def channel_receive_handler(client, broadcast, shortener=True):
                 retries += 1
                 await asyncio.sleep(0.5)
                 continue
-            
             await notify_owner(
                 client,
                 MSG_CRITICAL_ERROR.format(error=e, error_id=uuid.uuid4().hex[:8])
             )
             break
 
-# Start background tasks
+async def clean_cache_task():
+    while True:
+        try:
+            await asyncio.sleep(3600)
+            await CACHE.clean_expired()
+        except Exception as e:
+            logger.error(f"Error in cache cleaning task: {e}")
+
 StreamBot.loop.create_task(clean_cache_task())
-rate_limiter.start_cleanup_task()

Thunder/utils/bot_utils.py

@@ -1,24 +1,19 @@
 # Thunder/utils/bot_utils.py
 
 import asyncio
-import time
-import random
-import hashlib
-import uuid
 from typing import Optional, Tuple
-from urllib.parse import quote_plus, quote
+from urllib.parse import quote
 
 from pyrogram import Client, enums
-from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, User, CallbackQuery, LinkPreviewOptions
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, User, CallbackQuery, LinkPreviewOptions, ReplyParameters
 from pyrogram.enums import ChatMemberStatus
-from pyrogram.raw.functions.messages import DeleteHistory
-from pyrogram.errors import FloodWait, UserNotParticipant, PeerIdInvalid, ChannelPrivate, ChatAdminRequired, BadRequest
 
-from Thunder.bot import StreamBot
 from Thunder.vars import Var
 from Thunder.utils.database import db
 from Thunder.utils.human_readable import humanbytes
+from Thunder.utils.retry_api import retry_send_message
 from Thunder.utils.logger import logger
+from Thunder.utils.error_handling import log_errors
 from Thunder.utils.messages import (
     MSG_BUTTON_GET_HELP,
     MSG_NEW_USER,
@@ -26,99 +21,75 @@ from Thunder.utils.messages import (
     MSG_DC_USER_INFO,
     MSG_LINKS,
     MSG_BUTTON_STREAM_NOW,
-    MSG_BUTTON_DOWNLOAD,
-    MSG_ERROR_GENERIC_CALLBACK
+    MSG_BUTTON_DOWNLOAD
 )
 from Thunder.utils.file_properties import get_name, get_media_file_size, get_hash
 from Thunder.utils.shortener import shorten
 
-
+@log_errors
 async def notify_channel(bot: Client, text: str):
-    try:
-        if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
-            await bot.send_message(chat_id=Var.BIN_CHANNEL, text=text)
-    except Exception:
-        pass
+    if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
+        await bot.send_message(chat_id=Var.BIN_CHANNEL, text=text)
 
+@log_errors
 async def notify_owner(client: Client, text: str):
-    try:
-        owner_ids = Var.OWNER_ID
-        if isinstance(owner_ids, (list, tuple, set)):
-            tasks = [
-                client.send_message(chat_id=owner_id, text=text)
-                for owner_id in owner_ids
-            ]
-            results = await asyncio.gather(*tasks)
-            await asyncio.sleep(0.1)
-        else:
-            await client.send_message(chat_id=owner_ids, text=text)
-            await asyncio.sleep(0.1)
-        
-        if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
-            await client.send_message(chat_id=Var.BIN_CHANNEL, text=text)
-            await asyncio.sleep(0.1)
-    except Exception as e:
-        logger.error(f"Failed to send message to owner: {e}")
+    owner_ids = Var.OWNER_ID
+    tasks = [retry_send_message(client, oid, text) for oid in (owner_ids if isinstance(owner_ids, (list, tuple, set)) else [owner_ids])]
+    if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
+        tasks.append(retry_send_message(client, Var.BIN_CHANNEL, text))
+    await asyncio.gather(*tasks, return_exceptions=True)
 
+@log_errors
 async def handle_user_error(message: Message, error_msg: str):
-    try:
-        await message.reply_text(
-            error_msg,
-            quote=True,
-            link_preview_options=LinkPreviewOptions(is_disabled=True),
-            reply_markup=InlineKeyboardMarkup([
-                [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")]
-            ])
-        )
-    except Exception:
-        pass
+    await retry_send_message(
+        message._client,
+        message.chat.id,
+        error_msg,
+        reply_parameters=ReplyParameters(message_id=message.id),
+        link_preview_options=LinkPreviewOptions(is_disabled=True),
+        reply_markup=InlineKeyboardMarkup([
+            [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")]
+        ])
+    )
 
+@log_errors
 async def log_new_user(bot: Client, user_id: int, first_name: str):
-    try:
-        if not await db.is_user_exist(user_id): 
-            await db.add_user(user_id)
-            if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0: 
-                await bot.send_message(
-                    Var.BIN_CHANNEL,
-                    MSG_NEW_USER.format(
-                        first_name=first_name,
-                        user_id=user_id
-                    )
-                )
-    except Exception:
-        pass
+    if not await db.is_user_exist(user_id):
+        await db.add_user(user_id)
+        if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
+            await retry_send_message(
+                bot,
+                Var.BIN_CHANNEL,
+                MSG_NEW_USER.format(first_name=first_name, user_id=user_id)
+            )
 
+@log_errors
 async def generate_media_links(log_msg: Message, shortener: bool = True) -> Tuple[str, str, str, str]:
-    try:
-        base_url = Var.URL.rstrip("/")
-        
-        file_id = log_msg.id
-        
-        media_name = get_name(log_msg)
-        if isinstance(media_name, bytes):
-            media_name = media_name.decode('utf-8', errors='replace')
-        else:
-            media_name = str(media_name)
-        
-        media_size = humanbytes(get_media_file_size(log_msg))
-        file_name_encoded = quote(media_name)
-        hash_value = get_hash(log_msg)
-        
-        stream_link_raw = f"{base_url}/watch/{hash_value}{file_id}/{file_name_encoded}"
-        online_link_raw = f"{base_url}/{hash_value}{file_id}/{file_name_encoded}"
-        
-        stream_link = stream_link_raw
-        online_link = online_link_raw
-        
-        if shortener and getattr(Var, "SHORTEN_MEDIA_LINKS", False):
-            stream_link = await shorten(stream_link_raw)
-            online_link = await shorten(online_link_raw)
-        
-        return stream_link, online_link, media_name, media_size
-    except Exception as e:
-        logger.error(f"Error generating media links: {e}")
-        return "", "", "", ""
+    base_url = Var.URL.rstrip("/")
+    file_id = log_msg.id
+    media_name = get_name(log_msg)
+    if isinstance(media_name, bytes):
+        media_name = media_name.decode('utf-8', errors='replace')
+    else:
+        media_name = str(media_name)
+    media_size = humanbytes(get_media_file_size(log_msg))
+    file_name_encoded = quote(media_name)
+    hash_value = get_hash(log_msg)
+    stream_link = f"{base_url}/watch/{hash_value}{file_id}/{file_name_encoded}"
+    online_link = f"{base_url}/{hash_value}{file_id}/{file_name_encoded}"
+    if shortener and getattr(Var, "SHORTEN_MEDIA_LINKS", False):
+        shortened_results = await asyncio.gather(
+            shorten(stream_link),
+            shorten(online_link),
+            return_exceptions=True
+        )
+        if not isinstance(shortened_results[0], Exception):
+            stream_link = shortened_results[0]
+        if not isinstance(shortened_results[1], Exception):
+            online_link = shortened_results[1]
+    return stream_link, online_link, media_name, media_size
 
+@log_errors
 async def send_links_to_user(client: Client, command_message: Message, media_name: str, media_size: str, stream_link: str, online_link: str):
     msg_text = MSG_LINKS.format(
         file_name=media_name,
@@ -126,25 +97,22 @@ async def send_links_to_user(client: Client, command_message: Message, media_nam
         download_link=online_link,
         stream_link=stream_link
     )
-    
-    try:
-        await command_message.reply_text(
-            msg_text,
-            quote=True,
-            link_preview_options=LinkPreviewOptions(is_disabled=True),
-            parse_mode=enums.ParseMode.MARKDOWN,
-            reply_markup=InlineKeyboardMarkup([
-                [
-                    InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=stream_link),
-                    InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=online_link)
-                ]
-            ]),
-        )
-        await asyncio.sleep(0.3)
-    except Exception as e:
-        logger.error(f"Error sending links to user: {e}")
-        raise
+    await retry_send_message(
+        client,
+        command_message.chat.id,
+        msg_text,
+        reply_parameters=ReplyParameters(message_id=command_message.id),
+        link_preview_options=LinkPreviewOptions(is_disabled=True),
+        parse_mode=enums.ParseMode.MARKDOWN,
+        reply_markup=InlineKeyboardMarkup([
+            [
+                InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=stream_link),
+                InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=online_link)
+            ]
+        ])
+    )
 
+@log_errors
 async def generate_dc_text(user: User) -> str:
     dc_id = user.dc_id if user.dc_id is not None else MSG_DC_UNKNOWN
     return MSG_DC_USER_INFO.format(
@@ -153,39 +121,28 @@ async def generate_dc_text(user: User) -> str:
         dc_id=dc_id
     )
 
+@log_errors
 async def get_user_safely(bot: Client, query) -> Optional[User]:
-    try:
-        if isinstance(query, str):
-            if query.startswith('@'):
-                return await bot.get_users(query)
-            elif query.isdigit():
-                return await bot.get_users(int(query))
-        elif isinstance(query, int):
+    if isinstance(query, str):
+        if query.startswith('@'):
             return await bot.get_users(query)
-        return None
-    except Exception:
-        return None
+        elif query.isdigit():
+            return await bot.get_users(int(query))
+    elif isinstance(query, int):
+        return await bot.get_users(query)
+    return None
 
+@log_errors
 async def check_admin_privileges(client: Client, chat_id: int) -> bool:
-    try:
-        member = await client.get_chat_member(chat_id, client.me.id)
-        return member.status in [
-            ChatMemberStatus.ADMINISTRATOR,
-            ChatMemberStatus.OWNER
-        ]
-    except Exception:
-        return False
+    member = await client.get_chat_member(chat_id, client.me.id)
+    return member.status in [ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]
 
+@log_errors
 async def _execute_command_from_callback(client: Client, callback_query: CallbackQuery, command_name: str, command_func):
-    try:
-        await callback_query.answer()
-        mock_message = callback_query.message
-        mock_message.from_user = callback_query.from_user
-        mock_message.chat = callback_query.message.chat
-        mock_message.text = f"/{command_name}"
-        mock_message.command = [command_name]
-        await command_func(client, mock_message)
-        logger.info(f"User {callback_query.from_user.id} used {command_name} via callback")
-    except Exception as e:
-        logger.error(f"Error in {command_name}_callback: {e}")
-        await callback_query.answer(MSG_ERROR_GENERIC_CALLBACK.format(error_id=uuid.uuid4().hex[:8]), show_alert=True)
+    await callback_query.answer()
+    mock_message = callback_query.message
+    mock_message.from_user = callback_query.from_user
+    mock_message.chat = callback_query.message.chat
+    mock_message.text = f"/{command_name}"
+    mock_message.command = [command_name]
+    await command_func(client, mock_message)

Thunder/utils/broadcast_helper.py

@@ -1,41 +1,24 @@
 # Thunder/utils/broadcast_helper.py
 
 import asyncio
-import traceback
 from typing import Tuple
-
 from pyrogram.errors import FloodWait, InputUserDeactivated, UserIsBlocked, PeerIdInvalid
 from pyrogram.types import Message
-from Thunder.utils.logger import logger
-
+from Thunder.utils.error_handling import log_errors
 
+@log_errors
 async def send_msg(user_id: int, message: Message) -> Tuple[int, str]:
-    # Attempt to forward a message to a user and handle exceptions
     try:
         await message.forward(chat_id=user_id)
-        return 200, None  # Success code
-
+        return 200, None
     except FloodWait as e:
-        logger.warning(f"FloodWait error: sleeping for {e.value} seconds.")
         await asyncio.sleep(e.value + 1)
-        return await send_msg(user_id, message)  # Retry after wait
-
+        return await send_msg(user_id, message)
     except InputUserDeactivated:
-        error_msg = f"{user_id} : deactivated"
-        logger.error(error_msg)
-        return 400, error_msg
-
+        return 400, f"{user_id} : deactivated"
     except UserIsBlocked:
-        error_msg = f"{user_id} : blocked the bot"
-        logger.error(error_msg)
-        return 400, error_msg
-
+        return 400, f"{user_id} : blocked the bot"
     except PeerIdInvalid:
-        error_msg = f"{user_id} : user ID invalid"
-        logger.error(error_msg)
-        return 400, error_msg
-
+        return 400, f"{user_id} : user ID invalid"
     except Exception as e:
-        error_msg = f"{user_id} : {traceback.format_exc()}"
-        logger.error(f"Unexpected error: {error_msg}", exc_info=True)
-        return 500, error_msg
+        return 500, f"{user_id} : {str(e)}"

Thunder/utils/config_parser.py

@@ -2,44 +2,36 @@
 
 import os
 from typing import Dict, Optional
-from Thunder.utils.logger import logger
-
+from Thunder.utils.error_handling import log_errors
 
 class TokenParser:
-    # Class to parse multiple bot tokens from environment variables
-    
     def __init__(self, config_file: Optional[str] = None):
-        # Initialize the TokenParser
         self.tokens: Dict[int, str] = {}
         self.config_file = config_file
+        self._env_cache = None
 
+    @log_errors
     def parse_from_env(self) -> Dict[int, str]:
-        # Parse bot tokens from environment variables
-        # MULTI_TOKEN1=token_1, MULTI_TOKEN2=token_2, etc.
+        if self._env_cache is None:
+            self._env_cache = dict(os.environ)
         
-        # Filter environment variables that start with "MULTI_TOKEN"
         multi_tokens = {
-            key: value for key, value in os.environ.items() 
+            key: value.strip() 
+            for key, value in self._env_cache.items()
             if key.startswith("MULTI_TOKEN") and value.strip()
         }
-
+        
         if not multi_tokens:
-            logger.info("No MULTI_TOKEN environment variables found. Running with primary bot only.")
             return {}
-
-        # Extract numeric part and sort tokens
+        
         sorted_tokens = sorted(
             multi_tokens.items(),
             key=lambda item: int(''.join(filter(str.isdigit, item[0])) or 0)
         )
-
-        # Map to a dictionary with integer keys starting at 1
+        
         self.tokens = {
-            index + 1: token for index, (_, token) in enumerate(sorted_tokens) if token.strip()
+            index + 1: token
+            for index, (_, token) in enumerate(sorted_tokens)
         }
-
-        if not self.tokens:
-            logger.info("No valid MULTI_TOKEN environment variables found. Running with primary bot only.")
-            return {}
-
-        return self.tokens
+        
+        return self.tokens

Thunder/utils/custom_dl.py

@@ -15,17 +15,15 @@ from .file_properties import get_file_ids
 from Thunder.utils.logger import logger
 
 class ByteStreamer:
-    # A custom class that handles streaming of media files from Telegram servers
     
     def __init__(self, client: Client):
         self.client = client
-        self.clean_timer = 30 * 60  # Cache clean interval in seconds (30 minutes)
+        self.clean_timer = 30 * 60
         self.cached_file_ids: Dict[int, FileId] = {}
         self.file_references_cache: Dict[int, Dict[str, Union[FileId, float]]] = {}
         self.cache_lock = asyncio.Lock()
         self.media_sessions_lock = asyncio.Lock()
         
-        # Start cache cleaning tasks
         self.cache_cleaner_task = asyncio.create_task(self.clean_cache())
         self.session_cleaner_task = asyncio.create_task(self.cleanup_media_sessions())
     
@@ -44,7 +42,6 @@ class ByteStreamer:
             except asyncio.CancelledError:
                 pass
         
-        # Clean up all media sessions
         for dc_id, session in list(self.client.media_sessions.items()):
             try:
                 await session.stop()
@@ -79,14 +76,12 @@ class ByteStreamer:
     async def refresh_file_reference(self, file_id: FileId) -> Optional[FileId]:
         logger.debug(f"Refreshing file reference for message ID {file_id.message_id}")
         
-        # Check if we have a fresh cached reference
         async with self.cache_lock:
             cached_ref = self.file_references_cache.get(file_id.message_id)
-            if cached_ref and time.time() - cached_ref["timestamp"] < 3600:  # Less than 1 hour old
+            if cached_ref and time.time() - cached_ref["timestamp"] < 3600:
                 return cached_ref["file_id"]
         
         try:
-            # Fetch the message again to get fresh file reference
             message = await self.client.get_messages(
                 chat_id=Var.BIN_CHANNEL,
                 message_ids=file_id.message_id
@@ -96,13 +91,11 @@ class ByteStreamer:
                 logger.debug(f"Media message {file_id.message_id} not found when refreshing file reference")
                 return None
             
-            # Extract new file ID
             new_file_id = await get_file_ids(self.client, Var.BIN_CHANNEL, file_id.message_id)
             if not new_file_id:
                 logger.error(f"Failed to extract file ID from message {file_id.message_id}")
                 return None
             
-            # Cache the new file reference
             async with self.cache_lock:
                 self.file_references_cache[file_id.message_id] = {
                     "file_id": new_file_id,
@@ -133,7 +126,6 @@ class ByteStreamer:
                     
                     for attempt in range(6):
                         if attempt > 0:
-                            # Add exponential backoff between attempts
                             await asyncio.sleep(1 * (2 ** (attempt - 1)))
                         
                         try:
@@ -167,11 +159,9 @@ class ByteStreamer:
                     )
                     await media_session.start()
                 
-                # Mark the session creation time for cleanup
                 setattr(media_session, 'last_used', time.time())
                 client.media_sessions[file_id.dc_id] = media_session
             else:
-                # Update last used time
                 setattr(media_session, 'last_used', time.time())
         
         return media_session
@@ -248,17 +238,18 @@ class ByteStreamer:
             
             # Handle missing file reference
             if location is None:
-                logger.warning(f"Missing file reference for {file_id.message_id}, attempting to refresh")
+                logger.warning(f"Missing file reference, attempting to refresh")
                 refreshed_file_id = await self.refresh_file_reference(file_id)
                 if refreshed_file_id:
                     location = await self.get_location(refreshed_file_id)
                     file_id = refreshed_file_id
                 
                 if location is None:
-                    logger.error(f"Failed to get location for {file_id.message_id} even after refreshing file reference")
-                    raise FileNotFound(f"File location not found after refresh for {file_id.message_id}")
+                    logger.error("Failed to get location even after refreshing file reference")
+                    return
             
             max_retries = 5
+            retry_count = 0
             
             while current_part <= part_count:
                 try:
@@ -266,54 +257,42 @@ class ByteStreamer:
                         raw.functions.upload.GetFile(
                             location=location, offset=offset, limit=chunk_size
                         ),
-                        timeout=Var.TIMEOUT
                     )
                 except FloodWait as e:
                     logger.warning(f"FloodWait encountered: waiting for {e.value} seconds.")
                     await asyncio.sleep(e.value + 1)
                     continue
                 except (FileReferenceExpired, FileReferenceInvalid) as e:
-                    logger.warning(f"File reference for {file_id.message_id} expired/invalid: {e}. Attempting refresh.")
+                    logger.debug(f"File reference expired: {e}")
                     refreshed_file_id = await self.refresh_file_reference(file_id)
                     if refreshed_file_id:
-                        file_id = refreshed_file_id # Update file_id
+                        file_id = refreshed_file_id
                         location = await self.get_location(file_id)
                         if location is None:
-                            logger.error(f"Failed to get location for {file_id.message_id} after file reference refresh.")
-                            raise FileNotFoundError(f"File location not found after refresh for {file_id.message_id}")
-                        logger.info(f"Successfully refreshed file reference for {file_id.message_id} and got new location.")
+                            logger.error("Failed to get location after refresh")
+                            return
                         retry_count = 0
                         continue
                     else:
-                        logger.error(f"Failed to refresh file reference for {file_id.message_id}.")
-                        raise FileNotFoundError(f"Failed to refresh file reference for {file_id.message_id}")
-                except asyncio.TimeoutError as e: # Specific handling for asyncio.TimeoutError
-                    retry_count += 1
-                    logger.warning(f"TimeoutError during file fetch for {file_id.message_id} (attempt {retry_count}/{max_retries}): {e}")
-                    if retry_count >= max_retries:
-                        logger.error(f"Max retries reached for TimeoutError on {file_id.message_id}: {e}")
-                        raise TimeoutError(f"Max retries for TimeoutError on {file_id.message_id} after {max_retries} attempts.")
-                    await asyncio.sleep(1 * (2 ** (retry_count - 1)))
-                    continue
+                        logger.error("Failed to refresh file reference")
+                        return
                 except RPCError as e:
                     retry_count += 1
-                    logger.warning(f"RPC Error during file fetch for {file_id.message_id} (attempt {retry_count}/{max_retries}): {e}")
+                    logger.warning(f"RPC Error during file fetch: {e}")
                     if retry_count >= max_retries:
-                        logger.error(f"Max retries reached for RPCError on {file_id.message_id}: {e}")
-                        raise RPCError(f"Max retries for RPCError on {file_id.message_id}: {e}")
+                        return
                     await asyncio.sleep(1 * (2 ** (retry_count - 1)))
                     continue
                 except ConnectionError as e:
                     retry_count += 1
-                    logger.warning(f"Connection error during file fetch for {file_id.message_id} (attempt {retry_count}/{max_retries}): {e}")
+                    logger.error(f"Connection error during file fetch: {e}")
                     if retry_count >= max_retries:
-                        logger.error(f"Max retries reached for ConnectionError on {file_id.message_id}: {e}")
-                        raise ConnectionError(f"Max retries for ConnectionError on {file_id.message_id}: {e}")
-                    await asyncio.sleep(1)  # Brief pause before retry
+                        return
+                    await asyncio.sleep(1)
                     continue
                 except Exception as e:
-                    logger.error(f"Unexpected error during file fetch for {file_id.message_id}: {str(e)}", exc_info=True)
-                    raise
+                    logger.error(f"Unexpected error during file fetch: {str(e)}", exc_info=True)
+                    return
                 
                 if isinstance(r, raw.types.upload.File):
                     chunk = r.bytes
@@ -330,13 +309,12 @@ class ByteStreamer:
 
                     current_part += 1
                     offset += chunk_size
-                    retry_count = 0  # Reset retry count after success
+                    retry_count = 0
 
                     if current_part > part_count:
                         break
-        except (AttributeError) as e:
-            logger.error(f"Error while yielding file for {file_id.message_id if 'file_id' in locals() else 'unknown file'} (AttributeError): {e}", exc_info=True)
-            raise
+        except (TimeoutError, AttributeError) as e:
+            logger.error(f"Error while yielding file: {e}")
         finally:
             work_loads[index] -= 1
     
@@ -346,15 +324,12 @@ class ByteStreamer:
                 await asyncio.sleep(self.clean_timer)
                 
                 async with self.cache_lock:
-                    # Instead of clearing everything, we could selectively clean
-                    # based on timestamps if we tracked them
                     self.cached_file_ids.clear()
                     
-                    # Clean file reference cache based on age
                     now = time.time()
                     expired_refs = [
                         key for key, value in self.file_references_cache.items()
-                        if now - value["timestamp"] > 3600  # 1 hour expiry
+                        if now - value["timestamp"] > 3600
                     ]
                     for key in expired_refs:
                         self.file_references_cache.pop(key, None)
@@ -365,12 +340,12 @@ class ByteStreamer:
                 break
             except Exception as e:
                 logger.error(f"Error in cache cleaning task: {e}")
-                await asyncio.sleep(60)  # Wait before retrying
+                await asyncio.sleep(60)
     
     async def cleanup_media_sessions(self) -> None:
         while True:
             try:
-                await asyncio.sleep(1800)  # 30 minutes
+                await asyncio.sleep(1800)
                 
                 async with self.media_sessions_lock:
                     now = time.time()
@@ -393,4 +368,4 @@ class ByteStreamer:
                 break
             except Exception as e:
                 logger.error(f"Error in media session cleaning task: {e}")
-                await asyncio.sleep(60)  # Wait before retrying
+                await asyncio.sleep(60)

Thunder/utils/database.py

@@ -1,15 +1,14 @@
-"""Database utilities for managing users, bans, and tokens via MongoDB."""
+# Thunder/utils/database.py
+
 import datetime
 from typing import Optional, Dict, Any
 from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorCollection
-from Thunder.utils.logger import logger
 from Thunder.vars import Var
+from Thunder.utils.logger import logger
+from Thunder.utils.error_handling import log_errors
 
 class Database:
-    # Database class for handling user data using MongoDB
-    
     def __init__(self, uri: str, database_name: str, *args, **kwargs):
-        # Initialize database connection
         self._client = AsyncIOMotorClient(uri, *args, **kwargs)
         self.db = self._client[database_name]
         self.col: AsyncIOMotorCollection = self.db.users
@@ -17,212 +16,175 @@ class Database:
         self.token_col: AsyncIOMotorCollection = self.db.tokens
         self.authorized_users_col: AsyncIOMotorCollection = self.db.authorized_users
         self.restart_message_col: AsyncIOMotorCollection = self.db.restart_message
-    
+
+    @log_errors
     async def ensure_indexes(self):
-        # Ensure necessary indexes are created
         await self.banned_users_col.create_index("user_id", unique=True)
         await self.token_col.create_index("token", unique=True)
         await self.authorized_users_col.create_index("user_id", unique=True)
-        # Add unique index on users.id
         await self.col.create_index("id", unique=True)
-
-        # TTL index to auto-remove expired tokens
         await self.token_col.create_index("expires_at", expireAfterSeconds=0)
         await self.restart_message_col.create_index("message_id", unique=True)
-        # TTL index to auto-remove expired restart messages
         await self.restart_message_col.create_index("timestamp", expireAfterSeconds=3600)
+        logger.info("Database indexes ensured.")
 
+    @log_errors
     def new_user(self, user_id: int) -> dict:
-        # Create new user document
         return {
             'id': user_id,
             'join_date': datetime.datetime.utcnow()
         }
-    
+
+    @log_errors
     async def add_user(self, user_id: int):
-        # Add new user if not exists
         if not await self.is_user_exist(user_id):
-            user = self.new_user(user_id)
-            await self.col.insert_one(user)
-    
+            await self.col.insert_one(self.new_user(user_id))
+            logger.debug(f"Added new user {user_id} to database.")
+
+    @log_errors
     async def add_user_pass(self, user_id: int, ag_pass: str):
-        # Add or update user password
         await self.add_user(user_id)
         await self.col.update_one({'id': user_id}, {'$set': {'ag_p': ag_pass}})
-    
+        logger.debug(f"Updated password for user {user_id}.")
+
+    @log_errors
     async def get_user_pass(self, user_id: int) -> Optional[str]:
-        # Get user password
-        user_pass = await self.col.find_one({'id': user_id}, {'ag_p': 1})
-        return user_pass.get('ag_p') if user_pass else None
-    
+        user_data = await self.col.find_one({'id': user_id}, {'ag_p': 1})
+        return user_data.get('ag_p') if user_data else None
+
+    @log_errors
     async def is_user_exist(self, user_id: int) -> bool:
-        # Check if user exists
         user = await self.col.find_one({'id': user_id}, {'_id': 1})
         return bool(user)
-    
+
+    @log_errors
     async def total_users_count(self) -> int:
-        # Count total users
         return await self.col.count_documents({})
-    
+
+    @log_errors
     async def get_all_users(self):
-        # Get all users (returns cursor)
         return self.col.find({})
-    
+
+    @log_errors
     async def delete_user(self, user_id: int):
-        # Delete user
         await self.col.delete_one({'id': user_id})
-    
+        logger.info(f"Deleted user {user_id}.")
+
+    @log_errors
     async def create_index(self):
-        # Create index for faster queries
         await self.col.create_index("id", unique=True)
-        
+        logger.info("Created index for 'id' on users collection.")
+
+    @log_errors
     async def get_active_users(self, days: int = 7):
-        # Get users active within specified days
         cutoff = datetime.datetime.utcnow() - datetime.timedelta(days=days)
         return self.col.find({'join_date': {'$gte': cutoff}})
-        
+
+    @log_errors
     async def add_banned_user(
         self, user_id: int, banned_by: Optional[int] = None,
         reason: Optional[str] = None, ban_time: Optional[str] = None
     ):
-        # Add or update banned user with upsert
         ban_data = {
             "user_id": user_id,
             "banned_at": datetime.datetime.utcnow(),
             "banned_by": banned_by,
             "reason": reason
         }
-        try:
-            await self.banned_users_col.update_one(
-                {"user_id": user_id},
-                {"$set": ban_data},
-                upsert=True
-            )
-        except Exception as e:
-            logger.error(
-                f"Database error in add_banned_user for user {user_id}: {e}"
-            )
-            raise RuntimeError(f"Failed to ban user {user_id}: {e}")
+        await self.banned_users_col.update_one(
+            {"user_id": user_id},
+            {"$set": ban_data},
+            upsert=True
+        )
+        logger.info(f"Added/Updated banned user {user_id}. Reason: {reason}")
 
+    @log_errors
     async def remove_banned_user(self, user_id: int) -> bool:
-        # Remove banned user and return if document was deleted
-        try:
-            result = await self.banned_users_col.delete_one(
-                {"user_id": user_id}
-            )
-            return result.deleted_count > 0
-        except Exception as e:
-            logger.error(
-                f"Database error in remove_banned_user for user {user_id}: {e}"
-            )
-            return False
+        result = await self.banned_users_col.delete_one({"user_id": user_id})
+        if result.deleted_count > 0:
+            logger.info(f"Removed banned user {user_id}.")
+            return True
+        return False
 
+    @log_errors
     async def is_user_banned(self, user_id: int) -> Optional[Dict[str, Any]]:
-        # Check if user is banned and return ban details
-        try:
-            return await self.banned_users_col.find_one({"user_id": user_id})
-        except Exception as e:
-            logger.error(
-                f"Database error in is_user_banned for user {user_id}: {e}"
-            )
-            return None
+        return await self.banned_users_col.find_one({"user_id": user_id})
 
+    @log_errors
     async def check_user_token(self, user_id: int) -> Dict[str, bool]:
-        """Check if user has valid token."""
-        try:
-            # Only return active (not expired) tokens
-            token_data = await self.token_col.find_one({
+        token_data = await self.token_col.find_one({
+            "user_id": user_id,
+            "expires_at": {"$gt": datetime.datetime.utcnow()}
+        })
+        return {"has_token": bool(token_data)}
+
+    @log_errors
+    async def update_user_token(self, user_id: int, token: str) -> None:
+        token_data = await self.token_col.find_one({"token": token})
+        expires_at = datetime.datetime.utcnow() + datetime.timedelta(hours=Var.TOKEN_TTL_HOURS)
+        if token_data:
+            await self.token_col.update_one(
+                {"token": token},
+                {"$set": {"user_id": user_id, "expires_at": expires_at}}
+            )
+            logger.info(f"Updated token for user {user_id}.")
+        else:
+            await self.token_col.insert_one({
                 "user_id": user_id,
-                "expires_at": {"$gt": datetime.datetime.utcnow()}
+                "token": token,
+                "created_at": datetime.datetime.utcnow(),
+                "expires_at": expires_at
             })
-            return {"has_token": bool(token_data)}
-        except Exception as e:
-            logger.error(f"Database error checking token for {user_id}: {e}")
-            return {"has_token": False}
-            
-    async def update_user_token(self, user_id: int, token: str) -> None:
-        """Update user's active token in database."""
-        try:
-            # Find the token data first
-            token_data = await self.token_col.find_one({"token": token})
-            
-            if token_data:
-                # Link token to user and refresh expiration
-                await self.token_col.update_one(
-                    {"token": token},
-                    {"$set": {
-                        "user_id": user_id,
-                        "expires_at": datetime.datetime.utcnow() + datetime.timedelta(hours=Var.TOKEN_TTL_HOURS)
-                    }}
-                )
-            else:
-                # If no token data found, create a basic entry (this is a fallback)
-                logger.warning(f"Token {token} not found in database when assigning to user {user_id}")
-                await self.token_col.insert_one({
-                    "user_id": user_id,
-                    "token": token,
-                    "created_at": datetime.datetime.utcnow(),
-                    "expires_at": datetime.datetime.utcnow() + datetime.timedelta(hours=Var.TOKEN_TTL_HOURS)
-                })
-        except Exception as e:
-            logger.error(f"Database error updating token for {user_id}: {e}")
-            raise RuntimeError(f"Failed to update token: {e}")
+            logger.info(f"Inserted new token for user {user_id}.")
 
+    @log_errors
     async def save_broadcast_state(self, broadcast_id, state_data):
-        broadcast_collection = self.db.broadcasts
-        await broadcast_collection.update_one(
+        await self.db.broadcasts.update_one(
             {"_id": broadcast_id},
             {"$set": state_data},
             upsert=True
         )
+        logger.debug(f"Saved broadcast state for ID {broadcast_id}.")
 
+    @log_errors
     async def get_broadcast_state(self, broadcast_id):
-        broadcast_collection = self.db.broadcasts
-        state = await broadcast_collection.find_one({"_id": broadcast_id})
-        return state
+        return await self.db.broadcasts.find_one({"_id": broadcast_id})
 
+    @log_errors
     async def list_active_broadcasts(self):
-        broadcast_collection = self.db.broadcasts
-        cursor = broadcast_collection.find({"is_cancelled": False})
-        return await cursor.to_list(length=100)
+        cursor = self.db.broadcasts.find({"is_cancelled": False})
+        return await cursor.to_list(length=None)
 
+    @log_errors
     async def add_restart_message(self, message_id: int, chat_id: int) -> None:
-        """Store the restart message ID and chat ID."""
         try:
-            await self.restart_message_col.insert_one(
-                {"message_id": message_id, "chat_id": chat_id, "timestamp": datetime.datetime.utcnow()}
-            )
-            logger.debug(f"Restart message {message_id} in chat {chat_id} saved to DB.")
+            await self.restart_message_col.insert_one({
+                "message_id": message_id, 
+                "chat_id": chat_id, 
+                "timestamp": datetime.datetime.utcnow()
+            })
+            logger.info(f"Added restart message {message_id} for chat {chat_id}.")
         except Exception as e:
-            logger.error(f"Database error saving restart message: {e}")
+            logger.error(f"Error adding restart message {message_id}: {e}")
 
+    @log_errors
     async def get_restart_message(self) -> Optional[Dict[str, Any]]:
-        """Retrieve the restart message from the database."""
         try:
-            # Get the most recent restart message
-            restart_msg = await self.restart_message_col.find_one(sort=[("timestamp", -1)])
-            if restart_msg:
-                logger.debug(f"Retrieved restart message {restart_msg['message_id']} from DB.")
-            return restart_msg
+            return await self.restart_message_col.find_one(sort=[("timestamp", -1)])
         except Exception as e:
-            logger.error(f"Database error retrieving restart message: {e}")
+            logger.error(f"Error getting restart message: {e}")
             return None
 
+    @log_errors
     async def delete_restart_message(self, message_id: int) -> None:
-        """Delete the restart message from the database."""
         try:
-            result = await self.restart_message_col.delete_one({"message_id": message_id})
-            if result.deleted_count > 0:
-                logger.debug(f"Restart message {message_id} deleted from DB.")
-            else:
-                logger.debug(f"Attempted to delete non-existent restart message {message_id}.")
+            await self.restart_message_col.delete_one({"message_id": message_id})
+            logger.info(f"Deleted restart message {message_id}.")
         except Exception as e:
-            logger.error(f"Database error deleting restart message: {e}")
+            logger.error(f"Error deleting restart message {message_id}: {e}")
 
     async def close(self):
-        # Close database connection
         if self._client:
             self._client.close()
 
-# Initialize the Database instance
 db = Database(Var.DATABASE_URL, Var.NAME)

Thunder/utils/decorators.py

@@ -1,119 +1,147 @@
+# Thunder/utils/decorators.py
+
 from functools import wraps
 from pyrogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup
 from Thunder.vars import Var
+from Thunder.utils.logger import logger
 from Thunder.utils.messages import (
     MSG_DECORATOR_BANNED,
     MSG_TOKEN_INVALID,
     MSG_ERROR_UNAUTHORIZED
 )
 from Thunder.utils.database import db
-from Thunder.utils.logger import logger
 from Thunder.utils.tokens import check, allowed, generate
 from Thunder.utils.shortener import shorten
 
-def _check_message_user(message):
-    """Helper to validate message and user."""
-    if not message.from_user:
-        return None
-    return message.from_user.id
 
 def check_banned(func):
     @wraps(func)
     async def wrapper(client, message: Message, *args, **kwargs):
-        user_id = _check_message_user(message)
-        if not user_id:
-            return await func(client, message, *args, **kwargs)
+        try:
+            if not message.from_user:
+                return await func(client, message, *args, **kwargs)
+            user_id = message.from_user.id
+            if isinstance(Var.OWNER_ID, int) and user_id == Var.OWNER_ID:
+                 return await func(client, message, *args, **kwargs)
+            elif isinstance(Var.OWNER_ID, (list, tuple, set)) and user_id in Var.OWNER_ID:
+                 return await func(client, message, *args, **kwargs)
             
-        if user_id in Var.OWNER_ID:
+            ban_details = await db.is_user_banned(user_id)
+            if ban_details:
+                banned_at = ban_details.get('banned_at')
+                ban_time = (
+                    banned_at.strftime('%B %d, %Y, %I:%M %p UTC') 
+                    if banned_at and hasattr(banned_at, 'strftime') 
+                    else str(banned_at) if banned_at else 'N/A'
+                )
+                await message.reply_text(
+                    MSG_DECORATOR_BANNED.format(
+                        reason=ban_details.get('reason', 'Not specified'),
+                        ban_time=ban_time
+                    ),
+                    quote=True
+                )
+                logger.info(f"Blocked banned user {user_id} from accessing {func.__name__}.")
+                return
+            return await func(client, message, *args, **kwargs)
+        except Exception as e:
+            logger.error(f"Error in check_banned decorator for {func.__name__}: {e}")
             return await func(client, message, *args, **kwargs)
-            
-        ban_details = await db.is_user_banned(user_id)
-        if ban_details:
-            banned_at = ban_details.get('banned_at')
-            if banned_at and hasattr(banned_at, 'strftime'):
-                ban_time = banned_at.strftime('%B %d, %Y, %I:%M %p UTC')
-            else:
-                ban_time = str(banned_at) if banned_at else 'N/A'
-            
-            ban_message = MSG_DECORATOR_BANNED.format(
-                reason=ban_details.get('reason', 'Not specified'),
-                ban_time=ban_time
-            )
-            await message.reply_text(ban_message, quote=True)
-            return
-            
-        return await func(client, message, *args, **kwargs)
     return wrapper
 
 def require_token(func):
     @wraps(func)
     async def wrapper(client, message: Message, *args, **kwargs):
-        user_id = _check_message_user(message)
-        if not user_id:
-            return await func(client, message, *args, **kwargs)
-        
-        if not getattr(Var, "TOKEN_ENABLED", False):
-            return await func(client, message, *args, **kwargs)
-        
-        if user_id in Var.OWNER_ID:
-            return await func(client, message, *args, **kwargs)
-        
-        if await allowed(user_id):
-            return await func(client, message, *args, **kwargs)
-        
-        if not await check(user_id):
+        try:
+            if not message.from_user:
+                return await func(client, message, *args, **kwargs)
+            if not getattr(Var, "TOKEN_ENABLED", False):
+                return await func(client, message, *args, **kwargs)
+            
+            user_id = message.from_user.id
+            is_owner = (isinstance(Var.OWNER_ID, int) and user_id == Var.OWNER_ID) or \
+                       (isinstance(Var.OWNER_ID, (list, tuple, set)) and user_id in Var.OWNER_ID)
+            
+            if is_owner or await allowed(user_id) or await check(user_id):
+                return await func(client, message, *args, **kwargs)
+            
             token_data = await generate(user_id)
+            if not token_data or 'token' not in token_data:
+                logger.error(f"Failed to generate token for user {user_id} in require_token.")
+                await message.reply_text("Sorry, could not generate an access token. Please try again later.", quote=True)
+                return
+
             me = await client.get_me()
             deep_link = f"https://t.me/{me.username}?start={token_data['token']}"
-            
+            short_url = deep_link
             try:
-                short_url = await shorten(deep_link)
+                short_url_result = await shorten(deep_link)
+                if short_url_result:
+                    short_url = short_url_result
             except Exception as e:
-                logger.error(f"URL shortening failed: {e}")
-                short_url = deep_link
-
+                logger.warning(f"Failed to shorten token link for user {user_id}: {e}. Using full link.")
+            
             await message.reply_text(
                 MSG_TOKEN_INVALID,
-                reply_markup=InlineKeyboardMarkup(
-                    [[InlineKeyboardButton("Get Token", url=short_url)]]
-                ),
+                reply_markup=InlineKeyboardMarkup([
+                    [InlineKeyboardButton("Get Token", url=short_url)]
+                ]),
                 quote=True
             )
+            logger.info(f"Sent token request to user {user_id} for {func.__name__}.")
+            return
+        except Exception as e:
+            logger.error(f"Error in require_token decorator for {func.__name__}: {e}")
+            try:
+                await message.reply_text("An error occurred while checking your authorization. Please try again.", quote=True)
+            except Exception as inner_e:
+                logger.error(f"Failed to send error message to user in require_token: {inner_e}")
             return
-        
-        return await func(client, message, *args, **kwargs)
     return wrapper
 
 def shorten_link(func):
     @wraps(func)
     async def wrapper(client, message: Message, *args, **kwargs):
-        user_id = None
-        if message.from_user:
-            user_id = message.from_user.id
-
-        if user_id and (user_id in Var.OWNER_ID or await allowed(user_id)):
-            kwargs['shortener'] = False
-        else:
-            kwargs['shortener'] = getattr(Var, "SHORTEN_MEDIA_LINKS", False)
-        
-        return await func(client, message, *args, **kwargs)
+        try:
+            user_id = message.from_user.id if message.from_user else None
+            use_shortener = getattr(Var, "SHORTEN_MEDIA_LINKS", False)
+            if user_id:
+                try:
+                    is_owner = (isinstance(Var.OWNER_ID, int) and user_id == Var.OWNER_ID) or \
+                               (isinstance(Var.OWNER_ID, (list, tuple, set)) and user_id in Var.OWNER_ID)
+                    if is_owner or await allowed(user_id):
+                        use_shortener = False
+                except Exception as e:
+                    logger.warning(f"Error checking allowed status for user {user_id} in shorten_link: {e}. Defaulting shortener behavior.")
+            
+            kwargs['shortener'] = use_shortener
+            return await func(client, message, *args, **kwargs)
+        except Exception as e:
+            logger.error(f"Error in shorten_link decorator for {func.__name__}: {e}")
+            kwargs['shortener'] = getattr(Var, "SHORTEN_MEDIA_LINKS", False) 
+            return await func(client, message, *args, **kwargs)
     return wrapper
 
-
-def get_owner_ids():
-    """Helper function to safely get owner IDs."""
-    owner_ids = Var.OWNER_ID if hasattr(Var, 'OWNER_ID') and Var.OWNER_ID is not None else []
-    if isinstance(owner_ids, int):
-        owner_ids = [owner_ids]
-    return owner_ids
-
-
 def owner_only(func):
-    """Decorator to restrict access to bot owners."""
+    _cached_owner_ids = None
     async def wrapper(client, callback_query):
-        owner_ids = get_owner_ids()
-        if callback_query.from_user.id not in owner_ids:
-            await callback_query.answer(MSG_ERROR_UNAUTHORIZED, show_alert=True)
+        nonlocal _cached_owner_ids
+        try:
+            if _cached_owner_ids is None:
+                owner_ids_config = getattr(Var, 'OWNER_ID', [])
+                _cached_owner_ids = [owner_ids_config] if isinstance(owner_ids_config, int) else list(owner_ids_config)
+            
+            if callback_query.from_user.id not in _cached_owner_ids:
+                await callback_query.answer(MSG_ERROR_UNAUTHORIZED, show_alert=True)
+                logger.warning(f"Unauthorized access attempt by {callback_query.from_user.id} to owner_only function {func.__name__}.")
+                return
+            await func(client, callback_query)
+        except Exception as e:
+            logger.error(f"Error in owner_only decorator for {func.__name__}: {e}")
+            try:
+                await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+            except Exception as inner_e:
+                logger.error(f"Failed to send error answer in owner_only: {inner_e}")
             return
-        await func(client, callback_query)
     return wrapper
+

Thunder/utils/error_handling.py

@@ -0,0 +1,14 @@
+# Thunder/utils/error_handling.py
+
+from functools import wraps
+from Thunder.utils.logger import logger
+
+def log_errors(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"Error in {func.__name__}: {e}", exc_info=True)
+            raise
+    return wrapper

Thunder/utils/file_properties.py

@@ -1,75 +1,59 @@
 # Thunder/utils/file_properties.py
 
 from pyrogram import Client
-from pyrogram.types import Message
+from pyrogram.types import Message  
 from pyrogram.file_id import FileId
 from Thunder.server.exceptions import FileNotFound
-from Thunder.utils.logger import logger
+from Thunder.utils.error_handling import log_errors
 from typing import Any, Optional
 
 def get_media_from_message(message: Message) -> Optional[Any]:
-    # Extract media from message using known media type attributes
-    media_types = ("audio", "document", "photo", "sticker", 
-                  "animation", "video", "voice", "video_note")
-    
-    for attr in media_types:
+    for attr in ("audio", "document", "photo", "sticker", "animation", "video", "voice", "video_note"):
         if media := getattr(message, attr, None):
             return media
     return None
 
-def parse_file_id(message: Message) -> Optional[FileId]:
-    # Decode FileId from media if available
-    if media := get_media_from_message(message):
-        return FileId.decode(media.file_id)
-    logger.warning(f"No media found in message: {message.id}")
-    return None
-
-def parse_file_unique_id(message: Message) -> Optional[str]:
-    # Extract unique file ID from media if available
-    if media := get_media_from_message(message):
-        return media.file_unique_id
-    logger.warning("No media found for unique ID extraction")
-    return None
-
-async def get_file_ids(client: Client, chat_id: int, message_id: int) -> FileId:
-    # Fetch and process media file details from message
-    try:
-        message = await client.get_messages(chat_id, message_id)
-        if not message or message.empty:
-            logger.debug("Message not found or empty")
-            raise FileNotFound("Message not found/empty")
-
-        if not (media := get_media_from_message(message)):
-            logger.debug("Message contains no media")
-            raise FileNotFound("No media in message")
-
-        file_id = parse_file_id(message)
-        if not file_id:
-            logger.debug("Failed to parse file ID")
-            raise FileNotFound("Invalid file ID")
+@log_errors
+async def get_file_ids(client: Client, chat_id: int, message_id: int) -> Optional[FileId]: # Return Optional
+    message = await client.get_messages(chat_id, message_id)
+    if not message or message.empty:
+        raise FileNotFound("Message not found/empty")
+    
+    media = get_media_from_message(message)
+    if not media:
+        raise FileNotFound("No media in message")
+    
+    if not hasattr(media, 'file_id') or not hasattr(media, 'file_unique_id'):
+        raise FileNotFound("Media metadata incomplete")
 
-        # Enhance FileId object with additional metadata
-        file_id.file_size = getattr(media, "file_size", 0)
-        file_id.mime_type = getattr(media, "mime_type", "")
-        file_id.file_name = getattr(media, "file_name", "")
-        file_id.unique_id = parse_file_unique_id(message)
+    file_id_obj = FileId.decode(media.file_id)
+    file_id_obj.file_size = getattr(media, "file_size", 0)
+    file_id_obj.mime_type = getattr(media, "mime_type", "")
+    file_id_obj.file_name = getattr(media, "file_name", "")
+    file_id_obj.unique_id = media.file_unique_id
+    return file_id_obj
 
-        return file_id
+@log_errors
+def parse_file_id(message: Message) -> Optional[FileId]:
+    media = get_media_from_message(message)
+    return FileId.decode(media.file_id) if media and hasattr(media, 'file_id') else None
 
-    except Exception as e:
-        logger.debug(f"File ID processing failed: {str(e)}")
-        raise
+@log_errors
+def parse_file_unique_id(message: Message) -> Optional[str]:
+    media = get_media_from_message(message)
+    return media.file_unique_id if media and hasattr(media, 'file_unique_id') else None
 
+@log_errors
 def get_hash(media_msg: Message) -> str:
-    # Generate short hash from file unique ID
-    if media := get_media_from_message(media_msg):
-        return media.file_unique_id[:6]
-    return ""
+    media = get_media_from_message(media_msg)
+    return media.file_unique_id[:6] if media and hasattr(media, 'file_unique_id') and media.file_unique_id else ''
 
+@log_errors
 def get_name(media_msg: Message) -> str:
-    # Extract filename from media if available
-    return getattr(get_media_from_message(media_msg), "file_name", "")
+    media = get_media_from_message(media_msg)
+    return getattr(media, 'file_name', '') if media and hasattr(media, 'file_name') else ''
 
+@log_errors
 def get_media_file_size(message: Message) -> int:
-    # Get file size from media content
-    return getattr(get_media_from_message(message), "file_size", 0)
+    media = get_media_from_message(message)
+    return getattr(media, 'file_size', 0) if media and hasattr(media, 'file_size') else 0

Thunder/utils/force_channel.py

@@ -1,99 +1,34 @@
-"""
-Decorator to enforce channel membership before allowing command execution in Pyrogram bots.
-"""
-
 from typing import Any, Callable, Coroutine
-import asyncio
-import uuid
-
 from pyrogram import Client
 from pyrogram.enums import ChatMemberStatus
-from pyrogram.errors import UserNotParticipant, ChatAdminRequired, RightForbidden, RPCError, FloodWait
+from pyrogram.errors import UserNotParticipant, ChatAdminRequired, PeerIdInvalid
 from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
-
 from Thunder.vars import Var
-from Thunder.utils.logger import logger
-from Thunder.utils.messages import (
-    MSG_FORCE_CHANNEL_ERROR,
-    MSG_FORCE_CHANNEL_RPC_ERROR,
-    MSG_FORCE_CHANNEL_GENERIC_ERROR,
-    MSG_FORCE_CHANNEL_NO_LINK,
-    MSG_FORCE_CHANNEL_MEMBERSHIP_REQUIRED,
-    MSG_FORCE_CHANNEL_SERVICE_INTERRUPTION,
-    MSG_FORCE_CHANNEL_ACCESS_REQUIRED
-)
+from Thunder.utils.error_handling import log_errors
 
 def force_channel_check(
     func: Callable[[Client, Message], Coroutine[Any, Any, Any]]
 ) -> Callable[[Client, Message], Coroutine[Any, Any, Any]]:
-    """Decorator to enforce channel membership before allowing command execution."""
+    
+    @log_errors
     async def wrapper(client: Client, message: Message, *args, **kwargs) -> None:
-        if not Var.FORCE_CHANNEL_ID:
-            await func(client, message, *args, **kwargs)
-            return
-
-        if message.chat.id == Var.FORCE_CHANNEL_ID:
-            await func(client, message, *args, **kwargs)
-            return
-
-        user_id = message.from_user.id
+        if not Var.FORCE_CHANNEL_ID or message.chat.id == Var.FORCE_CHANNEL_ID:
+            return await func(client, message, *args, **kwargs)
         try:
-            member = await client.get_chat_member(
-                chat_id=Var.FORCE_CHANNEL_ID,
-                user_id=user_id
-            )
+            member = await client.get_chat_member(Var.FORCE_CHANNEL_ID, message.from_user.id)
             if member.status in [ChatMemberStatus.MEMBER, ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]:
-                await func(client, message, *args, **kwargs)
-                return
+                return await func(client, message, *args, **kwargs)
         except UserNotParticipant:
-            logger.debug(f"[ForceChannelCheck] User {user_id} is not a participant of FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID}. Prompting to join.")
-        except (ChatAdminRequired, RightForbidden):
-            logger.error(f"[ForceChannelCheck] Bot lacks permissions in FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID}.")
-            await message.reply(MSG_FORCE_CHANNEL_ERROR.format(error_id=uuid.uuid4().hex[:8]))
-            return
-        except asyncio.TimeoutError:
-            error_id = uuid.uuid4().hex[:8]
-            logger.error(f"[ForceChannelCheck] TimeoutError (ID: {error_id}) for user {user_id} while checking membership in {Var.FORCE_CHANNEL_ID}.")
-            await message.reply(MSG_FORCE_CHANNEL_RPC_ERROR.format(error_id=error_id))
-            return
-        except RPCError as e:
-            logger.error(f"[ForceChannelCheck] RPCError for user {user_id} in {Var.FORCE_CHANNEL_ID}: {e}")
-            await message.reply(MSG_FORCE_CHANNEL_RPC_ERROR.format(error_id=uuid.uuid4().hex[:8]))
-            return
-        except FloodWait as e:
-            wait_time: int = e.value
-            logger.debug(f"[ForceChannelCheck] Flood wait for {wait_time} seconds")
-            await asyncio.sleep(wait_time)
-            return await wrapper(client, message, *args, **kwargs)
-        except Exception as e:
-            logger.error(f"[ForceChannelCheck] Unexpected error for user {user_id} in {Var.FORCE_CHANNEL_ID}: {e}")
-            await message.reply(MSG_FORCE_CHANNEL_GENERIC_ERROR.format(error_id=uuid.uuid4().hex[:8]))
-            return
-
-        try:
-            chat = await client.get_chat(Var.FORCE_CHANNEL_ID)
-            invite_link = f"https://t.me/{chat.username}" if chat.username else chat.invite_link
-            if not invite_link:
-                logger.warning(f"[ForceChannelCheck] No invite link for {Var.FORCE_CHANNEL_ID} ({chat.title})")
-                await message.reply(MSG_FORCE_CHANNEL_NO_LINK)
-                return
-
+            pass
+        except (ChatAdminRequired, PeerIdInvalid):
+            return await func(client, message, *args, **kwargs)
+        chat = await client.get_chat(Var.FORCE_CHANNEL_ID)
+        invite_link = f"https://t.me/{chat.username}" if chat.username else chat.invite_link
+        if invite_link:
             await message.reply(
-                MSG_FORCE_CHANNEL_MEMBERSHIP_REQUIRED.format(channel_name=chat.title, error_id=uuid.uuid4().hex[:8]),
-                reply_markup=InlineKeyboardMarkup([
-                    [InlineKeyboardButton(MSG_FORCE_CHANNEL_ACCESS_REQUIRED, url=invite_link)],
-                ]),
+                f"Please join {chat.title} to use this bot.",
+                reply_markup=InlineKeyboardMarkup([[
+                    InlineKeyboardButton("Join Channel", url=invite_link)
+                ]])
             )
-        except asyncio.TimeoutError:
-            error_id = uuid.uuid4().hex[:8]
-            logger.error(f"[ForceChannelCheck] TimeoutError (ID: {error_id}) getting chat/invite link for {Var.FORCE_CHANNEL_ID}.")
-            await message.reply(MSG_FORCE_CHANNEL_SERVICE_INTERRUPTION.format(error_id=error_id))
-        except RPCError as e:
-            logger.error(f"[ForceChannelCheck] RPCError getting chat/invite link for {Var.FORCE_CHANNEL_ID}: {e}")
-            await message.reply(MSG_FORCE_CHANNEL_SERVICE_INTERRUPTION.format(error_id=uuid.uuid4().hex[:8]))
-        except Exception as e:
-            logger.error(f"[ForceChannelCheck] Unexpected error getting chat/invite link for {Var.FORCE_CHANNEL_ID}: {e}")
-            await message.reply(MSG_FORCE_CHANNEL_GENERIC_ERROR.format(error_id=uuid.uuid4().hex[:8]))
     return wrapper
-
-

Thunder/utils/human_readable.py

@@ -1,16 +1,14 @@
 # Thunder/utils/human_readable.py
+from Thunder.utils.error_handling import log_errors
 
+_UNITS = ('', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
+
+@log_errors
 def humanbytes(size: int, decimal_places: int = 2) -> str:
-    # Converts bytes to human-readable format (KB, MB, GB, etc.)
     if not size:
         return "0 B"
-        
-    power = 2 ** 10
     n = 0
-    units = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']
-    
-    while size >= power and n < len(units) - 1:
-        size /= power
+    while size >= 1024 and n < len(_UNITS) - 1:
+        size /= 1024
         n += 1
-        
-    return f"{round(size, decimal_places)} {units[n]}B"
+    return f"{round(size, decimal_places)} {_UNITS[n]}B"

Thunder/utils/keepalive.py

@@ -4,19 +4,15 @@ import asyncio
 import aiohttp
 from Thunder.vars import Var
 from Thunder.utils.logger import logger
+from Thunder.utils.error_handling import log_errors
 
+@log_errors
 async def ping_server():
-    # Periodically pings server URL to keep it alive
-    sleep_time = Var.PING_INTERVAL
-    
-    while True:
-        await asyncio.sleep(sleep_time)
-        try:
-            async with aiohttp.ClientSession(
-                timeout=aiohttp.ClientTimeout(total=10)            ) as session:
-                async with session.get(Var.URL) as resp:
-                    pass
-        except asyncio.TimeoutError:
-            logger.warning("Server ping timeout")
-        except Exception as e:
-            logger.error(f"Ping error: {str(e)}")
+    async with aiohttp.ClientSession(
+        timeout=aiohttp.ClientTimeout(total=10)
+    ) as session:
+        while True:
+            await asyncio.sleep(Var.PING_INTERVAL)
+            async with session.get(Var.URL) as resp:
+                if resp.status != 200:
+                    logger.warning(f"Ping to {Var.URL} returned status {resp.status}.")

Thunder/utils/logger.py

@@ -1,42 +1,38 @@
 # Thunder/utils/logger.py
 
 import logging
-from logging.handlers import RotatingFileHandler
-import sys
+from logging.handlers import RotatingFileHandler, QueueHandler, QueueListener
 import os
+import queue
+import atexit
 
-# Get project root and setup log directory
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-LOG_DIR = os.path.join(PROJECT_ROOT, 'logs')
+# Setup paths
+LOG_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'logs')
 os.makedirs(LOG_DIR, exist_ok=True)
 LOG_FILE = os.path.join(LOG_DIR, 'bot.txt')
 
-# Configure logger
-logger = logging.getLogger('ThunderBot')
-logger.setLevel(logging.INFO)
-logger.propagate = False
+logging._srcfile = None
+logging.logThreads = 0
+logging.logProcesses = 0 
+
+log_queue = queue.Queue(maxsize=10000)
 
-# Setup log formatting
-log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 
-# Configure rotating file handler (10MB max, 5 backup files)
-file_handler = RotatingFileHandler(
-    LOG_FILE,
-    maxBytes=10 * 1024 * 1024,
-    backupCount=5
-)
-file_handler.setFormatter(log_formatter)
-file_handler.setLevel(logging.INFO)
+file_handler = RotatingFileHandler(LOG_FILE, maxBytes=10*1024*1024, backupCount=5)
+file_handler.setFormatter(formatter)
 
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
 
-# Configure console output
-console_handler = logging.StreamHandler(sys.stdout)
-console_handler.setFormatter(log_formatter)
-console_handler.setLevel(logging.INFO)
+listener = QueueListener(log_queue, file_handler, console_handler, respect_handler_level=True)
+listener.start()
 
+logger = logging.getLogger('ThunderBot')
+logger.setLevel(logging.INFO)
+logger.propagate = False
+logger.addHandler(QueueHandler(log_queue))
 
-# Add handlers to our logger instance
-logger.addHandler(file_handler)
-logger.addHandler(console_handler)
+atexit.register(listener.stop)
 
 __all__ = ['logger', 'LOG_FILE']

Thunder/utils/messages.py

@@ -1,7 +1,4 @@
-"""
-Centralized message constants for the Thunder File to Link Bot.
-All user-facing strings should be defined here to maintain consistency and ease of maintenance.
-"""
+# Thunder/utils/messages.py
 
 # =====================================================================================
 # ====== ERROR MESSAGES ======
@@ -300,8 +297,8 @@ MSG_PROCESSING_REQUEST = "⏳ **Processing your request...**"
 MSG_PROCESSING_FILE = "⏳ **Processing your file...**"
 MSG_DEFAULT_FILENAME = "Untitled File"
 MSG_NEW_FILE_REQUEST = (
-    "> 👤 **Source:** [{user_name}](tg://user?id={user_id})\n"
-    "> 🆔 **ID:** `{user_id}`\n\n"
+    "> 👤 **Source:** [{source_info}](tg://user?id={id_})\n"
+    "> 🆔 **ID:** `{id_}`\n\n"
     "🔗 **Download:** `{online_link}`\n\n"
     "🖥️ **Stream:** `{stream_link}`"
 )

Thunder/utils/render_template.py

@@ -7,41 +7,36 @@ from Thunder.vars import Var
 from Thunder.bot import StreamBot
 from Thunder.utils.file_properties import get_file_ids
 from Thunder.server.exceptions import InvalidHash
-from Thunder.utils.logger import logger
+from Thunder.utils.error_handling import log_errors
 
-# Initialize Jinja2 environment
-template_env = Environment(loader=FileSystemLoader('Thunder/template'), enable_async=True)
+template_env = Environment(
+    loader=FileSystemLoader('Thunder/template'),
+    enable_async=True,
+    cache_size=200,
+    auto_reload=False,
+    optimized=True
+)
 
-async def render_page(id: int, secure_hash: str, requested_action: str | None = None) -> str: # Re-add requested_action
+@log_errors
+async def render_page(id: int, secure_hash: str, requested_action: str | None = None) -> str:
     file_data = await get_file_ids(StreamBot, int(Var.BIN_CHANNEL), id)
     if file_data.unique_id[:6] != secure_hash:
-        logger.debug(f'Link hash: {secure_hash} - Expected: {file_data.unique_id[:6]}')
-        logger.debug(f"Invalid hash for message ID {id}")
         raise InvalidHash
-
     quoted_filename = urllib.parse.quote(file_data.file_name.replace('/', '_'))
-    src = urllib.parse.urljoin(Var.URL, f'{secure_hash}{str(id)}/{quoted_filename}')
-    
+    src = urllib.parse.urljoin(Var.URL, f'{secure_hash}{id}/{quoted_filename}')
     safe_filename = html_module.escape(file_data.file_name)
-    
-    template_name: str
-    context: dict
-
     if requested_action == 'stream':
-        template_name = 'req.html'
+        template = template_env.get_template('req.html')
         context = {
             'tag': "video",
             'heading': f"View {safe_filename}",
             'file_name': safe_filename,
             'src': src
         }
-    else:  # Default to download
-        template_name = 'dl.html'
+    else:
+        template = template_env.get_template('dl.html')
         context = {
             'file_name': safe_filename,
             'src': src
         }
-
-    template = template_env.get_template(template_name)
-    html_content = await template.render_async(**context)
-    return html_content
+    return await template.render_async(**context)

Thunder/utils/retry_api.py

@@ -0,0 +1,91 @@
+# Thunder/utils/retry_api.py
+
+import asyncio
+import random
+from typing import Callable, TypeVar, Any, Awaitable
+from pyrogram.errors import FloodWait, RPCError
+from Thunder.utils.logger import logger
+
+T = TypeVar('T')
+DEFAULT_RETRY_COUNT = 3
+BASE_RETRY_DELAY = 1.0
+MAX_FLOOD_WAIT = 30
+MAX_JITTER_FACTOR = 0.1
+
+async def retry_api_call(
+    func: Callable[[], Awaitable[T]],
+    max_retries: int = DEFAULT_RETRY_COUNT,
+    base_delay: float = BASE_RETRY_DELAY,
+    operation_name: str = "API call"
+) -> T:
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.debug(f"Retry attempt {attempt} for {operation_name}.")
+            return await func()
+        except FloodWait as e:
+            if attempt == max_retries:
+                logger.error(f"Max retries reached for {operation_name} due to FloodWait: {e}")
+                raise
+            wait_time = min(e.value, MAX_FLOOD_WAIT)
+            logger.warning(f"FloodWait ({e.value}s) for {operation_name}, sleeping {wait_time}s before retry.")
+            await asyncio.sleep(wait_time)
+        except (asyncio.TimeoutError, RPCError) as e:
+            if attempt == max_retries:
+                logger.error(f"Max retries reached for {operation_name} due to {e.__class__.__name__}: {e}")
+                raise
+            delay = base_delay * (2 ** (attempt - 1))
+            jitter = random.uniform(0, delay * MAX_JITTER_FACTOR)
+            logger.warning(f"{e.__class__.__name__} during {operation_name}: {e}. Retrying in {delay + jitter:.2f}s.")
+            await asyncio.sleep(delay + jitter)
+        except Exception as e:
+            if attempt == max_retries:
+                logger.error(f"Max retries reached for {operation_name} due to unexpected error: {e}")
+                raise
+            delay = base_delay * (2 ** (attempt - 1))
+            logger.warning(f"Unexpected error {e.__class__.__name__} during {operation_name}: {e}. Retrying in {delay}s.")
+            await asyncio.sleep(delay)
+
+async def retry_api_operation(
+    client: Any,
+    operation: str,
+    *args: Any,
+    max_retries: int = DEFAULT_RETRY_COUNT,
+    base_delay: float = BASE_RETRY_DELAY,
+    **kwargs: Any
+) -> Any:
+    kwargs.pop("operation_name", None)
+    return await retry_api_call(
+        lambda: getattr(client, operation)(*args, **kwargs),
+        max_retries=max_retries,
+        base_delay=base_delay
+    )
+
+async def retry_get_chat_member(client: Any, chat_id: int, user_id: int, **kwargs) -> Any:
+    kwargs.pop("operation_name", None)
+    return await retry_api_operation(
+        client,
+        "get_chat_member",
+        chat_id,
+        user_id,
+        **kwargs
+    )
+
+async def retry_get_chat(client: Any, chat_id: int, **kwargs) -> Any:
+    kwargs.pop("operation_name", None)
+    return await retry_api_operation(
+        client,
+        "get_chat",
+        chat_id,
+        **kwargs
+    )
+
+async def retry_send_message(client: Any, chat_id: int, text: str, **kwargs) -> Any:
+    kwargs.pop("operation_name", None)
+    current_max_retries = kwargs.pop("max_retries", DEFAULT_RETRY_COUNT)
+    current_base_delay = kwargs.pop("base_delay", BASE_RETRY_DELAY)
+    return await retry_api_call(
+        lambda: client.send_message(chat_id=chat_id, text=text, **kwargs),
+        max_retries=current_max_retries,
+        base_delay=current_base_delay
+    )

Thunder/utils/shortener.py

@@ -1,243 +1,146 @@
-'''URL shortening utility.'''
-import asyncio
-from typing import Dict, Optional
+# Thunder/utils/shortener.py
+
+from abc import ABC, abstractmethod
 from base64 import b64encode
 from random import random, choice
-from urllib.parse import quote, urlparse
-from warnings import filterwarnings
+from urllib.parse import quote
 import cloudscraper
-
 from Thunder.vars import Var
 from Thunder.utils.logger import logger
 
-# Global shortener dictionary, scraper session, lock, and status flag
-shortener_dict: Dict[str, str] = {}
-_scraper_session: Optional[cloudscraper.CloudScraper] = None
-_init_lock = asyncio.Lock()
-_shortener_system_ready = False
+class ShortenerPlugin(ABC):
+    @classmethod
+    @abstractmethod
+    def matches(cls, domain: str) -> bool:
+        pass
+    
+    @abstractmethod
+    async def shorten(self, url: str, api_key: str) -> str:
+        pass
 
-# Suppress insecure HTTPS warnings
-try:
-    import urllib3
-    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-except (ImportError, AttributeError):
-    filterwarnings('ignore', message='Unverified HTTPS request')
+class LinkvertisePlugin(ShortenerPlugin):
+    @classmethod
+    def matches(cls, domain: str) -> bool:
+        return "linkvertise" in domain
+    
+    async def shorten(self, url: str, api_key: str) -> str:
+        encoded_url = quote(b64encode(url.encode("utf-8")))
+        return choice([
+            f"https://link-to.net/{api_key}/{random() * 1000}/dynamic?r={encoded_url}",
+            f"https://up-to-down.net/{api_key}/{random() * 1000}/dynamic?r={encoded_url}",
+            f"https://direct-link.net/{api_key}/{random() * 1000}/dynamic?r={encoded_url}",
+            f"https://file-link.net/{api_key}/{random() * 1000}/dynamic?r={encoded_url}",
+        ])
 
-def _init_shorteners() -> bool:
-    """Initializes shortener config and the global scraper session."""
-    global shortener_dict, _scraper_session, _shortener_system_ready
+class BitlyPlugin(ShortenerPlugin):
+    @classmethod
+    def matches(cls, domain: str) -> bool:
+        return "bitly.com" in domain
     
-    _shortener_system_ready = False # Assume failure until success
-    shortener_dict = {}
-    _scraper_session = None
+    async def shorten(self, url: str, api_key: str) -> str:
+        response = self.session.post(
+            "https://api-ssl.bit.ly/v4/shorten",
+            json={"long_url": url},
+            headers={"Authorization": f"Bearer {api_key}"}
+        )
+        if response.status_code == 200:
+            return response.json()["link"]
+        return url
+
+class OuoIoPlugin(ShortenerPlugin):
+    @classmethod
+    def matches(cls, domain: str) -> bool:
+        return "ouo.io" in domain
     
-    # Check if shortening is enabled via Var
-    is_enabled = getattr(Var, "SHORTEN_ENABLED", False) or getattr(Var, "SHORTEN_MEDIA_LINKS", False)
-    if not is_enabled:
-        logger.info("ⓘ URL shortening is disabled")
-        return False
+    async def shorten(self, url: str, api_key: str) -> str:
+        response = self.session.get(f"http://ouo.io/api/{api_key}?s={url}")
+        if response.status_code == 200 and response.text:
+            return response.text
+        return url
+
+class CuttLyPlugin(ShortenerPlugin):
+    @classmethod
+    def matches(cls, domain: str) -> bool:
+        return "cutt.ly" in domain
+    
+    async def shorten(self, url: str, api_key: str) -> str:
+        response = self.session.get(f"http://cutt.ly/api/api.php?key={api_key}&short={url}")
+        if response.status_code == 200:
+            return response.json()["url"]["shortLink"]
+        return url
+
+class GenericShortenerPlugin(ShortenerPlugin):
+    @classmethod
+    def matches(cls, domain: str) -> bool:
+        return True
     
-    # Get URL shortener configuration
-    site = getattr(Var, "URL_SHORTENER_SITE", "")
-    api_key = getattr(Var, "URL_SHORTENER_API_KEY", "")
+    async def shorten(self, url: str, api_key: str) -> str:
+        response = self.session.get(f"https://{self.domain}/api?api={api_key}&url={quote(url)}")
+        if response.status_code == 200:
+            return response.json().get("shortenedUrl", url)
+        return url
+
+class ShortenerSystem:
+    def __init__(self):
+        self.session = None
+        self.plugin = None
+        self.ready = False
+    
+    def _get_plugin_class(self, domain: str):
+        for plugin_class in ShortenerPlugin.__subclasses__():
+            if plugin_class.matches(domain):
+                return plugin_class
+
+        return GenericShortenerPlugin
     
-    if site and api_key:
-        shortener_dict[site] = api_key
+    async def initialize(self) -> bool:
+        if self.ready:
+            return True
+        
+        if not (getattr(Var, "SHORTEN_ENABLED", False) or 
+                getattr(Var, "SHORTEN_MEDIA_LINKS", False)):
+            return False
+        
+        site = getattr(Var, "URL_SHORTENER_SITE", "")
+        api_key = getattr(Var, "URL_SHORTENER_API_KEY", "")
+        
+        if not (site and api_key):
+            return False
+        
         try:
-            _scraper_session = cloudscraper.create_scraper(
+            self.session = cloudscraper.create_scraper(
                 browser={
                     'browser': 'chrome',
-                    'platform': 'android',
-                    'desktop': False
-                }
+                    'platform': 'windows',
+                    'desktop': True,
+                    'mobile': False
+                },
+                delay=1
             )
-            logger.info(f"✓ Shortener initialized: {site} (session created)")
-            _shortener_system_ready = True
+            
+            plugin_class = self._get_plugin_class(site)
+            self.plugin = plugin_class()
+            self.plugin.session = self.session
+            self.plugin.domain = site
+            self.ready = True
             return True
         except Exception as e:
-            logger.error(f"Failed to create scraper session: {e}")
-            # Reset to ensure clean state on session creation failure
-            shortener_dict = {}
-            _scraper_session = None
-            _shortener_system_ready = False
+            logger.error(f"Failed to initialize ShortenerSystem: {e}")
             return False
     
-    logger.warning("ⓘ URL shortener not configured or API key missing")
-    _shortener_system_ready = False # Explicitly ensure it's false
-    return False
-
-def _validate_url(url: str) -> bool:
-    """Checks if a string is a well-formed URL."""
-    try:
-        result = urlparse(url)
-        return all([result.scheme, result.netloc])
-    except Exception:
-        return False
-
-async def short_url(longurl: str, attempt: int = 0) -> str:
-    """Shortens a URL using a configured service, with retries and fallback."""
-    global _shortener_system_ready, _scraper_session # Ensure globals are accessible
-
-    if not _shortener_system_ready:  # First check (no lock)
-        async with _init_lock:
-            if not _shortener_system_ready:  # Double check (with lock)
-                _init_shorteners()  # Attempt initialization
-
-    if not _shortener_system_ready:
-        # Initialization failed or not enabled, _init_shorteners logs details
-        return longurl
+    async def short_url(self, url: str) -> str:
+        if not self.ready:
+            return url
         
-    if _scraper_session is None:
-        logger.error(
-            "Critical state: _shortener_system_ready is True, but _scraper_session is None. "
-            "Attempting a locked re-initialization."
-        )
-        async with _init_lock:
-            _init_shorteners()
-        
-        if not _shortener_system_ready or _scraper_session is None:
-            logger.error(
-                "Critical: Scraper session remains uninitialized after re-attempt. "
-                "URL shortening will be skipped for this request."
-            )
-            return longurl
+        try:
+            return await self.plugin.shorten(url, Var.URL_SHORTENER_API_KEY)
+        except Exception as e:
+            logger.error(f"Error shortening URL {url}: {e}")
+            return url
 
-    if attempt >= 3:
-        logger.warning(f"Max attempts reached for {longurl}. Returning original.")
-        return longurl
-    
-    if not _validate_url(longurl):
-        logger.warning(f"Invalid URL format: {longurl}. Returning original.")
-        return longurl
-    
-    try:
-        session = _scraper_session 
-        
-        # Ensure shortener_dict is not empty before trying to access its items
-        if not shortener_dict:
-            logger.error("Shortener dictionary is empty. Cannot proceed with shortening.")
-            return longurl # Or raise an exception if this state is unexpected
-            
-        _shortener, _shortener_api = choice(list(shortener_dict.items()))
-        
-        # --- Shorte.st --- 
-        if "shorte.st" in _shortener:
-            headers = {"public-api-token": _shortener_api}
-            data = {"urlToShorten": quote(longurl)}
-            response = session.put(
-                "https://api.shorte.st/v1/data/url",
-                headers=headers,
-                data=data
-            )
-            
-            if response.status_code != 200:
-                raise Exception(f"HTTP error {response.status_code}")
-                
-            return response.json()["shortenedUrl"]
-            
-        # --- Linkvertise ---        
-        elif "linkvertise" in _shortener:
-            url = quote(b64encode(longurl.encode("utf-8")))
-            linkvertise = [
-                f"https://link-to.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
-                f"https://up-to-down.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
-                f"https://direct-link.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
-                f"https://file-link.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
-            ]
-            return choice(linkvertise)
-            
-        # --- Bitly.com ---    
-        elif "bitly.com" in _shortener:
-            headers = {"Authorization": f"Bearer {_shortener_api}"}
-            response = session.post(
-                "https://api-ssl.bit.ly/v4/shorten",
-                json={"long_url": longurl},
-                headers=headers
-            )
-            
-            if response.status_code != 200:
-                raise Exception(f"HTTP error {response.status_code}")
-                
-            return response.json()["link"]
-            
-        # --- Ouo.io ---    
-        elif "ouo.io" in _shortener:
-            response = session.get(
-                f"http://ouo.io/api/{_shortener_api}?s={longurl}",
-                verify=False
-            )
-            
-            if not response.text or response.status_code != 200:
-                raise Exception(f"HTTP error {response.status_code}")
-                
-            return response.text
-            
-        # --- Cutt.ly ---    
-        elif "cutt.ly" in _shortener:
-            response = session.get(
-                f"http://cutt.ly/api/api.php?key={_shortener_api}&short={longurl}"
-            )
-            
-            if response.status_code != 200:
-                raise Exception(f"HTTP error {response.status_code}")
-                
-            return response.json()["url"]["shortLink"]
-            
-        # --- Generic & Fallback ---    
-        else:
-            # Generic shortener handling
-            response = session.get(
-                f"https://{_shortener}/api?api={_shortener_api}&url={quote(longurl)}"
-            )
-            
-            if response.status_code != 200:
-                raise Exception(f"Generic API error {response.status_code}")
-                
-            result = response.json()
-            shorted = result.get("shortenedUrl")
-            
-            # Fallback to shrtco.de if generic failed or no result
-            if not shorted:
-                try:
-                    shrtco_response = session.get(
-                        f"https://api.shrtco.de/v2/shorten?url={quote(longurl)}"
-                    )
-                    
-                    if shrtco_response.status_code != 200:
-                        logger.warning(f"shrtco.de fallback failed with status {shrtco_response.status_code}")
-                        return longurl # Return original if fallback also fails badly
-                        
-                    shrtco_result = shrtco_response.json()
-                    if not shrtco_result.get("ok") or "result" not in shrtco_result or "full_short_link" not in shrtco_result["result"]:
-                        logger.warning(f"shrtco.de fallback response malformed: {shrtco_result}")
-                        return longurl
-                        
-                    shrtco_link = shrtco_result["result"]["full_short_link"]
-                    
-                    # Try the configured generic shortener again with the shrtco.de link
-                    response = session.get(
-                        f"https://{_shortener}/api?api={_shortener_api}&url={shrtco_link}"
-                    )
-                    
-                    if response.status_code != 200:
-                        logger.warning(f"Generic shortener retry with shrtco.de link failed: status {response.status_code}")
-                        return longurl # Return original if retry fails
-                        
-                    result = response.json()
-                    shorted = result.get("shortenedUrl")
-                except Exception as fallback_e:
-                    logger.error(f"shrtco.de fallback exception: {fallback_e}")
-                    return longurl # Return original on fallback exception
-            
-            return shorted if shorted else longurl
-            
-    except Exception as e:
-        shortener_name = _shortener if '_shortener' in locals() else 'unknown'
-        logger.error(f"URL shortener error ({shortener_name} for {longurl}): {e}, attempt {attempt + 1}")
-        
-        await asyncio.sleep(1) # Wait before retrying
-        return await short_url(longurl, attempt + 1)
+_system = ShortenerSystem()
 
 async def shorten(url: str) -> str:
-    """Async public wrapper for short_url."""
-    return await short_url(url)
+    if not _system.ready:
+        await _system.initialize()
+    return await _system.short_url(url)

Thunder/utils/time_format.py

@@ -1,18 +1,12 @@
-# Thunder/utils/time_format.py
+from Thunder.utils.error_handling import log_errors
 
+_TIME_PERIODS = (('d', 86400), ('h', 3600), ('m', 60), ('s', 1))
+
+@log_errors
 def get_readable_time(seconds: int) -> str:
-    # Convert seconds to human-readable time format (e.g., "2d 5h 30m 10s")
-    periods = [
-        ('d', 86400),  # Days
-        ('h', 3600),   # Hours
-        ('m', 60),     # Minutes
-        ('s', 1)       # Seconds
-    ]
     result = []
-
-    for suffix, period in periods:
+    for suffix, period in _TIME_PERIODS:
         if seconds >= period:
             value, seconds = divmod(seconds, period)
-            result.append(f"{int(value)}{suffix}")
-
+            result.append(f"{value}{suffix}")
     return ' '.join(result) if result else '0s'

Thunder/utils/tokens.py

@@ -1,265 +1,139 @@
-"""
-Token generation, verification, and authorization management for the Thunder bot.
-"""
-
-import uuid
+import secrets
 from datetime import datetime, timedelta
-from typing import Optional, Dict, Any, AsyncIterator, List, Union
-from motor.motor_asyncio import AsyncIOMotorCursor
-
+from typing import Optional, Dict, Any, List
 from Thunder.utils.database import db
-from Thunder.utils.logger import logger
 from Thunder.vars import Var
+from Thunder.utils.error_handling import log_errors
+
+_OWNER_IDS_CACHE = None
+
+def _get_owner_ids():
+    global _OWNER_IDS_CACHE
+    if _OWNER_IDS_CACHE is None:
+        owner_id = Var.OWNER_ID
+        _OWNER_IDS_CACHE = set(owner_id if isinstance(owner_id, (list, tuple, set)) else [owner_id])
+    return _OWNER_IDS_CACHE
 
+@log_errors
 async def check(user_id: int) -> bool:
-    """
-    Verify if a user has a valid token.
-    
-    Args:
-        user_id: User's Telegram ID
-        
-    Returns:
-        bool: True if user has valid token, False otherwise
-    """
-    try:
-        # Check if token system is enabled
-        if not getattr(Var, "TOKEN_ENABLED", False):
-            return True  # Token system disabled
-            
-        # Check if user is owner
-        if isinstance(Var.OWNER_ID, (list, tuple, set)):
-            is_owner = user_id in Var.OWNER_ID
-        else:
-            is_owner = user_id == Var.OWNER_ID
-            
-        # Check if user is owner or authorized
-        if is_owner or await allowed(user_id):
-            return True
-            
-        # Check for valid token
-        token_data = await db.token_col.find_one({"user_id": user_id})
-        if not token_data:
-            return False
-            
-        # Check if token is expired
-        if token_data["expires_at"] <= datetime.utcnow():
-            return False
-            
+    if not getattr(Var, "TOKEN_ENABLED", False):
         return True
-    except Exception as e:
-        logger.error(f"Error in token check for user {user_id}: {e}")
-        return False
+    if user_id in _get_owner_ids():
+        return True
+    current_time = datetime.utcnow()
+    auth_result = await db.authorized_users_col.find_one(
+        {"user_id": user_id},
+        {"_id": 1}
+    )
+    if auth_result:
+        return True
+    token_result = await db.token_col.find_one(
+        {"user_id": user_id, "expires_at": {"$gt": current_time}},
+        {"_id": 1}
+    )
+    return bool(token_result)
 
+@log_errors
 async def generate(user_id: int) -> Dict[str, Any]:
-    """
-    Generate a new token for a user.
-    
-    Args:
-        user_id: User's Telegram ID
-        
-    Returns:
-        dict: Token data with expiration time
-    """
-    try:
-        duration = getattr(Var, "TOKEN_TTL_HOURS", 24)
-        token = str(uuid.uuid4())
-        created_at = datetime.utcnow()
-        expires_at = created_at + timedelta(hours=duration)
-        
-        token_data = {
-            "user_id": user_id,
-            "token": token,
-            "created_at": created_at,
-            "expires_at": expires_at
-        }
-        
-        # Store or update token in database
-        await db.token_col.update_one(
-            {"user_id": user_id},
-            {"$set": token_data},
-            upsert=True
-        )
-        
-        return token_data
-    except Exception as e:
-        logger.error(f"Failed to generate token for user {user_id}: {e}")
-        raise
+    duration = getattr(Var, "TOKEN_TTL_HOURS", 24)
+    token = secrets.token_urlsafe(32)
+    created_at = datetime.utcnow()
+    expires_at = created_at + timedelta(hours=duration)
+    token_data = {
+        "user_id": user_id,
+        "token": token,
+        "created_at": created_at,
+        "expires_at": expires_at
+    }
+    await db.token_col.update_one(
+        {"user_id": user_id},
+        {"$set": token_data},
+        upsert=True
+    )
+    return token_data
 
+@log_errors
 async def allowed(user_id: int) -> bool:
-    """
-    Check if a user is authorized (permanently allowed).
-    
-    Args:
-        user_id: User's Telegram ID
-        
-    Returns:
-        bool: True if user is authorized, False otherwise
-    """
-    try:
-        auth_data = await db.authorized_users_col.find_one({"user_id": user_id})
-        return bool(auth_data)
-    except Exception as e:
-        logger.error(f"Error checking authorization for user {user_id}: {e}")
-        return False
+    result = await db.authorized_users_col.find_one(
+        {"user_id": user_id},
+        {"_id": 1}
+    )
+    return bool(result)
 
+@log_errors
 async def authorize(user_id: int, authorized_by: int) -> bool:
-    """
-    Authorize a user to use the bot permanently.
-    
-    Args:
-        user_id: User's Telegram ID to authorize
-        authorized_by: Admin's Telegram ID who authorized
-        
-    Returns:
-        bool: True if successful, False otherwise
-    """
-    try:
-        auth_data = {
-            "user_id": user_id,
-            "authorized_by": authorized_by,
-            "authorized_at": datetime.utcnow()
-        }
-        
-        await db.authorized_users_col.update_one(
-            {"user_id": user_id},
-            {"$set": auth_data},
-            upsert=True
-        )
-        
-        return True
-    except Exception as e:
-        logger.error(f"Failed to authorize user {user_id}: {e}")
-        return False
+    auth_data = {
+        "user_id": user_id,
+        "authorized_by": authorized_by,
+        "authorized_at": datetime.utcnow()
+    }
+    await db.authorized_users_col.update_one(
+        {"user_id": user_id},
+        {"$set": auth_data},
+        upsert=True
+    )
+    return True
 
+@log_errors
 async def deauthorize(user_id: int) -> bool:
-    """
-    Remove a user's authorization.
-    
-    Args:
-        user_id: User's Telegram ID to deauthorize
-        
-    Returns:
-        bool: True if successful, False otherwise
-    """
-    try:
-        result = await db.authorized_users_col.delete_one({"user_id": user_id})
-        return result.deleted_count > 0
-    except Exception as e:
-        logger.error(f"Failed to deauthorize user {user_id}: {e}")
-        return False
+    result = await db.authorized_users_col.delete_one({"user_id": user_id})
+    return result.deleted_count > 0
 
+@log_errors
 async def get_user(user_id: int) -> Optional[Dict[str, Any]]:
-    """
-    Get information about a user's token.
-    
-    Args:
-        user_id: User's Telegram ID
-        
-    Returns:
-        dict or None: Token data if found, None otherwise
-    """
-    try:
-        return await db.token_col.find_one({"user_id": user_id})
-    except Exception as e:
-        logger.error(f"Failed to get token data for user {user_id}: {e}")
-        return None
+    return await db.token_col.find_one({"user_id": user_id})
 
+@log_errors
 async def get(token: str) -> Optional[Dict[str, Any]]:
-    """
-    Retrieve token record by token string.
-    
-    Args:
-        token: Token string to look up
-        
-    Returns:
-        dict or None: Token data if found, None otherwise
-    """
-    try:
-        return await db.token_col.find_one({"token": token})
-    except Exception as e:
-        logger.error(f"Failed to get token data: {e}")
-        return None
+    return await db.token_col.find_one({"token": token})
 
+@log_errors
 async def list_allowed() -> List[Dict[str, Any]]:
-    """
-    Get all authorized users.
-    
-    Returns:
-        List[Dict[str, Any]]: List of authorized users data
-    """
-    try:
-        cursor = db.authorized_users_col.find({})
-        return await cursor.to_list(length=None)
-    except Exception as e:
-        logger.error(f"Failed to list authorized users: {e}")
-        return []
+    cursor = db.authorized_users_col.find(
+        {},
+        {"user_id": 1, "authorized_by": 1, "authorized_at": 1}
+    )
+    return await cursor.to_list(length=None)
 
+@log_errors
 async def list_tokens() -> List[Dict[str, Any]]:
-    """
-    Get all active tokens.
-    
-    Returns:
-        List[Dict[str, Any]]: List of active tokens data
-    """
-    try:
-        cursor = db.token_col.find({})
-        return await cursor.to_list(length=None)
-    except Exception as e:
-        logger.error(f"Failed to list tokens: {e}")
-        return []
+    current_time = datetime.utcnow()
+    cursor = db.token_col.find(
+        {"expires_at": {"$gt": current_time}},
+        {"user_id": 1, "expires_at": 1, "created_at": 1}
+    )
+    return await cursor.to_list(length=None)
 
+@log_errors
 async def validate_activation_token(token: str) -> Dict[str, Any]:
-    """
-    Validates an activation token and returns validation status.
-    
-    Args:
-        token: The token string to validate
-        
-    Returns:
-        dict: Validation result with status and details
-    """
-    try:
-        # Remove 'token' prefix if present
-        clean_token = token
-        if token.startswith("token"):
-            # Handle different possible separators
-            if len(token) > 5 and token[5] in ('-', '_'):
-                clean_token = token[6:]  # Skip prefix and separator
-            else:
-                clean_token = token[5:]  # Skip just the prefix
-                
-        # Check if token exists in database
-        token_record = await get(clean_token)
-        if not token_record:
-            return {
-                "valid": False,
-                "reason": "Token does not exist or has been revoked",
-                "token": clean_token
-            }
-            
-        # Check if token is expired
-        if token_record["expires_at"] <= datetime.utcnow():
-            return {
-                "valid": False,
-                "reason": "Token has expired",
-                "token": clean_token,
-                "expiry_date": token_record["expires_at"].strftime("%Y-%m-%d %H:%M:%S UTC")
-            }
-            
-        # Token is valid
+    clean_token = token
+    if token.startswith("token"):
+        clean_token = token[6:] if len(token) > 5 and token[5] in ('-', '_') else token[5:]
+    current_time = datetime.utcnow()
+    token_record = await db.token_col.find_one({"token": clean_token})
+    if not token_record:
         return {
-            "valid": True,
-            "token": clean_token,
-            "user_id": token_record["user_id"],
-            "expiry_date": token_record["expires_at"].strftime("%Y-%m-%d %H:%M:%S UTC"),
-            "created_at": token_record["created_at"].strftime("%Y-%m-%d %H:%M:%S UTC"),
-            "description": "Access token"
+            "valid": False,
+            "reason": "Token does not exist or has been revoked",
+            "token": clean_token
         }
-        
-    except Exception as e:
-        logger.error(f"Error validating token: {e}")
+    if token_record["expires_at"] <= current_time:
         return {
             "valid": False,
-            "reason": f"An error occurred during validation: {str(e)}",
-            "token": token
+            "reason": "Token has expired",
+            "token": clean_token,
+            "expiry_date": token_record["expires_at"].strftime("%Y-%m-%d %H:%M:%S UTC")
         }
+    return {
+        "valid": True,
+        "token": clean_token,
+        "user_id": token_record["user_id"],
+        "expiry_date": token_record["expires_at"].strftime("%Y-%m-%d %H:%M:%S UTC"),
+        "created_at": token_record["created_at"].strftime("%Y-%m-%d %H:%M:%S UTC"),
+        "description": "Access token"
+    }
+
+@log_errors
+async def cleanup_expired_tokens() -> int:
+    result = await db.token_col.delete_many({"expires_at": {"$lte": datetime.utcnow()}})
+    return result.deleted_count

Thunder/vars.py

@@ -1,7 +1,3 @@
-"""
-Thunder/vars.py - Configuration variables for the Thunder bot.
-"""
-
 from typing import Set, Optional, List, Dict
 import os
 from dotenv import load_dotenv
@@ -10,54 +6,37 @@ from Thunder.utils.logger import logger
 # Load environment variables from config.env
 load_dotenv("config.env")
 
-# Helper functions for parsing environment variables
 def str_to_bool(val: str) -> bool:
-    """Convert string value to boolean."""
     return val.lower() in ("true", "1", "t", "y", "yes")
 
 def str_to_int_list(val: str) -> List[int]:
-    """Convert space-separated string to list of integers."""
-    if not val:
-        return []
-    return [int(x) for x in val.split() if x.isdigit()]
+    return [int(x) for x in val.split() if x.isdigit()] if val else []
 
 def str_to_int_set(val: str) -> Set[int]:
-    """Convert space-separated string to set of integers."""
-    if not val:
-        return set()
-    return set(int(x) for x in val.split() if x.isdigit())
+    return {int(x) for x in val.split() if x.isdigit()} if val else set()
 
 class Var:
-    """Configuration variables for the Thunder bot."""
 
     # Telegram API credentials
     API_ID: int = int(os.getenv("API_ID", ""))
-    if not API_ID:
-        logger.critical("CRITICAL: API_ID is not configured in config.env!")
-        raise ValueError("CRITICAL: API_ID is not configured in config.env!")
-        
     API_HASH: str = os.getenv("API_HASH", "")
-    if not API_HASH:
-        logger.critical("CRITICAL: API_HASH is not configured in config.env!")
-        raise ValueError("CRITICAL: API_HASH is not configured in config.env!")
-
-    # Bot token and identity
     BOT_TOKEN: str = os.getenv("BOT_TOKEN", "")
-    if not BOT_TOKEN:
-        logger.critical("CRITICAL: BOT_TOKEN is not configured in config.env!")
-        raise ValueError("CRITICAL: BOT_TOKEN is not configured in config.env!")
-    NAME: str = os.getenv("NAME", "ThunderF2L")
     
-    # Performance settings
-    SLEEP_THRESHOLD: int = int(os.getenv("SLEEP_THRESHOLD", "60"))
+    if not all([API_ID, API_HASH, BOT_TOKEN]):
+        logger.critical("Missing required Telegram API configuration")
+        raise ValueError("Missing required Telegram API configuration")
+
+    # Bot identity and performance
+    NAME: str = os.getenv("NAME", "ThunderF2L")
+    SLEEP_THRESHOLD: int = int(os.getenv("SLEEP_THRESHOLD", "30"))
     WORKERS: int = int(os.getenv("WORKERS", "100"))
-    TIMEOUT: int = int(os.getenv("TIMEOUT", "30"))
+    TIMEOUT: int = int(os.getenv("TIMEOUT", "90"))
 
     # Channel for file storage
     BIN_CHANNEL: int = int(os.getenv("BIN_CHANNEL", "0"))
     if not BIN_CHANNEL:
-        logger.critical("CRITICAL: BIN_CHANNEL is not configured in config.env!")
-        raise ValueError("CRITICAL: BIN_CHANNEL is not configured in config.env!")
+        logger.critical("BIN_CHANNEL is required")
+        raise ValueError("BIN_CHANNEL is required")
 
     # Web server configuration
     PORT: int = int(os.getenv("PORT", "8080"))
@@ -82,8 +61,8 @@ class Var:
     # Database configuration
     DATABASE_URL: str = os.getenv("DATABASE_URL", "")
     if not DATABASE_URL:
-        logger.critical("CRITICAL: DATABASE_URL is not configured in config.env!")
-        raise ValueError("CRITICAL: DATABASE_URL is not configured in config.env!")
+        logger.critical("DATABASE_URL is required")
+        raise ValueError("DATABASE_URL is required")
 
     # Channel configurations
     BANNED_CHANNELS: Set[int] = str_to_int_set(os.getenv("BANNED_CHANNELS", ""))