What's the point of this library?

[stefanoborini]

I don't get the core reason behind this library. All it does is to save you to pass the dependency at invocation time, something that not only is literally a few keystrokes, but it actually removes the caller from the benefit to notice that the dependency has been passed, so it's actually detrimental to readability, as the dependency is passed magically without any clear indication that a dependency has been passed and is going to be used unless you specifically look inside the code of the callee.

Finally, how does this affect debuggability?

[rmk135]

Hello Stefano,

Imagine a large dependency injection-based application. You have a service that uses a client, that uses a database, that requires a configuration object: Service -> Client -> Database -> Config. The example is naive, but should be good for demonstrating the answer. The top level of your application is some sort of controller (endpoint / view / command / etc). You have three such controllers. Here is how it would look like:

def controller1():
    service = Service(
        client=Client(
            database=Database(
                config=Config(
                    value1=1,
                    value2=2,
                ),
            ),
        ),
    )
    ...


def controller2():
    service = Service(
        client=Client(
            database=Database(
                config=Config(
                    value1=1,
                    value2=2,
                ),
            ),
        ),
    )
    ...


def controller3():
    service = Service(
        client=Client(
            database=Database(
                config=Config(
                    value1=1,
                    value2=2,
                ),
            ),
        ),
    )
    ...

Now we need to change database type. We will use ExtendedDatabase class. What you would need to do is making a change in all the places where Database is used:

def controller1():
    service = Service(
        client=Client(
            database=ExtendedDatabase(  # <-- Change 1
                config=Config(
                    value1=1,
                    value2=2,
                ),
            ),
        ),
    )
    ...


def controller2():
    service = Service(
        client=Client(
            database=ExtendedDatabase(  # <-- Change 2
                config=Config(
                    value1=1,
                    value2=2,
                ),
            ),
        ),
    )
    ...


def controller3():
    service = Service(
        client=Client(
            database=ExtendedDatabase(  # <-- Change 3
                config=Config(
                    value1=1,
                    value2=2,
                ),
            ),
        ),
    )
    ...

Why that happens? Cause you had to duplicate too much knowledge about how you assemble objects. Dependency Injector provides you with building block so you could describe how you're going to assemble your objects without actually assembling them.

class Container(containers.DeclarativeContainer):
    config = providers.Factory(Config, value1=1, value2=2)
    database = providers.Factory(ExtendedDatabase, config=config)  # <-- The only change
    client = providers.Factory(Client, database=database)
    service = providers.Factory(Service, client=client)


def controller1(container: Container):
    service = container.service()
    ...


def controller2(container: Container):
    service = container.service()
    ...


def controller3(container: Container):
    service = container.service()
    ...

The benefit you're talking about could be a downside on a lager scale. The good news is that with the Dependency Injector you still see what is passed where in the container:

class Container(containers.DeclarativeContainer):
    config = providers.Factory(Config, value1=1, value2=2)
    database = providers.Factory(ExtendedDatabase, config=config)
    client = providers.Factory(Client, database=database)
    service = providers.Factory(Service, client=client)

[rmk135]

Right. You can pass database to the controller:

def controller1(database):
    service = Service(
        client=Client(
            database=database
            ),
        ),
    )
    
def controller2(database):
    service = Service(
        client=Client(
            database=database
            ),
        ),
    )
    
def controller3(database):
    service = Service(
        client=Client(
            database=database
            ),
        ),
    )

Now imagine the structure of application has changed that way that you need to change Client to the ExtendedClient. And ExtendedClient doesn't have a dependency on database:

def controller1(database):           # Change: remove not needed dependency
    service = Service(
        client=ExtendedClient(...),  # Change
    )
    
def controller2(database):           # Change: remove not needed dependency
    service = Service(
        client=ExtendedClient(...),  # Change
    )
    
def controller3(database):           # Change: remove not needed dependency
    service = Service(
        client=ExtendedClient(...),  # Change
    )

6 changes instead of 1 with framework.

[stefanoborini]

All right, I'm sold. Thanks!

[rmk135]

No problems. Thanks for asking.

[stefanoborini]

I think this is an excellent demonstration of its power. You should add this to your documentation. If you come in by knowing the dependency injection pattern it is quite confusing to understand the difference.

[rmk135]

Agree, that's a good idea. I have this page in the docs: https://python-dependency-injector.ets-labs.org/introduction/di_in_python.html. It's sort of similar topic, but doesn't talk exactly about what we discuss here. I think I'll add a link to this discussion there. Or may be will create FAQ page.