Erreurs d'utilisation

Pydantic tente de fournir des erreurs utiles. Les sections suivantes fournissent des détails sur les erreurs courantes que les développeurs peuvent rencontrer lorsqu'ils travaillent avec Pydantic, ainsi que des suggestions pour résoudre la condition d'erreur.

Classe non entièrement définie

Cette erreur est générée lorsqu'un type référencé dans une annotation d'un type validé par pydantic (comme une sous-classe de BaseModel ou une dataclass pydantic) n'est pas défini:

from typing import ForwardRef

from pydantic import BaseModel, PydanticUserError

UndefinedType = ForwardRef('UndefinedType')


class Foobar(BaseModel):
    a: UndefinedType


try:
    Foobar(a=1)
except PydanticUserError as exc_info:
    assert exc_info.code == 'class-not-fully-defined'

Ou lorsque le type a été défini après utilisation :

from typing import Optional

from pydantic import BaseModel, PydanticUserError


class Foo(BaseModel):
    a: Optional['Bar'] = None


try:
    # this doesn't work, see raised error
    foo = Foo(a={'b': {'a': None}})
except PydanticUserError as exc_info:
    assert exc_info.code == 'class-not-fully-defined'


class Bar(BaseModel):
    b: 'Foo'


# this works, though
foo = Foo(a={'b': {'a': None}})

Pour les sous-classes BaseModel, cela peut être corrigé en définissant le type puis en appelant .model_rebuild() :

from typing import Optional

from pydantic import BaseModel


class Foo(BaseModel):
    a: Optional['Bar'] = None


class Bar(BaseModel):
    b: 'Foo'


Foo.model_rebuild()

foo = Foo(a={'b': {'a': None}})

Dans d'autres cas, le message d'erreur doit indiquer comment reconstruire la classe avec le type approprié défini.

Schéma JSON personnalisé

La méthode __modify_schema__ n'est plus prise en charge dans la V2. Vous devez plutôt utiliser la méthode __get_pydantic_json_schema__ .

Le __modify_schema__ utilisé pour recevoir un seul argument représentant le schéma JSON. Voir l'exemple ci-dessous:

from pydantic import BaseModel, PydanticUserError

try:

    class Model(BaseModel):
        @classmethod
        def __modify_schema__(cls, field_schema):
            field_schema.update(examples='examples')

except PydanticUserError as exc_info:
    assert exc_info.code == 'custom-json-schema'

La nouvelle méthode __get_pydantic_json_schema__ reçoit deux arguments: le premier est un dictionnaire noté CoreSchema , et le second un handler appelable qui reçoit un CoreSchema en paramètre et renvoie un schéma JSON. Voir l'exemple ci-dessous:

from typing import Any, Dict

from pydantic_core import CoreSchema

from pydantic import BaseModel, GetJsonSchemaHandler


class Model(BaseModel):
    @classmethod
    def __get_pydantic_json_schema__(
        cls, core_schema: CoreSchema, handler: GetJsonSchemaHandler
    ) -> Dict[str, Any]:
        json_schema = super().__get_pydantic_json_schema__(core_schema, handler)
        json_schema = handler.resolve_ref_schema(json_schema)
        json_schema.update(examples='examples')
        return json_schema


print(Model.model_json_schema())
"""
{'examples': 'examples', 'properties': {}, 'title': 'Model', 'type': 'object'}
"""

Décorateur sur champ manquant

Cette erreur est générée lorsque vous définissez un décorateur avec un champ qui n'est pas valide.

from typing import Any

from pydantic import BaseModel, PydanticUserError, field_validator

try:

    class Model(BaseModel):
        a: str

        @field_validator('b')
        def check_b(cls, v: Any):
            return v

except PydanticUserError as exc_info:
    assert exc_info.code == 'decorator-missing-field'

Vous pouvez utiliser check_fields=False si vous héritez du modèle et que vous le vouliez.

