fastapi-injected 0.2.0__tar.gz → 0.2.1__tar.gz

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: fastapi-injected
-Version: 0.2.0
+Version: 0.2.1
 Summary: Yet another library to reuse fastapi dependency injection
 Project-URL: Repository, https://github.com/uriyyo/fastapi-injected
 Author-email: Yurii Karabas <1998uriyyo@gmail.com>
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.12
 Requires-Dist: fastapi>=0.139.2
 Requires-Dist: typing-extensions>=4.16.0
+Requires-Dist: typing-inspection>=0.4.4
 Description-Content-Type: text/markdown
 
 # fastapi-injected

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/fastapi_injected/_deps_tp.py

@@ -1,11 +1,13 @@
-from typing import Annotated, Any, TypeAliasType, TypeVar, get_args, get_origin
+from typing import Annotated, Any, TypeVar, get_args, get_origin
 
 from fastapi.params import Depends
+from typing_inspection.typing_objects import is_typealiastype
 
 
-def _unwrap_tp(tp: Any) -> Any:
-    if isinstance(tp, TypeAliasType):
-        return tp.__value__
+def unwrap_tp(tp: Any) -> Any:
+    # PEP 695 aliases can be nested, e.g. `type A = B` where `type B = Annotated[...]`
+    while is_typealiastype(tp):
+        tp = tp.__value__
 
     return tp
 
@@ -18,13 +20,13 @@ def _get_annotated_metadata(tp: Any) -> tuple[Any, ...]:
 
 
 def is_dep(tp: Any) -> bool:
-    tp = _unwrap_tp(tp)
+    tp = unwrap_tp(tp)
 
     return any(isinstance(tp, Depends) for tp in _get_annotated_metadata(tp))
 
 
 def _enforce_dep(tp: Any) -> Any:
-    tp = _unwrap_tp(tp)
+    tp = unwrap_tp(tp)
 
     if not is_dep(tp):
         msg = f"Expected a Dep, got {tp!r}"
@@ -57,4 +59,5 @@ __all__ = [
     "is_dep",
     "unwrap_dep_dependency",
     "unwrap_dep_tp",
+    "unwrap_tp",
 ]

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/fastapi_injected/_fastapi_lifecycle.py

@@ -1,10 +1,11 @@
-from collections.abc import AsyncIterable
+from collections.abc import AsyncGenerator
 from functools import wraps
 from typing import TYPE_CHECKING, Any
 
-from fastapi import Request, WebSocket, routing
+from fastapi import Depends, FastAPI, Request, WebSocket, routing
 from fastapi.dependencies import utils
 
+from .overrides import push_overrides
 from .scope import push_inject_scope
 from .types import DependencyCache
 
@@ -49,14 +50,27 @@ def _get_dependency_cache(request: Request) -> DependencyCache:
         raise MissingDependencyCacheError("Dependency cache not found") from None
 
 
-async def init_inject_scope(request: Request) -> AsyncIterable[None]:
-    async with push_inject_scope(
-        dependency_cache=_get_dependency_cache(request),
-        request=request,
-    ):
-        yield
+async def init_inject_scope(request: Request) -> AsyncGenerator[None]:
+    with push_overrides(provider=request.scope["route"].dependency_overrides_provider):
+        async with push_inject_scope(
+            dependency_cache=_get_dependency_cache(request),
+            request=request,
+        ):
+            yield
+
+
+def add_injected_scope(
+    app: FastAPI,
+    /,
+) -> None:
+    if any(dep.dependency is init_inject_scope for dep in app.router.dependencies):
+        return
+
+    dependency = Depends(init_inject_scope)
+    app.router.dependencies.insert(0, dependency)
 
 
 __all__ = [
+    "add_injected_scope",
     "init_inject_scope",
 ]

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/fastapi_injected/deps.py

@@ -4,17 +4,27 @@ from contextlib import AbstractContextManager, AsyncExitStack, contextmanager
 from contextvars import ContextVar, Token
 from copy import copy
 from functools import lru_cache, wraps
