aiogram-webhook 0.0.1__py3-none-any.whl

aiogram_webhook/__init__.py

@@ -0,0 +1,12 @@
+from aiogram_webhook.adapters.base import WebAdapter
+from aiogram_webhook.engines.simple import SimpleEngine
+from aiogram_webhook.engines.token import TokenEngine
+
+__all__ = ["SimpleEngine", "TokenEngine", "WebAdapter"]
+
+try:
+    from aiogram_webhook.adapters.fastapi import FastApiWebAdapter  # noqa: F401
+
+    __all__.insert(0, "FastApiWebAdapter")
+except ImportError:
+    pass

aiogram_webhook/adapters/base.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from ipaddress import IPv4Address, IPv6Address
+
+
+@dataclass(slots=True)
+class BoundRequest(ABC):
+    """
+    Abstract base class for a request bound to a web adapter.
+
+    Provides interface for extracting data from incoming requests and generating responses.
+    """
+
+    request: Any
+    adapter: WebAdapter
+
+    @abstractmethod
+    async def json(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def header(self, name: str) -> Any | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def query_param(self, name: str) -> Any | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def path_param(self, name: str) -> Any | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def ip(self) -> IPv4Address | IPv6Address | str | None:
+        raise NotImplementedError
+
+    def secret_token(self) -> str | None:
+        return self.header(self.adapter.secret_header)
+
+    @abstractmethod
+    def json_response(self, status: int, payload: dict[str, Any]) -> Any:
+        raise NotImplementedError
+
+
+@dataclass
+class WebAdapter(ABC):
+    """
+    Abstract base class for web framework adapters.
+
+    Provides interface for binding requests and registering webhook handlers.
+    """
+
+    secret_header: str = "x-telegram-bot-api-secret-token"  # noqa: S105
+
+    @abstractmethod
+    def bind(self, request: Any) -> BoundRequest:
+        raise NotImplementedError
+
+    @abstractmethod
+    def register(self, app: Any, path: str, handler: Callable[[BoundRequest], Awaitable[Any]]) -> None:
+        raise NotImplementedError

aiogram_webhook/adapters/fastapi.py

@@ -0,0 +1,41 @@
+from collections.abc import Awaitable, Callable
+from ipaddress import IPv4Address, IPv6Address
+from typing import Any
+
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+from aiogram_webhook.adapters.base import BoundRequest, WebAdapter
+
+
+class FastAPIBoundRequest(BoundRequest):
+    request: Request
+
+    async def json(self) -> dict[str, Any]:
+        return await self.request.json()
+
+    def header(self, name: str) -> Any | None:
+        return self.request.headers.get(name)
+
+    def query_param(self, name: str) -> Any | None:
+        return self.request.query_params.get(name)
+
+    def path_param(self, name: str) -> Any | None:
+        return self.request.path_params.get(name)
+
+    def ip(self) -> IPv4Address | IPv6Address | str | None:
+        return self.request.client.host if self.request.client else None
+
+    def json_response(self, status: int, payload: dict[str, Any]) -> JSONResponse:
+        return JSONResponse(status_code=status, content=payload)
+
+
+class FastApiWebAdapter(WebAdapter):
+    def bind(self, request: Request) -> BoundRequest:
+        return FastAPIBoundRequest(adapter=self, request=request)
+
+    def register(self, app: Any, path: str, handler: Callable[[BoundRequest], Awaitable[Any]]) -> None:
+        async def endpoint(request: Request):
+            return await handler(self.bind(request))
+
+        app.add_api_route(path, endpoint, methods=["POST"])

aiogram_webhook/engines/__init__.py

@@ -0,0 +1,5 @@
+from aiogram_webhook.engines.base import WebhookEngine
+from aiogram_webhook.engines.simple import SimpleEngine
+from aiogram_webhook.engines.token import TokenEngine
+
+__all__ = ("SimpleEngine", "TokenEngine", "WebhookEngine")

aiogram_webhook/engines/base.py

@@ -0,0 +1,129 @@
+import asyncio
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+
+from aiogram import Bot, Dispatcher
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import TelegramType
+
+from aiogram_webhook.adapters.base import BoundRequest, WebAdapter
+from aiogram_webhook.routing.base import BaseRouting
+from aiogram_webhook.security.checks.ip import IPCheck
+from aiogram_webhook.security.security import Security
+
+if TYPE_CHECKING:
+    from aiogram.types import InputFile
+
+
+class WebhookEngine(ABC):
+    """
+    Base webhook engine for processing Telegram bot updates.
+
+    Handles incoming webhook requests, bot resolution, security checks,
+    routing, and dispatching updates to the aiogram dispatcher. Supports
+    both synchronous and background processing.
+
+    Constructor arguments:
+        dispatcher: aiogram.Dispatcher instance for update processing.
+        web_adapter: Web framework adapter class.
+        routing: Webhook routing strategy.
+        security: True — protect by IP (IPCheck), False/None — not protect, Security — custom protect.
+        handle_in_background: Whether to process updates in background (default: True).
+    """
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        /,
+        web_adapter: WebAdapter,
+        routing: BaseRouting,
+        security: Security | bool | None = None,
+        handle_in_background: bool = True,
+    ) -> None:
+        if security is True:
+            self.security = Security(IPCheck())
+        else:
+            self.security = security
+        self.dispatcher = dispatcher
+        self.web_adapter = web_adapter
+        self.routing = routing
+        self.handle_in_background = handle_in_background
+        self._background_feed_update_tasks: set[asyncio.Task[Any]] = set()
+
+    @abstractmethod
+    def resolve_bot_from_request(self, bound_request: BoundRequest) -> Bot | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def on_startup(self, bots: Iterable[Bot] | None = None, **kwargs: Any) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def on_shutdown(self) -> None:
+        raise NotImplementedError
+
+    async def handle_request(self, bound_request: BoundRequest):
+        bot = self.resolve_bot_from_request(bound_request)
+        if bot is None:
+            return bound_request.json_response(status=400, payload={"detail": "Bot not found"})
+
+        if self.security:
+            is_allowed = await self.security.verify(bot=bot, bound_request=bound_request)
+            if not is_allowed:
+                return bound_request.json_response(status=403, payload={"detail": "Forbidden"})
+
+        if self.handle_in_background:
+            return await self._handle_request_background(bot=bot, bound_request=bound_request)
+
+        return await self._handle_request(bot=bot, bound_request=bound_request)
+
+    def register(self, app: Any) -> None:
+        self.web_adapter.register(app=app, path=self.routing.path, handler=self.handle_request)
+
+    async def _handle_request(self, bot: Bot, bound_request: BoundRequest) -> dict[str, Any]:
+        result = await self.dispatcher.feed_webhook_update(bot=bot, update=await bound_request.json())
+
+        if not isinstance(result, TelegramMethod):
+            return bound_request.json_response(status=200, payload={})
+
+        if self._has_files(bot, result):
+            await self.dispatcher.silent_call_request(bot=bot, result=result)
+            return bound_request.json_response(status=200, payload={})
+
+        payload = self._to_webhook_json(bot, result)
+        return bound_request.json_response(status=200, payload=payload)
+
+    async def _background_feed_update(self, bot: Bot, update: dict[str, Any]) -> None:
+        result = await self.dispatcher.feed_raw_update(bot=bot, update=update)  # **self.data
+        if isinstance(result, TelegramMethod):
+            await self.dispatcher.silent_call_request(bot=bot, result=result)
+
+    async def _handle_request_background(self, bot: Bot, bound_request: BoundRequest):
+        feed_update_task = asyncio.create_task(
+            self._background_feed_update(
+                bot=bot,
+                update=await bound_request.json(),
+            ),
+        )
+        self._background_feed_update_tasks.add(feed_update_task)
+        feed_update_task.add_done_callback(self._background_feed_update_tasks.discard)
+
+        return bound_request.json_response(status=200, payload={})
+
+    @staticmethod
+    def _has_files(bot: Bot, method: TelegramMethod[TelegramType]) -> bool:
+        files: dict[str, InputFile] = {}
+        for v in method.model_dump(warnings=False).values():
+            bot.session.prepare_value(v, bot=bot, files=files)
+        return bool(files)
+
+    @staticmethod
+    def _to_webhook_json(bot: Bot, method: TelegramMethod[TelegramType]) -> dict[str, Any]:
+        files: dict[str, InputFile] = {}
+        params: dict[str, Any] = {}
+        for k, v in method.model_dump(warnings=False).items():
+            pv = bot.session.prepare_value(v, bot=bot, files=files)
+            if pv is not None:
+                params[k] = pv
+        return {"method": method.__api_method__, **params}