from typing import Any

from pydantic import BaseModel, create_model, field_validator


class Model(BaseModel):
    @field_validator('a', check_fields=False)
    def check_a(cls, v: Any):
        return v


model = create_model('FooModel', a=(str, 'cake'), __base__=Model)

Discriminateur sans champ

Cette erreur est générée lorsqu'un modèle dans des unions discriminées ne définit pas de champ discriminateur.

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, PydanticUserError


class Cat(BaseModel):
    c: str


class Dog(BaseModel):
    pet_type: Literal['dog']
    d: str


try:

    class Model(BaseModel):
        pet: Union[Cat, Dog] = Field(..., discriminator='pet_type')
        number: int

except PydanticUserError as exc_info:
    assert exc_info.code == 'discriminator-no-field'

Type d'alias du discriminateur

Cette erreur est générée lorsque vous définissez un alias sans chaîne sur un champ discriminateur.

from typing import Union

from typing_extensions import Literal

from pydantic import AliasChoices, BaseModel, Field, PydanticUserError


class Cat(BaseModel):
    pet_type: Literal['cat'] = Field(
        validation_alias=AliasChoices('Pet', 'PET')
    )
    c: str


class Dog(BaseModel):
    pet_type: Literal['dog']
    d: str


try:

    class Model(BaseModel):
        pet: Union[Cat, Dog] = Field(..., discriminator='pet_type')
        number: int

except PydanticUserError as exc_info:
    assert exc_info.code == 'discriminator-alias-type'

Le discriminateur a besoin d'un sens littéral

Cette erreur est générée lorsque vous définissez un type non Literal sur un champ discriminateur.

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, PydanticUserError


class Cat(BaseModel):
    pet_type: int
    c: str


class Dog(BaseModel):
    pet_type: Literal['dog']
    d: str


try:

    class Model(BaseModel):
        pet: Union[Cat, Dog] = Field(..., discriminator='pet_type')
        number: int

except PydanticUserError as exc_info:
    assert exc_info.code == 'discriminator-needs-literal'

Alias du discriminateur

Cette erreur se produit lorsque vous définissez différents alias sur les champs discriminateurs.

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, PydanticUserError


class Cat(BaseModel):
    pet_type: Literal['cat'] = Field(validation_alias='PET')
    c: str


class Dog(BaseModel):
    pet_type: Literal['dog'] = Field(validation_alias='Pet')
    d: str


try:

    class Model(BaseModel):
        pet: Union[Cat, Dog] = Field(..., discriminator='pet_type')
        number: int

except PydanticUserError as exc_info:
    assert exc_info.code == 'discriminator-alias'

Validateur de discriminateur invalide

Cette erreur est générée lorsque vous utilisez un validateur before, wrap ou plain sur un champ discriminateur.

Ceci n'est pas autorisé car le champ discriminateur est utilisé pour déterminer le type de modèle à utiliser pour la validation. Vous ne pouvez donc pas utiliser un validateur susceptible de modifier sa valeur.

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, PydanticUserError, field_validator


class Cat(BaseModel):
    pet_type: Literal['cat']

    @field_validator('pet_type', mode='before')
    @classmethod
    def validate_pet_type(cls, v):
        if v == 'kitten':
            return 'cat'
        return v


class Dog(BaseModel):
    pet_type: Literal['dog']


try:

    class Model(BaseModel):
        pet: Union[Cat, Dog] = Field(..., discriminator='pet_type')
        number: int

except PydanticUserError as exc_info:
    assert exc_info.code == 'discriminator-validator'

Cela peut être contourné en utilisant un Union standard, en supprimant le discriminateur:

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, field_validator


class Cat(BaseModel):
    pet_type: Literal['cat']

    @field_validator('pet_type', mode='before')
    @classmethod
    def validate_pet_type(cls, v):
        if v == 'kitten':
            return 'cat'
        return v


