1.9.2

feat: Centralize rate limiting and add auto-command setup

- Centralized rate limit handling to improve API reliability.
- Increased default sleep threshold from 120s to 300s.
- Added `SET_COMMANDS` option for automatic command registration.
- Refined bot command descriptions for clarity and consistency.
- Updated documentation for new features and command ordering.

README.md

@@ -43,7 +43,8 @@
 
 **Perfect for:**
 
-- 📤 Download Telegram media at high speed.
+- 🚀 Download Telegram media at high speed.
+- ☁️ Leveraging free unlimited cloud storage with high-speed links.
 - 🎬 Content creators sharing media files.
 - 👥 Communities distributing resources.
 - 🎓 Educational platforms sharing materials.
@@ -53,7 +54,7 @@
 
 ## ✨ Features
 
-### 🚀 Core Functionality
+### 🧠 Core Functionality
 
 - **Generate Direct Links:** Convert Telegram media files into direct streaming links.
 - **Permanent Links:** Links remain active as long as the file exists in the storage channel.
@@ -63,6 +64,7 @@
 - **Channel and Group Support:** Works in private chats, groups, and channels.
 - **MongoDB Integration:** Store user data and info with advanced database capabilities.
 - **HTTP/HTTPS Streaming:** Stream media with custom player support for all devices and browsers.
+- **Flood Wait Handling:** Centralized handling for Telegram flood waits.
 
 ### 🧩 Advanced Features
 
@@ -74,6 +76,7 @@
 - **Custom Domain Support:** Use your own domain for streaming links.
 - **Customizable Templates:** Personalize HTML templates for download pages.
 - **Data Center Info:** Get data center information for users and files.
+- **Auto Set Commands:** Automatically set bot commands on startup.
 
 ### ⚙️ Technical Capabilities
 
@@ -132,7 +135,7 @@ Rename `config_sample.env` to `config.env` and edit the following variables:
 | `MULTI_BOT_TOKENS`   | Additional bot tokens for load balancing | *(empty)* | `MULTI_TOKEN1=`              |
 | `FORCE_CHANNEL_ID`   | Channel ID users must join               | *(empty)* | `-1001234567890`              |
 | `BANNED_CHANNELS`    | Space-separated banned channel IDs       | *(empty)* | `-1001234567890 -100987654321`|
-| `SLEEP_THRESHOLD`    | Threshold for client switching           | `120`      | `30`                          |
+| `SLEEP_THRESHOLD`    | Threshold for client switching           | `300`      | `600`                          |
 | `WORKERS`            | Number of async workers                  | `8`     | `200`                         |
 | `NAME`               | Bot application name                     | `ThunderF2L` | `MyFileBot`                |
 | `BIND_ADDRESS`       | Address to bind web server               | `0.0.0.0` | `127.0.0.1`                   |
@@ -143,6 +146,7 @@ Rename `config_sample.env` to `config.env` and edit the following variables:
 | `SHORTEN_MEDIA_LINKS`| Enable URL shortening for media links   | `False`   | `True`                         |
 | `URL_SHORTENER_API_KEY` | API key for URL shortening service    | `""`      | `"abc123def456"`               |
 | `URL_SHORTENER_SITE` | URL shortening service to use           | `""`      | `"example.com"`                  |
+| `SET_COMMANDS`       | Automatically set bot commands on startup | `True`   | `False`                           |
 
 > ℹ️ For all options, see `config_sample.env`.
 
@@ -226,24 +230,26 @@ python -m Thunder
 
 ### Commands for @BotFather
 
