1.9.9

- Updated dependency: migrated from Motor to PyMongo
- Replaced centralized flood-wait handling with per-instance custom logic
- Added public Docker support for easier deployment
• One-click deploy button for Koyeb
• Deployment guides for Render and Railway
- Expanded FAQ section

.github/workflows/dockerize.yml

@@ -0,0 +1,25 @@
+name: Docker Build & Push
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: fyaz05
+          password: ${{ secrets.DOCKER_TOKEN }}
+          
+      - name: Build and Push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: fyaz05/thunder:latest

README.md

@@ -21,9 +21,6 @@
 - [About The Project](#about-the-project)
 - [How It Works](#how-it-works)
 - [Features](#features)
-- [Getting Started](#getting-started)
-  - [Prerequisites](#prerequisites)
-  - [Installation](#installation)
 - [Configuration](#configuration)
   - [Essential Configuration](#essential-configuration)
   - [Optional Configuration](#optional-configuration)
@@ -34,8 +31,14 @@
   - [Token System](#token-system)
   - [URL Shortening](#url-shortening)
   - [Rate Limiting System](#rate-limiting-system)
-- [Production Deployment Guide](#production-deployment-guide)
-  - [Custom Domain & FQDN System](#custom-domain--fqdn-system)
+  - [Network Speed Testing](#network-speed-testing)
+- [Deployment Guide](#deployment-guide)
+  - [Prerequisites](#prerequisites)
+  - [Installation](#installation)
+  - [Quick Deploy](#quick-deploy)
+    - [Deploy to Koyeb](#deploy-to-koyeb)
+    - [Deploy to Render](#deploy-to-render)
+    - [Deploy to Railway](#deploy-to-railway)
   - [Reverse Proxy Setup](#reverse-proxy-setup)
 - [Support & Community](#support--community)
   - [Troubleshooting & FAQ](#troubleshooting--faq)
@@ -95,65 +98,6 @@ User Uploads File → Telegram Bot → Forwards to Channel → Generates Direct
 - 🎨 **Custom Templates** - Personalize messages sent by the bot to match your brand.
 - 📈 **Media Info Display** - Shows file size, duration, and format details in the response message.
 
-## Getting Started
-
-This section covers the system requirements and step-by-step installation guide for setting up Thunder.
-
-### Prerequisites
-
-| Requirement | Description | Source |
-| :--- | :--- | :--- |
-| Python 3.13 | Programming language | [python.org](https://python.org) |
-| MongoDB | Database | [mongodb.com](https://mongodb.com) |
-| Telegram API | API credentials | [my.telegram.org](https://my.telegram.org/apps) |
-| Bot Token | From @BotFather | [@BotFather](https://t.me/BotFather) |
-| Public Server | VPS/Dedicated server | Any provider |
-| Storage Channel | For file storage | Create in Telegram |
-
-### Installation
-
-#### Docker Installation (Recommended)
-
-```bash
-# 1. Clone repository
-git clone https://github.com/fyaz05/FileToLink.git
-cd FileToLink
-
-# 2. Configure
-cp config_sample.env config.env
-nano config.env  # Edit your settings
-
-# 3. Build and run
-docker build -t thunder .
-docker run -d --name thunder -p 8080:8080 thunder
-```
-
-<details>
-<summary>Manual Installation</summary>
-
-```bash
-# 1. Clone repository
-git clone https://github.com/fyaz05/FileToLink.git
-cd FileToLink
-
-# 2. Setup virtual environment
-python3 -m venv venv
-source venv/bin/activate  # Windows: venv\Scripts\activate
-
-# 3. Install dependencies
-pip install -r requirements.txt
-
-# 4. Configure
-cp config_sample.env config.env
-nano config.env
-
-# 5. Run bot
-python -m Thunder
-```
-
-> **Tip:** Start with the essential configuration to get Thunder running, then add optional features as needed.
-
-</details>
 
 ## Configuration
 
@@ -168,15 +112,16 @@ Copy `config_sample.env` to `config.env` and fill in your values.
 | `BOT_TOKEN` | Bot token from @BotFather | `123456:ABCdefGHI` |
 | `BIN_CHANNEL` | Storage channel ID | `-1001234567890` |
 | `OWNER_ID` | Owner user ID | `12345678` |
-| `OWNER_USERNAME` | Owner username | `yourusername` |
 | `DATABASE_URL` | MongoDB connection | `mongodb+srv://...` |
 | `FQDN` | Domain/IP address | `f2l.thunder.com` |
 | `HAS_SSL` | HTTPS enabled | `True` or `False` |
 | `PORT` | Server port | `8080` |
 | `NO_PORT` | Hide port in URLs | `True` or `False` |
 
+### Optional Configuration
+
 <details>
-<summary><h3>Optional Configuration</h3></summary>
+<summary>Optional Configuration Details</summary>
 
 | Variable | Description | Default |
 | :--- | :--- | :--- |
@@ -324,19 +269,95 @@ Monitor server performance with built-in speed testing:
 
 Features include download/upload speeds, latency measurements, and shareable result images for performance monitoring.
 
-## Production Deployment Guide
+## Deployment Guide
+
+This section covers the complete setup process for deploying Thunder, from prerequisites to production deployment.
+
+### Prerequisites
+
+| Requirement | Description | Source |
+| :--- | :--- | :--- |
+| Python 3.13 | Programming language | [python.org](https://python.org) |
+| MongoDB | Database | [mongodb.com](https://mongodb.com) |
+| Telegram API | API credentials | [my.telegram.org](https://my.telegram.org/apps) |
+| Bot Token | From @BotFather | [@BotFather](https://t.me/BotFather) |
+| Public Server | VPS/Dedicated server | Any provider |
+| Storage Channel | For file storage | Create in Telegram |
+
+### Installation
 
-### Custom Domain & FQDN System
+#### Docker Installation (Recommended)
+
+```bash
+# 1. Clone repository
+git clone https://github.com/fyaz05/FileToLink.git
+cd FileToLink
 
-Thunder provides enterprise-grade domain configuration through the `FQDN` setting, enabling professional file sharing with custom domains and comprehensive SSL support.
+# 2. Configure
+cp config_sample.env config.env
+nano config.env  # Edit your settings
 
--   **Custom Domain Support**: Set your primary domain for file sharing.
--   **Protocol Selection**: Dynamically serves over HTTP/HTTPS based on your `HAS_SSL` configuration.
--   **Cloudflare Compatible**: Full support for Cloudflare Origin Certificates and reverse proxies.
--   **Security Headers**: Adds proper security headers for production deployments.
+# 3. Build and run
+docker build -t thunder .
+docker run -d --name thunder -p 8080:8080 thunder
+```
 
 <details>
-<summary><h3>Reverse Proxy Setup</h3></summary>
+<summary>Manual Installation</summary>
+
+```bash
+# 1. Clone repository
+git clone https://github.com/fyaz05/FileToLink.git
+cd FileToLink
+
+# 2. Setup virtual environment
+python3 -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+
+# 3. Install dependencies
+pip install -r requirements.txt
+
+# 4. Configure
+cp config_sample.env config.env
+nano config.env
+
+# 5. Run bot
+python -m Thunder
+```
+
+> **Tip:** Start with the essential configuration to get Thunder running, then add optional features as needed.
+
+</details>
+
+## Quick Deploy
+
+### Deploy to Koyeb
+
+[![Deploy to Koyeb](https://www.koyeb.com/static/images/deploy/button.svg)](https://app.koyeb.com/deploy?type=docker&image=docker.io/fyaz05/thunder:latest&name=thunder&ports=8080;http;/&env[API_ID]=&env[API_HASH]=&env[BOT_TOKEN]=&env[BIN_CHANNEL]=&env[OWNER_ID]=&env[DATABASE_URL]=&env[FQDN]=)
+
+
+After deployment, to add any additional environment variables, use the Koyeb dashboard under **Settings** → **Environment Variables**.
+
+### Deploy to Render
+
+1. Open [Render Dashboard](https://dashboard.render.com) → **New** → **Web Service**
+2. Choose **Existing Image**: `fyaz05/thunder:latest`
+3. Add your environment variables
+4. Click **Deploy**
+
+### Deploy to Railway
+
+1. Open [Railway](https://railway.app) → **New Project** → **Deploy Service**
+2. Choose **Docker Image**: `fyaz05/thunder:latest`
+3. Add your environment variables
+4. Click **Deploy**
+
+> **Note:** See the [Configuration](#configuration) section for required environment variables.
+
+## Reverse Proxy Setup
+
+<details>
+<summary>Reverse Proxy Guide</summary>
 
 This guide will help you set up a secure reverse proxy using **NGINX** for your file streaming bot with **Cloudflare SSL protection**.
 
@@ -433,23 +454,54 @@ Your reverse proxy is now securely streaming files behind Cloudflare!
 
 ### Troubleshooting & FAQ
 
-**Bot not responding?**
+#### **Initial Setup**
+
+**Q: Why isn't my bot responding after setup?**
+A: This is usually a configuration issue. Please check the following:
+1.  **Verify `config.env`**: Make sure all essential variables (`API_ID`, `API_HASH`, `BOT_TOKEN`, `BIN_CHANNEL`, `DATABASE_URL`) are filled in correctly.
+2.  **Use `config.env` Only**: Do not edit `vars.py` or `config_sample.env`. The bot is designed to only read your settings from `config.env`.
+3.  **Check Logs**: Review the console logs on your server or hosting platform (Koyeb, Render, Heroku) for any startup errors.
+
+**Q: What do I use for the `FQDN` variable?**
+A: It's the public URL or IP address of your bot.
+-   **With a Domain**: Use your subdomain (e.g., `f2l.thunder.com`).
+-   **On Koyeb/Render/Heroku**: Use the public URL provided by the platform.
+-   **On a VPS**: Use your server's public IP address.
+
+**Q: Why are my links not working on a VPS?**
+A: For links to work on a VPS, the URL must include the port number (e.g., `http://YOUR_VPS_IP:8080`). Ensure that `NO_PORT` is set to `False` in `config.env` and that your server is configured to allow traffic through that port.
+
+#### **Common Errors**
+
+**Q: Why are my links showing a "Resource Not Found" error or not working?**
+A: This error means the bot can't access the file. Check these three things:
+1.  **Invalid Token**: Your `BOT_TOKEN` or one of the `MULTI_TOKEN`s might be wrong. Double-check them with @BotFather.
+2.  **Missing Admin Rights**: The bot and **all** your client accounts must be **administrators** in the `BIN_CHANNEL`.
+3.  **File Deleted**: The link will break if the file was deleted from your `BIN_CHANNEL`.
+
+**Q: Why isn't video or audio playing correctly in my browser?**
+A: Your browser likely doesn't support the file's audio or video format (codec). This is a browser limitation, not a bot issue.
+-   **Solution**: For perfect playback, copy the link and play it in a dedicated media player. Recommended players include **VLC Media Player**, **MX Player**, **PotPlayer**, **IINA**, and **MPV**.
+
+**Q: Why does the bot sometimes become unresponsive?**
+A: This is likely a **Telegram Flood Wait**. To prevent spam, Telegram temporarily limits accounts that make too many requests. The bot is designed to handle this automatically by pausing and will resume on its own once the limit is lifted.
 
--   Check if the `BOT_TOKEN` is correct in your `config.env`.
--   Ensure your server's firewall is not blocking the bot's port.
--   View bot logs for any error messages.
+#### **Performance**
 
-**Links not working?**
+**Q: How can I fix slow download and streaming speeds?**
+A: If your speeds are slow, here’s how to fix it:
+-   **Add More Clients**: This is the best solution. Add `MULTI_TOKEN`s to your `config.env` to distribute the workload and increase throughput.
+-   **Use DC4 Accounts**: For top performance, use Telegram accounts from **Data Center 4 (DC4)**, as they often have the fastest connection. Use `/dc` to check an account's data center.
+-   **Upgrade Your Server**: A server with a slow network will bottleneck your speeds. Consider upgrading your VPS plan.
 
--   Verify your `FQDN` and `PORT` settings are correct.
--   If using SSL (`HAS_SSL=True`), ensure your reverse proxy and certificates are set up correctly.
--   Check that the bot has admin rights in the `BIN_CHANNEL` and can forward messages there.
+#### **Bot Usage**
 
-**Q: How do I get my API credentials?**
-A: Visit [my.telegram.org/apps](https://my.telegram.org/apps) to get your `API_ID` and `API_HASH`.
+**Q: How do I generate links for multiple files at once?**
+A: The `/link` command can process multiple files sent in sequence. To use it, **reply to the first file** of the series with the command and the total count.
+-   **Example**: For a series of 5 files, reply to the very first file with `/link 5`.
 
-**Q: Where can I create a bot token?**
-A: Use [@BotFather](https://t.me/BotFather) on Telegram to create and manage your bot.
+**Q: Can I mix tokens from different accounts and data centers?**
+A: Yes. Mixing clients from different accounts and data centers (like DC1, DC4, and DC5) is a great way to improve bot performance and reliability.
 
 ### Contributing
 
@@ -469,7 +521,7 @@ Licensed under the [Apache License 2.0](LICENSE). See the `LICENSE` file for det
 
 -   [Pyrofork](https://github.com/Mayuri-Chan/pyrofork) - Telegram MTProto API Framework
 -   [aiohttp](https://github.com/aio-libs/aiohttp) - Asynchronous HTTP Client/Server
--   [Motor](https://github.com/mongodb/motor) - Asynchronous MongoDB Driver
+-   [PyMongo](https://github.com/mongodb/mongo-python-driver) - Asynchronous MongoDB Driver
 -   [TgCrypto](https://github.com/pyrogram/tgcrypto) - High-performance cryptography library
 
 ## ⚠️ Disclaimer

Thunder/__init__.py

@@ -3,4 +3,4 @@
 import time
 
 StartTime = time.time()
-__version__ = "1.9.8"
+__version__ = "1.9.9"

Thunder/__main__.py

@@ -12,6 +12,7 @@ from pathlib import Path
 install()
 from aiohttp import web
 from pyrogram import idle
+from pyrogram.errors import FloodWait, MessageNotModified
 
 from Thunder import __version__
 from Thunder.bot import StreamBot
@@ -19,7 +20,6 @@ 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
@@ -100,8 +100,20 @@ async def start_services():
 
     print("   ▶ Starting Telegram Bot initialization...")
     try:
-        await handle_flood_wait(StreamBot.start)
-        bot_info = await handle_flood_wait(StreamBot.get_me)
+        try:
+            await StreamBot.start()
+        except FloodWait as e:
+            logger.debug(f"FloodWait in bot start, sleeping for {e.value}s")
+            await asyncio.sleep(e.value)
+            await StreamBot.start()
+        
+        try:
+            bot_info = await StreamBot.get_me()
+        except FloodWait as e:
+            logger.debug(f"FloodWait in get_me, sleeping for {e.value}s")
+            await asyncio.sleep(e.value)
+            bot_info = await StreamBot.get_me()
+        
         StreamBot.username = bot_info.username
         print(f"   ✓ Bot initialized successfully as @{StreamBot.username}")
 
@@ -111,12 +123,22 @@ async def start_services():
         restart_message_data = await db.get_restart_message()
         if restart_message_data:
             try:
-                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,
-                )
+                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 edit, 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,
+                    )
+                except MessageNotModified:
+                    pass
                 await db.delete_restart_message(
                     restart_message_data["message_id"]
                 )
@@ -197,7 +219,6 @@ async def start_services():
     print(f"   ▶ Bot Name: {bot_info.first_name}")
     print(f"   ▶ Username: @{bot_info.username}")
     print(f"   ▶ Server: {bind_address}:{Var.PORT}")
-    print(f"   ▶ Owner: {Var.OWNER_USERNAME}")
     print(f"   ▶ Startup Time: {elapsed_time:.2f} seconds")
     print("╚═══════════════════════════════════════════════════════════╝")
     print("   ▶ Bot is now running! Press CTRL+C to stop.")

Thunder/bot/clients.py

@@ -3,17 +3,21 @@
 import asyncio
 
 from pyrogram import Client
+from pyrogram.errors import FloodWait
 
 from Thunder.bot import StreamBot, multi_clients, work_loads
 from Thunder.utils.config_parser import TokenParser
-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 handle_flood_wait(client.stop)
+            try:
+                await client.stop()
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await client.stop()
         except Exception as e:
             logger.error(f"Error stopping client: {e}", exc_info=True)
 
@@ -46,7 +50,11 @@ async def initialize_clients():
                 max_concurrent_transmissions=1000,
                 sleep_threshold=Var.SLEEP_THRESHOLD
             )
-            await handle_flood_wait(client.start)
+            try:
+                await client.start()
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await client.start()
             work_loads[client_id] = 0
             print(f"   ◎ Client ID {client_id} started")
             return client_id, client

Thunder/bot/plugins/admin.py

@@ -12,6 +12,7 @@ import psutil
 from pyrogram import filters
 from pyrogram.client import Client
 from pyrogram.enums import ParseMode
+from pyrogram.errors import FloodWait, MessageNotModified
 from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
 
 from Thunder import StartTime, __version__
@@ -19,7 +20,6 @@ from Thunder.bot import StreamBot, multi_clients, work_loads
 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 (
@@ -156,9 +156,12 @@ async def send_logs(client: Client, message: Message):
         return
     
     try:
-        await handle_flood_wait(
-            message.reply_document, LOG_FILE,
-            caption=MSG_LOG_FILE_CAPTION)
+        try:
+            await message.reply_document(LOG_FILE, caption=MSG_LOG_FILE_CAPTION)
+        except FloodWait as e:
+            logger.debug(f"FloodWait in log file sending, sleeping for {e.value}s")
+            await asyncio.sleep(e.value)
+            await 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 reply(message, text=MSG_ERROR_GENERIC)
@@ -246,7 +249,12 @@ async def ban_command(client: Client, message: Message):
                 text += MSG_CHANNEL_BANNED_REASON_SUFFIX.format(reason=reason)
             await reply(message, text=text)
             try:
-                await handle_flood_wait(client.leave_chat, target_id)
+                try:
+                    await client.leave_chat(target_id)
+                except FloodWait as e:
+                    logger.debug(f"FloodWait in leave_chat, sleeping for {e.value}s")
+                    await asyncio.sleep(e.value)
+                    await client.leave_chat(target_id)
             except Exception as e:
                 logger.warning(f"Could not leave banned channel {target_id}: {e}", exc_info=True)
         else:
@@ -260,7 +268,12 @@ async def ban_command(client: Client, message: Message):
                 text += MSG_BAN_REASON_SUFFIX.format(reason=reason)
             await reply(message, text=text)
             try:
-                await handle_flood_wait(client.send_message, target_id, MSG_USER_BANNED_NOTIFICATION)
+                try:
+                    await client.send_message(target_id, MSG_USER_BANNED_NOTIFICATION)
+                except FloodWait as e:
+                    logger.debug(f"FloodWait in ban notification, sleeping for {e.value}s")
+                    await asyncio.sleep(e.value)
+                    await client.send_message(target_id, MSG_USER_BANNED_NOTIFICATION)
             except Exception as e:
                 logger.warning(f"Could not notify banned user {target_id}: {e}", exc_info=True)
 
@@ -288,7 +301,12 @@ async def unban_command(client: Client, message: Message):
             if await db.remove_banned_user(user_id=target_id):
                 await reply(message, text=MSG_ADMIN_USER_UNBANNED.format(user_id=target_id))
                 try:
-                    await handle_flood_wait(client.send_message, target_id, MSG_USER_UNBANNED_NOTIFICATION)
+                    try:
+                        await client.send_message(target_id, MSG_USER_UNBANNED_NOTIFICATION)
+                    except FloodWait as e:
+                        logger.debug(f"FloodWait in unban notification, sleeping for {e.value}s")
+                        await asyncio.sleep(e.value)
+                        await client.send_message(target_id, MSG_USER_UNBANNED_NOTIFICATION)
                 except Exception as e:
                     logger.warning(f"Could not notify unbanned user {target_id}: {e}", exc_info=True)
             else:
@@ -331,24 +349,45 @@ async def run_shell_command(client: Client, message: Message):
         
         output = output.strip() or MSG_SHELL_NO_OUTPUT
         
-        await handle_flood_wait(status_msg.delete)
+        try:
+            await status_msg.delete()
+        except FloodWait as e:
+            logger.debug(f"FloodWait in shell status message delete, sleeping for {e.value}s")
+            await asyncio.sleep(e.value)
+            await status_msg.delete()
         
         if len(output) > 4096:
             file = BytesIO(output.encode())
             file.name = "shell_output.txt"
-            await handle_flood_wait(
-                message.reply_document, file,
-                caption=MSG_SHELL_OUTPUT.format(
-                    command=html.escape(command)))
+            try:
+                await message.reply_document(
+                    file,
+                    caption=MSG_SHELL_OUTPUT.format(
+                        command=html.escape(command)))
+            except FloodWait as e:
+                logger.debug(f"FloodWait in shell output document, sleeping for {e.value}s")
+                await asyncio.sleep(e.value)
+                await message.reply_document(
+                    file,
+                    caption=MSG_SHELL_OUTPUT.format(
+                        command=html.escape(command)))
         else:
             await reply(message, text=output, parse_mode=ParseMode.HTML)
             
     except Exception as e:
         try:
-            await handle_flood_wait(
-                status_msg.edit_text,
-                MSG_SHELL_ERROR.format(error=html.escape(str(e))),
-                parse_mode=ParseMode.HTML)
+            try:
+                await status_msg.edit_text(
+                    MSG_SHELL_ERROR.format(error=html.escape(str(e))),
+                    parse_mode=ParseMode.HTML)
+            except FloodWait as e:
+                logger.debug(f"FloodWait in shell error message edit, sleeping for {e.value}s")
+                await asyncio.sleep(e.value)
+                await status_msg.edit_text(
+                    MSG_SHELL_ERROR.format(error=html.escape(str(e))),
+                    parse_mode=ParseMode.HTML)
+            except MessageNotModified:
+                pass
         except Exception:
             await reply(
                 message,
@@ -362,7 +401,14 @@ async def speedtest_command(client: Client, message: Message):
     try:
         result_dict, image_url = await run_speedtest()
         if result_dict is None:
-            await handle_flood_wait(status_msg.edit_text, MSG_SPEEDTEST_ERROR)
+            try:
+                await status_msg.edit_text(MSG_SPEEDTEST_ERROR)
+            except FloodWait as e:
+                logger.debug(f"FloodWait in speedtest error edit, sleeping for {e.value}s")
+                await asyncio.sleep(e.value)
+                await status_msg.edit_text(MSG_SPEEDTEST_ERROR)
+            except MessageNotModified:
+                pass
             return
         
         result_text = _format_speedtest_result(result_dict)
@@ -370,7 +416,14 @@ async def speedtest_command(client: Client, message: Message):
     except Exception as e:
         logger.error(f"Error in speedtest_command: {e}", exc_info=True)
         try:
-            await handle_flood_wait(status_msg.edit_text, MSG_SPEEDTEST_ERROR)
+            try:
+                await status_msg.edit_text(MSG_SPEEDTEST_ERROR)
+            except FloodWait as e:
+                logger.debug(f"FloodWait in speedtest exception error edit, sleeping for {e.value}s")
+                await asyncio.sleep(e.value)
+                await status_msg.edit_text(MSG_SPEEDTEST_ERROR)
+            except MessageNotModified:
+                pass
         except Exception:
             await reply(message, text=MSG_SPEEDTEST_ERROR)
 
@@ -403,10 +456,27 @@ def _format_speedtest_result(result_dict: dict) -> str:
 
 async def _send_result(message: Message, status_msg: Message, result_text: str, image_url: str):
     if image_url:
-        await handle_flood_wait(message.reply_photo, image_url, caption=result_text, parse_mode=ParseMode.MARKDOWN)
-        await handle_flood_wait(status_msg.delete)
+        try:
+            await message.reply_photo(image_url, caption=result_text, parse_mode=ParseMode.MARKDOWN)
+        except FloodWait as e:
+            logger.debug(f"FloodWait in speedtest photo reply, sleeping for {e.value}s")
+            await asyncio.sleep(e.value)
+            await message.reply_photo(image_url, caption=result_text, parse_mode=ParseMode.MARKDOWN)
+        try:
+            await status_msg.delete()
+        except FloodWait as e:
+            logger.debug(f"FloodWait in speedtest status delete, sleeping for {e.value}s")
+            await asyncio.sleep(e.value)
+            await status_msg.delete()
     else:
-        await handle_flood_wait(status_msg.edit_text, result_text, parse_mode=ParseMode.MARKDOWN)
+        try:
+            await status_msg.edit_text(result_text, parse_mode=ParseMode.MARKDOWN)
+        except FloodWait as e:
+            logger.debug(f"FloodWait in speedtest result edit, sleeping for {e.value}s")
+            await asyncio.sleep(e.value)
+            await status_msg.edit_text(result_text, parse_mode=ParseMode.MARKDOWN)
+        except MessageNotModified:
+            pass
 
 
 def _fmt(value, decimals: int = 2) -> str:

Thunder/bot/plugins/callbacks.py

@@ -1,14 +1,15 @@
 # Thunder/bot/plugins/callbacks.py
 
+import asyncio
+
 from pyrogram import Client, filters
-from pyrogram.errors import MessageNotModified, MessageDeleteForbidden
+from pyrogram.errors import FloodWait, MessageNotModified, MessageDeleteForbidden
 from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
                             InlineKeyboardMarkup)
 
 from Thunder.bot import StreamBot
 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 (
     MSG_ABOUT, MSG_BROADCAST_CANCEL, MSG_BUTTON_ABOUT, MSG_BUTTON_CLOSE,
@@ -22,7 +23,11 @@ async def get_force_channel_button(client: Client):
     if not Var.FORCE_CHANNEL_ID:
         return None
     try:
-        chat = await handle_flood_wait(client.get_chat, Var.FORCE_CHANNEL_ID)
+        try:
+            chat = await client.get_chat(Var.FORCE_CHANNEL_ID)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            chat = await 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:
@@ -43,17 +48,28 @@ 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 handle_flood_wait(
-            callback_query.message.edit_text,
-            text=MSG_HELP.format(max_files=Var.MAX_BATCH_FILES),
-            reply_markup=InlineKeyboardMarkup(buttons),
-            disable_web_page_preview=True
-        )
+        try:
+            await callback_query.message.edit_text(
+                text=MSG_HELP.format(max_files=Var.MAX_BATCH_FILES),
+                reply_markup=InlineKeyboardMarkup(buttons),
+                disable_web_page_preview=True
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await callback_query.message.edit_text(
+                text=MSG_HELP.format(max_files=Var.MAX_BATCH_FILES),
+                reply_markup=InlineKeyboardMarkup(buttons),
+                disable_web_page_preview=True
+            )
     except MessageNotModified:
         pass
     except Exception as e:
         logger.error(f"Error in help callback: {e}", exc_info=True)
-        await handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
+        try:
+            await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await 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):
@@ -66,46 +82,80 @@ async def about_callback(client: Client, callback_query: CallbackQuery):
                 InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")
             ]
         ]
-        await handle_flood_wait(
-            callback_query.message.edit_text,
-            text=MSG_ABOUT,
-            reply_markup=InlineKeyboardMarkup(buttons),
-            disable_web_page_preview=True
-        )
+        try:
+            await callback_query.message.edit_text(
+                text=MSG_ABOUT,
+                reply_markup=InlineKeyboardMarkup(buttons),
+                disable_web_page_preview=True
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await callback_query.message.edit_text(
+                text=MSG_ABOUT,
+                reply_markup=InlineKeyboardMarkup(buttons),
+                disable_web_page_preview=True
+            )
     except MessageNotModified:
         pass
     except Exception as e:
         logger.error(f"Error in about callback: {e}", exc_info=True)
-        await handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
+        try:
+            await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await 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 handle_flood_wait(callback_query.answer, MSG_ERROR_BROADCAST_RESTART, show_alert=True)
+        try:
+            await callback_query.answer(MSG_ERROR_BROADCAST_RESTART, show_alert=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await 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 handle_flood_wait(
-            callback_query.message.edit_text,
-            MSG_ERROR_BROADCAST_INSTRUCTION,
-            reply_markup=InlineKeyboardMarkup(buttons),
-            disable_web_page_preview=True
-        )
+        try:
+            await callback_query.message.edit_text(
+                MSG_ERROR_BROADCAST_INSTRUCTION,
+                reply_markup=InlineKeyboardMarkup(buttons),
+                disable_web_page_preview=True
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await callback_query.message.edit_text(
+                MSG_ERROR_BROADCAST_INSTRUCTION,
+                reply_markup=InlineKeyboardMarkup(buttons),
+                disable_web_page_preview=True
+            )
     except Exception as e:
         logger.error(f"Error in restart broadcast callback: {e}", exc_info=True)
-        await handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
+        try:
+            await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await 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 handle_flood_wait(callback_query.answer)
         try:
-            await handle_flood_wait(callback_query.message.delete)
+            await callback_query.answer()
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await callback_query.answer()
+        try:
+            try:
+                await callback_query.message.delete()
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await callback_query.message.delete()
         except MessageDeleteForbidden:
             logger.debug(f"Failed to delete callback query message due to permissions. Message ID: {callback_query.message.id}")
         except Exception as e:
@@ -114,7 +164,11 @@ async def close_panel_callback(client: Client, callback_query: CallbackQuery):
         if callback_query.message.reply_to_message:
             try:
                 reply_msg = callback_query.message.reply_to_message
-                await handle_flood_wait(reply_msg.delete)
+                try:
+                    await reply_msg.delete()
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await reply_msg.delete()
             except MessageDeleteForbidden:
                 logger.debug(f"Failed to delete replied message due to permissions. Message ID: {reply_msg.id}")
             except Exception as e:
@@ -128,23 +182,42 @@ 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 handle_flood_wait(
-                callback_query.message.edit_text,
-                MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id)
-            )
+            try:
+                await callback_query.message.edit_text(
+                    MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id)
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await callback_query.message.edit_text(
+                    MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id)
+                )
         else:
-            await handle_flood_wait(
-                callback_query.answer,
-                MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id),
-                show_alert=True
-            )
+            try:
+                await callback_query.answer(
+                    MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id),
+                    show_alert=True
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await 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 handle_flood_wait(callback_query.answer, "An error occurred. Please try again.", show_alert=True)
+        try:
+            await callback_query.answer("An error occurred. Please try again.", show_alert=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await 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 handle_flood_wait(callback_query.answer, MSG_ERROR_CALLBACK_UNSUPPORTED, show_alert=True)
+        try:
+            await callback_query.answer(MSG_ERROR_CALLBACK_UNSUPPORTED, show_alert=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await 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,9 +1,11 @@
 # Thunder/bot/plugins/common.py
 
+import asyncio
 import time
 from datetime import datetime, timedelta
 
 from pyrogram import Client, filters
+from pyrogram.errors import FloodWait, MessageNotModified
 from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
                             Message, User)
 
@@ -14,7 +16,6 @@ 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.handler import handle_flood_wait
 from Thunder.utils.human_readable import humanbytes
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import (
@@ -47,16 +48,30 @@ 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 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:]
-                    ))
+                    try:
+                        return await msg.reply_text(text=MSG_TOKEN_FAILED.format(
+                            reason="This activation link is not for your account.",
+                            error_id=str(int(time.time()))[-8:]
+                        ))
+                    except FloodWait as e:
+                        await asyncio.sleep(e.value)
+                        return await 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 handle_flood_wait(msg.reply_text, text=MSG_TOKEN_FAILED.format(
-                        reason="Token has already been activated.",
-                        error_id=str(int(time.time()))[-8:]
-                    ))
+                    try:
+                        return await msg.reply_text(text=MSG_TOKEN_FAILED.format(
+                            reason="Token has already been activated.",
+                            error_id=str(int(time.time()))[-8:]
+                        ))
+                    except FloodWait as e:
+                        await asyncio.sleep(e.value)
+                        return await msg.reply_text(text=MSG_TOKEN_FAILED.format(
+                            reason="Token has already been activated.",
+                            error_id=str(int(time.time()))[-8:]
+                        ))
                 
                 now = datetime.utcnow()
                 exp = now + timedelta(hours=Var.TOKEN_TTL_HOURS)
@@ -67,9 +82,17 @@ async def start_command(bot: Client, msg: Message):
                 )
                 
                 hrs = round((exp - now).total_seconds() / 3600, 1)
-                return await handle_flood_wait(msg.reply_text, text=MSG_TOKEN_ACTIVATED.format(duration_hours=hrs))
+                try:
+                    return await msg.reply_text(text=MSG_TOKEN_ACTIVATED.format(duration_hours=hrs))
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    return await msg.reply_text(text=MSG_TOKEN_ACTIVATED.format(duration_hours=hrs))
             else:
-                return await handle_flood_wait(msg.reply_text, text=MSG_TOKEN_INVALID)
+                try:
+                    return await msg.reply_text(text=MSG_TOKEN_INVALID)
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    return await 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)
@@ -86,7 +109,11 @@ async def start_command(bot: Client, msg: Message):
     if link:
         btns.append([InlineKeyboardButton(MSG_BUTTON_JOIN_CHANNEL.format(channel_title=title), url=link)])
     
-    await handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    try:
+        await msg.reply_text(text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await 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):
@@ -103,7 +130,11 @@ 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 handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    try:
+        await msg.reply_text(text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await 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):
@@ -118,7 +149,11 @@ async def about_command(bot: Client, msg: Message):
          InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
     ]
     
-    await handle_flood_wait(msg.reply_text, text=MSG_ABOUT, reply_markup=InlineKeyboardMarkup(btns))
+    try:
+        await msg.reply_text(text=MSG_ABOUT, reply_markup=InlineKeyboardMarkup(btns))
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await 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)
@@ -127,7 +162,11 @@ 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 handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    try:
+        await msg.reply_text(text=txt, reply_markup=InlineKeyboardMarkup(btns))
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await msg.reply_text(text=txt, reply_markup=InlineKeyboardMarkup(btns))
 
 async def send_file_dc(msg: Message, file_msg: Message):
     try:
@@ -161,7 +200,11 @@ async def send_file_dc(msg: Message, file_msg: Message):
         )
         
         btns = [[InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]]
-        await handle_flood_wait(msg.reply_text, text=txt, reply_markup=InlineKeyboardMarkup(btns))
+        try:
+            await msg.reply_text(text=txt, reply_markup=InlineKeyboardMarkup(btns))
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await msg.reply_text(text=txt, reply_markup=InlineKeyboardMarkup(btns))
         
     except Exception as e:
         logger.error(f"File DC error: {e}", exc_info=True)
@@ -207,7 +250,11 @@ async def ping_command(bot: Client, msg: Message):
     if not await force_channel_check(bot, msg):
         return
     start = time.time()
-    sent = await handle_flood_wait(msg.reply_text, text=MSG_PING_START)
+    try:
+        sent = await msg.reply_text(text=MSG_PING_START)
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        sent = await msg.reply_text(text=MSG_PING_START)
     end = time.time()
     ms = (end - start) * 1000
     
@@ -216,8 +263,18 @@ async def ping_command(bot: Client, msg: Message):
          InlineKeyboardButton(MSG_BUTTON_CLOSE, callback_data="close_panel")]
     ]
     
-    await handle_flood_wait(sent.edit_text,
-        MSG_PING_RESPONSE.format(time_taken_ms=ms),
-        reply_markup=InlineKeyboardMarkup(btns),
-        disable_web_page_preview=True
-    )
+    try:
+        await sent.edit_text(
+            MSG_PING_RESPONSE.format(time_taken_ms=ms),
+            reply_markup=InlineKeyboardMarkup(btns),
+            disable_web_page_preview=True
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await sent.edit_text(
+            MSG_PING_RESPONSE.format(time_taken_ms=ms),
+            reply_markup=InlineKeyboardMarkup(btns),
+            disable_web_page_preview=True
+        )
+    except MessageNotModified:
+        pass

Thunder/bot/plugins/stream.py

@@ -5,7 +5,7 @@ import secrets
 from typing import Any, Dict, Optional
 
 from pyrogram import Client, enums, filters
-from pyrogram.errors import MessageNotModified, MessageDeleteForbidden, MessageIdInvalid
+from pyrogram.errors import FloodWait, MessageNotModified, MessageDeleteForbidden, MessageIdInvalid
 from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
@@ -16,7 +16,6 @@ from Thunder.utils.database import db
 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 (
     MSG_BATCH_LINKS_READY, MSG_BUTTON_DOWNLOAD, MSG_BUTTON_START_CHAT,
@@ -39,11 +38,19 @@ MESSAGE_DELAY = 0.5
 
 async def fwd_media(m_msg: Message) -> Optional[Message]:
     try:
-        return await handle_flood_wait(m_msg.copy, chat_id=Var.BIN_CHANNEL)
+        try:
+            return await m_msg.copy(chat_id=Var.BIN_CHANNEL)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            return await 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}")
-            return await handle_flood_wait(m_msg.copy, chat_id=Var.BIN_CHANNEL, caption=None)
+            try:
+                return await m_msg.copy(chat_id=Var.BIN_CHANNEL, caption=None)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                return await m_msg.copy(chat_id=Var.BIN_CHANNEL, caption=None)
         logger.error(f"Error fwd_media copy: {e}", exc_info=True)
         return None
 
@@ -65,22 +72,38 @@ async def validate_request_common(client: Client, message: Message) -> Optional[
 
 
 async def send_channel_links(target_msg: Message, links: Dict[str, Any], source_info: str, source_id: int):
-    await handle_flood_wait(
-        target_msg.reply_text,
-        MSG_NEW_FILE_REQUEST.format(
-            source_info=source_info,
-            id_=source_id,
-            online_link=links['online_link'],
-            stream_link=links['stream_link']
-        ),
-        disable_web_page_preview=True,
-        quote=True
-    )
+    try:
+        await target_msg.reply_text(
+            MSG_NEW_FILE_REQUEST.format(
+                source_info=source_info,
+                id_=source_id,
+                online_link=links['online_link'],
+                stream_link=links['stream_link']
+            ),
+            disable_web_page_preview=True,
+            quote=True
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await target_msg.reply_text(
+            MSG_NEW_FILE_REQUEST.format(
+                source_info=source_info,
+                id_=source_id,
+                online_link=links['online_link'],
+                stream_link=links['stream_link']
+            ),
+            disable_web_page_preview=True,
+            quote=True
+        )
 
 
 async def safe_edit_message(message: Message, text: str, **kwargs):
     try:
-        return await handle_flood_wait(message.edit_text, text, **kwargs)
+        try:
+            return await message.edit_text(text, **kwargs)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            return await message.edit_text(text, **kwargs)
     except MessageNotModified:
         pass
     except MessageDeleteForbidden:
@@ -91,7 +114,11 @@ async def safe_edit_message(message: Message, text: str, **kwargs):
 
 async def safe_delete_message(message: Message):
     try:
-        await handle_flood_wait(message.delete)
+        try:
+            await message.delete()
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await message.delete()
     except MessageDeleteForbidden:
         logger.debug(f"Failed to delete message {message.id} due to permissions.")
     except Exception as e:
@@ -107,32 +134,55 @@ async def send_dm_links(bot: Client, user_id: int, links: Dict[str, Any], chat_t
                       download_link=links['online_link'],
                       stream_link=links['stream_link']
                   )
-        await handle_flood_wait(
-            bot.send_message,
-            chat_id=user_id,
-            text=dm_text,
-            disable_web_page_preview=True,
-            parse_mode=enums.ParseMode.MARKDOWN,
-            reply_markup=get_link_buttons(links)
-        )
+        try:
+            await bot.send_message(
+                chat_id=user_id,
+                text=dm_text,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.MARKDOWN,
+                reply_markup=get_link_buttons(links)
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await bot.send_message(
+                chat_id=user_id,
+                text=dm_text,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.MARKDOWN,
+                reply_markup=get_link_buttons(links)
+            )
     except Exception as e:
         logger.error(f"Error sending DM to user {user_id}: {e}", exc_info=True)
 
 
 async def send_link(msg: Message, links: Dict[str, Any]):
-    await handle_flood_wait(
-        msg.reply_text,
-        MSG_LINKS.format(
-            file_name=links['media_name'],
-            file_size=links['media_size'],
-            download_link=links['online_link'],
-            stream_link=links['stream_link']
-        ),
-        quote=True,
-        parse_mode=enums.ParseMode.MARKDOWN,
-        disable_web_page_preview=True,
-        reply_markup=get_link_buttons(links)
-    )
+    try:
+        await msg.reply_text(
+            MSG_LINKS.format(
+                file_name=links['media_name'],
+                file_size=links['media_size'],
+                download_link=links['online_link'],
+                stream_link=links['stream_link']
+            ),
+            quote=True,
+            parse_mode=enums.ParseMode.MARKDOWN,
+            disable_web_page_preview=True,
+            reply_markup=get_link_buttons(links)
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await msg.reply_text(
+            MSG_LINKS.format(
+                file_name=links['media_name'],
+                file_size=links['media_size'],
+                download_link=links['online_link'],
+                stream_link=links['stream_link']
+            ),
+            quote=True,
+            parse_mode=enums.ParseMode.MARKDOWN,
+            disable_web_page_preview=True,
+            reply_markup=get_link_buttons(links)
+        )
 
 
 @StreamBot.on_message(filters.command("link") & ~filters.private)
@@ -143,14 +193,23 @@ async def link_handler(bot: Client, msg: Message, **kwargs):
             return
         if message.from_user and not await db.is_user_exist(message.from_user.id):
             invite_link = f"https://t.me/{client.me.username}?start=start"
-            await handle_flood_wait(
-                message.reply_text,
-                MSG_ERROR_START_BOT.format(invite_link=invite_link),
-                disable_web_page_preview=True,
-                parse_mode=enums.ParseMode.MARKDOWN,
-                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
-                quote=True
-            )
+            try:
+                await message.reply_text(
+                    MSG_ERROR_START_BOT.format(invite_link=invite_link),
+                    disable_web_page_preview=True,
+                    parse_mode=enums.ParseMode.MARKDOWN,
+                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
+                    quote=True
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await message.reply_text(
+                    MSG_ERROR_START_BOT.format(invite_link=invite_link),
+                    disable_web_page_preview=True,
+                    parse_mode=enums.ParseMode.MARKDOWN,
+                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
+                    quote=True
+                )
             return
 
         if (message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]
@@ -180,7 +239,11 @@ async def link_handler(bot: Client, msg: Message, **kwargs):
                 await reply_user_err(message, MSG_ERROR_INVALID_NUMBER)
                 return
 
-        status_msg = await handle_flood_wait(message.reply_text, MSG_PROCESSING_REQUEST, quote=True)
+        try:
+            status_msg = await message.reply_text(MSG_PROCESSING_REQUEST, quote=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            status_msg = await message.reply_text(MSG_PROCESSING_REQUEST, quote=True)
         shortener_val = handler_kwargs.get('shortener', shortener_val)
         if num_files == 1:
             await process_single(client, message, message.reply_to_message, status_msg, shortener_val, notification_msg=notification_msg)
@@ -208,7 +271,11 @@ async def private_receive_handler(bot: Client, msg: Message, **kwargs):
         notification_msg = handler_kwargs.get('notification_msg')
 
         await log_newusr(client, message.from_user.id, message.from_user.first_name or "")
-        status_msg = await handle_flood_wait(message.reply_text, MSG_PROCESSING_FILE, quote=True)
+        try:
+            status_msg = await message.reply_text(MSG_PROCESSING_FILE, quote=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            status_msg = await message.reply_text(MSG_PROCESSING_FILE, quote=True)
         await process_single(client, message, message, status_msg, shortener_val, notification_msg=notification_msg)
 
     await handle_rate_limited_request(bot, msg, _actual_private_receive_handler, **kwargs)
@@ -232,7 +299,11 @@ async def channel_receive_handler(bot: Client, msg: Message):
 
         if is_banned_statically or is_banned_dynamically:
             try:
-                await handle_flood_wait(client.leave_chat, message.chat.id)
+                try:
+                    await client.leave_chat(message.chat.id)
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await client.leave_chat(message.chat.id)
             except Exception as e:
                 logger.error(f"Error leaving banned channel {message.chat.id}: {e}")
             return
@@ -254,16 +325,27 @@ async def channel_receive_handler(bot: Client, msg: Message):
 
             if notification_msg:
                 try:
-                    await handle_flood_wait(
-                        notification_msg.edit_text,
-                        MSG_NEW_FILE_REQUEST.format(
-                            source_info=source_info,
-                            id_=message.chat.id,
-                            online_link=links['online_link'],
-                            stream_link=links['stream_link']
-                        ),
-                        disable_web_page_preview=True
-                    )
+                    try:
+                        await notification_msg.edit_text(
+                            MSG_NEW_FILE_REQUEST.format(
+                                source_info=source_info,
+                                id_=message.chat.id,
+                                online_link=links['online_link'],
+                                stream_link=links['stream_link']
+                            ),
+                            disable_web_page_preview=True
+                        )
+                    except FloodWait as e:
+                        await asyncio.sleep(e.value)
+                        await notification_msg.edit_text(
+                            MSG_NEW_FILE_REQUEST.format(
+                                source_info=source_info,
+                                id_=message.chat.id,
+                                online_link=links['online_link'],
+                                stream_link=links['stream_link']
+                            ),
+                            disable_web_page_preview=True
+                        )
                 except Exception as e:
                     logger.error(f"Error editing notification message with links: {e}", exc_info=True)
                     await send_channel_links(stored_msg, links, source_info, message.chat.id)
@@ -271,7 +353,11 @@ async def channel_receive_handler(bot: Client, msg: Message):
                 await send_channel_links(stored_msg, links, source_info, message.chat.id)
 
             try:
-                await handle_flood_wait(message.edit_reply_markup, reply_markup=get_link_buttons(links))
+                try:
+                    await message.edit_reply_markup(reply_markup=get_link_buttons(links))
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await message.edit_reply_markup(reply_markup=get_link_buttons(links))
             except (MessageNotModified, MessageDeleteForbidden, MessageIdInvalid):
                 logger.debug(f"Failed to edit reply markup for message {message.id} due to not modified, permissions or invalid ID. Sending new link instead.")
                 await send_link(message, links)
@@ -339,17 +425,29 @@ async def process_single(
             source_info = source_msg.chat.title or "Unknown Channel"
             source_id = source_msg.chat.id
         if source_info and source_id:
-            await handle_flood_wait(
-                stored_msg.reply_text,
-                MSG_NEW_FILE_REQUEST.format(
-                    source_info=source_info,
-                    id_=source_id,
-                    online_link=links['online_link'],
-                    stream_link=links['stream_link']
-                ),
-                disable_web_page_preview=True,
-                quote=True
-            )
+            try:
+                await stored_msg.reply_text(
+                    MSG_NEW_FILE_REQUEST.format(
+                        source_info=source_info,
+                        id_=source_id,
+                        online_link=links['online_link'],
+                        stream_link=links['stream_link']
+                    ),
+                    disable_web_page_preview=True,
+                    quote=True
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await stored_msg.reply_text(
+                    MSG_NEW_FILE_REQUEST.format(
+                        source_info=source_info,
+                        id_=source_id,
+                        online_link=links['online_link'],
+                        stream_link=links['stream_link']
+                    ),
+                    disable_web_page_preview=True,
+                    quote=True
+                )
         if status_msg:
             await safe_delete_message(status_msg)
         return links
@@ -381,18 +479,31 @@ async def process_batch(
         batch_size = min(BATCH_SIZE, count - batch_start)
         batch_ids = list(range(start_id + batch_start, start_id + batch_start + batch_size))
         try:
-            await handle_flood_wait(
-                status_msg.edit_text,
-                MSG_PROCESSING_BATCH.format(
-                    batch_number=(batch_start // BATCH_SIZE) + 1,
-                    total_batches=(count + BATCH_SIZE - 1) // BATCH_SIZE,
-                    file_count=batch_size
+            try:
+                await status_msg.edit_text(
+                    MSG_PROCESSING_BATCH.format(
+                        batch_number=(batch_start // BATCH_SIZE) + 1,
+                        total_batches=(count + BATCH_SIZE - 1) // BATCH_SIZE,
+                        file_count=batch_size
+                    )
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await status_msg.edit_text(
+                    MSG_PROCESSING_BATCH.format(
+                        batch_number=(batch_start // BATCH_SIZE) + 1,
+                        total_batches=(count + BATCH_SIZE - 1) // BATCH_SIZE,
+                        file_count=batch_size
+                    )
                 )
-            )
         except MessageNotModified:
             pass
         try:
-            messages = await handle_flood_wait(bot.get_messages, msg.chat.id, batch_ids)
+            try:
+                messages = await bot.get_messages(msg.chat.id, batch_ids)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                messages = await bot.get_messages(msg.chat.id, batch_ids)
             if messages is None:
                 messages = []
         except Exception as e:
@@ -410,47 +521,81 @@ async def process_batch(
                 failed += 1
         if (processed + failed) % BATCH_UPDATE_INTERVAL == 0 or (processed + failed) == count:
             try:
-                await handle_flood_wait(
-                    status_msg.edit_text,
-                    MSG_PROCESSING_STATUS.format(
-                        processed=processed,
-                        total=count,
-                        failed=failed
+                try:
+                    await status_msg.edit_text(
+                        MSG_PROCESSING_STATUS.format(
+                            processed=processed,
+                            total=count,
+                            failed=failed
+                        )
+                    )
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await status_msg.edit_text(
+                        MSG_PROCESSING_STATUS.format(
+                            processed=processed,
+                            total=count,
+                            failed=failed
+                        )
                     )
-                )
             except MessageNotModified:
                 pass
     for i in range(0, len(links_list), LINK_CHUNK_SIZE):
         chunk = links_list[i:i+LINK_CHUNK_SIZE]
         chunk_text = MSG_BATCH_LINKS_READY.format(count=len(chunk)) + f"\n\n`{chr(10).join(chunk)}`"
-        await handle_flood_wait(
-            msg.reply_text,
-            chunk_text,
-            quote=True,
-            disable_web_page_preview=True,
-            parse_mode=enums.ParseMode.MARKDOWN
-        )
+        try:
+            await msg.reply_text(
+                chunk_text,
+                quote=True,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.MARKDOWN
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await msg.reply_text(
+                chunk_text,
+                quote=True,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.MARKDOWN
+            )
         if msg.chat.type != enums.ChatType.PRIVATE and msg.from_user:
             try:
-                await handle_flood_wait(
-                    bot.send_message,
-                    chat_id=msg.from_user.id,
-                    text=MSG_DM_BATCH_PREFIX.format(chat_title=msg.chat.title or "the chat") + "\n" + chunk_text,
-                    disable_web_page_preview=True,
-                    parse_mode=enums.ParseMode.MARKDOWN
-                )
+                try:
+                    await bot.send_message(
+                        chat_id=msg.from_user.id,
+                        text=MSG_DM_BATCH_PREFIX.format(chat_title=msg.chat.title or "the chat") + "\n" + chunk_text,
+                        disable_web_page_preview=True,
+                        parse_mode=enums.ParseMode.MARKDOWN
+                    )
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await bot.send_message(
+                        chat_id=msg.from_user.id,
+                        text=MSG_DM_BATCH_PREFIX.format(chat_title=msg.chat.title or "the chat") + "\n" + chunk_text,
+                        disable_web_page_preview=True,
+                        parse_mode=enums.ParseMode.MARKDOWN
+                    )
             except Exception as e:
                 logger.error(f"Error sending DM in batch: {e}", exc_info=True)
                 await reply_user_err(msg, MSG_ERROR_DM_FAILED)
         if i + LINK_CHUNK_SIZE < len(links_list):
             await asyncio.sleep(MESSAGE_DELAY)
-    await handle_flood_wait(
-        status_msg.edit_text,
-        MSG_PROCESSING_RESULT.format(
-            processed=processed,
-            total=count,
-            failed=failed
+    try:
+        await status_msg.edit_text(
+            MSG_PROCESSING_RESULT.format(
+                processed=processed,
+                total=count,
+                failed=failed
+            )
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await status_msg.edit_text(
+            MSG_PROCESSING_RESULT.format(
+                processed=processed,
+                total=count,
+                failed=failed
+            )
         )
-    )
     if notification_msg:
         await safe_delete_message(notification_msg)

Thunder/utils/bot_utils.py

@@ -6,12 +6,12 @@ from urllib.parse import quote
 
 from pyrogram import Client
 from pyrogram.enums import ChatMemberStatus
+from pyrogram.errors import FloodWait
 from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
                             Message, User)
 
 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_DC_UNKNOWN,
@@ -24,24 +24,43 @@ from Thunder.vars import Var
 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):
         return
-    await handle_flood_wait(cli.send_message, chat_id=Var.BIN_CHANNEL, text=txt)
+    try:
+        await cli.send_message(chat_id=Var.BIN_CHANNEL, text=txt)
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await cli.send_message(chat_id=Var.BIN_CHANNEL, text=txt)
 
 
 async def notify_own(cli: Client, txt: str):
     o_ids = Var.OWNER_ID if isinstance(Var.OWNER_ID, (list, tuple, set)) else [Var.OWNER_ID]
-    tasks = [handle_flood_wait(cli.send_message, chat_id=oid, text=txt) for oid in o_ids]
+    
+    async def send_with_flood_wait(chat_id: int):
+        try:
+            await cli.send_message(chat_id=chat_id, text=txt)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await cli.send_message(chat_id=chat_id, text=txt)
+    
+    tasks = [send_with_flood_wait(oid) for oid in o_ids]
     if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
-        tasks.append(handle_flood_wait(cli.send_message, chat_id=Var.BIN_CHANNEL, text=txt))
+        tasks.append(send_with_flood_wait(Var.BIN_CHANNEL))
     await asyncio.gather(*tasks, return_exceptions=True)
 
 
 async def reply_user_err(msg: Message, err_txt: str):
-    await handle_flood_wait(
-        msg.reply_text,
-        text=err_txt,
-        reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")]]),
-        disable_web_page_preview=True
-    )
+    try:
+        await msg.reply_text(
+            text=err_txt,
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")]]),
+            disable_web_page_preview=True
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await msg.reply_text(
+            text=err_txt,
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")]]),
+            disable_web_page_preview=True
+        )
 
 
 async def log_newusr(cli: Client, uid: int, fname: str):
@@ -50,7 +69,11 @@ async def log_newusr(cli: Client, uid: int, fname: str):
             return
         await db.add_user(uid)
         if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
-            await handle_flood_wait(cli.send_message, chat_id=Var.BIN_CHANNEL, text=MSG_NEW_USER.format(first_name=fname, user_id=uid))
+            try:
+                await cli.send_message(chat_id=Var.BIN_CHANNEL, text=MSG_NEW_USER.format(first_name=fname, user_id=uid))
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await cli.send_message(chat_id=Var.BIN_CHANNEL, text=MSG_NEW_USER.format(first_name=fname, user_id=uid))
     except Exception as e:
         logger.error(f"Database error in log_newusr for user {uid}: {e}")
 
@@ -91,20 +114,40 @@ async def gen_dc_txt(usr: User) -> str:
 async def get_user(cli: Client, qry: Any) -> Optional[User]:
     if isinstance(qry, str):
         if qry.startswith('@'):
-            return await handle_flood_wait(cli.get_users, qry)
+            try:
+                return await cli.get_users(qry)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                return await cli.get_users(qry)
         elif qry.isdigit():
-            return await handle_flood_wait(cli.get_users, int(qry))
+            try:
+                return await cli.get_users(int(qry))
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                return await cli.get_users(int(qry))
     elif isinstance(qry, int):
-        return await handle_flood_wait(cli.get_users, qry)
+        try:
+            return await cli.get_users(qry)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            return await cli.get_users(qry)
     return None
 
 
 async def is_admin(cli: Client, chat_id_val: int) -> bool:
-    member = await handle_flood_wait(cli.get_chat_member, chat_id_val, cli.me.id)
+    try:
+        member = await cli.get_chat_member(chat_id_val, cli.me.id)
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        member = await cli.get_chat_member(chat_id_val, cli.me.id)
     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, disable_web_page_preview=True)
+    try:
+        return await msg.reply_text(**kwargs, quote=True, disable_web_page_preview=True)
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        return await msg.reply_text(**kwargs, quote=True, disable_web_page_preview=True)

Thunder/utils/broadcast.py

@@ -12,7 +12,6 @@ from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
 from Thunder.utils.database import db
-from Thunder.utils.handler import handle_flood_wait
 from Thunder.utils.logger import logger
 from Thunder.utils.messages import (
     MSG_INVALID_BROADCAST_CMD,
@@ -27,20 +26,32 @@ broadcast_ids = {}
 
 async def broadcast_message(client: Client, message: Message):
     if not message.reply_to_message:
-        await handle_flood_wait(message.reply_text, MSG_INVALID_BROADCAST_CMD)
+        try:
+            await message.reply_text(MSG_INVALID_BROADCAST_CMD)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await 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 handle_flood_wait(
-        message.reply_text,
-        MSG_BROADCAST_START,
-        reply_markup=InlineKeyboardMarkup([[
-            InlineKeyboardButton(MSG_BUTTON_CANCEL_BROADCAST, callback_data=f"cancel_{broadcast_id}")
-        ]])
-    )
+    try:
+        status_msg = await message.reply_text(
+            MSG_BROADCAST_START,
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton(MSG_BUTTON_CANCEL_BROADCAST, callback_data=f"cancel_{broadcast_id}")
+            ]])
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        status_msg = await message.reply_text(
+            MSG_BROADCAST_START,
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton(MSG_BUTTON_CANCEL_BROADCAST, callback_data=f"cancel_{broadcast_id}")
+            ]])
+        )
     
     start_time = time.time()
     stats["total"] = await db.total_users_count()
@@ -87,26 +98,52 @@ async def broadcast_message(client: Client, message: Message):
                 
                 except FloodWait as e:
                     await asyncio.sleep(e.value)
-                    if await handle_flood_wait(message.reply_to_message.copy, user['id']):
-                        stats["success"] += 1
-                    else:
-                        stats["failed"] += 1
+                    try:
+                        result = await message.reply_to_message.copy(user['id'])
+                        if result:
+                            stats["success"] += 1
+                        else:
+                            stats["failed"] += 1
+                    except FloodWait as e2:
+                        await asyncio.sleep(e2.value)
+                        result = await message.reply_to_message.copy(user['id'])
+                        if result:
+                            stats["success"] += 1
+                        else:
+                            stats["failed"] += 1
             except Exception as e:
                 logger.error(f"Error copying message to user {user['id']}: {e}", exc_info=True)
                 stats["failed"] += 1
         
-        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"],
-                successes=stats["success"],
-                failures=stats["failed"],
-                deleted_accounts=stats["deleted"]
-            ),
-            parse_mode=ParseMode.MARKDOWN
-        )
+        try:
+            await status_msg.delete()
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await status_msg.delete()
+        
+        try:
+            await message.reply_text(
+                MSG_BROADCAST_COMPLETE.format(
+                    elapsed_time=get_readable_time(int(time.time() - start_time)),
+                    total_users=stats["total"],
+                    successes=stats["success"],
+                    failures=stats["failed"],
+                    deleted_accounts=stats["deleted"]
+                ),
+                parse_mode=ParseMode.MARKDOWN
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await message.reply_text(
+                MSG_BROADCAST_COMPLETE.format(
+                    elapsed_time=get_readable_time(int(time.time() - start_time)),
+                    total_users=stats["total"],
+                    successes=stats["success"],
+                    failures=stats["failed"],
+                    deleted_accounts=stats["deleted"]
+                ),
+                parse_mode=ParseMode.MARKDOWN
+            )
         
         del broadcast_ids[broadcast_id]
     

Thunder/utils/database.py

@@ -2,20 +2,21 @@
 
 import datetime
 from typing import Optional, Dict, Any
-from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorCollection
+from pymongo import AsyncMongoClient
+from pymongo.asynchronous.collection import AsyncCollection
 from Thunder.vars import Var
 from Thunder.utils.logger import logger
 
 class Database:
     def __init__(self, uri: str, database_name: str, *args, **kwargs):
-        self._client = AsyncIOMotorClient(uri, *args, **kwargs)
+        self._client = AsyncMongoClient(uri, *args, **kwargs)
         self.db = self._client[database_name]
-        self.col: AsyncIOMotorCollection = self.db.users
-        self.banned_users_col: AsyncIOMotorCollection = self.db.banned_users
-        self.banned_channels_col: AsyncIOMotorCollection = self.db.banned_channels
-        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
+        self.col: AsyncCollection = self.db.users
+        self.banned_users_col: AsyncCollection = self.db.banned_users
+        self.banned_channels_col: AsyncCollection = self.db.banned_channels
+        self.token_col: AsyncCollection = self.db.tokens
+        self.authorized_users_col: AsyncCollection = self.db.authorized_users
+        self.restart_message_col: AsyncCollection = self.db.restart_message
 
     async def ensure_indexes(self):
         try:
@@ -208,6 +209,6 @@ class Database:
 
     async def close(self):
         if self._client:
-            self._client.close()
+            await self._client.close()
 
 db = Database(Var.DATABASE_URL, Var.NAME)

Thunder/utils/decorators.py

@@ -1,9 +1,10 @@
 # Thunder/utils/decorators.py
 
+import asyncio
+from pyrogram.errors import FloodWait
 from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
 
 from Thunder.utils.database import db
-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)
@@ -28,14 +29,23 @@ 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 handle_flood_wait(
-                message.reply_text,
-                MSG_DECORATOR_BANNED.format(
-                    reason=ban_details.get('reason', 'Not specified'),
-                    ban_time=ban_time
-                ),
-                quote=True
-            )
+            try:
+                await message.reply_text(
+                    MSG_DECORATOR_BANNED.format(
+                        reason=ban_details.get('reason', 'Not specified'),
+                        ban_time=ban_time
+                    ),
+                    quote=True
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await message.reply_text(
+                    MSG_DECORATOR_BANNED.format(
+                        reason=ban_details.get('reason', 'Not specified'),
+                        ban_time=ban_time
+                    ),
+                    quote=True
+                )
             logger.debug(f"Blocked banned user {user_id}.")
             return False
         return True
@@ -60,18 +70,34 @@ 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 handle_flood_wait(message.reply_text, "Sorry, could not generate an access token link. Please try again later.", quote=True)
+            try:
+                await message.reply_text("Sorry, could not generate an access token link. Please try again later.", quote=True)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await 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 handle_flood_wait(message.reply_text, "Sorry, could not generate an access token link. Please try again later.", quote=True)
+            try:
+                await message.reply_text("Sorry, could not generate an access token link. Please try again later.", quote=True)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await message.reply_text("Sorry, could not generate an access token link. Please try again later.", quote=True)
             return False
 
-        me = await handle_flood_wait(client.get_me)
+        try:
+            me = await client.get_me()
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            me = await 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)
+            try:
+                await message.reply_text("Sorry, an unexpected error occurred. Please try again later.", quote=True)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await 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
@@ -83,20 +109,33 @@ 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 handle_flood_wait(
-            message.reply_text,
-            MSG_TOKEN_INVALID,
-            reply_markup=InlineKeyboardMarkup([
-                [InlineKeyboardButton("Activate Access", url=short_url)]
-            ]),
-            quote=True
-        )
+        try:
+            await message.reply_text(
+                MSG_TOKEN_INVALID,
+                reply_markup=InlineKeyboardMarkup([
+                    [InlineKeyboardButton("Activate Access", url=short_url)]
+                ]),
+                quote=True
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await message.reply_text(
+                MSG_TOKEN_INVALID,
+                reply_markup=InlineKeyboardMarkup([
+                    [InlineKeyboardButton("Activate Access", url=short_url)]
+                ]),
+                quote=True
+            )
         logger.debug(f"Sent temporary token activation link to user {user_id}.")
         return False
     except Exception as e:
         logger.error(f"Error in require_token: {e}", exc_info=True)
         try:
-            await handle_flood_wait(message.reply_text, "An error occurred while checking your authorization. Please try again.", quote=True)
+            try:
+                await message.reply_text("An error occurred while checking your authorization. Please try again.", quote=True)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                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}", exc_info=True)
         return False

Thunder/utils/file_properties.py

@@ -1,14 +1,15 @@
 # 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.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
 
 
@@ -78,7 +79,11 @@ def get_fname(msg: Message) -> str:
 
 async def get_fids(client: Client, chat_id: int, message_id: int) -> FileId:
     try:
-        msg = await handle_flood_wait(client.get_messages, chat_id, message_id)
+        try:
+            msg = await client.get_messages(chat_id, message_id)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            msg = await client.get_messages(chat_id, message_id)
         
         if not msg or getattr(msg, 'empty', False):
             raise FileNotFound("Message not found")

Thunder/utils/force_channel.py

@@ -6,7 +6,6 @@ from pyrogram import Client
 from pyrogram.errors import FloodWait, UserNotParticipant
 from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
 
-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
@@ -24,7 +23,11 @@ async def get_force_info(bot: Client):
         return _force_link, _force_title
     
     try:
-        chat = await handle_flood_wait(bot.get_chat, Var.FORCE_CHANNEL_ID)
+        try:
+            chat = await bot.get_chat(Var.FORCE_CHANNEL_ID)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            chat = await 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"
@@ -54,17 +57,33 @@ async def force_channel_check(client: Client, message: Message):
     except UserNotParticipant:
         link, title = await get_force_info(client)
         if link and title:
-            await handle_flood_wait(
-                message.reply_text,
-                MSG_COMMUNITY_CHANNEL.format(channel_title=title),
-                reply_markup=InlineKeyboardMarkup([[
-                    InlineKeyboardButton("Join", url=link)
-                ]])
-            )
+            try:
+                await message.reply_text(
+                    MSG_COMMUNITY_CHANNEL.format(channel_title=title),
+                    reply_markup=InlineKeyboardMarkup([[
+                        InlineKeyboardButton("Join", url=link)
+                    ]])
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await message.reply_text(
+                    MSG_COMMUNITY_CHANNEL.format(channel_title=title),
+                    reply_markup=InlineKeyboardMarkup([[
+                        InlineKeyboardButton("Join", url=link)
+                    ]])
+                )
         else:
-            await handle_flood_wait(message.reply_text, "You must join the channel to use this bot.")
+            try:
+                await message.reply_text("You must join the channel to use this bot.")
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await 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 handle_flood_wait(message.reply_text, "An unexpected error occurred while checking channel membership. Please try again.")
+        try:
+            await message.reply_text("An unexpected error occurred while checking channel membership. Please try again.")
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await message.reply_text("An unexpected error occurred while checking channel membership. Please try again.")
         return False

Thunder/utils/handler.py

@@ -1,31 +0,0 @@
-# Thunder/utils/handler.py
-
-import asyncio
-from typing import Callable
-
-from pyrogram.errors import FloodWait, MessageNotModified
-
-from Thunder.utils.logger import logger
-
-
-async def handle_flood_wait(func: Callable, *args, **kwargs):
-    retries = kwargs.pop('retries', 3)
-    delay = kwargs.pop('delay', 3)
-
-    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 MessageNotModified:
-            logger.debug(f"MessageNotModified in '{func.__name__}' - not retrying as content hasn't changed.")
-            raise
-        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/rate_limiter.py

@@ -15,7 +15,6 @@ from Thunder.utils.messages import (
     MSG_RATE_LIMIT_QUEUE_REGULAR,
     MSG_RATE_LIMIT_QUEUE_FULL
 )
-from Thunder.utils.handler import handle_flood_wait
 from Thunder.vars import Var
 
 
@@ -228,20 +227,20 @@ class RateLimiter:
                                 self.user_queue_counts.pop(user_id, None)
 
             except asyncio.CancelledError:
-                logger.info("Request executor cancelled, shutting down.")
+                logger.debug("Request executor cancelled, shutting down.")
                 break
             except Exception as e:
                 logger.critical(f"Critical error in request executor: {e}", exc_info=True)
                 await asyncio.sleep(5)
 
     async def shutdown(self):
-        logger.info("Shutting down rate limiter and clearing queues...")
+        logger.debug("Shutting down rate limiter and clearing queues...")
         async with self.request_lock:
             self.request_queue.clear()
             self.priority_queue.clear()
             self.user_queue_counts.clear()
             self.request_event.clear()
-        logger.info("Rate limiter queues cleared.")
+        logger.debug("Rate limiter queues cleared.")
 
     def get_queue_status(self) -> dict:
         return {
@@ -390,12 +389,19 @@ async def _send_notification(bot: Client, message: Message, template: str, file_
 
             text = template.format(wait_estimate=wait_estimate, s="s" if wait_estimate > 1 else "", **format_kwargs)
 
-            return await handle_flood_wait(
-                bot.send_message,
-                chat_id=message.chat.id,
-                text=text,
-                reply_to_message_id=message.id
-            )
+            try:
+                return await bot.send_message(
+                    chat_id=message.chat.id,
+                    text=text,
+                    reply_to_message_id=message.id
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                return await bot.send_message(
+                    chat_id=message.chat.id,
+                    text=text,
+                    reply_to_message_id=message.id
+                )
         else:
             logger.debug("Skipping notification for channel message (no from_user)")
             return None

Thunder/utils/render_template.py

@@ -1,14 +1,15 @@
 # Thunder/utils/render_template.py
 
+import asyncio
 import html as html_module
 import urllib.parse
 
 from jinja2 import Environment, FileSystemLoader
+from pyrogram.errors import FloodWait
 
 from Thunder.bot import StreamBot
 from Thunder.server.exceptions import InvalidHash
 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
 
@@ -22,7 +23,12 @@ template_env = Environment(
 
 async def render_page(id: int, secure_hash: str, requested_action: str | None = None) -> str:
     try:
-        message = await handle_flood_wait(StreamBot.get_messages, chat_id=int(Var.BIN_CHANNEL), message_ids=id)
+        try:
+            message = await StreamBot.get_messages(chat_id=int(Var.BIN_CHANNEL), message_ids=id)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            message = await StreamBot.get_messages(chat_id=int(Var.BIN_CHANNEL), message_ids=id)
+        
         if not message:
             raise InvalidHash("Message not found")
         

Thunder/utils/speedtest.py

@@ -31,7 +31,7 @@ def _perform_speedtest() -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
         results['download_bps'] = st.results.download / 8
         results['upload_bps'] = st.results.upload / 8
         
-        logger.info(f"Download: {download_mbps:.2f} Mbps | Upload: {upload_mbps:.2f} Mbps")
+        logger.debug(f"Download: {download_mbps:.2f} Mbps | Upload: {upload_mbps:.2f} Mbps")
         
         try:
             return results, st.results.share()

Thunder/vars.py

@@ -53,10 +53,8 @@ class Var:
     if not OWNER_ID:
         logger.warning("WARNING: OWNER_ID is not set. No user will be granted owner access.")
 
-    OWNER_USERNAME: str = os.getenv("OWNER_USERNAME", "")
-
     FQDN: str = os.getenv("FQDN", "") or BIND_ADDRESS
-    HAS_SSL: bool = str_to_bool(os.getenv("HAS_SSL", "False"))
+    HAS_SSL: bool = str_to_bool(os.getenv("HAS_SSL", "True"))
     PROTOCOL: str = "https" if HAS_SSL else "http"
     PORT_SEGMENT: str = "" if NO_PORT else f":{PORT}"
     URL: str = f"{PROTOCOL}://{FQDN}{PORT_SEGMENT}/"

config_sample.env

@@ -17,15 +17,14 @@ BOT_TOKEN="" # Example: "123456789:ABCdef..."
 BIN_CHANNEL=0 # Example: -1001234567890
 
 # Owner information (get ID from @userinfobot)
-OWNER_ID="" # Your Telegram user ID(s) as a space-separated string. Example: "123456789 098765432"
-OWNER_USERNAME="" # Example: "@YourUsername"
+OWNER_ID=0 # Your Telegram user ID. Example: 123456789
 
 # Database connection string
 DATABASE_URL="" # Example: "mongodb+srv://user:pass@host/db"
 
 # Deployment configuration
 FQDN="" # Your domain name
-HAS_SSL="False" # Set to "True" if using HTTPS
+HAS_SSL="True" # Set to "True" if using HTTPS
 PORT=8080 # Web server port
 NO_PORT="True" # Hide port in URLs ("True" or "False")
 
@@ -123,3 +122,4 @@ WORKERS=8 # Number of worker processes
 # Web server configuration
 BIND_ADDRESS="0.0.0.0" # Listen on all network interfaces
 PING_INTERVAL=840 # Ping interval in seconds
+

requirements.txt

@@ -2,7 +2,7 @@ aiohttp
 cloudscraper
 Jinja2
 pyrofork
-motor
+pymongo
 psutil
 python-dotenv
 speedtest-cli