class Dog(BaseModel):
    pet_type: Literal['dog']


class Model(BaseModel):
    pet: Union[Cat, Dog]


assert Model(pet={'pet_type': 'kitten'}).pet.pet_type == 'cat'

Cas de discriminateur appelable sans balise

Cette erreur se produit lorsqu'une Union qui utilise un Discriminator appelable n'a pas d'annotations Tag pour tous les cas.

from typing import Union

from typing_extensions import Annotated

from pydantic import BaseModel, Discriminator, PydanticUserError, Tag


def model_x_discriminator(v):
    if isinstance(v, str):
        return 'str'
    if isinstance(v, (dict, BaseModel)):
        return 'model'


# tag missing for both union choices
try:

    class DiscriminatedModel(BaseModel):
        x: Annotated[
            Union[str, 'DiscriminatedModel'],
            Discriminator(model_x_discriminator),
        ]

except PydanticUserError as exc_info:
    assert exc_info.code == 'callable-discriminator-no-tag'

# tag missing for `'DiscriminatedModel'` union choice
try:

    class DiscriminatedModel(BaseModel):
        x: Annotated[
            Union[Annotated[str, Tag('str')], 'DiscriminatedModel'],
            Discriminator(model_x_discriminator),
        ]

except PydanticUserError as exc_info:
    assert exc_info.code == 'callable-discriminator-no-tag'

# tag missing for `str` union choice
try:

    class DiscriminatedModel(BaseModel):
        x: Annotated[
            Union[str, Annotated['DiscriminatedModel', Tag('model')]],
            Discriminator(model_x_discriminator),
        ]

except PydanticUserError as exc_info:
    assert exc_info.code == 'callable-discriminator-no-tag'

Version TypedDict

Cette erreur est générée lorsque vous utilisez typing.TypedDict au lieu de typing_extensions.TypedDict sur Python < 3.12.

Champ parent du modèle remplacé

Cette erreur est générée lorsqu'un champ défini sur une classe de base a été remplacé par un attribut non annoté.

from pydantic import BaseModel, PydanticUserError


class Foo(BaseModel):
    a: float


try:

    class Bar(Foo):
        x: float = 12.3
        a = 123.0

except PydanticUserError as exc_info:
    assert exc_info.code == 'model-field-overridden'

Annotation manquante dans le champ modèle

Cette erreur est générée lorsqu'un champ n'a pas d'annotation.

from pydantic import BaseModel, Field, PydanticUserError

try:

    class Model(BaseModel):
        a = Field('foobar')
        b = None

except PydanticUserError as exc_info:
    assert exc_info.code == 'model-field-missing-annotation'

Si le champ n'est pas censé être un champ, vous pourrez peut-être résoudre l'erreur en l'annotant en tant que ClassVar :

from typing import ClassVar

from pydantic import BaseModel


class Model(BaseModel):
    a: ClassVar[str]

Ou en mettant à jour model_config['ignored_types'] :

from pydantic import BaseModel, ConfigDict


class IgnoredType:
    pass


class MyModel(BaseModel):
    model_config = ConfigDict(ignored_types=(IgnoredType,))

    _a = IgnoredType()
    _b: int = IgnoredType()
    _c: IgnoredType
    _d: IgnoredType = IgnoredType()

Config et model_config ont tous deux définis

Cette erreur est générée lorsque class Config et model_config sont utilisées ensemble.

from pydantic import BaseModel, ConfigDict, PydanticUserError

try:

    class Model(BaseModel):
        model_config = ConfigDict(from_attributes=True)

        a: str

        class Config:
            from_attributes = True

except PydanticUserError as exc_info:
    assert exc_info.code == 'config-both'

Arguments de mots clés supprimés

Cette erreur est générée lorsque les arguments de mots-clés ne sont pas disponibles dans Pydantic V2.

Par exemple, regex est supprimée de Pydantic V2:

from pydantic import BaseModel, Field, PydanticUserError

