Biên niên sử Python ứng dụng: Giới thiệu nhẹ nhàng về Pydantic | của Ilija Lazarevic | Tháng 7 năm 2024

Thế còn giá trị mặc định và trích xuất đối số thì sao?

from pydantic import validate_call
@validate_call(validate_return=True)
def add(*args: int, a: int, b: int = 4) -> int:
return str(sum(args) + a + b)
# ----
add(4,3,4)
> ValidationError: 1 validation error for add
a
Lacking required key phrase solely argument (sort=missing_keyword_only_argument, input_value=ArgsKwargs((4, 3, 4)), input_type=ArgsKwargs)
For additional info go to 
# ----
add(4, 3, 4, a=3)
> 18
# ----
@validate_call
def add(*args: int, a: int, b: int = 4) -> int:
return str(sum(args) + a + b)
# ---- 
add(4, 3, 4, a=3)
> '18'

Những điều rút ra từ ví dụ này:

• Bạn có thể chú thích kiểu của số lượng biến khai báo đối số (*args).
• Giá trị mặc định vẫn là một tùy chọn, ngay cả khi bạn đang chú thích kiểu dữ liệu biến.
• validate_call chấp nhận validate_return đối số, cũng thực hiện xác thực giá trị trả về của hàm. Ép kiểu dữ liệu cũng được áp dụng trong trường hợp này. validate_return được thiết lập để False theo mặc định. Nếu để nguyên như vậy, hàm có thể không trả về những gì được khai báo trong gợi ý kiểu.

Còn nếu bạn muốn xác thực kiểu dữ liệu nhưng cũng hạn chế các giá trị mà biến có thể nhận thì sao? Ví dụ:

from pydantic import validate_call, Subject
from typing import Annotated 
type_age = Annotated(int, Subject(lt=120))
@validate_call(validate_return=True)
def add(age_one: int, age_two: type_age) -> int:
return age_one + age_two
add(3, 300)
> ValidationError: 1 validation error for add
1
Enter must be lower than 120 (sort=less_than, input_value=200, input_type=int)
For additional info go to 

Ví dụ này cho thấy:

• Bạn có thể dùng Annotated Và pydantic.Subject không chỉ xác thực kiểu dữ liệu mà còn thêm siêu dữ liệu mà Pydantic sử dụng để hạn chế giá trị và định dạng biến.
• ValidationError lại một lần nữa rất dài dòng về những gì sai với lệnh gọi hàm của chúng ta. Điều này có thể thực sự hữu ích.

Đây là một ví dụ nữa về cách bạn có thể xác thực và hạn chế các giá trị biến. Chúng tôi sẽ mô phỏng một tải trọng (từ điển) mà bạn muốn xử lý trong hàm của mình sau khi nó đã được xác thực:

from pydantic import HttpUrl, PastDate
from pydantic import Subject
from pydantic import validate_call
from typing import Annotated
Identify = Annotated(str, Subject(min_length=2, max_length=15))
@validate_call(validate_return=True)
def process_payload(url: HttpUrl, title: Identify, birth_date: PastDate) -> str:
return f'{title=}, {birth_date=}'
# ----
payload = {
'url': 'httpss://instance.com',
'title': 'J',
'birth_date': '2024-12-12'
}
process_payload(**payload)
> ValidationError: 3 validation errors for process_payload
url
URL scheme must be 'http' or 'https' (sort=url_scheme, input_value='httpss://instance.com', input_type=str)
For additional info go to 
title
String ought to have at the least 2 characters (sort=string_too_short, input_value='J', input_type=str)
For additional info go to 
birth_date
Date must be prior to now (sort=date_past, input_value='2024-12-12', input_type=str)
For additional info go to 
# ----
payload = {
'url': '',
'title': 'Joe-1234567891011121314',
'birth_date': '2020-12-12'
}
process_payload(**payload)
> ValidationError: 1 validation error for process_payload
title
String ought to have at most 15 characters (sort=string_too_long, input_value='Joe-1234567891011121314', input_type=str)
For additional info go to 

Đây là những điều cơ bản về cách xác thực đối số hàm và giá trị trả về của chúng.

Bây giờ, chúng ta sẽ tìm hiểu cách quan trọng thứ hai để sử dụng Pydantic nhằm xác thực và xử lý dữ liệu: thông qua việc xác định mô hình.

Phần này thú vị hơn vì mục đích xử lý dữ liệu, như bạn sẽ thấy.

Cho đến nay, chúng tôi đã sử dụng validate_call để trang trí các hàm và các đối số hàm đã chỉ định cùng các kiểu và ràng buộc tương ứng của chúng.

