Usage Errors

Pydanticは有用なエラーを提供しようとします。次のセクションでは、開発者がPydanticを使用しているときに遭遇する可能性のある一般的なエラーの詳細と、エラー状態に対処するための提案について説明します。

Class not fully defined

このエラーは、pydanicで検証された型(BaseModelのサブクラスやpydanicdataclassなど)の注釈で参照される型が定義されていない場合に発生します。

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'

Or when the type has been defined after usage:

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

それ以外の場合は、エラーメッセージに、適切な型を定義してクラスを再構築する方法が示されます。

Custom JSON Schema

__modify_schema__メソッドはV2でサポートされなくなりました。代わりに__get_pydantic_json_schema__メソッドを使用してください。

__modify_schema__は、JSONスキーマを表す単一の引数を受け取るために使用されます。以下の例を参照してください。

Old way

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__は2つの引数を受け取ります。1つ目はCoreSchemaと呼ばれる辞書で、2つ目はCoreSchemaをパラメータとして受け取り、JSONスキーマを返す呼び出し可能なhandlerです。以下の例を参照してください。

New way

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

Decorator on missing field

このエラーは、無効なフィールドを持つデコレータを定義した場合に発生します。

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)

Discriminator no field

このエラーは、識別されたユニオンのモデルが識別フィールドを定義していない場合に発生します。

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'

Discriminator needs literal

このエラーは、識別子フィールドに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'

Discriminator alias

識別子フィールドに異なるエイリアスを定義すると、このエラーが発生します。

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'

Invalid discriminator validator

このエラーは、識別子フィールドでbefore、wrap、またはplainバリデータを使用した場合に発生します。

discriminatorフィールドは検証に使用するモデルのタイプを決定するために使用されるため、これは許可されません。したがって、その値を変更する可能性のあるバリデータは使用できません。

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'

Callable discriminator case with no tag

このエラーは、呼び出し可能な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 version

このエラーは、Python<3.12でtyping_extensions.TypedDictの代わりにtyping.TypedDictを使用した場合に発生します。

Model parent field overridden

このエラーは、基本クラスで定義されたフィールドが、注釈のない属性によって上書きされた場合に発生します。

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'

Model field missing annotation

このエラーは、フィールドにアノテーションがない場合に発生します。

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]

Or updating 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 and model_config both defined

このエラーは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'

Keyword arguments removed

このエラーは、キーワード引数が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 schema invalid type

このエラーは、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 instantiated

このエラーは、BaseModelを直接インスタンス化すると発生します。PydanticモデルはBaseModelから継承する必要があります。

from pydantic import BaseModel, PydanticUserError

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

Undefined annotation

このエラーは、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'

Import error

このエラーは、Pydantic V1では使用できたが、Pydantic V2では削除されたオブジェクトをインポートしようとしたときに発生します。

詳細については、Migration Guideを参照してください。

create_model field definitions

このエラーは、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'

Or when you use typing.Annotated with invalid input

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で__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'

Validator with no fields

このエラーは、validator bare(フィールドなし)を使用した場合に発生します。

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

Invalid validator fields

このエラーは、文字列以外のフィールドでバリデータを使用した場合に発生します。

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

Root validator, pre, skip_on_failure

pre=False(デフォルト)で@root_validatorを使用する場合は、skip_on_failure=Trueを指定しなければなりません。 skip_on_failure=Falseオプションは使用できなくなりました。

skip_on_failure=Falseを設定しようとしていない場合は、skip_on_failure=Trueを設定しても問題ありません。 これを行うと、いずれかのフィールドで検証が失敗した場合に、このルート・バリデーターが呼び出されなくなります。

詳細については、Migration Guideを参照してください。

model_serializer instance methods

@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, and info

fieldおよびconfigパラメータはPydantic V2では使用できません。 代わりにinfoパラメータを使用してください。

info.configから設定にアクセスできますが、これはPydantic V1のようなオブジェクトではなく辞書です。

field引数は使用できなくなりました。

Pydantic V1 validator signature

このエラーは、Pydantic V 1スタイルのバリデータにサポートされていない署名を使用した場合に発生します。

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'

Unrecognized field_validator signature

このエラーは、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'

Unrecognized field_serializer signature

このエラーは、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): ...

Unrecognized model_serializer signature

このエラーは、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'

Multiple field serializers

このエラーは、1つのフィールドに対して複数の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'

Invalid annotated type

このエラーは、注釈がタイプに注釈を付けられない場合に発生します。

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 unused with 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

Cannot specify model_config['extra'] with RootModel

RootModelは初期化中に追加フィールドを格納することも受け入れることもできないので、RootModelのサブクラスを作成するときにconfig設定'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'

Cannot evaluate type annotation

型アノテーションは代入の後に評価されるため、フィールドの1つと競合する型アノテーション名を使用すると、予期しない結果になる可能性があります。次の場合にエラーが発生します。

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

Incompatible dataclass init and extra settings

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.

Incompatible init and init_var settings on dataclass field

init=Falseとinit_var=Trueの設定は相互に排他的です。これを行うと、次の例に示すPydantictUserErrorが発生します。

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 is used as a model field

このエラーは、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 is used on a BaseModel subclass

このエラーは、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 is used on a BaseModel subclass

このエラーは、すでにPydanticモデルであるクラスでPydanticdataclassデコレータが使用された場合に発生します。

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'