try:

    class Model(BaseModel):
        x: str = Field(regex='test')

except PydanticUserError as exc_info:
    assert exc_info.code == 'removed-kwargs'

Type de schéma JSON non valide

Cette erreur se produit lorsque Pydantic ne parvient pas à générer un schéma JSON pour certains CoreSchema .

from pydantic import BaseModel, ImportString, PydanticUserError


class Model(BaseModel):
    a: ImportString


try:
    Model.model_json_schema()
except PydanticUserError as exc_info:
    assert exc_info.code == 'invalid-for-json-schema'

Schéma JSON déjà utilisé

Cette erreur se produit lorsque le générateur de schéma JSON a déjà été utilisé pour générer un schéma JSON. Vous devez créer une nouvelle instance pour générer un nouveau schéma JSON.

BaseModel instancié

Cette erreur est générée lorsque vous instanciez directement BaseModel . Les modèles Pydantic doivent hériter de BaseModel .

from pydantic import BaseModel, PydanticUserError

try:
    BaseModel()
except PydanticUserError as exc_info:
    assert exc_info.code == 'base-model-instantiated'

Annotation non définie

Cette erreur est générée lors de la gestion d'annotations non définies lors de la génération CoreSchema .

from pydantic import BaseModel, PydanticUndefinedAnnotation


class Model(BaseModel):
    a: 'B'  # noqa F821


try:
    Model.model_rebuild()
except PydanticUndefinedAnnotation as exc_info:
    assert exc_info.code == 'undefined-annotation'

Schéma pour type inconnu

Cette erreur est générée lorsque Pydantic ne parvient pas à générer un CoreSchema pour un certain type.

from pydantic import BaseModel, PydanticUserError

try:

    class Model(BaseModel):
        x: 43 = 123

except PydanticUserError as exc_info:
    assert exc_info.code == 'schema-for-unknown-type'

Erreur d'importation

Cette erreur se produit lorsque vous essayez d'importer un objet qui était disponible dans Pydantic V1, mais qui a été supprimé dans Pydantic V2.

Consultez le Guide de migration pour plus d'informations.

définitions de champ create_model

Cette erreur se produit lorsque vous fournissez une entrée de définitions de champ dans create_model qui n'est pas valide.

from pydantic import PydanticUserError, create_model

try:
    create_model('FooModel', foo=(str, 'default value', 'more'))
except PydanticUserError as exc_info:
    assert exc_info.code == 'create-model-field-definitions'

Ou lorsque vous utilisez typing.Annotated avec une entrée invalide

from typing_extensions import Annotated

from pydantic import PydanticUserError, create_model

try:
    create_model('FooModel', foo=Annotated[str, 'NotFieldInfoValue'])
except PydanticUserError as exc_info:
    assert exc_info.code == 'create-model-field-definitions'

base de configuration create_model

Cette erreur se produit lorsque vous utilisez à la fois __config__ et __base__ dans create_model .

from pydantic import BaseModel, ConfigDict, PydanticUserError, create_model

try:
    config = ConfigDict(frozen=True)
    model = create_model(
        'FooModel', foo=(int, ...), __config__=config, __base__=BaseModel
    )
except PydanticUserError as exc_info:
    assert exc_info.code == 'create-model-config-base'

Validateur sans champs

Cette erreur se produit lorsque vous utilisez le validateur nu (sans champs).

from pydantic import BaseModel, PydanticUserError, field_validator

try:

    class Model(BaseModel):
        a: str

        @field_validator
        def checker(cls, v):
            return v

except PydanticUserError as exc_info:
    assert exc_info.code == 'validator-no-fields'

Les validateurs doivent être utilisés avec des champs et des arguments de mots clés.

from pydantic import BaseModel, field_validator


class Model(BaseModel):
    a: str

    @field_validator('a')
    def checker(cls, v):
        return v

Champs de validation invalides

