Exigence de

Vous pouvez utiliser le modèle ormar au lieu du modèle pydantique dans les paramètres du corps de la requête fastapi.

Si vous le souhaitez, vous pouvez bien sûr mélanger Ormar.Models avec Pydantic.

Une des tâches les plus courantes dans une requête consiste à exclure certains champs que vous ne souhaitez pas inclure dans la charge envoyée à l'API.

Cela peut être fait de plusieurs façons dans Ormar, vous pouvez donc consulter vos options ci-dessous et choisir celle qui convient le mieux à votre situation.

Exclure des champs dans une demande

Champs optionnels

Notez que chaque champ facultatif n'est pas obligatoire, ce qui signifie que les champs facultatifs peuvent être ignorés à la fois dans la réponse et la demande.

Les champs ne sont pas nécessaires si (tous/plusieurs/tous):

Le champ est marqué nullable=True
Le champ a une valeur par défaut ou une fonction fournie, c'est-à-dire default="Test"
Le champ a la valeur server_default définie
Field est un champ autoincrement=Trueprimary_key (notez que ormar.Integerprimary_key est autoincrement par défaut)

Exemples:

base_ormar_config = ormar.OrmarConfig(
    Metadata= métadonnée
    database=database
)

Classe Utilisateur (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    email: str = ormar.String(max_length=255)
    password: str = ormar.String(max_length=255)
    first_name: str = ormar.String(max_length=255, nullable=True)
    last_name: str = ormar.String(max_length=255)
    catégorie: str = ormar.String(max_length=255, default="User")

Dans l'exemple ci-dessus, le champ id (qui est un entier incrémental automatique), le premier_nom (avec nullable=True) et la catégorie (avec une valeur par défaut) sont facultatifs et peuvent être ignorés dans la réponse, et le modèle sera toujours validé.

Si le champ peut être vide, il n'est pas nécessaire de l'inclure dans la charge utile lors de sa création ainsi que dans la réponse, donc selon l'exemple ci-dessus, vous pouvez:

Attention!!! Notez que bien que vous n'ayez pas à passer un champ facultatif, vous pouvez toujours le faire. si quelqu 'un passe une valeur, elle sera utilisée plus tard, à moins que vous ne preniez des mesures pour l'empêcher.

# note cette application est une application FastApi
@ app.post ("/users/", response_model=User) #ici nous utilisons l'ormar.Model in response
async def create_user(user: User): #ici nous utilisons ormar. modèle dans le paramètre de demande
    return await user.save ()

Cela signifie que si vous ne passez pas ie first_name dans la requête, il sera correctement validé (car le champ est facultatif) et None sera enregistré dans la base de données.

Générer un modèle pydantique à partir d'un modèle ormar.

Étant donné que la tâche d'exclure des champs est très courante, ormar dispose d'une méthode spéciale pour générer des modèles pydantiques à partir d'un modèle ormar.Models existant sans avoir à ressaisir tous les champs.

Cette méthode est la méthode get_pydantic() disponible pour toutes les classes de modèle.

# generate a tree of models without password on User et without priority on nested Category
RequestUser = User.get_pydantic(exclude={"password": ..., "category":{"priority"}})
@ app.post ("/users3/", response_model=User) #ici vous pouvez aussi utiliser both ormar/pydantic
async def create_user3(user: RequestUser): # use the generated model here
    # note comment maintenant l'utilisateur est un modèle cydantique et non ordonné, donc vous devez convertir
    return await User(**user.model_dump()).save()

!!! NOTE Pour voir plus d'exemples et lire plus, visitez la section get_pydantic de la documentation.

Attention La méthode get_pydantic génère tous les modèles de l'arbre de modèles imbriqués selon un algorithme qui permet d'éviter les boucles dans le modèle (même algorithme utilisé dans model_dump(), select_all(), etc.).

Cela signifie que les modèles naturels n'ont pas de référence au modèle parent (par défaut, la relation orale est bidirectionnelle).

Remarque: si le modèle donné existe dans un arbre plus qu 'une fois, il sera doublé dans les modèles pydantiques (chaque occurrence aura son propre modèle séparé).

Mypy et vérification de type

Notez que l'affectation d'une fonction en tant que type python passe à l'exécution (car non vérifiée), et les vérificateurs de type statique comme mypy se plaignent.

Bien que le résultat d'un appel de fonction soit toujours le même pour un modèle donné, les types créés dynamiquement ne sont pas autorisés.

Vous avez donc deux options:

La première consiste simplement à ajouter # type:ignore pour ignorer la vérification de type.

RequestUser = User.get_pydantic(exclude={"password": ..., "category":{"priority"}})
@ app.post ("/users3/", response_model= utilisateur)
async def create_user3(user: RequestUser): # type: ignore
    # note comment maintenant l'utilisateur n'est pas un modèle d'ordre, donc vous devez convertir
    return await User(**user.model_dump()).save()

Le second est un peu plus hacky, en utilisant la façon dont fastapi extrait les arguments de la fonction.

Vous pouvez remplacer__annotations__entrée pour un paramètre donné.

RequestUser = User.get_pydantic(exclude={"password": ..., "category":{"priority"}})
#Ne pas utiliser le décorateur d'application
async def create_user3(user: User): # use omar modèle ici
    return await User(**user.model_dump()).save()
# overwrite l'entrée d'annotations de fonction pour le param utilisateur avec le modèle généré
create_user3.__annotations__["user"] = RequestUser
# manually call app functions (app.get, app.post, etc.) et passez votre référence de fonction
app.post ("/categories/", response_model=User)(create_user3)

Notez que cela conduira mypy à "penser" que l'utilisateur est un modèle ormar, mais comme dans la requête, cela n'a pas d'importance (vous passerez le dict jsonized de toute façon et devrez le convertir avant de l'enregistrer).

Cela devrait toujours fonctionner correctement, car le modèle résultant sera un sous-ensemble de champs, de sorte que tous les champs requis seront validés et que tous les champs inutilisés échoueront à l'exécution.

Modèle cantilever indépendant

La solution finale consiste à créer manuellement des modèles pydantiques distincts. cela fonctionne exactement comme une application fastapi normale, vous pouvez donc utiliser différents modèles de réponse et de demande, etc.

Sample de:

Import Pydantic

Classe UserCreate(pydantic.BaseModel):
    model_config = pydantic.ConfigDict(from_attributes=True)

    par email: str
    premier_nom: str
    last_name: str
    mot de passe: str


@ app.post ("/users3/", response_model=User) # use omar modèle ici (mais de course vous pouvez utiliser pydantic aussi ici)
async def create_user3(user: UserCreate): # use pydantic model ici
    # note comment maintenant demander param est un modèle pydantique et pas l'ordre un
    # So you need to parse/Convertir à l'ordre avant de pouvoir utiliser la base de données
    return await User(**user.model_dump()).save()