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/ More on reddit.com

I'm thinking to use magic on my upcoming side project, great stuff It's fascinating to see the Python community steadily introduce new libraries aimed at simplifying Dependency Injection. Some recent additions to the scene include FastDepends and Dishka . I'm curious to see how magic-di will stack up against these. It's like a silent battle for the most efficient and user-friendly DI solution More on reddit.com

How does it compare to these projects: ? https://github.com/imwithye/flask-inject https://github.com/python-injector/flask_injector https://github.com/ets-labs/python-dependency-injector More on reddit.com

Automated dependency injectors are not very pythonic - I've not seen a great argument for using them in python that doesn't shoot down monkey patching for nonexistent reasons. 230 stars is quite a lot for a module that does something the language simply doesn't need. More on reddit.com