Initial commit

venv/Lib/site-packages/aiogram/client/session/middlewares/base.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Protocol
+
+from aiogram.methods import Response, TelegramMethod
+from aiogram.methods.base import TelegramType
+
+if TYPE_CHECKING:
+    from ...bot import Bot
+
+
+class NextRequestMiddlewareType(Protocol[TelegramType]):  # pragma: no cover
+    async def __call__(
+        self,
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        pass
+
+
+class RequestMiddlewareType(Protocol):  # pragma: no cover
+    async def __call__(
+        self,
+        make_request: NextRequestMiddlewareType[TelegramType],
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        pass
+
+
+class BaseRequestMiddleware(ABC):
+    """
+    Generic middleware class
+    """
+
+    @abstractmethod
+    async def __call__(
+        self,
+        make_request: NextRequestMiddlewareType[TelegramType],
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        """
+        Execute middleware
+
+        :param make_request: Wrapped make_request in middlewares chain
+        :param bot: bot for request making
+        :param method: Request method (Subclass of :class:`aiogram.methods.base.TelegramMethod`)
+
+        :return: :class:`aiogram.methods.Response`
+        """
+        pass

venv/Lib/site-packages/aiogram/client/session/middlewares/manager.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import Any, Callable, List, Optional, Sequence, Union, cast, overload
+
+from aiogram.client.session.middlewares.base import (
+    NextRequestMiddlewareType,
+    RequestMiddlewareType,
+)
+from aiogram.methods.base import TelegramType
+
+
+class RequestMiddlewareManager(Sequence[RequestMiddlewareType]):
+    def __init__(self) -> None:
+        self._middlewares: List[RequestMiddlewareType] = []
+
+    def register(
+        self,
+        middleware: RequestMiddlewareType,
+    ) -> RequestMiddlewareType:
+        self._middlewares.append(middleware)
+        return middleware
+
+    def unregister(self, middleware: RequestMiddlewareType) -> None:
+        self._middlewares.remove(middleware)
+
+    def __call__(
+        self,
+        middleware: Optional[RequestMiddlewareType] = None,
+    ) -> Union[
+        Callable[[RequestMiddlewareType], RequestMiddlewareType],
+        RequestMiddlewareType,
+    ]:
+        if middleware is None:
+            return self.register
+        return self.register(middleware)
+
+    @overload
+    def __getitem__(self, item: int) -> RequestMiddlewareType:
+        pass
+
+    @overload
+    def __getitem__(self, item: slice) -> Sequence[RequestMiddlewareType]:
+        pass
+
+    def __getitem__(
+        self, item: Union[int, slice]
+    ) -> Union[RequestMiddlewareType, Sequence[RequestMiddlewareType]]:
+        return self._middlewares[item]
+
+    def __len__(self) -> int:
+        return len(self._middlewares)
+
+    def wrap_middlewares(
+        self,
+        callback: NextRequestMiddlewareType[TelegramType],
+        **kwargs: Any,
+    ) -> NextRequestMiddlewareType[TelegramType]:
+        middleware = partial(callback, **kwargs)
+        for m in reversed(self._middlewares):
+            middleware = partial(m, middleware)
+        return cast(NextRequestMiddlewareType[TelegramType], middleware)

venv/Lib/site-packages/aiogram/client/session/middlewares/request_logging.py

@@ -0,0 +1,37 @@
+import logging
+from typing import TYPE_CHECKING, Any, List, Optional, Type
+
+from aiogram import loggers
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import Response, TelegramType
+
+from .base import BaseRequestMiddleware, NextRequestMiddlewareType
+
+if TYPE_CHECKING:
+    from ...bot import Bot
+
+logger = logging.getLogger(__name__)
+
+
+class RequestLogging(BaseRequestMiddleware):
+    def __init__(self, ignore_methods: Optional[List[Type[TelegramMethod[Any]]]] = None):
+        """
+        Middleware for logging outgoing requests
+
+        :param ignore_methods: methods to ignore in logging middleware
+        """
+        self.ignore_methods = ignore_methods if ignore_methods else []
+
+    async def __call__(
+        self,
+        make_request: NextRequestMiddlewareType[TelegramType],
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        if type(method) not in self.ignore_methods:
+            loggers.middlewares.info(
+                "Make request with method=%r by bot id=%d",
+                type(method).__name__,
+                bot.id,
+            )
+        return await make_request(bot, method)