Ở đây, chúng ta định nghĩa các mô hình bằng cách định nghĩa các lớp mô hình, trong đó chúng ta chỉ định các trường, kiểu của chúng và các ràng buộc. Điều này rất giống với những gì chúng ta đã làm trước đó. Bằng cách định nghĩa một lớp mô hình kế thừa từ Pydantic BaseModelchúng tôi sử dụng một cơ chế ẩn thực hiện xác thực dữ liệu, phân tích cú pháp và tuần tự hóa. Điều này mang lại cho chúng tôi khả năng tạo các đối tượng tuân thủ các thông số kỹ thuật của mô hình.

Đây là một ví dụ:

from pydantic import Subject
from pydantic import BaseModel
class Individual(BaseModel):
title: str = Subject(min_length=2, max_length=15)
age: int = Subject(gt=0, lt=120)
# ----
john = Individual(title='john', age=20)
> Individual(title='john', age=20)
# ----
mike = Individual(title='m', age=0)
> ValidationError: 2 validation errors for Individual
title
String ought to have at the least 2 characters (sort=string_too_short, input_value='j', input_type=str)
For additional info go to 
age
Enter must be higher than 0 (sort=greater_than, input_value=0, input_type=int)
For additional info go to 

Bạn cũng có thể sử dụng chú thích ở đây và bạn cũng có thể chỉ định các giá trị mặc định cho các trường. Hãy xem một ví dụ khác:

from pydantic import Subject
from pydantic import BaseModel
from typing import Annotated 
Identify = Annotated(str, Subject(min_length=2, max_length=15))
Age = Annotated(int, Subject(default=1, ge=0, le=120))
class Individual(BaseModel):
title: Identify
age: Age
# ----
mike = Individual(title='mike')
> Individual(title='mike', age=1)

Mọi thứ trở nên rất thú vị khi trường hợp sử dụng của bạn trở nên phức tạp một chút. Hãy nhớ payload mà chúng ta đã định nghĩa? Tôi sẽ định nghĩa một cấu trúc khác phức tạp hơn mà chúng ta sẽ xem xét và xác thực. Để làm cho nó thú vị hơn, hãy tạo một tải trọng mà chúng ta sẽ sử dụng để truy vấn một dịch vụ đóng vai trò là trung gian giữa chúng ta và các nhà cung cấp LLM. Sau đó, chúng ta sẽ xác thực nó.

Đây là một ví dụ:

from pydantic import Subject
from pydantic import BaseModel
from pydantic import ConfigDict
from typing import Literal
from typing import Annotated
from enum import Enum
payload = {
"req_id": "check",
"textual content": "This can be a pattern textual content.",
"instruction": "embed",
"llm_provider": "openai",
"llm_params": {
"llm_temperature": 0,
"llm_model_name": "gpt4o"
},
"misc": "what"
}
ReqID = Annotated(str, Subject(min_length=2, max_length=15))
class LLMProviders(str, Enum):
OPENAI = 'openai'
CLAUDE = 'claude'
class LLMParams(BaseModel):
temperature: int = Subject(validation_alias='llm_temperature', ge=0, le=1)
llm_name: str = Subject(validation_alias='llm_model_name', 
serialization_alias='mannequin')
class Payload(BaseModel):
req_id: str = Subject(exclude=True)
textual content: str = Subject(min_length=5)
instruction: Literal('embed', 'chat')
llm_provider: LLMProviders
llm_params: LLMParams
# model_config = ConfigDict(use_enum_values=True)
# ----
validated_payload = Payload(**payload)
validated_payload
> Payload(req_id='check', 
textual content='This can be a pattern textual content.', 
instruction='embed', 
llm_provider=, 
llm_params=LLMParams(temperature=0, llm_name='gpt4o'))
# ----          
validated_payload.model_dump()
> {'textual content': 'This can be a pattern textual content.',
'instruction': 'embed',
'llm_provider': ,
'llm_params': {'temperature': 0, 'llm_name': 'gpt4o'}}
# ----
validated_payload.model_dump(by_alias=True)
> {'textual content': 'This can be a pattern textual content.',
'instruction': 'embed',
'llm_provider': ,
'llm_params': {'temperature': 0, 'mannequin': 'gpt4o'}}
# ----
# After including 
#     model_config = ConfigDict(use_enum_values=True)
# in Payload mannequin definition, you get
validated_payload.model_dump(by_alias=True)
> {'textual content': 'This can be a pattern textual content.',
'instruction': 'embed',
'llm_provider': 'openai',
'llm_params': {'temperature': 0, 'mannequin': 'gpt4o'}}

