사용 오류

Pydantic은 유용한 오류를 제공하려고 시도합니다. 다음 섹션에서는 오류 조건을 해결하기 위한 제안과 함께 개발자가 Pydantic으로 작업할 때 발생할 수 있는 일반적인 오류에 대한 세부 정보를 제공합니다.

Class not fully defined

이 오류는 pydantic 검증 유형(예: BaseModel 의 하위 클래스 또는 pydantic dataclass )의 주석에서 참조된 유형이 정의되지 않은 경우 발생합니다.

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'

또는 사용 후 유형이 정의된 경우:

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

BaseModel 하위 클래스의 경우 유형을 정의한 다음 .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}})

다른 경우에는 오류 메시지에 적절한 유형이 정의된 클래스를 다시 빌드하는 방법이 표시되어야 합니다.

사용자 정의 JSON 스키마

__modify_schema__ 메서드는 V2에서 더 이상 지원되지 않습니다. 대신 __get_pydantic_json_schema__ 메서드를 사용해야 합니다.

JSON 스키마를 나타내는 단일 인수를 수신하는 데 사용되는 __modify_schema__ . 아래 예를 참조하세요.

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'

새로운 메소드 __get_pydantic_json_schema__ 두 개의 인수를 받습니다. 첫 번째는 CoreSchema 로 표시된 사전이고, 두 번째는 CoreSchema 매개변수로 받고 JSON 스키마를 반환하는 호출 가능한 handler . 아래 예를 참조하세요.

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

누락된 필드의 데코레이터

이 오류는 유효하지 않은 필드로 데코레이터를 정의할 때 발생합니다.

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'

모델에서 상속하고 이를 의도한 경우 check_fields=False 사용할 수 있습니다.

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)

판별자 없음 필드

이 오류는 판별 공용체의 모델이 판별자 필드를 정의하지 않을 때 발생합니다.

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 alias type

이 오류는 판별자 필드에 문자열이 아닌 별칭을 정의할 때 발생합니다.

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'

판별자에는 리터럴이 필요합니다.

이 오류는 판별자 필드에 Literal 아닌 유형을 정의할 때 발생합니다.

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'

판별자 별칭

이 오류는 판별자 필드에 다른 별칭을 정의할 때 발생합니다.

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'

잘못된 판별자 유효성 검사기

이 오류는 판별자 필드에 이전, 래핑 또는 일반 유효성 검사기를 사용할 때 발생합니다.

이는 판별자 필드가 유효성 검사에 사용할 모델 유형을 결정하는 데 사용되므로 해당 값을 변경할 수 있는 유효성 검사기를 사용할 수 없기 때문에 허용되지 않습니다.

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'

이 문제는 표준 Union 사용하고 판별자를 삭제하여 해결할 수 있습니다.

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'

태그가 없는 호출 가능한 판별자 사례

이 오류는 호출 가능한 Discriminator 사용하는 Union 모든 사례에 대한 Tag 주석이 없을 때 발생합니다.

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 버전

이 오류는 Python < 3.12에서 typing_extensions.TypedDict 대신 typing.TypedDict를 사용하면 발생합니다.

모델 상위 필드가 재정의되었습니다.

이 오류는 기본 클래스에 정의된 필드가 주석이 지정되지 않은 속성으로 재정의된 경우 발생합니다.

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'

모델 필드 누락 주석

이 오류는 필드에 주석이 없으면 발생합니다.

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'

필드가 필드가 아닌 경우 ClassVar 로 주석을 달아 오류를 해결할 수 있습니다.

from typing import ClassVar

from pydantic import BaseModel


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

또는 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 와 model_config 모두 {#config-both}를 정의했습니다.

이 오류는 class Config 와 model_config 함께 사용할 때 발생합니다.

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'

키워드 인수가 제거되었습니다.

이 오류는 Pydantic V2에서 키워드 인수를 사용할 수 없을 때 발생합니다.

예를 들어 regex 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 스키마 잘못된 유형

이 오류는 Pydantic이 일부 CoreSchema 에 대한 JSON 스키마 생성에 실패할 때 발생합니다.

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 already used

이 오류는 JSON 스키마 생성기를 이미 사용하여 JSON 스키마를 생성한 경우 발생합니다. 새 JSON 스키마를 생성하려면 새 인스턴스를 생성해야 합니다.

BaseModel 인스턴스화됨

이 오류는 BaseModel 직접 인스턴스화할 때 발생합니다. Pydantic 모델은 BaseModel 을 상속해야 합니다.

from pydantic import BaseModel, PydanticUserError

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

정의되지 않은 주석

이 오류는 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 for unknown type

이 오류는 Pydantic이 일부 유형에 대한 CoreSchema 생성에 실패할 때 발생합니다.

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'

가져오기 오류

이 오류는 Pydantic V1에서 사용 가능했지만 Pydantic V2에서는 제거된 객체를 가져오려고 할 때 발생합니다.

자세한 내용은 마이그레이션 가이드를 참조하세요.

create_model 필드 정의

이 오류는 create_model 에 유효하지 않은 필드 정의 입력을 제공할 때 발생합니다.

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'

또는 잘못된 입력으로 [typing.Annotated .주석 ][`typing.Annotated` .주석 ]을 사용하는 경우

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 구성 베이스

이 오류는 create_model 에서 __config__ 와 __base__ 함께 사용하면 발생합니다.

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'

필드가 없는 유효성 검사기

이 오류는 유효성 검사기 베어(필드 없음)를 사용할 때 발생합니다.

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'

유효성 검사기는 필드 및 키워드 인수와 함께 사용해야 합니다.

from pydantic import BaseModel, field_validator


class Model(BaseModel):
    a: str

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

잘못된 유효성 검사기 필드

이 오류는 문자열이 아닌 필드에 유효성 검사기를 사용할 때 발생합니다.

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'

필드는 별도의 문자열 인수로 전달되어야 합니다.

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-instance-method}의 유효성 검사기

