Gebruikfouten

Pydantic probeert nuttige fouten te bieden. De volgende secties geven details over veelvoorkomende fouten die ontwikkelaars kunnen tegenkomen bij het werken met Pydantic, samen met suggesties voor het aanpakken van de foutconditie.

Klasse niet volledig gedefinieerd

Deze fout treedt op wanneer een type waarnaar wordt verwezen in een annotatie van een pydantic-gevalideerd type (zoals een subklasse van BaseModel of een pydantic dataclass ) niet is gedefinieerd:

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'

Of wanneer het type na gebruik is gedefinieerd:

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

Voor BaseModel-subklassen kan dit worden opgelost door het type te definiëren en vervolgens .model_rebuild() aan te roepen:

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 andere gevallen moet het foutbericht aangeven hoe de klasse opnieuw moet worden opgebouwd met het juiste gedefinieerde type.

Aangepast JSON-schema

De methode __modify_schema__ wordt niet langer ondersteund in V2. U moet in plaats daarvan de methode __get_pydantic_json_schema__ gebruiken.

Het __modify_schema__ wordt gebruikt om één argument te ontvangen dat het JSON-schema vertegenwoordigt. Zie het onderstaande voorbeeld:

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'

De nieuwe methode __get_pydantic_json_schema__ ontvangt twee argumenten: de eerste is een woordenboek dat wordt aangeduid als CoreSchema , en de tweede een opvraagbare handler die een CoreSchema als parameter ontvangt en een JSON-schema retourneert. Zie het onderstaande voorbeeld:

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

Decorateur op ontbrekend veld

Deze fout treedt op wanneer u een decorateur definieert met een veld dat niet geldig is.

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'

U kunt check_fields=False gebruiken als u van het model overerft en dit heeft bedoeld.

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)

Discriminator geen veld

Deze fout treedt op wanneer een model in gediscrimineerde vakbonden geen discriminatorveld definieert.

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'

Discriminator-aliastype

Deze fout treedt op wanneer u een niet-tekenreeksalias definieert in een discriminatorveld.

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'

Discriminator heeft letterlijke behoeften

Deze fout treedt op wanneer u een niet- Literal type definieert in een discriminatorveld.

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'

Discriminator-alias

Deze fout treedt op wanneer u verschillende aliassen definieert voor discriminatorvelden.

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'

Ongeldige discriminatorvalidator

Deze fout treedt op als u een before-, wrap- of plain-validator op een discriminatorveld gebruikt.

Dit is niet toegestaan omdat het discriminatorveld wordt gebruikt om het type model te bepalen dat voor validatie moet worden gebruikt. U kunt dus geen validator gebruiken die de waarde ervan zou kunnen veranderen.

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'

Dit kan worden omzeild door een standaard Union te gebruiken en de discriminator te laten vallen:

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'

Oproepbare discriminatorbehuizing zonder tag

Deze fout treedt op wanneer een Union die een opvraagbare Discriminator gebruikt, niet voor alle gevallen Tag annotaties heeft.

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 -versie

Deze fout treedt op wanneer u typing.TypedDict gebruikt in plaats van typing_extensions.TypedDict in Python < 3.12.

Bovenliggend modelveld overschreven

Deze fout treedt op wanneer een veld dat op een basisklasse is gedefinieerd, wordt overschreven door een niet-geannoteerd attribuut.

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'

Ontbrekende annotatie in modelveld

Deze fout treedt op als een veld geen annotatie heeft.

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'

Als het veld niet bedoeld is als veld, kunt u de fout mogelijk oplossen door het te annoteren als een ClassVar :

from typing import ClassVar

from pydantic import BaseModel


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

Of update 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 en model_config zijn beide gedefinieerd

Deze fout treedt op wanneer class Config en model_config samen worden gebruikt.

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'

Zoekwoordargumenten verwijderd

Deze fout treedt op wanneer de trefwoordargumenten niet beschikbaar zijn in Pydantic V2.

regex wordt bijvoorbeeld verwijderd uit 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'

JSON-schema ongeldig type

Deze fout treedt op wanneer Pydantic er niet in slaagt een JSON-schema te genereren voor een bepaald 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'

JSON-schema al gebruikt

Deze fout treedt op wanneer de JSON-schemagenerator al is gebruikt om een JSON-schema te genereren. U moet een nieuw exemplaar maken om een nieuw JSON-schema te genereren.

BaseModel geïnstantieerd

Deze fout treedt op wanneer u BaseModel rechtstreeks instantieert. Pydantic-modellen moeten overerven van BaseModel .

from pydantic import BaseModel, PydanticUserError

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

Ongedefinieerde annotatie

Deze fout treedt op bij het verwerken van ongedefinieerde annotaties tijdens het genereren van 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'

Schema voor onbekend type

Deze fout treedt op wanneer Pydantic er niet in slaagt een CoreSchema voor een bepaald type te genereren.

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'

Importfout

Deze fout treedt op wanneer u een object probeert te importeren dat beschikbaar was in Pydantic V1, maar is verwijderd in Pydantic V2.

Zie de Migratiehandleiding voor meer informatie.

create_model velddefinities

