# pydantic

***

**1. Data Validation:**

```python
from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int
    is_active: bool

person = Person(name="John", age=30, is_active=True)
print(person.dict())  # {'name': 'John', 'age': 30, 'is_active': True}
```

**2. Data Conversion:**

```python
from pydantic import BaseModel, Field

class Person(BaseModel):
    name: str = Field(alias="full_name")  # Set an alias for the field

data = {"full_name": "John Doe"}
person = Person(**data)
print(person.name)  # 'John Doe'
```

**3. Nested Data Structures:**

```python
from pydantic import BaseModel

class Address:
    street: str
    city: str

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

person = Person(name="John", address={"street": "Main St.", "city": "New York"})
print(person.address.city)  # 'New York'
```

**4. Data Default Values:**

```python
from pydantic import BaseModel, Field

class Person(BaseModel):
    name: str = Field(default="Unknown")  # Set a default value for the field

person = Person()
print(person.name)  # 'Unknown'
```

**5. Data Constraints:**

```python
from pydantic import BaseModel, validator

class Person(BaseModel):
    age: int

    @validator("age")
    def check_age(cls, v):
        if v < 0:
            raise ValueError("Age cannot be negative")
        return v

person = Person(age=30)
print(person.age)  # 30
```

**6. Data Enums:**

```python
from pydantic import BaseModel, Enum

class Gender(str, Enum):
    male = "male"
    female = "female"

class Person(BaseModel):
    gender: Gender

person = Person(gender="male")
print(person.gender)  # Gender.male
```

**7. Data Union Types:**

```python
from pydantic import BaseModel, Union

class Name:
    first_name: str
    last_name: str

class PhoneNumber:
    number: str

class Person(BaseModel):
    name: Union[Name, PhoneNumber]

person = Person(name=Name(first_name="John", last_name="Doe"))
print(person.name.first_name)  # 'John'
```

**8. Data Schemas for APIs:**

```python
from fastapi import FastAPI
from pydantic import BaseModel

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

app = FastAPI()

@app.post("/person")
def create_person(person: PersonModel):
    return {"message": "Person created successfully"}
```

**9. Data Model for Databases:**

```python
from sqlalchemy import create_engine
from pydantic import BaseModel

class PersonModel(BaseModel):
    id: int
    name: str
    age: int

engine = create_engine("sqlite:///:memory:")
PersonModel.metadata.create_all(engine)
```

**10. Data Model for Data Science:**

```python
import pandas as pd
from pydantic import validate_model

data = pd.read_csv("data.csv")
person_model = validate_model(PersonModel, data)
```

**11. Data Model for Machine Learning:**

```python
from sklearn.model_selection import train_test_split
from pydantic import BaseModel

class DatasetModel(BaseModel):
    features: list
    labels: list

data = DatasetModel.parse_obj(pd.read_csv("data.csv").to_dict(orient="list"))
X, y = train_test_split(data.features, data.labels)
```

**12. Data Model for JSON Serialization:**

```python
import json
from pydantic import BaseModel

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

data = {"name": "John", "age": 30}
person_json = PersonModel.parse_raw(json.dumps(data)).json()
```

**13. Data Model for Config Files:**

```python
from pydantic import BaseModel

class ConfigModel(BaseModel):
    database_url: str
    smtp_server: str

config = ConfigModel.parse_file("config.yml")
print(config.database_url)  # 'localhost:5432'
```

**14. Data Model for Command-Line Arguments:**

```python
import argparse
from pydantic import BaseModel

class ArgumentModel(BaseModel):
    input_file: str
    output_file: str

parser = argparse.ArgumentParser()
parser.add_argument("--input-file", type=str, dest="input_file")
parser.add_argument("--output-file", type=str, dest="output_file")
args = ArgumentModel.parse_args(parser.parse_args())
```

**15. Data Model for HTML Forms:**

```python
from pydantic import BaseModel, Field

class FormModel(BaseModel):
    name: str = Field(alias="full_name")
    email: str
    password: str

data = {"full_name": "John Doe", "email": "john.doe@example.com", "password": "secret"}
form_model = FormModel(**data)
```

**16. Data Model for XML Validation:**

```python
from lxml import etree
from pydantic import BaseModel, XmlRoot

@XmlRoot(tag="person")
class PersonModel(BaseModel):
    name: str
    age: int

xml = etree.parse("person.xml")
person_model = PersonModel.parse(xml.getroot())
```

**17. Data Model for CSV Parsing:**

```python
import csv
from pydantic import BaseModel

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

with open("data.csv") as f:
    csv_reader = csv.DictReader(f)
    for row in csv_reader:
        person_model = PersonModel(**row)
        print(person_model.name)  # John
```

**18. Data Model for Excel Parsing:**

```python
import xlrd
from pydantic import BaseModel

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

workbook = xlrd.open_workbook("data.xls")
worksheet = workbook.sheet_by_index(0)
for row in range(1, worksheet.nrows):
    values = [cell.value for cell in worksheet.row(row)]
    person_model = PersonModel(**dict(zip(worksheet.row_values(0), values)))
    print(person_model.name)  # John
```

