Merge branch 'release/1.4.1'

Author: s3rius

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "taskiq-dependencies"
-version = "1.4.0"
+version = "1.4.1"
 description = "FastAPI like dependency injection implementation"
 authors = ["Pavel Kirilin <[email protected]>"]
 readme = "README.md"

taskiq_dependencies/ctx.py

@@ -1,8 +1,9 @@
 import asyncio
 import inspect
+from collections import defaultdict
 from copy import copy
 from logging import getLogger
-from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional
+from typing import TYPE_CHECKING, Any, DefaultDict, Dict, Generator, List, Optional
 
 from taskiq_dependencies.utils import ParamInfo
 
@@ -49,6 +50,8 @@ def traverse_deps(  # noqa: C901, WPS210
         # to separate dependencies that use cache,
         # from dependencies that aren't.
         cache = copy(self.initial_cache)
+        # Cache for all dependencies with kwargs.
+        kwargs_cache: "DefaultDict[Any, List[Any]]" = defaultdict(list)
         # We iterate over topologicaly sorted list of dependencies.
         for index, dep in enumerate(self.graph.ordered_deps):
             # If this dependency doesn't use cache,
@@ -62,6 +65,19 @@ def traverse_deps(  # noqa: C901, WPS210
             # If dependency is already calculated.
             if dep.dependency in cache:
                 continue
+            # For dependencies with kwargs we check kwarged cache.
+            elif dep.kwargs and dep.dependency in kwargs_cache:
+                cache_hit = False
+                # We have to iterate over all cached dependencies with
+                # kwargs, because users may pass unhashable objects as kwargs.
+                # That's why we cannot use them as dict keys.
+                for cached_kwargs, _ in kwargs_cache[dep.dependency]:
+                    if cached_kwargs == dep.kwargs:
+                        cache_hit = True
+                        break
+                if cache_hit:
+                    continue
+
             kwargs = {}
             # Now we get list of dependencies for current top-level dependency
             # and iterate over it.
@@ -78,7 +94,13 @@ def traverse_deps(  # noqa: C901, WPS210
                 if subdep.use_cache:
                     # If this dependency can be calculated, using cache,
                     # we try to get it from cache.
-                    kwargs[subdep.param_name] = cache[subdep.dependency]
+                    if subdep.kwargs and subdep.dependency in kwargs_cache:
+                        for cached_kwargs, kw_cache in kwargs_cache[subdep.dependency]:
+                            if cached_kwargs == subdep.kwargs:
+                                kwargs[subdep.param_name] = kw_cache
+                                break
+                    else:
+                        kwargs[subdep.param_name] = cache[subdep.dependency]
                 else:
                     # If this dependency doesn't use cache,
                     # we resolve it's dependencies and
@@ -101,9 +123,13 @@ def traverse_deps(  # noqa: C901, WPS210
                 # because we calculate them when needed.
                 and dep.dependency != ParamInfo
             ):
-                user_kwargs = dep.kwargs
+                user_kwargs = copy(dep.kwargs)
                 user_kwargs.update(kwargs)
-                cache[dep.dependency] = yield dep.dependency(**user_kwargs)
+                resolved = yield dep.dependency(**user_kwargs)
+                if dep.kwargs:
+                    kwargs_cache[dep.dependency].append((dep.kwargs, resolved))
+                else:
+                    cache[dep.dependency] = resolved
         return kwargs
 
 

taskiq_dependencies/graph.py

@@ -9,7 +9,7 @@
 try:
     from fastapi.params import Depends as FastapiDepends  # noqa: WPS433
 except ImportError:
-    FastapiDepends = Dependency  # type: ignore
+    FastapiDepends = None
 
 
 class DependencyGraph:
@@ -183,7 +183,10 @@ def _build_graph(self) -> None:  # noqa: C901, WPS210
 
                 # This is for FastAPI integration. So you can
                 # use Depends from taskiq mixed with fastapi's dependencies.
-                if isinstance(default_value, FastapiDepends):
+                if FastapiDepends is not None and isinstance(  # noqa: WPS337
+                    default_value,
+                    FastapiDepends,
+                ):
                     default_value = Dependency(
                         dependency=default_value.dependency,
                         use_cache=default_value.use_cache,
@@ -194,7 +197,6 @@ def _build_graph(self) -> None:  # noqa: C901, WPS210
                 # TaskiqDepends.
                 if not isinstance(default_value, Dependency):
                     continue
-
                 # If user haven't set the dependency,
                 # using TaskiqDepends constructor,
                 # we need to find variable's type hint.

tests/test_graph.py

@@ -704,3 +704,29 @@ def target(val: int = Depends(dep)) -> None:
     ) as ctx:
         kwargs = await ctx.resolve_kwargs()
         assert kwargs["val"] == 321
+
+
+def test_kwargs_caches() -> None:
+    """
+    Test that kwarged caches work.
+
+    If user wants to pass kwargs to the dependency
+    multiple times, we must verify that it works.
+
+    And dependency calculated multiple times,
+    even with caches.
+    """
+
+    def random_dep(a: int) -> int:
+        return a
+
+    A = Depends(random_dep, kwargs={"a": 1})
+    B = Depends(random_dep, kwargs={"a": 2})
+
+    def target(a: int = A, b: int = B) -> int:
+        return a + b
+
+    graph = DependencyGraph(target=target)
+    with graph.sync_ctx() as ctx:
+        kwargs = ctx.resolve_kwargs()
+        assert target(**kwargs) == 3