from typing import Optional
from pydantic import BaseModel, Field, EmailStr

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

# Valid data
user = User(name="Alice", age=30, email="[email protected]")
print(user)

# Invalid data will raise a ValidationError
try:
    User(name="Bob", age="twenty", email="bob@invalid")
except Exception as e:
    print(e)


class Product(BaseModel):
    id: int = Field(..., gt=0, description="Unique product identifier")
    name: str = Field(..., min_length=2, max_length=100)
    price: float = Field(..., gt=0.0)
    description: Optional[str] = None # Optional field
    seller_email: EmailStr # Pydantic's built-in email validation

product = Product(id=1, name="Laptop", price=1200.50, seller_email="[email protected]")
print(product)

user_data = {
    "name": "Alice",
    "age": 30,
    "email": "[email protected]"
}
user_model = User(**user_data)

user_model = User.model_validate(user_data)


class Movie(BaseModel):
    title: str
    year: int
    director: str
    genres: list[str]

# Your JSON string data
json_string = '''
{
    "title": "Inception",
    "year": 2010,
    "director": "Christopher Nolan",
    "genres": ["Sci-Fi", "Action", "Thriller"]
}
'''
movie_model = Movie.model_validate_json(json_string)

from pydantic import BaseModel
import json

class Item(BaseModel):
    name: str
    quantity: int

data_dict = {"name": "Apple", "quantity": 5}
item1 = Item.model_validate(data_dict)
print(item1)

json_data = '{"name": "Banana", "quantity": 10}'
item2 = Item.model_validate_json(json_data)
print(item2)

from pydantic import BaseModel

class City(BaseModel):
    name: str
    population: int

tokyo = City(name="Tokyo", population=14000000)
print(tokyo.model_dump())
print(tokyo.model_dump_json(indent=2)) # Pretty print JSON

from datetime import date
from pydantic import BaseModel, ValidationError, field_validator, model_validator

class Event(BaseModel):
    name: str
    start_date: date
    end_date: date

    @field_validator('name')
    @classmethod
    def check_name_is_not_empty(cls, v):
        if not v.strip():
            raise ValueError('Event name cannot be empty')
        return v

    @model_validator(mode='after') # 'after' means after field validation
    def check_dates_order(self):
        if self.start_date > self.end_date:
            raise ValueError('Start date must be before end date')
        return self

try:
    event1 = Event(name="Conference", start_date="2025-07-20", end_date="2025-07-22")
    print(event1)
except ValidationError as e:
    print(e)

try:
    Event(name="Bad Event", start_date="2025-07-25", end_date="2025-07-23")
except ValidationError as e:
    print(e)

from pydantic import BaseModel
from typing import List

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

class Customer(BaseModel):
    customer_id: int
    name: str
    shipping_addresses: List[Address]

customer_data = {
    "customer_id": 123,
    "name": "Jane Doe",
    "shipping_addresses": [
        {"street": "123 Main St", "city": "Anytown", "zip_code": "12345"},
        {"street": "456 Oak Ave", "city": "Otherville", "zip_code": "67890"}
    ]
}

customer = Customer.model_validate(customer_data)
print(customer)

from pydantic import BaseModel

class Task(BaseModel):
    id: int
    title: str
    completed: bool = False

print(Task.model_json_schema(indent=2))

# Primitives
name: str = "Tom"
age: int = 30
salary: float = 500.5
is_active: bool = True

# Collections
numbers: list = [1,2,3]
scores: tuple = (90, 85, 88)
unique: set = {1, 2, 3}
data: dict = {"key": "value"}


# Specific Collection Types

from typing import List, Dict, Tuple, Set

names: List[str] = ["Alice", "Bob", "Charlie"]
user: Dict[str, str] = {
    "name": "John",
    "email": "[email protected]"
}
person: Tuple[str, int, bool] = ("Alice", 30, True)
unique_ids: Set[int] = {1, 2, 3, 4, 5}

# after python 3.9 the following are also work
names: list[str] = ["Alice", "Bob", "Charlie"]
user: dict[str, str] = {
    "name": "John",
    "email": "[email protected]"
}person: tuple[str, int, bool] = ("Alice", 30, True)
unique_ids: set[int] = {1, 2, 3, 4, 5}

# Optional

from typing import Optional

# can be string or None
middle_name: Optional[str] = None

# Union 
from typing import Union
number: Union[int, float] = 10
number = 10.5


# Literal for exact values
from typing import Literal
Status = Literal["pending", "approved", "rejected"]

def process_order(status: Status) -> None:
    pass

# TypedDict
from typing import TypedDict
# TypedDict for dictionary structures
class UserDict(TypedDict):
    name: str
    age: int
    email: str


# Class
user: User = get_user(123)

# method
def calculate_bmi(weight: float, height: float) -> float:
    return weight / (height ** 2)

# Self
from typing import Self

class User:
    def copy(self) -> Self:  # Returns same class type
        return User()