fastapi-injected 0.3.4__tar.gz → 0.3.5__tar.gz

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-injected
-Version: 0.3.4
+Version: 0.3.5
 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>
@@ -164,7 +164,7 @@ async with push_inject_scope(app=app):
 
 Without it, reading `request.app` raises a `KeyError` naming what is missing rather than a bare `'app'`.
 
-Analysing a dependency is the expensive part of resolving one, so the result is cached — keyed by the dependency itself, not by whatever object carried it, so nothing that only passed through is kept alive. `clear_dependant_cache()` drops it, for long-lived processes and test suites that want the memory back.
+Analysing a dependency is the expensive part of resolving one, so the result is cached — keyed by the dependency itself, not by whatever object carried it, so nothing that only passed through is kept alive. Only dependencies written in source code are cached this way: functions and classes, and annotations built from them. One made at runtime — `Given(...)`, a `MakeInjected` or `bind_deps` result, an object that brings its own `Depends` — is analysed again on every resolve, and FastAPI never gets to keep it: what it carries is released with the resolve instead of living as long as the process. `clear_dependant_cache()` drops the cache, for long-lived processes and test suites that want the memory back.
 
 ### Overriding dependencies
 
@@ -227,7 +227,7 @@ async with push_inject_scope({Session: fake}) as scope:
 
 ### Dependencies that are objects
 
-Dependants are cached by the callable that resolves them, so a dependency that is an object — a class holding configuration, a parametrized resolver — has to be hashable to get there. A plain dataclass is not, and a frozen one still refuses as soon as it holds a list or a dict.
+Resolved values are cached in their scope by the callable that resolves them, so a dependency that is an object — a class holding configuration, a parametrized resolver — has to be hashable to get there. A plain dataclass is not, and a frozen one still refuses as soon as it holds a list or a dict.
 
 `MakeDataclass` is a base class that makes its subclasses dataclasses with a hash that always answers: by fields when they can be hashed, by identity when they cannot.
 

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/README.md

@@ -143,7 +143,7 @@ async with push_inject_scope(app=app):
 
 Without it, reading `request.app` raises a `KeyError` naming what is missing rather than a bare `'app'`.
 
-Analysing a dependency is the expensive part of resolving one, so the result is cached — keyed by the dependency itself, not by whatever object carried it, so nothing that only passed through is kept alive. `clear_dependant_cache()` drops it, for long-lived processes and test suites that want the memory back.
+Analysing a dependency is the expensive part of resolving one, so the result is cached — keyed by the dependency itself, not by whatever object carried it, so nothing that only passed through is kept alive. Only dependencies written in source code are cached this way: functions and classes, and annotations built from them. One made at runtime — `Given(...)`, a `MakeInjected` or `bind_deps` result, an object that brings its own `Depends` — is analysed again on every resolve, and FastAPI never gets to keep it: what it carries is released with the resolve instead of living as long as the process. `clear_dependant_cache()` drops the cache, for long-lived processes and test suites that want the memory back.
 
 ### Overriding dependencies
 
@@ -206,7 +206,7 @@ async with push_inject_scope({Session: fake}) as scope:
 
 ### Dependencies that are objects
 
-Dependants are cached by the callable that resolves them, so a dependency that is an object — a class holding configuration, a parametrized resolver — has to be hashable to get there. A plain dataclass is not, and a frozen one still refuses as soon as it holds a list or a dict.
+Resolved values are cached in their scope by the callable that resolves them, so a dependency that is an object — a class holding configuration, a parametrized resolver — has to be hashable to get there. A plain dataclass is not, and a frozen one still refuses as soon as it holds a list or a dict.
 
 `MakeDataclass` is a base class that makes its subclasses dataclasses with a hash that always answers: by fields when they can be hashed, by identity when they cannot.
 

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/fastapi_injected/_bind.py

@@ -6,6 +6,7 @@ from typing import Annotated, Any, Concatenate, get_origin, overload
 from fastapi.dependencies.utils import get_typed_signature
 from fastapi.params import Depends
 
