aiogram-webhook 2.0.1__tar.gz → 3.0.1__tar.gz

aiogram_webhook-3.0.1/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.3
+Name: aiogram-webhook
+Version: 3.0.1
+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
+Author-email: m-xim <i@m-xim.ru>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Dist: aiogram>=3.14.0
+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
+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
+
+![PyPI version](docs/_assets/brand/banner.png)
+
+# aiogram-webhook
+[![PyPI version](https://img.shields.io/pypi/v/aiogram-webhook?color=blue)](https://pypi.org/project/aiogram-webhook)
+[![codecov](https://codecov.io/github/m-xim/aiogram-webhook/graph/badge.svg?token=H21MX17Y7D)](https://codecov.io/github/m-xim/aiogram-webhook)
+[![Tests Status](https://github.com/m-xim/aiogram-webhook/actions/workflows/tests.yml/badge.svg)](https://github.com/m-xim/aiogram-webhook/actions)
+[![License](https://img.shields.io/github/license/m-xim/aiogram-webhook.svg)](/LICENSE)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/m-xim/aiogram-webhook)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
+
+`aiogram-webhook` is a modular Python library for webhook integration in aiogram.
+It supports single-bot and token-based multi-bot setups, with route building, optional request checks, and adapters for FastAPI and aiohttp.
+
+## Install
+
+```bash
+pip install aiogram-webhook
+pip install "aiogram-webhook[fastapi]"
+pip install "aiogram-webhook[aiohttp]"
+```
+
+## Quick Start
+
+```python
+from aiogram import Bot, Dispatcher
+from fastapi import FastAPI
+
+from aiogram_webhook import FastAPIAdapter, SingleBotEngine
+from aiogram_webhook.route import Route
+
+dispatcher = Dispatcher()
+bot = Bot("BOT_TOKEN")
+
+engine = SingleBotEngine(
+    dispatcher,
+    bot,
+    web=FastAPIAdapter(),
+    route=Route(base_url="https://example.com", path="/webhook"),
+)
+
+app = FastAPI()
+engine.register(app)
+```
+
+Call `await engine.set_webhook()` during your application startup to register the public webhook URL in Telegram.
+For production, pass `security=Security(...)` to verify Telegram requests.
+
+## Documentation
+
+The full documentation is in [`docs`](https://aiogram-webhook.m-xim.ru). It covers installation, FastAPI and aiohttp setup, routing, security, lifecycle behavior, and the public API.
+
+## Contributing
+
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for development setup, branch naming, commit conventions, and PR guidelines.

aiogram_webhook-3.0.1/README.md

@@ -0,0 +1,55 @@
+![PyPI version](docs/_assets/brand/banner.png)
+
+# aiogram-webhook
+[![PyPI version](https://img.shields.io/pypi/v/aiogram-webhook?color=blue)](https://pypi.org/project/aiogram-webhook)
+[![codecov](https://codecov.io/github/m-xim/aiogram-webhook/graph/badge.svg?token=H21MX17Y7D)](https://codecov.io/github/m-xim/aiogram-webhook)
+[![Tests Status](https://github.com/m-xim/aiogram-webhook/actions/workflows/tests.yml/badge.svg)](https://github.com/m-xim/aiogram-webhook/actions)
+[![License](https://img.shields.io/github/license/m-xim/aiogram-webhook.svg)](/LICENSE)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/m-xim/aiogram-webhook)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
+
+`aiogram-webhook` is a modular Python library for webhook integration in aiogram.
+It supports single-bot and token-based multi-bot setups, with route building, optional request checks, and adapters for FastAPI and aiohttp.
+
+## Install
+
+```bash
+pip install aiogram-webhook
+pip install "aiogram-webhook[fastapi]"
+pip install "aiogram-webhook[aiohttp]"
+```
+
+## Quick Start
+
+```python
+from aiogram import Bot, Dispatcher
+from fastapi import FastAPI
+
+from aiogram_webhook import FastAPIAdapter, SingleBotEngine
+from aiogram_webhook.route import Route
+
+dispatcher = Dispatcher()
+bot = Bot("BOT_TOKEN")
+
+engine = SingleBotEngine(
+    dispatcher,
+    bot,
+    web=FastAPIAdapter(),
+    route=Route(base_url="https://example.com", path="/webhook"),
+)
+
+app = FastAPI()
+engine.register(app)
+```
+
+Call `await engine.set_webhook()` during your application startup to register the public webhook URL in Telegram.
+For production, pass `security=Security(...)` to verify Telegram requests.
+
+## Documentation
+
+The full documentation is in [`docs`](https://aiogram-webhook.m-xim.ru). It covers installation, FastAPI and aiohttp setup, routing, security, lifecycle behavior, and the public API.
+
+## Contributing
+
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for development setup, branch naming, commit conventions, and PR guidelines.

{aiogram_webhook-2.0.1 → aiogram_webhook-3.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aiogram-webhook"
-version = "2.0.1"
+version = "3.0.1"
 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" }
@@ -9,15 +9,17 @@ 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",
-    "multibot",
 ]
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -28,13 +30,14 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: Libraries",
     "Operating System :: OS Independent",
+    "Typing :: Typed",
 ]
 
 [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://github.com/m-xim/aiogram-webhook#readme"
+Documentation = "https://aiogram-webhook.m-xim.ru"
 
 [project.optional-dependencies]
 fastapi = [
@@ -48,17 +51,17 @@ dev = [
     "ty",
     "pytest",
     "pytest-asyncio",
-    "httpx"
+    "pytest-cov",
+    "httpx2",
 ]
 
 [build-system]
-requires = ["uv_build"]
+requires = ["uv_build<0.12"]
 build-backend = "uv_build"
 
 [tool.uv]
 package = true
 
-
 [tool.semantic_release]
 version_source = "pyproject"
 commit_message = "chore(release): {version}"

aiogram_webhook-3.0.1/src/aiogram_webhook/__init__.py

@@ -0,0 +1,16 @@
+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.web.aiohttp import AiohttpAdapter
+
+__all__ = ["AiohttpAdapter", "BotConfig", "SingleBotEngine", "TokenEngine", "WebhookConfig"]
+
+
+try:
+    from aiogram_webhook.web.fastapi import FastAPIAdapter  # noqa: F401
+
+    __all__.insert(2, "FastAPIAdapter")
+except ModuleNotFoundError as exc:
+    if exc.name != "fastapi":
+        raise

{aiogram_webhook-2.0.1/src/aiogram_webhook/config → aiogram_webhook-3.0.1/src/aiogram_webhook/configs}/bot.py

@@ -4,7 +4,7 @@ from aiogram.client.default import DefaultBotProperties
 from aiogram.client.session.base import BaseSession
 
 
-@dataclass
+@dataclass(slots=True)
 class BotConfig:
     session: BaseSession | None = None
     """HTTP Client session (For example AiohttpSession). If not specified it will be automatically created."""

{aiogram_webhook-2.0.1/src/aiogram_webhook/config → aiogram_webhook-3.0.1/src/aiogram_webhook/configs}/webhook.py

@@ -1,19 +1,21 @@
+from dataclasses import dataclass
+
 from aiogram.types import InputFile
-from pydantic import BaseModel, ConfigDict, Field
 
+from aiogram_webhook.utils.config import OMITTED, Omittable
 
-class WebhookConfig(BaseModel):
-    """Webhook configuration for setWebhook API parameters."""
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+@dataclass(frozen=True, slots=True)
+class WebhookConfig:
+    """Webhook configuration for setWebhook API parameters."""
 
-    certificate: InputFile | None = None
+    certificate: Omittable[InputFile | None] = OMITTED
     """Upload your public key certificate so that the root certificate in use can be checked. See our `self-signed guide <https://core.telegram.org/bots/self-signed>`_ for details."""
-    ip_address: str | None = None
+    ip_address: Omittable[str | None] = OMITTED
     """The fixed IP address which will be used to send webhook requests instead of the IP address resolved through DNS"""
-    max_connections: int | None = Field(default=None, ge=1, le=100)
+    max_connections: Omittable[int | None] = OMITTED
     """The maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to *40*. Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput."""
-    allowed_updates: list[str] | None = None
+    allowed_updates: Omittable[list[str] | None] = OMITTED
     """A JSON-serialized list of the update types you want your bot to receive. For example, specify :code:`["message", "edited_channel_post", "callback_query"]` to only receive updates of these types. See :class:`aiogram.types.update.Update` for a complete list of available update types. Specify an empty list to receive all update types except *chat_member*, *message_reaction*, and *message_reaction_count* (default). If not specified, the previous setting will be used."""
-    drop_pending_updates: bool | None = None
+    drop_pending_updates: Omittable[bool | None] = OMITTED
     """Pass :code:`True` to drop all pending updates"""

aiogram_webhook-3.0.1/src/aiogram_webhook/engines/base.py

@@ -0,0 +1,153 @@
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any, Generic, TypeVar
+
+from aiogram import Bot, Dispatcher
+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.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.web.base import WebAdapter, WebRequest
+
+logger = get_logger("engines")
+
+AppT = TypeVar("AppT")
+RawRequestT = TypeVar("RawRequestT")
+FrameworkResponseT = TypeVar("FrameworkResponseT")
+
+
+class BaseWebhookEngine(ABC, Generic[AppT, RawRequestT, FrameworkResponseT]):
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        web: WebAdapter[AppT, RawRequestT, FrameworkResponseT],
+        route: Route,
+        security: Security | None = None,
+        handle_in_background: bool = True,
+        shutdown_timeout: float = 10.0,
+    ) -> None:
+        self.dispatcher = dispatcher
+        self.web = web
+        self.route = route
+        self.security = security
+        self.handle_in_background = handle_in_background
+
+        self.shutdown_timeout = shutdown_timeout
+        self._is_shutting_down = False
+
+        if self.security is None:
+            warnings.warn(
+                f"Security is not configured for {type(self).__name__}. Pass security=... to verify webhook requests.",
+                UserWarning,
+                stacklevel=2,
+            )
+
+    def register(self, app: AppT) -> None:
+        logger.info("Registering webhook path %s via %s", self.route.path, self.web.__class__.__name__)
+        self.web.register(
+            app=app,
+            path=self.route.path,
+            handler=self.handle_request,
+            on_startup=self.on_startup,
+            on_shutdown=self.on_shutdown,
+        )
+
+    async def handle_request(self, request: WebRequest[RawRequestT]) -> FrameworkResponseT:
+        try:
+            if self._is_shutting_down:
+                raise RequestHandlingStoppedError
+
+            route_params = await self.route.match(request)
+
+            target = await self._resolve_target(request=request, route_params=route_params)
+            if target is None:
+                raise TargetNotFoundError(route_param_names=route_params.keys())
+
+            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={})
+
+        except AiogramWebhookError as exc:
+            log_webhook_error(logger, exc)
+
+            return self.web.json_response(status_code=exc.status_code, data=exc.response_payload())
+
+    async def on_startup(self, app: AppT, *args: Any, **kwargs: Any) -> None:
+        await self._on_startup(app, *args, **kwargs)
+        self._is_shutting_down = False
+
+    async def on_shutdown(self, app: AppT, *args: Any, **kwargs: Any) -> None:
+        self._is_shutting_down = True
+        await self._on_shutdown(app, *args, **kwargs)
+
+    @asynccontextmanager
+    async def lifespan(self, app: AppT) -> AsyncGenerator[None, Any]:
+        try:
+            await self.on_startup(app=app)
+            yield
+        finally:
+            await self.on_shutdown(app=app)
+
+    @abstractmethod
+    async def _on_startup(self, app: AppT, *args: Any, **kwargs: Any) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def _on_shutdown(self, app: AppT, *args: Any, **kwargs: Any) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def _resolve_target(self, request: WebRequest[RawRequestT], route_params: RouteParams) -> Target | None: ...
+
+    @abstractmethod
+    async def _resolve_bot(self, target: Target) -> Bot | None: ...
+
+    @abstractmethod
+    def _get_task_tracker(self, bot: Bot) -> TaskTracker:
+        raise NotImplementedError
+
+    async def _background_feed(self, bot: Bot, update: dict[str, Any]) -> None:
+        result = await self.dispatcher.feed_raw_update(bot=bot, update=update)
+
+        if isinstance(result, TelegramMethod):
+            await self.dispatcher.silent_call_request(bot=bot, result=result)
+
+    def _build_lifecycle_data(self, *, app: AppT, **kwargs) -> dict[str, Any]:
+        return {
+            "dispatcher": self.dispatcher,
+            **self.dispatcher.workflow_data,
+            "app": app,
+            "webhook_engine": self,
+            **kwargs,
+        }

aiogram_webhook-3.0.1/src/aiogram_webhook/engines/errors.py

@@ -0,0 +1,77 @@
+import logging
+from collections.abc import Iterable
+
+from aiogram_webhook.errors import AiogramWebhookError
+
+
+def format_names(names: Iterable[str]) -> str:
+    return ", ".join(repr(name) for name in sorted(names))
+
+
+class EngineError(AiogramWebhookError):
+    code = "engine_error"
+
+
+class TargetNotFoundError(EngineError):
+    code = "engine_target_not_found"
+    status_code = 404
+    public_detail = "Not found"
+    log_level = logging.INFO
+
+    def __init__(self, *, route_param_names: Iterable[str]) -> None:
+        self.route_param_names = tuple(sorted(route_param_names))
+
+        super().__init__(f"Webhook target was not found. Route param names: {format_names(self.route_param_names)}.")
+
+
+class BotNotFoundError(EngineError):
+    code = "engine_bot_not_found"
+    status_code = 404
+    public_detail = "Not found"
+    log_level = logging.ERROR
+
+    def __init__(
+        self,
+        *,
+        target_bot_id: int | None = None,
+        target_type: str | None = None,
+    ) -> None:
+        self.target_bot_id = target_bot_id
+        self.target_type = target_type
+
+        message = "Webhook bot was not found."
+
+        if target_bot_id is not None:
+            message += f" Target bot id: {target_bot_id}."
+
+        if target_type is not None:
+            message += f" Target type: {target_type!r}."
+
+        super().__init__(message)
+
+
+class InvalidJsonError(EngineError):
+    code = "engine_invalid_json"
+    status_code = 400
+    public_detail = "Bad request"
+    log_level = logging.ERROR
+
+    def __init__(self, *, original_error: BaseException | None = None) -> None:
+        self.original_error_type = type(original_error).__name__ if original_error is not None else None
+
+        message = "Invalid webhook JSON payload."
+
+        if self.original_error_type is not None:
+            message += f" Original error type: {self.original_error_type}."
+
+        super().__init__(message)
+
+
+class RequestHandlingStoppedError(EngineError):
+    code = "engine_request_handling_stopped"
+    status_code = 503
+    public_detail = "Service unavailable"
+    log_level = logging.DEBUG
+
+    def __init__(self) -> None:
+        super().__init__("Webhook engine is shutting down and no longer accepts requests.")

aiogram_webhook-3.0.1/src/aiogram_webhook/engines/multi.py

@@ -0,0 +1,74 @@
+from abc import ABC
+from collections.abc import Iterable, Mapping
+from types import MappingProxyType
+from typing import Any, Generic
+
+from aiogram import Bot
+
+from aiogram_webhook import WebhookConfig
+from aiogram_webhook.engines.base import AppT, BaseWebhookEngine, FrameworkResponseT, RawRequestT, logger
+from aiogram_webhook.engines.target import Target
+from aiogram_webhook.route import Route
+from aiogram_webhook.security import Security
+from aiogram_webhook.tasks import TaskTracker
+from aiogram_webhook.utils.config import dataclass_config_to_kwargs
+from aiogram_webhook.web.base import WebAdapter
+
+
+class BaseMultiBotEngine(
+    BaseWebhookEngine[AppT, RawRequestT, FrameworkResponseT], ABC, Generic[AppT, RawRequestT, FrameworkResponseT]
+):
+    def __init__(
+        self,
+        dispatcher,
+        web: WebAdapter[AppT, RawRequestT, FrameworkResponseT],
+        route: Route,
+        security: Security | None = None,
+        webhook_config: WebhookConfig | None = None,
+        handle_in_background: bool = True,
+        shutdown_timeout: float = 10.0,
+    ) -> None:
+        self._task_trackers: dict[int, TaskTracker] = {}
+        self._bots: dict[int, Bot] = {}
+        self.webhook_config = webhook_config or WebhookConfig()
+        super().__init__(
+            dispatcher=dispatcher,
+            web=web,
+            route=route,
+            security=security,
+            handle_in_background=handle_in_background,
+            shutdown_timeout=shutdown_timeout,
+        )
+
+    async def _build_webhook_kwargs(
+        self, target: Target, webhook_config: WebhookConfig | None = None
+    ) -> dict[str, Any]:
+        kwargs = dataclass_config_to_kwargs(self.webhook_config, webhook_config)
+        if self.security is not None:
+            secret_token = await self.security.secret_token(target)
+            if secret_token is not None:
+                kwargs["secret_token"] = secret_token
+        return kwargs
+
+    @property
+    def bots(self) -> Mapping[int, Bot]:
+        return MappingProxyType(self._bots)
+
+    async def _on_startup(self, app: AppT, *args: Any, bots: Iterable[Bot] | None = None, **kwargs: Any) -> None:  # noqa: ARG002
+        all_bots = set(self.bots.values())
+
+        if bots is not None:
+            all_bots |= set(bots)
+
+        logger.info("Starting multi-bot webhook engine with %s bot(s)", len(all_bots))
+        lifecycle_data = self._build_lifecycle_data(app=app, bots=all_bots, **kwargs)
+        await self.dispatcher.emit_startup(**lifecycle_data)
+
+    def _get_task_tracker(self, bot: Bot) -> TaskTracker:
+        tracker = self._task_trackers.get(bot.id)
+
+        if tracker is None:
+            tracker = TaskTracker()
+            self._task_trackers[bot.id] = tracker
+
+        return tracker

aiogram_webhook-3.0.1/src/aiogram_webhook/engines/single.py

@@ -0,0 +1,71 @@
+from typing import Generic
+
+from aiogram import Bot
+
+from aiogram_webhook.configs.webhook import WebhookConfig
+from aiogram_webhook.engines.base import AppT, BaseWebhookEngine, FrameworkResponseT, RawRequestT, logger
+from aiogram_webhook.engines.target import Target
+from aiogram_webhook.route import Route
+from aiogram_webhook.route.params import RouteParams
+from aiogram_webhook.tasks import TaskTracker
+from aiogram_webhook.utils.config import dataclass_config_to_kwargs
+from aiogram_webhook.web.base import WebAdapter, WebRequest
+
+
+class SingleBotEngine(
+    BaseWebhookEngine[AppT, RawRequestT, FrameworkResponseT], Generic[AppT, RawRequestT, FrameworkResponseT]
+):
+    def __init__(
+        self,
+        dispatcher,
+        bot: Bot,
+        web: WebAdapter[AppT, RawRequestT, FrameworkResponseT],
+        route: Route,
+        security=None,
+        handle_in_background: bool = True,
+        shutdown_timeout: float = 10.0,
+    ) -> None:
+        self.bot = bot
+        self._task_tracker = TaskTracker()
+
+        super().__init__(
+            dispatcher=dispatcher,
+            web=web,
+            route=route,
+            security=security,
+            handle_in_background=handle_in_background,
+            shutdown_timeout=shutdown_timeout,
+        )
+
+    async def _resolve_target(self, request: WebRequest[RawRequestT], route_params: RouteParams) -> Target | None:  # noqa: ARG002
+        return Target(bot_id=self.bot.id, bot_token=self.bot.token)
+
+    async def _resolve_bot(self, target: Target) -> Bot:  # noqa: ARG002
+        return self.bot
+
+    def _get_task_tracker(self, bot: Bot) -> TaskTracker:  # noqa: ARG002
+        return self._task_tracker
+
+    async def set_webhook(self, webhook_config: WebhookConfig | None = None) -> bool:
+        target = Target(bot_id=self.bot.id, bot_token=self.bot.token)
+        kwargs = dataclass_config_to_kwargs(webhook_config or WebhookConfig())
+        if self.security is not None:
+            secret_token = await self.security.secret_token(target)
+            if secret_token is not None:
+                kwargs["secret_token"] = secret_token
+        return await self.bot.set_webhook(url=await self.route.build_url(target=target), **kwargs)
+
+    async def _on_startup(self, app: AppT, *args, **kwargs) -> None:  # noqa: ARG002
+        logger.info("Starting single-bot webhook engine for bot %s", self.bot.id)
+        lifecycle_data = self._build_lifecycle_data(app=app, bot=self.bot, **kwargs)
+        await self.dispatcher.emit_startup(**lifecycle_data)
+
+    async def _on_shutdown(self, app: AppT, *args, **kwargs) -> None:  # noqa: ARG002
+        logger.info("Stopping single-bot webhook engine for bot %s", self.bot.id)
+        await self._task_tracker.close(timeout=self.shutdown_timeout)
+
+        lifecycle_data = self._build_lifecycle_data(app=app, bot=self.bot, **kwargs)
+        await self.dispatcher.emit_shutdown(**lifecycle_data)
+
+        if self.bot.session is not None:
+            await self.bot.session.close()

aiogram_webhook-3.0.1/src/aiogram_webhook/engines/target.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class Target:
+    bot_id: int
+    bot_token: str