0Pricing
FastAPI Backend Development Bootcamp · Lesson

Class-based & Yield Dependencies

Learn to create more complex dependencies using classes and manage resources with `yield` for setup and teardown logic.

Class-based & Yield Dependencies is a free FastAPI Backend Development Bootcamp lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the FastAPI Backend Development Bootcamp learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Beyond Simple Function Dependencies

In previous lessons, we learned about basic function-based dependencies in FastAPI. These are great for simple tasks like validation or injecting common values.

But what if your dependency needs to maintain state, accept configuration, or manage resources that require both setup and cleanup? That's where class-based and yield dependencies come in!

Why Use Class-Based Dependencies?

Class-based dependencies offer several advantages for more complex scenarios:

  • Organization: Encapsulate related logic and data within a class.
  • State: Classes can hold internal state, which can be useful (though be mindful of request isolation).
  • Configuration: Easily pass parameters to the dependency during its instantiation.
  • Testability: Easier to mock or inject specific class instances for testing.

Defining a Class Dependency

To create a class-based dependency, you define a Python class. FastAPI can then use an instance of this class. If your class has a __call__ method, FastAPI will invoke it to get the dependency's value.

Let's see a simple example:

class MyService:
    def __init__(self):
        self.message = "Welcome from MyService!"

    def __call__(self):
        # This method is called by FastAPI to get the value
        return self.message

# Simulate FastAPI's usage:
# FastAPI would instantiate MyService() once or per request
service_instance = MyService()

# It then calls the __call__ method to get the value
dependency_value = service_instance()
print(dependency_value)

How FastAPI Handles Class Dependencies

When you use Depends(MyClass), FastAPI will:

  • Create an instance of MyClass.
  • If MyClass has a __call__ method, it will call it and use the returned value as the dependency.
  • Otherwise, it will use the instance of MyClass itself as the dependency.

If you use Depends(MyClass()), you're passing an already instantiated object, and FastAPI will simply use that object (and its __call__ method if present).

Class Dependencies with Parameters

A major benefit of class-based dependencies is the ability to pass parameters to their constructor. This is perfect for injecting configuration or other dependencies into your service class.

Imagine a service that needs an API key:

class ExternalApiService:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.external.com"

    def __call__(self):
        return f"API Service configured with key: {self.api_key}"

# In a real FastAPI app, the api_key might come from
# an environment variable or another dependency.
# Here, we simulate instantiation with different keys.

prod_api = ExternalApiService(api_key="prod_secret_123")
dev_api = ExternalApiService(api_key="dev_test_abc")

print(prod_api())
print(dev_api())

Introducing Yield Dependencies

Some resources, like database connections or file handlers, need not only to be set up but also properly cleaned up afterwards. This is where yield dependencies shine!

A yield dependency is a generator function that allows you to run code before the endpoint is executed (setup) and after the response is sent (teardown).

Yield for Resource Setup

The code before the yield statement in your dependency function is executed as setup logic. The value that is yielded is what your endpoint function will receive as a dependency.

def get_database_session():
    print("DB: Establishing connection...") # Setup logic
    db_session = {"id": 1, "status": "active"} # Simulate a session
    yield db_session # This value is passed to the dependent function
    # Teardown logic (after yield) would go here

# Simulate a function that uses the dependency
def process_data(session):
    print(f"Endpoint: Processing data with session ID: {session['id']}")

# How FastAPI conceptually uses it:
# 1. Calls get_database_session()
# 2. Takes the yielded value
# 3. Passes it to process_data()

session_generator = get_database_session()
active_session = next(session_generator) # Runs setup, gets yielded value
process_data(active_session)
# FastAPI would then ensure the generator is closed, triggering teardown.

Yield for Resource Teardown

The power of yield dependencies is in their ability to perform cleanup. Any code placed after the yield statement will execute once the request has finished and the response has been sent.

This is typically done within a try...finally block to guarantee cleanup, even if errors occur.

def get_file_handle():
    print("File: Opening 'log.txt'...")
    file_handle = open("log.txt", "w") # Simulate opening a file
    try:
        yield file_handle # Provide the file handle
    finally:
        print("File: Closing 'log.txt'.")
        file_handle.close() # Teardown logic: close the file

# Simulate a function using the dependency
def write_log(f_handle):
    f_handle.write("Lesson content generated.\n")
    print("Endpoint: Wrote to log file.")

# Manual simulation of FastAPI's lifecycle:
file_generator = get_file_handle()
current_file = next(file_generator) # Setup runs
write_log(current_file)

# This step would be handled by FastAPI to trigger teardown
try:
    next(file_generator) # Continues generator, runs finally block
except StopIteration:
    print("Generator exhausted, teardown complete.")

Combining Class-based & Yield Dependencies

You can use both class-based and yield dependencies together! For instance, a class-based dependency might provide configuration for a database, and a yield dependency would then use that configuration to establish and close a database connection.

This allows for highly modular and robust resource management within your FastAPI application.

Quick Check

Consider the benefits and use cases for advanced dependency injection patterns.

Lesson Summary

Great job! In this lesson, you've leveled up your understanding of FastAPI dependencies.

  • Class-based dependencies help organize complex logic, maintain state, and accept configuration.
  • Yield dependencies (generator functions) are powerful for managing resources that require both setup (before yield) and guaranteed teardown (after yield, often in a finally block).

These patterns make your FastAPI applications more robust, maintainable, and easier to test.

Frequently asked questions

Is the “Class-based & Yield Dependencies” lesson free?

Yes — the full text of “Class-based & Yield Dependencies” is free to read here on the web, and the FastAPI Backend Development Bootcamp course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the FastAPI Backend Development Bootcamp course, upgrade to CoddyKit PRO.

What will I learn in “Class-based & Yield Dependencies”?

Learn to create more complex dependencies using classes and manage resources with `yield` for setup and teardown logic. You practise FastAPI Backend Development Bootcamp with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start FastAPI Backend Development Bootcamp?

No prior experience is required. FastAPI Backend Development Bootcamp on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Class-based & Yield Dependencies” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this FastAPI Backend Development Bootcamp lesson?

Yes. Every FastAPI Backend Development Bootcamp lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Understanding Dependencies in FastAPI
  2. Injecting Common Dependencies
  3. Class-based & Yield Dependencies
  4. Global Dependencies and Sub-Dependencies
← Back to FastAPI Backend Development Bootcamp