Simple, small dependency injection container for python

Basics

class Users(object):

    def __init__(self, connection):
        self.connection = connection
        
    def fetch(self, limit=10):
        return self.connection....
        
class Connection(object):
    
    def __init__(self, username, password):
        self.username = username
        self.password = password

# configuration
from simpledi import Container

container = Container()
container.users = lambda c: Users(c.connection)
container.connection = lambda c: Connection(c.username, c.password)
container.username = lambda c: read_userame()
container.password = lambda c: read_password()

# usage
container.users.fetch()

Providers

The core concept of the container is the Provider which is a glorified callable that receives the container as the first argument. As simple as it is, this simple concept allow to create some more advanced providers that are explained below:

The AutoProvider

Receives a class name as it's only argument and, based on the name of the arguments of __init__ constructor, it creates the instance when called auto-providing the needed dependencies. For the example above, we can simple replace the manual provider methods for Users and Connections with the "auto" provider method:

from simpledi import auto

container.users = auto(Users)
container.connnection = auto(Connection)

The CacheProvider

For the example above, creating the connection each time might not be ideal; The cache provider it's simple provider that caches the result of the first call of the provider it wraps:

container.connection = cache(auto(Connection))

# same connection instance each time
assert container.connection == container.connection 

The InstanceProvider

Sometimes you just want to bind simple instances into container; as an example, if one of your dependencies is a simple string, you can bind it with container.my_string = lambda c: "a_string". You can use the instance provider to do the exact same thing:

container.my_string = instance("a string")
container.my_number = instance(42)

The ListInstanceProvider

You dependency might sometimes be a list of things; plugin architectures are a good example. Let's say we have an image conversion utility class that accepts a list of convertors as it dependencies and calls each one.

class ImageProcessor(object):
    
    def __init__(self, image_processors):
        self.image_processors = image_processors
        
    def process(self, imageurl):
        for processor in self.image_processors:
            self.image_processors.process(imageurl)

Now to wire everything up and allow for a an extension point in our application we can do:

container = Container()
container.image_processor = auto(ImageProcessor)
container.image_processors = ListInstanceProvider(
    auto(JpegProcessor),
    auto(PngProcessor)
)


# somewere down below, based on a configurtion flag or something:
container.get_provider('image_processors').add(auto(AsciiProcessor))


# and your image processor will be wired with the 3 image processors you configured
container.image_processor.process("http://....")