from pydantic import BaseModel, field_validator

class UserSignup(BaseModel):
    username: str
    email: str
    country_code: str

    @field_validator("username", mode="before")
    @classmethod
    def strip_username(cls, v):
        # Runs BEFORE type coercion
        if isinstance(v, str):
            return v.strip().lower()
        return v

    @field_validator("country_code", mode="before")
    @classmethod
    def normalize_country(cls, v):
        return v.upper() if isinstance(v, str) else v

u = UserSignup(
    username="  Alice  ",
    email="alice@x.com",
    country_code="us"
)
print(u.username)     # "alice" (stripped + lowercased)
print(u.country_code) # "US"

from pydantic import BaseModel, model_validator
from datetime import date

class BookingRequest(BaseModel):
    check_in: date
    check_out: date
    guests: int
    room_type: str

    @model_validator(mode="after")
    def validate_dates_and_capacity(self) -> "BookingRequest":
        # self is the model instance — all fields are available
        if self.check_out <= self.check_in:
            raise ValueError("check_out must be after check_in")

        max_guests = 2 if self.room_type == "single" else 4
        if self.guests > max_guests:
            raise ValueError(
                f"Room type '{self.room_type}' allows max {max_guests} guests"
            )
        return self

# ✅ Valid
b = BookingRequest(
    check_in=date(2025,6,1),
    check_out=date(2025,6,5),
    guests=2,
    room_type="single"
)

# ❌ Too many guests for single room
BookingRequest(
    check_in=date(2025,6,1),
    check_out=date(2025,6,5),
    guests=5,
    room_type="single"
)

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    password: str
    email: str

u = User(id=1, name="Alice", password="secret", email="a@x.com")

# Full dump
print(u.model_dump())
# {'id': 1, 'name': 'Alice', 'password': 'secret', 'email': 'a@x.com'}

# Exclude sensitive fields
print(u.model_dump(exclude={"password"}))
# {'id': 1, 'name': 'Alice', 'email': 'a@x.com'}

# Include only specific fields
print(u.model_dump(include={"id", "name"}))
# {'id': 1, 'name': 'Alice'}

# Exclude fields with None values
print(u.model_dump(exclude_none=True))

# Exclude fields with default values
print(u.model_dump(exclude_defaults=True))

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    in_stock: bool

# From a plain dict
data = {"name": "Laptop", "price": "999.99", "in_stock": "true"}
p = Product.model_validate(data)
print(p.price)     # 999.99 (float)
print(p.in_stock)  # True (bool)

# From JSON string
json_str = '{"name": "Phone", "price": 499, "in_stock": false}'
p2 = Product.model_validate_json(json_str)
print(p2.name)  # Phone

# From ORM object (SQLAlchemy row, etc.)
# Use model_config = ConfigDict(from_attributes=True)
from pydantic import ConfigDict

class ProductFromORM(BaseModel):
    model_config = ConfigDict(from_attributes=True)
    name: str
    price: float

# orm_object is a SQLAlchemy model with .name and .price attributes
# product = ProductFromORM.model_validate(orm_object)

from pydantic import BaseModel

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

base_config = Config()
print(base_config)  # host='localhost' port=5432 db_name='dev'

# Create a copy with some fields updated
prod_config = base_config.model_copy(update={
    "host": "prod-db.internal",
    "db_name": "production"
})
print(prod_config)  # host='prod-db.internal' port=5432 db_name='production'
print(base_config)  # unchanged — original is intact

# Deep copy (copies nested models too)
test_config = base_config.model_copy(deep=True, update={"port": 5433})

from pydantic import BaseModel, Field, ConfigDict
from pydantic.alias_generators import to_camel

# Option 1: Per-field alias
class Payment(BaseModel):
    user_id: int = Field(alias="userId")        # input key is "userId"
    amount_cents: int = Field(alias="amountCents")

# Must use alias for input
p = Payment.model_validate({"userId": 42, "amountCents": 1000})
print(p.user_id)      # 42 (Python name)
print(p.model_dump(by_alias=True))
# {'userId': 42, 'amountCents': 1000}

# Option 2: Global alias generator (entire model)
class APIResponse(BaseModel):
    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)

    first_name: str
    last_name: str
    created_at: str

