Pydantic BaseModel en détail
Šiame puslapyje
Pydantic : le partenaire idéal
Pydantic est la bibliothèque Python standard pour la validation des données. Avec les sorties structurées de Grok, elle devient un outil essentiel : tu définis tes schémas sous forme de classes Python, et le modèle remplit automatiquement ces classes.
Les bases de Pydantic pour les sorties structurées
Tu crées un modèle Pydantic en héritant de BaseModel. Chaque attribut doté d’une annotation de type devient un champ dans le schéma JSON :
from pydantic import BaseModel
class Produit(BaseModel):
nom: str
prix: float
en_stock: bool
categorie: str
Ce modèle génère automatiquement le schéma JSON équivalent. Tu n’as rien d’autre à écrire.
Types Python pris en charge
Voici la correspondance entre les types Python et les types JSON Schema :
class ExempleComplet(BaseModel):
# Scalaires
texte: str # → "type": "string"
nombre: float # → "type": "number"
entier: int # → "type": "number"
actif: bool # → "type": "boolean"
# Optionnels
note: str | None # → anyOf string/null
# Collections
tags: list[str] # → array of strings
scores: list[float] # → array of numbers
# Énumérations
niveau: str # + enum in Field
Modèles imbriqués
La vraie puissance de Pydantic réside dans l’imbrication des modèles :
class Adresse(BaseModel):
rue: str
ville: str
code_postal: str
pays: str
class Competence(BaseModel):
nom: str
niveau: str # "debutant", "intermediaire", "expert"
annees: int
class Candidat(BaseModel):
prenom: str
nom: str
email: str
adresse: Adresse
competences: list[Competence]
disponible: bool
pretention_salariale: float | None
Lorsque tu passes Candidat comme response_format, le modèle remplit toute la hiérarchie : l’adresse complète, chaque compétence avec ses détails, et ainsi de suite.
Énumérations avec Pydantic
Pour imposer des valeurs prédéfinies, utilise Literal de Python :
from typing import Literal
class Ticket(BaseModel):
titre: str
description: str
priorite: Literal["basse", "moyenne", "haute", "critique"]
statut: Literal["ouvert", "en_cours", "resolu", "ferme"]
type: Literal["bug", "feature", "documentation"]
Le modèle ne peut retourner que les valeurs listées. Toute autre valeur est impossible.
Utilisation de parse()
response, ticket = client.chat.parse(
model="grok-4.20-0309-reasoning",
messages=[{
"role": "user",
"content": "The login button does not work on mobile"
}],
response_format=Ticket
)
print(ticket.priorite) # "haute"
print(ticket.type) # "bug"
print(ticket.statut) # "ouvert"
Utilisation de response_format
response = client.chat.create(
model="grok-4.20-0309-reasoning",
messages=[{
"role": "user",
"content": "The login button does not work on mobile"
}],
response_format=Ticket
)
ticket = Ticket.model_validate_json(
response.choices[0].message.content
)
Valeurs par défaut et documentation
Tu peux ajouter des descriptions à tes champs avec Field. Ces descriptions aident le modèle à mieux comprendre ce que tu attends :
from pydantic import BaseModel, Field
class AnalyseSentiment(BaseModel):
texte_original: str = Field(
description="The text analyzed as is"
)
sentiment: Literal["positif", "negatif", "neutre"] = Field(
description="The dominant sentiment of the text"
)
score_confiance: float = Field(
description="Confidence score between 0.0 and 1.0"
)
mots_cles: list[str] = Field(
description="The 3 to 5 most significant keywords"
)
Les descriptions dans Field sont incluses dans le schéma JSON envoyé au modèle. Elles améliorent la qualité des réponses.
Svarbiausi punktai
- Pydantic convertit automatiquement tes classes Python en schémas JSON
- L’imbrication de modèles te permet de structurer des données complexes
Literalremplaceenumpour imposer des valeurs prédéfiniesstr | Nonerend un champ optionnel (peut êtrenull)Field(description=...)améliore la qualité des réponses du modèle- Fonctionne avec
parse()(automatique) etresponse_format(manuel)