aiogram_webhook/engines/simple.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from aiogram_webhook.engines.base import WebhookEngine
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from aiogram import Bot, Dispatcher
+
+    from aiogram_webhook.adapters.base import BoundRequest, WebAdapter
+    from aiogram_webhook.routing.base import BaseRouting
+    from aiogram_webhook.security.security import Security
+
+
+class SimpleEngine(WebhookEngine):
+    """
+    Simple webhook engine for single-bot applications.
+
+    Uses a single Bot instance for all webhook requests.
+    Ideal for applications that handle only one bot.
+
+    Attributes:
+        bot: The Bot instance to use for all requests.
+    """
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        bot: Bot,
+        /,
+        web_adapter: WebAdapter,
+        routing: BaseRouting,
+        security: Security | bool | None = None,
+        handle_in_background: bool = True,
+    ) -> None:
+        """
+        Initialize the SimpleEngine for one bot.
+
+        Args:
+            dispatcher: Dispatcher instance for update processing.
+            bot: The Bot instance to use for all requests.
+            web_adapter: Web framework adapter class.
+            routing: Webhook routing strategy.
+            security: Security settings and checks.
+            handle_in_background: Whether to process updates in background.
+        """
+        self.bot = bot
+        super().__init__(
+            dispatcher,
+            web_adapter=web_adapter,
+            routing=routing,
+            security=security,
+            handle_in_background=handle_in_background,
+        )
+
+    def resolve_bot_from_request(self, bound_request: BoundRequest) -> Bot | None:  # noqa: ARG002
+        """
+        Always returns the single Bot instance for any request.
+
+        Args:
+            bound_request: The incoming bound request.
+        Returns:
+            The single Bot instance.
+        """
+        return self.bot
+
+    async def on_startup(self, bots: Iterable[Bot] | None = None, **kwargs: Any) -> None:
+        """
+        Called on application startup. Emits dispatcher startup event for all bots.
+
+        Args:
+            bots: Optional iterable of Bot instances.
+            **kwargs: Additional keyword arguments for dispatcher.
+        """
+        all_bots = set(bots) | {self.bot} if bots else {self.bot}
+        await self.dispatcher.emit_startup(
+            dispatcher=self.dispatcher,
+            bots=all_bots,
+            webhook_engine=self,
+            **kwargs,
+        )
+
+    async def on_shutdown(self) -> None:
+        """
+        Called on application shutdown. Emits dispatcher shutdown event and closes bot session.
+        """
+        await self.dispatcher.emit_shutdown(
+            dispatcher=self.dispatcher,
+            bots={self.bot},
+            webhook_engine=self,
+        )
+        await self.bot.session.close()
+
+    async def set_webhook(self, **kwargs) -> Bot:
+        """
+        Sets the webhook for the single Bot instance.
+
+        Args:
+            **kwargs: Additional arguments for set_webhook.
+        Returns:
+            The Bot instance after setting webhook.
+        """
+        await self.bot.set_webhook(url=self.routing.webhook_point(self.bot), secret_token=None, **kwargs)
+        return self.bot

