fastapi-injected 0.1.0__py3-none-any.whl

fastapi_injected/__init__.py

@@ -0,0 +1,13 @@
+from .inject import inject
+from .scope import push_inject_scope
+from .solve import solve
+from .types import Dep, DepFactory, Inejected
+
+__all__ = [
+    "Dep",
+    "DepFactory",
+    "Inejected",
+    "inject",
+    "push_inject_scope",
+    "solve",
+]

fastapi_injected/deps.py

@@ -0,0 +1,158 @@
+import inspect
+from collections.abc import Callable
+from contextvars import ContextVar
+from copy import copy
+from functools import lru_cache, wraps
+from typing import Annotated, Any, Literal, cast, overload
+
+from fastapi import Depends
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import get_dependant, get_typed_signature
+from fastapi.dependencies.utils import solve_dependencies as _solve_dependencies
+from starlette.requests import Request
+from starlette.types import Message, Scope
+
+from .scope import InjectScope
+from .sign import prepare_sign, update_func_sign
+from .types import Coro, HasSignature
+
+
+def _dummy_scope() -> Scope:
+    return {
+        "type": "http",
+        "http_version": "1.1",
+        "query_string": b"",
+        "headers": [],
+    }
+
+
+def _dummy_request(
+    *,
+    extra_scope: Scope | None = None,
+) -> Request:
+    async def _dummy_receive() -> Message:
+        return {
+            "type": "http.request",
+            "body": b"",
+        }
+
+    async def _dummy_send(_: Message, /) -> None:
+        pass
+
+    scope = _dummy_scope()
+    if extra_scope:
+        scope.update(extra_scope)
+
+    return Request(
+        scope,
+        receive=_dummy_receive,
+        send=_dummy_send,
+    )
+
+
+@lru_cache(maxsize=1024)
+def create_dependant[**P, R](func: Callable[P, Coro[R]], /) -> Dependant:
+    @wraps(func)
+    async def __call(*args: P.args, **kwargs: P.kwargs) -> R:
+        return await func(*args, **kwargs)
+
+    update_func_sign(
+        __call,
+        prepare_sign(get_typed_signature(func)),
+    )
+
+    return get_dependant(
+        path="",
+        call=__call,
+    )
+
+
+@lru_cache(maxsize=1024)
+def create_single_dependant[**P, R](func: Callable[P, R], /) -> Dependant:
+    async def _factory(__value__: R) -> R:
+        return __value__
+
+    cast("HasSignature", _factory).__signature__ = inspect.Signature(
+        parameters=[
+            inspect.Parameter(
+                "__value__",
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=Annotated[Any, Depends(func)],
+            ),
+        ],
+        return_annotation=Any,
+    )
+
+    return get_dependant(
+        path="",
+        call=_factory,
+    )
+
+
+@overload
+async def solve_dependencies(
+    dependant: Dependant,
+    scope: InjectScope,
+    *,
+    single: Literal[False] = False,
+) -> dict[str, Any]: ...
+
+
+@overload
+async def solve_dependencies(
+    dependant: Dependant,
+    scope: InjectScope,
+    *,
+    single: Literal[True],
+) -> Any: ...
+
+
+async def solve_dependencies(
+    dependant: Dependant,
+    scope: InjectScope,
+    *,
+    single: bool = False,
+) -> dict[str, Any]:
+    solved = await _solve_dependencies(
+        request=_dummy_request(
+            extra_scope={
+                "fastapi_inner_astack": scope.request_astack,
+                "fastapi_function_astack": scope.func_astack,
+            },
+        ),
+        dependant=dependant,
+        async_exit_stack=scope.request_astack,
+        dependency_cache=copy(scope.dependency_cache),
+        dependency_overrides_provider=_dependency_override_provider.get(),
+        embed_body_fields=False,
+    )
+
+    scope.dependency_cache.update(solved.dependency_cache)
+
+    if solved.errors:
+        raise ValueError(solved.errors)
+
+    if single:
+        try:
+            return solved.values["__value__"]
+        except KeyError:
+            raise ValueError("No single dependency found") from None
+
+    return solved.values
+
+
+_dependency_override_provider: ContextVar[Any] = ContextVar(
+    "_dependency_override_provider",
+    default=None,
+)
+
+
+def set_inject_dependency_override_provider(provider: Any, /) -> None:
+    _dependency_override_provider.set(provider)
+
+
+__all__ = [
+    "create_dependant",
+    "set_inject_dependency_override_provider",
+    "solve_dependencies",
+]

