fastapi-injected 0.1.2__tar.gz → 0.1.3__tar.gz

{fastapi_injected-0.1.2 → fastapi_injected-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-injected
-Version: 0.1.2
+Version: 0.1.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>

{fastapi_injected-0.1.2 → fastapi_injected-0.1.3}/fastapi_injected/__init__.py

@@ -1,13 +1,15 @@
+from ._fastapi_lifecycle import init_inject_scope
 from .inject import inject
+from .resolve import resolve
 from .scope import push_inject_scope
-from .solve import solve
 from .types import Dep, DepFactory, Injected
 
 __all__ = [
     "Dep",
     "DepFactory",
     "Injected",
+    "init_inject_scope",
     "inject",
     "push_inject_scope",
-    "solve",
+    "resolve",
 ]

fastapi_injected-0.1.3/fastapi_injected/_fastapi_lifecycle.py

@@ -0,0 +1,62 @@
+from collections.abc import AsyncIterable
+from functools import wraps
+from typing import TYPE_CHECKING, Any
+
+from fastapi import Request, WebSocket, routing
+from fastapi.dependencies import utils
+
+from .scope import push_inject_scope
+from .types import DependencyCache
+
+_DEPENDENCY_CACHE_KEY = "__fastapi_injected_dependency_cache__"
+
+
+class MissingDependencyCacheError(Exception):
+    pass
+
+
+if not TYPE_CHECKING:
+    _base_solve_dependencies = utils.solve_dependencies
+
+    @wraps(_base_solve_dependencies)
+    async def _solve_dependencies(
+        *,
+        request: Request | WebSocket,
+        dependency_cache: DependencyCache | None = None,
+        **kwargs: Any,
+    ) -> utils.SolvedDependency:
+        if (current_cache := request.scope.get(_DEPENDENCY_CACHE_KEY)) is not None:
+            dependency_cache = current_cache
+        elif dependency_cache is None:
+            dependency_cache = {}
+
+        request.scope[_DEPENDENCY_CACHE_KEY] = dependency_cache
+
+        return await _base_solve_dependencies(
+            request=request,
+            dependency_cache=dependency_cache,
+            **kwargs,
+        )
+
+    utils.solve_dependencies = _solve_dependencies
+    routing.solve_dependencies = _solve_dependencies
+
+
+def _get_dependency_cache(request: Request) -> DependencyCache:
+    try:
+        return request.scope[_DEPENDENCY_CACHE_KEY]
+    except KeyError:
+        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
+
+
+__all__ = [
+    "init_inject_scope",
+]

{fastapi_injected-0.1.2 → fastapi_injected-0.1.3}/fastapi_injected/deps.py

@@ -1,5 +1,6 @@
 import inspect
 from collections.abc import Callable
+from contextlib import AsyncExitStack
 from contextvars import ContextVar
 from copy import copy
 from functools import lru_cache, wraps
@@ -9,47 +10,12 @@ 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)
@@ -114,16 +80,12 @@ async def solve_dependencies(
     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,
-            },
-        ),
+        request=scope.request,
         dependant=dependant,
-        async_exit_stack=scope.request_astack,
         dependency_cache=copy(scope.dependency_cache),
         dependency_overrides_provider=_dependency_override_provider.get(),
+        # this parameter is deprecated and not used
+        async_exit_stack=cast(AsyncExitStack, None),
         embed_body_fields=False,
     )
 

fastapi_injected-0.1.2/fastapi_injected/solve.py → fastapi_injected-0.1.3/fastapi_injected/resolve.py

@@ -4,7 +4,7 @@ from .deps import create_single_dependant, solve_dependencies
 from .scope import inside_inject_scope
 
 