aiogram_webhook/engines/token.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from aiogram import Bot, Dispatcher
+from aiogram.utils.token import extract_bot_id
+
+from aiogram_webhook.engines.base import WebhookEngine
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from aiogram_webhook.adapters.base import BoundRequest, WebAdapter
+    from aiogram_webhook.routing.base import BaseRouting
+    from aiogram_webhook.security.security import Security
+
+
+class TokenEngine(WebhookEngine):
+    """
+    Multi-bot webhook engine with dynamic bot resolution.
+
+    Resolves Bot instances from request tokens.
+    Creates and caches Bot instances on-demand. Suitable for multi-tenant applications.
+    """
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        /,
+        web_adapter: WebAdapter,
+        routing: BaseRouting,
+        security: Security | bool | None = None,
+        bot_settings: dict[str, Any] | None = None,
+        handle_in_background: bool = True,
+    ) -> None:
+        """
+        Initialize the TokenEngine for multi-bot applications.
+
+        Args:
+            dispatcher: Dispatcher instance for update processing.
+            web_adapter: Web framework adapter class.
+            routing: Webhook routing strategy.
+            security: Security settings and checks.
+            bot_settings: Default settings for creating Bot instances.
+            handle_in_background: Whether to process updates in background.
+        """
+        super().__init__(
+            dispatcher,
+            web_adapter=web_adapter,
+            routing=routing,
+            security=security,
+            handle_in_background=handle_in_background,
+        )
+        self.bot_settings = bot_settings
+        self._bots: dict[int, Bot] = {}
+
+    def resolve_bot_from_request(self, bound_request: BoundRequest) -> Bot | None:
+        token = self.routing.extract_key(bound_request)
+        if not token:
+            return None
+        return self.resolve_bot(token)
+
+    async def on_startup(self, bots: Iterable[Bot] | None = None, **kwargs: Any) -> None:
+        """Called on application startup. Emits dispatcher startup event for all bots."""
+        all_bots = set(bots) | set(self._bots.values()) if bots else set(self._bots.values())
+
+        await self.dispatcher.emit_startup(
+            dispatcher=self.dispatcher,
+            bots=all_bots,
+            webhook_engine=self,
+            **kwargs,
+        )
+
+    async def on_shutdown(self) -> None:
+        """Called on application shutdown. Emits dispatcher shutdown event and closes all bot sessions."""
+        await self.dispatcher.emit_shutdown(
+            dispatcher=self.dispatcher,
+            bots=set(self._bots.values()),
+            webhook_engine=self,
+        )
+
+        for bot in self._bots.values():
+            await bot.session.close()
+        # self._bots.clear()
+
+    async def set_webhook(self, token: str, **kwargs) -> Bot:
+        """Sets the webhook for the Bot instance resolved by token."""
+        bot = self.resolve_bot(token)
+
+        await bot.set_webhook(url=self.routing.webhook_point(bot), secret_token=None, **kwargs)
+        return bot
+
+    def resolve_bot(self, token: str) -> Bot:
+        """Resolve or create a Bot instance by token and cache it."""
+        bot = self._bots.get(extract_bot_id(token))
+        if not bot:
+            bot = Bot(token=token, **(self.bot_settings or {}))
+            self._bots[bot.id] = bot
+        return bot

