Fix/callable class generator not handled (#108)

* fix: handle callable class instance generators

* refactor: rewrite is coro check function to have the same style with other check functions

* test: add tests for class callable generators to test task

* docs: update path in docstring

* refactor: remove unused code in tests

* test: add tests for class callable generators to test execute

* version: bump to new 0.77.0 version

* refactor: remove obsolete sync param in test concurrency async case

---------

Co-authored-by: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>

Author: maxzhenzhera

di/_utils/inspect.py

@@ -30,19 +30,27 @@ def unwrap_callable(call: Any) -> Any:
 def is_coroutine_callable(call: Any) -> bool:
     if inspect.isclass(call):
         return False
-    call = unwrap_callable(call)
-    if inspect.iscoroutinefunction(call):
+    unwrapped_call = unwrap_callable(call)
+    if inspect.iscoroutinefunction(unwrapped_call):
         return True
-    # not a class but has a __call__, so maybe a callable class instance
-    return inspect.iscoroutinefunction(getattr(call, "__call__"))
+    dunder_call = getattr(unwrapped_call, "__call__", None)
+    return inspect.iscoroutinefunction(dunder_call)
 
 
 def is_async_gen_callable(call: Callable[..., Any]) -> bool:
-    return inspect.isasyncgenfunction(unwrap_callable(call))
+    unwrapped_call = unwrap_callable(call)
+    if inspect.isasyncgenfunction(unwrapped_call):
+        return True
+    dunder_call = getattr(unwrapped_call, "__call__", None)
+    return inspect.isasyncgenfunction(dunder_call)
 
 
 def is_gen_callable(call: Any) -> bool:
-    return inspect.isgeneratorfunction(unwrap_callable(call))
+    unwrapped_call = unwrap_callable(call)
+    if inspect.isgeneratorfunction(unwrapped_call):
+        return True
+    dunder_call = getattr(unwrapped_call, "__call__", None)
+    return inspect.isgeneratorfunction(dunder_call)
 
 
 def get_annotations(call: Callable[..., Any]) -> Dict[str, Any]:

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "di"
-version = "0.76.0"
+version = "0.77.0"
 description = "Dependency injection toolkit"
 authors = ["Adrian Garcia Badaracco <adrian@adriangb.com>"]
 readme = "README.md"

tests/test_execute.py

@@ -92,32 +92,6 @@ def test_execute():
     assert res.three.zero is res.zero
 
 
-def sync_callable_func() -> int:
-    return 1
-
-
-async def async_callable_func() -> int:
-    return 1
-
-
-def sync_gen_func() -> Generator[int, None, None]:
-    yield 1
-
-
-async def async_gen_func() -> AsyncGenerator[int, None]:
-    yield 1
-
-
-class SyncCallableCls:
-    def __call__(self) -> int:
-        return 1
-
-
-class AsyncCallableCls:
-    async def __call__(self) -> int:
-        return 1
-
-
 @dataclass
 class Synchronizer:
     started: List[anyio.Event]
@@ -164,15 +138,30 @@ async def __call__(self, synchronizer: Synchronizer) -> None:
         await async_callable_func_slow(synchronizer)
 
 
+class SyncGenCallableClsSlow:
+    @as_async
+    def __call__(self, synchronizer: Synchronizer) -> Generator[None, None, None]:
+        _sync_callable_func_slow(synchronizer)
+        yield None
+
+
+class AsyncGenCallableClsSlow:
+    async def __call__(self, synchronizer: Synchronizer) -> AsyncGenerator[None, None]:
+        await async_callable_func_slow(synchronizer)
+        yield None
+
+
 @pytest.mark.parametrize(
-    "dep1,sync1",
+    "dep1",
     [
-        (sync_callable_func_slow, True),
-        (async_callable_func_slow, False),
-        (sync_gen_func_slow, True),
-        (async_gen_func_slow, False),
-        (SyncCallableClsSlow(), True),
-        (AsyncCallableClsSlow(), False),
+        sync_callable_func_slow,
+        async_callable_func_slow,
+        sync_gen_func_slow,
+        async_gen_func_slow,
+        SyncCallableClsSlow(),
+        AsyncCallableClsSlow(),
+        SyncGenCallableClsSlow(),
+        AsyncGenCallableClsSlow(),
     ],
     ids=[
         "sync_callable_func",
@@ -181,17 +170,21 @@ async def __call__(self, synchronizer: Synchronizer) -> None:
         "async_gen_func",
         "SyncCallableCls",
         "AsyncCallableCls",
+        "SyncGenCallableCls",
+        "AsyncGenCallableCls",
     ],
 )
 @pytest.mark.parametrize(
-    "dep2,sync2",
+    "dep2",
     [
-        (sync_callable_func_slow, True),
-        (async_callable_func_slow, False),
-        (sync_gen_func_slow, True),
-        (async_gen_func_slow, False),
-        (SyncCallableClsSlow(), True),
-        (AsyncCallableClsSlow(), False),
+        sync_callable_func_slow,
+        async_callable_func_slow,
+        sync_gen_func_slow,
+        async_gen_func_slow,
+        SyncCallableClsSlow(),
+        AsyncCallableClsSlow(),
+        SyncGenCallableClsSlow(),
+        AsyncGenCallableClsSlow(),
     ],
     ids=[
         "sync_callable_func",
@@ -200,10 +193,12 @@ async def __call__(self, synchronizer: Synchronizer) -> None:
         "async_gen_func",
         "SyncCallableCls",
         "AsyncCallableCls",
+        "SyncGenCallableCls",
+        "AsyncGenCallableCls",
     ],
 )
 @pytest.mark.anyio
-async def test_concurrency_async(dep1: Any, sync1: bool, dep2: Any, sync2: bool):
+async def test_concurrency_async(dep1: Any, dep2: Any):
     container = Container()
 
     synchronizer = Synchronizer([anyio.Event(), anyio.Event()], anyio.Event())

tests/test_task.py

@@ -1,5 +1,5 @@
 """Black box tests that check the high level API but in practice are written to fully
-test all of the execution paths in di/_utils/task.py
+test all of the execution paths in di/_task.py
 """
 import functools
 from typing import Any, AsyncGenerator, Callable, Generator
@@ -37,6 +37,16 @@ async def __call__(self) -> int:
         return 1
 
 
+class SyncGenCallableCls:
+    def __call__(self) -> Generator[int, None, None]:
+        yield 1
+
+
+class AsyncGenCallableCls:
+    async def __call__(self) -> AsyncGenerator[int, None]:
+        yield 1
+
+
 def no_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
     return func
 
@@ -62,6 +72,8 @@ def wrapper(*args, **kwargs):  # type: ignore
         async_gen_func,
         SyncCallableCls(),
         AsyncCallableCls(),
+        SyncGenCallableCls(),
+        AsyncGenCallableCls(),
     ],
     ids=[
         "sync_callable_func",
@@ -70,6 +82,8 @@ def wrapper(*args, **kwargs):  # type: ignore
         "async_gen_func",
         "SyncCallableCls",
         "AsyncCallableCls",
+        "SyncGenCallableCls",
+        "AsyncGenCallableCls",
     ],
 )
 @pytest.mark.parametrize(