fastapi_injected/inject.py

@@ -0,0 +1,55 @@
+from functools import partial, wraps
+from typing import overload
+
+from .deps import create_dependant, solve_dependencies
+from .scope import inside_inject_scope
+from .sign import strip_sign
+from .types import AsyncFunc, Decorator
+
+
+@overload
+def inject[**P, R](
+    func: AsyncFunc[P, R],
+    /,
+) -> AsyncFunc[P, R]:
+    pass
+
+
+@overload
+def inject[**P, R](
+    *,
+    new_scope: bool = False,
+) -> Decorator[P, R]:
+    pass
+
+
+def inject[**P, R](
+    func: AsyncFunc[P, R] | None = None,
+    /,
+    *,
+    new_scope: bool = False,
+) -> AsyncFunc[P, R] | Decorator[P, R]:
+    if func is None:
+        return partial(inject, new_scope=new_scope)  # type: ignore[ty:invalid-return-type]
+
+    dependant = create_dependant(func)
+
+    @wraps(func)
+    @strip_sign(dependant)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        async with inside_inject_scope(
+            new_scope=new_scope,
+        ) as inject_scope:
+            solved = await solve_dependencies(dependant, inject_scope)
+
+            for key, value in solved.items():
+                kwargs.setdefault(key, value)
+
+            return await func(*args, **kwargs)
+
+    return wrapper
+
+
+__all__ = [
+    "inject",
+]

fastapi_injected/scope.py

@@ -0,0 +1,75 @@
+from collections.abc import AsyncIterator
+from contextlib import (
+    AbstractAsyncContextManager,
+    AsyncExitStack,
+    asynccontextmanager,
+    nullcontext,
+)
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any
+
+from .types import DependencyCache
+
+
+@dataclass
+class InjectScope:
+    dependency_cache: DependencyCache
+    func_astack: AsyncExitStack
+    request_astack: AsyncExitStack
+
+
+_inject_scope: ContextVar[InjectScope | None] = ContextVar(
+    "_inject_scope",
+    default=None,
+)
+
+
+@asynccontextmanager
+async def push_inject_scope(
+    dependency_cache: DependencyCache | None = None,
+) -> AsyncIterator[InjectScope]:
+    async with AsyncExitStack() as stack:
+        scope = InjectScope(
+            dependency_cache or {},
+            stack,
+            stack,
+        )
+        token = _inject_scope.set(scope)
+
+        try:
+            yield scope
+        finally:
+            _inject_scope.reset(token)
+
+
+def current_inject_scope() -> InjectScope | None:
+    return _inject_scope.get()
+
+
+@asynccontextmanager
+async def inside_inject_scope(
+    *,
+    new_scope: bool = False,
+) -> AsyncIterator[InjectScope]:
+    scope = current_inject_scope()
+
+    _ctx: AbstractAsyncContextManager[Any]
+
+    if scope is None or new_scope:
+        stack = AsyncExitStack()
+        scope = await stack.enter_async_context(push_inject_scope())
+
+        _ctx = stack
+    else:
+        _ctx = nullcontext()
+
+    async with _ctx:
+        yield scope
+
+
+__all__ = [
+    "InjectScope",
+    "current_inject_scope",
+    "inside_inject_scope",
+]

fastapi_injected/sign.py