Một số hiểu biết quan trọng rút ra từ ví dụ chi tiết này là:

• Bạn có thể sử dụng Enums hoặc Literal để xác định danh sách các giá trị cụ thể được mong đợi.
• Trong trường hợp bạn muốn đặt tên trường của mô hình khác với tên trường trong dữ liệu đã xác thực, bạn có thể sử dụng validation_alias. Nó chỉ định tên trường trong dữ liệu đang được xác thực.
• serialization_alias được sử dụng khi tên trường bên trong của mô hình không nhất thiết phải giống với tên bạn muốn sử dụng khi tuần tự hóa mô hình.
• Trường có thể được loại trừ khỏi tuần tự hóa với exclude=True.
• Các trường mô hình cũng có thể là các mô hình Pydantic. Quá trình xác thực trong trường hợp đó được thực hiện theo cách đệ quy. Phần này thực sự tuyệt vời, vì Pydantic thực hiện công việc đi sâu trong khi xác thực các cấu trúc lồng nhau.
• Các trường không được tính đến trong định nghĩa mô hình sẽ không được phân tích cú pháp.

Ở đây tôi sẽ chỉ cho bạn những đoạn mã cho thấy nơi và cách bạn có thể sử dụng Pydantic trong các công việc hàng ngày của mình.

Giả sử bạn có dữ liệu cần xác thực và xử lý. Dữ liệu có thể được lưu trữ trong CSV, tệp Parquet hoặc, ví dụ, trong cơ sở dữ liệu NoSQL dưới dạng tài liệu. Hãy lấy ví dụ về tệp CSV và giả sử bạn muốn xử lý nội dung của tệp đó.

Đây là tập tin CSV (check.csv) ví dụ:

title,age,bank_account
johnny,0,20
matt,10,0
abraham,100,100000
mary,15,15
linda,130,100000

Và đây là cách nó được xác thực và phân tích:

from pydantic import BaseModel
from pydantic import Subject 
from pydantic import field_validator
from pydantic import ValidationInfo
from typing import Record
import csv
FILE_NAME = 'check.csv'
class DataModel(BaseModel):
title: str = Subject(min_length=2, max_length=15)
age: int = Subject(ge=1, le=120)
bank_account: float = Subject(ge=0, default=0)
@field_validator('title')
@classmethod
def validate_name(cls, v: str, data: ValidationInfo) -> str:
return str(v).capitalize()
class ValidatedModels(BaseModel):
validated: Record(DataModel)
validated_rows = ()
with open(FILE_NAME, 'r') as f:
reader = csv.DictReader(f, delimiter=',')
for row in reader:
strive:
validated_rows.append(DataModel(**row))
besides ValidationError as ve:
# print out error
# disregard the document
print(f'{ve=}')
validated_rows
> (DataModel(title='Matt', age=10, bank_account=0.0),
DataModel(title='Abraham', age=100, bank_account=100000.0),
DataModel(title='Mary', age=15, bank_account=15.0))
validated = ValidatedModels(validated=validated_rows)
validated.model_dump()
> {'validated': ({'title': 'Matt', 'age': 10, 'bank_account': 0.0},
{'title': 'Abraham', 'age': 100, 'bank_account': 100000.0},
{'title': 'Mary', 'age': 15, 'bank_account': 15.0})}

FastAPI đã được tích hợp với Pydantic, vì vậy bài viết này sẽ rất ngắn gọn. Cách FastAPI xử lý các yêu cầu là chuyển chúng đến một hàm xử lý tuyến đường. Bằng cách chuyển yêu cầu này đến một hàm, xác thực được thực hiện tự động. Một cái gì đó tương tự như validate_call mà chúng tôi đã đề cập ở đầu bài viết này.

Ví dụ của app.py được sử dụng để chạy dịch vụ dựa trên FastAPI:

from fastapi import FastAPI
from pydantic import BaseModel, HttpUrl
class Request(BaseModel):
request_id: str
url: HttpUrl
app = FastAPI()
@app.put up("/search/by_url/")
async def create_item(req: Request):
return merchandise

Pydantic là một thư viện thực sự mạnh mẽ và có nhiều cơ chế cho nhiều trường hợp sử dụng và trường hợp ngoại lệ khác nhau. Hôm nay, tôi đã giải thích những phần cơ bản nhất về cách bạn nên sử dụng nó và tôi sẽ cung cấp tài liệu tham khảo bên dưới cho những ai không yếu tim.

Hãy đi và khám phá. Tôi chắc chắn rằng nó sẽ giúp ích cho bạn trên nhiều phương diện khác nhau.