Initial local state

tgbot/middlewares/__init__.py

@@ -0,0 +1,20 @@
+# - *- coding: utf- 8 - *-
+from aiogram import Dispatcher
+
+from tgbot.middlewares.middleware_throttling import ThrottlingMiddleware
+from tgbot.middlewares.middleware_user import ExistsUserMiddleware
+
+
+# Регистрация пользовательских middleware
+def register_all_middlewares(dp: Dispatcher):
+    dp.callback_query.outer_middleware(ExistsUserMiddleware())
+    dp.message.outer_middleware(ExistsUserMiddleware())
+
+    throttling = ThrottlingMiddleware()
+    dp.message.middleware(throttling)
+    dp.callback_query.middleware(throttling)
+
+
+# Совместимое имя для старых импортов
+def register_all_middlwares(dp: Dispatcher):
+    register_all_middlewares(dp)

tgbot/middlewares/middleware_throttling.py

@@ -0,0 +1,77 @@
+# - *- coding: utf- 8 - *-
+import time
+from typing import Any, Awaitable, Callable, Dict, Optional, Union
+
+from aiogram import BaseMiddleware
+from aiogram.dispatcher.flags import get_flag
+from aiogram.types import CallbackQuery, Message, TelegramObject, User
+from cachetools import TTLCache
+
+from tgbot.data.config import BOT_THROTTLE_RATE
+
+
+class ThrottlingMiddleware(BaseMiddleware):
+    # Создание хранилищ лимитов
+    def __init__(self, default_rate: Union[int, float] = BOT_THROTTLE_RATE) -> None:
+        self.default_rate = default_rate
+        self.message_users = TTLCache(maxsize=10_000, ttl=600)
+        self.callback_users = TTLCache(maxsize=10_000, ttl=600)
+
+    # Ограничение частых сообщений и колбэков
+    async def __call__(self, handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]], event: TelegramObject, data):
+        this_user: Optional[User] = data.get("event_from_user")
+
+        if this_user is None:
+            return await handler(event, data)
+
+        flag_rate = get_flag(data, "rate")
+        rate = float(self.default_rate if flag_rate is None else flag_rate)
+
+        if rate == 0:
+            return await handler(event, data)
+
+        now_time = time.monotonic()
+        bucket = self._get_bucket(event)
+        user_key = this_user.id
+
+        if user_key not in bucket:
+            bucket[user_key] = {
+                "last_throttled": now_time,
+                "count_throttled": 0,
+                "now_rate": rate,
+            }
+
+            return await handler(event, data)
+
+        if now_time - bucket[user_key]["last_throttled"] >= bucket[user_key]["now_rate"]:
+            bucket.pop(user_key)
+
+            return await handler(event, data)
+
+        bucket[user_key]["last_throttled"] = now_time
+        bucket[user_key]["count_throttled"] += 1
+
+        if bucket[user_key]["count_throttled"] == 1:
+            bucket[user_key]["now_rate"] = rate + 2
+            await self._warn_user(event)
+        elif bucket[user_key]["count_throttled"] == 2:
+            bucket[user_key]["now_rate"] = rate + 3
+        else:
+            bucket[user_key]["now_rate"] = rate + 5
+
+        return None
+
+    # Выбор bucket под тип апдейта
+    def _get_bucket(self, event: TelegramObject) -> TTLCache:
+        if isinstance(event, CallbackQuery):
+            return self.callback_users
+
+        return self.message_users
+
+    # Предупреждение пользователя о спаме
+    @staticmethod
+    async def _warn_user(event: TelegramObject) -> None:
+        if isinstance(event, Message):
+            await event.reply("<b>❗ Пожалуйста, не спамьте</b>")
+        elif isinstance(event, CallbackQuery) or hasattr(event, "answer"):
+            await event.answer("❗ Пожалуйста, не спамьте", cache_time=1)

tgbot/middlewares/middleware_user.py

@@ -0,0 +1,50 @@
+# - *- coding: utf- 8 - *-
+from aiogram import BaseMiddleware
+from cachetools import TTLCache
+
+from tgbot.data.config import BOT_USER_CACHE_TTL
+from tgbot.database import Userx
+from tgbot.utils.const_functions import clear_html
+
+
+class ExistsUserMiddleware(BaseMiddleware):
+    # Создание кеша пользователей
+    def __init__(self, cache_ttl: int = BOT_USER_CACHE_TTL) -> None:
+        self.users = Userx()
+        self.cache = TTLCache(maxsize=10_000, ttl=cache_ttl)
+
+    # Добавление или обновление пользователя перед handler-ом
+    async def __call__(self, handler, event, data):
+        this_user = data.get("event_from_user")
+
+        if this_user is not None and not this_user.is_bot:
+            user_id = this_user.id
+            user_login = (this_user.username or "").lower()
+            user_name = clear_html(this_user.first_name) or ""
+            user_surname = clear_html(this_user.last_name) or ""
+            user_fullname = clear_html(this_user.full_name) or " ".join(filter(None, [user_name, user_surname]))
+
+            user_data = (
+                user_login,
+                user_name,
+                user_surname,
+                user_fullname,
+            )
+
+            cached_user = self.cache.get(user_id)
+
+            if cached_user is None or cached_user["data"] != user_data:
+                user = await self.users.upsert(
+                    user_id=user_id,
+                    user_login=user_data[0],
+                    user_name=user_data[1],
+                    user_surname=user_data[2],
+                    user_fullname=user_data[3],
+                )
+                self.cache[user_id] = {"data": user_data, "user": user}
+            else:
+                user = cached_user["user"]
+
+            data["User"] = user
+
+        return await handler(event, data)