Merge pull request #16 from taskiq-python/feature/replacing_deps

Author: s3rius

.github/workflows/test.yml

@@ -3,23 +3,7 @@ name: Testing
 on: [push, pull_request]
 
 jobs:
-  pre_job:
-    # continue-on-error: true # Uncomment once integration is finished
-    runs-on: ubuntu-latest
-    # Map a step output to a job output
-    outputs:
-      should_skip: ${{ steps.skip_check.outputs.should_skip }}
-    steps:
-      - id: skip_check
-        uses: fkirc/skip-duplicate-actions@master
-        with:
-          # All of these options are optional, so you can remove them if you are happy with the defaults
-          concurrent_skipping: 'same_content'
-          skip_after_successful_duplicate: 'true'
-          paths_ignore: '["**/README.md"]'
   lint:
-    needs: pre_job
-    if: ${{ needs.pre_job.outputs.should_skip != 'true' }}
     strategy:
       matrix:
         cmd:
@@ -43,8 +27,6 @@ jobs:
       - name: Run lint check
         run: poetry run pre-commit run -a ${{ matrix.cmd }}
   pytest:
-    needs: pre_job
-    if: ${{ needs.pre_job.outputs.should_skip != 'true' }}
     permissions:
       checks: write
       pull-requests: write

README.md

