# ── FLASK (traditional) ─────────────────────────────────────────────────────
from flask import Flask, jsonify, request

flask_app = Flask(__name__)

@flask_app.route("/items/<int:item_id>", methods=["GET"])
def get_item(item_id):
    # No type checking on output — anything goes in the dict
    return jsonify({"id": item_id, "name": "Widget"})

# ── FASTAPI ──────────────────────────────────────────────────────────────────
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):          # Type definition drives validation AND docs
    id: int
    name: str
    price: float

@app.get("/items/{item_id}", response_model=Item)
def get_item(item_id: int):     # Type hint ← FastAPI reads this at startup
    # FastAPI will:
    # 1. Validate that {item_id} in the URL is an integer
    # 2. Validate the returned dict matches Item schema
    # 3. Show this endpoint in /docs Swagger UI automatically
    # 4. Return 422 with a clear error if types don't match
    return {"id": item_id, "name": "Widget", "price": 9.99}

# Step 1: Create a virtual environment (isolated Python environment)
python -m venv .venv

# Step 2: Activate it
source .venv/bin/activate        # macOS / Linux
# .venv\Scripts\activate         # Windows

# Step 3: Install FastAPI with all standard extras
pip install "fastapi[standard]"
# This installs: fastapi, uvicorn[standard], pydantic, httpx, python-multipart, etc.

# Step 4: Verify installation
python -c "import fastapi; print(fastapi.__version__)"

my_api/
├── app/
│   ├── __init__.py          # Makes this a Python package
│   ├── main.py              # FastAPI app instance + app-level config
│   ├── config.py            # Pydantic Settings (env vars)
│   ├── dependencies.py      # Shared Depends() functions (auth, pagination)
│   ├── routers/             # One file per resource (items, users, orders)
│   │   ├── __init__.py
│   │   ├── items.py
│   │   └── users.py
│   ├── models/              # SQLAlchemy ORM models (database tables)
│   ├── schemas/             # Pydantic schemas (request/response shapes)
│   └── services/            # Business logic (kept separate from routes)
├── tests/
│   └── test_items.py
├── .env                     # Environment variables (NEVER commit to git)
├── .env.example             # Template showing required vars (safe to commit)
├── requirements.txt
└── alembic/                 # Database migrations

from fastapi import FastAPI

# Create the application instance.
# Everything flows from this object — routes, middleware, docs, startup hooks.
app = FastAPI(
    title="My First API",            # Shown in /docs header
    description="Learning FastAPI",  # Markdown is supported here
    version="0.1.0",
)

# Route decorator syntax: @app.{HTTP_METHOD}("{PATH}")
# The function name doesn't matter to FastAPI — the decorator defines the route.
@app.get("/")                        # Handles: GET /
def root():
    # Return any dict — FastAPI automatically:
    # 1. Converts it to JSON  ({"message": "Hello, FastAPI!"})
    # 2. Sets Content-Type: application/json header
    # 3. Returns HTTP 200 OK
    return {"message": "Hello, FastAPI!"}

@app.get("/about")
def about():
    return {"name": "My API", "version": "0.1.0"}

# Development — auto-reloads when you save files
uvicorn app.main:app --reload --port 8000
# │         │    │       │
# │         │    │       └── Watch files for changes (dev only!)
# │         │    └────────── Variable name in main.py (the FastAPI instance)
# │         └─────────────── Module path (app/main.py → app.main)
# └───────────────────────── The ASGI server

# Or use FastAPI's built-in CLI (comes with fastapi[standard])
fastapi dev app/main.py             # development (auto-reload)
fastapi run app/main.py             # production (no reload)

from fastapi import FastAPI, Path
from enum import Enum
from typing import Annotated

app = FastAPI()

# ── Basic typed path parameter ───────────────────────────────────────────────
@app.get("/items/{item_id}")
def get_item(item_id: int):
    # URL: GET /items/42   → item_id = 42  (int, not string "42")
    # URL: GET /items/abc  → 422 error: "value is not a valid integer"
    return {"item_id": item_id, "type": type(item_id).__name__}  # "int"