@@ -0,0 +1,61 @@
+import inspect
+from typing import cast
+
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import analyze_param
+
+from .types import Decorator, Func, HasSignature, Inejected
+
+
+def update_func_sign[**P, R](func: Func[P, R], sign: inspect.Signature) -> Func[P, R]:
+    cast("HasSignature", func).__signature__ = sign
+    return func
+
+
+def prepare_sign(sign: inspect.Signature) -> inspect.Signature:
+    def _update_param(param: inspect.Parameter) -> inspect.Parameter:
+        if param.default is Inejected:
+            param = param.replace(default=inspect.Parameter.empty)
+
+        return param
+
+    def _is_depends(param: inspect.Parameter) -> bool:
+        result = analyze_param(
+            param_name=param.name,
+            annotation=param.annotation,
+            value=param.default,
+            is_path_param=False,
+        )
+
+        return result.depends is not None
+
+    return sign.replace(
+        parameters=[_update_param(param) for param in sign.parameters.values() if _is_depends(param)],
+    )
+
+
+def strip_deps_from_sign(
+    sign: inspect.Signature,
+    dependent: Dependant,
+) -> inspect.Signature:
+    names = {param.name for param in dependent.dependencies}
+
+    return sign.replace(parameters=[param for param in sign.parameters.values() if param.name not in names])
+
+
+def strip_sign[**P, R](dependant: Dependant, /) -> Decorator[P, R]:
+    def decorator(func: Func[P, R]) -> Func[P, R]:
+        return update_func_sign(
+            func,
+            strip_deps_from_sign(inspect.signature(func), dependant),
+        )
+
+    return decorator
+
+
+__all__ = [
+    "prepare_sign",
+    "strip_deps_from_sign",
+    "strip_sign",
+    "update_func_sign",
+]

fastapi_injected/solve.py

@@ -0,0 +1,26 @@
+from typing_extensions import TypeForm
+
+from .deps import create_single_dependant, solve_dependencies
+from .scope import inside_inject_scope
+
+
+async def solve[R](
+    tp: TypeForm[R],
+    *,
+    new_scope: bool = False,
+) -> R:
+    dependant = create_single_dependant(tp)
+
+    async with inside_inject_scope(
+        new_scope=new_scope,
+    ) as inject_scope:
+        return await solve_dependencies(
+            dependant,
+            inject_scope,
+            single=True,
+        )
+
+
+__all__ = [
+    "solve",
+]

fastapi_injected/types.py

@@ -0,0 +1,62 @@
+import inspect
+from collections.abc import Callable, Coroutine
+from typing import TYPE_CHECKING, Annotated, Any, Protocol, TypeVar
+
+from fastapi import Depends
+from fastapi.types import DependencyCacheKey
+from typing_extensions import sentinel
+
+if TYPE_CHECKING:
+    Inejected: Any = object()
+else:
+    Inejected = sentinel("Injected")
+
+if TYPE_CHECKING:
+    type Dep[T] = Annotated[T, Depends()]
+else:
+    _T = TypeVar("_T")
+
+    Dep = Annotated[_T, Depends()]
+
+
+if TYPE_CHECKING:
+    from typing import Annotated as DepFactory
+else:
+
+    class DepFactory:
+        def __class_getitem__(cls, item: Any) -> Any:
+            match item:
+                case (tp, factory):
+                    return Annotated[tp, Depends(factory)]
+                case _:
+                    raise TypeError(f"Invalid item: {item}")
+
+
+type Coro[R] = Coroutine[Any, Any, R]
+
+type AsyncFunc[**P, R] = Callable[P, Coro[R]]
+type Func[**P, R] = Callable[P, R]
+
+type Decorator[**P, R] = Callable[
+    [Callable[P, R]],
+    Callable[P, R],
+]
+
+type DependencyCache = dict[DependencyCacheKey, Any]
+
+
+class HasSignature(Protocol):
+    __signature__: inspect.Signature
+
+
+__all__ = [
+    "AsyncFunc",
+    "Coro",
+    "Decorator",
+    "Dep",
+    "DepFactory",
+    "DependencyCache",
+    "Func",
+    "HasSignature",
+    "Inejected",
+]

