Merge branch 'release/1.4.0'

Author: s3rius

.python-version

@@ -0,0 +1,4 @@
+3.11.4
+3.10.12
+3.9.17
+3.8.17

README.md

@@ -309,3 +309,56 @@ with graph.sync_ctx(replaced_deps={dependency: replaced}) as ctx:
 ```
 
 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.
+
+## Annotated types
+
+Taskiq dependenices also support dependency injection through Annotated types.
+
+```python
+from typing import Annotated
+
+async def my_function(dependency: Annotated[int, Depends(my_func)]):
+    pass
+```
+
+Or you can specify classes
+
+
+```python
+from typing import Annotated
+
+class MyClass:
+    pass
+
+async def my_function(dependency: Annotated[MyClass, Depends(my_func)]):
+    pass
+```
+
+And, of course you can easily save such type aliases in variables.
+
+```python
+from typing import Annotated
+
+DepType = Annotated[int, Depends(my_func)]
+
+def my_function(dependency: DepType):
+    pass
+
+```
+
+Also we support overrides for annotated types.
+
+For example:
+
+```python
+from typing import Annotated
+
+DepType = Annotated[int, Depends(my_func)]
+
+def my_function(
+    dependency: DepType,
+    no_cache_dep: Annotated[DepType, Depends(my_func, use_cache=False)],
+) -> None:
+    pass
+
+```

pyproject.toml

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

taskiq_dependencies/graph.py

@@ -9,7 +9,7 @@
 try:
     from fastapi.params import Depends as FastapiDepends  # noqa: WPS433
 except ImportError:
-    FastapiDepends = None  # type: ignore
+    FastapiDepends = Dependency  # type: ignore
 
 
 class DependencyGraph:
@@ -136,9 +136,8 @@ def _build_graph(self) -> None:  # noqa: C901, WPS210
                         + f"Please provide a type in param `{dep.parent.param_name}`"
                         + f" of `{dep.parent.dependency}`",
                     )
-                # We zip together names of parameters and the subsctituted values
-                # In parameters we would see TypeVars in args
-                # we would find actual classes.
+                # We zip together names of parameters and the substituted values
+                # for generics.
                 generics = zip(
                     parent_cls_origin.__parameters__,
                     parent_cls.__args__,  # type: ignore
@@ -172,13 +171,19 @@ def _build_graph(self) -> None:  # noqa: C901, WPS210
             # default vaule.
             for param_name, param in sign.parameters.items():
                 default_value = param.default
+                if hasattr(param.annotation, "__metadata__"):  # noqa: WPS421
+                    # We go backwards,
+                    # because you may want to override your annotation
+                    # and the overriden value will appear to be after
+                    # the original `Depends` annotation.
+                    for meta in reversed(param.annotation.__metadata__):
+                        if isinstance(meta, (Dependency, FastapiDepends)):
+                            default_value = meta
+                            break
 
                 # This is for FastAPI integration. So you can
                 # use Depends from taskiq mixed with fastapi's dependencies.
-                if FastapiDepends is not None and isinstance(  # noqa: WPS337
-                    default_value,
-                    FastapiDepends,
-                ):
+                if isinstance(default_value, FastapiDepends):
                     default_value = Dependency(
                         dependency=default_value.dependency,
                         use_cache=default_value.use_cache,

tests/test_annotated.py

@@ -0,0 +1,126 @@
+import sys
+
+import pytest
+
+if sys.version_info < (3, 10):
+    pytest.skip("Annotated is available only for python 3.10+", allow_module_level=True)
+
+from typing import Annotated, AsyncGenerator, Generic, Tuple, TypeVar
+
+from taskiq_dependencies import DependencyGraph, Depends
+
+
+def test_annotated_func() -> None:
+    def get_int() -> int:
+        return 1
+
+    def target_func(dep: Annotated[int, Depends(get_int)]) -> int:
+        return dep
+
+    with DependencyGraph(target_func).sync_ctx() as ctx:
+        res = target_func(**ctx.resolve_kwargs())
+    assert res == 1
+
+
+def test_annotated_class() -> None:
+    class TestClass:
+        pass
+
+    def target_func(dep: Annotated[TestClass, Depends()]) -> TestClass:
+        return dep
+
+    with DependencyGraph(target_func).sync_ctx() as ctx:
+        res = target_func(**ctx.resolve_kwargs())
+    assert isinstance(res, TestClass)
+
+
+def test_annotated_generic() -> None:
+    _T = TypeVar("_T")
+
+    class MyClass:
+        pass
+
+    class MainClass(Generic[_T]):
+        def __init__(self, val: _T = Depends()) -> None:
+            self.val = val
+
+    def test_func(a: Annotated[MainClass[MyClass], Depends()]) -> MyClass:
+        return a.val
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        value = test_func(**(g.resolve_kwargs()))
+
+    assert isinstance(value, MyClass)
+
+
+@pytest.mark.anyio
+async def test_annotated_asyncgen() -> None:
+    opened = False
+    closed = False
+
+    async def my_gen() -> AsyncGenerator[int, None]:
+        nonlocal opened, closed
+        opened = True
+
+        yield 1
+
+        closed = True
+
+    def test_func(dep: Annotated[int, Depends(my_gen)]) -> int:
+        return dep
+
+    async with DependencyGraph(target=test_func).async_ctx() as g:
+        value = test_func(**(await g.resolve_kwargs()))
+        assert value == 1
+
+    assert opened and closed
+
+
+def test_multiple() -> None:
+    class TestClass:
+        pass
+
+    MyType = Annotated[TestClass, Depends(use_cache=False)]
+
+    def test_func(dep: MyType, dep2: MyType) -> Tuple[MyType, MyType]:
+        return dep, dep2
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        value = test_func(**(g.resolve_kwargs()))
+        assert value[0] != value[1]
+        assert isinstance(value[0], TestClass)
+        assert isinstance(value[1], TestClass)
+
+
+def test_multiple_with_cache() -> None:
+    class TestClass:
+        pass
+
+    MyType = Annotated[TestClass, Depends()]
+
+    def test_func(dep: MyType, dep2: MyType) -> Tuple[MyType, MyType]:
+        return dep, dep2
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        value = test_func(**(g.resolve_kwargs()))
+        assert id(value[0]) == id(value[1])
+        assert isinstance(value[0], TestClass)
+
+
+def test_override() -> None:
+    class TestClass:
+        pass
+
+    MyType = Annotated[TestClass, Depends()]
+
+    def test_func(
+        dep: MyType,
+        dep2: Annotated[MyType, Depends(use_cache=False)],
+    ) -> Tuple[MyType, MyType]:
+        return dep, dep2
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        value = test_func(**(g.resolve_kwargs()))
+        assert id(value[0]) != id(value[1])
+        assert isinstance(value[0], TestClass)
+        assert isinstance(value[1], TestClass)

tests/test_fastapi.py

@@ -1,6 +1,9 @@
+import sys
 from typing import Any
 from unittest.mock import patch
 
+import pytest
+
 from taskiq_dependencies import DependencyGraph
 
 
@@ -29,3 +32,27 @@ def func_b(dep_a: int = MyFastapiDepends(func_a)) -> int:  # type: ignore
             kwargs = ctx.resolve_kwargs()
 
         assert kwargs == {"dep_a": 1}
+
+
+@pytest.mark.skipif(sys.version_info < (3, 10), reason="Only for python 3.10+")
+def test_dependency_swap_annotated() -> None:
+    """
+    Test that dependency classes are swapped.
+
+    This test checks that if function depends on FastAPI depends, it will
+    be swapped and resolved.
+    """
+    from typing import Annotated
+
+    with patch("taskiq_dependencies.graph.FastapiDepends", MyFastapiDepends):
+
+        def func_a() -> int:
+            return 1
+
+        def func_b(dep_a: Annotated[int, MyFastapiDepends(func_a)]) -> int:  # type: ignore
+            return dep_a
+
+        with DependencyGraph(func_b).sync_ctx() as ctx:
+            kwargs = ctx.resolve_kwargs()
+
+        assert kwargs == {"dep_a": 1}

tox.ini

@@ -0,0 +1,16 @@
+[tox]
+isolated_build = true
+env_list =
+    py311
+    py310
+    py39
+    py38
+
+[testenv]
+skip_install = true
+allowlist_externals = poetry
+commands_pre =
+    poetry install
+commands =
+    pre-commit run --all-files
+    poetry run pytest -vv