-from typing import Annotated, Any, Literal, cast, overload
+from typing import Annotated, Any, Literal, Protocol, cast, overload, runtime_checkable
 
-from fastapi import Depends
+from fastapi import Depends, params
 from fastapi.dependencies.models import Dependant
 from fastapi.dependencies.utils import get_dependant, get_typed_signature, solve_dependencies
 
+from ._deps_tp import is_dep, unwrap_tp
 from .scope import InjectScope
 from .sign import prepare_sign, update_func_sign
 from .types import Coro, HasSignature
 
 
+@runtime_checkable
+class HasDependsHook[**P, R](Protocol):
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Any:
+        pass
+
+    def __get_depends__(self) -> params.Depends:
+        pass
+
+
 @lru_cache(maxsize=1024)
 def create_dependant[**P, R](func: Callable[P, Coro[R]], /) -> Dependant:
     @wraps(func)
@@ -33,23 +43,36 @@ def create_dependant[**P, R](func: Callable[P, Coro[R]], /) -> Dependant:
 
 
 @lru_cache(maxsize=1024)
-def create_single_dependant[**P, R](func: Callable[P, R], /) -> Dependant:
+def create_single_dependant[**P, R](
+    func: Callable[P, R] | HasDependsHook[P, R],
+    /,
+    *,
+    path: str | None = None,
+) -> Dependant:
     async def _factory(__value__: R) -> R:
         return __value__
 
+    match func:
+        case _ if is_dep(func):
+            annotation = unwrap_tp(func)
+        case HasDependsHook():
+            annotation = Annotated[Any, func.__get_depends__()]
+        case _:
+            annotation = Annotated[Any, Depends(func)]
+
     cast("HasSignature", _factory).__signature__ = inspect.Signature(
         parameters=[
             inspect.Parameter(
                 "__value__",
                 inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                annotation=Annotated[Any, Depends(func)],
+                annotation=annotation,
             ),
         ],
         return_annotation=Any,
     )
 
     return get_dependant(
-        path="",
+        path=path or "",
         call=_factory,
     )
 
