Basic usage

You start by defining the container of your dependencies. Whenever you want the container to resolve a dependency, it uses the container to search for existing objects and a resolver automatically creates desired dependencies:

from inseminator import Container


class DomainModel:
   def __init__(self):
      self.__logic_constant = 1

   def domain_logic(self, input_value: int) -> int:
      return input_value + self.__logic_constant


class Controller:
   def __init__(self, domain_model: DomainModel):
      self.__domain_model = domain_model

   def handler(self, input_value: int) -> int:
      return self.__domain_model.domain_logic(input_value)


# entry-point of your application

container = Container()

# view layer handling

controller = container.resolve(Controller)
result = controller.handler(1)
print(result)

The strategy for resolving Controller is its constructor signature. The resolver works as follows.

1. We ask the container to resolve a dependency Controller -> container.resolve(Controller).

2. Resolver inside the container checks the Controller’s constructor signature, i.e. type hints of __init__ method and sees domain_models: DomainModel.

3. If an instance of DomainModel class is already known by the container it uses that instance. In the opposite case, the container starts the same resolving machinery for DomainModel - which is the exact case we are facing now.

4. Because DomainModel doesn’t have any dependencies it can construct it directly.

5. Now the resolver has all the dependencies for Controller constructor and can instantiate it.

If we programmed against an interface instead of implementation the example is modified like this:

from inseminator import Container

from typing import Protocol

class DomainModel(Protocol):
   def domain_logic(self, input_value: int) -> int:
      ...

class Controller:
   def __init__(self, domain_model: DomainModel):
      self.__domain_model = domain_model

   def handler(self, input_value: int) -> int:
      return self.__domain_model.domain_logic(input_value)


# domain model implementation


class ConcreteDomainModel:
   def __init__(self):
      self.__logic_constant = 1

   def domain_logic(self, input_value: int) -> int:
      return input_value + self.__logic_constant


# entry point of your application

container = Container()
container.register(DomainModel, value=ConcreateDomainModel())

# view layer handling

controller = container.resolve(Controller)
result = controller.handler(1)
print(result)

In this situation, protocol DomainModel doesn’t hold implementation details, only interface. Using:

container.register(DomainModel, value=ConcreateDomainModel())

we’re guiding the resolver to use instance of ConcreateDomainModel in case someone asks for DomainModel.