modern-di-aiogram 2.0.0__tar.gz

modern_di_aiogram-2.0.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: modern-di-aiogram
+Version: 2.0.0
+Summary: modern-di integration for aiogram
+Keywords: dependency-injection,di,ioc-container,modern-di,aiogram,telegram,python
+Author: Artur Shiriev
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: aiogram>=3.2,<4
+Requires-Dist: modern-di>=2.25,<3
+Requires-Python: >=3.10, <4
+Project-URL: Homepage, https://modern-di.modern-python.org
+Project-URL: Documentation, https://modern-di.modern-python.org
+Project-URL: Repository, https://github.com/modern-python/modern-di-aiogram
+Project-URL: Issues, https://github.com/modern-python/modern-di-aiogram/issues
+Project-URL: Changelog, https://github.com/modern-python/modern-di-aiogram/releases
+Description-Content-Type: text/markdown
+
+# modern-di-aiogram
+
+[Modern-DI](https://github.com/modern-python/modern-di) integration for [aiogram](https://docs.aiogram.dev) 3.x.
+
+## Quickstart
+
+```python
+import typing
+
+from aiogram import Bot, Dispatcher
+from aiogram.types import Message
+from modern_di import Container, Group, Scope, providers
+from modern_di_aiogram import FromDI, inject, setup_di
+
+
+class Settings:
+    def __init__(self) -> None:
+        self.greeting = "hello"
+
+
+class Dependencies(Group):
+    settings = providers.Factory(scope=Scope.APP, creator=Settings)
+
+
+dispatcher = Dispatcher()
+setup_di(dispatcher, Container(groups=[Dependencies], validate=True))
+
+
+@dispatcher.message()
+@inject
+async def greet(message: Message, settings: typing.Annotated[Settings, FromDI(Dependencies.settings)]) -> None:
+    await message.answer(f"{settings.greeting}, {message.from_user.first_name}")
+```
+
+See the [documentation](https://modern-di.modern-python.org) for the full guide, including `auto_inject`.

modern_di_aiogram-2.0.0/README.md

@@ -0,0 +1,35 @@
+# modern-di-aiogram
+
+[Modern-DI](https://github.com/modern-python/modern-di) integration for [aiogram](https://docs.aiogram.dev) 3.x.
+
+## Quickstart
+
+```python
+import typing
+
+from aiogram import Bot, Dispatcher
+from aiogram.types import Message
+from modern_di import Container, Group, Scope, providers
+from modern_di_aiogram import FromDI, inject, setup_di
+
+
+class Settings:
+    def __init__(self) -> None:
+        self.greeting = "hello"
+
+
+class Dependencies(Group):
+    settings = providers.Factory(scope=Scope.APP, creator=Settings)
+
+
+dispatcher = Dispatcher()
+setup_di(dispatcher, Container(groups=[Dependencies], validate=True))
+
+
+@dispatcher.message()
+@inject
+async def greet(message: Message, settings: typing.Annotated[Settings, FromDI(Dependencies.settings)]) -> None:
+    await message.answer(f"{settings.greeting}, {message.from_user.first_name}")
+```
+
+See the [documentation](https://modern-di.modern-python.org) for the full guide, including `auto_inject`.

modern_di_aiogram-2.0.0/modern_di_aiogram/__init__.py

@@ -0,0 +1,18 @@
+from modern_di_aiogram.main import (
+    FromDI,
+    aiogram_event_provider,
+    aiogram_update_provider,
+    fetch_di_container,
+    inject,
+    setup_di,
+)
+
+
+__all__ = [
+    "FromDI",
+    "aiogram_event_provider",
+    "aiogram_update_provider",
+    "fetch_di_container",
+    "inject",
+    "setup_di",
+]

modern_di_aiogram-2.0.0/modern_di_aiogram/main.py

@@ -0,0 +1,131 @@
+import dataclasses
+import functools
+import inspect
+import typing
+
+import aiogram
+from aiogram import BaseMiddleware, Dispatcher
+from aiogram.dispatcher.event.handler import HandlerObject
+from aiogram.types import TelegramObject, Update
+from modern_di import Container, Scope, providers
+
+
+aiogram_update_provider = providers.ContextProvider(Update, scope=Scope.REQUEST)
+aiogram_event_provider = providers.ContextProvider(TelegramObject, scope=Scope.REQUEST)
+_CONNECTION_PROVIDERS = (aiogram_update_provider, aiogram_event_provider)
+
+# Root container in the dispatcher's workflow-data; per-update child in the
+# per-update ``data`` dict (also the keyword-only param name ``inject`` adds).
+# Named constants keep writer and reader in provable agreement.
+_ROOT_CONTAINER_KEY = "modern_di_root_container"
+_CHILD_CONTAINER_KEY = "modern_di_container"
+
+
+class _DiMiddleware(BaseMiddleware):
+    def __init__(self, container: Container) -> None:
+        self.container = container
+
+    async def __call__(
+        self,
+        handler: typing.Callable[[TelegramObject, dict[str, typing.Any]], typing.Awaitable[typing.Any]],
+        event: TelegramObject,
+        data: dict[str, typing.Any],
+    ) -> typing.Any:  # noqa: ANN401
+        child_container = self.container.build_child_container(
+            scope=Scope.REQUEST,
+            context={Update: event, TelegramObject: typing.cast("Update", event).event},
+        )
+        data[_CHILD_CONTAINER_KEY] = child_container
+        try:
+            return await handler(event, data)
+        finally:
+            await child_container.close_async()
+
+
+def setup_di(dispatcher: Dispatcher, container: Container, *, auto_inject: bool = False) -> Container:
+    dispatcher[_ROOT_CONTAINER_KEY] = container
+    container.add_providers(*_CONNECTION_PROVIDERS)
+    dispatcher.startup.register(container.open)
+    dispatcher.shutdown.register(container.close_async)
+    dispatcher.update.outer_middleware(_DiMiddleware(container))
+    if auto_inject:
+        dispatcher.startup.register(functools.partial(_inject_router, dispatcher))
+    return container
+
+
+def fetch_di_container(dispatcher: Dispatcher) -> Container:
+    return typing.cast(Container, dispatcher[_ROOT_CONTAINER_KEY])
+
+
+T = typing.TypeVar("T")
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class _FromDI(typing.Generic[T_co]):
+    dependency: providers.AbstractProvider[T_co] | type[T_co]
+
+
+def FromDI(dependency: providers.AbstractProvider[T] | type[T]) -> T:  # noqa: N802
+    return typing.cast(T, _FromDI(dependency))
+
+
+def _parse_inject_params(func: typing.Callable[..., typing.Any]) -> dict[str, _FromDI[typing.Any]]:
+    hints = typing.get_type_hints(func, include_extras=True)
+    di_params: dict[str, _FromDI[typing.Any]] = {}
+    for name, hint in hints.items():
+        if name == "return":
+            continue
+        if typing.get_origin(hint) is typing.Annotated:
+            for meta in typing.get_args(hint)[1:]:
+                if isinstance(meta, _FromDI):
+                    di_params[name] = meta
+                    break
+    return di_params
+
+
+def inject(func: typing.Callable[..., typing.Awaitable[T]]) -> typing.Callable[..., typing.Awaitable[T]]:
+    di_params = _parse_inject_params(func)
+    if not di_params:
+        func.__modern_di_injected__ = True  # ty: ignore[unresolved-attribute]
+        return func
+
+    original_signature = inspect.signature(func)
+    visible_params = [p for name, p in original_signature.parameters.items() if name not in di_params]
+    container_param_injected = _CHILD_CONTAINER_KEY not in original_signature.parameters
+    if container_param_injected:
+        visible_params.append(
+            inspect.Parameter(_CHILD_CONTAINER_KEY, kind=inspect.Parameter.KEYWORD_ONLY, annotation=Container),
+        )
+
+    async def wrapper(*args: typing.Any, **kwargs: typing.Any) -> T:  # noqa: ANN401
+        container: Container = (
+            kwargs.pop(_CHILD_CONTAINER_KEY) if container_param_injected else kwargs[_CHILD_CONTAINER_KEY]
+        )
+        resolved = {name: container.resolve_dependency(marker.dependency) for name, marker in di_params.items()}
+        return await func(*args, **kwargs, **resolved)
+
+    # NOT functools.wraps: aiogram unwraps __wrapped__ and would defeat __signature__.
+    wrapper.__name__ = func.__name__  # ty: ignore[unresolved-attribute]
+    wrapper.__qualname__ = func.__qualname__  # ty: ignore[unresolved-attribute]
+    wrapper.__doc__ = func.__doc__
+    wrapper.__module__ = func.__module__
+    wrapper.__signature__ = original_signature.replace(parameters=visible_params)  # ty: ignore[unresolved-attribute]
+    wrapper.__modern_di_injected__ = True  # ty: ignore[unresolved-attribute]
+    return wrapper
+
+
+def _inject_router(router: aiogram.Router) -> None:
+    for sub_router in router.chain_tail:
+        for observer in sub_router.observers.values():
+            if observer.event_name == "update":
+                continue
+            for handler in observer.handlers:
+                if not getattr(handler.callback, "__modern_di_injected__", False):
+                    wrapped = HandlerObject(
+                        callback=inject(handler.callback),
+                        filters=handler.filters,
+                        flags=handler.flags,
+                    )
+                    handler.callback = wrapped.callback
+                    handler.params = wrapped.params

modern_di_aiogram-2.0.0/pyproject.toml

@@ -0,0 +1,84 @@
+[project]
+name = "modern-di-aiogram"
+description = "modern-di integration for aiogram"
+authors = [{ name = "Artur Shiriev", email = "me@shiriev.ru" }]
+requires-python = ">=3.10,<4"
+license = "MIT"
+readme = "README.md"
+keywords = ["dependency-injection", "di", "ioc-container", "modern-di", "aiogram", "telegram", "python"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "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",
+    "Typing :: Typed",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = ["aiogram>=3.2,<4", "modern-di>=2.25,<3"]
+version = "2.0.0"
+
+[project.urls]
+Homepage = "https://modern-di.modern-python.org"
+Documentation = "https://modern-di.modern-python.org"
+Repository = "https://github.com/modern-python/modern-di-aiogram"
+Issues = "https://github.com/modern-python/modern-di-aiogram/issues"
+Changelog = "https://github.com/modern-python/modern-di-aiogram/releases"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+]
+lint = [
+    "ty",
+    "ruff",
+    "eof-fixer",
+    "typing-extensions",
+]
+
+[build-system]
+requires = ["uv_build>=0.11,<1.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "modern_di_aiogram"
+module-root = ""
+
+[tool.ruff]
+fix = false
+unsafe-fixes = true
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D1", # allow missing docstrings
+    "S101", # allow asserts
+    "TCH", # ignore flake8-type-checking
+    "FBT", # allow boolean args
+    "D203", # "one-blank-line-before-class" conflicting with D211
+    "D213", # "multi-line-summary-second-line" conflicting with D212
+    "COM812", # flake8-commas "Trailing comma missing"
+    "ISC001", # flake8-implicit-str-concat
+    "G004", # allow f-strings in logging
+]
+isort.lines-after-imports = 2
+isort.no-lines-before = ["standard-library", "local-folder"]
+
+[tool.pytest.ini_options]
+addopts = ""
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.coverage.report]
+exclude_also = [
+    "if typing.TYPE_CHECKING:",
+]