+from ._calls import annotated
 from ._deps_tp import unwrap_tp
 from .sign import update_func_sign
 from .types import AsyncFunc, DepOf, Func
@@ -39,12 +40,12 @@ def _is_annotation(tp: Any, /) -> bool:
 
 def _dep_annotation(dep: DepOf[Any] | Callable[..., Any], /) -> Any:
     if isinstance(dep, Depends):
-        return Annotated[Any, dep]
+        return annotated(Any, dep)
 
     if _is_annotation(dep) or not callable(dep):
         return dep
 
-    return Annotated[Any, Depends(dep)]
+    return annotated(Any, Depends(dep))
 
 
 def signature_with_deps(

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/fastapi_injected/_cache.py

@@ -5,6 +5,7 @@ from typing import Any
 from fastapi.dependencies.models import Dependant
 from fastapi.types import DependencyCacheKey
 
+from ._calls import unwrap_proxy
 from ._dataclass import MakeDataclass
 from .types import DependencyCache
 
@@ -16,13 +17,14 @@ def overridden_calls(dependant: Dependant, overrides: Collection[Any], /) -> fro
     overridden: set[Any] = set()
 
     def _visit(dep: Dependant, /) -> bool:
-        is_overridden = dep.call is not None and dep.call in overrides
+        call = unwrap_proxy(dep.call)
+        is_overridden = call is not None and call in overrides
 
         for sub_dep in dep.dependencies:
             is_overridden = _visit(sub_dep) or is_overridden
 
-        if is_overridden and dep.call is not None:
-            overridden.add(dep.call)
+        if is_overridden and call is not None:
+            overridden.add(call)
 
         return is_overridden
 
@@ -30,6 +32,14 @@ def overridden_calls(dependant: Dependant, overrides: Collection[Any], /) -> fro
     return frozenset(overridden)
 
 
+def _cache_key(key: DependencyCacheKey, /) -> DependencyCacheKey:
+    # kept under the call a proxy stands for: the proxy is released once its resolve is
+    # done, the entry has to stay reachable for the rest of the scope
+    call, *rest = key
+
+    return (unwrap_proxy(call), *rest)  # type: ignore[ty:invalid-return-type]
+
+
 class ScopeCache(MakeDataclass, MutableMapping[DependencyCacheKey, Any]):
     cache: DependencyCache
     fallbacks: Sequence[tuple[Mapping[DependencyCacheKey, Any], frozenset[Any]]] = field(default_factory=tuple)
@@ -42,6 +52,8 @@ class ScopeCache(MakeDataclass, MutableMapping[DependencyCacheKey, Any]):
                 yield cache
 
     def __getitem__(self, key: DependencyCacheKey) -> Any:
+        key = _cache_key(key)
+
         try:
             return self.cache[key]
         except KeyError:
@@ -56,10 +68,10 @@ class ScopeCache(MakeDataclass, MutableMapping[DependencyCacheKey, Any]):
         raise KeyError(key)
 
     def __setitem__(self, key: DependencyCacheKey, value: Any) -> None:
-        self.cache[key] = value
+        self.cache[_cache_key(key)] = value
 
     def __delitem__(self, key: DependencyCacheKey) -> None:
-        del self.cache[key]
+        del self.cache[_cache_key(key)]
 
     def __iter__(self) -> Iterator[DependencyCacheKey]:
         seen = set(self.cache)

fastapi_injected-0.3.5/fastapi_injected/_calls.py

@@ -0,0 +1,192 @@
+import dataclasses
+import inspect
+import typing
+from collections.abc import Callable, Iterator, Mapping
+from typing import Any, get_args, get_origin
+
+from fastapi.dependencies.utils import get_typed_signature
+from fastapi.params import Depends
+
+from ._deps_tp import unwrap_tp
+
+
+def annotated(tp: Any, /, *metadata: Any) -> Any:
+    # `Annotated[...]` goes through typing's own cache, which holds on to the last
+    # aliases it built - and with them whatever value a runtime marker carries
+    return typing._AnnotatedAlias(tp, metadata)  # type: ignore[ty:unresolved-attribute] # noqa: SLF001
+
+
+def is_static_call(call: Any, /) -> bool:
+    # what source code wrote down lives as long as the process anyway, so caching
+    # by it keeps nothing extra alive - an instance or a closure may carry request data
+    if inspect.isclass(call):
+        return True
+
+    # a builtin bound to an instance, like `cache.get`, carries that instance along
+    if inspect.isbuiltin(call):
+        return call.__self__ is None or inspect.ismodule(call.__self__)
+
+    # `__qualname__` is what `functools.wraps` copied over, the code knows where it was defined
+    if inspect.isfunction(call):
+        return "<locals>" not in call.__code__.co_qualname
+
+    return False
+
+
+def _depends_metadata(annotation: Any, /) -> tuple[Any, list[Any]] | None:
+    annotation = unwrap_tp(annotation)
+
+    if get_origin(annotation) is not typing.Annotated:
+        return None
+
+    tp, *metadata = get_args(annotation)
+
+    return tp, metadata
+
+
+def is_static_annotation(annotation: Any, /) -> bool:
+    match _depends_metadata(annotation):
+        case (tp, metadata):
+            return all(
+                is_static_call(tp if meta.dependency is None else meta.dependency)
+                for meta in metadata
+                if isinstance(meta, Depends)
+            )
+        case _:
+            return False
+
+
+class CallProxy:
+    # what FastAPI is handed in place of a call made at runtime: its classification
+    # caches keep every call they are shown, and once released this is all they keep
+    __slots__ = ("_hash", "_proxies", "_signature", "call")
+
+    def __init__(self, call: Callable[..., Any], proxies: list["CallProxy"], /) -> None:
+        self.call: Callable[..., Any] | None = call
+        self._proxies = proxies
+        self._signature: inspect.Signature | None = None
+
+        try:
+            self._hash = hash(call)
+        except TypeError:
+            self._hash = id(call)
+
+        proxies.append(self)
+
+    @property
+    def __wrapped__(self) -> Callable[..., Any]:
+        # FastAPI unwraps a call to tell a coroutine from a generator, so it sees the
+        # real one - a released proxy has nothing left to show
+        if self.call is None:
+            raise AttributeError("__wrapped__")
+
+        return self.call
+
+    @property
+    def __signature__(self) -> inspect.Signature:
+        # FastAPI builds the dependencies of this call from its signature, so whatever
+        # was made at runtime among them is handed over behind a proxy as well
+        if self._signature is None:
+            sign = get_typed_signature(self.__wrapped__)
+            self._signature = sign.replace(
+                parameters=[self._detach_param(param) for param in sign.parameters.values()],
+            )
+
+        return self._signature
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.__wrapped__(*args, **kwargs)
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def __eq__(self, other: object) -> bool:
+        # equal to the call it stands for, so it finds the same cache entries and overrides
+        if self.call is None:
+            return other is self
+
+        return self.call == unwrap_proxy(other)
+
+    def release(self) -> None:
+        self.call = None
+        self._signature = None
+        self._proxies = []
+
+    def _detach_depends(self, depends: Depends, /) -> Depends:
+        if depends.dependency is None or is_static_call(depends.dependency):
+            return depends
+
+        return dataclasses.replace(depends, dependency=CallProxy(depends.dependency, self._proxies))
+
+    def _detach_param(self, param: inspect.Parameter, /) -> inspect.Parameter:
+        if isinstance(param.default, Depends):
+            param = param.replace(default=self._detach_depends(param.default))
+
+        match _depends_metadata(param.annotation):
+            case (tp, metadata):
+                detached = [self._detach_depends(meta) if isinstance(meta, Depends) else meta for meta in metadata]
+
+                if any(new is not old for new, old in zip(detached, metadata, strict=True)):
+                    param = param.replace(annotation=annotated(tp, *detached))
+
+        return param
+
+
+class DetachedOverrides(Mapping[Any, Any]):
+    # an override replaces a call inside FastAPI, past where a proxy could be put on it,
+    # so the overrides of a resolve hand out what they hold behind one
+    __slots__ = ("_handed", "_overrides", "_proxies")
+
+    def __init__(self, overrides: Mapping[Any, Any], proxies: list[CallProxy], /) -> None:
+        self._overrides = overrides
+        self._proxies = proxies
+        self._handed: dict[int, CallProxy] = {}
+
+    @property
+    def dependency_overrides(self) -> Mapping[Any, Any]:
+        # FastAPI asks a provider for its overrides, and this is both
+        return self
+
+    def __getitem__(self, key: Any) -> Any:
+        override = self._overrides[key]
+
+        if is_static_call(override):
+            return override
+
+        if (proxy := self._handed.get(id(override))) is None:
+            proxy = self._handed[id(override)] = CallProxy(override, self._proxies)
+
+        return proxy
+
+    def __iter__(self) -> Iterator[Any]:
+        return iter(self._overrides)
+
+    def __len__(self) -> int:
+        return len(self._overrides)
+
+    def __bool__(self) -> bool:
+        # FastAPI takes the override path only when there are some, and asks at every step
+        return bool(self._overrides)
+
+
+def release(proxies: list[CallProxy], /) -> None:
+    for proxy in proxies:
+        proxy.release()
+
+
+def unwrap_proxy(call: Any, /) -> Any:
+    if isinstance(call, CallProxy) and call.call is not None:
+        return call.call
+
+    return call
+
+
+__all__ = [
+    "CallProxy",
+    "DetachedOverrides",
+    "annotated",
+    "is_static_annotation",
+    "is_static_call",
+    "release",
+    "unwrap_proxy",
+]

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/fastapi_injected/_given.py

@@ -1,7 +1,8 @@
-from typing import Annotated, Any, cast
+from typing import Any, cast
 
 from fastapi import Depends
 
+from ._calls import annotated
 from ._dataclass import MakeDataclass
 from .types import DepOf
 
@@ -16,7 +17,7 @@ class _Constant[R](MakeDataclass):
 def Given[R](value: R, /) -> DepOf[R]:  # noqa: N802
     # a dependency that was already resolved by whoever built it - constants that hold
     # the same value are the same dependency, so they are cached and overridden alike
-    return cast("DepOf[R]", Annotated[Any, Depends(_Constant(value))])
+    return cast("DepOf[R]", annotated(Any, Depends(_Constant(value))))
 
 
 __all__ = [

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/fastapi_injected/deps.py

@@ -1,14 +1,15 @@
 import inspect
-from collections.abc import Callable
-from contextlib import AsyncExitStack
+from collections.abc import Callable, Iterator
+from contextlib import AsyncExitStack, contextmanager
 from functools import lru_cache, wraps
-from typing import Annotated, Any, Literal, Protocol, cast, overload, runtime_checkable
+from typing import Any, Literal, Protocol, cast, overload, runtime_checkable
 
 from fastapi import Depends, params
 from fastapi.dependencies.models import Dependant
 from fastapi.dependencies.utils import get_dependant, get_typed_signature, solve_dependencies
 from fastapi.exceptions import RequestValidationError
 
+from ._calls import CallProxy, DetachedOverrides, annotated, is_static_annotation, release
 from ._deps_tp import is_dep, unwrap_tp
 from .scope import InjectScope
 from .sign import prepare_sign, update_func_sign
@@ -55,25 +56,41 @@ def create_dependant[**P, R](func: Callable[P, Coro[R]], /) -> Dependant:
     )
 
 
-def create_single_dependant[**P, R](
+@contextmanager
+def single_dependant[**P, R](
     func: Callable[P, R] | HasDependsHook[P, R],
     /,
     *,
     path: str | None = None,
-) -> Dependant:
+) -> Iterator[Dependant]:
     match func:
         case _ if is_dep(func):
             annotation = unwrap_tp(func)
         case HasDependsHook():
-            annotation = Annotated[Any, func.__get_depends__()]
+            annotation = annotated(Any, func.__get_depends__())
         case _:
-            annotation = Annotated[Any, Depends(func)]
+            annotation = annotated(Any, Depends(func))
 
-    return _create_annotation_dependant(annotation, path=path)
+    if is_static_annotation(annotation):
+        yield _create_annotation_dependant(annotation, path=path)
+        return
 
+    # a dependency made at runtime is analysed again on every resolve, and FastAPI only
+    # ever sees its calls behind proxies released here - caching either would keep
+    # whatever it carries alive past the request
+    proxies: list[CallProxy] = []
+    dependant = get_dependant(
+        path=path or "",
+        call=CallProxy(_value_factory(annotation), proxies),
+    )
 
-@lru_cache(maxsize=1024)
-def _create_annotation_dependant(annotation: Any, /, *, path: str | None = None) -> Dependant:
+    try:
+        yield dependant
+    finally:
+        release(proxies)
+
+
+def _value_factory(annotation: Any, /) -> Callable[..., Coro[Any]]:
     async def _factory(__value__: Any) -> Any:
         return __value__
 
@@ -88,9 +105,14 @@ def _create_annotation_dependant(annotation: Any, /, *, path: str | None = None)
         return_annotation=Any,
     )
 