Cette erreur est générée lorsque vous utilisez un validateur avec des champs autres que des chaînes.

from pydantic import BaseModel, PydanticUserError, field_validator

try:

    class Model(BaseModel):
        a: str
        b: str

        @field_validator(['a', 'b'])
        def check_fields(cls, v):
            return v

except PydanticUserError as exc_info:
    assert exc_info.code == 'validator-invalid-fields'

Les champs doivent être transmis sous forme d'arguments de chaîne distincts:

from pydantic import BaseModel, field_validator


class Model(BaseModel):
    a: str
    b: str

    @field_validator('a', 'b')
    def check_fields(cls, v):
        return v

Validateur sur la méthode d'instance

Cette erreur est générée lorsque vous appliquez un validateur sur une méthode d'instance.

from pydantic import BaseModel, PydanticUserError, field_validator

try:

    class Model(BaseModel):
        a: int = 1

        @field_validator('a')
        def check_a(self, values):
            return values

except PydanticUserError as exc_info:
    assert exc_info.code == 'validator-instance-method'

Validateur racine, pre , skip_on_failure

Si vous utilisez @root_validator avec pre=False (valeur par défaut), vous DEVEZ spécifier skip_on_failure=True . L'option skip_on_failure=False n'est plus disponible.

Si vous n'essayiez pas de définir skip_on_failure=False , vous pouvez définir en toute sécurité skip_on_failure=True . Si vous le faites, ce validateur racine ne sera plus appelé si la validation échoue pour l'un des champs.

Veuillez consulter le Guide de migration pour plus de détails.

méthodes d'instance model_serializer

@model_serializer doit être appliqué aux méthodes d'instance.

Cette erreur est générée lorsque vous appliquez model_serializer sur une méthode d'instance sans self:

from pydantic import BaseModel, PydanticUserError, model_serializer

try:

    class MyModel(BaseModel):
        a: int

        @model_serializer
        def _serialize(slf, x, y, z):
            return slf

except PydanticUserError as exc_info:
    assert exc_info.code == 'model-serializer-instance-method'

Ou sur une méthode de classe:

from pydantic import BaseModel, PydanticUserError, model_serializer

try:

    class MyModel(BaseModel):
        a: int

        @model_serializer
        @classmethod
        def _serialize(self, x, y, z):
            return self

except PydanticUserError as exc_info:
    assert exc_info.code == 'model-serializer-instance-method'

validator , field , config et info

Les paramètres field et config ne sont pas disponibles dans Pydantic V2. Veuillez utiliser le paramètre info à la place.

Vous pouvez accéder à la configuration via info.config , mais il s'agit d'un dictionnaire au lieu d'un objet comme c'était le cas dans Pydantic V1.

L'argument field n'est plus disponible.

Signature du validateur Pydantic V1

Cette erreur se produit lorsque vous utilisez une signature non prise en charge pour le validateur de style Pydantic V1.

import warnings

from pydantic import BaseModel, PydanticUserError, validator

warnings.filterwarnings('ignore', category=DeprecationWarning)

try:

    class Model(BaseModel):
        a: int

        @validator('a')
        def check_a(cls, value, foo):
            return value

except PydanticUserError as exc_info:
    assert exc_info.code == 'validator-v1-signature'

Signature field_validator non reconnue

Cette erreur est générée lorsqu'une fonction field_validator ou model_validator a la mauvaise signature.

from pydantic import BaseModel, PydanticUserError, field_validator

try:

    class Model(BaseModel):
        a: str

        @field_validator('a')
        @classmethod
        def check_a(cls):
            return 'a'

except PydanticUserError as exc_info:
    assert exc_info.code == 'validator-signature'

Signature field_serializer non reconnue

Cette erreur est générée lorsque la fonction field_serializer a la mauvaise signature.

from pydantic import BaseModel, PydanticUserError, field_serializer

try:

    class Model(BaseModel):
        x: int

        @field_serializer('x')
        def no_args():
            return 'x'