# ── Enum: restrict to a fixed set of values ──────────────────────────────────
class Color(str, Enum):      # inherit from str for JSON serialization
    red   = "red"
    green = "green"
    blue  = "blue"

@app.get("/colors/{color}")
def get_color(color: Color):
    return {"color": color, "hex": {"red": "#FF0000", "green": "#00FF00", "blue": "#0000FF"}[color]}

# ── Path() for extra validation and documentation ────────────────────────────
@app.get("/users/{user_id}")
def get_user(
    user_id: Annotated[int, Path(
        title="User ID",
        description="Must be between 1 and 9999",
        ge=1,     # greater-than-or-equal-to 1
        le=9999,  # less-than-or-equal-to 9999
    )]
):
    return {"user_id": user_id}

# ── :path type — captures slashes (for file paths) ───────────────────────────
@app.get("/files/{file_path:path}")
def read_file(file_path: str):
    # GET /files/reports/2024/january.csv
    # file_path = "reports/2024/january.csv"  ← slashes are included!
    return {"path": file_path}

from fastapi import FastAPI, Query
from typing import Annotated

app = FastAPI()

# ── Required and optional with defaults ─────────────────────────────────────
@app.get("/items")
def list_items(
    skip: int = 0,         # optional — defaults to 0 if not provided
    limit: int = 10,       # optional — defaults to 10
):
    return {"skip": skip, "limit": limit}

# ── Optional nullable parameter ──────────────────────────────────────────────
@app.get("/search")
def search(q: str | None = None):
    if q:
        return {"results": [f"Result for: {q}"]}
    return {"results": []}

# ── Query() for validation and documentation ────────────────────────────────
@app.get("/products")
def list_products(
    search: Annotated[str | None, Query(
        min_length=2,
        max_length=100,
        description="Search term",
        alias="q",                  # the URL param is ?q= not ?search=
    )] = None,
    min_price: float = Query(default=0, ge=0, description="Minimum price"),
    max_price: float = Query(default=9999, gt=0),
):
    return {"search": search, "price_range": [min_price, max_price]}

# ── List / multi-value query params ─────────────────────────────────────────
@app.get("/items/tagged")
def items_by_tag(tag: list[str] = Query(default=[])):
    # GET /items/tagged?tag=python&tag=fastapi&tag=web
    return {"tags": tag}

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str                        # required (no default)
    price: float                     # required
    is_available: bool = True        # optional, defaults to True
    description: str | None = None   # optional, defaults to None

# Client sends JSON: {"name": "Widget", "price": 9.99}
@app.post("/items/")
def create_item(item: Item):
    # item is a fully validated Python object, not a raw dict
    tax = item.price * 0.1
    return {"item": item, "price_with_tax": item.price + tax}

# ── Nested models ────────────────────────────────────────────────────────────
class Address(BaseModel):
    street: str
    city: str
    country: str = "US"

class Customer(BaseModel):
    name: str
    email: str
    address: Address       # nested model — FastAPI handles recursively

@app.post("/customers/")
def create_customer(customer: Customer):
    return customer   # Pydantic models serialize to JSON automatically

# ── Mix path + query + body ──────────────────────────────────────────────────
@app.put("/items/{item_id}")
def update_item(
    item_id: int,            # ← from path
    q: str | None = None,   # ← from query string
    item: Item = None,       # ← from request body (JSON)
):
    result = {"item_id": item_id}
    if q:    result["q"] = q
    if item: result["item"] = item
    return result

from fastapi import FastAPI
from pydantic import BaseModel
from datetime import datetime

app = FastAPI()

class UserIn(BaseModel):
    username: str
    email: str
    password: str           # client provides this to create account

class UserOut(BaseModel):
    id: int
    username: str
    email: str
    created_at: datetime
    # 'password' is intentionally absent — never send it back!

@app.post("/users/", response_model=UserOut)
def create_user(user: UserIn):
    saved = {
        "id": 1,
        "username": user.username,
        "email": user.email,
        "password": "hashed_password_here",  # ← exists in DB record
        "created_at": datetime.now(),
    }
    # FastAPI strips "password" before sending — only UserOut fields go out
    return saved

