Optional dependencies

I am trying to create a container that optionally takes a dependency, and otherwise provides a value derived from another provider. The (IMO) hacky solution I have so far is a custom provider which either provides a Callable, or a default value if the callable has an error. Then I use this with the Callable being the dependency provider.

My questions are (1) is there a better way? and (2) even using this method, DefaultCallable defined below seems like a hack – how can I improve?

T = TypeVar("T")

class DefaultCallable(providers.Provider):

    __slots__ = ("_callable", "_default")

    def __init__(
        self, callable: Callable[..., T], default: T, *args, **kwargs
    ):
        self._default = default
        self._callable = providers.Callable(callable, *args, **kwargs)

        super().__init__()

    def __deepcopy__(self, memo):
        copied = memo.get(id(self))
        if copied is not None:
            return copied

        # TODO: type?
        copied = self.__class__(
            cast(Callable[..., T], self._callable.provides),
            providers.deepcopy(self._default, memo),
            *providers.deepcopy(self._callable.args, memo),
            **providers.deepcopy(self._callable.kwargs, memo),
        )
        self._copy_overridings(copied, memo)
        return copied

    def _provide(self, args, kwargs):
        try:
            return self._callable(*args, **kwargs)
        except Exception:
            # TODO: why do we need to check if is provider?
            # type?
            if getattr(cast(Any, self._default), "__IS_PROVIDER__", False):
                return cast(Any, self._default)()
            else:
                return self._default

# Used like

class Foo(containers.DeclarativeContainer):

    #: specify dv for pattern discovery (optional)
    dv_in: Provider[xr.DataArray] = providers.Dependency(
        instance_of=xr.DataArray
    )

    #: dv for pattern discovery (specified or default)
    dv: Provider[xr.DataArray] = DefaultCallable(
        # cast(Callable[..., xr.DataArray], dv_in), type??
        cast(Any, dv_in),
        problem.training.provided["dv"],
    )

[rmk135]

Hey @shaunc , check this sample:

from dependency_injector import containers, providers


class DataArray:
    ...


class DefaultDataArray(DataArray):
    ...


class ExtraDataArray(DataArray):
    ...


class DependencyWithDefault(providers.Dependency):

    def __init__(self, instance_of=object, default=None):
        super().__init__(instance_of)
        if default:
            self.override(default)


class Foo(containers.DeclarativeContainer):

    problem_training = providers.Dict({"dv": DefaultDataArray()})

    dv_in: providers.Provider[DataArray] = DependencyWithDefault(
        instance_of=DataArray,
        default=problem_training.provided["dv"],
    )


if __name__ == '__main__':
    container_with_default = Foo()
    default_dv_in = container_with_default.dv_in()

    container_with_extra = Foo(dv_in=ExtraDataArray())
    extra_dv_in = container_with_extra.dv_in()

    assert isinstance(default_dv_in, DefaultDataArray)
    assert isinstance(extra_dv_in, ExtraDataArray)

If I got it right, the cornerstone idea is to have a default provider for the dependency. If so, the easiest way to make it is to override the dependency provider in the declarative container.

You can achieve this by extending the Dependency provider like in the sample above, or even without that:

class Foo(containers.DeclarativeContainer):

    problem_training = providers.Dict({"dv": DefaultDataArray()})

    dv_in: providers.Provider[DataArray] = providers.Dependency(instance_of=DataArray)
    dv_in.override(problem_training.provided["dv"])

Appreciate your feedback.

PS: the idea of adding a default argument like in the first sample seems reasonable. I’ll add it to the backlog.

[rmk135]

Hey @shaunc , will need some time to answer.