-async def solve[R](
+async def resolve[R](
     tp: TypeForm[R],
     *,
     new_scope: bool = False,
@@ -22,5 +22,5 @@ async def solve[R](
 
 
 __all__ = [
-    "solve",
+    "resolve",
 ]

fastapi_injected-0.1.3/fastapi_injected/scope.py

@@ -0,0 +1,108 @@
+from collections.abc import AsyncIterator
+from contextlib import (
+    AsyncExitStack,
+    asynccontextmanager,
+)
+from contextvars import ContextVar
+from dataclasses import dataclass
+
+from fastapi import Request
+from starlette.types import Message, Scope
+
+from .types import DependencyCache
+
+
+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,
+    )
+
+
+@dataclass
+class InjectScope:
+    dependency_cache: DependencyCache
+    request: Request
+
+
+_inject_scope: ContextVar[InjectScope | None] = ContextVar(
+    "_inject_scope",
+    default=None,
+)
+
+
+@asynccontextmanager
+async def push_inject_scope(
+    *,
+    dependency_cache: DependencyCache | None = None,
+    request: Request | None = None,
+) -> AsyncIterator[InjectScope]:
+    if dependency_cache is None:
+        dependency_cache = {}
+
+    async with AsyncExitStack() as stack:
+        request = request or _dummy_request(
+            extra_scope={
+                "fastapi_inner_astack": stack,
+                "fastapi_function_astack": stack,
+            },
+        )
+
+        scope = InjectScope(dependency_cache, request)
+        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()
+
+    async with AsyncExitStack() as stack:
+        if scope is None or new_scope:
+            scope = await stack.enter_async_context(push_inject_scope())
+
+        yield scope
+
+
+__all__ = [
+    "InjectScope",
+    "current_inject_scope",
+    "inside_inject_scope",
+]

{fastapi_injected-0.1.2 → fastapi_injected-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-injected"
-version = "0.1.2"
+version = "0.1.3"
 description = "Yet another library to reuse fastapi dependency injection"
 authors = [
     { name = "Yurii Karabas", email = "1998uriyyo@gmail.com" },
@@ -30,6 +30,7 @@ dev = [
     "ty>=0.0.62",
     "pre-commit>=4.6.1",
     "pydantic-ai-slim>=2.15.0",
+    "httpx>=0.28.1",
 ]
 
 [project.urls]

fastapi_injected-0.1.3/tests/test_fastapi.py

@@ -0,0 +1,35 @@
+from fastapi import Depends, FastAPI, status
+from fastapi.testclient import TestClient
+
+from fastapi_injected import Dep, Injected, init_inject_scope, inject, resolve
+
+from .deps import 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

fastapi_injected-0.1.2/tests/test_solve.py → fastapi_injected-0.1.3/tests/test_resolve.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 
 import pytest
 
-from fastapi_injected import Dep, push_inject_scope, solve
+from fastapi_injected import Dep, push_inject_scope, resolve
 
 pytestmark = pytest.mark.asyncio
 
@@ -17,16 +17,16 @@ class Bar:
     foo: Dep[Foo]
 
 
-async def test_solve():
-    bar = await solve(Bar)
+async def test_resolve():
+    bar = await resolve(Bar)
 
     assert isinstance(bar, Bar)
     assert isinstance(bar.foo, Foo)
 
 
-async def test_solve_reuse_cache():
+async def test_resolve_reuse_cache():
     async with push_inject_scope():
-        b1 = await solve(Bar)
-        b2 = await solve(Bar)
+        b1 = await resolve(Bar)
+        b2 = await resolve(Bar)
 
         assert b1 is b2

{fastapi_injected-0.1.2 → fastapi_injected-0.1.3}/tests/test_typing.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from fastapi_injected import Dep, DepFactory, Injected, inject, solve
+from fastapi_injected import Dep, DepFactory, Injected, inject, resolve
 
 from .deps import Child, Container, ContextState, ctx_dep
 
@@ -22,8 +22,8 @@ async def func(
     return a + 10
 
 
-async def solve_test() -> None:
-    container = await solve(Container)
+async def resolve_test() -> None:
+    container = await resolve(Container)
 
     static_assert(is_equivalent_to(TypeOf[container], Container))
 

{fastapi_injected-0.1.2 → fastapi_injected-0.1.3}/uv.lock

@@ -160,7 +160,7 @@ wheels = [
 
 [[package]]
 name = "fastapi-injected"
-version = "0.1.2"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },
@@ -168,6 +168,7 @@ dependencies = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "httpx" },
     { name = "pre-commit" },
     { name = "pydantic-ai-slim" },
     { name = "pytest" },
@@ -182,6 +183,7 @@ requires-dist = [{ name = "fastapi", specifier = ">=0.139.2" }]
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "httpx", specifier = ">=0.28.1" },
     { name = "pre-commit", specifier = ">=4.6.1" },
     { name = "pydantic-ai-slim", specifier = ">=2.15.0" },
     { name = "pytest", specifier = ">=9.1.1" },

fastapi_injected-0.1.2/fastapi_injected/scope.py

@@ -1,75 +0,0 @@
-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",
-]