Kesalahan Penggunaan

Pydantic mencoba memberikan kesalahan yang berguna. Bagian berikut memberikan detail tentang kesalahan umum yang mungkin ditemui pengembang saat bekerja dengan Pydantic, bersama dengan saran untuk mengatasi kondisi kesalahan tersebut.

Kelas tidak sepenuhnya ditentukan

Kesalahan ini muncul ketika tipe yang direferensikan dalam anotasi tipe yang divalidasi pydantic (seperti subkelas BaseModel , atau dataclass pydantic ) tidak ditentukan:

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'

Atau ketika tipe telah ditentukan setelah penggunaan:

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

Untuk subkelas BaseModel, hal ini dapat diperbaiki dengan menentukan tipenya dan kemudian memanggil .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}})

Dalam kasus lain, pesan kesalahan harus menunjukkan cara membangun kembali kelas dengan tipe yang sesuai yang ditentukan.

Skema JSON Khusus

Metode __modify_schema__ tidak lagi didukung di V2. Anda harus menggunakan metode __get_pydantic_json_schema__ sebagai gantinya.

__modify_schema__ digunakan untuk menerima argumen tunggal yang mewakili skema JSON. Lihat contoh di bawah ini:

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'

Metode baru __get_pydantic_json_schema__ menerima dua argumen: yang pertama adalah kamus yang dilambangkan sebagai CoreSchema , dan yang kedua adalah handler callable yang menerima CoreSchema sebagai parameter, dan mengembalikan skema JSON. Lihat contoh di bawah ini:

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

Dekorator pada bidang yang hilang

Kesalahan ini muncul ketika Anda mendefinisikan dekorator dengan bidang yang tidak valid.

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'

Anda dapat menggunakan check_fields=False jika Anda mewarisi model dan menginginkannya.

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 tanpa kolom

Kesalahan ini muncul ketika model dalam serikat pekerja yang didiskriminasi tidak menentukan bidang diskriminator.

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'

Tipe alias diskriminator

