From 1cc94e99fb7f8a474d6a2db46ca0139c817e6bce Mon Sep 17 00:00:00 2001 From: Leonardus Chen Date: Sat, 25 Oct 2025 13:11:27 +0700 Subject: [PATCH 1/2] Fix aggregate.py --- tests/typing/aggregate.py | 38 +++++++++++++++++++++++--------------- 1 file changed, 23 insertions(+), 15 deletions(-) diff --git a/tests/typing/aggregate.py b/tests/typing/aggregate.py index 1f134cb0..3beff893 100644 --- a/tests/typing/aggregate.py +++ b/tests/typing/aggregate.py @@ -1,4 +1,5 @@ from dependency_injector import providers +from typing_extensions import assert_type, Any class Animal: ... @@ -8,29 +9,36 @@ class Cat(Animal): ... # Test 1: to check Aggregate provider -provider1: providers.Aggregate[str] = providers.Aggregate( +provider1 = providers.Aggregate( a=providers.Object("str1"), b=providers.Object("str2"), ) -provider_a_1: providers.Provider[str] = provider1.a +provider_a_1 = provider1.a provider_b_1: providers.Provider[str] = provider1.b -val1: str = provider1("a") +val1 = provider1("a") +assert_type(provider1, providers.Aggregate[str]) +assert_type(provider_a_1, providers.Provider[str]) +assert_type(provider_b_1, providers.Provider[str]) +assert_type(val1, str) -provider1_set_non_string_keys: providers.Aggregate[str] = providers.Aggregate() +provider1_set_non_string_keys = providers.Aggregate[str]() provider1_set_non_string_keys.set_providers({Cat: providers.Object("str")}) -provider_set_non_string_1: providers.Provider[str] = ( - provider1_set_non_string_keys.providers[Cat] -) +provider_set_non_string_1 = provider1_set_non_string_keys.providers[Cat] +assert_type(provider_set_non_string_1, providers.Provider[str]) + -provider1_new_non_string_keys: providers.Aggregate[str] = providers.Aggregate( +# TODO: Change providers.Aggregate to accept Mapping? Then remove explicit typing here +provider1_new_non_string_keys = providers.Aggregate[str]( {Cat: providers.Object("str")}, ) -factory_new_non_string_1: providers.Provider[str] = ( - provider1_new_non_string_keys.providers[Cat] -) +factory_new_non_string_1 = provider1_new_non_string_keys.providers[Cat] +assert_type(provider1_new_non_string_keys, providers.Aggregate[str]) +assert_type(factory_new_non_string_1, providers.Provider[str]) + provider1_no_explicit_typing = providers.Aggregate(a=providers.Object("str")) -provider1_no_explicit_typing_factory: providers.Provider[str] = ( - provider1_no_explicit_typing.providers["a"] -) -provider1_no_explicit_typing_object: str = provider1_no_explicit_typing("a") +provider1_no_explicit_typing_factory = provider1_no_explicit_typing.providers["a"] +provider1_no_explicit_typing_object = provider1_no_explicit_typing("a") + +assert_type(provider1_no_explicit_typing_factory, providers.Provider[str]) +assert_type(provider1_no_explicit_typing_object, str) From 143b86d926c8e81b83d088903de147eea1f9163a Mon Sep 17 00:00:00 2001 From: Leonardus Chen Date: Sat, 25 Oct 2025 14:12:26 +0700 Subject: [PATCH 2/2] Fix callable.py --- tests/typing/callable.py | 53 ++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 19 deletions(-) diff --git a/tests/typing/callable.py b/tests/typing/callable.py index 8d345d3b..81312b20 100644 --- a/tests/typing/callable.py +++ b/tests/typing/callable.py @@ -1,4 +1,5 @@ -from typing import Any, Callable, Dict, Optional, Tuple, Type +from typing import Any, Callable, Dict, Optional, Tuple +from typing_extensions import assert_type from dependency_injector import providers @@ -7,7 +8,6 @@ class Animal: ... class Cat(Animal): - @classmethod def create(cls) -> Animal: return cls() @@ -15,11 +15,13 @@ def create(cls) -> Animal: # Test 1: to check the return type (class) provider1 = providers.Callable(Cat) -animal1: Animal = provider1(1, 2, 3, b="1", c=2, e=0.0) +cat1 = provider1(1, 2, 3, b="1", c=2, e=0.0) +assert_type(cat1, Cat) # Test 2: to check the return type (class factory method) provider2 = providers.Callable(Cat.create) -animal2: Animal = provider2() +animal2 = provider2() +assert_type(animal2, Animal) # Test 3: to check the .override() method provider3 = providers.Callable(Animal) @@ -28,24 +30,34 @@ def create(cls) -> Animal: # Test 4: to check the .args & .kwargs attributes provider4 = providers.Callable(Animal) -args4: Tuple[Any] = provider4.args -kwargs4: Dict[str, Any] = provider4.kwargs +args4 = provider4.args +kwargs4 = provider4.kwargs +assert_type(args4, Tuple[Any]) +# TODO: Change Callable.kwargs to Dict[str, Any]? Then adjust test back to Dict[str, Any] +assert_type(kwargs4, Dict[Any, Any]) # Test 5: to check the provided instance interface provider5 = providers.Callable(Animal) -provided5: Animal = provider5.provided() -attr_getter5: providers.AttributeGetter = provider5.provided.attr -item_getter5: providers.ItemGetter = provider5.provided["item"] -method_caller: providers.MethodCaller = provider5.provided.method.call(123, arg=324) +provided_val5 = provider5.provided() +attr_getter5 = provider5.provided.attr +item_getter5 = provider5.provided["item"] +method_caller5 = provider5.provided.method.call(123, arg=324) +# TODO: Remove explicit typing of Provider.provided return type +assert_type(provided_val5, Any) +assert_type(attr_getter5, providers.AttributeGetter) +assert_type(item_getter5, providers.ItemGetter) +assert_type(method_caller5, providers.MethodCaller) # Test 6: to check the DelegatedCallable provider6 = providers.DelegatedCallable(Cat) -animal6: Animal = provider6(1, 2, 3, b="1", c=2, e=0.0) +cat6 = provider6(1, 2, 3, b="1", c=2, e=0.0) +assert_type(cat6, Cat) # Test 7: to check the AbstractCallable provider7 = providers.AbstractCallable(Animal) provider7.override(providers.Callable(Cat)) -animal7: Animal = provider7(1, 2, 3, b="1", c=2, e=0.0) +animal7 = provider7(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal7, Animal) # Test 8: to check the CallableDelegate __init__ provider8 = providers.CallableDelegate(providers.Callable(lambda: None)) @@ -55,20 +67,23 @@ def create(cls) -> Animal: async def _async9() -> None: - animal1: Animal = await provider9(1, 2, 3, b="1", c=2, e=0.0) # type: ignore - animal2: Animal = await provider9.async_(1, 2, 3, b="1", c=2, e=0.0) + await provider9(1, 2, 3, b="1", c=2, e=0.0) # type: ignore[misc] + cat9 = await provider9.async_(1, 2, 3, b="1", c=2, e=0.0) + assert_type(cat9, Cat) # Test 10: to check the .provides provider10 = providers.Callable(Cat) -provides10: Optional[Callable[..., Cat]] = provider10.provides -assert provides10 is Cat +provides10 = provider10.provides +assert_type(provides10, Optional[Callable[..., Cat]]) # Test 11: to check the .provides for explicit typevar provider11 = providers.Callable[Animal](Cat) -provides11: Optional[Callable[..., Animal]] = provider11.provides -assert provides11 is Cat +provides11 = provider11.provides +assert_type(provides11, Optional[Callable[..., Animal]]) + # Test 12: to check string imports -provider12: providers.Callable[Dict[Any, Any]] = providers.Callable("builtins.dict") +# TODO: Use T_Any as Callable typevar? Then remove type-ignore +provider12 = providers.Callable("builtins.dict") # type: ignore[var-annotated] provider12.set_provides("builtins.dict")