이 오류는 인스턴스 메서드에 유효성 검사기를 적용할 때 발생합니다.

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'

루트 유효성 검사기, pre , skip_on_failure

pre=False (기본값)와 함께 @root_validator 사용하는 경우에는 skip_on_failure=True 지정해야 합니다. skip_on_failure=False 옵션은 더 이상 사용할 수 없습니다.

skip_on_failure=False 설정하려고 하지 않은 경우에는 skip_on_failure=True 안전하게 설정할 수 있습니다. 그렇게 하면 필드에 대한 유효성 검사가 실패하면 이 루트 유효성 검사기가 더 이상 호출되지 않습니다.

자세한 내용은 마이그레이션 가이드를 참조하세요.

model_serializer 인스턴스 메소드

@model_serializer 인스턴스 메소드에 적용되어야 합니다.

self 없이 인스턴스 메서드에 model_serializer 적용하면 이 오류가 발생합니다.

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'

또는 클래스 메소드에서:

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

Pydantic V2에서는 field 및 config 매개변수를 사용할 수 없습니다. 대신 info 매개변수를 사용하세요.

info.config 를 통해 구성에 접근할 수 있지만 이는 Pydantic V1에서와 같은 객체가 아닌 사전입니다.

field 인수는 더 이상 사용할 수 없습니다.

Pydantic V1 유효성 검사기 서명

이 오류는 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 서명

이 오류는 field_validator 또는 model_validator 함수에 잘못된 서명이 있을 때 발생합니다.

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'

인식할 수 없는 field_serializer 서명

이 오류는 field_serializer 함수에 잘못된 서명이 있을 때 발생합니다.

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'

유효한 직렬 변환기 서명은 다음과 같습니다.

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

인식할 수 없는 model_serializer 서명

이 오류는 model_serializer 함수에 잘못된 서명이 있을 때 발생합니다.

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'

다중 필드 직렬 변환기

이 오류는 필드에 대해 여러 model_serializer 함수가 정의된 경우 발생합니다.

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'

잘못된 주석 유형

이 오류는 주석이 유형에 주석을 달 수 없을 때 발생합니다.

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 TypeAdapter {#type-adapter-config-unused}와 함께 사용되지 않습니다.

유형이 재정의할 수 없는 자체 구성이 있는 유형인 경우(현재는 BaseModel , TypedDict 및 dataclass 만 해당) config TypeAdapter 에 전달하려고 하면 이 오류가 발생합니다.

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'

대신 유형을 하위 클래스로 분류하고 이에 대한 구성을 재정의하거나 설정해야 합니다.

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

RootModel {#root-model-extra}로 model_config['extra'] 지정할 수 없습니다.

RootModel 초기화 중에 추가 필드를 저장하거나 허용할 수 없기 때문에 RootModel 의 하위 클래스를 생성할 때 구성 설정 'extra' 에 대한 값을 지정하려고 하면 오류가 발생합니다.

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'

유형 주석을 평가할 수 없습니다.

유형 주석은 할당 후에 평가되므로 필드 중 하나와 충돌하는 유형 주석 이름을 사용하면 예기치 않은 결과가 발생할 수 있습니다. 다음과 같은 경우 오류가 발생합니다.

from datetime import date

from pydantic import BaseModel, Field


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

해결 방법으로 별칭을 사용하거나 가져오기를 변경할 수 있습니다.

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

from pydantic import BaseModel, Field


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

호환되지 않는 dataclass init 및 extra 설정

Pydantic은 필드에 init=False 설정된 동안 데이터 클래스에 extra='allow' 설정을 지정하는 것을 허용하지 않습니다.

따라서 다음과 같은 작업을 수행할 수 없습니다.

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


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

위의 코드 조각으로 인해 A 데이터 클래스에 대한 스키마를 구축하는 동안 다음 오류가 발생합니다.

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

dataclass 필드 {#clashing-init-and-init-var}의 호환되지 않는 init 및 init_var 설정

init=False 및 init_var=True 설정은 상호 배타적입니다. 그렇게 하면 아래 예에 표시된 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 는 모델 필드로 사용됩니다.

이 오류는 model_config 필드 이름으로 사용하는 경우 발생합니다.

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는 BaseModel 하위 클래스 {#with-config-on-model}에서 사용됩니다.

이 오류는 이미 Pydantic 모델인 클래스에서 with_config 데코레이터를 사용할 때 발생합니다(대신 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 는 BaseModel 하위 클래스 {#dataclass-on-model}에서 사용됩니다.

이 오류는 이미 Pydantic 모델인 클래스에서 Pydantic dataclass 데코레이터를 사용할 때 발생합니다.

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'

---

本文总阅读量次