Anwendungsfehler

Pydantic versucht, nützliche Fehler bereitzustellen. Die folgenden Abschnitte enthalten Details zu häufigen Fehlern, auf die Entwickler bei der Arbeit mit Pydantic stoßen können, sowie Vorschläge zur Behebung der Fehlerbedingung.

Klasse nicht vollständig definiert

Dieser Fehler wird ausgelöst, wenn ein Typ, auf den in einer Annotation eines pydantic-validierten Typs verwiesen wird (z. B. eine Unterklasse von BaseModel oder eine pydantic- dataclass ), nicht definiert ist:

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'

Oder wenn der Typ nach der Verwendung definiert wurde:

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}})

Bei BaseModel-Unterklassen kann dies behoben werden, indem der Typ definiert und dann .model_rebuild() aufgerufen wird:

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}})

In anderen Fällen sollte die Fehlermeldung angeben, wie die Klasse mit dem entsprechenden definierten Typ neu erstellt werden kann.

Benutzerdefiniertes JSON-Schema

Die Methode __modify_schema__ wird in V2 nicht mehr unterstützt. Sie sollten stattdessen die Methode __get_pydantic_json_schema__ verwenden.

Das __modify_schema__ wird verwendet, um ein einzelnes Argument zu empfangen, das das JSON-Schema darstellt. Siehe das Beispiel unten:

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'

