Adding type hints to dependency-injector

[awaizman1]

Hi,

Now that python typing (type hints) is very common, it would be great that dependency-injector will have type hints / annotations.
Currently when using Container / Provider classes mypy complains since it doesn't have information about a provider returned type, etc.

For example:

provider: Provider[Animal] = providers.Factory(Cat)

animal = provider()  # mypy can know that animal is of type Animal

My current workaround is to put type: ignore in many places but it is less desired since I won't get errors at type checking time.

Thanks

[rmk135]

Hi @awaizman1 ,

Yep, that will be useful. I've faced the same problem on the own projects.

Fairly saying I did an attempt to make it work but there was some problem with generics I couldn't solve. I'll try to make it work again.

[agates4]

I will also say that this is the exact feature that I am looking for. Type hinting is very useful and will put this library above and beyond!

+++++1

[rmk135]

Got it. Thanks for feedback. Dependency Injector will have typing support.

[JarnoRFB]

I am not at all familiar with the code base, so I don't now how to implement this as a feature, but I was able to add correct type inference for the return type with

T = TypeVar("T")


class TypedFactory(providers.Factory, Generic[T]):

    def __init__(self, cls: Type[T], *args, **kwargs):
        super().__init__(cls, *args, **kwargs)

    def __call__(self, *args, **kwargs) -> T:
        return super().__call__(*args, **kwargs)

What I would really look forward to would be type safety when creating the object graph / the providers. I believe that should be possible once ParamSpec lands in Python. Then one could consider doing something like.

P = ParamSpec("P")
R = TypeVar("R")

def factory(cls: Callable[P, R]) -> Callable[P, R]

and use it like

a = providers.factory(A)(arg1, kwarg1=42)

[rmk135]

Hey @JarnoRFB ,

This code sample will help a lot. I did something similar experimenting with the generics and mypy. It didn't work when I tried. I'm glad to know that it works now.

The ParamSpec is exactly what is needed. I didn't know it's coming. That's very good. Thanks for the sharing.

[rmk135]

Typing stubs are added at 3.33.0.

I've used the generics-based approach provided by @JarnoRFB:

provider = providers.Factory(Cat)
animal = provider()  # mypy knows that animal is of type Cat

I've also added new types module. It contains Provider[T] generic type. This generic is useful when you need to specify the type explicitly. It can be used with any provider.

from dependency_injector import providers, types


provider: types.Provider[Animal] = providers.Factory(Cat)

animal = provider()  # mypy know that animal is of type Animal

[awaizman1]

Hi @rmk135,

Thanks a lot for quick feature addition.

I tried using it but still can't make it work as expected (and a bit confused).

I saw the library now has 2 competing files:

• type stubs: providers.pyi
• types.py - holds Provider[Generic[T]]

Consider the following example:

class Foo:
    pass

provider: Provider[Foo] = providers.Factory(Foo)
provider.override(providers.Singleton(Foo))

When using the type stubs (from dependency_injector.providers import Provider), the Provider defined there has all the methods as expected (i.e. override, delegate, etc.) but lacks the Generic type info thus getting this mypy error:

error: "Provider" expects no type arguments, but 1 given  [type-arg]

When using type.py (from dependency_injector.types import Provider) the Provider lacks all methods (i.e. override, etc.) thus getting this mypy error:

 error: "Provider[Foo]" has no attribute "override"  [attr-defined]

I think it would be great to enhance the type stubs (providers.pyi) to include the type argument - from a user perspective this is expected behavior when working with typed objects in python (as opposed to have this info in a separate different module)

[rmk135]

Hi @awaizman1 ,

I've faced a technical limitation implementing this feature. Let me show it.

1st part. When you do from dependency_injector import providers:

• mypy uses stubs from providers.pyi
• Python uses real providers module

2nd part of the puzzle is that there is no way to build in typing support into the providers module. Dependency Injector still supports Python 2.7. I'm also not yet sure how to add the typing to the Cython module. I assume it should work, but have not tried to make it.

Moving of the generic types.Provider to the stubs module will make mypy happy, but will not work when you run the code. providers.Provider is not a real generic and it will fail in the Python runtime.

Stubs providers.pyi and module types.py were not designed to be competitive. They serve different purpose. Stubs should cover the providers definition cases. Provider from the types.py is for the case when a provider is an argument of some function.

---

One thing I can do as a temporary solution is to add the .override() definition to the types.py so it doesn't cause an error.

---

Another issue with the types.Provider module is that the check isinstance(providers.Provider, types.Provider) will return False. That's not nice. I don't yet know how to fix it. Need to think of it.

Appreciate your and others thoughts.