oapi-gen-dishka 0.1.0__tar.gz

oapi_gen_dishka-0.1.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: oapi-gen-dishka
+Version: 0.1.0
+Summary: Request-scoped Dishka injection for oapi-gen handlers
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: dishka<2,>=1.10.1
+Requires-Dist: starlette<2,>=1.0
+
+# oapi-gen-dishka
+
+Inject Dishka dependencies into the async methods called by an `oapi-gen` router.
+Generated code stays unchanged. The integration reuses Dishka's native Starlette
+request container, so operation handlers, security handlers, and ordinary Starlette
+endpoints share the same `Scope.REQUEST` instances.
+
+This directory is an independently buildable package. Install it into your
+application from a local checkout:
+
+```bash
+uv add /path/to/oapi-gen/integrations/dishka
+```
+
+## Usage
+
+The example uses the repository's complete Cats specification. Generate it into
+your application's package:
+
+```bash
+oapi-gen generate tests/fixtures/cats.openapi.yaml --output app/http/generated
+```
+
+```python
+from contextlib import asynccontextmanager
+from uuid import UUID, uuid4
+
+from dishka import FromDishka, Provider, Scope, make_async_container, provide
+from starlette.applications import Starlette
+from oapi_gen_dishka import inject, setup_dishka
+
+from app.http.generated import Handlers, contracts, create_router, models
+
+
+class CatsRepository:
+    def __init__(self):
+        self.cats: dict[UUID, models.Cat] = {}
+
+
+class CatsController:
+    @inject
+    async def list_cats(
+        self,
+        request: contracts.ListCatsRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.ListCatsResponse:
+        cats = list(repository.cats.values())
+        return contracts.ListCatsResponse200(body=cats[: request.limit])
+
+    @inject
+    async def create_cat(
+        self,
+        request: contracts.CreateCatRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.CreateCatResponse:
+        cat = models.Cat(id=uuid4(), name=request.body.name)
+        repository.cats[cat.id] = cat
+        return contracts.CreateCatResponse201()
+
+    @inject
+    async def show_cat_by_id(
+        self,
+        request: contracts.ShowCatByIdRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.ShowCatByIdResponse:
+        cat = repository.cats.get(request.cat_id)
+        if cat is None:
+            return contracts.ShowCatByIdResponse404(
+                body=models.HttpError(message="Cat not found"),
+            )
+        return contracts.ShowCatByIdResponse200(body=cat)
+
+
+class AppProvider(Provider):
+    # This in-memory example keeps cats between requests in one process.
+    repository = provide(CatsRepository, scope=Scope.APP)
+
+
+container = make_async_container(AppProvider())
+
+
+@asynccontextmanager
+async def lifespan(app: Starlette):
+    try:
+        yield
+    finally:
+        await container.close()
+
+
+router = create_router(Handlers(cats=CatsController()), prefix="/api")
+app = Starlette(lifespan=lifespan, routes=router.routes)
+setup_dishka(container, app)
+```
+
+Use `Scope.REQUEST` for services or database sessions that must be recreated for
+each request. Dishka resolves dependencies from the normal provider graph and
+finalizes generator providers at the end of the request, including on exceptions.
+Add Dishka's `StarletteProvider()` from `dishka.integrations.starlette` when a
+provider needs `starlette.requests.Request`.
+
+`@inject` also works on generated security handler methods. Use
+`dishka.integrations.starlette.inject` on ordinary Starlette endpoints; both
+decorators resolve from the same container after the single setup call above.
+
+## Boundaries
+
+- Async HTTP handlers only. WebSockets, sync containers, and background work
+  outside the request lifetime are not supported by this decorator.
+- Call this package's `setup_dishka` once, before startup, **instead of** calling
+  `dishka.integrations.starlette.setup_dishka` separately.
+- The controller instance passed to `Handlers` is shared. Keep request-specific
+  state in local variables and injected dependencies, not on `self`.
+- Providers must register dependencies; `FromDishka[T]` selects the registered
+  type and does not register it automatically. Dishka components are supported.
+- Runtime signatures omit injected parameters and retain the remaining
+  annotations. The decorator preserves the static response type but uses
+  `Callable[..., ...]` for arguments, since Python typing cannot remove arbitrary
+  `FromDishka` parameters. Annotate controller references with the generated
+  protocol when calling them directly to check request argument types:
+
+  ```python
+  controller: contracts.CatsApi = CatsController()
+  ```
+
+## Development
+
+```bash
+uv sync --project integrations/dishka
+uv run --project integrations/dishka pytest integrations/dishka/tests
+uv run --project integrations/dishka ruff check integrations/dishka
+uv run --project integrations/dishka basedpyright --project integrations/dishka
+uv build integrations/dishka --out-dir integrations/dishka/dist
+```
+
+The local development dependency on `oapi-gen` is used only for integration tests;
+the published wheel does not depend on the generator at runtime.

