50 AI Prompts for Python and FastAPI Development

Act as a FastAPI expert.

Task:
Scaffold a FastAPI project with the following structure and configuration.

Project structure:
app/
  main.py          # FastAPI app instance, lifespan, include_router calls
  config.py        # Settings class using pydantic-settings and .env
  database.py      # SQLAlchemy async engine and get_db dependency
  routers/
    users.py       # /users routes
    auth.py        # /auth/login, /auth/refresh routes
  models/
    user.py        # SQLAlchemy User model
  schemas/
    user.py        # Pydantic request and response schemas
  dependencies/
    auth.py        # get_current_user dependency

Tech stack: Python 3.12, FastAPI, SQLAlchemy 2.0 async, PostgreSQL, pydantic-settings
Include: pyproject.toml with all dependencies

Act as a Pydantic v2 expert.

Task:
Create Pydantic schemas for a user management API.

Schemas needed:
1. UserCreate: email (valid email), password (min 8 chars, at least 1 digit),
   name (min 2 chars), role (Literal admin, user, viewer — default user)

2. UserUpdate: all fields optional, same validation rules when provided

3. UserResponse: id (UUID), email, name, role, createdAt (datetime),
   isActive (bool) — exclude password from response

4. UserListResponse: items (list of UserResponse), total (int),
   page (int), limit (int)

Requirements:
- Use Pydantic v2 syntax (model_config, field_validator, not v1 validators)
- Email must be lowercased and stripped in a field_validator
- UserResponse must use model_config with from_attributes=True for ORM mode
- Use UUID type for id, datetime for timestamps

Act as a SQLAlchemy 2.0 async and Alembic expert.

Task:
Write the SQLAlchemy model and async CRUD repository for a User entity.

User model fields:
- id: UUID, primary key, server default gen_random_uuid()
- email: String(255), unique, not null, indexed
- hashed_password: String(255), not null
- name: String(100), not null
- role: Enum (admin, user, viewer), default user
- is_active: Boolean, default True
- created_at: DateTime with timezone, server default now()
- updated_at: DateTime with timezone, onupdate now()

CRUD repository methods:
- get_by_id(db, user_id) -> User | None
- get_by_email(db, email) -> User | None
- create(db, data: UserCreate) -> User
- update(db, user_id, data: UserUpdate) -> User | None
- delete(db, user_id) -> bool
- list_users(db, skip, limit) -> tuple[list[User], int]

Use: SQLAlchemy 2.0, AsyncSession, select() API, Python 3.12

Act as a FastAPI security expert.

Task:
Implement JWT authentication for a FastAPI application.

Requirements:
1. Password hashing: use passlib with bcrypt, verify_password and get_password_hash helpers

2. JWT tokens:
   - Access token: expires in 15 minutes, contains sub (user_id) and role
   - Refresh token: expires in 7 days, stored hash in database for rotation
   - Use PyJWT, secret from settings, algorithm HS256

3. Auth router:
   - POST /auth/login: accepts email and password, returns access_token and refresh_token
   - POST /auth/refresh: accepts refresh_token cookie, returns new access_token
   - POST /auth/logout: revokes refresh token

4. Dependencies:
   - get_current_user: reads Bearer token, returns User from DB or raises 401
   - require_admin: depends on get_current_user, raises 403 if role is not admin

Use: FastAPI, PyJWT, passlib, SQLAlchemy 2.0 async, Python 3.12

Act as a FastAPI and Celery expert.

Task:
Set up Celery with FastAPI for background task processing.

Architecture:
- Celery broker: Redis
- Celery result backend: Redis
- FastAPI triggers Celery tasks on certain API events

Tasks to implement:
1. send_welcome_email(user_id, email): send email after user registration
   - Retry up to 3 times on failure with 60 second delay

2. generate_monthly_report(tenant_id): heavy data aggregation
   - Time limit: 300 seconds
   - Runs on a dedicated queue: reports

3. cleanup_expired_tokens(): scheduled task, runs every hour
   - Uses Celery beat schedule

Provide:
- celery_app.py with Redis config and beat schedule
- Each task function with retry and error handling
- How to call the tasks from FastAPI route handlers

Use: FastAPI, Celery 5, Redis, Python 3.12

Act as a FastAPI and pytest expert.

Task:
Write pytest tests for a FastAPI users API.

Endpoints to test:
- POST /users (create user, admin only)
- GET /users (list users, admin only)
- GET /users/{user_id} (get user, authenticated)
- PUT /users/{user_id} (update user, admin or own account)
- DELETE /users/{user_id} (delete user, admin only)

Test scenarios per endpoint:
- Success case with valid data and correct auth
- 401 when no token is provided
- 403 when token has insufficient role
- 422 when request body fails Pydantic validation
- 404 when resource does not exist

Provide:
- conftest.py with: async test database setup, user factory fixture,
  auth token fixture for user and admin roles, override_get_db fixture
- test_users.py with all test cases

Use: pytest, pytest-asyncio, httpx AsyncClient, SQLAlchemy 2.0 async, Python 3.12

Act as a FastAPI production deployment expert.

Task:
Set up production deployment for a FastAPI application.

Provide:
1. Dockerfile:
   - Multi-stage: builder installs dependencies, runtime copies app only
   - Base image: python:3.12-slim
   - Run as non-root user
   - Use uv for fast dependency installation
   - Entry point: gunicorn with uvicorn worker class, 4 workers

2. gunicorn.conf.py:
   - workers: (2 * CPU cores) + 1
   - worker_class: uvicorn.workers.UvicornWorker
   - timeout: 120
   - keepalive: 5
   - access log format with request duration

3. Nginx config:
   - Proxy to FastAPI on port 8000
   - Set X-Forwarded-For and X-Real-IP headers
   - Gzip compression for JSON responses
   - Rate limiting: 100 requests per minute per IP

4. Health check endpoint: GET /health returns {status: ok, version: str}

Also show the docker-compose.yml for local development.