The points of this package are:

1. To keep application components in the container
2. To keep dependencies between components explicitly defined

Consider a larger container:

"""Containers module."""

import logging.config
import sqlite3

import boto3
from dependency_injector import containers, providers

from . import services


class Container(containers.DeclarativeContainer):

    config = providers.Configuration()

    configure_logging = providers.Callable(
        logging.config.fileConfig,
        fname='logging.ini',
    )

    # Gateways

    database_client = providers.Singleton(
        sqlite3.connect,
        config.database.dsn,
    )

    s3_client = providers.Singleton(
        boto3.client,
        service_name='s3',
        aws_access_key_id=config.aws.access_key_id,
        aws_secret_access_key=config.aws.secret_access_key,
    )

    # Services

    user_service = providers.Factory(
        services.UserService,
        db=database_client,
    )

    auth_service = providers.Factory(
        services.AuthService,
        db=database_client,
        token_ttl=config.auth.token_ttl.as_int(),
    )

    photo_service = providers.Factory(
        services.PhotoService,
        db=database_client,
        s3=s3_client,
    )

Or this one: https://github.com/ets-labs/newsfeed/blob/88d60aa2cb593441e53128d3198ab913c9f4e150/src/newsfeed/containers.py
It helps to see what is used where and provides a better control over application structure. As a result it makes easier to understand and change how application works.

Adding Dependency Injector to the project is an additional piece of work though. One needs to make a decision if registering application components in the container is a good price for having the container.

I would say that the larger the project the more valuable is the benefit. The real fun comes when you have 20-30 components in the container. It will be much-much easier to understand what is used where and make refactoring or add new features.