aiogram-webhook 3.1.0__tar.gz → 3.2.0__tar.gz

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aiogram-webhook
-Version: 3.1.0
+Version: 3.2.0
 Summary: A python library for integrating webhook support with multiple web frameworks in aiogram. Organizes bot operation via webhooks for both single and multi-bot setups.
 Keywords: aiogram,multibot,telegram,webhook,fastapi,aiohttp
 Author: m-xim
@@ -20,12 +20,6 @@ Requires-Dist: yarl>=1.17.0
 Requires-Dist: multidict>=6.7.1
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: aiohttp>=3.9.0 ; extra == 'aiohttp'
-Requires-Dist: ruff ; extra == 'dev'
-Requires-Dist: ty ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-asyncio ; extra == 'dev'
-Requires-Dist: pytest-cov ; extra == 'dev'
-Requires-Dist: httpx2 ; extra == 'dev'
 Requires-Dist: fastapi>=0.128.0 ; extra == 'fastapi'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/m-xim/aiogram-webhook
@@ -33,7 +27,6 @@ Project-URL: Repository, https://github.com/m-xim/aiogram-webhook
 Project-URL: Issues, https://github.com/m-xim/aiogram-webhook/issues
 Project-URL: Documentation, https://aiogram-webhook.m-xim.ru
 Provides-Extra: aiohttp
-Provides-Extra: dev
 Provides-Extra: fastapi
 Description-Content-Type: text/markdown
 

aiogram_webhook-3.2.0/pyproject.toml

