Skip to content
📦 Autowiring dependency injection container for python 3
Python Shell
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.

Lagom - Dependency injection container

Build Status Scrutinizer Code Quality Code Coverage PyPI


Lagom is a dependency injection container designed to give you "just enough" help with building your dependencies. The intention is that almost all of your code does't know about or rely on lagom. Lagom will only be involved at the top level to pull everything together.

An example usage can be found here:


pip install lagom
# or: 
# pipenv install lagom
# poetry add lagom


Everything in Lagom is based on types. To create an object you pass the type to the container:

container = Container()
some_thing = container[SomeClass]

Defining a singleton

container[SomeExpensiveToCreateClass] = SomeExpensiveToCreateClass("up", "left")

alternatively if you want to defer construction until it's needed:

container[SomeExpensiveToCreateClass] = Singleton(SomeExpensiveToCreateClass)

Defining a type that gets recreated every time

container[SomeClass] = lambda: SomeClass("down", "spiral")

if the type needs things from the container the lambda can take a single argument which is the container:

container[SomeClass] = lambda c: SomeClass(c[SomeOtherDep], "spinning")

if your construction logic is longer than would fit in a lambda a function can also be bound to the container:

def my_constructor() -> MyComplexDep:
    # Really long
    # stuff goes here
    return MyComplexDep(some_number=5)

Alias a concrete instance to an ABC

container[SomeAbc] = ConcreteClass

Partially bind a function

Apply a function decorator to any function.

def handle_some_request(request: typing.Dict, game: Game):
    # do something to the game

This function can now be called omitting any arguments that the container knows how to build.

# we can now call the following. the game argument will automagically
# come from the container
handle_some_request(request={"roll_dice": 5})

Invocation level caching

Suppose you have a function and you want all the dependencies to share an instance of an object then you can define invocation level shared dependencies.

class ProfileLoader:
    def __init__(self, loader: DataLoader):

class AvatarLoader:
    def __init__(self, loader: DataLoader):

@bind_to_container(container, shared=[DataLoader])
def handle_some_request(request: typing.Dict, profile: ProfileLoader, user_avatar: AvatarLoader):
    # do something to the game

now each invocation of handle_some_request will get the same instance of loader so this class can cache values for the invocation lifetime.

Alternative to decorator

The above example can also be used without a decorator if you want to keep the pure unaltered function available for testing.

def handle_some_request(request: typing.Dict, game: Game):

# This new function can be bound to a route or used wherever
# need
func_with_injection = container.partial(handle_some_request)

Full Example

App setup

from abc import ABC
from dataclasses import dataclass

from lagom import Container

# Here is an example of some classes your application may be built from

DiceApiUrl = NewType("DiceApiUrl", str)

class RateLimitingConfig:

class DiceClient(ABC):

class HttpDiceClient(DiceClient):

    def __init__(self, url: DiceApiUrl, limiting: RateLimitingConfig):

class Game:
    def __init__(self, dice_roller: DiceClient):

# Next we setup some definitions

container = Container()
# We need a specific url
container[DiceApiUrl] = DiceApiUrl("")
# Wherever our code wants a DiceClient we get the http one
container[DiceClient] = HttpDiceClient

# Now the container can build the game object

game = container[Game]

Modifying the container instead of patching in tests

Taking the container from above we can now swap out the dice client to a test double/fake. When we get an instance of the Game class it will have the new fake dice client injected in.

def container_fixture():
    from my_app.prod_container import container
    return container.clone() # Cloning enables overwriting deps

def test_something(container_fixture: Container):
    container_fixture[DiceClient] = FakeDice(always_roll=6)
    game_to_test = container_fixture[Game]
    # TODO: act & assert on something


Starlette (

To make integration with starlette simpler a special container is provided that can generate starlette routes.

Starlette endpoints are defined in the normal way. Any extra arguments are then provided by the container:

async def homepage(request, db: DBConnection):
    user = db.fetch_data_for_user(request.user)
    return PlainTextResponse(f"Hello {}")

container = StarletteContainer()
container[DBConnection] = DB("DSN_CONNECTION_GOES_HERE")

routes = [
    # This function takes the same arguments as starlette.routing.Route
    container.route("/", endpoint=homepage),

app = Starlette(routes=routes)

FastAPI (

FastAPI already provides a method for dependency injection however if you'd like to use lagom instead a special container is provided.

Calling the method .depends will provide a dependency in the format that FastAPI expects:

container = FastApiContainer()
container[DBConnection] = DB("DSN_CONNECTION_GOES_HERE")

app = FastAPI()

async def homepage(request, db = container.depends(DBConnection)):
    user = db.fetch_data_for_user(request.user)
    return PlainTextResponse(f"Hello {}")

Flask API (

A special container is provided for flask. It takes the flask app then provides a wrapped route decorator to use:

app = Flask(__name__)
container = FlaskContainer(app)
container[Database] = Singleton(lambda: Database("connection details"))

@container.route("/save_it/<string:thing_to_save>", methods=['POST'])
def save_to_db(thing_to_save, db: Database):
    return 'saved'

(taken from

The decorator leaves the original function unaltered so it can be used directly in tests.


Contributions and PRS are welcome. For any large changes please open an issue to discuss first. All PRs should pass the tests, type checking and styling. To get development setup locally:

pipenv install --dev


./scripts/ # To format the code
./scripts/ # To make sure the build will pass

Design Goals

  • The API should expose sensible typing (for use in pycharm/mypy)
  • Everything should be done by type. No reliance on names.
  • All domain code should remain unmodified. No special decorators.
  • Usage of the container should encourage code to be testable without monkey patching.
  • Embrace modern python features (3.7 at the time of creation)
You can’t perform that action at this time.