oapi_gen_dishka-0.1.0/README.md

@@ -0,0 +1,139 @@
+# oapi-gen-dishka
+
+Inject Dishka dependencies into the async methods called by an `oapi-gen` router.
+Generated code stays unchanged. The integration reuses Dishka's native Starlette
+request container, so operation handlers, security handlers, and ordinary Starlette
+endpoints share the same `Scope.REQUEST` instances.
+
+This directory is an independently buildable package. Install it into your
+application from a local checkout:
+
+```bash
+uv add /path/to/oapi-gen/integrations/dishka
+```
+
+## Usage
+
+The example uses the repository's complete Cats specification. Generate it into
+your application's package:
+
+```bash
+oapi-gen generate tests/fixtures/cats.openapi.yaml --output app/http/generated
+```
+
+```python
+from contextlib import asynccontextmanager
+from uuid import UUID, uuid4
+
+from dishka import FromDishka, Provider, Scope, make_async_container, provide
+from starlette.applications import Starlette
+from oapi_gen_dishka import inject, setup_dishka
+
+from app.http.generated import Handlers, contracts, create_router, models
+
+
+class CatsRepository:
+    def __init__(self):
+        self.cats: dict[UUID, models.Cat] = {}
+
+
+class CatsController:
+    @inject
+    async def list_cats(
+        self,
+        request: contracts.ListCatsRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.ListCatsResponse:
+        cats = list(repository.cats.values())
+        return contracts.ListCatsResponse200(body=cats[: request.limit])
+
+    @inject
+    async def create_cat(
+        self,
+        request: contracts.CreateCatRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.CreateCatResponse:
+        cat = models.Cat(id=uuid4(), name=request.body.name)
+        repository.cats[cat.id] = cat
+        return contracts.CreateCatResponse201()
+
+    @inject
+    async def show_cat_by_id(
+        self,
+        request: contracts.ShowCatByIdRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.ShowCatByIdResponse:
+        cat = repository.cats.get(request.cat_id)
+        if cat is None:
+            return contracts.ShowCatByIdResponse404(
+                body=models.HttpError(message="Cat not found"),
+            )
+        return contracts.ShowCatByIdResponse200(body=cat)
+
+
+class AppProvider(Provider):
+    # This in-memory example keeps cats between requests in one process.
+    repository = provide(CatsRepository, scope=Scope.APP)
+
+
+container = make_async_container(AppProvider())
+
+
+@asynccontextmanager
+async def lifespan(app: Starlette):
+    try:
+        yield
+    finally:
+        await container.close()
+
+
+router = create_router(Handlers(cats=CatsController()), prefix="/api")
+app = Starlette(lifespan=lifespan, routes=router.routes)
+setup_dishka(container, app)
+```
+
+Use `Scope.REQUEST` for services or database sessions that must be recreated for
+each request. Dishka resolves dependencies from the normal provider graph and
+finalizes generator providers at the end of the request, including on exceptions.
+Add Dishka's `StarletteProvider()` from `dishka.integrations.starlette` when a
+provider needs `starlette.requests.Request`.
+
+`@inject` also works on generated security handler methods. Use
+`dishka.integrations.starlette.inject` on ordinary Starlette endpoints; both
+decorators resolve from the same container after the single setup call above.
+
+## Boundaries
+
+- Async HTTP handlers only. WebSockets, sync containers, and background work
+  outside the request lifetime are not supported by this decorator.
+- Call this package's `setup_dishka` once, before startup, **instead of** calling
+  `dishka.integrations.starlette.setup_dishka` separately.
+- The controller instance passed to `Handlers` is shared. Keep request-specific
+  state in local variables and injected dependencies, not on `self`.
+- Providers must register dependencies; `FromDishka[T]` selects the registered
+  type and does not register it automatically. Dishka components are supported.
+- Runtime signatures omit injected parameters and retain the remaining
+  annotations. The decorator preserves the static response type but uses
+  `Callable[..., ...]` for arguments, since Python typing cannot remove arbitrary
+  `FromDishka` parameters. Annotate controller references with the generated
+  protocol when calling them directly to check request argument types:
+
+  ```python
+  controller: contracts.CatsApi = CatsController()
+  ```
+
+## Development
+
+```bash
+uv sync --project integrations/dishka
+uv run --project integrations/dishka pytest integrations/dishka/tests
+uv run --project integrations/dishka ruff check integrations/dishka
+uv run --project integrations/dishka basedpyright --project integrations/dishka
+uv build integrations/dishka --out-dir integrations/dishka/dist
+```
+
+The local development dependency on `oapi-gen` is used only for integration tests;
+the published wheel does not depend on the generator at runtime.

