Pylance complaining about missing parameters with injected classes

When using @inject I have issues with pylance getting mad that there are missing parameters for the classes I inject in. Is there a fix for this?

[and3rson]

@dkraczkowski sounds great! Writing a mypy plugin will be pretty easy with this, since the plugin will know which fields will be injected. The algorithm for the plugin will be as follows:

• Register a hook for kink.inject.inject function
• When the hook is called and the decorated object is mypy.types.Callable, inspect its arguments
• Mark the arguments of type Injectable[X] as optional, effectively making mypy ignore them.

Does this make sense? I’m open to any other suggestions!

[dkraczkowski]

@and3rson I think you are right and that’s the problem that the author has. But my point is you should not be doing this- you should not be instantiating class without arguments. Instead, you should request it from the DI.

Instead of doing this:

di[TemperatureService] = TemperatureService()

the Author should just do this:

instance = di[TemperatureService]

There is no need to instantiate TemperatureService manually when you can simply request it from the di, and if mypy will complain that it does not know what the instance is simply tell it, like below:

instance: TemperatureService = di[TemperatureService]

Your example after refactoring

from kink import di, inject

class User:
    def __init__(self, name):
        self.name = name

@inject
class UserRepository:
    def save(self, user: User) -> None:
        pass

# ...

 @inject
class UserService:
    def  __init__(self, repository: UserRepository):
        self.repository = repository
   
    def create_user(self, name: str) -> User: 
        user = User(name=name)
        self.repository.save(user)
        return user

# pylint  no longer complains here

service: UserService = di[UserService]
service.create_user("Foo Bar")

How it works

When you use the @inject decorator, it injects dependencies and registers the class itself in the di container. This means every class annotated with @inject can be requested from the DI container (kink.di), without the need to define a factory for them. Please consider the following example:

from kink import di, inject

@inject
class B:
    def __init__(self):
        ...

@inject
class A:
    def __init__(self, b: B):
        self.b = b

assert isinstance(di[A], A)
assert isinstance(di[B], B)

Hope this helps