fastapi_injected-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: fastapi-injected
+Version: 0.1.0
+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>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.139.2
+Description-Content-Type: text/markdown
+
+# fastapi-injected
+
+Yet another attempt to reuse FastAPI's dependency injection outside of request handlers.
+
+This is an opinionated library: it takes the DI machinery you already know from FastAPI (`Depends`, generator dependencies with teardown, dependency caching) and makes it usable in plain async functions — background jobs, CLI commands, workers, scripts — without a `Request` in sight.
+
+## Installation
+
+```sh
+pip install fastapi-injected
+```
+
+Requires Python 3.12+.
+
+## Usage
+
+Declare dependencies as regular classes and annotate fields with `Dep[...]`:
+
+```python
+from dataclasses import dataclass
+from typing import AsyncIterator
+
+from fastapi_injected import Dep, DepFactory, Inejected, inject
+
+
+@dataclass
+class Session:
+    closed: bool = False
+
+
+async def session_dep() -> AsyncIterator[Session]:
+    session = Session()
+    try:
+        yield session
+    finally:
+        session.closed = True
+
+
+@dataclass
+class Repository:
+    session: DepFactory[Session, session_dep]
+
+
+@dataclass
+class Service:
+    repo: Dep[Repository]
+
+
+@inject
+async def handler(*, service: Dep[Service] = Inejected) -> None:
+    ...  # service is built and injected, session is closed on exit
+
+
+await handler()
+```
+
+- `Dep[T]` — resolve `T` by calling it, same as FastAPI's `Annotated[T, Depends()]`.
+- `DepFactory[T, factory]` — resolve `T` via a factory, same as `Annotated[T, Depends(factory)]`. Generator factories get proper teardown.
+- `Inejected` — a sentinel default that exists purely to make type checkers happy: without it they would complain about a missing argument at call sites. At runtime the parameter is always filled in by `@inject`.
+
+Injected parameters mix freely with regular ones — pass your own arguments as usual and the rest is injected:
+
+```python
+@inject
+async def add(a: int, b: int, *, service: Dep[Service] = Inejected) -> int:
+    ...
+
+
+result = await add(1, 2)
+```
+
+### Solving a type directly
+
+No decorator needed — resolve a dependency graph on demand:
+
+```python
+from fastapi_injected import solve
+
+service = await solve(Service)
+```
+
+### Scopes and caching
+
+By default every call to an injected function gets its own scope: dependencies are built, cached within the call, and torn down when it returns. Wrap several calls in `push_inject_scope()` to share one cache (and defer teardown to the end of the scope):
+
+```python
+from fastapi_injected import push_inject_scope
+
+async with push_inject_scope():
+    a = await handler()  # dependencies built here
+    b = await handler()  # same instances reused
+# generator dependencies are torn down here
+```
+
+Use `@inject(new_scope=True)` to opt a function out of the surrounding scope and always get fresh dependencies.
+
+## License
+
+MIT

fastapi_injected-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fastapi_injected/__init__.py,sha256=FCIqhlzoaXEFvCgRpp4Gh_TPE9y_XJJ9YnDs2HY9C1o,248
+fastapi_injected/deps.py,sha256=2YaeVI_JifdCDaqPrNzKK5MC7UC0-Iljo7pD73qphUY,3819
+fastapi_injected/inject.py,sha256=oGymgj6pKi5k3FEjzsUZ9AB7c-PSMB9yH5slRCLgo-o,1194
+fastapi_injected/scope.py,sha256=8gBQ2xoGJYGg02fsNlURzF0Oqhlklj1XTPTXl62PtEs,1576
+fastapi_injected/sign.py,sha256=EYDUDGFAgiSj7WCe7zUZJMiKxNAy4bagj4e3yrdSF0c,1701
+fastapi_injected/solve.py,sha256=2ChVdxKq8j5qo1JvuElpHAEa4YlZoWK6jUMDbCTb1Lk,515
+fastapi_injected/types.py,sha256=xulauhqiC5nwJqOVfh8AzgkyArVtyTutgDRKl2HJKtI,1304
+fastapi_injected-0.1.0.dist-info/METADATA,sha256=vDLM2ZXQ-KCSEJGkzOB7dI_sbEkCD1MdPXdA4b31GYc,3460
+fastapi_injected-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+fastapi_injected-0.1.0.dist-info/licenses/LICENSE,sha256=HCD36n-kWe513ObB4_rz7wgkBrc5BXuuPcqCh5QEiOk,1069
+fastapi_injected-0.1.0.dist-info/RECORD,,

fastapi_injected-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fastapi_injected-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yurii Karabas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.