fastapi-injected 0.3.1__tar.gz → 0.3.3__tar.gz

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-injected
-Version: 0.3.1
+Version: 0.3.3
 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>
@@ -253,18 +253,6 @@ class Config(MakeDataclass, frozen=True, kw_only=True):
     retries: int = 3
 ```
 
-The same is true of what holds a dependency. FastAPI's `Depends` and `Security` are frozen dataclasses, so they hash by field — and `Security(get_user, scopes=["items:read"])`, the documented spelling, holds a list, which makes the whole annotation unhashable and fails as a bare `TypeError` from `typing`. `fastapi_injected` ships both as `MakeDataclass` subclasses, which is the same class in every way that matters to FastAPI, and one that can be cached:
-
-```python
-from fastapi_injected import Security, resolve
-
-type CurrentUser = Annotated[User, Security(get_user, scopes=["items:read"])]
-
-await resolve(CurrentUser)
-```
-
-Scopes are kept as a tuple, so the same scopes written as another list stay one dependency. Everything the package builds internally is held this way too, so a dependency object that cannot be hashed by fields no longer decides whether the annotation around it can be.
-
 ### When resolution fails
 
 A dependency can fail to resolve for the same reasons it would in a route — a missing header, a query parameter that does not validate. `DependencyResolutionError` carries those errors in the shape pydantic produced them, and turns into the response FastAPI would have returned:
@@ -369,7 +357,7 @@ Everything the package supports is importable from `fastapi_injected` itself, an
 
 | | |
 | --- | --- |
-| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected`, `Depends`, `Security` |
+| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected` |
 | Resolving | `inject`, `resolve`, `bind_deps`, `signature_with_deps`, `remap_dep_args`, `clear_dependant_cache` |
 | Scopes and overrides | `InjectScope`, `push_inject_scope`, `inside_inject_scope`, `push_overrides`, `Overrides`, `OverridesProvider`, `ValueOverride`, `FactoryOverride` |
 | Building on top | `MakeDataclass`, `MakeInjected`, `HasDependsHook`, `ArgMarker`, `is_arg`, `is_dep`, `unwrap_dep_tp`, `unwrap_dep_dependency` |

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/README.md

@@ -232,18 +232,6 @@ class Config(MakeDataclass, frozen=True, kw_only=True):
     retries: int = 3
 ```
 
-The same is true of what holds a dependency. FastAPI's `Depends` and `Security` are frozen dataclasses, so they hash by field — and `Security(get_user, scopes=["items:read"])`, the documented spelling, holds a list, which makes the whole annotation unhashable and fails as a bare `TypeError` from `typing`. `fastapi_injected` ships both as `MakeDataclass` subclasses, which is the same class in every way that matters to FastAPI, and one that can be cached:
-
-```python
-from fastapi_injected import Security, resolve
-
-type CurrentUser = Annotated[User, Security(get_user, scopes=["items:read"])]
-
-await resolve(CurrentUser)
-```
-
-Scopes are kept as a tuple, so the same scopes written as another list stay one dependency. Everything the package builds internally is held this way too, so a dependency object that cannot be hashed by fields no longer decides whether the annotation around it can be.
-
 ### When resolution fails
 
 A dependency can fail to resolve for the same reasons it would in a route — a missing header, a query parameter that does not validate. `DependencyResolutionError` carries those errors in the shape pydantic produced them, and turns into the response FastAPI would have returned:
@@ -348,7 +336,7 @@ Everything the package supports is importable from `fastapi_injected` itself, an
 
 | | |
 | --- | --- |
-| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected`, `Depends`, `Security` |
+| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected` |
 | Resolving | `inject`, `resolve`, `bind_deps`, `signature_with_deps`, `remap_dep_args`, `clear_dependant_cache` |
 | Scopes and overrides | `InjectScope`, `push_inject_scope`, `inside_inject_scope`, `push_overrides`, `Overrides`, `OverridesProvider`, `ValueOverride`, `FactoryOverride` |
 | Building on top | `MakeDataclass`, `MakeInjected`, `HasDependsHook`, `ArgMarker`, `is_arg`, `is_dep`, `unwrap_dep_tp`, `unwrap_dep_dependency` |

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/fastapi_injected/__init__.py

@@ -4,7 +4,6 @@ from ._deps_tp import is_arg, is_dep, unwrap_dep_dependency, unwrap_dep_tp
 from ._fastapi_lifecycle import MissingDependencyCacheError, add_injected_scope, init_inject_scope
 from ._given import Given
 from ._injected import MakeInjected
