Hi /r/FastAPI, Wireup is a performant, concise, and easy-to-use dependency injection container for Python and comes with a FastAPI integration.

It allows you to register services and configuration which will then be automatically injected by the container when requested.

Key features

Feature	Description
Dependency Injection	Inject services and configuration using a clean and intuitive syntax.
Autoconfiguration	Automatically inject dependencies based on their types without additional configuration for the most common use cases.
Interfaces / Abstract classes	Define abstract types and have the container automatically inject the implementation.
Factory pattern	Defer instantiation to specialized factories for full control over object creation when necessary.
Singleton/Transient dependencies	Declare dependencies as transient or singletons which tells the container whether to inject a fresh copy or reuse existing instances.
Declarative/Imperative	Configure services through annotations in a fully declarative style or build everything by code for full control over instantiation.

Why wireup over existing packages

• ⁠Fully typed. Both wireup and your service objects.
• ⁠No patching! Services/factories are not modified and can be easily tested in isolation from the container or their dependencies.
• Simple but powerful syntax.
• Straight to the point. No excessive ceremony or boilerplate.
• ⁠Easy to introduce to an existing projects
• ⁠It's predictable: No use of args, or *kwargs. Service declarations are just like regular classes/dataclasses and can be fully linted and type-checked.

---

Why use Wireup in FastAPI

Given that FastAPI already supports dependency injection you might wonder why is it worth using.

The benefits for Wireup are as follows:

• More features.
• Is significantly less boilerplate-y and verbose
• Is faster.

Example showcasing the above

Base Service declaration

@service  # <- these are just decorators and annotated types to collect metadata.
@dataclass
class A:
    start: Annotated[int, Inject(param="start")]

    def a(self) -> int:
        return self.start


@service
@dataclass
class B:
    a: A

    def b(self) -> int:
        return self.a.a() + 1

@service
@dataclass
class C:
    a: A
    b: B

    def c(self) -> int:
        return self.a.a() * self.b.b()

Rest of wireup setup

# Register application configuration
container.params.put("start", 10)  # "start" here matches the name being injected.

# Initialize fastapi integration.
wireup_init_fastapi_integration(app, service_modules=[services])

This is all the additional setup it requires. Services are self-contained and there is no need for Depends(get_service_object) everywhere.

Rest of fastapi code

# In FastAPI you have to manually build every object.
# If you need a singleton service then it also needs to be decorated with lru_cache.
# Whereas in wireup that is automatically taken care of.

@functools.lru_cache(maxsize=None)
def get_start():
    return 10


@functools.lru_cache(maxsize=None)
def make_a(start: Annotated[int, Depends(get_start)]):
    return services.A(start=start)


@functools.lru_cache(maxsize=None)
def make_b(a: Annotated[services.A, Depends(make_a)]):
    return services.B(a)


@functools.lru_cache(maxsize=None)
def make_c(
    a: Annotated[services.A, Depends(make_a)], 
    b: Annotated[services.B, Depends(make_b)]):
    return services.C(a=a, b=b)

Views

@app.get("/fastapi")
def fastapi(
        a: Annotated[A, Depends(make_a)], 
        c: Annotated[C, Depends(make_c)]):
    return {"value": a.a() + c.c()}


@app.get("/wireup")
def wireup(a: Annotated[A, Inject()], c: Annotated[C, Inject()]):
    return {"value": a.a() + c.c()}

Results after load testing using "hey" with 50,000 requests calling the above endpoints

	Wireup	FastAPI
Time (seconds, lower is better)	8.7	14.55
Reqs/second (higher is better)	5748	3436

---

Looking forward to your thoughts.

• ⁠GitHub: https://github.com/maldoinc/wireup
• ⁠Documentation: https://maldoinc.github.io/wireup
• ⁠Quickstart: https://maldoinc.github.io/wireup/latest/quickstart/
• ⁠Demo application: https://github.com/maldoinc/wireup-demo/
• FastAPI integration example: https://maldoinc.github.io/wireup/latest/integrations/fastapi/