FastAPI for APIs: Modern & Fast API Development with Python

FastAPI is a modern, fast and highly productive Python web framework used for building APIs (Application Programming Interfaces). It is based on the latest Python 3.8+ type hints and provides automatic data validation, serialization, documentation generation and API client generation. In this blog, we will dive deeper into the features and benefits of FastAPI and explore how it can be used to develop modern and fast APIs with Python.

Why Use FastAPI?

FastAPI is designed to be easy to use and fast. It is built on top of the Starlette ASGI framework, which is known for its high-performance capabilities. FastAPI also utilizes the Pydantic library for data validation and serialization, making it easy to work with complex data structures.

FastAPI is also highly extensible, meaning it can be easily customized and integrated with other Python libraries and frameworks. Additionally, it has built-in support for popular API authentication schemes such as OAuth2 and JWT (JSON Web Tokens).

Getting Started with FastAPI

To get started with FastAPI, you need to have Python 3.6 or higher installed on your system. You can install FastAPI and its dependencies using pip:

pip install fastapi

Once FastAPI is installed, you can create a new API application by creating a new Python file and importing the FastAPI class:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

In the above code, we have created a new FastAPI application and defined a single route with a GET method that returns a JSON response. We can run the application using the following command:

uvicorn main:app --reload

This will start a development server running on http://localhost:8000. You can visit this URL in your browser to see the "Hello World" message returned by the API.

Defining Routes

FastAPI provides decorators for defining routes and their associated HTTP methods. Here is an example of a route with a POST method:

@app.post("/items/")
async def create_item(item: Item):
    db_item = save_to_db(item)
    return {"id": db_item.id, **item.dict()}

In the above example, we have defined a route with a POST method that accepts a request body in the form of an Item object. The Item object is defined using the Pydantic library, which provides automatic data validation and serialization.

Automatic Data Validation and Serialization

FastAPI uses Pydantic models for automatic data validation and serialization. This makes it easy to work with complex data structures and ensures that data is always in the correct format.

Here is an example of a Pydantic model definition:

from typing import List

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None
    tags: List[str] = []

In the above example, we have defined an Item model that has a name, description, price, tax, and tags field. The description, tax, and tags fields are optional and have default values.

API Documentation

FastAPI automatically generates API documentation based on the route definitions and Pydantic models. This documentation can be accessed by visiting the /docs or /redoc endpoints of the API.

Here is an example of the automatically generated documentation for the create_item route:

API Client Generation

FastAPI also provides automatic API client generation based on the route definitions and Pydantic models. This makes it easy to consume the API from other Python applications or services.

To generate an API client, we can use the httpx library and the asyncapi module that comes with FastAPI. Here is an example of generating an API client for the create_item route:

from asyncapi import Client
from asyncapi.models import Item

client = Client("http://localhost:8000")

item = Item(name="New Item", price=10.99)
response = await client.create_item(item)

print(response)

In the above example, we have created a new Client object that points to the API server. We then create a new Item object and pass it to the create_item method of the client object. The response from the API is returned and printed to the console.

Conclusion

FastAPI is a modern and fast Python web framework that is perfect for building APIs. It provides automatic data validation and serialization, API documentation generation, and API client generation. FastAPI is easy to use and highly productive, making it a great choice for modern API development with Python.