+    return _factory
+
+
+@lru_cache(maxsize=1024)
+def _create_annotation_dependant(annotation: Any, /, *, path: str | None = None) -> Dependant:
     return get_dependant(
         path=path or "",
-        call=_factory,
+        call=_value_factory(annotation),
     )
 
 
@@ -122,16 +144,21 @@ async def resolve_dependencies(
     *,
     single: bool = False,
 ) -> dict[str, Any]:
-    async with scope.lock:
-        solved = await solve_dependencies(
-            request=scope.bound_request,
-            dependant=dependant,
-            dependency_cache=cast("DependencyCache", scope.cache_for(dependant)),
-            dependency_overrides_provider=scope,
-            # this parameter is deprecated and not used
-            async_exit_stack=cast(AsyncExitStack, None),
-            embed_body_fields=False,
-        )
+    proxies: list[CallProxy] = []
+
+    try:
+        async with scope.lock:
+            solved = await solve_dependencies(
+                request=scope.bound_request,
+                dependant=dependant,
+                dependency_cache=cast("DependencyCache", scope.cache_for(dependant)),
+                dependency_overrides_provider=DetachedOverrides(scope.dependency_overrides, proxies),
+                # this parameter is deprecated and not used
+                async_exit_stack=cast(AsyncExitStack, None),
+                embed_body_fields=False,
+            )
+    finally:
+        release(proxies)
 
     if solved.errors:
         raise DependencyResolutionError(solved.errors)
