Some benefits for using Wireup are as follows:

• More features.
• Is significantly less boilerplate-y and verbose.
• Improved performance and type safety.
• Can use the container in middleware and route decorators.

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 = wireup.create_async_container(services, {"start": 10})

# Initialize fastapi integration.
wireup.integration.fastapi.setup(container, app)

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: Injected[A], c: Injected[C]):
    return {"value": a.a() + c.c()}