Deze fout treedt op wanneer u velddefinities invoert in create_model die niet geldig zijn.

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'

Of wanneer u typing.Annotated gebruikt met ongeldige invoer

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 configuratiebasis

Deze fout treedt op als u zowel __config__ als __base__ samen gebruikt in 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'

Validator zonder velden

Deze fout treedt op als u validator bare gebruikt (zonder velden).

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'

Validators moeten worden gebruikt met velden en trefwoordargumenten.

from pydantic import BaseModel, field_validator


class Model(BaseModel):
    a: str

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

Ongeldige validatorvelden

Deze fout treedt op wanneer u een validator gebruikt met niet-tekenreeksvelden.

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'

Velden moeten als afzonderlijke stringargumenten worden doorgegeven:

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 op instantiemethode

Deze fout treedt op wanneer u een validator op een instantiemethode toepast.

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'

Rootvalidator, pre , skip_on_failure

Als u @root_validator gebruikt met pre=False (de standaardinstelling), MOET u skip_on_failure=True opgeven. De skip_on_failure=False optie is niet langer beschikbaar.

Als u niet probeerde skip_on_failure=False in te stellen, kunt u veilig skip_on_failure=True instellen. Als u dit doet, wordt deze rootvalidator niet langer aangeroepen als de validatie voor een van de velden mislukt.

Raadpleeg de Migratiehandleiding voor meer informatie.

model_serializer instantiemethoden

@model_serializer moet worden toegepast op instantiemethoden.

Deze fout treedt op wanneer u model_serializer toepast op een instantiemethode zonder 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'

Of op een 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 en info

De field en config zijn niet beschikbaar in Pydantic V2. Gebruik in plaats daarvan de info parameter.

Je hebt toegang tot de configuratie via info.config , maar het is een woordenboek in plaats van een object zoals in Pydantic V1.

Het field is niet langer beschikbaar.

Pydantic V1-validatorhandtekening

Deze fout treedt op wanneer u een niet-ondersteunde handtekening gebruikt voor de validator in Pydantic V1-stijl.

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'

Niet-herkende field_validator handtekening

Deze fout treedt op wanneer een field_validator of model_validator functie de verkeerde handtekening heeft.

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'

Niet-herkende field_serializer handtekening

Deze fout treedt op wanneer de field_serializer -functie de verkeerde handtekening heeft.

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'

Geldige serialisatiehandtekeningen zijn:

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

Niet-herkende model_serializer handtekening

Deze fout treedt op wanneer de functie model_serializer de verkeerde handtekening heeft.

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'

Meerdere veldserializers

Deze fout treedt op wanneer meerdere model_serializer functies voor een veld zijn gedefinieerd.

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'

Ongeldig geannoteerd type

Deze fout treedt op wanneer een annotatie een type niet kan annoteren.

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 is ongebruikt met TypeAdapter

U krijgt deze foutmelding als u config probeert door te geven aan TypeAdapter wanneer het type een type is dat zijn eigen configuratie heeft die niet kan worden overschreven (momenteel zijn dit alleen BaseModel , TypedDict en 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'

In plaats daarvan moet u het type subclassificeren en de configuratie ervan overschrijven of instellen:

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

Kan model_config['extra'] niet opgeven met RootModel

Omdat RootModel niet in staat is om extra velden op te slaan of zelfs maar te accepteren tijdens de initialisatie, geven we een foutmelding als u probeert een waarde op te geven voor de configuratie-instelling 'extra' bij het maken van een subklasse van 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'

Kan typeannotatie niet evalueren

Omdat typeannotaties worden geëvalueerd na toewijzingen, kunt u onverwachte resultaten krijgen als u een typeannotatienaam gebruikt die conflicteert met een van uw velden. We genereren een fout in het volgende geval:

from datetime import date

from pydantic import BaseModel, Field


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

Als tijdelijke oplossing kunt u een alias gebruiken of uw import wijzigen:

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

from pydantic import BaseModel, Field


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

Incompatibele dataclass init en extra instellingen

Pydantic staat de specificatie van de extra='allow' instelling voor een dataklasse niet toe, terwijl voor een van de velden init=False is ingesteld.

U mag dus niet het volgende doen:

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


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

Het bovenstaande fragment resulteert in de volgende fout tijdens het bouwen van een schema voor de A -dataklasse:

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

Incompatibele init en init_var instellingen voor dataclass -veld

De instellingen init=False en init_var=True sluiten elkaar uit. Als u dit wel doet, resulteert dit in de PydanticUserError die in het onderstaande voorbeeld wordt weergegeven.

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 wordt gebruikt als modelveld

Deze fout treedt op wanneer model_config wordt gebruikt als de naam van een veld.

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 wordt gebruikt op een BaseModel subklasse

Deze fout treedt op wanneer de decorateur with_config wordt gebruikt op een klasse die al een Pydantic-model is (gebruik in plaats daarvan het kenmerk 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 wordt gebruikt op een BaseModel subklasse

Deze fout treedt op wanneer de Pydantic dataclass decorator wordt gebruikt op een klasse die al een Pydantic-model is.

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'

---

本文总阅读量次