except PydanticUserError as exc_info:
    assert exc_info.code == 'field-serializer-signature'

Les signatures valides du sérialiseur sont:

from pydantic import model_serializer

# an instance method with the default mode or `mode='plain'`
@model_serializer('x')  # or @serialize('x', mode='plain')
def ser_x(self, value: Any, info: pydantic.FieldSerializationInfo): ...

# a static method or free-standing function with the default mode or `mode='plain'`
@model_serializer('x')  # or @serialize('x', mode='plain')
@staticmethod
def ser_x(value: Any, info: pydantic.FieldSerializationInfo): ...
# equivalent to
def ser_x(value: Any, info: pydantic.FieldSerializationInfo): ...
serializer('x')(ser_x)

# an instance method with `mode='wrap'`
@model_serializer('x', mode='wrap')
def ser_x(self, value: Any, nxt: pydantic.SerializerFunctionWrapHandler, info: pydantic.FieldSerializationInfo): ...

# a static method or free-standing function with `mode='wrap'`
@model_serializer('x', mode='wrap')
@staticmethod
def ser_x(value: Any, nxt: pydantic.SerializerFunctionWrapHandler, info: pydantic.FieldSerializationInfo): ...
# equivalent to
def ser_x(value: Any, nxt: pydantic.SerializerFunctionWrapHandler, info: pydantic.FieldSerializationInfo): ...
serializer('x')(ser_x)

For all of these, you can also choose to omit the `info` argument, for example:

@model_serializer('x')
def ser_x(self, value: Any): ...

@model_serializer('x', mode='wrap')
def ser_x(self, value: Any, handler: pydantic.SerializerFunctionWrapHandler): ...

Signature model_serializer non reconnue

Cette erreur est générée lorsque la fonction model_serializer a la mauvaise signature.

from pydantic import BaseModel, PydanticUserError, model_serializer

try:

    class MyModel(BaseModel):
        a: int

        @model_serializer
        def _serialize(self, x, y, z):
            return self

except PydanticUserError as exc_info:
    assert exc_info.code == 'model-serializer-signature'

Sérialiseurs de champs multiples

Cette erreur est générée lorsque plusieurs fonctions model_serializer sont définies pour un champ.

from pydantic import BaseModel, PydanticUserError, field_serializer

try:

    class MyModel(BaseModel):
        x: int
        y: int

        @field_serializer('x', 'y')
        def serializer1(v):
            return f'{v:,}'

        @field_serializer('x')
        def serializer2(v):
            return v

except PydanticUserError as exc_info:
    assert exc_info.code == 'multiple-field-serializers'

Type annoté invalide

Cette erreur est générée lorsqu'une annotation ne peut pas annoter un type.

from typing_extensions import Annotated

from pydantic import BaseModel, FutureDate, PydanticUserError

try:

    class Model(BaseModel):
        foo: Annotated[str, FutureDate()]

except PydanticUserError as exc_info:
    assert exc_info.code == 'invalid-annotated-type'

config n'est pas utilisée avec TypeAdapter

