modern-di-fastapi 0.1.0__tar.gz

modern_di_fastapi-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+# Generic things
+*.pyc
+*~
+__pycache__/*
+*.swp
+*.sqlite3
+*.map
+.vscode
+.idea
+.DS_Store
+.env
+.mypy_cache
+.pytest_cache
+.ruff_cache
+.coverage
+htmlcov/
+coverage.xml
+pytest.xml
+dist/
+.python-version
+.venv
+uv.lock

modern_di_fastapi-0.1.0/Justfile

@@ -0,0 +1,23 @@
+default: install lint test
+
+install:
+    uv lock --upgrade
+    uv sync --all-extras --frozen
+
+lint:
+    uv run ruff format .
+    uv run ruff check . --fix
+    uv run mypy .
+
+lint-ci:
+    uv run ruff format . --check
+    uv run ruff check . --no-fix
+    uv run mypy .
+
+test *args:
+    uv run pytest {{ args }}
+
+publish:
+    rm -rf dist
+    uv build
+    uv publish --token $PYPI_TOKEN

modern_di_fastapi-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.3
+Name: modern-di-fastapi
+Version: 0.1.0
+Summary: Modern-DI integration for FastAPI
+Project-URL: repository, https://github.com/modern-python/modern-di
+Project-URL: docs, https://modern-di.readthedocs.io
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Keywords: DI,FastAPI,dependency injector,ioc-container,python
+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
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.10
+Requires-Dist: fastapi>=0.100
+Requires-Dist: modern-di
+Description-Content-Type: text/markdown
+
+"Modern-DI-FastAPI"
+==
+
+Integration of [Modern-DI](https://github.com/modern-python/modern-di) to FastAPI
+
+📚 [Documentation](https://modern-di.readthedocs.io)

modern_di_fastapi-0.1.0/README.md

@@ -0,0 +1,6 @@
+"Modern-DI-FastAPI"
+==
+
+Integration of [Modern-DI](https://github.com/modern-python/modern-di) to FastAPI
+
+📚 [Documentation](https://modern-di.readthedocs.io)

modern_di_fastapi-0.1.0/modern_di_fastapi/__init__.py

@@ -0,0 +1,9 @@
+from modern_di_fastapi.depends import FromDI, setup_modern_di
+from modern_di_fastapi.middleware import ContainerMiddleware
+
+
+__all__ = [
+    "ContainerMiddleware",
+    "FromDI",
+    "setup_modern_di",
+]

modern_di_fastapi-0.1.0/modern_di_fastapi/depends.py

@@ -0,0 +1,24 @@
+import dataclasses
+import typing
+
+import fastapi
+import modern_di
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class Dependency(typing.Generic[T_co]):
+    dependency: modern_di.resolvers.AbstractResolver[T_co]
+
+    async def __call__(self, request: fastapi.Request) -> T_co:
+        return await self.dependency.async_resolve(request.state.modern_di_container)
+
+
+def FromDI(dependency: modern_di.resolvers.AbstractResolver[T_co], *, use_cache: bool = True) -> T_co:  # noqa: N802
+    return typing.cast(T_co, fastapi.Depends(dependency=Dependency(dependency), use_cache=use_cache))
+
+
+def setup_modern_di(container: modern_di.Container, app: fastapi.FastAPI) -> None:
+    app.state.modern_di_container = container

modern_di_fastapi-0.1.0/modern_di_fastapi/middleware.py

@@ -0,0 +1,27 @@
+import typing
+
+import modern_di
+from starlette.requests import Request
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+class ContainerMiddleware:
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(
+        self,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        request = Request(scope, receive=receive, send=send)
+        context: dict[str, typing.Any] = {"request": request}
+
+        container: modern_di.Container = request.app.state.modern_di_container
+        async with container.build_child_container(context=context) as request_container:
+            request.state.modern_di_container = request_container
+            return await self.app(scope, receive, send)

modern_di_fastapi-0.1.0/pyproject.toml

@@ -0,0 +1,90 @@
+[project]
+name = "modern-di-fastapi"
+description = "Modern-DI integration for FastAPI"
+authors = [
+    { name = "Artur Shiriev", email = "me@shiriev.ru" },
+]
+readme = "README.md"
+requires-python = ">=3.10,<4"
+license = "MIT"
+keywords = ["DI", "dependency injector", "ioc-container", "FastAPI", "python"]
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+    "Topic :: Software Development :: Libraries",
+]
+packages = [
+    { include = "modern_di_fastapi" },
+]
+dynamic = ["version"]
+dependencies = [
+    "fastapi>=0.100",
+    "modern-di",
+]
+
+[project.urls]
+repository = "https://github.com/modern-python/modern-di"
+docs = "https://modern-di.readthedocs.io"
+
+[dependency-groups]
+dev = [
+    "httpx",
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "ruff",
+    "mypy",
+    "typing-extensions",
+    "asgi-lifespan",
+]
+
+[tool.uv.sources]
+modern-di = { path = "../../" }
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+fallback-version = "0"
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.ruff]
+fix = true
+unsafe-fixes = true
+line-length = 120
+target-version = "py310"
+extend-exclude = [
+    "docs",
+]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D1", # allow missing docstrings
+    "S101", # allow asserts
+    "TCH", # ignore flake8-type-checking
+    "FBT", # allow boolean args
+    "ANN101", # missing-type-self
+    "ANN102", # missing-type-cls
+    "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
+]
+isort.lines-after-imports = 2
+isort.no-lines-before = ["standard-library", "local-folder"]
+
+[tool.pytest.ini_options]
+addopts = "--cov=. --cov-report term-missing"
+asyncio_mode = "auto"
+
+[tool.coverage.report]
+exclude_also = ["if typing.TYPE_CHECKING:"]

modern_di_fastapi-0.1.0/tests/test_fastapi_di.py

@@ -0,0 +1,69 @@
+import contextlib
+import dataclasses
+import typing
+
+import fastapi
+import httpx
+import modern_di
+import pytest
+from asgi_lifespan import LifespanManager
+from modern_di import Scope, resolvers
+from starlette import status
+from starlette.requests import Request
+
+import modern_di_fastapi
+from modern_di_fastapi import ContainerMiddleware, FromDI
+
+
+@contextlib.asynccontextmanager
+async def lifespan(app_: fastapi.FastAPI) -> typing.AsyncIterator[None]:
+    di_container = modern_di.Container(scope=modern_di.Scope.APP)
+    modern_di_fastapi.setup_modern_di(container=di_container, app=app_)
+    async with di_container:
+        yield
+
+
+app = fastapi.FastAPI(lifespan=lifespan)
+app.add_middleware(ContainerMiddleware)
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class SimpleCreator:
+    dep1: str
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class DependentCreator:
+    dep1: SimpleCreator
+
+
+def context_adapter_function(*, request: Request, **_: object) -> str:
+    return request.method
+
+
+app_factory = resolvers.Factory(Scope.APP, SimpleCreator, dep1="original")
+request_factory = resolvers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
+context_adapter = resolvers.ContextAdapter(Scope.REQUEST, context_adapter_function)
+
+
+@app.get("/")
+async def read_root(
+    app_factory_instance: typing.Annotated[SimpleCreator, FromDI(app_factory)],
+    request_factory_instance: typing.Annotated[DependentCreator, FromDI(request_factory)],
+    method: typing.Annotated[str, FromDI(context_adapter)],
+) -> str:
+    assert isinstance(app_factory_instance, SimpleCreator)
+    assert isinstance(request_factory_instance, DependentCreator)
+    return method
+
+
+@pytest.fixture(scope="session")
+async def client() -> typing.AsyncIterator[httpx.AsyncClient]:
+    async with LifespanManager(app):
+        yield httpx.AsyncClient(app=app, base_url="http://test")
+
+
+async def test_read_main(client: httpx.AsyncClient) -> None:
+    response = await client.get("/")
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == "GET"