# Both work with populate_by_name=True:
r1 = APIResponse(first_name="John", last_name="Doe", created_at="2025")
r2 = APIResponse.model_validate({"firstName":"Jane","lastName":"Doe","createdAt":"2025"})

from pydantic import BaseModel, computed_field

class Rectangle(BaseModel):
    width: float
    height: float

    @computed_field
    @property
    def area(self) -> float:
        return self.width * self.height

    @computed_field
    @property
    def perimeter(self) -> float:
        return 2 * (self.width + self.height)

r = Rectangle(width=5.0, height=3.0)
print(r.area)       # 15.0
print(r.perimeter)  # 16.0
print(r.model_dump())
# {'width': 5.0, 'height': 3.0, 'area': 15.0, 'perimeter': 16.0}

# FastAPI use case: full_name derived from first + last
class UserProfile(BaseModel):
    first_name: str
    last_name: str

    @computed_field
    @property
    def full_name(self) -> str:
        return f"{self.first_name} {self.last_name}"

from pydantic import BaseModel
from typing import Optional

class Address(BaseModel):
    street: str
    city: str
    zip_code: str
    country: str = "IN"

class LineItem(BaseModel):
    product_id: int
    name: str
    quantity: int
    unit_price: float

    @computed_field
    @property
    def subtotal(self) -> float:
        return self.quantity * self.unit_price

class Order(BaseModel):
    order_id: str
    customer_name: str
    shipping_address: Address          # nested model
    items: list[LineItem]             # list of nested models
    notes: Optional[str] = None

# Pydantic recursively validates the nested dicts
order = Order.model_validate({
    "order_id": "ORD-001",
    "customer_name": "Alice",
    "shipping_address": {
        "street": "123 MG Road",
        "city": "Bengaluru",
        "zip_code": "560001"
    },
    "items": [
        {"product_id": 1, "name": "Laptop", "quantity": 1, "unit_price": 75000},
        {"product_id": 2, "name": "Mouse",  "quantity": 2, "unit_price": 500}
    ]
})
print(order.shipping_address.city)     # Bengaluru
print(order.items[0].name)             # Laptop

from pydantic import BaseModel
from typing import Generic, TypeVar, Optional

T = TypeVar("T")

class APIResponse(BaseModel, Generic[T]):
    """Standard API envelope used across all endpoints."""
    success: bool
    data: Optional[T] = None
    message: str = ""
    code: int = 200

# Use it with any type
class UserOut(BaseModel):
    id: int
    name: str

class ProductOut(BaseModel):
    id: int
    title: str

# FastAPI endpoint
from fastapi import FastAPI
app = FastAPI()

@app.get("/users/{user_id"}, response_model=APIResponse[UserOut])
async def get_user(user_id: int):
    user = UserOut(id=user_id, name="Alice")
    return APIResponse(success=True, data=user)

# Response JSON:
# {"success": true, "data": {"id": 1, "name": "Alice"}, "message": "", "code": 200}

from pydantic import BaseModel
from typing import Literal, Union, Annotated
from pydantic import Field

class EmailNotification(BaseModel):
    type: Literal["email"]        # discriminator value
    to: str
    subject: str
    body: str

class SMSNotification(BaseModel):
    type: Literal["sms"]          # discriminator value
    phone: str
    message: str

class PushNotification(BaseModel):
    type: Literal["push"]         # discriminator value
    device_token: str
    title: str
    body: str

# Annotated Union with discriminator
Notification = Annotated[
    Union[EmailNotification, SMSNotification, PushNotification],
    Field(discriminator="type")
]

class NotificationJob(BaseModel):
    notification: Notification
    priority: int = 1

# Pydantic picks the right model based on "type"
job1 = NotificationJob.model_validate({
    "notification": {"type": "email", "to": "a@x.com",
                      "subject": "Hi", "body": "Hello"}
})
print(type(job1.notification).__name__)  # EmailNotification

job2 = NotificationJob.model_validate({
    "notification": {"type": "sms", "phone": "+91999",
                      "message": "Your OTP is 1234"}
})
print(type(job2.notification).__name__)  # SMSNotification