Kesalahan ini muncul ketika Anda mendefinisikan alias non-string pada bidang diskriminator.

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 membutuhkan {#discriminator-needs-literal} secara literal

Kesalahan ini muncul ketika Anda mendefinisikan tipe non- Literal pada bidang diskriminator.

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 diskriminator

Kesalahan ini muncul ketika Anda mendefinisikan alias berbeda pada bidang diskriminator.

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'

Validator diskriminator tidak valid

Kesalahan ini muncul ketika Anda menggunakan validator sebelumnya, bungkus, atau biasa pada bidang diskriminator.

Hal ini tidak diperbolehkan karena bidang diskriminator digunakan untuk menentukan jenis model yang akan digunakan untuk validasi, sehingga Anda tidak dapat menggunakan validator yang mungkin mengubah nilainya.

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'

Hal ini dapat diatasi dengan menggunakan Union standar, menghilangkan diskriminator:

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'

Kasus diskriminator yang dapat dipanggil tanpa tag

Kesalahan ini muncul ketika Union yang menggunakan Discriminator yang dapat dipanggil tidak memiliki anotasi Tag untuk semua kasus.

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'

Versi TypedDict

Kesalahan ini muncul saat Anda menggunakan typing.TypedDict alih-alih typing_extensions.TypedDict pada Python <3.12.

Bidang induk model diganti

Kesalahan ini muncul ketika bidang yang ditentukan pada kelas dasar ditimpa oleh atribut yang tidak diberi anotasi.

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'

Bidang model tidak memiliki anotasi

Kesalahan ini muncul ketika suatu bidang tidak memiliki anotasi.

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'

Jika bidang tersebut tidak dimaksudkan sebagai bidang, Anda mungkin dapat mengatasi kesalahan tersebut dengan menganotasinya sebagai ClassVar :

from typing import ClassVar

from pydantic import BaseModel


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

Atau memperbarui 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 dan model_config keduanya ditentukan

Kesalahan ini muncul ketika class Config dan model_config digunakan bersama.

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'

Argumen kata kunci dihapus

Kesalahan ini muncul ketika argumen kata kunci tidak tersedia di Pydantic V2.

Misalnya, regex dihapus dari 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'

Skema JSON tipe tidak valid

Kesalahan ini muncul ketika Pydantic gagal menghasilkan skema JSON untuk beberapa 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'

Skema JSON sudah digunakan

Kesalahan ini muncul ketika generator skema JSON telah digunakan untuk menghasilkan skema JSON. Anda harus membuat instance baru untuk menghasilkan skema JSON baru.

BaseModel dibuat

Kesalahan ini muncul saat Anda membuat instance BaseModel secara langsung. Model Pydantic harus mewarisi dari BaseModel .

from pydantic import BaseModel, PydanticUserError

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

Anotasi tidak terdefinisi

Kesalahan ini muncul saat menangani anotasi yang tidak ditentukan selama pembuatan 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'

Skema untuk tipe yang tidak diketahui

Kesalahan ini muncul ketika Pydantic gagal menghasilkan CoreSchema untuk beberapa jenis.

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'

Kesalahan impor

Kesalahan ini muncul ketika Anda mencoba mengimpor objek yang tersedia di Pydantic V1, tetapi telah dihapus di Pydantic V2.

Lihat Panduan Migrasi untuk informasi lebih lanjut.

create_model definisi bidang

Kesalahan ini muncul ketika Anda memberikan input definisi bidang di create_model yang tidak valid.

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'

Atau saat Anda menggunakan typing.Annotated dengan input yang tidak valid

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 basis konfigurasi

Kesalahan ini muncul saat Anda menggunakan __config__ dan __base__ secara bersamaan di 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 tanpa kolom

Kesalahan ini muncul ketika Anda menggunakan validator kosong (tanpa bidang).

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'

Validator harus digunakan dengan argumen bidang dan kata kunci.

from pydantic import BaseModel, field_validator


class Model(BaseModel):
    a: str

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

Bidang validator tidak valid

Kesalahan ini muncul ketika Anda menggunakan validator dengan bidang non-string.

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'

Bidang harus diteruskan sebagai argumen string terpisah:

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 pada metode instance

Kesalahan ini muncul ketika Anda menerapkan validator pada metode instans.

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'

Validator root, pre , skip_on_failure

Jika Anda menggunakan @root_validator dengan pre=False (default), Anda HARUS menentukan skip_on_failure=True . Opsi skip_on_failure=False tidak lagi tersedia.

Jika Anda tidak mencoba menyetel skip_on_failure=False , Anda dapat menyetel skip_on_failure=True dengan aman. Jika Anda melakukannya, validator root ini tidak akan dipanggil lagi jika validasi gagal untuk salah satu bidang.

Silakan lihat Panduan Migrasi untuk lebih jelasnya.

metode instance model_serializer

@model_serializer harus diterapkan pada metode instan.

Kesalahan ini muncul ketika Anda menerapkan model_serializer pada metode instance tanpa 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'

Atau pada metode kelas:

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 , dan info

Parameter field dan config tidak tersedia di Pydantic V2. Silakan gunakan parameter info sebagai gantinya.

Anda dapat mengakses konfigurasi melalui info.config , tetapi ini adalah kamus, bukan objek seperti di Pydantic V1.

Argumen field tidak lagi tersedia.

Tanda tangan validator Pydantic V1

Kesalahan ini muncul ketika Anda menggunakan tanda tangan yang tidak didukung untuk validator gaya 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'

field_validator tanda tangan tidak dikenal

Kesalahan ini muncul ketika fungsi field_validator atau model_validator memiliki tanda tangan yang salah.

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'

Tanda tangan field_serializer tidak dikenal

Kesalahan ini muncul ketika fungsi field_serializer memiliki tanda tangan yang salah.

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'

Tanda tangan serializer yang valid adalah:

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

Tanda tangan model_serializer tidak dikenal

Kesalahan ini muncul ketika fungsi model_serializer memiliki tanda tangan yang salah.

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'

Serializer beberapa bidang

Kesalahan ini muncul ketika beberapa fungsi model_serializer ditentukan untuk suatu bidang.

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'

Jenis beranotasi tidak valid

Kesalahan ini muncul ketika anotasi tidak dapat memberi anotasi pada suatu tipe.

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 tidak digunakan dengan TypeAdapter

Anda akan mendapatkan kesalahan ini jika Anda mencoba meneruskan config ke TypeAdapter ketika tipenya adalah tipe yang memiliki konfigurasinya sendiri yang tidak dapat diganti (saat ini hanya BaseModel , TypedDict dan 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'

Sebagai gantinya, Anda harus membuat subkelas tipenya dan mengganti atau mengatur konfigurasinya:

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

Tidak dapat menentukan model_config['extra'] dengan RootModel

Karena RootModel tidak mampu menyimpan atau bahkan menerima kolom tambahan selama inisialisasi, kami memunculkan kesalahan jika Anda mencoba menentukan nilai untuk pengaturan konfigurasi 'extra' saat membuat subkelas 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'

Tidak dapat mengevaluasi anotasi tipe

Karena anotasi tipe dievaluasi setelah penugasan, Anda mungkin mendapatkan hasil yang tidak diharapkan saat menggunakan nama anotasi tipe yang bentrok dengan salah satu bidang Anda. Kami memunculkan kesalahan dalam kasus berikut:

from datetime import date

from pydantic import BaseModel, Field


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

Sebagai solusinya, Anda dapat menggunakan alias atau mengubah impor Anda:

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

from pydantic import BaseModel, Field


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

Pengaturan init dan extra dataclass tidak kompatibel

Pydantic tidak mengizinkan spesifikasi pengaturan extra='allow' pada kelas data sementara salah satu bidang memiliki set init=False .

Oleh karena itu, Anda tidak boleh melakukan hal seperti berikut:

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


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

Cuplikan di atas menghasilkan kesalahan berikut selama pembuatan skema untuk kelas data A :

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

Setelan init dan init_var tidak kompatibel pada kolom dataclass

Pengaturan init=False dan init_var=True saling eksklusif. Melakukannya akan menghasilkan PydanticUserError yang ditunjukkan pada contoh di bawah.

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 digunakan sebagai bidang model

Kesalahan ini muncul ketika model_config digunakan sebagai nama bidang.

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 digunakan pada subkelas BaseModel

Kesalahan ini muncul ketika dekorator with_config digunakan pada kelas yang sudah menjadi model Pydantic (gunakan atribut model_config sebagai gantinya).

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 digunakan pada subkelas BaseModel

Kesalahan ini muncul ketika dekorator dataclass Pydantic digunakan pada kelas yang sudah menjadi model 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'

---

本文总阅读量次