@@ -82,7 +105,7 @@ async def resolve_dependencies(
         request=scope.request,
         dependant=dependant,
         dependency_cache=copy(scope.dependency_cache),
-        dependency_overrides_provider=_dependency_override_provider.get(),
+        dependency_overrides_provider=get_inject_dependency_override_provider(),
         # this parameter is deprecated and not used
         async_exit_stack=cast(AsyncExitStack, None),
         embed_body_fields=False,

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/fastapi_injected/overrides.py

@@ -15,8 +15,9 @@ class NonFreshScopeError(Exception):
         super().__init__("push_overrides requires a fresh scope")
 
 
-def _get_current_overrides() -> Iterator[Mapping[Any, Any]]:
-    obj = get_inject_dependency_override_provider()
+def _get_overrides(obj: Any | None, /) -> Iterator[Mapping[Any, Any]]:
+    if obj is None:
+        return
 
     if isinstance(obj, HasDependencyOverrides):
         yield obj.dependency_overrides
@@ -33,7 +34,7 @@ def _get_override_key(tp: Any) -> Any:
 
 
 @dataclass
-class _OverridesProvider:
+class OverridesProvider:
     dependency_overrides: Mapping[Any, Any]
 
 
@@ -77,30 +78,45 @@ def _enforce_fresh_scope() -> None:
         raise NonFreshScopeError
 
 
+def create_fallback_override_provider(
+    *,
+    overrides: Overrides | None = None,
+    provider: HasDependencyOverrides | None = None,
+) -> OverridesProvider:
+    return OverridesProvider(
+        ChainMap(
+            {_get_override_key(k): _create_resolver(v) for k, v in (overrides or {}).items()},
+            *_get_overrides(provider),  # type: ignore[ty:invalid-argument-type]
+            *_get_overrides(get_inject_dependency_override_provider()),  # type: ignore[ty:invalid-argument-type]
+        ),
+    )
+
+
 @contextmanager
 def push_overrides(
-    overrides: Overrides,
+    overrides: Overrides | None = None,
     /,
     *,
+    provider: HasDependencyOverrides | None = None,
     require_fresh_scope: bool = True,
 ) -> Iterator[None]:
 
     if require_fresh_scope:
         _enforce_fresh_scope()
 
-    deps = ChainMap(
-        {_get_override_key(k): _create_resolver(v) for k, v in overrides.items()},
-        *_get_current_overrides(),  # type: ignore[ty:invalid-argument-type]
-    )
-
     with set_inject_dependency_override_provider(
-        _OverridesProvider(deps),
+        create_fallback_override_provider(
+            overrides=overrides,
+            provider=provider,
+        ),
     ):
         yield
 
 
 __all__ = [
     "FactoryOverride",
+    "OverridesProvider",
     "ValueOverride",
+    "create_fallback_override_provider",
     "push_overrides",
 ]

fastapi_injected-0.2.1/fastapi_injected/resolve.py

@@ -0,0 +1,56 @@
+from collections.abc import Callable
+from typing import Any, overload
+
+from typing_extensions import TypeForm
+
+from fastapi_injected.types import DepReturn
+
+from .deps import HasDependsHook, create_single_dependant, resolve_dependencies
+from .scope import inside_inject_scope
+
+
+@overload
+async def resolve[**P, R](
+    tp: Callable[P, DepReturn[R]] | HasDependsHook[P, DepReturn[R]],
+    /,
+    *,
+    new_scope: bool = False,
+) -> R:
+    pass
+
+
+@overload
+async def resolve[R](
+    tp: TypeForm[R],
+    /,
+    *,
+    new_scope: bool = False,
+) -> R:
+    pass
+
+
+async def resolve(
+    tp: Any,
+    /,
+    *,
+    new_scope: bool = False,
+) -> Any:
+
+    async with inside_inject_scope(
+        new_scope=new_scope,
+    ) as inject_scope:
+        dependant = create_single_dependant(
+            tp,
+            path=inject_scope.path_format,
+        )
+
+        return await resolve_dependencies(
+            dependant,
+            inject_scope,
+            single=True,
+        )
+
+
+__all__ = [
+    "resolve",
+]

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/fastapi_injected/scope.py

@@ -7,6 +7,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass
 
 from fastapi import Request
+from fastapi.routing import APIRoute, APIWebSocketRoute
 from starlette.types import Message, Scope
 
 from .types import DependencyCache
@@ -50,6 +51,14 @@ class InjectScope:
     dependency_cache: DependencyCache
     request: Request
 
+    @property
+    def path_format(self) -> str | None:
+        match self.request.scope:
+            case {"route": APIRoute() | APIWebSocketRoute() as route}:
+                return route.path_format
+            case _:
+                return None
+
 
 _inject_scope: ContextVar[InjectScope | None] = ContextVar(
     "_inject_scope",

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/fastapi_injected/types.py

@@ -1,5 +1,5 @@
 import inspect
-from collections.abc import Callable, Coroutine, Mapping
+from collections.abc import AsyncIterator, Callable, Coroutine, Iterator, Mapping
 from typing import TYPE_CHECKING, Annotated, Any, Protocol, TypeVar, runtime_checkable
 
 from fastapi import Depends
@@ -54,12 +54,15 @@ class HasDependencyOverrides(Protocol):
     dependency_overrides: Mapping[Any, Any]
 
 
+type DepReturn[R] = Coro[R] | Iterator[R] | AsyncIterator[R] | R
+
 __all__ = [
     "AsyncFunc",
     "Coro",
     "Decorator",
     "Dep",
     "DepFactory",
+    "DepReturn",
     "DependencyCache",
     "Func",
     "HasDependencyOverrides",

{fastapi_injected-0.2.0 → fastapi_injected-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-injected"
-version = "0.2.0"
+version = "0.2.1"
 description = "Yet another library to reuse fastapi dependency injection"
 authors = [
     { name = "Yurii Karabas", email = "1998uriyyo@gmail.com" },
@@ -20,6 +20,7 @@ classifiers = [
 dependencies = [
     "fastapi>=0.139.2",
     "typing-extensions>=4.16.0",
+    "typing-inspection>=0.4.4",
 ]
 
 [dependency-groups]

fastapi_injected-0.2.1/tests/test_fastapi.py

@@ -0,0 +1,121 @@
+from typing import Annotated
+
+from fastapi import Depends, FastAPI, status
+from fastapi.testclient import TestClient
+
+from fastapi_injected import Dep, Injected, init_inject_scope, inject, resolve
+from fastapi_injected._fastapi_lifecycle import add_injected_scope
+
+from .deps import Child, Container
+
+app = FastAPI(
+    dependencies=[
+        Depends(init_inject_scope),
+    ],
+)
+
+client = TestClient(app)
+
+
+@inject
+async def _func(
+    *,
+    container: Dep[Container] = Injected,
+) -> Container:
+    return container
+
+
+@app.get("/")
+async def route(container: Dep[Container]) -> str:
+    assert await resolve(Container) is container
+    assert await _func() is container
+
+    return ""
+
+
+def test_cache_is_working() -> None:
+    result = client.get("/")
+    assert result.status_code == status.HTTP_200_OK
+
+
+async def _item_id_dep(item_id: int) -> int:
+    return item_id
+
+
+type ItemID = Annotated[int, Depends(_item_id_dep)]
+
+
+@app.get("/items/{item_id}")
+async def item_route(item_id: ItemID) -> int:
+    assert await resolve(ItemID) == item_id
+
+    return item_id
+
+
+def test_resolve_uses_route_path() -> None:
+    result = client.get("/items/42")
+
+    assert result.status_code == status.HTTP_200_OK
+    assert result.json() == 42
+
+
+def test_add_injected_scope() -> None:
+    other_app = FastAPI()
+    assert not other_app.router.dependencies
+
+    add_injected_scope(other_app)
+    assert [dep.dependency for dep in other_app.router.dependencies] == [init_inject_scope]
+
+
+def test_add_injected_scope_is_idempotent() -> None:
+    other_app = FastAPI(dependencies=[Depends(_item_id_dep)])
+
+    add_injected_scope(other_app)
+    add_injected_scope(other_app)
+
+    assert [dep.dependency for dep in other_app.router.dependencies] == [
+        init_inject_scope,
+        _item_id_dep,
+    ]
+
+
+overridden_app = FastAPI()
+add_injected_scope(overridden_app)
+
+overridden_client = TestClient(overridden_app)
+
+
+@inject
+async def _injected_child(
+    *,
+    child: Dep[Child] = Injected,
+) -> Child:
+    return child
+
+
+@overridden_app.get("/")
+async def overridden_route() -> str:
+    container = await resolve(Container)
+
+    assert container.child is _overridden_child
+    assert await _injected_child() is _overridden_child
+
+    return ""
+
+
+_overridden_child = Child()
+
+
+async def _override_child() -> Child:
+    return _overridden_child
+
+
+def test_app_dependency_overrides_are_used() -> None:
+    overridden_app.dependency_overrides[Child] = _override_child
+
+    try:
+        result = overridden_client.get("/")
+    finally:
+        overridden_app.dependency_overrides.clear()
+
+    assert result.status_code == status.HTTP_200_OK

fastapi_injected-0.2.1/tests/test_overrides.py

@@ -0,0 +1,107 @@
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+import pytest
+
+from fastapi_injected import Dep, ValueOverride, push_inject_scope, push_overrides, resolve
+from fastapi_injected.overrides import (
+    NonFreshScopeError,
+    OverridesProvider,
+    create_fallback_override_provider,
+)
+
+from .deps import Child, Container, ContextState, ctx_dep
+
+pytestmark = pytest.mark.asyncio
+
+
+@dataclass
+class Provider:
+    dependency_overrides: Mapping[Any, Any] = field(default_factory=dict)
+
+
+def _child_factory(child: Child) -> Any:
+    async def _factory() -> Child:
+        return child
+
+    return _factory
+
+
+async def test_push_overrides():
+    child = Child()
+
+    with push_overrides({Child: ValueOverride(child)}):
+        container = await resolve(Container)
+
+    assert container.child is child
+
+
+async def test_push_overrides_provider():
+    child = Child()
+    provider = Provider({Child: _child_factory(child)})
+
+    with push_overrides(provider=provider):
+        container = await resolve(Container)
+
+    assert container.child is child
+
+
+async def test_push_overrides_without_anything():
+    with push_overrides():
+        container = await resolve(Container)
+
+    assert isinstance(container.child, Child)
+
+
+async def test_push_overrides_take_precedence_over_provider():
+    from_overrides, from_provider = Child(), Child()
+    provider = Provider({Child: _child_factory(from_provider)})
+
+    with push_overrides({Child: ValueOverride(from_overrides)}, provider=provider):
+        container = await resolve(Container)
+
+    assert container.child is from_overrides
+
+
+async def test_push_overrides_fallback_to_outer_provider():
+    child, ctx = Child(), ContextState()
+
+    with push_overrides({Child: ValueOverride(child)}):
+        with push_overrides({ctx_dep: ValueOverride(ctx)}, require_fresh_scope=False):
+            container = await resolve(Container)
+
+            # `ctx` comes from the inner overrides, `child` falls back to the outer ones
+            assert container.ctx is ctx
+            assert container.child is child
+
+        container = await resolve(Container)
+
+        assert container.ctx is not ctx
+        assert container.child is child
+
+
+async def test_push_overrides_provider_fallback_to_outer_provider():
+    outer = Child()
+    provider = Provider()
+
+    with push_overrides({Child: ValueOverride(outer)}), push_overrides(provider=provider, require_fresh_scope=False):
+        container = await resolve(Container)
+
+    assert container.child is outer
+
+
+async def test_push_overrides_requires_fresh_scope():
+    async with push_inject_scope():
+        await resolve(Container)
+
+        with pytest.raises(NonFreshScopeError), push_overrides({Child: ValueOverride(Child())}):
+            pass  # pragma: no cover
+
+
+async def test_create_fallback_override_provider():
+    child = Child()
+    provider = create_fallback_override_provider(overrides={Dep[Child]: ValueOverride(child)})
+
+    assert isinstance(provider, OverridesProvider)
+    assert list(provider.dependency_overrides) == [Child]

fastapi_injected-0.2.1/tests/test_resolve.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass
+
+import pytest
+from fastapi import Depends, params
+
+from fastapi_injected import Dep, push_inject_scope, resolve
+
+pytestmark = pytest.mark.asyncio
+
+
+@dataclass
+class Foo:
+    pass
+
+
+@dataclass
+class Bar:
+    foo: Dep[Foo]
+
+
+async def test_resolve():
+    bar = await resolve(Bar)
+
+    assert isinstance(bar, Bar)
+    assert isinstance(bar.foo, Foo)
+
+
+async def test_resolve_reuse_cache():
+    async with push_inject_scope():
+        b1 = await resolve(Bar)
+        b2 = await resolve(Bar)
+
+        assert b1 is b2
+
+
+@dataclass(frozen=True)
+class DependsHook:
+    use_cache: bool = True
+
+    def __call__(self) -> Bar:  # pragma: no cover
+        raise AssertionError("should be resolved via __get_depends__")
+
+    def __get_depends__(self) -> params.Depends:
+        return Depends(Bar, use_cache=self.use_cache)
+
+
+async def test_resolve_depends_hook():
+    bar = await resolve(DependsHook())
+
+    assert isinstance(bar, Bar)
+    assert isinstance(bar.foo, Foo)
+
+
+async def test_resolve_depends_hook_reuse_cache():
+    async with push_inject_scope():
+        b1 = await resolve(DependsHook())
+        b2 = await resolve(DependsHook())
+
+        assert b1 is b2
+
+
+async def test_resolve_depends_hook_no_cache():
+    async with push_inject_scope():
+        b1 = await resolve(DependsHook(use_cache=False))
+        b2 = await resolve(DependsHook(use_cache=False))
+
+        assert b1 is not b2