FAST API

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints. Here are several reasons why FastAPI is an excellent choice for building APIs:

1. Speed

FastAPI is one of the fastest web frameworks available, thanks to its use of Starlette for the web parts and Pydantic for the data parts. It’s designed to be as fast as possible, ensuring that your API has minimal latency and high throughput.

2. Ease of Use

FastAPI leverages Python’s type hints, making the code easier to write and understand. It automatically generates interactive API documentation (using Swagger UI and ReDoc), which simplifies testing and understanding of the API endpoints.

3. Data Validation

FastAPI uses Pydantic for data validation and parsing. This ensures that the data sent to the API is correctly formatted and validated before any further processing.

4. Automatic Documentation

FastAPI generates interactive API documentation from your code using OpenAPI. This is extremely helpful for developers, as they can see and interact with the API directly from the browser.

5. Asynchronous Support

FastAPI has first-class support for asynchronous programming, making it easy to write asynchronous endpoints that can handle large numbers of concurrent requests efficiently.

6. Dependency Injection

FastAPI provides a powerful dependency injection system that makes it easy to manage and inject dependencies into your endpoints, which can simplify the design of your application and improve its testability.

7. Security

FastAPI includes tools to handle security and authentication, like OAuth2 and JWT tokens, right out of the box.

8. Community and Ecosystem

FastAPI has a growing community and a rich ecosystem of plugins and extensions. It integrates well with other popular Python libraries and tools, such as SQLAlchemy for ORM, Celery for background tasks, and others.

Example: Building a tasklist FastAPI

1. Imports

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
from uuid import UUID, uuid4
  • FastAPI: The web framework for building APIs.
  • HTTPException: Used to raise HTTP errors.
  • BaseModel: A base class from Pydantic for creating data models.
  • List, Optional: Type hints for better code readability and type checking.
  • UUID, uuid4: For generating unique identifiers for each task or blog post.

2. Initialize FastAPI

app = FastAPI()
  • Creates an instance of the FastAPI application.

3. Define the Task Model

class Task(BaseModel):
    id: Optional[UUID] = None
    title: str
    description: Optional[str] = None
    completed: bool = False
  • Task: This is a data model for tasks with optional id, title, optional description, and completed status.

4. In-Memory Storage

tasks = []
  • tasks: A list to store the tasks. In a real application, this would typically be a database.

5. Create Task Endpoint

@app.post("/tasks/", response_model=Task)
def create_task(task: Task):
    task.id = uuid4()
    tasks.append(task)
    return task
  • @app.post(“/tasks/”): This is a POST endpoint to create a new task.
  • create_task: A function that accepts a Task, assigns it a unique id, and adds it to the tasks list.

6. Read All Tasks Endpoint

@app.get("/tasks/", response_model=List[Task])
def read_tasks():
    return tasks
  • @app.get(“/tasks/”): This is a GET endpoint to read all tasks.
  • read_tasks: A function that returns the list of all tasks.

7. Read Task by ID Endpoint

@app.get("/tasks/{task_id}", response_model=Task)
def read_task(task_id: UUID):
    for task in tasks:
        if task.id == task_id:
            return task
        
    raise HTTPException(status_code=404, detail="Task not found")
  • @app.get(“/tasks/{task_id}”): This is a GET endpoint to read a specific task by its ID.
  • read_task: A function that searches for a task by its ID. If found, it returns the task; otherwise, it raises a 404 error.

8. Update Task Endpoint

@app.put("/tasks/{task_id}", response_model=Task)
def update_task(task_id: UUID, task_update: Task):
    for idx, task in enumerate(tasks):
        if task.id == task_id:
            updated_task = task.copy(update=task_update.dict(exclude_unset=True))
            tasks[idx] = updated_task
            return updated_task
        
    raise HTTPException(status_code=404, detail="Task not found")
  • @app.put(“/tasks/{task_id}”): This is a PUT endpoint to update an existing task.
  • update_task: A function that updates a task’s information by copying the updated fields and replacing the old task. If the task is not found, it raises a 404 error.

9. Delete Task Endpoint

@app.delete("/tasks/{task_id}", response_model=Task)
def delete_task(task_id: UUID):
    for idx, task in enumerate(tasks):
        if task.id == task_id:
            return tasks.pop(idx)
    
    raise HTTPException(status_code=404, detail="Task not found")
  • @app.delete(“/tasks/{task_id}”): This is a DELETE endpoint to delete a task by its ID.
  • delete_task: A function that removes a task from the list if found; otherwise, it raises a 404 error.

10. Run the Application

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
  • if name == “main”: This ensures that the app runs only if the script is executed directly.
  • uvicorn.run: Runs the FastAPI app using Uvicorn, a lightning-fast ASGI server.

Git

Vijay Gokarn