Ошибки использования

Пидантик пытается предоставить полезные ошибки. В следующих разделах представлена подробная информация о распространенных ошибках, с которыми могут столкнуться разработчики при работе с Pydantic, а также предложения по устранению ошибок.

Класс не полностью определен

Эта ошибка возникает, когда тип, указанный в аннотации типа, проверенного pydantic (например, подкласс BaseModel или dataclass pydantic), не определен:

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__ больше не поддерживается в версии 2. Вместо этого вам следует использовать метод __get_pydantic_json_schema__ .

__modify_schema__ используется для получения одного аргумента, представляющего схему JSON. См. пример ниже:

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 , а второй — вызываемый handler , который получает CoreSchema в качестве параметра и возвращает схему JSON. См. пример ниже:

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'

Тип псевдонима дискриминатора

Эта ошибка возникает, когда вы определяете нестроковый псевдоним в поле дискриминатора.

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'

Случай вызываемого дискриминатора без тега

Эта ошибка возникает, когда Union , использующее вызываемый Discriminator не имеет аннотаций 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

Эта ошибка возникает, когда вы используете typing.TypedDict вместо typing_extensions.TypedDict в Python < 3.12.

Родительское поле модели переопределено

Эта ошибка возникает, когда поле, определенное в базовом классе, было переопределено неаннотированным атрибутом.

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 определяют

Эта ошибка возникает, когда 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 не может создать схему JSON для некоторой 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 уже используется

Эта ошибка возникает, если генератор схемы JSON уже использовался для создания схемы JSON. Вам необходимо создать новый экземпляр для создания новой схемы JSON.

Создан экземпляр базовой модели

Эта ошибка возникает при непосредственном создании экземпляра 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'

Схема для неизвестного типа

Эта ошибка возникает, когда 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 с неверным вводом

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

Эта ошибка возникает, когда вы одновременно используете __config__ и __base__ в 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'

Валидатор без полей

Эта ошибка возникает, когда вы используете голый валидатор (без полей).

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

Валидатор метода экземпляра

Эта ошибка возникает, когда вы применяете валидатор к методу экземпляра.

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

Если вы используете @root_validator с pre=False (по умолчанию), вы ДОЛЖНЫ указать skip_on_failure=True . skip_on_failure=False больше не доступен.

Если вы не пытались установить skip_on_failure=False , вы можете безопасно установить skip_on_failure=True . Если вы это сделаете, этот корневой валидатор больше не будет вызываться, если проверка любого из полей не удалась.

Более подробную информацию можно найти в Руководстве по миграции .

методы экземпляра model_serializer

@model_serializer необходимо применять к методам экземпляра.

Эта ошибка возникает, когда вы применяете model_serializer к методу экземпляра без 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'

Или в методе класса:

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

Параметры field и config недоступны в Pydantic V2. Вместо этого используйте параметр 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

Вы получите эту ошибку, если попытаетесь передать config в TypeAdapter , если тип имеет собственную конфигурацию, которую нельзя переопределить (в настоящее время это только BaseModel , TypedDict и 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'

Вместо этого вам нужно будет создать подкласс типа и переопределить или установить для него конфигурацию:

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'] с RootModel

Поскольку RootModel не способен хранить или даже принимать дополнительные поля во время инициализации, мы выдаем ошибку, если вы попытаетесь указать значение параметра конфигурации 'extra' при создании подкласса 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'

Невозможно оценить аннотацию типа

Поскольку аннотации типов оцениваются после присвоений, вы можете получить неожиданные результаты при использовании имени аннотации типа, которое конфликтует с одним из ваших полей. Мы выдаем ошибку в следующем случае:

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

Несовместимая init dataclass и extra настройки

Pydantic не позволяет указывать параметр extra='allow' для класса данных, если в любом из полей установлен параметр init=False .

Таким образом, вы не можете делать что-то вроде следующего:

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.

Несовместимые настройки init и init_var в поле dataclass

Параметры 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 используется в классе, который уже является моделью Pydantic (вместо этого используйте атрибут 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 Pydantic используется для класса, который уже является моделью 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'

---

本文总阅读量次