FastAPI

FastAPI is a modern, high-performance web framework for building APIs with Python. It is based on standard Python type hints and leverages two core libraries:

• Starlette: Handles the web parts.
• Pydantic: Handles the data parts.

Key characteristics include:

• High Performance: On par with NodeJS and Go.
• Standards-based: Fully compatible with OpenAPI (formerly Swagger) and JSON Schema.
• Developer Experience: Provides excellent editor support (autocompletion/IntelliSense) and automatic interactive documentation.

FastAPI is a modern, high-performance web framework for building APIs with Python. It is based on standard Python type hints and leverages Starlette for web capabilities and Pydantic for data validation and serialization.

Key characteristics include:

• High Performance: On par with NodeJS and Go.
• Developer Efficiency: Designed to increase development speed and reduce human-induced errors.
• Standards-based: Fully compatible with OpenAPI and JSON Schema.
• Robustness: Provides automatic interactive documentation.

Middleware is a function that intercepts every request before it reaches a specific path operation and every response before it is returned to the client.

The Middleware Lifecycle:

1. It receives the incoming request.
2. It can perform actions on the request or run code.
3. It passes the request to the rest of the application (the path operation) using a call_next function.
4. It receives the response generated by the application.
5. It can perform actions on the response or run code.
6. It returns the final response.

Technical Details:

• If you use dependencies with yield, the exit code runs after the middleware.
• Background tasks run after all middleware have finished.

Dependency Injection (DI) is a system where your path operation functions declare the requirements (dependencies) they need to work, and FastAPI takes care of providing (injecting) those dependencies.

This is useful for:

• Sharing logic across multiple endpoints.
• Sharing database connections.
• Enforcing security, authentication, or role requirements.
• Minimizing code repetition.

Dependencies can form a hierarchical tree where one dependency depends on another (sub-dependencies). FastAPI resolves the entire tree and provides the results to your functions.

Dependencies declared in the dependencies list of a path operation decorator behave with the following characteristics:

• Requirement fulfillment: They can declare request requirements like headers or other sub-dependencies.
• Exception handling: They can raise exceptions (e.g., HTTPException) just like normal dependencies. If an exception is raised, the path operation will not execute.
• Return values: They can return values, but those values are discarded and not accessible within the path operation function.
• Reusability: You can reuse existing dependency functions that return values; even if the return value is ignored, the dependency logic will still run.

When you declare a response_model or a return type hint in a path operation, FastAPI uses Pydantic to serialize the data to JSON. This process is highly optimized (using Rust in recent versions) and is generally much faster than manually creating a JSONResponse with jsonable_encoder.

When using a response_model, FastAPI skips the jsonable_encoder step and instead takes the JSON bytes generated by Pydantic and returns a Response with the application/json media type directly.

When adding custom proprietary headers (often using the X- prefix), browsers will not allow client-side code (like JavaScript fetch) to access them by default due to CORS security.

To make custom headers visible to a client in a browser, you must add them to your CORS configuration using the expose_headers parameter in your CORS middleware.

You can control how much of a path operation's docstring is used for the OpenAPI description by inserting an escaped form feed character (\f). FastAPI will truncate the description at this character, preventing it from appearing in the OpenAPI schema while allowing other tools (like Sphinx) to still access the full text.

@app.get("/items/")
def read_items():
    """
    This is the description that will show in OpenAPI.\f
    This part will be hidden from OpenAPI but visible to other tools.
    """
    return [{"item": "Portal Gun"}]