FastDepends

Warnings

• breaking Version 3.0.0 introduced explicit serializer selection. If you were implicitly relying on Pydantic v1 behavior, you now need to explicitly pass a serializer instance (e.g., `PydanticSerializer()`) to the `@inject` decorator.
  Fix: Update `@inject` calls to specify `serializer=PydanticSerializer()` or `serializer=MsgSpecSerializer()` if custom validation or serialization fields (like `Pydantic.Field` or `Msgspec.field`) are used. For basic type casting, no explicit serializer might be needed.
• gotcha When running in a synchronous context, only synchronous dependencies are available. Asynchronous dependencies can only be resolved when the `@inject`'ed function itself is asynchronous and an event loop is running.
  Fix: Ensure that `async def` dependencies are only used within `async def` functions decorated with `@inject`, and that these functions are called within an active asyncio event loop. For synchronous `inject`'ed functions, use `def` dependencies.
• gotcha Dependencies are cached by default within a single call to an `@inject`'ed function. This means if a dependency is called multiple times by different sub-dependencies within the same top-level `@inject` call, it will only execute once and return the cached result.
  Fix: If a dependency needs to be executed every time it's referenced (e.g., for side effects or fresh data), set `cache=False` when declaring it: `Depends(my_dependency, cache=False)`.
• gotcha FastDepends leverages Pydantic for validation and type casting by default. Mixing FastDepends with projects or dependencies that are strictly tied to Pydantic v1 might lead to compatibility issues, especially if the new explicit serializer system is not used correctly.
  Fix: Ensure consistent Pydantic versions across your project. When using Pydantic-specific features with FastDepends, explicitly use `fast_depends.pydantic.PydanticSerializer` and ensure your Pydantic model definitions align with the installed Pydantic version (v1 or v2). FastDepends v3.x is generally compatible with Pydantic v2.

Install

• pip install fast-depends Install core library
• pip install fast-depends[pydantic] Install with Pydantic serializer
• pip install fast-depends[msgspec] Install with Msgspec serializer

Imports

• inject

  from fast_depends import inject

  The primary decorator for applying dependency injection to functions.
• Depends

  from fast_depends import Depends

  Used to declare a dependency on another callable.
• ContextDepends

  from fast_depends import ContextDepends

  Used for injecting context-aware dependencies (e.g., current request, user).
• PydanticSerializer

  from fast_depends.pydantic import PydanticSerializer

  Required when explicitly using Pydantic for serialization/validation with @inject.
• MsgSpecSerializer

  from fast_depends.msgspec import MsgSpecSerializer

  Required when explicitly using Msgspec for high-performance serialization/validation with @inject.

Quickstart

This quickstart demonstrates basic synchronous and asynchronous dependency injection using the `@inject` decorator and `Depends` for declaring dependencies. The `get_user_id` dependency is resolved and injected into `process_data`, while `async_get_greeting` is resolved into `greet_user`.

from fast_depends import inject, Depends

def get_user_id() -> int:
    return 42

@inject
def process_data(data: str, user_id: int = Depends(get_user_id)) -> str:
    return f"Processing '{data}' for user {user_id}"

result = process_data("hello world")
print(result)

# Async example (requires an event loop)
import asyncio

async def async_get_greeting() -> str:
    await asyncio.sleep(0.1)
    return "Hello"

@inject
async def greet_user(name: str, greeting: str = Depends(async_get_greeting)) -> str:
    return f"{greeting}, {name}!"

async def main_async():
    async_result = await greet_user("Alice")
    print(async_result)

# To run the async example in a synchronous environment:
# asyncio.run(main_async())