-from ._params import Depends, Security
 from .deps import (
     DependencyResolutionError,
     HasDependsHook,
@@ -25,7 +24,6 @@ __all__ = [
     "DepFactory",
     "DepOf",
     "DependencyResolutionError",
-    "Depends",
     "FactoryOverride",
     "Given",
     "HasDependsHook",
@@ -38,7 +36,6 @@ __all__ = [
     "NotADependencyError",
     "Overrides",
     "OverridesProvider",
-    "Security",
     "UnboundDepArgsError",
     "UnboundScopeError",
     "ValueOverride",

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/fastapi_injected/_bind.py

@@ -1,13 +1,12 @@
 import inspect
 from collections.abc import Callable, Sequence
 from functools import wraps
-from typing import Annotated, Any, Concatenate, overload
+from typing import Annotated, Any, Concatenate, get_origin, overload
 
-from fastapi import params
 from fastapi.dependencies.utils import get_typed_signature
+from fastapi.params import Depends
 
-from ._deps_tp import is_dep
-from ._params import Depends
+from ._deps_tp import unwrap_tp
 from .sign import update_func_sign
 from .types import AsyncFunc, DepOf, Func
 
@@ -34,13 +33,15 @@ def _dep_arg_index(name: str, /) -> int | None:
     return int(index) if index.isdigit() else None
 
 
+def _is_annotation(tp: Any, /) -> bool:
+    return get_origin(unwrap_tp(tp)) is Annotated
+
+
 def _dep_annotation(dep: DepOf[Any] | Callable[..., Any], /) -> Any:
-    if isinstance(dep, params.Depends):
+    if isinstance(dep, Depends):
         return Annotated[Any, dep]
 
-    # a marker is an annotation already, while a callable is a dependency the same way
-    # `resolve` takes one - anything else is left as it was written
-    if is_dep(dep) or not callable(dep):
+    if _is_annotation(dep) or not callable(dep):
         return dep
 
     return Annotated[Any, Depends(dep)]

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/fastapi_injected/_given.py

@@ -1,7 +1,8 @@
 from typing import Annotated, Any, cast
 
+from fastapi import Depends
+
 from ._dataclass import MakeDataclass
-from ._params import Depends
 from .types import DepOf
 
 

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/fastapi_injected/deps.py

@@ -4,13 +4,12 @@ from contextlib import AsyncExitStack
 from functools import lru_cache, wraps
 from typing import Annotated, Any, Literal, Protocol, cast, overload, runtime_checkable
 
-from fastapi import params
+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 ._deps_tp import is_dep, unwrap_tp
-from ._params import Depends
 from .scope import InjectScope
 from .sign import prepare_sign, update_func_sign
 from .types import Coro, DependencyCache, HasSignature

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/fastapi_injected/types.py

@@ -2,11 +2,10 @@ import inspect
 from collections.abc import AsyncIterator, Callable, Coroutine, Iterator, Mapping
 from typing import TYPE_CHECKING, Annotated, Any, Protocol, TypeVar, runtime_checkable
 
+from fastapi import Depends
 from fastapi.types import DependencyCacheKey
 from typing_extensions import TypeForm, sentinel
 
-from ._params import Depends
-
 if TYPE_CHECKING:
     Injected: Any = object()
 else:

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/pyproject.toml

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

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/tests/test_bind.py

@@ -2,9 +2,19 @@ from dataclasses import dataclass
 from typing import Annotated, Any
 
 import pytest
-from fastapi import Depends
-
-from fastapi_injected import Given, bind_deps, inject, push_inject_scope, push_overrides, resolve, signature_with_deps
+from fastapi import Depends, FastAPI, Header
+from fastapi.testclient import TestClient
+
+from fastapi_injected import (
+    Given,
+    bind_deps,
+    init_inject_scope,
+    inject,
+    push_inject_scope,
+    push_overrides,
+    resolve,
+    signature_with_deps,
+)
 from fastapi_injected._bind import UnboundDepArgsError, dep_arg_name, remap_dep_args, take_dep_args
 
 pytestmark = pytest.mark.asyncio
@@ -87,6 +97,30 @@ async def test_a_dependency_can_be_bound_however_it_is_written(dep):
     assert await resolve(bind_deps(describe, Given(Doc()), dep)) == "readme:admin"
 
 
+TitleHeader = Annotated[str, Header(alias="x-title")]
+
+
+async def titled(title: str, role: Role) -> str:
+    return f"{title}:{role.name}"
+
+
+async def test_a_request_marker_is_bound_as_written() -> None:
+    sign = signature_with_deps(titled, TitleHeader, RoleDep)
+
+    assert next(iter(sign.parameters.values())).annotation == TitleHeader
+
+
+async def test_a_request_marker_resolves_from_the_request() -> None:
+    app = FastAPI(dependencies=[Depends(init_inject_scope)])
+
+    @app.get("/marker")
+    async def _route(described: Annotated[str, Depends(bind_deps(titled, TitleHeader, RoleDep))]) -> str:
+        return described
+
+    with TestClient(app) as client:
+        assert client.get("/marker", headers={"x-title": "readme"}).json() == "readme:admin"
+
+
 async def test_signature_with_deps_names_the_bound_parameters() -> None:
     sign = signature_with_deps(describe, Given(Doc()), RoleDep)
 

{fastapi_injected-0.3.1 → fastapi_injected-0.3.3}/uv.lock

@@ -186,7 +186,7 @@ wheels = [
 
 [[package]]
 name = "fastapi-injected"
-version = "0.3.1"
+version = "0.3.3"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },

fastapi_injected-0.3.1/fastapi_injected/_params.py

@@ -1,19 +0,0 @@
-from fastapi import params
-
-from ._dataclass import MakeDataclass
-
-
-class Depends(MakeDataclass, params.Depends, frozen=True):
-    pass
-
-
-class Security(Depends, params.Security, frozen=True):
-    def __post_init__(self) -> None:
-        if self.scopes is not None:
-            object.__setattr__(self, "scopes", tuple(self.scopes))
-
-
-__all__ = [
-    "Depends",
-    "Security",
-]

fastapi_injected-0.3.1/tests/_typing/params.py

@@ -1,30 +0,0 @@
-from typing import Annotated
-
-from fastapi import params
-
-from fastapi_injected import Depends, Security
-
-from .deps import (
-    ContextState,
-    ctx_dep,
-    is_assignable_to,
-    is_subtype_of,
-    static_assert,
-)
-
-# they are the fastapi params they wrap, so anything taking one takes these
-static_assert(is_subtype_of(Depends, params.Depends))
-static_assert(is_subtype_of(Security, params.Security))
-static_assert(is_subtype_of(Security, Depends))
-static_assert(is_assignable_to(Annotated[ContextState, Security(ctx_dep, scopes=["me"])], ContextState))
-
-
-def _params() -> None:
-    Depends()
-    Depends(ctx_dep, use_cache=False)
-    Security(ctx_dep, scopes=["me"], use_cache=False)
-
-
-def _negatives() -> None:
-    Depends(use_cache="yes")  # type: ignore[ty:invalid-argument-type]
-    Security(ctx_dep, scopes=1)  # type: ignore[ty:invalid-argument-type]

fastapi_injected-0.3.1/tests/test_params.py

@@ -1,78 +0,0 @@
-from typing import Annotated
-
-import pytest
-from fastapi import params
-from fastapi.security import SecurityScopes
-
-from fastapi_injected import Depends, Security, is_dep, push_inject_scope, resolve
-
-
-async def scopes_dep(scopes: SecurityScopes) -> list[str]:
-    return scopes.scopes
-
-
-class Unhashable:
-    __hash__ = None  # type: ignore[ty:invalid-assignment]
-
-    async def __call__(self) -> str:
-        return "value"
-
-
-def test_they_are_fastapi_params():
-    assert isinstance(Depends(scopes_dep), params.Depends)
-    assert isinstance(Security(scopes_dep), params.Security)
-    assert isinstance(Security(scopes_dep), params.Depends)
-
-
-def test_scopes_are_written_as_documented():
-    security = Security(scopes_dep, scopes=["items:read"])
-
-    assert security.scopes == ("items:read",)
-    assert is_dep(Annotated[list[str], security])
-
-
-def test_equal_params_hash_equally():
-    assert hash(Depends(scopes_dep)) == hash(Depends(scopes_dep))
-    assert Security(scopes_dep, scopes=["me"]) == Security(scopes_dep, scopes=["me"])
-    assert hash(Security(scopes_dep, scopes=["me"])) == hash(Security(scopes_dep, scopes=("me",)))
-
-
-def test_a_scoped_annotation_can_be_hashed():
-    # the annotation is the key a dependant is cached by, and a list of scopes used to break it
-    assert hash(Annotated[list[str], Security(scopes_dep, scopes=["items:read", "me"])])
-
-    with pytest.raises(TypeError, match="unhashable type: 'list'"):
-        hash(Annotated[list[str], params.Security(scopes_dep, scopes=["items:read", "me"])])
-
-
-def test_unhashable_dependencies_fall_back_to_identity():
-    depends = Depends(Unhashable())
-
-    assert hash(depends) == object.__hash__(depends)
-    assert hash(Annotated[str, depends])
-
-
-@pytest.mark.asyncio
-async def test_a_scoped_dependency_resolves():
-    scoped = Annotated[list[str], Security(scopes_dep, scopes=["items:read", "me"])]
-
-    assert await resolve(scoped) == ["items:read", "me"]
-
-
-@pytest.mark.asyncio
-async def test_equal_params_are_one_dependency():
-    calls = 0
-
-    async def counted() -> int:
-        nonlocal calls
-        calls += 1
-        return calls
-
-    async with push_inject_scope():
-        assert await resolve(Annotated[int, Security(counted, scopes=["me"])]) == 1
-        # the same scopes written as another list are the same dependency, so it is cached
-        assert await resolve(Annotated[int, Security(counted, scopes=["me"])]) == 1
-        # different scopes are not
-        assert await resolve(Annotated[int, Security(counted, scopes=["other"])]) == 2
-
-    assert calls == 2