**19. Data Model for PDF Parsing:**

```python
from pdfminer.high_level import extract_text
from pydantic import BaseModel, Field

class PersonModel(BaseModel):
    name: str = Field(alias="full_name")
    email: str
    phone_number: str

pdf_text = extract_text("person.pdf")
data = dict(zip(pdf_text.split("\n")[::2], pdf_text.split("\n")[1::2]))
person_model = PersonModel(**data)
```

**20. Data Model for Image Recognition:**

```python
import cv2
from pydantic import BaseModel, Field

class ObjectModel(BaseModel):
    name: str = Field(alias="label")
    confidence: float = Field(alias="score")

image = cv2.imread("image.png")
detector = cv2.dnn.readNetFromCaffe("deploy.prototxt.txt", "mobilenet_iter_73000.caffemodel")
blob = cv2.dnn.blobFromImage(image, 0.007843, (300, 300), 127.5)
detector.setInput(blob)
detections = detector.forward()
objects = [ObjectModel(name=label, confidence=score) for score, idx, label in zip(detections[0, 0, :, 2], detections[0, 0, :, 1], detections[0, 0, :, 1])]
print(objects)  # [ObjectModel(name='person', confidence=0.95), ...]
```

**21. Data Model for Text-to-Speech:**

```python
import pyttsx3
from pydantic import BaseModel, Field

class TextModel(BaseModel):
    text: str
    language: str = Field(default="en")

text_model = TextModel(text="Hello world!")
engine = pyttsx3.init()
engine.setProperty("lang", text_model.language)
engine.say(text_model.text)
engine.runAndWait()
```

**22. Data Model for Speech-to-Text:**

```python
import speech_recognition as sr
from pydantic import BaseModel, Field

class SpeechModel(BaseModel):
    audio_data: bytes
    language: str = Field(default="en")

speech_model = SpeechModel(audio_data=sr.AudioFile("audio.wav").read())
r = sr.Recognizer()
r.recognize_google(speech_model.audio_data, language=speech_model.language)
```

**23. Data Model for Machine Translation:**

```python
import googletrans
from pydantic import BaseModel, Field

class TranslationModel(BaseModel):
    text: str
    target_language: str = Field(default="en")

translation_model = TranslationModel(text="Hola mundo!")
translator = googletrans.Translator()
translation = translator.translate(translation_model.text, translation_model.target_language)
print(translation.text)  # 'Hello world!'
```

**24. Data Model for Image Manipulation:**

```python
from PIL import Image
from pydantic import BaseModel, Field

class ImageModel(BaseModel):
    image_path: str
    operations: list

image_model = ImageModel(image_path="image.png", operations=[{"rotate": 90}, {"resize": (500, 500)}])
image = Image.open(image_model.image_path)
for operation in image_model.operations:
    if "rotate" in operation:
        image = image.rotate(operation["rotate"])
    elif "resize" in operation:
        image = image.resize(operation["resize"])
image.save("image_processed.png")
```

**25. Data Model for Email Sending:**

```python
import smtplib
from email.message import EmailMessage
from pydantic import BaseModel, Field

class EmailModel(BaseModel):
    sender: str
    recipients: list
    subject: str
    body: str

email_model = EmailModel(sender="john.doe@example.com", recipients=["jane.doe@example.com"], subject="Hello!", body="This is an email.")
smtp_server = smtplib.SMTP("smtp.example.com")
smtp_server.starttls()
smtp_server.login(email_model.sender, "password")
message = EmailMessage()
message["Subject"] = email_model.subject
message["From"] = email_model.sender
message["To"] = ",".join(email_model.recipients)
message.set_content(email_model.body)
smtp_server.send_message(message)
smtp_server.quit()
```

**26. Data Model for Financial Calculations:**

```python
import math
from pydantic import BaseModel, Field

class FinanceModel(BaseModel):
    principal: float = Field(gt=0)
    interest_rate: float = Field(gt=0)
    years: float = Field(gt=0)

finance_model = FinanceModel(principal=1000, interest_rate=0.05, years=5)
amount = finance_model.principal * (1 + finance_model.interest_rate)**finance_model.years
print(amount)  # 1276.28
```

**27. Data Model for Business Logic:**

```python
from decimal import Decimal
from pydantic import BaseModel, Field

class OrderItemModel(BaseModel):
    product_id: str
    quantity: int = Field(gt=0)
    unit_price: Decimal = Field(gt=0)

class OrderModel(BaseModel):
    customer_id: str
    items: list[OrderItemModel]

    @property
    def total_amount(self):
        return sum(item.quantity * item.unit_price for item in self.items)

order_model = OrderModel(customer_id="CUST001", items=[OrderItemModel(product_id="PROD001", quantity=2, unit_price=Decimal("10.00")), OrderItemModel(product_id="PROD002", quantity=1, unit_price=Decimal("5.00"))])
print(order_model.total_amount)  # Decimal('25.00')
```