Die neue Methode __get_pydantic_json_schema__ empfängt zwei Argumente: Das erste ist ein Wörterbuch mit der Bezeichnung CoreSchema und das zweite ein aufrufbarer handler , der ein CoreSchema als Parameter empfängt und ein JSON-Schema zurückgibt. Siehe das Beispiel unten:

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'}
"""

Dekorateur auf fehlendem Feld

Dieser Fehler wird ausgelöst, wenn Sie einen Dekorator mit einem ungültigen Feld definieren.

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'

Sie können check_fields=False verwenden, wenn Sie vom Modell erben und dies beabsichtigen.

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)

Diskriminator kein Feld

Dieser Fehler wird ausgelöst, wenn ein Modell in diskriminierten Gewerkschaften kein Diskriminatorfeld definiert.

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'

Diskriminator-Aliastyp

Dieser Fehler wird ausgelöst, wenn Sie einen Nicht-String-Alias für ein Diskriminatorfeld definieren.

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'

Diskriminator braucht Literal

Dieser Fehler wird ausgelöst, wenn Sie einen Nicht Literal -Typ für ein Diskriminatorfeld definieren.

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'

Diskriminator-Alias

Dieser Fehler wird ausgelöst, wenn Sie unterschiedliche Aliase für Diskriminatorfelder definieren.

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'

Ungültiger Diskriminator-Validator

Dieser Fehler wird ausgelöst, wenn Sie einen Before-, Wrap- oder Plain-Validator für ein Diskriminatorfeld verwenden.

Dies ist nicht zulässig, da das Diskriminatorfeld verwendet wird, um den Typ des für die Validierung zu verwendenden Modells zu bestimmen. Sie können also keinen Validator verwenden, der seinen Wert ändern könnte.

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'

Dies kann umgangen werden, indem ein Standard Union verwendet und der Diskriminator weggelassen wird:

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'

Callable-Diskriminator-Fall ohne Tag

Dieser Fehler wird ausgelöst, wenn eine Union , die einen aufrufbaren Discriminator verwendet, nicht für alle Fälle Tag -Anmerkungen verfügt.

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'

TypedDict version

Dieser Fehler wird ausgelöst, wenn Sie typing.TypedDict anstelle von typing_extensions.TypedDict in Python < 3.12 verwenden.

Das übergeordnete Modellfeld wurde überschrieben

Dieser Fehler wird ausgelöst, wenn ein in einer Basisklasse definiertes Feld durch ein nicht annotiertes Attribut überschrieben wurde.

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 zum Modellfeld fehlt

Dieser Fehler wird ausgelöst, wenn ein Feld keine Anmerkung hat.

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'

Wenn das Feld kein Feld sein soll, können Sie den Fehler möglicherweise beheben, indem Sie es als ClassVar annotieren:

from typing import ClassVar

from pydantic import BaseModel


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

Oder model_config['ignored_types'] aktualisieren:

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 und model_config definierten beide

Dieser Fehler wird ausgelöst, wenn class Config und model_config zusammen verwendet werden.

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'

Keyword-Argumente entfernt

Dieser Fehler wird ausgelöst, wenn die Schlüsselwortargumente in Pydantic V2 nicht verfügbar sind.

regex wird beispielsweise aus Pydantic V2 entfernt:

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'

JSON schema invalid type

Dieser Fehler wird ausgelöst, wenn Pydantic für einige CoreSchema kein JSON-Schema generieren kann.

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'

JSON-Schema bereits verwendet

Dieser Fehler wird ausgelöst, wenn der JSON-Schemagenerator bereits zum Generieren eines JSON-Schemas verwendet wurde. Sie müssen eine neue Instanz erstellen, um ein neues JSON-Schema zu generieren.

BaseModel instanziiert

Dieser Fehler wird ausgelöst, wenn Sie BaseModel direkt instanziieren. Pydantic-Modelle sollten von BaseModel erben.

from pydantic import BaseModel, PydanticUserError

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

Undefinierte Anmerkung

Dieser Fehler wird ausgelöst, wenn undefinierte Anmerkungen während CoreSchema Generierung verarbeitet werden.

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'

Schema für unbekannten Typ

Dieser Fehler wird ausgelöst, wenn Pydantic für einen Typ kein CoreSchema generiert.

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'

Importfehler

Dieser Fehler wird ausgelöst, wenn Sie versuchen, ein Objekt zu importieren, das in Pydantic V1 verfügbar war, aber in Pydantic V2 entfernt wurde.

Weitere Informationen finden Sie im Migrationsleitfaden .

create_model Felddefinitionen

Dieser Fehler wird ausgelöst, wenn Sie in create_model eine Felddefinitionseingabe bereitstellen, die ungültig ist.

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'

Oder wenn Sie typing.Annotated mit ungültiger Eingabe verwenden

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'

create_model -Konfigurationsbasis

Dieser Fehler wird ausgelöst, wenn Sie sowohl __config__ als auch __base__ zusammen in create_model verwenden.

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'

Validator ohne Felder

Dieser Fehler wird ausgelöst, wenn Sie den Validator nackt (ohne Felder) verwenden.

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'

Validatoren sollten mit Feldern und Schlüsselwortargumenten verwendet werden.

from pydantic import BaseModel, field_validator


class Model(BaseModel):
    a: str

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

Ungültige Validatorfelder

Dieser Fehler wird ausgelöst, wenn Sie einen Validator mit Nicht-String-Feldern verwenden.

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'

Felder sollten als separate String-Argumente übergeben werden:

from pydantic import BaseModel, field_validator


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

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

Validator für Instanzmethode

Dieser Fehler wird ausgelöst, wenn Sie einen Validator auf eine Instanzmethode anwenden.

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'

Root-Validator, pre , skip_on_failure

Wenn Sie @root_validator mit pre=False (Standardeinstellung) verwenden, MÜSSEN Sie skip_on_failure=True angeben. Die Option skip_on_failure=False ist nicht mehr verfügbar.

Wenn Sie nicht versucht haben skip_on_failure=False festzulegen, können Sie skip_on_failure=True bedenkenlos festlegen. Wenn Sie dies tun, wird dieser Root-Validator nicht mehr aufgerufen, wenn die Validierung für eines der Felder fehlschlägt.

Weitere Informationen finden Sie im Migrationsleitfaden .

model_serializer Instanzmethoden

@model_serializer muss auf Instanzmethoden angewendet werden.

Dieser Fehler wird ausgelöst, wenn Sie model_serializer auf eine Instanzmethode ohne self anwenden:

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'

Oder auf einer Klassenmethode:

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 und info

Die field und config sind in Pydantic V2 nicht verfügbar. Bitte verwenden Sie stattdessen den info -Parameter.

Sie können über info.config auf die Konfiguration zugreifen, es handelt sich jedoch um ein Wörterbuch und nicht um ein Objekt wie in Pydantic V1.

Das field ist nicht mehr verfügbar.

Pydantic V1-Validatorsignatur

Dieser Fehler wird ausgelöst, wenn Sie eine nicht unterstützte Signatur für den Validator im Pydantic V1-Stil verwenden.

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'

Unbekannte field_validator -Signatur

Dieser Fehler wird ausgelöst, wenn eine field_validator oder model_validator -Funktion die falsche Signatur hat.

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'

Unbekannte field_serializer Signatur

Dieser Fehler wird ausgelöst, wenn die Funktion field_serializer die falsche Signatur hat.

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'

Gültige Serialisierungssignaturen sind:

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): ...

Unbekannte model_serializer Signatur

Dieser Fehler wird ausgelöst, wenn die Funktion model_serializer die falsche Signatur hat.

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'

Serialisierer für mehrere Felder

Dieser Fehler wird ausgelöst, wenn mehrere model_serializer -Funktionen für ein Feld definiert sind.

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'

Ungültiger annotierter Typ

Dieser Fehler wird ausgelöst, wenn eine Annotation einen Typ nicht annotieren kann.

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 wird mit TypeAdapter nicht verwendet

Sie erhalten diese Fehlermeldung, wenn Sie versuchen, config an TypeAdapter zu übergeben, wenn es sich bei dem Typ um einen Typ handelt, der über eine eigene Konfiguration verfügt, die nicht überschrieben werden kann (derzeit sind dies nur BaseModel , TypedDict und 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'

Stattdessen müssen Sie den Typ in eine Unterklasse umwandeln und die Konfiguration überschreiben oder festlegen:

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

model_config['extra'] kann nicht mit RootModel {#root-model-extra} angegeben werden

Da RootModel nicht in der Lage ist, zusätzliche Felder während der Initialisierung zu speichern oder gar zu akzeptieren, lösen wir einen Fehler aus, wenn Sie versuchen, beim Erstellen einer Unterklasse von RootModel einen Wert für die Konfigurationseinstellung 'extra' anzugeben:

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'

Typanmerkung kann nicht ausgewertet werden

Da Typanmerkungen nach Zuweisungen ausgewertet werden, erhalten Sie möglicherweise unerwartete Ergebnisse, wenn Sie einen Typanmerkungsnamen verwenden, der mit einem Ihrer Felder kollidiert. Im folgenden Fall melden wir einen Fehler:

from datetime import date

from pydantic import BaseModel, Field


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

Um dieses Problem zu umgehen, können Sie entweder einen Alias verwenden oder Ihren Import ändern:

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 und extra Einstellungen

Pydantic erlaubt nicht die Angabe der Einstellung extra='allow' für eine Datenklasse, während in einem der Felder init=False gesetzt ist.

Daher dürfen Sie Folgendes nicht tun:

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


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

Das obige Snippet führt während der Schemaerstellung für die A Datenklasse zu folgendem Fehler:

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

Inkompatible init und init_var Einstellungen im dataclass

Die Einstellungen init=False und init_var=True schließen sich gegenseitig aus. Dies führt zu dem im folgenden Beispiel gezeigten PydanticUserError .

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 wird als Modellfeld verwendet

Dieser Fehler wird ausgelöst, wenn model_config als Name eines Feldes verwendet wird.

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 wird auf einer BaseModel Unterklasse {#with-config-on-model} verwendet

Dieser Fehler wird ausgelöst, wenn der Dekorator with_config für eine Klasse verwendet wird, die bereits ein Pydantic-Modell ist (verwenden Sie stattdessen das 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 wird für eine BaseModel Unterklasse verwendet

Dieser Fehler wird ausgelöst, wenn der Pydantic- dataclass für eine Klasse verwendet wird, die bereits ein Pydantic-Modell ist.

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'

---

本文总阅读量次