Vous obtiendrez cette erreur si vous essayez de transmettre config à TypeAdapter lorsque le type est un type qui a sa propre configuration qui ne peut pas être remplacée (actuellement, il s'agit uniquement BaseModel , TypedDict et dataclass ):

from typing_extensions import TypedDict

from pydantic import ConfigDict, PydanticUserError, TypeAdapter


class MyTypedDict(TypedDict):
    x: int


try:
    TypeAdapter(MyTypedDict, config=ConfigDict(strict=True))
except PydanticUserError as exc_info:
    assert exc_info.code == 'type-adapter-config-unused'

Au lieu de cela, vous devrez sous-classer le type et remplacer ou définir la configuration dessus:

from typing_extensions import TypedDict

from pydantic import ConfigDict, TypeAdapter


class MyTypedDict(TypedDict):
    x: int

    # or `model_config = ...` for BaseModel
    __pydantic_config__ = ConfigDict(strict=True)


TypeAdapter(MyTypedDict)  # ok

Impossible de spécifier model_config['extra'] avec RootModel

Parce que RootModel n'est pas capable de stocker ou même d'accepter des champs supplémentaires lors de l'initialisation, nous générons une erreur si vous essayez de spécifier une valeur pour le paramètre de configuration 'extra' lors de la création d'une sous-classe de RootModel :

from pydantic import PydanticUserError, RootModel

try:

    class MyRootModel(RootModel):
        model_config = {'extra': 'allow'}
        root: int

except PydanticUserError as exc_info:
    assert exc_info.code == 'root-model-extra'

Impossible d'évaluer l'annotation de type

Étant donné que les annotations de type sont évaluées après les affectations, vous pouvez obtenir des résultats inattendus lorsque vous utilisez un nom d'annotation de type qui entre en conflit avec l'un de vos champs. Nous remontons une erreur dans le cas suivant :

from datetime import date

from pydantic import BaseModel, Field


class Model(BaseModel):
    date: date = Field(description='A date')

Pour contourner le problème, vous pouvez soit utiliser un alias, soit modifier votre importation:

import datetime
# Or `from datetime import date as _date`

from pydantic import BaseModel, Field


class Model(BaseModel):
    date: datetime.date = Field(description='A date')

init dataclass incompatible et paramètres extra

Pydantic n'autorise pas la spécification du paramètre extra='allow' sur une classe de données alors que l'un des champs a init=False défini.

Ainsi, vous ne pouvez pas faire quelque chose comme ce qui suit:

from pydantic import ConfigDict, Field
from pydantic.dataclasses import dataclass


@dataclass(config=ConfigDict(extra='allow'))
class A:
    a: int = Field(init=False, default=1)

L'extrait ci-dessus entraîne l'erreur suivante lors de la création du schéma pour la classe de données A:

pydantic.errors.PydanticUserError: Field a has `init=False` and dataclass has config setting `extra="allow"`.
This combination is not allowed.

Paramètres init et init_var incompatibles sur le champ dataclass

Les paramètres init=False et init_var=True s'excluent mutuellement. Cela entraîne l’ PydanticUserError indiquée dans l’exemple ci-dessous.

from pydantic import Field
from pydantic.dataclasses import dataclass


@dataclass
class Foo:
    bar: str = Field(..., init=False, init_var=True)


"""
pydantic.errors.PydanticUserError: Dataclass field bar has init=False and init_var=True, but these are mutually exclusive.
"""

model_config est utilisé comme champ de modèle

Cette erreur est générée lorsque model_config est utilisé comme nom d'un champ.

from pydantic import BaseModel, PydanticUserError

try:

    class Model(BaseModel):
        model_config: str

except PydanticUserError as exc_info:
    assert exc_info.code == 'model-config-invalid-field-name'

with_config est utilisé sur une sous-classe BaseModel

Cette erreur est générée lorsque le décorateur with_config est utilisé sur une classe qui est déjà un modèle Pydantic (utilisez plutôt l'attribut model_config ).

from pydantic import BaseModel, PydanticUserError, with_config

try:

    @with_config({'allow_inf_nan': True})
    class Model(BaseModel):
        bar: str

except PydanticUserError as exc_info:
    assert exc_info.code == 'with-config-on-model'

dataclass est utilisé sur une sous-classe BaseModel

Cette erreur est générée lorsque le décorateur dataclass Pydantic est utilisé sur une classe qui est déjà un modèle Pydantic.

from pydantic import BaseModel, PydanticUserError
from pydantic.dataclasses import dataclass

try:

    @dataclass
    class Model(BaseModel):
        bar: str

except PydanticUserError as exc_info:
    assert exc_info.code == 'dataclass-on-model'

---

本文总阅读量次