@@ -260,3 +260,52 @@ This code will is going to print:
 strstr
 100
 ```
+
+## Dependencies replacement
+
+You can replace dependencies in runtime, it will recalculate graph
+and will execute your function with updated dependencies.
+
+**!!! This functionality tremendously slows down dependency resolution.**
+
+Use this functionality only for tests. Otherwise, you will end up building dependency graphs on every resolution request. Which is very slow.
+
+But for tests it may be a game changer, since you don't want to change your code, but some dependencies instead.
+
+Here's an example. Imagine you have a built graph for a specific function, like this:
+
+```python
+from taskiq_dependencies import DependencyGraph, Depends
+
+
+def dependency() -> int:
+    return 1
+
+
+def target(dep_value: int = Depends(dependency)) -> None:
+    assert dep_value == 1
+
+graph = DependencyGraph(target)
+```
+
+Normally, you would call the target, by writing something like this:
+
+```python
+with graph.sync_ctx() as ctx:
+    target(**ctx.resolve_kwargs())
+```
+
+But what if you want to replace dependency in runtime, just
+before resolving kwargs? The solution is to add `replaced_deps`
+parameter to the context method. For example:
+
+```python
+def replaced() -> int:
+    return 2
+
+
+with graph.sync_ctx(replaced_deps={dependency: replaced}) as ctx:
+    target(**ctx.resolve_kwargs())
+```
+
+Furthermore, the new dependency can depend on other dependencies. Or you can change type of your dependency, like generator instead of plain return. Everything should work as you would expect it.

taskiq_dependencies/graph.py

@@ -20,6 +20,7 @@ class DependencyGraph:
     def __init__(
         self,
         target: Callable[..., Any],
+        replaced_deps: Optional[Dict[Any, Any]] = None,
     ) -> None:
         self.target = target
         # Ordinary dependencies with cache.
@@ -28,6 +29,7 @@ def __init__(
         # Can be considered as sub graphs.
         self.subgraphs: Dict[Any, DependencyGraph] = {}
         self.ordered_deps: List[Dependency] = []
+        self.replaced_deps = replaced_deps
         self._build_graph()
 
     def is_empty(self) -> bool:
@@ -41,6 +43,7 @@ def is_empty(self) -> bool:
     def async_ctx(
         self,
         initial_cache: Optional[Dict[Any, Any]] = None,
+        replaced_deps: Optional[Dict[Any, Any]] = None,
         exception_propagation: bool = True,
     ) -> AsyncResolveContext:
         """
@@ -51,17 +54,22 @@ def async_ctx(
         :param initial_cache: initial cache dict.
         :param exception_propagation: If true, all found errors within
             context will be propagated to dependencies.
+        :param replaced_deps: Dependencies to replace during runtime.
         :return: new resolver context.
         """
+        graph = self
+        if replaced_deps:
+            graph = DependencyGraph(self.target, replaced_deps)
         return AsyncResolveContext(
-            self,
+            graph,
             initial_cache,
             exception_propagation,
         )
 
     def sync_ctx(
         self,
         initial_cache: Optional[Dict[Any, Any]] = None,
+        replaced_deps: Optional[Dict[Any, Any]] = None,
         exception_propagation: bool = True,
     ) -> SyncResolveContext:
         """
@@ -72,10 +80,14 @@ def sync_ctx(
         :param initial_cache: initial cache dict.
         :param exception_propagation: If true, all found errors within
             context will be propagated to dependencies.
+        :param replaced_deps: Dependencies to replace during runtime.
         :return: new resolver context.
         """
+        graph = self
+        if replaced_deps:
+            graph = DependencyGraph(self.target, replaced_deps)
         return SyncResolveContext(
-            self,
+            graph,
             initial_cache,
             exception_propagation,
         )
@@ -102,6 +114,8 @@ def _build_graph(self) -> None:  # noqa: C901, WPS210
                 continue
             if dep.dependency is None:
                 continue
+            if self.replaced_deps and dep.dependency in self.replaced_deps:
+                dep.dependency = self.replaced_deps[dep.dependency]
             # Get signature and type hints.
             origin = getattr(dep.dependency, "__origin__", None)
             if origin is None:

tests/test_graph.py

@@ -1,4 +1,5 @@
 import asyncio
+import re
 import uuid
 from typing import Any, AsyncGenerator, Generator, Generic, Tuple, TypeVar
 
@@ -36,8 +37,9 @@ def testfunc(a: int = Depends(dep1)) -> int:
         return a
 
     with DependencyGraph(testfunc).sync_ctx({}) as sctx:
-        with pytest.raises(RuntimeError):
-            assert sctx.resolve_kwargs() == {"a": 1}
+        with pytest.warns(match=re.compile(".*was never awaited.*")):
+            with pytest.raises(RuntimeError):
+                assert sctx.resolve_kwargs() == {"a": 1}
 
     async with DependencyGraph(testfunc).async_ctx({}) as actx:
         assert await actx.resolve_kwargs() == {"a": 1}
@@ -611,3 +613,94 @@ def target(
         assert dep_obj.dependency == GenericClass[Tuple[str, int]]
         assert dep_obj.signature.name == "class_val"
         assert dep_obj.signature.annotation == GenericClass[Tuple[str, int]]
+
+
+@pytest.mark.anyio
+async def test_replaced_dep_simple() -> None:
+    def replaced() -> int:
+        return 321
+
+    def dep() -> int:
+        return 123
+
+    def target(val: int = Depends(dep)) -> None:
+        return None
+
+    graph = DependencyGraph(target=target)
+    async with graph.async_ctx(replaced_deps={dep: replaced}) as ctx:
+        kwargs = await ctx.resolve_kwargs()
+    assert kwargs["val"] == 321
+
+
+@pytest.mark.anyio
+async def test_replaced_dep_generators() -> None:
+    call_count = 0
+
+    def replaced() -> Generator[int, None, None]:
+        nonlocal call_count
+        yield 321
+        call_count += 1
+
+    def dep() -> int:
+        return 123
+
+    def target(val: int = Depends(dep)) -> None:
+        return None
+
+    graph = DependencyGraph(target=target)
+    async with graph.async_ctx(replaced_deps={dep: replaced}) as ctx:
+        kwargs = await ctx.resolve_kwargs()
+    assert kwargs["val"] == 321
+    assert call_count == 1
+
+
+@pytest.mark.anyio
+async def test_replaced_dep_exception_propogation() -> None:
+    exc_count = 0
+
+    def replaced() -> Generator[int, None, None]:
+        nonlocal exc_count
+        try:
+            yield 321
+        except ValueError:
+            exc_count += 1
+
+    def dep() -> int:
+        return 123
+
+    def target(val: int = Depends(dep)) -> None:
+        raise ValueError("lol")
+
+    graph = DependencyGraph(target=target)
+    with pytest.raises(ValueError):
+        async with graph.async_ctx(
+            replaced_deps={dep: replaced},
+            exception_propagation=True,
+        ) as ctx:
+            kwargs = await ctx.resolve_kwargs()
+            assert kwargs["val"] == 321
+            target(**kwargs)
+    assert exc_count == 1
+
+
+@pytest.mark.anyio
+async def test_replaced_dep_subdependencies() -> None:
+    def subdep() -> int:
+        return 321
+
+    def replaced(ret_val: int = Depends(subdep)) -> int:
+        return ret_val
+
+    def dep() -> int:
+        return 123
+
+    def target(val: int = Depends(dep)) -> None:
+        """Stub function."""
+
+    graph = DependencyGraph(target=target)
+    async with graph.async_ctx(
+        replaced_deps={dep: replaced},
+        exception_propagation=True,
+    ) as ctx:
+        kwargs = await ctx.resolve_kwargs()
+        assert kwargs["val"] == 321