-Paste the following into the BotFather "Edit Commands" section for your bot:
+> If `SET_COMMANDS` is set to `True` in your configuration, the bot will automatically configure these commands.
+
+Paste the following into the BotFather "Edit Commands" section for your bot.
 
 ```text
 start - Start the bot and get a welcome message
-link - Generate a direct link for a file (supports batch in groups)
-dc - Get the data center (DC) of a user or file
-ping - Check if the bot is online
+link - (Group) Generate a direct link for a file or batch
+dc - Retrieve the data center (DC) information of a user or file
+ping - Check the bot's status and response time
 about - Get information about the bot
 help - Show help and usage instructions
-status - (Admin) Check bot status, uptime, and resource usage
+status - (Admin) View bot details and current workload
+stats - (Admin) View usage statistics and resource consumption
 broadcast - (Admin) Send a message to all users
-stats - (Admin) View usage statistics and analytics
 ban - (Admin) Ban a user
 unban - (Admin) Unban a user
 log - (Admin) Send bot logs
 restart - (Admin) Restart the bot
 shell - (Admin) Execute a shell command
-users - (Admin) Show total number of users
+users - (Admin) Show the total number of users
 authorize - (Admin) Grant permanent access to a user
 deauthorize - (Admin) Remove permanent access from a user
 listauth - (Admin) List all authorized users

Thunder/__init__.py

@@ -3,4 +3,4 @@
 import time
 
 StartTime = time.time()
-__version__ = "1.9.1"
+__version__ = "1.9.2"

Thunder/__main__.py

@@ -1,27 +1,27 @@
 # Thunder/__main__.py
 
-import os
-import sys
-import glob
 import asyncio
+import glob
 import importlib.util
-
-from aiohttp import web
+import os
+import sys
 from datetime import datetime
 from pathlib import Path
 
+from aiohttp import web
 from pyrogram import idle
-from pyrogram.errors import FloodWait
 
 from Thunder import __version__
 from Thunder.bot import StreamBot
-from Thunder.bot.clients import initialize_clients, cleanup_clients
+from Thunder.bot.clients import cleanup_clients, initialize_clients
+from Thunder.server import web_server
+from Thunder.utils.commands import set_commands
 from Thunder.utils.database import db
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.keepalive import ping_server
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import MSG_ADMIN_RESTART_DONE
 from Thunder.utils.tokens import cleanup_expired_tokens
-from Thunder.server import web_server
 from Thunder.vars import Var
 
 PLUGIN_PATH = "Thunder/bot/plugins/*.py"
@@ -88,33 +88,23 @@ async def start_services():
 
     print("   ▶ Starting Telegram Bot initialization...")
     try:
-        try:
-            await StreamBot.start()
-            bot_info = await StreamBot.get_me()
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            await StreamBot.start()
-            bot_info = await StreamBot.get_me()
+        await handle_flood_wait(StreamBot.start)
+        bot_info = await handle_flood_wait(StreamBot.get_me)
         StreamBot.username = bot_info.username
         print(f"   ✓ Bot initialized successfully as @{StreamBot.username}")
 
+        await set_commands()
+        print("   ✓ Bot commands set successfully.")
+
         restart_message_data = await db.get_restart_message()
         if restart_message_data:
             try:
-                try:
-                    await StreamBot.edit_message_text(
-                        chat_id=restart_message_data["chat_id"],
-                        message_id=restart_message_data["message_id"],
-                        text=MSG_ADMIN_RESTART_DONE
-                    )
-                except FloodWait as e:
-                    logger.debug(f"FloodWait in restart message: sleeping for {e.value}s")
-                    await asyncio.sleep(e.value)
-                    await StreamBot.edit_message_text(
-                        chat_id=restart_message_data["chat_id"],
-                        message_id=restart_message_data["message_id"],
-                        text=MSG_ADMIN_RESTART_DONE
-                    )
+                await handle_flood_wait(
+                    StreamBot.edit_message_text,
+                    chat_id=restart_message_data["chat_id"],
+                    message_id=restart_message_data["message_id"],
+                    text=MSG_ADMIN_RESTART_DONE
+                )
                 await db.delete_restart_message(restart_message_data["message_id"])
             except Exception as e:
                 logger.error(f"Error processing restart message: {e}", exc_info=True)

Thunder/bot/clients.py

@@ -3,18 +3,17 @@
 import asyncio
 
 from pyrogram import Client
-from pyrogram.errors import FloodWait
 
-from Thunder.vars import Var
+from Thunder.bot import StreamBot, multi_clients, work_loads
 from Thunder.utils.config_parser import TokenParser
-from Thunder.bot import multi_clients, work_loads, StreamBot
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
-
+from Thunder.vars import Var
 
 async def cleanup_clients():
     for client in multi_clients.values():
         try:
-            await client.stop()
+            await handle_flood_wait(client.stop)
         except Exception as e:
             logger.error(f"Error stopping client: {e}", exc_info=True)
 
@@ -41,18 +40,15 @@ async def initialize_clients():
             if client_id == len(all_tokens):
                 await asyncio.sleep(2)
             client = Client(
-                name=str(client_id),
-                api_id=Var.API_ID,
                 api_hash=Var.API_HASH,
+                api_id=Var.API_ID,
                 bot_token=token,
-                sleep_threshold=Var.SLEEP_THRESHOLD,
-                in_memory=True
+                in_memory=True,
+                name=str(client_id),
+                no_updates=True,
+                sleep_threshold=Var.SLEEP_THRESHOLD
             )
-            try:
-                await client.start()
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                await client.start()
+            await handle_flood_wait(client.start)
             work_loads[client_id] = 0
             print(f"   ◎ Client ID {client_id} started")
             return client_id, client

Thunder/bot/plugins/admin.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import html
-import psutil
 import os
 import shutil
 import sys
@@ -10,17 +9,18 @@ import time
 from datetime import datetime
 from io import BytesIO
 
+import psutil
 from pyrogram import filters
 from pyrogram.client import Client
 from pyrogram.enums import ParseMode
-from pyrogram.errors import FloodWait
-from pyrogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
 
 from Thunder import StartTime, __version__
 from Thunder.bot import StreamBot, multi_clients, work_loads
-from Thunder.bot.plugins.common import retry, reply
+from Thunder.utils.bot_utils import reply
 from Thunder.utils.broadcast import broadcast_message
 from Thunder.utils.database import db
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.human_readable import humanbytes
 from Thunder.utils.logger import LOG_FILE, logger
 from Thunder.utils.messages import *
@@ -34,13 +34,13 @@ owner_filter = filters.private & filters.user(Var.OWNER_ID)
 async def get_total_users(client: Client, message: Message):
     try:
         total = await db.total_users_count()
-        await retry(reply, message,
+        await reply(message,
                    text=MSG_DB_STATS.format(total_users=total),
                    parse_mode=ParseMode.MARKDOWN,
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]]))
     except Exception as e:
         logger.error(f"Error in get_total_users: {e}", exc_info=True)
-        await retry(reply, message, text=MSG_DB_ERROR)
+        await reply(message, text=MSG_DB_ERROR)
 
 @StreamBot.on_message(filters.command("broadcast") & owner_filter & filters.reply)
 async def broadcast_handler(client: Client, message: Message):
@@ -57,13 +57,13 @@ async def show_status(client: Client, message: Message):
         
         total_workload = sum(work_loads.values())
         status_text_str = MSG_SYSTEM_STATUS.format(uptime=uptime_str, active_bots=len(multi_clients), total_workload=total_workload, workload_items=workload_items, version=__version__)
-        await retry(reply, message,
+        await reply(message,
                    text=status_text_str,
                    parse_mode=ParseMode.MARKDOWN,
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]]))
     except Exception as e:
         logger.error(f"Error in show_status: {e}", exc_info=True)
-        await retry(reply, message, text=MSG_STATUS_ERROR)
+        await reply(message, text=MSG_STATUS_ERROR)
 
 @StreamBot.on_message(filters.command("stats") & owner_filter)
 async def show_stats(client: Client, message: Message):
@@ -99,72 +99,69 @@ async def show_stats(client: Client, message: Message):
             download=humanbytes(net_io_counters.bytes_recv)
         )
 
-        await retry(reply, message,
+        await reply(message,
                    text=stats_text_val,
                    parse_mode=ParseMode.MARKDOWN,
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]]))
     except Exception as e:
         logger.error(f"Error in show_stats: {e}", exc_info=True)
-        await retry(reply, message, text=MSG_STATUS_ERROR)
+        await reply(message, text=MSG_STATUS_ERROR)
 
 @StreamBot.on_message(filters.command("restart") & owner_filter)
 async def restart_bot(client: Client, message: Message):
-    msg = await retry(reply, message, text=MSG_RESTARTING)
+    msg = await reply(message, text=MSG_RESTARTING)
     await db.add_restart_message(msg.id, message.chat.id)
     os.execv(sys.executable, [sys.executable, "-m", "Thunder"])
 
 @StreamBot.on_message(filters.command("log") & owner_filter)
 async def send_logs(client: Client, message: Message):
     if not os.path.exists(LOG_FILE) or os.path.getsize(LOG_FILE) == 0:
-        await retry(reply, message, text=MSG_LOG_FILE_MISSING if not os.path.exists(LOG_FILE) else MSG_LOG_FILE_EMPTY)
+        await reply(message, text=MSG_LOG_FILE_MISSING if not os.path.exists(LOG_FILE) else MSG_LOG_FILE_EMPTY)
         return
     
     try:
-        await message.reply_document(LOG_FILE, caption=MSG_LOG_FILE_CAPTION)
-    except FloodWait as e:
-        await asyncio.sleep(e.value)
-        await message.reply_document(LOG_FILE, caption=MSG_LOG_FILE_CAPTION)
+        await handle_flood_wait(message.reply_document, LOG_FILE, caption=MSG_LOG_FILE_CAPTION)
     except Exception as e:
         logger.error(f"Error sending log file: {e}", exc_info=True)
-        await retry(reply, message, text=MSG_ERROR_GENERIC)
+        await reply(message, text=MSG_ERROR_GENERIC)
 
 @StreamBot.on_message(filters.command("authorize") & owner_filter)
 async def authorize_command(client: Client, message: Message):
     if len(message.command) != 2:
-        return await retry(reply, message, text=MSG_AUTHORIZE_USAGE, parse_mode=ParseMode.MARKDOWN)
+        return await reply(message, text=MSG_AUTHORIZE_USAGE, parse_mode=ParseMode.MARKDOWN)
     
     try:
         user_id = int(message.command[1])
         success = await authorize(user_id, message.from_user.id)
-        await retry(reply, message,
+        await reply(message,
                    text=MSG_AUTHORIZE_SUCCESS.format(user_id=user_id) if success else MSG_AUTHORIZE_FAILED.format(user_id=user_id))
     except ValueError:
-        await retry(reply, message, text=MSG_INVALID_USER_ID)
+        await reply(message, text=MSG_INVALID_USER_ID)
     except Exception as e:
         logger.error(f"Error in authorize_command: {e}", exc_info=True)
-        await retry(reply, message, text=MSG_ERROR_GENERIC)
+        await reply(message, text=MSG_ERROR_GENERIC)
 
 @StreamBot.on_message(filters.command("deauthorize") & owner_filter)
 async def deauthorize_command(client: Client, message: Message):
     if len(message.command) != 2:
-        return await retry(reply, message, text=MSG_DEAUTHORIZE_USAGE, parse_mode=ParseMode.MARKDOWN)
+        return await reply(message, text=MSG_DEAUTHORIZE_USAGE, parse_mode=ParseMode.MARKDOWN)
     
     try:
         user_id = int(message.command[1])
         success = await deauthorize(user_id)
-        await retry(reply, message,
+        await reply(message,
                    text=MSG_DEAUTHORIZE_SUCCESS.format(user_id=user_id) if success else MSG_DEAUTHORIZE_FAILED.format(user_id=user_id))
     except ValueError:
-        await retry(reply, message, text=MSG_INVALID_USER_ID)
+        await reply(message, text=MSG_INVALID_USER_ID)
     except Exception as e:
         logger.error(f"Error in deauthorize_command: {e}", exc_info=True)
-        await retry(reply, message, text=MSG_ERROR_GENERIC)
+        await reply(message, text=MSG_ERROR_GENERIC)
 
 @StreamBot.on_message(filters.command("listauth") & owner_filter)
 async def list_authorized_command(client: Client, message: Message):
     users = await list_allowed()
     if not users:
-        return await retry(reply, message, text=MSG_NO_AUTH_USERS)
+        return await reply(message, text=MSG_NO_AUTH_USERS)
     
     text = MSG_ADMIN_AUTH_LIST_HEADER
     for i, user in enumerate(users, 1):
@@ -174,7 +171,7 @@ async def list_authorized_command(client: Client, message: Message):
             auth_time=user['authorized_at']
         )
     
-    await retry(reply, message,
+    await reply(message,
                text=text,
                parse_mode=ParseMode.MARKDOWN,
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]]))
@@ -182,12 +179,12 @@ async def list_authorized_command(client: Client, message: Message):
 @StreamBot.on_message(filters.command("ban") & owner_filter)
 async def ban_user_command(client: Client, message: Message):
     if len(message.command) < 2:
-        return await retry(reply, message, text=MSG_BAN_USAGE)
+        return await reply(message, text=MSG_BAN_USAGE)
     
     try:
         user_id = int(message.command[1])
         if user_id == Var.OWNER_ID:
-            return await retry(reply, message, text=MSG_CANNOT_BAN_OWNER)
+            return await reply(message, text=MSG_CANNOT_BAN_OWNER)
         
         reason = " ".join(message.command[2:]) or MSG_ADMIN_NO_BAN_REASON
         await db.add_banned_user(
@@ -201,47 +198,41 @@ async def ban_user_command(client: Client, message: Message):
         if reason != MSG_ADMIN_NO_BAN_REASON:
             text += MSG_BAN_REASON_SUFFIX.format(reason=reason)
         
-        await retry(reply, message, text=text)
+        await reply(message, text=text)
         
         try:
-            await client.send_message(user_id, MSG_USER_BANNED_NOTIFICATION)
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            await client.send_message(user_id, MSG_USER_BANNED_NOTIFICATION)
+            await handle_flood_wait(client.send_message, user_id, MSG_USER_BANNED_NOTIFICATION)
         except Exception as e:
             logger.warning(f"Could not notify banned user {user_id}: {e}", exc_info=True)
             
     except ValueError:
-        await retry(reply, message, text=MSG_INVALID_USER_ID)
+        await reply(message, text=MSG_INVALID_USER_ID)
 
 @StreamBot.on_message(filters.command("unban") & owner_filter)
 async def unban_user_command(client: Client, message: Message):
     if len(message.command) != 2:
-        return await retry(reply, message, text=MSG_UNBAN_USAGE)
+        return await reply(message, text=MSG_UNBAN_USAGE)
     
     try:
         user_id = int(message.command[1])
         if await db.remove_banned_user(user_id=user_id):
-            await retry(reply, message, text=MSG_ADMIN_USER_UNBANNED.format(user_id=user_id))
+            await reply(message, text=MSG_ADMIN_USER_UNBANNED.format(user_id=user_id))
             try:
-                await client.send_message(user_id, MSG_USER_UNBANNED_NOTIFICATION)
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                await client.send_message(user_id, MSG_USER_UNBANNED_NOTIFICATION)
+                await handle_flood_wait(client.send_message, user_id, MSG_USER_UNBANNED_NOTIFICATION)
             except Exception as e:
                 logger.warning(f"Could not notify unbanned user {user_id}: {e}", exc_info=True)
         else:
-            await retry(reply, message, text=MSG_USER_NOT_IN_BAN_LIST.format(user_id=user_id))
+            await reply(message, text=MSG_USER_NOT_IN_BAN_LIST.format(user_id=user_id))
     except ValueError:
-        await retry(reply, message, text=MSG_INVALID_USER_ID)
+        await reply(message, text=MSG_INVALID_USER_ID)
 
 @StreamBot.on_message(filters.command("shell") & owner_filter)
 async def run_shell_command(client: Client, message: Message):
     if len(message.command) < 2:
-        return await retry(reply, message, text=MSG_SHELL_USAGE, parse_mode=ParseMode.HTML)
+        return await reply(message, text=MSG_SHELL_USAGE, parse_mode=ParseMode.HTML)
     
     command = " ".join(message.command[1:])
-    status_msg = await retry(reply, message,
+    status_msg = await reply(message,
                             text=MSG_SHELL_EXECUTING.format(command=html.escape(command)),
                             parse_mode=ParseMode.HTML)
     
@@ -262,26 +253,14 @@ async def run_shell_command(client: Client, message: Message):
         
         output = output.strip() or MSG_SHELL_NO_OUTPUT
         
-        try:
-            await status_msg.delete()
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            await status_msg.delete()
+        await handle_flood_wait(status_msg.delete)
         
         if len(output) > 4096:
             file = BytesIO(output.encode())
             file.name = "shell_output.txt"
-            try:
-                await message.reply_document(file, caption=MSG_SHELL_OUTPUT.format(command=html.escape(command)))
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                await message.reply_document(file, caption=MSG_SHELL_OUTPUT.format(command=html.escape(command)))
+            await handle_flood_wait(message.reply_document, file, caption=MSG_SHELL_OUTPUT.format(command=html.escape(command)))
         else:
-            try:
-                await retry(reply, message, text=output, parse_mode=ParseMode.HTML)
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                await retry(reply, message, text=output, parse_mode=ParseMode.HTML)
+            await reply(message, text=output, parse_mode=ParseMode.HTML)
             
     except Exception as e:
-        await status_msg.edit_text(MSG_SHELL_ERROR.format(error=html.escape(str(e))), parse_mode=ParseMode.HTML)
+        await handle_flood_wait(status_msg.edit_text, MSG_SHELL_ERROR.format(error=html.escape(str(e))), parse_mode=ParseMode.HTML)

Thunder/bot/plugins/callbacks.py

@@ -1,37 +1,32 @@
 # Thunder/bot/plugins/callbacks.py
 
-import asyncio
 from pyrogram import Client, filters
-from pyrogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, LinkPreviewOptions
-from pyrogram.errors import MessageNotModified, FloodWait
+from pyrogram.errors import MessageNotModified
+from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
+                            InlineKeyboardMarkup, LinkPreviewOptions)
 
 from Thunder.bot import StreamBot
-from Thunder.vars import Var
+from Thunder.utils.broadcast import broadcast_ids
+from Thunder.utils.decorators import owner_only
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import *
-from Thunder.utils.decorators import owner_only
-from Thunder.utils.broadcast import broadcast_ids
+from Thunder.vars import Var
 
 async def get_force_channel_button(client: Client):
     if not Var.FORCE_CHANNEL_ID:
         return None
-    max_retries = 2
-    for attempt in range(max_retries):
-        try:
-            chat = await client.get_chat(Var.FORCE_CHANNEL_ID)
+    try:
+        chat = await handle_flood_wait(client.get_chat, Var.FORCE_CHANNEL_ID)
+        if chat:
             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 or "Channel"),
                     url=invite_link
                 )]
-            break
-        except FloodWait as e:
-            logger.debug(f"FloodWait: Waiting {e.value} seconds (attempt {attempt+1}/{max_retries})")
-            await asyncio.sleep(e.value)
-        except Exception as e:
-            logger.error(f"Error getting force channel button: {e}", exc_info=True)
-            break
+    except Exception as e:
+        logger.error(f"Error getting force channel button: {e}", exc_info=True)
     return None
 
 @StreamBot.on_callback_query(filters.regex(r"^help_command$"))
@@ -43,7 +38,8 @@ async def help_callback(client: Client, callback_query: CallbackQuery):
         if force_button:
             buttons.append(force_button)
         buttons.append([InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")])
-        await callback_query.message.edit_text(
+        await handle_flood_wait(
+            callback_query.message.edit_text,
             text=MSG_HELP.format(max_files=Var.MAX_BATCH_FILES),
             reply_markup=InlineKeyboardMarkup(buttons),
             link_preview_options=LinkPreviewOptions(is_disabled=True)
@@ -52,7 +48,7 @@ async def help_callback(client: Client, callback_query: CallbackQuery):
         pass
     except Exception as e:
         logger.error(f"Error in help callback: {e}", exc_info=True)
-        await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        await handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
 
 @StreamBot.on_callback_query(filters.regex(r"^about_command$"))
 async def about_callback(client: Client, callback_query: CallbackQuery):
@@ -65,7 +61,8 @@ async def about_callback(client: Client, callback_query: CallbackQuery):
                 InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")
             ]
         ]
-        await callback_query.message.edit_text(
+        await handle_flood_wait(
+            callback_query.message.edit_text,
             text=MSG_ABOUT,
             reply_markup=InlineKeyboardMarkup(buttons),
             link_preview_options=LinkPreviewOptions(is_disabled=True)
@@ -74,38 +71,39 @@ async def about_callback(client: Client, callback_query: CallbackQuery):
         pass
     except Exception as e:
         logger.error(f"Error in about callback: {e}", exc_info=True)
-        await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        await handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
 
 @StreamBot.on_callback_query(filters.regex(r"^restart_broadcast$"))
 async def restart_broadcast_callback(client: Client, callback_query: CallbackQuery):
     if not await owner_only(client, callback_query):
         return
     try:
-        await callback_query.answer(MSG_ERROR_BROADCAST_RESTART, show_alert=True)
+        await handle_flood_wait(callback_query.answer, MSG_ERROR_BROADCAST_RESTART, show_alert=True)
         buttons = [
             [
                 InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command"),
                 InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")
             ]
         ]
-        await callback_query.message.edit_text(
+        await handle_flood_wait(
+            callback_query.message.edit_text,
             MSG_ERROR_BROADCAST_INSTRUCTION,
             reply_markup=InlineKeyboardMarkup(buttons),
             link_preview_options=LinkPreviewOptions(is_disabled=True)
         )
     except Exception as e:
         logger.error(f"Error in restart broadcast callback: {e}", exc_info=True)
-        await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        await handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
 
 @StreamBot.on_callback_query(filters.regex(r"^close_panel$"))
 async def close_panel_callback(client: Client, callback_query: CallbackQuery):
     try:
-        await callback_query.answer()
-        await callback_query.message.delete()
+        await handle_flood_wait(callback_query.answer)
+        await handle_flood_wait(callback_query.message.delete)
         if callback_query.message.reply_to_message:
             try:
                 reply_msg = callback_query.message.reply_to_message
-                await reply_msg.delete()
+                await handle_flood_wait(reply_msg.delete)
             except Exception:
                 pass
     except Exception as e:
@@ -117,21 +115,23 @@ async def cancel_broadcast(client: Client, callback_query: CallbackQuery):
         broadcast_id = callback_query.data.split("_")[1]
         if broadcast_id in broadcast_ids:
             broadcast_ids[broadcast_id]["cancelled"] = True
-            await callback_query.message.edit_text(
+            await handle_flood_wait(
+                callback_query.message.edit_text,
                 MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id)
             )
         else:
-            await callback_query.answer(
+            await handle_flood_wait(
+                callback_query.answer,
                 MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id),
                 show_alert=True
             )
     except Exception as e:
         logger.error(f"Error in cancel broadcast callback: {e}", exc_info=True)
-        await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        await handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
 
 @StreamBot.on_callback_query()
 async def fallback_callback(client: Client, callback_query: CallbackQuery):
     try:
-        await callback_query.answer(MSG_ERROR_CALLBACK_UNSUPPORTED, show_alert=True)
+        await handle_flood_wait(callback_query.answer, MSG_ERROR_CALLBACK_UNSUPPORTED, show_alert=True)
     except Exception as e:
         logger.error(f"Error in fallback callback: {e}", exc_info=True)

Thunder/bot/plugins/common.py

@@ -1,41 +1,24 @@
 # Thunder/bot/plugins/common.py
 
-import asyncio
 import time
 from datetime import datetime, timedelta
+
 from pyrogram import Client, filters
-from pyrogram.errors import FloodWait
-from pyrogram.types import (
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    LinkPreviewOptions,
-    Message,
-    User,
-)
+from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
+                            LinkPreviewOptions, Message, User)
 
 from Thunder.bot import StreamBot
-from Thunder.vars import Var
+from Thunder.utils.bot_utils import (gen_dc_txt, get_user, log_newusr, reply,
+                                     reply_user_err)
 from Thunder.utils.database import db
 from Thunder.utils.decorators import check_banned
+from Thunder.utils.file_properties import get_fname, get_fsize, parse_fid
 from Thunder.utils.force_channel import force_channel_check, get_force_info
-from Thunder.utils.bot_utils import gen_links, log_newusr, reply_user_err, gen_dc_txt, get_user
+from Thunder.utils.handler import handle_flood_wait
+from Thunder.utils.human_readable import humanbytes
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import *
-from Thunder.utils.human_readable import humanbytes
-from Thunder.utils.file_properties import get_fsize, get_fname, parse_fid
-
-async def retry(func, *args, max_retries=2, **kwargs):
-    for attempt in range(max_retries):
-        try:
-            return await func(*args, **kwargs)
-        except FloodWait as e:
-            wait_time = float(e.value) if isinstance(e.value, (int, float)) else 10.0
-            logger.debug(f"FloodWait: Retrying in {wait_time}s (attempt {attempt+1}/{max_retries})")
-            await asyncio.sleep(wait_time)
-    return await func(*args, **kwargs)
-
-async def reply(msg: Message, **kwargs):
-    return await msg.reply_text(**kwargs, quote=True, link_preview_options=LinkPreviewOptions(is_disabled=True))
+from Thunder.vars import Var
 
 @StreamBot.on_message(filters.command("start") & filters.private)
 async def start_command(bot: Client, msg: Message):
@@ -54,13 +37,13 @@ async def start_command(bot: Client, msg: Message):
             token = await db.token_col.find_one({"token": payload})
             if token:
                 if token["user_id"] != user.id:
-                    return await retry(reply, msg, text=MSG_TOKEN_FAILED.format(
+                    return await handle_flood_wait(msg.reply_text, text=MSG_TOKEN_FAILED.format(
                         reason="This activation link is not for your account.",
                         error_id=str(int(time.time()))[-8:]
                     ))
                 
                 if token.get("activated"):
-                    return await retry(reply, msg, text=MSG_TOKEN_FAILED.format(
+                    return await handle_flood_wait(msg.reply_text, text=MSG_TOKEN_FAILED.format(
                         reason="Token has already been activated.",
                         error_id=str(int(time.time()))[-8:]
                     ))
@@ -74,9 +57,9 @@ async def start_command(bot: Client, msg: Message):
                 )
                 
                 hrs = round((exp - now).total_seconds() / 3600, 1)
-                return await retry(reply, msg, text=MSG_TOKEN_ACTIVATED.format(duration_hours=hrs))
+                return await handle_flood_wait(msg.reply_text, text=MSG_TOKEN_ACTIVATED.format(duration_hours=hrs))
             else:
-                return await retry(reply, msg, text=MSG_TOKEN_INVALID)
+                return await handle_flood_wait(msg.reply_text, text=MSG_TOKEN_INVALID)
             
     txt = MSG_WELCOME.format(user_name=user.first_name if user else "Unknown")
     link, title = await get_force_info(bot)
@@ -93,7 +76,7 @@ async def start_command(bot: Client, msg: Message):
     if link:
         btns.append([InlineKeyboardButton(MSG_BUTTON_JOIN_CHANNEL.format(channel_title=title), url=link)])
     
-    await retry(reply, msg, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    await handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
 
 @StreamBot.on_message(filters.command("help") & filters.private)
 async def help_command(bot: Client, msg: Message):
@@ -110,7 +93,7 @@ async def help_command(bot: Client, msg: Message):
         btns.append([InlineKeyboardButton(MSG_BUTTON_JOIN_CHANNEL.format(channel_title=title), url=link)])
     
     btns.append([InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")])
-    await retry(reply, msg, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    await handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
 
 @StreamBot.on_message(filters.command("about") & filters.private)
 async def about_command(bot: Client, msg: Message):
@@ -125,7 +108,7 @@ async def about_command(bot: Client, msg: Message):
          InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
     ]
     
-    await retry(reply, msg, text=MSG_ABOUT, reply_markup=InlineKeyboardMarkup(btns))
+    await handle_flood_wait(msg.reply_text, text=MSG_ABOUT, reply_markup=InlineKeyboardMarkup(btns))
 
 async def send_user_dc(msg: Message, user: User):
     txt = await gen_dc_txt(user)
@@ -134,7 +117,7 @@ async def send_user_dc(msg: Message, user: User):
         [InlineKeyboardButton(MSG_BUTTON_VIEW_PROFILE, url=url)],
         [InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
     ]
-    await retry(reply, msg, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    await handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
 
 async def send_file_dc(msg: Message, file_msg: Message):
     try:
@@ -168,7 +151,7 @@ async def send_file_dc(msg: Message, file_msg: Message):
         )
         
         btns = [[InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]]
-        await retry(reply, msg, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+        await handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
         
     except Exception as e:
         logger.error(f"File DC error: {e}", exc_info=True)
@@ -214,7 +197,7 @@ async def ping_command(bot: Client, msg: Message):
     if not await force_channel_check(bot, msg):
         return
     start = time.time()
-    sent = await retry(reply, msg, text=MSG_PING_START)
+    sent = await handle_flood_wait(msg.reply_text, text=MSG_PING_START)
     end = time.time()
     ms = (end - start) * 1000
     
@@ -223,7 +206,7 @@ async def ping_command(bot: Client, msg: Message):
          InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
     ]
     
-    await retry(sent.edit_text,
+    await handle_flood_wait(sent.edit_text,
         MSG_PING_RESPONSE.format(time_taken_ms=ms),
         reply_markup=InlineKeyboardMarkup(btns),
         link_preview_options=LinkPreviewOptions(is_disabled=True)

Thunder/bot/plugins/stream.py

@@ -1,42 +1,33 @@
 # Thunder/bot/plugins/stream.py
 
 import asyncio
-from typing import Optional, Dict, Any
-from pyrogram import Client, filters, enums
-from pyrogram.errors import FloodWait, MessageNotModified, RPCError
-from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, Message, LinkPreviewOptions
+from typing import Any, Dict, Optional
+
+from pyrogram import Client, enums, filters
+from pyrogram.errors import MessageNotModified
+from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
+                            LinkPreviewOptions, Message)
+
 from Thunder.bot import StreamBot
+from Thunder.utils.bot_utils import (gen_links, is_admin, log_newusr, notify_own,
+                                     reply_user_err)
 from Thunder.utils.database import db
-from Thunder.utils.messages import *
+from Thunder.utils.decorators import (check_banned, get_shortener_status,
+                                      require_token)
+from Thunder.utils.force_channel import force_channel_check
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
+from Thunder.utils.messages import *
 from Thunder.vars import Var
-from Thunder.utils.decorators import check_banned, require_token, get_shortener_status
-from Thunder.utils.force_channel import force_channel_check
-from Thunder.utils.bot_utils import notify_own, reply_user_err, log_newusr, gen_links, is_admin, handle_flood_wait
+
 
 async def fwd_media(m_msg: Message) -> Optional[Message]:
     try:
-        return await m_msg.copy(chat_id=Var.BIN_CHANNEL)
-    except FloodWait as e:
-        logger.debug(f"FloodWait: fwd_media copy, sleep {e.value}s")
-        await asyncio.sleep(e.value + 1)
-        try:
-            return await m_msg.copy(chat_id=Var.BIN_CHANNEL)
-        except Exception as retry_e:
-            logger.error(f"Error fwd_media copy on retry after FloodWait: {retry_e}", exc_info=True)
-            return None
-    except RPCError as e:
+        return await handle_flood_wait(m_msg.copy, chat_id=Var.BIN_CHANNEL)
+    except Exception as e:
         if "MEDIA_CAPTION_TOO_LONG" in str(e):
             logger.debug(f"MEDIA_CAPTION_TOO_LONG error, retrying without caption: {e}")
-            try:
-                return await m_msg.copy(chat_id=Var.BIN_CHANNEL, caption=None)
-            except Exception as retry_e:
-                logger.error(f"Error fwd_media copy on retry without caption: {retry_e}", exc_info=True)
-                return None
-        else:
-            logger.error(f"Error fwd_media copy: {e}", exc_info=True)
-            return None
-    except Exception as e:
+            return await handle_flood_wait(m_msg.copy, chat_id=Var.BIN_CHANNEL, caption=None)
         logger.error(f"Error fwd_media copy: {e}", exc_info=True)
         return None
 
@@ -232,7 +223,7 @@ async def process_single(bot: Client, msg: Message, file_msg: Message, status_ms
         return links
     except Exception as e:
         if status_msg:
-            await status_msg.edit_text(MSG_ERROR_PROCESSING_MEDIA)
+            await handle_flood_wait(status_msg.edit_text, MSG_ERROR_PROCESSING_MEDIA)
         if str(e):
             await notify_own(bot, MSG_CRITICAL_ERROR.format(
                 error=str(e),
@@ -259,11 +250,9 @@ async def process_batch(bot: Client, msg: Message, start_id: int, count: int, st
         except MessageNotModified:
             pass
         try:
-            messages = await bot.get_messages(msg.chat.id, batch_ids)
-        except FloodWait as e:
-            logger.warning(f"FloodWait: process_batch get_messages, sleep {e.value}s")
-            await asyncio.sleep(e.value + 1)
-            messages = await bot.get_messages(msg.chat.id, batch_ids)
+            messages = await handle_flood_wait(bot.get_messages, msg.chat.id, batch_ids)
+            if messages is None:
+                messages = []
         except Exception as e:
             logger.error(f"Error getting messages in batch: {e}", exc_info=True)
             messages = []

Thunder/server/stream_routes.py

@@ -3,10 +3,12 @@
 import re
 import secrets
 import time
+from urllib.parse import quote, unquote
+
 from aiohttp import web
-from urllib.parse import unquote, quote
-from Thunder import StartTime, __version__
-from Thunder.bot import multi_clients, StreamBot, work_loads
+
+from Thunder import __version__, StartTime
+from Thunder.bot import StreamBot, multi_clients, work_loads
 from Thunder.server.exceptions import FileNotFound, InvalidHash
 from Thunder.utils.custom_dl import ByteStreamer
 from Thunder.utils.logger import logger

Thunder/utils/bot_utils.py

@@ -1,43 +1,26 @@
 # Thunder/utils/bot_utils.py
 
 import asyncio
-from typing import Optional, Dict, Any, Callable
+from typing import Any, Callable, Dict, Optional
 from urllib.parse import quote
 
 from pyrogram import Client
-from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, User, LinkPreviewOptions
 from pyrogram.enums import ChatMemberStatus
 from pyrogram.errors import FloodWait
+from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
+                            LinkPreviewOptions, Message, User)
 
-from Thunder.vars import Var
 from Thunder.utils.database import db
+from Thunder.utils.file_properties import get_fname, get_fsize, get_hash
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.human_readable import humanbytes
 from Thunder.utils.logger import logger
-from Thunder.utils.messages import (
-    MSG_BUTTON_GET_HELP,
-    MSG_NEW_USER,
-    MSG_DC_UNKNOWN,
-    MSG_DC_USER_INFO
-)
-from Thunder.utils.file_properties import get_fname, get_fsize, get_hash
+from Thunder.utils.messages import (MSG_BUTTON_GET_HELP, MSG_DC_UNKNOWN,
+                                    MSG_DC_USER_INFO, MSG_NEW_USER)
 from Thunder.utils.shortener import shorten
+from Thunder.vars import Var
 
 
-async def handle_flood_wait(func: Callable, *args, **kwargs):
-    try:
-        return await func(*args, **kwargs)
-    except FloodWait as e:
-        logger.debug(f"FloodWait in {func.__name__}: {e.value}s. Retrying...")
-        await asyncio.sleep(e.value)
-        try:
-            return await func(*args, **kwargs)
-        except Exception as retry_error:
-            logger.error(f"Retry failed in {func.__name__}: {retry_error}")
-            return None
-    except Exception as e:
-        logger.error(f"Error in {func.__name__}: {e}")
-        return None
-
 
 async def notify_ch(cli: Client, txt: str):
     if not (hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0):
@@ -122,3 +105,7 @@ async def is_admin(cli: Client, chat_id_val: int) -> bool:
     if member is None:
         return False
     return member.status in [ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]
+
+
+async def reply(msg: Message, **kwargs):
+    return await handle_flood_wait(msg.reply_text, **kwargs, quote=True, link_preview_options=LinkPreviewOptions(is_disabled=True))

Thunder/utils/broadcast.py

@@ -1,39 +1,36 @@
 # Thunder/utils/broadcast.py
 
+import asyncio
 import os
 import time
-import asyncio
+
 from pyrogram.client import Client
 from pyrogram.enums import ParseMode
-from pyrogram.types import (
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Message
-)
-from pyrogram.errors import (
-    FloodWait,
-    UserDeactivated,
-    UserIsBlocked,
-    PeerIdInvalid,
-    ChatWriteForbidden
-)
+from pyrogram.errors import (ChatWriteForbidden, PeerIdInvalid, UserDeactivated,
+                             UserIsBlocked)
+from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
+                            Message)
+
 from Thunder.utils.database import db
-from Thunder.utils.time_format import get_readable_time
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import *
+from Thunder.utils.time_format import get_readable_time
+
 
 broadcast_ids = {}
 
 async def broadcast_message(client: Client, message: Message):
     if not message.reply_to_message:
-        await message.reply_text(MSG_INVALID_BROADCAST_CMD)
+        await handle_flood_wait(message.reply_text, MSG_INVALID_BROADCAST_CMD)
         return
     
     broadcast_id = os.urandom(3).hex()
     stats = {"total": 0, "success": 0, "failed": 0, "deleted": 0, "cancelled": False}
     broadcast_ids[broadcast_id] = stats
     
-    status_msg = await message.reply_text(
+    status_msg = await handle_flood_wait(
+        message.reply_text,
         MSG_BROADCAST_START,
         reply_markup=InlineKeyboardMarkup([[
             InlineKeyboardButton(MSG_BUTTON_CANCEL_BROADCAST, callback_data=f"cancel_{broadcast_id}")
@@ -48,15 +45,9 @@ async def broadcast_message(client: Client, message: Message):
             if stats["cancelled"]:
                 break
             try:
-                await message.reply_to_message.copy(user['id'])
-                stats["success"] += 1
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                try:
-                    await message.reply_to_message.copy(user['id'])
+                if await handle_flood_wait(message.reply_to_message.copy, user['id']):
                     stats["success"] += 1
-                except Exception as e:
-                    logger.error(f"Error copying message to user {user['id']} after FloodWait: {e}", exc_info=True)
+                else:
                     stats["failed"] += 1
             except (UserDeactivated, UserIsBlocked, PeerIdInvalid, ChatWriteForbidden) as e:
                 logger.warning(f"User {user['id']} removed due to: {type(e).__name__}", exc_info=True)
@@ -66,8 +57,9 @@ async def broadcast_message(client: Client, message: Message):
                 logger.error(f"Error copying message to user {user['id']}: {e}", exc_info=True)
                 stats["failed"] += 1
         
-        await status_msg.delete()
-        await message.reply_text(
+        await handle_flood_wait(status_msg.delete)
+        await handle_flood_wait(
+            message.reply_text,
             MSG_BROADCAST_COMPLETE.format(
                 elapsed_time=get_readable_time(int(time.time() - start_time)),
                 total_users=stats["total"],

Thunder/utils/commands.py

@@ -0,0 +1,37 @@
+from pyrogram.types import BotCommand
+
+from Thunder.bot import StreamBot
+from Thunder.utils.logger import logger
+from Thunder.vars import Var
+
+def get_commands():
+    command_descriptions = {
+        "start": "Start the bot and get a welcome message",
+        "link": "(Group) Generate a direct link for a file or batch",
+        "dc": "Retrieve the data center (DC) information of a user or file",
+        "ping": "Check the bot's status and response time",
+        "about": "Get information about the bot",
+        "help": "Show help and usage instructions",
+        "status": "(Admin) View bot details and current workload",
+        "stats": "(Admin) View usage statistics and resource consumption",
+        "broadcast": "(Admin) Send a message to all users",
+        "ban": "(Admin) Ban a user",
+        "unban": "(Admin) Unban a user",
+        "log": "(Admin) Send bot logs",
+        "restart": "(Admin) Restart the bot",
+        "shell": "(Admin) Execute a shell command",
+        "users": "(Admin) Show the total number of users",
+        "authorize": "(Admin) Grant permanent access to a user",
+        "deauthorize": "(Admin) Remove permanent access from a user",
+        "listauth": "(Admin) List all authorized users"
+    }
+    return [BotCommand(name, desc) for name, desc in command_descriptions.items()]
+
+async def set_commands():
+    if Var.SET_COMMANDS:
+        try:
+            commands = get_commands()
+            if commands:
+                await StreamBot.set_bot_commands(commands)
+        except Exception as e:
+            logger.error(f"Failed to set bot commands: {e}", exc_info=True)

Thunder/utils/custom_dl.py

@@ -1,8 +1,7 @@
 # Thunder/utils/custom_dl.py
 
 import asyncio
-
-from typing import Dict, Any, AsyncGenerator
+from typing import Any, AsyncGenerator, Dict
 
 from pyrogram import Client
 from pyrogram.errors import FloodWait
@@ -14,21 +13,22 @@ from Thunder.vars import Var
 
 class ByteStreamer:
     __slots__ = ('client', 'chat_id')
-    
-    def __init__(self, client: Client):
+
+    def __init__(self, client: Client) -> None:
         self.client = client
         self.chat_id = int(Var.BIN_CHANNEL)
 
     async def get_message(self, message_id: int) -> Message:
-        try:
-            message = await self.client.get_messages(self.chat_id, message_id)
-        except FloodWait as e:
-            logger.debug(f"FloodWait: get_message, sleep {e.value}s")
-            await asyncio.sleep(e.value)
-            message = await self.client.get_messages(self.chat_id, message_id)
-        except Exception as e:
-            logger.debug(f"Error fetching message {message_id}: {e}", exc_info=True)
-            raise FileNotFound(f"Message {message_id} not found") from e
+        while True:
+            try:
+                message = await self.client.get_messages(self.chat_id, message_id)
+                break
+            except FloodWait as e:
+                logger.debug(f"FloodWait: get_message, sleep {e.value}s")
+                await asyncio.sleep(e.value)
+            except Exception as e:
+                logger.debug(f"Error fetching message {message_id}: {e}", exc_info=True)
+                raise FileNotFound(f"Message {message_id} not found") from e
         
         if not message or not message.media:
             raise FileNotFound(f"Message {message_id} not found")
@@ -40,30 +40,28 @@ class ByteStreamer:
         if limit > 0:
             chunk_offset = offset // (1024 * 1024)
             chunk_limit = (limit + 1024 * 1024 - 1) // (1024 * 1024)
-            
-            try:
-                async for chunk in self.client.stream_media(message, offset=chunk_offset, limit=chunk_limit):
-                    yield chunk
-            except FloodWait as e:
-                logger.debug(f"FloodWait: stream_file, sleep {e.value}s")
-                await asyncio.sleep(e.value)
-                async for chunk in self.client.stream_media(message, offset=chunk_offset, limit=chunk_limit):
-                    yield chunk
+            while True:
+                try:
+                    async for chunk in self.client.stream_media(message, offset=chunk_offset, limit=chunk_limit):
+                        yield chunk
+                    break
+                except FloodWait as e:
+                    logger.debug(f"FloodWait: stream_file, sleep {e.value}s")
+                    await asyncio.sleep(e.value)
         else:
-            try:
-                async for chunk in self.client.stream_media(message):
-                    yield chunk
-            except FloodWait as e:
-                logger.debug(f"FloodWait: stream_file, sleep {e.value}s")
-                await asyncio.sleep(e.value)
-                async for chunk in self.client.stream_media(message):
-                    yield chunk
+            while True:
+                try:
+                    async for chunk in self.client.stream_media(message):
+                        yield chunk
+                    break
+                except FloodWait as e:
+                    logger.debug(f"FloodWait: stream_file, sleep {e.value}s")
+                    await asyncio.sleep(e.value)
 
     def get_file_info_sync(self, message: Message) -> Dict[str, Any]:
         media = message.document or message.video or message.audio or message.photo
         if not media:
             return {"message_id": message.id, "error": "No media"}
-        
         return {
             "message_id": message.id,
             "file_size": getattr(media, 'file_size', 0) or 0,

Thunder/utils/decorators.py

@@ -1,16 +1,15 @@
 # Thunder/utils/decorators.py
 
-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 pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
+
 from Thunder.utils.database import db
-from Thunder.utils.tokens import check, allowed, generate
+from Thunder.utils.handler import handle_flood_wait
+from Thunder.utils.logger import logger
+from Thunder.utils.messages import (MSG_DECORATOR_BANNED,
+                                    MSG_ERROR_UNAUTHORIZED, MSG_TOKEN_INVALID)
 from Thunder.utils.shortener import shorten
+from Thunder.utils.tokens import allowed, check, generate
+from Thunder.vars import Var
 
 
 async def check_banned(client, message: Message):
@@ -19,7 +18,7 @@ async def check_banned(client, message: Message):
             return True
         user_id = message.from_user.id
         if user_id == Var.OWNER_ID:
-             return True
+            return True
 
         ban_details = await db.is_user_banned(user_id)
         if ban_details:
@@ -29,7 +28,8 @@ async def check_banned(client, message: Message):
                 if banned_at and hasattr(banned_at, 'strftime')
                 else str(banned_at) if banned_at else 'N/A'
             )
-            await message.reply_text(
+            await handle_flood_wait(
+                message.reply_text,
                 MSG_DECORATOR_BANNED.format(
                     reason=ban_details.get('reason', 'Not specified'),
                     ban_time=ban_time
@@ -60,15 +60,19 @@ async def require_token(client, message: Message):
             temp_token_string = await generate(user_id)
         except Exception as e:
             logger.error(f"Failed to generate temporary token for user {user_id} in require_token: {e}", exc_info=True)
-            await message.reply_text("Sorry, could not generate an access token link. Please try again later.", quote=True)
+            await handle_flood_wait(message.reply_text, "Sorry, could not generate an access token link. Please try again later.", quote=True)
             return False
 
         if not temp_token_string:
             logger.error(f"Temporary token generation returned empty for user {user_id} in require_token.", exc_info=True)
-            await message.reply_text("Sorry, could not generate an access token link. Please try again later.", quote=True)
+            await handle_flood_wait(message.reply_text, "Sorry, could not generate an access token link. Please try again later.", quote=True)
             return False
 
-        me = await client.get_me()
+        me = await handle_flood_wait(client.get_me)
+        if not me:
+            logger.error(f"Failed to get bot info for user {user_id} in require_token.", exc_info=True)
+            await handle_flood_wait(message.reply_text, "Sorry, an unexpected error occurred. Please try again later.", quote=True)
+            return False
         deep_link = f"https://t.me/{me.username}?start={temp_token_string}"
         short_url = deep_link
 
@@ -79,7 +83,8 @@ async def require_token(client, message: Message):
         except Exception as e:
             logger.warning(f"Failed to shorten token link for user {user_id}: {e}. Using full link.", exc_info=True)
 
-        await message.reply_text(
+        await handle_flood_wait(
+            message.reply_text,
             MSG_TOKEN_INVALID,
             reply_markup=InlineKeyboardMarkup([
                 [InlineKeyboardButton("Activate Access", url=short_url)]
@@ -91,7 +96,7 @@ async def require_token(client, message: Message):
     except Exception as e:
         logger.error(f"Error in require_token: {e}", exc_info=True)
         try:
-            await message.reply_text("An error occurred while checking your authorization. Please try again.", quote=True)
+            await handle_flood_wait(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}", exc_info=True)
         return False

Thunder/utils/file_properties.py

@@ -1,18 +1,17 @@
 # Thunder/utils/file_properties.py
 
-import asyncio
-
 from datetime import datetime as dt
 from typing import Any, Optional
 
 from pyrogram.client import Client
-from pyrogram.errors import FloodWait
-from pyrogram.types import Message
 from pyrogram.file_id import FileId
+from pyrogram.types import Message
 
 from Thunder.server.exceptions import FileNotFound
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
 
+
 def get_media(message: Message) -> Optional[Any]:
     for attr in ("audio", "document", "photo", "sticker", "animation", "video", "voice", "video_note"):
         media = getattr(message, attr, None)
@@ -22,18 +21,22 @@ def get_media(message: Message) -> Optional[Any]:
             return media
     return None
 
+
 def get_uniqid(message: Message) -> Optional[str]:
     media = get_media(message)
     return getattr(media, 'file_unique_id', None)
 
+
 def get_hash(media_msg: Message) -> str:
     uniq_id = get_uniqid(media_msg)
     return uniq_id[:6] if uniq_id else ''
 
+
 def get_fsize(message: Message) -> int:
     media = get_media(message)
     return getattr(media, 'file_size', 0) if media else 0
 
+
 def parse_fid(message: Message) -> Optional[FileId]:
     media = get_media(message)
     if media and hasattr(media, 'file_id'):
@@ -43,18 +46,22 @@ def parse_fid(message: Message) -> Optional[FileId]:
             return None
     return None
 
+
 def get_fname(msg: Message) -> str:
     media = get_media(msg)
     fname = None
+    
     if media:
         fname = getattr(media, 'file_name', None)
+    
     if not fname:
         media_type_str = "unknown_media"
         if msg.media:
             media_type_value = msg.media.value
             if media_type_value:
                 media_type_str = str(media_type_value)
-        ext = ""
+        
+        ext = "bin"
         if media and hasattr(media, '_file_type'):
             file_type = media._file_type
             if file_type == "photo":
@@ -71,24 +78,25 @@ def get_fname(msg: Message) -> str:
                 ext = "bin"
         timestamp = dt.now().strftime("%Y%m%d%H%M%S")
         fname = f"Thunder File To Link_{timestamp}.{ext}"
+    
     return fname
 
+
 async def get_fids(client: Client, chat_id: int, message_id: int) -> FileId:
     try:
-        try:
-            msg = await client.get_messages(chat_id, message_id)
-        except FloodWait as e:
-            logger.debug(f"FloodWait: get_fids, sleep {e.value}s")
-            await asyncio.sleep(e.value)
-            msg = await client.get_messages(chat_id, message_id)
+        msg = await handle_flood_wait(client.get_messages, chat_id, message_id)
+        
         if not msg or getattr(msg, 'empty', False):
             raise FileNotFound("Message not found")
+        
         media = get_media(msg)
         if media:
             if not hasattr(media, 'file_id') or not hasattr(media, 'file_unique_id'):
                 raise FileNotFound("Media metadata incomplete")
             return FileId.decode(media.file_id)
+        
         raise FileNotFound("No media in message")
+        
     except Exception as e:
         logger.error(f"Error in get_fids: {e}", exc_info=True)
         raise FileNotFound(str(e))

Thunder/utils/force_channel.py

@@ -3,12 +3,13 @@
 import asyncio
 
 from pyrogram import Client
-from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
 from pyrogram.errors import FloodWait, UserNotParticipant
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
 
-from Thunder.vars import Var
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import MSG_COMMUNITY_CHANNEL
+from Thunder.vars import Var
 
 _force_link = None
 _force_title = None
@@ -23,9 +24,10 @@ async def get_force_info(bot: Client):
         return _force_link, _force_title
     
     try:
-        chat = await bot.get_chat(Var.FORCE_CHANNEL_ID)
-        _force_link = chat.invite_link or (f"https://t.me/{chat.username}" if chat.username else None)
-        _force_title = chat.title or "Channel"
+        chat = await handle_flood_wait(bot.get_chat, Var.FORCE_CHANNEL_ID)
+        if chat:
+            _force_link = chat.invite_link or (f"https://t.me/{chat.username}" if chat.username else None)
+            _force_title = chat.title or "Channel"
         return _force_link, _force_title
     except Exception as e:
         logger.error(f"Force channel error: {e}", exc_info=True)
@@ -35,24 +37,30 @@ async def force_channel_check(client: Client, message: Message):
     if not Var.FORCE_CHANNEL_ID:
         return True
     try:
-        await client.get_chat_member(Var.FORCE_CHANNEL_ID, message.from_user.id)
-        return True
-    except FloodWait as e:
-        await asyncio.sleep(e.value)
-        return await force_channel_check(client, message)
+        while True:
+            try:
+                member = await client.get_chat_member(Var.FORCE_CHANNEL_ID, message.from_user.id)
+                if member is None:
+                    logger.error(f"Failed to get chat member for {message.from_user.id} in force channel {Var.FORCE_CHANNEL_ID} after retries.")
+                    return False
+                return True
+            except FloodWait as e:
+                logger.debug(f"FloodWait in force_channel_check, sleeping for {e.value}s")
+                await asyncio.sleep(e.value)
     except UserNotParticipant:
         link, title = await get_force_info(client)
         if link and title:
-            await message.reply_text(
+            await handle_flood_wait(
+                message.reply_text,
                 MSG_COMMUNITY_CHANNEL.format(channel_title=title),
                 reply_markup=InlineKeyboardMarkup([[
                     InlineKeyboardButton("Join", url=link)
                 ]])
             )
         else:
-            await message.reply_text("You must join the channel to use this bot.")
+            await handle_flood_wait(message.reply_text, "You must join the channel to use this bot.")
         return False
     except Exception as e:
         logger.error(f"Error checking force channel: {e}", exc_info=True)
-        await message.reply_text("An unexpected error occurred while checking channel membership. Please try again.")
+        await handle_flood_wait(message.reply_text, "An unexpected error occurred while checking channel membership. Please try again.")
         return False

Thunder/utils/handler.py

@@ -0,0 +1,28 @@
+# Thunder/utils/handler.py
+
+import asyncio
+from typing import Callable
+
+from pyrogram.errors import FloodWait
+
+from Thunder.utils.logger import logger
+
+
+async def handle_flood_wait(func: Callable, *args, **kwargs):
+    retries = kwargs.pop('retries', 5)
+    delay = kwargs.pop('delay', 5)
+    
+    for i in range(retries):
+        try:
+            return await func(*args, **kwargs)
+        except FloodWait as e:
+            wait_time = e.value
+            logger.debug(f"FloodWait encountered in '{func.__name__}'. Waiting for {wait_time}s. Retry {i + 1}/{retries}.")
+            await asyncio.sleep(wait_time)
+        except Exception:
+            logger.error(f"An exception occurred in '{func.__name__}' on retry {i + 1}/{retries}", exc_info=True)
+            if i < retries - 1:
+                await asyncio.sleep(delay)
+            else:
+                raise
+    return None

Thunder/utils/render_template.py

@@ -1,12 +1,14 @@
 # Thunder/utils/render_template.py
 
-import urllib.parse
 import html as html_module
+import urllib.parse
 
 from jinja2 import Environment, FileSystemLoader
+
 from Thunder.bot import StreamBot
 from Thunder.server.exceptions import InvalidHash
-from Thunder.utils.file_properties import get_uniqid, get_fname
+from Thunder.utils.file_properties import get_fname, get_uniqid
+from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
 from Thunder.vars import Var
 
@@ -20,7 +22,7 @@ template_env = Environment(
 
 async def render_page(id: int, secure_hash: str, requested_action: str | None = None) -> str:
     try:
-        message = await StreamBot.get_messages(chat_id=int(Var.BIN_CHANNEL), message_ids=id)
+        message = await handle_flood_wait(StreamBot.get_messages, chat_id=int(Var.BIN_CHANNEL), message_ids=id)
         if not message:
             raise InvalidHash("Message not found")
         

Thunder/vars.py

@@ -27,7 +27,7 @@ class Var:
         raise ValueError("Missing required Telegram API configuration")
 
     NAME: str = os.getenv("NAME", "ThunderF2L")
-    SLEEP_THRESHOLD: int = int(os.getenv("SLEEP_THRESHOLD", "120"))
+    SLEEP_THRESHOLD: int = int(os.getenv("SLEEP_THRESHOLD", "300"))
     WORKERS: int = int(os.getenv("WORKERS", "8"))
     TIMEOUT: int = int(os.getenv("TIMEOUT", "90"))
 
@@ -46,7 +46,7 @@ class Var:
     OWNER_ID: int = int(os.getenv("OWNER_ID", ""))
 
     if not OWNER_ID:
-        logger.warning("WARNING: OWNER_ID is empty. No user will have admin access.")
+        logger.warning("WARNING: OWNER_ID is not set. No user will be granted owner access.")
 
     OWNER_USERNAME: str = os.getenv("OWNER_USERNAME", "")
 
@@ -56,6 +56,8 @@ class Var:
     PORT_SEGMENT: str = "" if NO_PORT else f":{PORT}"
     URL: str = f"{PROTOCOL}://{FQDN}{PORT_SEGMENT}/"
 
+    SET_COMMANDS: bool = str_to_bool(os.getenv("SET_COMMANDS", "True"))
+
     DATABASE_URL: str = os.getenv("DATABASE_URL", "")
 
     if not DATABASE_URL:

config_sample.env

@@ -35,6 +35,9 @@ NO_PORT="True" # Hide port in URLs ("True" or "False")
 
 MAX_BATCH_FILES=50
 
+# Set bot commands on startup (True/False)
+SET_COMMANDS="True"
+
 # Force users to join a specific channel before using the bot
 FORCE_CHANNEL_ID="" # Example: -1001234567890 (Leave empty if not needed)
 
@@ -76,7 +79,7 @@ URL_SHORTENER_SITE="" # Example: "example.com"
 NAME="ThunderF2L" # Bot application name
 
 # Performance settings
-SLEEP_THRESHOLD=120 # Sleep time in seconds
+SLEEP_THRESHOLD=300 # Sleep time in seconds
 WORKERS=8 # Number of worker processes
 
 # Web server configuration