oapi_gen_dishka-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oapi-gen-dishka"
+version = "0.1.0"
+description = "Request-scoped Dishka injection for oapi-gen handlers"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = ["dishka>=1.10.1,<2", "starlette>=1.0,<2"]
+
+[dependency-groups]
+dev = [
+  "basedpyright==1.39.10",
+  "httpx==0.28.1",
+  "oapi-gen",
+  "pytest==9.1.1",
+  "ruff==0.16.6",
+]
+
+[tool.uv.sources]
+oapi-gen = { path = "../.." }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+oapi_gen_dishka = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+
+[tool.basedpyright]
+include = ["src"]
+pythonVersion = "3.12"
+typeCheckingMode = "standard"
+reportMissingTypeStubs = false

oapi_gen_dishka-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

oapi_gen_dishka-0.1.0/src/oapi_gen_dishka/__init__.py

@@ -0,0 +1,5 @@
+"""Dishka injection for the ordinary async methods called by generated routers."""
+
+from ._integration import inject, setup_dishka
+
+__all__ = ["inject", "setup_dishka"]

oapi_gen_dishka-0.1.0/src/oapi_gen_dishka/_integration.py

@@ -0,0 +1,77 @@
+"""Expose the native Dishka HTTP container to nested handler calls."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from contextvars import ContextVar
+from inspect import iscoroutinefunction
+from typing import Any, cast
+
+from dishka import AsyncContainer
+from dishka.integrations.base import wrap_injection
+from dishka.integrations.starlette import ContainerMiddleware
+from starlette.applications import Starlette
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+_request_container: ContextVar[AsyncContainer] = ContextVar("oapi_gen_dishka_request_container")
+
+
+def _get_container(args: tuple[Any, ...], kwargs: dict[str, Any]) -> AsyncContainer:
+    try:
+        return _request_container.get()
+    except LookupError:
+        raise RuntimeError(
+            "An injected oapi-gen handler must run inside an HTTP request configured with "
+            "oapi_gen_dishka.setup_dishka(container, app)."
+        ) from None
+
+
+def inject[Result](
+    func: Callable[..., Result],
+) -> Callable[..., Result]:
+    """Inject FromDishka parameters using the active HTTP request's container.
+
+    Runtime parameter annotations and the response type are preserved. Static
+    typing allows arbitrary call arguments because injected parameters are removed;
+    use the generated handler protocol for a strictly typed calling interface.
+    """
+    if not iscoroutinefunction(func):
+        raise TypeError("oapi_gen_dishka.inject requires an async function or method")
+    wrapped = wrap_injection(func=func, is_async=True, container_getter=_get_container)
+    return cast(Callable[..., Result], wrapped)
+
+
+class _RequestContextMiddleware:
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        token = _request_container.set(scope["state"]["dishka_container"])
+        try:
+            await self.app(scope, receive, send)
+        finally:
+            _request_container.reset(token)
+
+
+def setup_dishka(container: AsyncContainer, app: Starlette) -> None:
+    """Install native Dishka scope management and expose its container to handlers.
+
+    Call once, before app startup, to install the request container and handler context.
+    The application lifespan remains responsible for closing the APP container.
+    """
+    if not isinstance(container, AsyncContainer):
+        raise TypeError("oapi_gen_dishka requires an AsyncContainer")
+    if getattr(app.state, "dishka_container", None) is not None:
+        raise RuntimeError(
+            "Dishka is already configured for this app. Call oapi_gen_dishka.setup_dishka "
+            "once, instead of the framework's native Dishka setup."
+        )
+
+    # Starlette prepends middleware: native Dishka must run before this bridge.
+    app.add_middleware(_RequestContextMiddleware)
+    app.add_middleware(ContainerMiddleware)
+    app.state.dishka_container = container

oapi_gen_dishka-0.1.0/src/oapi_gen_dishka.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: oapi-gen-dishka
+Version: 0.1.0
+Summary: Request-scoped Dishka injection for oapi-gen handlers
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: dishka<2,>=1.10.1
+Requires-Dist: starlette<2,>=1.0
+
+# oapi-gen-dishka
+
+Inject Dishka dependencies into the async methods called by an `oapi-gen` router.
+Generated code stays unchanged. The integration reuses Dishka's native Starlette
+request container, so operation handlers, security handlers, and ordinary Starlette
+endpoints share the same `Scope.REQUEST` instances.
+
+This directory is an independently buildable package. Install it into your
+application from a local checkout:
+
+```bash
+uv add /path/to/oapi-gen/integrations/dishka
+```
+
+## Usage
+
+The example uses the repository's complete Cats specification. Generate it into
+your application's package:
+
+```bash
+oapi-gen generate tests/fixtures/cats.openapi.yaml --output app/http/generated
+```
+
+```python
+from contextlib import asynccontextmanager
+from uuid import UUID, uuid4
+
+from dishka import FromDishka, Provider, Scope, make_async_container, provide
+from starlette.applications import Starlette
+from oapi_gen_dishka import inject, setup_dishka
+
+from app.http.generated import Handlers, contracts, create_router, models
+
+
+class CatsRepository:
+    def __init__(self):
+        self.cats: dict[UUID, models.Cat] = {}
+
+
+class CatsController:
+    @inject
+    async def list_cats(
+        self,
+        request: contracts.ListCatsRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.ListCatsResponse:
+        cats = list(repository.cats.values())
+        return contracts.ListCatsResponse200(body=cats[: request.limit])
+
+    @inject
+    async def create_cat(
+        self,
+        request: contracts.CreateCatRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.CreateCatResponse:
+        cat = models.Cat(id=uuid4(), name=request.body.name)
+        repository.cats[cat.id] = cat
+        return contracts.CreateCatResponse201()
+
+    @inject
+    async def show_cat_by_id(
+        self,
+        request: contracts.ShowCatByIdRequest,
+        *,
+        repository: FromDishka[CatsRepository],
+    ) -> contracts.ShowCatByIdResponse:
+        cat = repository.cats.get(request.cat_id)
+        if cat is None:
+            return contracts.ShowCatByIdResponse404(
+                body=models.HttpError(message="Cat not found"),
+            )
+        return contracts.ShowCatByIdResponse200(body=cat)
+
+
+class AppProvider(Provider):
+    # This in-memory example keeps cats between requests in one process.
+    repository = provide(CatsRepository, scope=Scope.APP)
+
+
+container = make_async_container(AppProvider())
+
+
+@asynccontextmanager
+async def lifespan(app: Starlette):
+    try:
+        yield
+    finally:
+        await container.close()
+
+
+router = create_router(Handlers(cats=CatsController()), prefix="/api")
+app = Starlette(lifespan=lifespan, routes=router.routes)
+setup_dishka(container, app)
+```
+
+Use `Scope.REQUEST` for services or database sessions that must be recreated for
+each request. Dishka resolves dependencies from the normal provider graph and
+finalizes generator providers at the end of the request, including on exceptions.
+Add Dishka's `StarletteProvider()` from `dishka.integrations.starlette` when a
+provider needs `starlette.requests.Request`.
+
+`@inject` also works on generated security handler methods. Use
+`dishka.integrations.starlette.inject` on ordinary Starlette endpoints; both
+decorators resolve from the same container after the single setup call above.
+
+## Boundaries
+
+- Async HTTP handlers only. WebSockets, sync containers, and background work
+  outside the request lifetime are not supported by this decorator.
+- Call this package's `setup_dishka` once, before startup, **instead of** calling
+  `dishka.integrations.starlette.setup_dishka` separately.
+- The controller instance passed to `Handlers` is shared. Keep request-specific
+  state in local variables and injected dependencies, not on `self`.
+- Providers must register dependencies; `FromDishka[T]` selects the registered
+  type and does not register it automatically. Dishka components are supported.
+- Runtime signatures omit injected parameters and retain the remaining
+  annotations. The decorator preserves the static response type but uses
+  `Callable[..., ...]` for arguments, since Python typing cannot remove arbitrary
+  `FromDishka` parameters. Annotate controller references with the generated
+  protocol when calling them directly to check request argument types:
+
+  ```python
+  controller: contracts.CatsApi = CatsController()
+  ```
+
+## Development
+
+```bash
+uv sync --project integrations/dishka
+uv run --project integrations/dishka pytest integrations/dishka/tests
+uv run --project integrations/dishka ruff check integrations/dishka
+uv run --project integrations/dishka basedpyright --project integrations/dishka
+uv build integrations/dishka --out-dir integrations/dishka/dist
+```
+
+The local development dependency on `oapi-gen` is used only for integration tests;
+the published wheel does not depend on the generator at runtime.

oapi_gen_dishka-0.1.0/src/oapi_gen_dishka.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/oapi_gen_dishka/__init__.py
+src/oapi_gen_dishka/_integration.py
+src/oapi_gen_dishka/py.typed
+src/oapi_gen_dishka.egg-info/PKG-INFO
+src/oapi_gen_dishka.egg-info/SOURCES.txt
+src/oapi_gen_dishka.egg-info/dependency_links.txt
+src/oapi_gen_dishka.egg-info/requires.txt
+src/oapi_gen_dishka.egg-info/top_level.txt
+tests/test_integration.py
+tests/test_starlette.py

oapi_gen_dishka-0.1.0/src/oapi_gen_dishka.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

oapi_gen_dishka-0.1.0/src/oapi_gen_dishka.egg-info/requires.txt

@@ -0,0 +1,2 @@
+dishka<2,>=1.10.1
+starlette<2,>=1.0

oapi_gen_dishka-0.1.0/src/oapi_gen_dishka.egg-info/top_level.txt

@@ -0,0 +1 @@
+oapi_gen_dishka

oapi_gen_dishka-0.1.0/tests/test_integration.py

@@ -0,0 +1,416 @@
+import asyncio
+import importlib
+import inspect
+import json
+import subprocess
+import sys
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated
+from uuid import uuid4
+
+import httpx
+import pytest
+from dishka import FromComponent, FromDishka, Provider, Scope, make_async_container, provide
+from dishka.integrations.starlette import StarletteProvider
+from dishka.integrations.starlette import inject as inject_starlette
+from dishka.integrations.starlette import setup_dishka as setup_starlette_dishka
+from oapi_gen import generate_package
+from oapi_gen_dishka import inject, setup_dishka
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+from starlette.testclient import TestClient
+
+
+@dataclass
+class RequestResource:
+    name: str
+    id: str
+    native_dependency_seen: bool = False
+    closed: bool = False
+
+
+class ResourceProvider(Provider):
+    def __init__(self):
+        super().__init__()
+        self.resources: list[RequestResource] = []
+
+    @provide(scope=Scope.REQUEST)
+    async def resource(self, request: Request) -> AsyncIterator[RequestResource]:
+        resource = RequestResource(name=request.headers.get("X-Request", "normal"), id=uuid4().hex)
+        self.resources.append(resource)
+        try:
+            yield resource
+        finally:
+            resource.closed = True
+
+
+@pytest.fixture(scope="module")
+def generated(tmp_path_factory):
+    root = tmp_path_factory.mktemp("generated")
+    spec = {
+        "openapi": "3.1.0",
+        "info": {"title": "Dishka integration", "version": "1"},
+        "paths": {
+            "/items": {
+                "get": {
+                    "operationId": "listItems",
+                    "x-handler-group": "Items",
+                    "security": [{"bearerAuth": []}],
+                    "parameters": [
+                        {"name": "fail", "in": "query", "schema": {"type": "boolean"}},
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Resource id",
+                            "content": {"application/json": {"schema": {"type": "string"}}},
+                        },
+                    },
+                },
+            },
+        },
+        "components": {"securitySchemes": {"bearerAuth": {"type": "http", "scheme": "bearer"}}},
+    }
+    source = root / "spec.json"
+    source.write_text(json.dumps(spec))
+    name = "generated_dishka_test_api"
+    generate_package(source, root / name)
+    sys.path.insert(0, str(root))
+    try:
+        yield importlib.import_module(name)
+    finally:
+        sys.path.remove(str(root))
+        for key in list(sys.modules):
+            if key == name or key.startswith(f"{name}."):
+                del sys.modules[key]
+
+
+@inject
+async def outside_probe(*, resource: FromDishka[RequestResource]) -> RequestResource:
+    return resource
+
+
+def build_app(generated, started=None):
+    contracts = generated.contracts
+    provider = ResourceProvider()
+    container = make_async_container(provider, StarletteProvider())
+
+    class Controller:
+        @inject
+        async def list_items(
+            self,
+            request: contracts.ListItemsRequest,
+            *,
+            resource: FromDishka[RequestResource],
+        ) -> contracts.ListItemsResponse:
+            assert request.security_context is resource
+            assert resource.native_dependency_seen
+            assert not resource.closed
+            if request.fail:
+                raise ValueError("handler failed")
+            if resource.name == "cancel":
+                started.set()
+                await asyncio.Event().wait()
+            await asyncio.sleep(0)
+            # Nested injection must still see this request's resource after yielding.
+            assert await outside_probe() is resource
+            return contracts.ListItemsResponse200(body=f"{resource.name}:{resource.id}")
+
+    class Security:
+        @inject
+        async def handle_bearer_auth(
+            self,
+            context: object | None,
+            operation_id: str,
+            credential: contracts.BearerAuthSecurity,
+            *,
+            resource: FromDishka[RequestResource],
+        ) -> object:
+            assert operation_id == "listItems"
+            assert context is None
+            if credential.token != "accepted":
+                raise contracts.SecurityRejected("denied")
+            return resource
+
+    @asynccontextmanager
+    async def lifespan(app):
+        try:
+            yield
+        finally:
+            await container.close()
+
+    router = generated.create_router(generated.Handlers(items=Controller()), security=Security())
+    generated_endpoint = router.routes[0].endpoint
+
+    @inject_starlette
+    async def native_endpoint(request: Request, resource: FromDishka[RequestResource]):
+        resource.native_dependency_seen = True
+        return await generated_endpoint(request)
+
+    app = Starlette(
+        lifespan=lifespan,
+        routes=[Route("/items", native_endpoint), *router.routes[1:]],
+    )
+    setup_dishka(container, app)
+    return app, container, provider, Controller
+
+
+def test_generated_handlers_share_native_scope_with_security_and_dependencies(generated):
+    app, _, provider, controller = build_app(generated)
+    with TestClient(app) as client:
+        first = client.get("/items", headers={"Authorization": "Bearer accepted"})
+        second = client.get("/items", headers={"Authorization": "Bearer accepted"})
+        assert first.status_code == second.status_code == 200
+        assert first.json() != second.json()
+        assert len(provider.resources) == 2
+        assert all(resource.closed for resource in provider.resources)
+        operation = client.get("/openapi.json").json()["paths"]["/items"]["get"]
+        assert [parameter["name"] for parameter in operation["parameters"]] == ["fail"]
+
+    signature = inspect.signature(controller().list_items)
+    assert list(signature.parameters) == ["request"]
+    assert signature.parameters["request"].annotation is generated.contracts.ListItemsRequest
+    assert signature.return_annotation is generated.contracts.ListItemsResponse
+
+
+def test_parallel_http_requests_are_isolated(generated):
+    async def scenario():
+        app, container, provider, _ = build_app(generated)
+        try:
+            async with httpx.AsyncClient(
+                transport=httpx.ASGITransport(app=app),
+                base_url="http://test",
+            ) as client:
+                responses = await asyncio.gather(
+                    *(
+                        client.get(
+                            "/items",
+                            headers={"Authorization": "Bearer accepted", "X-Request": str(index)},
+                        )
+                        for index in range(10)
+                    )
+                )
+            assert all(response.status_code == 200 for response in responses)
+            assert [response.json().split(":")[0] for response in responses] == list(
+                map(str, range(10))
+            )
+            assert len({response.json().split(":")[1] for response in responses}) == 10
+            assert len(provider.resources) == 10
+            assert all(resource.closed for resource in provider.resources)
+            with pytest.raises(RuntimeError, match="inside an HTTP request"):
+                await outside_probe()
+        finally:
+            await container.close()
+
+    asyncio.run(scenario())
+
+
+def test_failures_finalize_dependencies_and_reset_context(generated):
+    async def scenario():
+        app, container, provider, _ = build_app(generated)
+        try:
+            async with httpx.AsyncClient(
+                transport=httpx.ASGITransport(app=app),
+                base_url="http://test",
+            ) as client:
+                with pytest.raises(ValueError, match="handler failed"):
+                    await client.get(
+                        "/items?fail=true", headers={"Authorization": "Bearer accepted"}
+                    )
+                assert provider.resources[-1].closed
+                with pytest.raises(RuntimeError, match="inside an HTTP request"):
+                    await outside_probe()
+                denied = await client.get("/items", headers={"Authorization": "Bearer denied"})
+                assert denied.status_code == 401
+                assert provider.resources[-1].closed
+                success = await client.get("/items", headers={"Authorization": "Bearer accepted"})
+                assert success.status_code == 200
+                assert all(resource.closed for resource in provider.resources)
+                with pytest.raises(RuntimeError, match="inside an HTTP request"):
+                    await outside_probe()
+        finally:
+            await container.close()
+
+    asyncio.run(scenario())
+
+
+def test_cancellation_finalizes_request_resources(generated):
+    async def scenario():
+        started = asyncio.Event()
+        app, container, provider, _ = build_app(generated, started)
+        try:
+            async with httpx.AsyncClient(
+                transport=httpx.ASGITransport(app=app),
+                base_url="http://test",
+            ) as client:
+                task = asyncio.create_task(
+                    client.get(
+                        "/items",
+                        headers={"Authorization": "Bearer accepted", "X-Request": "cancel"},
+                    )
+                )
+                try:
+                    await asyncio.wait_for(started.wait(), timeout=5)
+                finally:
+                    task.cancel()
+                    with pytest.raises(asyncio.CancelledError):
+                        await task
+                assert len(provider.resources) == 1
+                assert provider.resources[0].closed
+                with pytest.raises(RuntimeError, match="inside an HTTP request"):
+                    await outside_probe()
+        finally:
+            await container.close()
+
+    asyncio.run(scenario())
+
+
+def test_dishka_components_are_supported():
+    class ComponentProvider(Provider):
+        @provide(scope=Scope.REQUEST)
+        def resource(self) -> RequestResource:
+            return RequestResource(name="component", id="component-id")
+
+    @inject
+    async def handler(
+        *,
+        resource: Annotated[RequestResource, FromComponent("other")],
+    ) -> str:
+        return resource.name
+
+    container = make_async_container(ComponentProvider().to_component("other"))
+
+    @asynccontextmanager
+    async def lifespan(app):
+        try:
+            yield
+        finally:
+            await container.close()
+
+    async def endpoint(request: Request):
+        return JSONResponse(await handler())
+
+    app = Starlette(lifespan=lifespan, routes=[Route("/", endpoint)])
+
+    setup_dishka(container, app)
+    with TestClient(app) as client:
+        assert client.get("/").json() == "component"
+
+
+@pytest.mark.parametrize("native_first", [False, True])
+def test_setup_rejects_duplicate_scope_management(native_first):
+    async def scenario():
+        container = make_async_container(Provider())
+        app = Starlette()
+        try:
+            (setup_starlette_dishka if native_first else setup_dishka)(container, app)
+            middleware_count = len(app.user_middleware)
+            with pytest.raises(RuntimeError, match="already configured"):
+                setup_dishka(container, app)
+            assert len(app.user_middleware) == middleware_count
+        finally:
+            await container.close()
+
+    asyncio.run(scenario())
+
+
+def test_inject_rejects_sync_functions():
+    with pytest.raises(TypeError, match="async function or method"):
+        inject(lambda: None)
+
+
+def test_decorated_handlers_implement_generated_protocol(generated, tmp_path):
+    code = """
+from dishka import FromDishka
+from oapi_gen_dishka import inject
+from generated_dishka_test_api import contracts
+
+class Controller:
+    @inject
+    async def list_items(
+        self,
+        request: contracts.ListItemsRequest,
+        *,
+        dependency: FromDishka[object],
+    ) -> contracts.ListItemsResponse:
+        return contracts.ListItemsResponse200(body=str(request.fail))
+
+handler: contracts.ItemsApi = Controller()
+handlers = contracts.Handlers(items=Controller())
+
+async def call() -> contracts.ListItemsResponse:
+    return await handler.list_items(
+        request=contracts.ListItemsRequest(fail=None, security_context=None),
+    )
+"""
+    source = tmp_path / "example.py"
+    source.write_text(code)
+    config = tmp_path / "pyrightconfig.json"
+    config.write_text(
+        json.dumps(
+            {
+                "include": ["example.py"],
+                "pythonVersion": "3.12",
+                "typeCheckingMode": "standard",
+                "extraPaths": [
+                    str(Path(generated.__file__).parents[1]),
+                    str(Path(__file__).resolve().parents[1] / "src"),
+                ],
+            }
+        )
+    )
+    command = [
+        sys.executable,
+        "-m",
+        "basedpyright",
+        "--project",
+        str(config),
+        "--pythonpath",
+        sys.executable,
+        "--outputjson",
+    ]
+    result = subprocess.run(command, capture_output=True, text=True, check=False)
+    assert result.returncode == 0, result.stdout + result.stderr
+
+    source.write_text(
+        code + '\nasync def invalid() -> None:\n    await handler.list_items("wrong")\n'
+    )
+    result = subprocess.run(command, capture_output=True, text=True, check=False)
+    assert result.returncode == 1, result.stdout + result.stderr
+    diagnostics = json.loads(result.stdout)["generalDiagnostics"]
+    assert [diagnostic["rule"] for diagnostic in diagnostics] == ["reportArgumentType"]
+
+
+def test_readme_example_runs_with_complete_generated_api(tmp_path, monkeypatch):
+    integration_root = Path(__file__).resolve().parents[1]
+    repo_root = integration_root.parents[1]
+    example = (
+        integration_root.joinpath("README.md")
+        .read_text()
+        .split("```python\n", 1)[1]
+        .split("```", 1)[0]
+    )
+    generate_package(
+        repo_root / "tests/fixtures/cats.openapi.yaml", tmp_path / "app/http/generated"
+    )
+    monkeypatch.syspath_prepend(str(tmp_path))
+    try:
+        namespace = {}
+        exec(compile(example, "README.md", "exec"), namespace)
+        with TestClient(namespace["app"]) as client:
+            assert client.get("/api/cats").json() == []
+            assert client.post("/api/cats", json={"name": "Mittens"}).status_code == 201
+            cats = client.get("/api/cats?limit=1").json()
+            assert len(cats) == 1
+            assert cats[0]["name"] == "Mittens"
+            assert client.get(f"/api/cats/{cats[0]['id']}").json() == cats[0]
+            assert client.get(f"/api/cats/{uuid4()}").status_code == 404
+            assert client.get("/api/cats?limit=0").status_code == 422
+    finally:
+        for name in list(sys.modules):
+            if name == "app" or name.startswith("app."):
+                del sys.modules[name]

oapi_gen_dishka-0.1.0/tests/test_starlette.py

@@ -0,0 +1,101 @@
+import asyncio
+import importlib
+import json
+from collections.abc import AsyncIterator
+from pathlib import Path
+
+import httpx
+from dishka import FromDishka, Provider, Scope, make_async_container, provide
+from dishka.integrations.starlette import StarletteProvider
+from oapi_gen import generate_package
+from oapi_gen_dishka import inject, setup_dishka
+from starlette.applications import Starlette
+from starlette.requests import Request
+
+
+def test_starlette_scopes_are_shared_isolated_and_closed(tmp_path: Path, monkeypatch):
+    specification = {
+        "openapi": "3.1.0",
+        "info": {"title": "Scope test", "version": "1"},
+        "paths": {
+            "/value": {
+                "get": {
+                    "operationId": "test",
+                    "security": [{"key": []}],
+                    "responses": {
+                        "200": {
+                            "description": "value",
+                            "content": {"application/json": {"schema": {"type": "string"}}},
+                        }
+                    },
+                }
+            }
+        },
+        "components": {
+            "securitySchemes": {"key": {"type": "apiKey", "in": "header", "name": "X-Key"}}
+        },
+    }
+    source = tmp_path / "spec.json"
+    source.write_text(json.dumps(specification))
+    generate_package(source, tmp_path / "generated_starlette_dishka")
+    monkeypatch.syspath_prepend(str(tmp_path))
+    generated = importlib.import_module("generated_starlette_dishka")
+    contracts = importlib.import_module("generated_starlette_dishka.contracts")
+    resources = []
+
+    class Resource:
+        def __init__(self, name):
+            self.name = name
+            self.closed = False
+
+    class Services(Provider):
+        @provide(scope=Scope.REQUEST)
+        async def resource(self, request: Request) -> AsyncIterator[Resource]:
+            resource = Resource(request.headers["X-Key"])
+            resources.append(resource)
+            try:
+                yield resource
+            finally:
+                resource.closed = True
+
+    class Security:
+        @inject
+        async def handle_key(
+            self, context, operation_id, credential, resource: FromDishka[Resource]
+        ):
+            assert resource.name == credential.api_key
+            return resource
+
+    class Controller:
+        @inject
+        async def test(self, request, resource: FromDishka[Resource]):
+            await asyncio.sleep(0)
+            assert request.security_context is resource
+            assert not resource.closed
+            if resource.name == "fail":
+                raise ValueError("failed")
+            return contracts.TestResponse200(body=resource.name)
+
+    async def scenario():
+        container = make_async_container(Services(), StarletteProvider())
+        router = generated.create_router(
+            generated.Handlers(default=Controller()), security=Security()
+        )
+        app = Starlette(routes=router.routes)
+        setup_dishka(container, app)
+        try:
+            async with httpx.AsyncClient(
+                transport=httpx.ASGITransport(app, raise_app_exceptions=False),
+                base_url="http://test",
+            ) as client:
+                responses = await asyncio.gather(
+                    *[client.get("/value", headers={"X-Key": str(i)}) for i in range(10)]
+                )
+                assert [response.json() for response in responses] == [str(i) for i in range(10)]
+                assert (await client.get("/value", headers={"X-Key": "fail"})).status_code == 500
+            assert len(resources) == 11
+            assert all(resource.closed for resource in resources)
+        finally:
+            await container.close()
+
+    asyncio.run(scenario())