johanguse fastapi-boilerplate-backend .cursorrules file for Python

You are an expert in Python, FastAPI, and scalable API development.

Key Principles

- Write concise, technical responses with accurate Python examples.
- Use functional, declarative programming; avoid classes where possible.
- Prefer iteration and modularization over code duplication.
- Use descriptive variable names with auxiliary verbs (e.g., is_active, has_permission).
- Use lowercase with underscores for directories and files (e.g., routers/user_routes.py).
- Favor named exports for routes and utility functions.
- Use the Receive an Object, Return an Object (RORO) pattern.

Python/FastAPI
 - Use def for pure functions and async def for asynchronous operations.
 - Use type hints for all function signatures. Prefer Pydantic models over raw dictionaries for input validation.
 - File structure: exported router, sub-routes, utilities, static content, types (models, schemas).
 - Avoid unnecessary curly braces in conditional statements.
 - For single-line statements in conditionals, omit curly braces.
 - Use concise, one-line syntax for simple conditional statements (e.g., if condition: do_something()).

Error Handling and Validation
 - Prioritize error handling and edge cases:
  - Handle errors and edge cases at the beginning of functions.
  - Use early returns for error conditions to avoid deeply nested if statements.
  - Place the happy path last in the function for improved readability.
  - Avoid unnecessary else statements; use the if-return pattern instead.
  - Use guard clauses to handle preconditions and invalid states early.
  - Implement proper error logging and user-friendly error messages.
  - Use custom error types or error factories for consistent error handling.

Dependencies
 - FastAPI
 - Pydantic v2
 - Async database libraries like asyncpg or aiomysql
 - SQLAlchemy 2.0 (if using ORM features)
 - Poetry for dependency management
 - Alembic for database migrations
 - Resend for email

FastAPI-Specific Guidelines
 - Use functional components (plain functions) and Pydantic models for input validation and response schemas.
 - Use declarative route definitions with clear return type annotations.
 - Use def for synchronous operations and async def for asynchronous ones.
 - Minimize @app.on_event("startup") and @app.on_event("shutdown"); prefer lifespan context managers for managing startup and shutdown events.
 - Use middleware for logging, error monitoring, and performance optimization.
 - Optimize for performance using async functions for I/O-bound tasks, caching strategies, and lazy loading.
 - Use HTTPException for expected errors and model them as specific HTTP responses.
 - Use middleware for handling unexpected errors, logging, and error monitoring.
 - Use Pydantic's BaseModel for consistent input/output validation and response schemas.

Use FastAPI 0.115.0 or later
Now you can declare Query, Header, and Cookie parameters with Pydantic models. 🎉

Query Parameter Models
Use Pydantic models for Query parameters:

from typing import Annotated, Literal

from fastapi import FastAPI, Query
from pydantic import BaseModel, Field

app = FastAPI()


class FilterParams(BaseModel):
    limit: int = Field(100, gt=0, le=100)
    offset: int = Field(0, ge=0)
    order_by: Literal["created_at", "updated_at"] = "created_at"
    tags: list[str] = []


@app.get("/items/")
async def read_items(filter_query: Annotated[FilterParams, Query()]):
    return filter_query
Read the new docs: Query Parameter Models.

Header Parameter Models
Use Pydantic models for Header parameters:

from typing import Annotated

from fastapi import FastAPI, Header
from pydantic import BaseModel

app = FastAPI()


class CommonHeaders(BaseModel):
    host: str
    save_data: bool
    if_modified_since: str | None = None
    traceparent: str | None = None
    x_tag: list[str] = []


@app.get("/items/")
async def read_items(headers: Annotated[CommonHeaders, Header()]):
    return headers
Read the new docs: Header Parameter Models.

Cookie Parameter Models
Use Pydantic models for Cookie parameters:

from typing import Annotated

from fastapi import Cookie, FastAPI
from pydantic import BaseModel

app = FastAPI()


class Cookies(BaseModel):
    session_id: str
    fatebook_tracker: str | None = None
    googall_tracker: str | None = None


@app.get("/items/")
async def read_items(cookies: Annotated[Cookies, Cookie()]):
    return cookies
Read the new docs: Cookie Parameter Models.

Forbid Extra Query (Cookie, Header) Parameters
Use Pydantic models to restrict extra values for Query parameters (also applies to Header and Cookie parameters).

To achieve it, use Pydantic's model_config = {"extra": "forbid"}:

from typing import Annotated, Literal

from fastapi import FastAPI, Query
from pydantic import BaseModel, Field

app = FastAPI()


class FilterParams(BaseModel):
    model_config = {"extra": "forbid"}

    limit: int = Field(100, gt=0, le=100)
    offset: int = Field(0, ge=0)
    order_by: Literal["created_at", "updated_at"] = "created_at"
    tags: list[str] = []


@app.get("/items/")
async def read_items(filter_query: Annotated[FilterParams, Query()]):
    return filter_query

Performance Optimization
 - Minimize blocking I/O operations; use asynchronous operations for all database calls and external API requests.
 - Implement caching for static and frequently accessed data using tools like Redis or in-memory stores.
 - Optimize data serialization and deserialization with Pydantic.
 - Use lazy loading techniques for large datasets and substantial API responses.

Key Conventions
 1. Rely on FastAPI’s dependency injection system for managing state and shared resources.
 2. Prioritize API performance metrics (response time, latency, throughput).
 3. Limit blocking operations in routes:
   - Favor asynchronous and non-blocking flows.
   - Use dedicated async functions for database and external API operations.
   - Structure routes and dependencies clearly to optimize readability and maintainability.

Refer to FastAPI documentation for Data Models, Path Operations, and Middleware for best practices.