from pathlib import Path

# Create Path Objects:
my_file = Path("data")

# Use Path methods
my_file.exists()

# Content I/O

my_file.read_text()
#Path.write_text()
#Path.write_text()
#Path.write_bytes()

# From CWD
# 
current_dir = Path.cwd()
# From Home
home_dir = Path.home()
# From absolute Paths
abs_path = Path("/usr/local/bin/python")
# From relative paths (relative to CWD)
relative_path = Path("data/input.csv")

# Create path by manipulation
base_dir = Path('/opt/my_app')
config_file = base_dire / "config" / "settings.yaml"

parent_dir = config_file.parent

# Get file / directory name
config_file.name

# Getting Stem
config_file.stem # settings

# Getting suffix
config_file.suffix
config_file.suffixes

# Get absolute path
config_file.resolve()
# or
config_file.absolute()

# Get relative path
relative_to = config_file.relative_to(project_root)

my_file.exists()

my_file.is_file()
my_file.is_dir()
my_file.is_symlink()

# Statistics
stats = temp_file.stat()

# Create directories
new_dir.mkdir()

# create empty file
empty_file.touch()

# delete file

file_to_delete.unlink()


# delete empty directories

empty_folder.rmdir()

# rename / move file or directories

old_path.rename(new_path)

# Changing suffix
config_file.with_suffix('.yml')

config_path = Path("config.txt")
config_path.write_text("debug=True\nlog_level=INFO")
content = config_path.read_text()

binary_data_file = Path("binary_data.bin")
binary_data_file.write_bytes(b'\x01\x02\x03\x04')
data = binary_data_file.read_bytes()
print(f"Binary data: {data}")

# List
project_root.iterdir()

# Globbing
project_root.glob("*.py")

# Walking Directory Tree (Python 3.12+)
project_root.walk()

try:
    with open("my_large_file.csv", "w", encoding="utf-8") as f:
        f.write("Header1,Header2\n")
        for i in range(1000):
            f.write(f"data_{i},value_{i}\n")
except IOError as e:
    print(f"Error writing file: {e}")

import tempfile
from pathlib import Path

# Using a temporary directory
with tempfile.TemporaryDirectory() as tmp_dir_str:
    tmp_dir = Path(tmp_dir_str)
    temp_file = tmp_dir / "temp_report.txt"
    temp_file.write_text("Ephemeral data.")
    print(f"Created temporary file at: {temp_file}")
    # At the end of the 'with' block, tmp_dir_str and its contents are deleted
print("Temporary directory removed.")

import shutil

source_dir = Path("my_data")
destination_dir = Path("backup_data")


try:
    shutil.copytree(source_dir, destination_dir)
    print(f"Copied '{source_dir}' to '{destination_dir}'")
except FileExistsError:
    print(f"Destination '{destination_dir}' already exists. Skipping copy.")
except Exception as e:
    print(f"Error copying tree: {e}")

import shutil
from pathlib import Path

dir_to_delete = Path("backup_data") # Assuming this exists from the copytree example

if dir_to_delete.exists():
    print(f"Deleting '{dir_to_delete}'...")
    shutil.rmtree(dir_to_delete)
    print("Directory deleted.")
else:
    print(f"Directory '{dir_to_delete}' does not exist.")

archive_path = shutil.make_archive(archive_name, 'zip', source_dir)
print(f"Created archive: {archive_path}")

usage = shutil.disk_usage(Path(".")) # Check current directory's disk
print(f"Total: {usage.total / (1024**3):.2f} GB")
print(f"Used: {usage.used / (1024**3):.2f} GB")
print(f"Free: {usage.free / (1024**3):.2f} GB")

async def my_coroutine():
    print("Coroutine started")
    await asyncio.sleep(1) # This is a pause point
    print("Coroutine resumed after 1 second")
    return "Done!"

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="alice@example.com")
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="seller@store.com")
print(product)

user_data = {
    "name": "Alice",
    "age": 30,
    "email": "alice@example.com"
}
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": "john@example.com"
}
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": "john@example.com"
}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()