@@ -0,0 +1,80 @@
+[project]
+name = "aiogram-webhook"
+version = "3.2.0"
+description = "A python library for integrating webhook support with multiple web frameworks in aiogram. Organizes bot operation via webhooks for both single and multi-bot setups."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "aiogram>=3.14.0",
+    "yarl>=1.17.0",
+    "multidict>=6.7.1",
+    "aiohttp>=3.9.0",
+]
+keywords = [
+    "aiogram",
+    "multibot",
+    "telegram",
+    "webhook",
+    "fastapi",
+    "aiohttp",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+
+[project.license]
+text = "MIT"
+
+[[project.authors]]
+name = "m-xim"
+email = "i@m-xim.ru"
+
+[project.urls]
+Homepage = "https://github.com/m-xim/aiogram-webhook"
+Repository = "https://github.com/m-xim/aiogram-webhook"
+Issues = "https://github.com/m-xim/aiogram-webhook/issues"
+Documentation = "https://aiogram-webhook.m-xim.ru"
+
+[project.optional-dependencies]
+fastapi = ["fastapi>=0.128.0"]
+aiohttp = ["aiohttp>=3.9.0"]
+
+[dependency-groups]
+dev = [
+    "ruff",
+    "ty",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "httpx2",
+]
+
+[build-system]
+requires = ["uv_build<0.13"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+filterwarnings = ["ignore:Security is not configured:UserWarning"]
+
+[tool.uv]
+package = true
+
+[tool.semantic_release]
+version_source = "pyproject"
+commit_message = "chore(release): {version}"
+version_toml = ["pyproject.toml:project.version"]
+
+[tool.semantic_release.branches.main]
+match = "main"
+
+[tool.semantic_release.branches.develop]
+match = "develop"
+prerelease = true

aiogram_webhook-3.1.0/pyproject.toml → aiogram_webhook-3.2.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "aiogram-webhook"
-version = "3.1.0"
+version = "3.2.0"
 description = "A python library for integrating webhook support with multiple web frameworks in aiogram. Organizes bot operation via webhooks for both single and multi-bot setups."
 readme = "README.md"
 license = { text = "MIT" }
@@ -46,6 +46,8 @@ fastapi = [
 aiohttp = [
     "aiohttp>=3.9.0",
 ]
+
+[dependency-groups]
 dev = [
     "ruff",
     "ty",
@@ -56,7 +58,7 @@ dev = [
 ]
 
 [build-system]
-requires = ["uv_build<0.12"]
+requires = ["uv_build<0.13"]
 build-backend = "uv_build"
 
 [tool.pytest.ini_options]

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/__init__.py

@@ -2,9 +2,10 @@ from aiogram_webhook.configs.bot import BotConfig
 from aiogram_webhook.configs.webhook import WebhookConfig
 from aiogram_webhook.engines.single import SingleBotEngine
 from aiogram_webhook.engines.token import TokenEngine
+from aiogram_webhook.route import Route
 from aiogram_webhook.web.aiohttp import AiohttpAdapter
 
-__all__ = ["AiohttpAdapter", "BotConfig", "SingleBotEngine", "TokenEngine", "WebhookConfig"]
+__all__ = ["AiohttpAdapter", "BotConfig", "Route", "SingleBotEngine", "TokenEngine", "WebhookConfig"]
 
 
 try:

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/engines/base.py

@@ -8,17 +8,17 @@ from aiogram.methods import TelegramMethod
 from aiogram_webhook.engines.errors import (
     BotNotFoundError,
     InvalidJsonError,
-    RequestHandlingStoppedError,
     TargetNotFoundError,
 )
 from aiogram_webhook.engines.target import Target
 from aiogram_webhook.errors import AiogramWebhookError
+from aiogram_webhook.gate import RequestGate
 from aiogram_webhook.logs import get_logger, log_webhook_error
 from aiogram_webhook.route import Route
 from aiogram_webhook.route.params import RouteParams
 from aiogram_webhook.security import Security
 from aiogram_webhook.tasks import TaskTracker
-from aiogram_webhook.utils._payload import build_webhook_payload
+from aiogram_webhook.utils._payload import build_multipart_payload, prepare_webhook_reply
 from aiogram_webhook.web.base import WebAdapter, WebRequest
 
 logger = get_logger("engines")
@@ -45,7 +45,7 @@ class BaseWebhookEngine(ABC, Generic[AppT, RawRequestT, FrameworkResponseT]):
         self.handle_in_background = handle_in_background
 
         self.shutdown_timeout = shutdown_timeout
-        self._is_shutting_down = False
+        self._gate = RequestGate()
 
         if self.security is None:
             warnings.warn(
@@ -66,8 +66,8 @@ class BaseWebhookEngine(ABC, Generic[AppT, RawRequestT, FrameworkResponseT]):
 
     async def handle_request(self, request: WebRequest[RawRequestT]) -> FrameworkResponseT:
         try:
-            if self._is_shutting_down:
-                raise RequestHandlingStoppedError
+            # Fast path: reject early, before match/security.
+            self._gate.ensure_open()
 
             route_params = await self.route.match(request)
 
@@ -78,35 +78,57 @@ class BaseWebhookEngine(ABC, Generic[AppT, RawRequestT, FrameworkResponseT]):
             if self.security is not None:
                 await self.security.verify(target=target, request=request, route_params=route_params)
 
-            bot = await self._resolve_bot(target=target)
-            if bot is None:
-                raise BotNotFoundError(target_bot_id=target.bot_id, target_type=target.__class__.__name__)
-
-            try:
-                update = await request.json()
-            except ValueError as exc:
-                raise InvalidJsonError(original_error=exc) from exc
-
-            if self.handle_in_background:
-                self._get_task_tracker(bot).spawn(self._background_feed(bot, update))
-            else:
-                result = await self.dispatcher.feed_webhook_update(bot=bot, update=update)
-                if isinstance(result, TelegramMethod):
-                    return self.web.payload_response(status_code=200, payload=build_webhook_payload(bot, result))
-
-            return self.web.json_response(status_code=200, data={})
+            # Parse after security, but before the bot: a bad payload must not create a bot.
+            raw_update = await self._read_update(request)
+
+            with self._gate.enter():
+                bot = await self._resolve_bot(target=target)
+                if bot is None:
+                    raise BotNotFoundError(target_bot_id=target.bot_id, target_type=target.__class__.__name__)
+
+                logger.debug("New update: %s", raw_update)
+
+                if self.handle_in_background:
+                    self._get_task_tracker(bot).spawn(self._background_feed(bot, raw_update))
+                else:
+                    result = await self.dispatcher.feed_webhook_update(bot=bot, update=raw_update)
+                    if isinstance(result, TelegramMethod):
+                        data, files = prepare_webhook_reply(bot, result)
+                        logger.debug(
+                            "Replying to webhook with method %s (files: %s)", result.__api_method__, len(files)
+                        )
+                        if files:
+                            # Files can only be uploaded as multipart/form-data.
+                            return self.web.payload_response(
+                                status_code=200, payload=build_multipart_payload(bot, data, files)
+                            )
+                        return self.web.json_response(status_code=200, data=data)
+
+                return self.web.json_response(status_code=200, data={})
 
         except AiogramWebhookError as exc:
             log_webhook_error(logger, exc)
-
             return self.web.json_response(status_code=exc.status_code, data=exc.response_payload())
 
+    @staticmethod
+    async def _read_update(request: WebRequest[RawRequestT]) -> dict[str, Any]:
+        try:
+            raw_update = await request.json()
+        except ValueError as exc:
+            raise InvalidJsonError(original_error=exc) from exc
+
+        # Telegram sends a JSON object: reject arrays/scalars here with 400 instead of a 500 in the dispatcher.
+        if not isinstance(raw_update, dict):
+            raise InvalidJsonError
+
+        return raw_update
+
     async def on_startup(self, app: AppT, *args: Any, **kwargs: Any) -> None:
         await self._on_startup(app, *args, **kwargs)
-        self._is_shutting_down = False
+        self._gate.open()
 
     async def on_shutdown(self, app: AppT, *args: Any, **kwargs: Any) -> None:
-        self._is_shutting_down = True
+        await self._gate.close(self.shutdown_timeout)
         await self._on_shutdown(app, *args, **kwargs)
 
     @abstractmethod

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/engines/token.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections.abc import Iterable
 from typing import TYPE_CHECKING, Generic
 
 from aiogram import Bot
@@ -21,6 +22,12 @@ if TYPE_CHECKING:
 class TokenEngine(
     BaseMultiBotEngine[AppT, RawRequestT, FrameworkResponseT], Generic[AppT, RawRequestT, FrameworkResponseT]
 ):
+    """
+    Multi-bot webhook engine that resolves the bot from a `{bot_token}` route param.
+
+    E.g. `Route(base_url="https://example.com", path="/webhook/{bot_token}", params={"bot_token": BotTokenParam()})`.
+    """
+
     def __init__(
         self,
         dispatcher,
@@ -70,9 +77,12 @@ class TokenEngine(
                 "Set delete_webhook=True to delete webhook and optionally drop pending updates."
             )
 
-        if (tracker := self._task_trackers.pop(bot_id, None)) is not None:
-            await tracker.close(timeout=self.shutdown_timeout)
+        # Detach bot and tracker together with no await in between
         self._bots.pop(bot_id, None)
+        tracker = self._task_trackers.pop(bot_id, None)
+
+        if tracker is not None:
+            await tracker.close(timeout=self.shutdown_timeout)
 
         logger.info("Removed bot %s from token engine", bot_id)
 
@@ -105,14 +115,7 @@ class TokenEngine(
         self._bots[bot.id] = bot
         return bot
 
-    async def _on_startup(self, app: AppT, *args, **kwargs) -> None:  # noqa: ARG002
-        startup_bots = set(self._bots.values())
-
-        logger.info("Starting token-based webhook engine with %s bot(s)", len(startup_bots))
-        workflow_data = self._build_lifecycle_data(app=app, bots=startup_bots, **kwargs)
-        await self.dispatcher.emit_startup(**workflow_data)
-
-    async def _on_shutdown(self, app: AppT, *args, **kwargs) -> None:  # noqa: ARG002
+    async def _on_shutdown(self, app: AppT, *args, bots: Iterable[Bot] | None = None, **kwargs) -> None:  # noqa: ARG002
         logger.info("Stopping token-based webhook engine with %s bot(s)", len(self._bots))
         await asyncio.gather(
             *(tracker.close(timeout=self.shutdown_timeout) for tracker in self._task_trackers.values()),
@@ -120,7 +123,7 @@ class TokenEngine(
 
         self._task_trackers.clear()
 
-        lifecycle_data = self._build_lifecycle_data(app=app, bots=set(self.bots.values()), **kwargs)
+        lifecycle_data = self._build_lifecycle_data(app=app, bots=set(self.bots.values()) | set(bots or ()), **kwargs)
         await self.dispatcher.emit_shutdown(**lifecycle_data)
 
         self._bots.clear()

aiogram_webhook-3.2.0/src/aiogram_webhook/gate.py

@@ -0,0 +1,48 @@
+import asyncio
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from aiogram_webhook.engines.errors import RequestHandlingStoppedError
+from aiogram_webhook.logs import get_logger
+
+logger = get_logger("gate")
+
+
+class RequestGate:
+    """Admit requests while open; on close, reject new ones and wait for those already inside."""
+
+    def __init__(self) -> None:
+        self._closed = False
+        self._active = 0
+        self._idle = asyncio.Event()
+        self._idle.set()
+
+    def ensure_open(self) -> None:
+        if self._closed:
+            raise RequestHandlingStoppedError
+
+    @contextmanager
+    def enter(self) -> Generator[None]:
+        self.ensure_open()
+        self._active += 1
+        self._idle.clear()
+        try:
+            yield
+        finally:
+            self._active -= 1
+            if not self._active:
+                self._idle.set()
+
+    def open(self) -> None:
+        self._closed = False
+
+    async def close(self, timeout: float | None = None) -> bool:
+        self._closed = True
+        if self._active:
+            logger.info("Waiting for %s in-flight request(s) to finish", self._active)
+        try:
+            await asyncio.wait_for(self._idle.wait(), timeout)
+        except asyncio.TimeoutError:
+            logger.warning("Timeout reached. %s request(s) still in flight.", self._active)
+            return False
+        return True

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/route/route.py

@@ -62,7 +62,7 @@ class Route:
 
     async def build_url(self, target: Target) -> str:
         if self._path_params:
-            route_params = {}
+            route_params: dict[str, Any] = {}
             for binding in self._path_params:
                 route_params[binding.name] = await binding.param.build(target=target, params=route_params)
 

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/security/checks/check.py

@@ -1,4 +1,4 @@
-from typing import Protocol
+from typing import Any, Protocol
 
 from aiogram_webhook.engines.target import Target
 from aiogram_webhook.route.params import RouteParams
@@ -8,7 +8,7 @@ from aiogram_webhook.web.base import WebRequest
 class SecurityCheck(Protocol):
     """Protocol for security check on webhook requests."""
 
-    async def verify(self, target: Target, request: WebRequest, route_params: RouteParams) -> bool:
+    async def verify(self, target: Target, request: WebRequest[Any], route_params: RouteParams) -> bool:
         """
         Perform a security check on the incoming webhook request.
 

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/security/secret_token.py

@@ -1,7 +1,7 @@
 import re
 from abc import ABC, abstractmethod
 from hmac import compare_digest
-from typing import Final
+from typing import Any, Final
 
 from aiogram_webhook.engines.target import Target
 from aiogram_webhook.route.params import RouteParams
@@ -16,7 +16,7 @@ class SecretToken(ABC):
     Base class for secret token verification in webhook requests.
     """
 
-    async def verify(self, target: Target, request: WebRequest, route_params: RouteParams) -> bool:  # noqa: ARG002
+    async def verify(self, target: Target, request: WebRequest[Any], route_params: RouteParams) -> bool:  # noqa: ARG002
         """
         Verify the incoming secret token from the request.
 
@@ -26,9 +26,10 @@ class SecretToken(ABC):
         :return: True if the token is valid, False otherwise.
         """
         incoming_secret_token = request.headers.get(SECRET_TOKEN_HEADER)
-        if incoming_secret_token is None:
+        if incoming_secret_token is None or not incoming_secret_token.isascii():
             return False
-        return compare_digest(incoming_secret_token, await self.secret_token(target=target))
+        expected = await self.secret_token(target=target)
+        return compare_digest(incoming_secret_token.encode(), expected.encode())
 
     @abstractmethod
     async def secret_token(self, target: Target) -> str:

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/security/security.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from aiogram_webhook.engines.target import Target
 from aiogram_webhook.route.params import RouteParams
 from aiogram_webhook.security.checks.check import SecurityCheck
@@ -11,7 +13,7 @@ class Security:
         self._secret_token = secret_token
         self._checks: tuple[SecurityCheck, ...] = checks
 
-    async def verify(self, *, target: Target, request: WebRequest, route_params: RouteParams) -> None:
+    async def verify(self, *, target: Target, request: WebRequest[Any], route_params: RouteParams) -> None:
         if self._secret_token is not None:
             ok = await self._secret_token.verify(target=target, request=request, route_params=route_params)
             if not ok:
@@ -22,7 +24,7 @@ class Security:
             if not ok:
                 raise SecurityCheckError(
                     security_check=check.__class__.__name__,
-                    client_ip=str(request.client_ip) if request.client_ip is not None else None,
+                    client_ip=request.client_ip if request.client_ip is not None else None,
                 )
 
     async def secret_token(self, target: Target) -> str | None:

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/tasks.py

@@ -15,9 +15,9 @@ class TaskTracker:
 
     def spawn(self, coro: Coroutine[Any, Any, TaskResultT]) -> asyncio.Task[TaskResultT]:
         """
-        Starts a coroutine in the background and tracks it.
+        Start a coroutine in the background and track it.
 
-        :param coro: Coroutine to be executed.
+        :param coro: Coroutine to execute.
         :return: The created asyncio Task.
         """
         task = asyncio.create_task(coro)
@@ -26,8 +26,8 @@ class TaskTracker:
         task.add_done_callback(self._on_task_done)
         return task
 
-    def _on_task_done(self, task: asyncio.Task) -> None:
-        """Callback to remove the task from the set and log unhandled exceptions."""
+    def _on_task_done(self, task: asyncio.Task[Any]) -> None:
+        """Remove the task from the set and log unhandled exceptions."""
         self._tasks.discard(task)
 
         if not task.cancelled():
@@ -39,8 +39,9 @@ class TaskTracker:
 
     async def close(self, timeout: float | None = 10.0) -> None:
         """
-        Gracefully waits for all tracked tasks to complete.
-        Cancels remaining tasks if the timeout is reached.
+        Gracefully wait for all tracked tasks to complete.
+
+        Cancel remaining tasks if the timeout is reached.
 
         :param timeout: Maximum time (in seconds) to wait before canceling.
         """

aiogram_webhook-3.2.0/src/aiogram_webhook/utils/_payload.py

@@ -0,0 +1,49 @@
+import secrets
+from typing import TYPE_CHECKING, Any
+
+from aiogram import Bot
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import TelegramType
+from aiohttp import MultipartWriter
+
+if TYPE_CHECKING:
+    from aiogram.types import InputFile
+
+
+def prepare_webhook_reply(
+    bot: Bot, method: TelegramMethod[TelegramType]
+) -> tuple[dict[str, Any], dict[str, "InputFile"]]:
+    """Convert a TelegramMethod to webhook reply fields with JSON-native values."""
+
+    files: dict[str, InputFile] = {}
+    data: dict[str, Any] = {"method": method.__api_method__}
+    for key, value in method.model_dump(exclude_none=True, warnings=False).items():
+        prepared_value = bot.session.prepare_value(value, bot=bot, files=files, _dumps_json=False)
+        if prepared_value is None:
+            continue
+        data[key] = prepared_value
+
+    return data, files
+
+
+def build_multipart_payload(bot: Bot, data: dict[str, Any], files: dict[str, "InputFile"]) -> MultipartWriter:
+    """Build a multipart/form-data webhook reply: `data` fields plus attached `files`."""
+    writer = MultipartWriter(
+        "form-data",
+        boundary=f"webhookBoundary{secrets.token_urlsafe(16)}",
+    )
+
+    for key, value in data.items():
+        # multipart fields are strings: same as prepare_value(..., _dumps_json=True) at the top level
+        payload = writer.append(value if isinstance(value, str) else bot.session.json_dumps(value))
+        payload.set_content_disposition("form-data", name=key)
+
+    for key, value in files.items():
+        file_payload = value.read(bot)
+        payload = writer.append(file_payload)
+        # quote_fields=False keeps non-ASCII filenames as raw UTF-8 instead of percent-encoding them.
+        # "All queries must be made using UTF-8" — https://core.telegram.org/bots/api#making-requests
+        # Matches aiogram's FormData(quote_fields=False).
+        payload.set_content_disposition("form-data", quote_fields=False, name=key, filename=value.filename or key)
+
+    return writer

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/web/aiohttp.py

@@ -35,7 +35,7 @@ class AiohttpWebRequest(WebRequest[Request]):
             return None
 
         if peer_name := transport.get_extra_info("peername"):
-            return peer_name[0]
+            return str(peer_name[0])
         return None
 
     async def json(self) -> dict[str, Any]:
@@ -77,7 +77,7 @@ class AiohttpAdapter(WebAdapter[Application, Request, Response]):
         app.on_shutdown.append(on_shutdown)
 
     def json_response(
-        self, status_code: int, data: dict[str, str] | None = None, headers: Mapping[str, str] | None = None
+        self, status_code: int, data: dict[str, Any] | None = None, headers: Mapping[str, str] | None = None
     ) -> Response:
         return json_response(status=status_code, data=data, headers=headers)
 

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/web/base.py

@@ -6,6 +6,7 @@ from aiohttp.payload import Payload
 from multidict import CIMultiDictProxy, MultiMapping
 
 AppT = TypeVar("AppT")
+RawRequestT_co = TypeVar("RawRequestT_co", covariant=True)
 RawRequestT = TypeVar("RawRequestT")
 FrameworkResponseT = TypeVar("FrameworkResponseT")
 
@@ -17,11 +18,11 @@ QueryParams = MultiMapping[str]
 PathParams = Mapping[str, str]
 
 
-class WebRequest(Protocol[RawRequestT]):
+class WebRequest(Protocol[RawRequestT_co]):
     """Framework request behavior required by the web engine."""
 
     @property
-    def raw(self) -> RawRequestT:
+    def raw(self) -> RawRequestT_co:
         """Return the original framework request."""
         ...
 
@@ -40,7 +41,7 @@ class WebRequest(Protocol[RawRequestT]):
     def path_params(self) -> PathParams: ...
 
 
-WebHandler: TypeAlias = Callable[[WebRequest[RawRequestT]], Awaitable[FrameworkResponseT]]
+WebHandler: TypeAlias = Callable[[WebRequest[RawRequestT_co]], Awaitable[FrameworkResponseT]]
 
 
 class WebAdapter(ABC, Generic[AppT, RawRequestT, FrameworkResponseT]):
@@ -66,7 +67,7 @@ class WebAdapter(ABC, Generic[AppT, RawRequestT, FrameworkResponseT]):
 
     @abstractmethod
     def json_response(
-        self, status_code: int, data: dict[str, str] | None = None, headers: Mapping[str, str] | None = None
+        self, status_code: int, data: dict[str, Any] | None = None, headers: Mapping[str, str] | None = None
     ) -> FrameworkResponseT:
         """Create a JSON response for the framework."""
         raise NotImplementedError

{aiogram_webhook-3.1.0 → aiogram_webhook-3.2.0}/src/aiogram_webhook/web/fastapi.py

@@ -1,4 +1,4 @@
-from collections.abc import Mapping
+from collections.abc import AsyncGenerator, Mapping
 from contextlib import asynccontextmanager
 from typing import Any
 
@@ -72,7 +72,7 @@ class FastAPIAdapter(WebAdapter[FastAPI, Request, Response]):
             return await handler(self.bind_request(request))
 
         @asynccontextmanager
-        async def lifespan(_router: APIRouter):
+        async def lifespan(_router: APIRouter) -> AsyncGenerator[None, None]:
             try:
                 await on_startup(app)
                 yield
@@ -84,7 +84,7 @@ class FastAPIAdapter(WebAdapter[FastAPI, Request, Response]):
         app.include_router(router)
 
     def json_response(
-        self, status_code: int, data: dict[str, str] | None = None, headers: Mapping[str, str] | None = None
+        self, status_code: int, data: dict[str, Any] | None = None, headers: Mapping[str, str] | None = None
     ) -> Response:
         return JSONResponse(status_code=status_code, content=data, headers=headers)
 

aiogram_webhook-3.1.0/src/aiogram_webhook/utils/_payload.py

@@ -1,36 +0,0 @@
-import secrets
-from typing import TYPE_CHECKING
-
-from aiogram import Bot
-from aiogram.methods import TelegramMethod
-from aiogram.methods.base import TelegramType
-from aiohttp import MultipartWriter
-
-if TYPE_CHECKING:
-    from aiogram.types import InputFile
-
-
-def build_webhook_payload(bot: Bot, method: TelegramMethod[TelegramType]) -> MultipartWriter:
-    """Convert a TelegramMethod to multipart payload."""
-    writer = MultipartWriter(
-        "form-data",
-        boundary=f"webhookBoundary{secrets.token_urlsafe(16)}",
-    )
-
-    payload = writer.append(method.__api_method__)
-    payload.set_content_disposition("form-data", name="method")
-
-    files: dict[str, InputFile] = {}
-    for key, value in method.model_dump(warnings=False).items():
-        prepared_value = bot.session.prepare_value(value, bot=bot, files=files)
-        if prepared_value is None:
-            continue
-        payload = writer.append(prepared_value)
-        payload.set_content_disposition("form-data", name=key)
-
-    for key, value in files.items():
-        file_payload = value.read(bot)
-        payload = writer.append(file_payload)
-        payload.set_content_disposition("form-data", name=key, filename=value.filename or key)
-
-    return writer