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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-injected
-Version: 0.3.0
+Version: 0.3.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>
@@ -253,6 +253,18 @@ 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:
@@ -357,7 +369,7 @@ Everything the package supports is importable from `fastapi_injected` itself, an
 
 | | |
 | --- | --- |
-| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected` |
+| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected`, `Depends`, `Security` |
 | 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.0 → fastapi_injected-0.3.1}/README.md

@@ -232,6 +232,18 @@ 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:
@@ -336,7 +348,7 @@ Everything the package supports is importable from `fastapi_injected` itself, an
 
 | | |
 | --- | --- |
-| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected` |
+| Markers | `Dep`, `DepFactory`, `DepOf`, `Arg`, `Given`, `Injected`, `Depends`, `Security` |
 | 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.0 → fastapi_injected-0.3.1}/fastapi_injected/__init__.py

@@ -4,6 +4,7 @@ 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,
@@ -24,6 +25,7 @@ __all__ = [
     "DepFactory",
     "DepOf",
     "DependencyResolutionError",
+    "Depends",
     "FactoryOverride",
     "Given",
     "HasDependsHook",
@@ -36,6 +38,7 @@ __all__ = [
     "NotADependencyError",
     "Overrides",
     "OverridesProvider",
+    "Security",
     "UnboundDepArgsError",
     "UnboundScopeError",
     "ValueOverride",

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

@@ -3,10 +3,11 @@ from collections.abc import Callable, Sequence
 from functools import wraps
 from typing import Annotated, Any, Concatenate, 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 .sign import update_func_sign
 from .types import AsyncFunc, DepOf, Func
 
@@ -34,7 +35,7 @@ def _dep_arg_index(name: str, /) -> int | None:
 
 
 def _dep_annotation(dep: DepOf[Any] | Callable[..., Any], /) -> Any:
-    if isinstance(dep, Depends):
+    if isinstance(dep, params.Depends):
         return Annotated[Any, dep]
 
     # a marker is an annotation already, while a callable is a dependency the same way

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

@@ -1,8 +1,7 @@
 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/_params.py

@@ -0,0 +1,19 @@
+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.0 → fastapi_injected-0.3.1}/fastapi_injected/deps.py

@@ -4,12 +4,13 @@ from contextlib import AsyncExitStack
 from functools import lru_cache, wraps
 from typing import Annotated, Any, Literal, Protocol, cast, overload, runtime_checkable
 
-from fastapi import Depends, params
+from fastapi import 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.0 → fastapi_injected-0.3.1}/fastapi_injected/types.py

@@ -2,10 +2,11 @@ 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.0 → fastapi_injected-0.3.1}/pyproject.toml

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

fastapi_injected-0.3.1/tests/_typing/params.py

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,78 @@
+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

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

@@ -186,7 +186,7 @@ wheels = [
 
 [[package]]
 name = "fastapi-injected"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },
@@ -249,11 +249,11 @@ wheels = [
 
 [[package]]
 name = "griffelib"
-version = "2.1.0"
+version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/33/e4/8d187ea29c2e30b3a09505c567513077d6117861bde1fbd997a167f262ec/griffelib-2.1.0.tar.gz", hash = "sha256:762a186d2c6fd6794d4ea20d428d597ffb857cb56b66421651cbba15bdd5e813", size = 216234, upload-time = "2026-06-19T12:05:42.278Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/b4/a767e91c606deefc447a96eaf59edd77397960b1d677dffd833ee8449831/griffelib-2.2.0.tar.gz", hash = "sha256:e1bc36fe9cd21d4b6b659b456346755e4cfdc5676c0a5214083126ee12612b3c", size = 227048, upload-time = "2026-08-16T14:04:58.383Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/d3/5268aeabf2ad82658c4e2ff3a060648d0f02f3926cb53247c0e4d0dab49e/griffelib-2.1.0-py3-none-any.whl", hash = "sha256:cc7b3d2d2865ad0b909fcc38086e3f554b5ea7acbaa7bbb7ecaa3f5dfb7d9f00", size = 142560, upload-time = "2026-06-19T12:05:38.742Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b6/f65ac785d4ac90dcf7c831ac6256f5dd4a19780f4e1575b2c0d6eeebe319/griffelib-2.2.0-py3-none-any.whl", hash = "sha256:d71c3bc2bbed9f958488634fe788b843a9f705d6d2838ca32cd6c25eeb64dfc4", size = 166779, upload-time = "2026-08-16T14:04:54.365Z" },
 ]
 
 [[package]]