aiogram_webhook/routing/__init__.py

@@ -0,0 +1,5 @@
+from aiogram_webhook.routing.base import BaseRouting
+from aiogram_webhook.routing.path import PathRouting
+from aiogram_webhook.routing.query import QueryRouting
+
+__all__ = ("BaseRouting", "PathRouting", "QueryRouting")

aiogram_webhook/routing/base.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+
+from aiogram import Bot
+from yarl import URL
+
+from aiogram_webhook.adapters.base import BoundRequest
+
+
+class BaseRouting(ABC):
+    """
+    Abstract base class for webhook routing strategies.
+
+    Defines how webhook URLs are constructed and how keys (tokens)
+    are extracted from incoming requests.
+
+    Attributes:
+        url: Url template.
+    """
+
+    def __init__(self, url: str) -> None:
+        self.url = URL(url)
+        self.base = self.url.origin()
+        self.path = self.url.path
+
+    @abstractmethod
+    def webhook_point(self, bot: Bot) -> str:
+        """Return the webhook URL for the given bot."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def extract_key(self, bound_request: BoundRequest) -> str | None:
+        """Extract the routing key (e.g., token) from the incoming request."""
+        raise NotImplementedError

aiogram_webhook/routing/path.py

@@ -0,0 +1,28 @@
+from aiogram import Bot
+
+from aiogram_webhook.adapters.base import BoundRequest
+from aiogram_webhook.routing.base import BaseRouting
+
+
+class PathRouting(BaseRouting):
+    """
+    URL path-based routing strategy.
+
+    Extracts bot token from URL path parameters.
+    Example: /webhook/{token} -> extracts token from path.
+    """
+
+    def __init__(self, url: str, param: str | None = None) -> None:
+        super().__init__(url=url)
+        self.param = param
+
+    def webhook_point(self, bot: Bot) -> str:
+        url = self.url.human_repr()
+        if self.param is None:
+            return url
+        return url.format_map({self.param: bot.token})
+
+    def extract_key(self, bound_request: BoundRequest) -> str | None:
+        if self.param is None:
+            return None
+        return bound_request.path_param(self.param)

aiogram_webhook/routing/query.py

@@ -0,0 +1,35 @@
+from aiogram import Bot
+
+from aiogram_webhook.adapters.base import BoundRequest
+from aiogram_webhook.routing.base import BaseRouting
+
+
+class QueryRouting(BaseRouting):
+    """
+    URL query parameter-based routing strategy.
+
+    Extracts bot token from query parameters.
+    Example: /webhook?token=123:ABC -> extracts token from query.
+    """
+
+    def __init__(self, url: str, param: str) -> None:
+        """
+        Initialize the query parameter-based routing strategy.
+
+        Args:
+            url: The URL template for webhook endpoints.
+            param: The query parameter name for the bot token.
+        """
+        super().__init__(url=url)
+        self.param = param
+
+    def webhook_point(self, bot: Bot) -> str:
+        url = self.url.human_repr()
+        if self.param is None:
+            return url
+        return url.format_map({self.param: bot.token})
+
+    def extract_key(self, bound_request: BoundRequest) -> str | None:
+        if self.param is None:
+            return None
+        return bound_request.query_param(self.param)

aiogram_webhook/security/__init__.py

@@ -0,0 +1,6 @@
+from aiogram_webhook.security.checks.check import Check
+from aiogram_webhook.security.checks.ip import IPCheck
+from aiogram_webhook.security.secret_token import SecretToken, StaticSecretToken
+from aiogram_webhook.security.security import Security
+
+__all__ = ("Check", "IPCheck", "SecretToken", "Security", "StaticSecretToken")

aiogram_webhook/security/checks/check.py

@@ -0,0 +1,14 @@
+from typing import Protocol
+
+from aiogram import Bot
+
+from aiogram_webhook.adapters.base import BoundRequest
+
+
+class Check(Protocol):
+    """
+    Protocol for security check on webhook requests.
+    """
+
+    async def verify(self, bot: Bot, bound_request: BoundRequest) -> bool:
+        raise NotImplementedError

aiogram_webhook/security/checks/ip.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network, ip_address, ip_network
+from typing import Final
+
+from aiogram_webhook.security.checks.check import Check
+
+DEFAULT_TELEGRAM_NETWORKS: Final[tuple[IPv4Network | IPv6Network, ...]] = (
+    IPv4Network("149.154.160.0/20"),
+    IPv4Network("91.108.4.0/22"),
+)
+
+IPAddressOrNetwork = IPv4Network | IPv6Network | IPv4Address | IPv6Address
+
+
+class IPCheck(Check):
+    """
+    Security check for validating client IP address against allowed networks and addresses.
+    """
+
+    def __init__(self, *ip_entries: IPAddressOrNetwork | str, include_default: bool = True) -> None:
+        """
+        Initialize the IPCheck with allowed IP addresses and networks.
+
+        Args:
+            *ip_entries: IP addresses or networks to allow.
+            include_default: Whether to include default Telegram IP networks.
+        """
+        networks: set[IPv4Network | IPv6Network] = set()
+        addresses: set[IPv4Address | IPv6Address] = set()
+
+        if include_default:
+            networks.update(DEFAULT_TELEGRAM_NETWORKS)
+
+        for item in ip_entries:
+            parsed = self._parse(item)
+            if parsed is None:
+                continue
+            if isinstance(parsed, (IPv4Network, IPv6Network)):
+                networks.add(parsed)
+            else:
+                addresses.add(parsed)
+
+        self._networks: set[IPv4Network | IPv6Network] = networks
+        self._addresses: set[IPv4Address | IPv6Address] = addresses
+
+    async def verify(self, bot, bound_request) -> bool:  # noqa: ARG002
+        raw_ip = bound_request.ip()
+        if not raw_ip:
+            return False
+        try:
+            addr = ip_address(raw_ip)
+        except ValueError:
+            return False
+
+        if addr in self._addresses:
+            return True
+
+        return any(addr in net for net in self._networks)
+
+    @staticmethod
+    def _parse(item: IPAddressOrNetwork | str) -> IPAddressOrNetwork | None:
+        if isinstance(item, (IPv4Network, IPv6Network, IPv4Address, IPv6Address)):
+            return item
+        if isinstance(item, str):
+            return ip_network(item, strict=False) if "/" in item else ip_address(item)
+        return None

aiogram_webhook/security/secret_token.py

@@ -0,0 +1,42 @@
+from hmac import compare_digest
+from typing import Protocol
+
+from aiogram import Bot
+
+from aiogram_webhook.adapters.base import BoundRequest
+
+
+class SecretToken(Protocol):
+    """
+    Protocol for secret token verification in webhook requests.
+    """
+
+    async def verify(self, bot: Bot, bound_request: BoundRequest) -> bool:
+        """
+        Verify the secret token in the incoming request.
+        """
+        raise NotImplementedError
+
+    def secret_token(self, bot: Bot) -> str:
+        """
+        Return the secret token for the given bot.
+        """
+        raise NotImplementedError
+
+
+class StaticSecretToken(SecretToken):
+    """
+    Static secret token implementation for webhook security.
+    """
+
+    def __init__(self, token: str) -> None:
+        self._token = token
+
+    async def verify(self, bot: Bot, bound_request: BoundRequest) -> bool:  # noqa: ARG002
+        incoming = bound_request.secret_token()
+        if incoming is None:
+            return False
+        return compare_digest(incoming, self._token)
+
+    def secret_token(self, bot: Bot) -> str:  # noqa: ARG002
+        return self._token

aiogram_webhook/security/security.py

@@ -0,0 +1,38 @@
+from aiogram import Bot
+
+from aiogram_webhook.adapters.base import BoundRequest
+from aiogram_webhook.security.checks.check import Check
+from aiogram_webhook.security.secret_token import SecretToken
+
+
+class Security:
+    """
+    Security class for webhook request verification.
+
+    Combines secret token and custom checks for request validation.
+    """
+
+    def __init__(self, *checks: Check, secret_token: SecretToken | None = None) -> None:
+        self._secret_token = secret_token
+        self._checks: tuple[Check, ...] = checks
+
+    async def verify(self, bot: Bot, bound_request: BoundRequest) -> bool:
+        if self._secret_token is not None:
+            ok = await self._secret_token.verify(bot=bot, bound_request=bound_request)
+            if not ok:
+                return False
+
+        for checker in self._checks:
+            ok = await checker.verify(bot=bot, bound_request=bound_request)
+            if not ok:
+                return False
+
+        return True
+
+    async def get_secret_token(self, *, bot: Bot) -> str | None:
+        """
+        Get the secret token for the given bot, if configured.
+        """
+        if self._secret_token is None:
+            return None
+        return self._secret_token.secret_token(bot=bot)

aiogram_webhook-0.0.1.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: aiogram-webhook
+Version: 0.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.
+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://github.com/m-xim/aiogram-webhook#readme
+Author-email: m-xim <i@m-xim.ru>
+License: MIT
+License-File: LICENSE
+Keywords: aiogram,fastapi,multibot,telegram,webhook
+Classifier: Operating System :: OS Independent
+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: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: aiogram>=3.23.0
+Requires-Dist: yarl>=1.22.0
+Description-Content-Type: text/markdown
+
+# aiogram-webhook
+
+[![PyPI version](https://img.shields.io/pypi/v/aiogram-webhook?color=blue)](https://pypi.org/project/aiogram-webhook)
+[![License](https://img.shields.io/github/license/m-xim/aiogram-webhook.svg)](/LICENSE)
+[![Tests Status](https://github.com/m-xim/aiogram-webhook/actions/workflows/tests.yml/badge.svg)](https://github.com/m-xim/aiogram-webhook/actions)
+[![Release Status](https://github.com/m-xim/aiogram-webhook/actions/workflows/release.yml/badge.svg)](https://github.com/m-xim/aiogram-webhook/actions)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/m-xim/aiogram-webhook)
+
+**aiogram-webhook** is a Python library for seamless webhook integration with multiple web frameworks in aiogram. It enables both single and multi-bot operation via webhooks, with flexible routing and security features.
+
+<br>
+
+## ✨ Features
+
+- 🧱 Modular and extensible webhook engine
+- 🔀 Flexible routing (static and token-based)
+- 🤖 Supports single and multi-bot setups
+- ⚡ FastAPI adapters out of the box
+- 🔒 Security best practices: secret tokens, IP checks
+- 🧩 Easy to extend with custom adapters and routing
+
+## 🚀 Installation
+
+```bash
+uv add aiogram-webhook
+# or
+pip install aiogram-webhook
+```
+
+## ⚡ Quick Start
+
+### Single Bot Example (FastAPI)
+```python
+import uvicorn
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from aiogram import Bot, Dispatcher, Router
+from aiogram.filters import CommandStart
+from aiogram.types import Message
+from aiogram_webhook import SimpleEngine, FastApiWebAdapter
+from aiogram_webhook.routing import PathRouting
+
+router = Router()
+
+@router.message(CommandStart())
+async def start(message: Message):
+    await message.answer("OK")
+
+dispatcher = Dispatcher()
+dispatcher.include_router(router)
+bot = Bot("BOT_TOKEN_HERE")
+
+engine = SimpleEngine(
+    dispatcher,
+    bot,
+    web_adapter=FastApiWebAdapter(),
+    routing=PathRouting(url="/webhook"),
+)
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    engine.register(app)
+    await engine.set_webhook(
+        drop_pending_updates=True,
+        allowed_updates=("message", "callback_query"),
+    )
+    await engine.on_startup()
+    yield
+    await engine.on_shutdown()
+
+app = FastAPI(lifespan=lifespan)
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=8080)
+```
+
+### Multi-Bot Example (FastAPI)
+Each bot is configured in Telegram with its own webhook URL: `https://example.com/webhook/<BOT_TOKEN>`
+
+```python
+from aiogram import Dispatcher
+from aiogram.client.default import DefaultBotProperties
+from aiogram_webhook import TokenEngine, FastApiWebAdapter
+from aiogram_webhook.routing import PathRouting
+
+dispatcher = Dispatcher()
+engine = TokenEngine(
+    dispatcher,
+    web_adapter=FastApiWebAdapter(),
+    routing=PathRouting(url="/webhook/{bot_token}", param="bot_token"),
+    bot_settings={
+        "default": DefaultBotProperties(parse_mode="HTML"),
+    },
+)
+```
+
+Usage is the same:
+```python
+engine.register(app)
+await engine.set_webhook(...)
+await engine.on_startup()
+await engine.on_shutdown()
+```
+
+## 🛣️ Routing
+
+`PathRouting` defines where Telegram sends updates:
+
+- **Static path:**
+    ```python
+  PathRouting(url="/webhook")
+  ```
+- **Token-based path:**
+  ```python
+  PathRouting(url="/webhook/{bot_token}", param="bot_token")
+  ```
+
+## 🛡️ Security
+writings...

aiogram_webhook-0.0.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+aiogram_webhook/__init__.py,sha256=0rHHTrVd6q3zVPUuISvdkbRigzks9b5C9hTqRKckvH4,380
+aiogram_webhook/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiogram_webhook/adapters/base.py,sha256=5TYBW3hHH5Dyo_hJ9J2xbkAqxUqpJaOI6felPqwZza0,1806
+aiogram_webhook/adapters/fastapi.py,sha256=p7hjo8swJJU3qr7mLVbiITt3sdElJiUZGwm4syLsVk8,1415
+aiogram_webhook/engines/__init__.py,sha256=5yqqsJi8Q2Zn_7PBNJJPebTWnGV2roOjiLoLZZiLOCE,225
+aiogram_webhook/engines/base.py,sha256=j1QIUBnVAEQX89HnjN1yqJZiWr5IK1GCK3xZ7TnhAC0,5236
+aiogram_webhook/engines/simple.py,sha256=HvbXemzjxOQTSVMweSX11TrTjfbuFhH_2qQaIGY0Z4Y,3326
+aiogram_webhook/engines/token.py,sha256=YqoghLSjRx-GJvE6EaodllupKmynEygriEB-8xg00xA,3471
+aiogram_webhook/routing/__init__.py,sha256=xJkA4CkIWmj9ynhD5CUFo_8rtfUaqcfkiH9Btyzq7Q0,219
+aiogram_webhook/routing/base.py,sha256=n4DsCY3Ipk6Q_apri5FZIeulm5LRiLNQYG9V4OIBbNA,894
+aiogram_webhook/routing/path.py,sha256=0TqV73B8Bf4F7Z8IszK6fYj7ArOPPNVwkL3D3G5y5p8,829
+aiogram_webhook/routing/query.py,sha256=IedHWu-PtmQppK_oOb4NExqI6hXjI9zG0ClFn_U9nXs,1054
+aiogram_webhook/security/__init__.py,sha256=JW-bI0yZkkD70AGlBsNNcEAsEJXfSIWPDUzWLWyvNgQ,327
+aiogram_webhook/security/secret_token.py,sha256=HqBQbB43e0ae3Wd4ZBs6H8_0VomWdBG9H5HweQlqclY,1124
+aiogram_webhook/security/security.py,sha256=NA9iKski7hn_uzKyUEb3mhCoPdG9cl5gL3vDq3WMnIQ,1252
+aiogram_webhook/security/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiogram_webhook/security/checks/check.py,sha256=jhE4Ilk8hlXhg8x8Z3v-TXrgaVCdDN4Tj33VfKM6-gY,313
+aiogram_webhook/security/checks/ip.py,sha256=l_i9fW_b72jIuwIkfVOF5ycHXm611R89mDk-UVu3QK4,2265
+aiogram_webhook-0.0.1.dist-info/METADATA,sha256=xCflibZ2ZKBlhMwdqRBo9cg_X32q_iPMdbD23QH3r2w,4485
+aiogram_webhook-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+aiogram_webhook-0.0.1.dist-info/licenses/LICENSE,sha256=18BsTl9ZVeMudRIrRyZqTd80Z3fs2qHyLJZj0wDMrZc,1062
+aiogram_webhook-0.0.1.dist-info/RECORD,,

aiogram_webhook-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

aiogram_webhook-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 m-xim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.