Injecting dependencies from parent class

[mateuszzebek]

Is there any way to inject dependencies that are annotated only in parent class? As in example showed below

class XX:
    
    def __init__(self):
        ...

class X:
    
    def __init__(self, xx: XX):
        self.xx = xx


class Y(X):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        
instance=XX()
injector = Injector(bindings=[
    SelfBinding(Y),
    InstanceBinding(XX, instance, named="xx"),
])
y=injector.inject(Y)

[Aegdesil]

There is no way to do that as there is no way to know which argument from the child class is mapped to which argument in the parent class (you could be manipulating the kwargs before calling the parent constructor).

You have 3 solutions:

• add type hints in the child class (but if you are asking this I guess you have a reason not to do that, maybe you don't control this code ?)
• add a Provider to generate the Y class, the provider would have the same dependencies as Y but can be injected if its constructor has typed arguments
• subclass the child class again with a class that only overwrites the constructor with typed arguments

[mateuszzebek]

Thanks for helping me out with this.

I'm not sure I get it right. Let's say I have code with long inheritance line, like

class Vehicle
class Car(Vehicle)
with attribute brand, model and seats, and 25 other attributes

class Minivan(Car)

in this situation, you're saying - if I want to inject dependencies to Minivan, I should:

• solution 1: copy and paste type hints for 28 attributes?
• solution 2: create a class Provider with type hints for 28 attributes? (I am not sure here, did not use Provider before, just looking at docs: https://github.com/illuin-tech/opyoid/blob/master/docs/providers.md)
• solution 3: create subclass with type hints for 28 attributes?

Seems like a lot of work. Especially if I have more subclasses of Car, not to say - subclasses of Minivan.
So there is no real solution for this problem? Or do I misunderstand what you're suggesting?

[Aegdesil]

If you have many arguments, you can try:

• grouping them into one or a few data classes
• if you are not adding any argument in your subclasses, split the constructor in two:

class Vehicle:
    def __init__(self, ...):
        self.a = ...
        self.b = ...
        self.__post_init__()

    def __post_init__(self):
        pass


class Car(Vehicle):
    def __post_init__(self):
        self.car_attribute = ...

[mateuszzebek]

Sure I could put attributes into data classes and I often do so, but in subclasses I usually have some single parameters that I don't want to put into a data class. Say I have class Car with a dependency - data class car_parameters constisting of many arguments; but then I have a subclass Minivan where I define additional parameter minivan_specific_parameter. How to inject both? Copypasting parent class annotations is the best practice?

[Aegdesil]

Well you can either repeat the parent dependencies in the subclass (if you group them you should not have too many), or you can refactor your code to remove the need for inheritance ?

Usually having too many dependencies is a sign that your class is violating the single-responsibility principle, and that it should be split into multiple classes. If you are using dependency injection, you should not be afraid to have a lot of small classes, since the setup is handled by the library.

It is difficult to answer precisely without seeing your exact use case, but if you are using inheritance only to share code between some objects, you should instead create a separate class instead of a parent class.