@@ -151,6 +178,6 @@ __all__ = [
     "MissedDependencyError",
     "clear_dependant_cache",
     "create_dependant",
-    "create_single_dependant",
     "resolve_dependencies",
+    "single_dependant",
 ]

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/fastapi_injected/resolve.py

@@ -3,7 +3,7 @@ from typing import Any, overload
 
 from typing_extensions import TypeForm
 
-from .deps import HasDependsHook, create_single_dependant, resolve_dependencies
+from .deps import HasDependsHook, resolve_dependencies, single_dependant
 from .scope import inside_inject_scope
 from .types import DepDecl, DepShape
 
@@ -50,16 +50,12 @@ async def resolve(
     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,
-        )
+        with single_dependant(tp, path=inject_scope.path_format) as dependant:
+            return await resolve_dependencies(
+                dependant,
+                inject_scope,
+                single=True,
+            )
 
 
 __all__ = [

{fastapi_injected-0.3.4 → fastapi_injected-0.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-injected"
-version = "0.3.4"
+version = "0.3.5"
 description = "Yet another library to reuse fastapi dependency injection"
 authors = [
     { name = "Yurii Karabas", email = "1998uriyyo@gmail.com" },

fastapi_injected-0.3.5/tests/test_calls.py

@@ -0,0 +1,117 @@
+import inspect
+from functools import wraps
+from typing import Annotated, Any
+
+import pytest
+from fastapi import Depends
+
+from fastapi_injected import push_inject_scope, resolve
+from fastapi_injected._calls import CallProxy, DetachedOverrides, is_static_annotation, is_static_call
+
+pytestmark = pytest.mark.asyncio
+
+
+def module_level() -> int:
+    return 1
+
+
+def _closure() -> Any:
+    def inner() -> int:  # pragma: no cover
+        return 1
+
+    return inner
+
+
+def _wrapped() -> Any:
+    @wraps(module_level)
+    def wrapper() -> int:  # pragma: no cover
+        return 1
+
+    return wrapper
+
+
+class Unhashable:
+    __hash__ = None  # type: ignore[assignment]
+
+    def __call__(self) -> int:
+        return 1
+
+
+@pytest.mark.parametrize(
+    ("call", "expected"),
+    [
+        pytest.param(module_level, True, id="function"),
+        pytest.param(Unhashable, True, id="class"),
+        pytest.param(len, True, id="builtin"),
+        pytest.param(_closure(), False, id="closure"),
+        # `functools.wraps` copies the name of a function written at module level
+        pytest.param(_wrapped(), False, id="wrapped-closure"),
+        pytest.param({}.get, False, id="bound-builtin"),
+        pytest.param(Unhashable(), False, id="instance"),
+    ],
+)
+async def test_what_counts_as_written_in_source(call: Any, expected: bool):
+    assert is_static_call(call) is expected
+
+
+async def test_an_annotation_without_metadata_is_not_static():
+    assert not is_static_annotation(int)
+
+
+async def test_a_released_proxy_lets_go_of_its_call():
+    proxy = CallProxy(module_level, [])
+    proxy.release()
+
+    assert proxy.call is None
+    assert not hasattr(proxy, "__wrapped__")
+    assert proxy == proxy  # noqa: PLR0124
+    assert proxy != module_level
+
+
+async def test_a_proxy_of_an_unhashable_call_is_hashed_by_identity():
+    call = Unhashable()
+    proxy = CallProxy(call, [])
+
+    assert hash(proxy) == id(call)
+    assert proxy() == 1
+
+
+class One:
+    def __call__(self) -> int:
+        return 1
+
+
+class Defaulted:
+    # a dependency that is an object, written as a default rather than in the annotation
+    def __init__(self, value: int) -> None:
+        self.value = value
+
+    async def __call__(self, one: int = Depends(One())) -> int:
+        return self.value + one
+
+
+async def test_a_dependency_written_as_a_default_is_detached_too():
+    async with push_inject_scope():
+        assert await resolve(Defaulted(41)) == 42
+
+
+async def test_a_proxy_shows_fastapi_the_signature_it_stands_for():
+    async def call(value: Annotated[int, Depends(module_level)]) -> int:  # pragma: no cover
+        return value
+
+    # FastAPI reads the parameters only, its own typed signature drops the return annotation
+    assert inspect.signature(CallProxy(call, [])).parameters == inspect.signature(call).parameters
+
+
+async def test_detached_overrides_hand_out_what_was_made_at_runtime_behind_a_proxy():
+    value = One()
+    proxies: list[CallProxy] = []
+    overrides = DetachedOverrides({module_level: value, One: module_level}, proxies)
+
+    assert overrides.dependency_overrides is overrides
+    assert (list(overrides), len(overrides), bool(overrides)) == ([module_level, One], 2, True)
+    assert overrides[One] is module_level  # written in source, nothing to detach
+    assert overrides[module_level] is overrides[module_level]
+    assert overrides[module_level] == value
+    assert proxies == [value]
+    assert not DetachedOverrides({}, [])