# ── Return type annotation (modern style, Pydantic v2) ──────────────────────
@app.get("/me")
def get_me() -> UserOut:
    return {"id": 1, "username": "alice", "email": "alice@x.com", "created_at": datetime.now()}

# ── response_model_exclude_unset — only return fields that were set ──────────
class ItemPartial(BaseModel):
    name: str | None = None
    price: float | None = None

@app.patch("/items/{id}", response_model=ItemPartial, response_model_exclude_unset=True)
def patch_item(id: int, item: ItemPartial):
    # If client sends {"price": 9.99}, only {"price": 9.99} is returned
    return item

from fastapi import FastAPI, HTTPException, status

app = FastAPI()
fake_db = {1: "apple", 2: "banana", 3: "cherry"}

@app.get("/items/{item_id}")
def get_item(item_id: int):
    if item_id not in fake_db:
        # Raise, don't return — stops function execution immediately
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Item with id={item_id} was not found",
        )
    return {"item": fake_db[item_id]}

# 201 Created — use for POST that creates a resource
@app.post("/items/", status_code=status.HTTP_201_CREATED)
def create_item(name: str):
    new_id = max(fake_db.keys()) + 1
    fake_db[new_id] = name
    return {"id": new_id, "name": name}

# 204 No Content — use for DELETE
@app.delete("/items/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_item(item_id: int):
    if item_id not in fake_db:
        raise HTTPException(status_code=404, detail="Item not found")
    del fake_db[item_id]
    # Return nothing — 204 must have no body

@app.get("/protected")
def protected_resource(token: str | None = None):
    if not token:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Authentication required",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return {"data": "secret"}

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(
    title="Pet Store API",
    description="""
## Features
- Manage **pets** and their owners
- Full CRUD with validation
- JWT authentication
    """,
    version="2.0.0",
    docs_url="/docs",       # Swagger UI path (set to None to disable)
    redoc_url="/redoc",     # ReDoc path     (set to None to disable)
)

@app.get(
    "/pets/{pet_id}",
    tags=["pets"],
    summary="Get a pet by ID",
    description="Returns all data for a pet. Raises 404 if not found.",
    response_description="The complete pet object",
)
def get_pet(pet_id: int):
    return {"pet_id": pet_id, "name": "Buddy"}

@app.post("/pets/", tags=["pets"], status_code=201)
def create_pet(name: str, species: str):
    """
    Create a new pet record.

    - **name**: the pet's display name
    - **species**: cat, dog, bird, etc.
    """
    return {"id": 99, "name": name, "species": species}

class Pet(BaseModel):
    name: str    = Field(..., examples=["Buddy"])
    species: str = Field(..., examples=["dog"])
    age: int     = Field(ge=0, le=50, examples=[3])

from fastapi import FastAPI, Form, File, UploadFile
from typing import Annotated

app = FastAPI()

# ── Form fields ──────────────────────────────────────────────────────────────
@app.post("/login")
def login(
    username: Annotated[str, Form()],
    password: Annotated[str, Form()],
):
    return {"logged_in_as": username}

# ── Single file upload ────────────────────────────────────────────────────────
@app.post("/upload/")
async def upload_file(file: UploadFile):
    contents = await file.read()
    return {
        "filename": file.filename,
        "content_type": file.content_type,
        "size_bytes": len(contents),
    }

# ── Multiple files ────────────────────────────────────────────────────────────
@app.post("/upload/multiple")
async def upload_many(files: list[UploadFile]):
    results = []
    for f in files:
        size = len(await f.read())
        results.append({"filename": f.filename, "size": size})
    return {"uploaded": results}

# ── Mix form fields AND a file ────────────────────────────────────────────────
@app.post("/profile/")
async def update_profile(
    display_name: Annotated[str, Form()],
    bio: Annotated[str, Form()] = "",
    avatar: UploadFile | None = None,
):
    result = {"name": display_name, "bio": bio}
    if avatar:
        result["avatar_filename"] = avatar.filename
    return result