Picodi Documentation

Picodi is a straightforward and powerful Dependency Injection (DI) library for Python, designed to simplify managing dependencies in both synchronous and asynchronous applications.

Dependency Injection is a design pattern where an object receives its dependencies from an external source rather than creating them itself. Picodi helps you implement this pattern effectively, making your code more modular, testable, and maintainable.

Inspired by FastAPI’s DI system but usable in any Python project (framework-agnostic), Picodi offers:

• Simplicity: Easy-to-understand API.

• Flexibility: Works seamlessly in sync and async code.

• Zero Dependencies: Lightweight and requires only Python.

• Lifecycle Management: Control over dependency creation and cleanup using scopes and lifespans.

• Testability: Built-in support for overriding dependencies in tests.

Whether you’re building a web application with FastAPI, a CLI tool, or any other Python project, Picodi can help you manage your dependencies cleanly.

Documentation

Getting Started

• Introduction
  • What is Dependency Injection?
  • How Picodi Helps
• Tutorial
  • Tutorial: 01 - First Steps
  • Tutorial: 02 - Yield Dependencies
  • Tutorial: 03 - Scopes
  • Tutorial: 04 - Asynchronous Dependencies
  • Tutorial: 05 - Dependency Overrides
  • Tutorial: 06 - Testing
  • Tutorial: 07 - Conclusion

User Guide

• Dependencies Explained
  • Simple Dependency Functions
  • Yield Dependencies (Resource Management)
  • Dependencies Using Other Dependencies
  • Injecting the Registry into a Dependency
  • Key Takeaways
• Dependency Injection
  • The @inject Decorator
  • The Provide Marker
  • Dependency Resolution Graph
  • Injecting into Methods
  • Sync vs. Async Injection
  • Key Takeaways
• Scopes
  • Assigning Scopes to Dependencies
  • Built-in Scopes
  • Manual vs. Auto Scopes
  • Automatic Initialization (auto_init)
  • User-defined Scopes
  • Key Takeaways
• Overriding Dependencies
  • Why Override Dependencies?
  • How to Override: registry.override()
  • Clearing Overrides
  • Key Takeaways
• Lifespan Management
  • Initialization: registry.init()
  • Shutdown: registry.shutdown()
  • Context Managers: lifespan and alifespan
  • Key Takeaways
• Asynchronous Code
  • Defining Async Dependencies
  • Async Yield Dependencies
  • Injecting Async Dependencies
  • Lifespan Management (init/shutdown)
  • Injecting Async Dependencies into Sync Functions
  • Key Takeaways
• Testing with Picodi
  • The Role of Dependency Overrides
  • Manual Overrides in Tests
  • Pytest Integration
  • Key Takeaways
• Framework Integrations
  • General Approach
  • Starlette Integration
  • FastAPI Integration
  • Key Takeaways
• Best Practices
  • Inject Dependencies Only at the Application Edges
  • Use Scopes Wisely
  • Keep Dependencies Simple
  • Leverage Type Hints
  • Don’t Try to Resolve Everything with Dependency Injection
  • Key Takeaways

Help & Info

• Frequently Asked Questions
  • Q: I’m injecting an async def dependency into a def function, but I get a coroutine object instead of the value. Why?
  • Q: When should I use SingletonScope vs. NullScope?
  • Q: Why do I need registry.shutdown()? When should I call it?
  • Q: Can I use Picodi without type hints?
  • Q: How does Picodi compare to FastAPI’s built-in DI?
  • Q: My tests are failing because of state leaking between them. What’s wrong?
  • Q: flake8-bugbear complains about B008 Do not perform function calls in argument defaults when using Provide. How to fix it?

• Index

• Module Index

• Search Page