Delete Throttle

bot.py

@@ -12,7 +12,6 @@ from middlewares.admin import AdminMiddleware
 from middlewares.database import DatabaseMiddleware
 from middlewares.delete import DeleteMessageMiddleware
 from middlewares.logging import LoggingMiddleware
-from middlewares.throttling import ThrottlingMiddleware
 from middlewares.user import UserMiddleware
 
 bot = Bot(token=API_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
@@ -30,9 +29,8 @@ dp.callback_query.middleware(UserMiddleware())
 dp.message.middleware(DatabaseMiddleware())
 dp.callback_query.middleware(DatabaseMiddleware())
 
-# Add throttling middleware
-dp.message.middleware(ThrottlingMiddleware(limit=1))  # 1 message per second
-dp.callback_query.middleware(ThrottlingMiddleware(limit=1))
+# dp.message.middleware(ThrottlingMiddleware(limit=1))
+# dp.callback_query.middleware(ThrottlingMiddleware(limit=1))
 
 dp.message.outer_middleware(DeleteMessageMiddleware())
 dp.callback_query.outer_middleware(DeleteMessageMiddleware())

middlewares/throttling.py

@@ -1,42 +1,19 @@
-import asyncio
+from collections.abc import Awaitable, Callable
+from typing import Any
 
-from aiogram import Dispatcher, types
-from aiogram.dispatcher import DEFAULT_RATE_LIMIT
-from aiogram.dispatcher.handler import CancelHandler, current_handler
-from aiogram.dispatcher.middlewares import BaseMiddleware
-from aiogram.utils.exceptions import Throttled
-from aiogram.utils.keyboard import InlineKeyboardBuilder
+from aiogram import BaseMiddleware
+from aiogram.types import TelegramObject
 
 
-class ThrottlingMiddleware(BaseMiddleware):
-    def __init__(self, limit=DEFAULT_RATE_LIMIT, key_prefix="antiflood_"):
-        self.rate_limit = limit
-        self.prefix = key_prefix
-        super(ThrottlingMiddleware, self).__init__()
+class ThrottleMiddleware(BaseMiddleware):
+    def __init__(self, limit: int):
+        self.limit = limit
 
-    async def on_process_message(self, message: types.Message, data: dict):
-        handler = current_handler.get()
-        dispatcher = Dispatcher.get_current()
-
-        if handler:
-            limit = getattr(handler, "throttling_rate_limit", self.rate_limit)
-            key = getattr(handler, "throttling_key", f"{self.prefix}_{handler.__name__}")
-        else:
-            limit = self.rate_limit
-            key = f"{self.prefix}_message"
-
-        try:
-            await dispatcher.throttle(key, rate=limit)
-        except Throttled as t:
-            await self.message_throttled(message, t)
-            raise CancelHandler()
-
-    async def message_throttled(self, message: types.Message, throttled: Throttled):
-        delta = throttled.rate - throttled.delta
-
-        if throttled.exceeded_count <= 2:
-            builder = InlineKeyboardBuilder()
-            builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
-            await message.reply("🚫 Слишком много запросов! Пожалуйста, не торопитесь!", reply_markup=builder.as_markup())
-
-        await asyncio.sleep(delta)
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: dict[str, Any],
+    ) -> Any:
+        #todo
+        return await handler(event, data)