@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile = File(...)):
    return {"filename": file.filename, "content_type": file.content_type}

• Set a response cookie.

from fastapi import Response
@app.post("/cookie/")
def create_cookie(response: Response):
    response.set_cookie(key="fakesession", value="fake-cookie-session-value")
    return {"message": "Cookie set"}

• Read a request cookie.

from fastapi import Cookie
@app.get("/read-cookie/")
def read_cookie(fakesession: Optional[str] = Cookie(None)):
    return {"session": fakesession}

X. Error Handling & Advanced Responses

• Handle HTTPException.

from fastapi import HTTPException
@app.get("/items/{item_id}")
def read_item(item_id: str):
    if item_id not in items_db:
        raise HTTPException(status_code=404, detail="Item not found")

• Return a custom JSONResponse.

from fastapi.responses import JSONResponse
@app.get("/custom/")
def custom_response():
    return JSONResponse(status_code=202, content={"message": "Accepted"})

• Return an HTMLResponse.

from fastapi.responses import HTMLResponse
@app.get("/page", response_class=HTMLResponse)
def read_page():
    return "<h1>Hello World</h1>"

• Define a WebSocket endpoint.

from fastapi import WebSocket
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    await websocket.send_text("Hello from WebSocket")
    await websocket.close()

• Handle a path operation that may not exist.

@app.get("/{full_path:path}")
def read_catch_all(full_path: str):
    return {"path": full_path}

• Mount a static files directory.

from fastapi.staticfiles import StaticFiles
app.mount("/static", StaticFiles(directory="static"), name="static")

• Add a custom exception handler.

from fastapi import Request
from fastapi.responses import JSONResponse

class MyCustomException(Exception): pass

@app.exception_handler(MyCustomException)
async def custom_exception_handler(request: Request, exc: MyCustomException):
    return JSONResponse(status_code=418, content={"message": "I'm a teapot"})

• Read a request header.

from fastapi import Header
@app.get("/headers/")
async def read_headers(user_agent: Optional[str] = Header(None)):
    return {"User-Agent": user_agent}

• Get a raw Request object.

from fastapi import Request
@app.get("/request-info")
def get_request_info(request: Request):
    return {"client_host": request.client.host}

#Python #FastAPI #API #WebDevelopment #Pydantic

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

Data validation with Pydantic! 🐍✨

In the early stages of development, data validation usually doesn't cause problems. In many Python projects, validation initially looks simple:

if not isinstance(age, int):
    raise ValueError("age must be an int")

But then come email, JSON from APIs, query parameters, nested objects, configs, nullable fields, and type conversion. At some point, the code turns into a set of if/else and manual checks.

For such tasks, Pydantic is often used. Installation:

pip install pydantic
pip install "pydantic[email]"

Create a model:

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

Now the data is validated automatically:

user = User(
    name="Alex",
    age="30"
)

print(user.age)
print(type(user.age))

The result:
30
<class 'int'>

Pydantic will automatically convert the string "30" to an int. If you pass an incorrect value, you'll get a ValidationError:

User(
    name="Alex",
    age="test"
)

This is especially convenient when working with APIs, JSON, query parameters, and incoming data from outside.

A common production case is checking email:

from pydantic import BaseModel, EmailStr

class User(BaseModel):
    email: EmailStr

User(email="[email protected]")

If the email is invalid, Pydantic will throw a ValidationError. You can set default values:

from pydantic import BaseModel

class Config(BaseModel):
    host: str = "localhost"
    port: int = 5432

And allow None:

from pydantic import BaseModel

class User(BaseModel):
    nickname: str | None = None

This field becomes optional. A practical example is processing an API response:

from pydantic import BaseModel

class Product(BaseModel):
    id: int
    title: str
    price: float

data = {
    "id": "1",
    "title": "Keyboard",
    "price": "99.5"
}

product = Product(**data)

print(product)

The types will be automatically converted. For nested model structures, you can combine:

from pydantic import BaseModel

class Address(BaseModel):
    city: str
    zip_code: str

class User(BaseModel):
    name: str
    address: Address

user = User(
    name="Alex",
    address={
        "city": "Berlin",
        "zip_code": "10115"
    }
)

print(user)

The nested object will also be validated. Serialization in Pydantic v2:

print(user.model_dump())
print(user.model_dump_json())

Pydantic is actively used in FastAPI, ETL, microservices, data pipelines, and API clients.

For working with environment variables in Pydantic v2, a separate package is usually used:

pip install pydantic-settings

It's important to understand: Pydantic is not an ORM and does not replace business logic. Its task is to validate data, convert types, and describe schemas.

🔥 Pydantic significantly reduces the amount of manual data validation and makes processing incoming structures more predictable.

#Python #Pydantic #DataValidation #FastAPI #Coding #DevOps

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk
⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A