उपयोग त्रुटियाँ

पाइडेंटिक उपयोगी त्रुटियाँ प्रदान करने का प्रयास करता है। निम्नलिखित अनुभाग त्रुटि स्थिति को संबोधित करने के सुझावों के साथ-साथ पायडेंटिक के साथ काम करते समय डेवलपर्स द्वारा सामना की जा सकने वाली सामान्य त्रुटियों पर विवरण प्रदान करते हैं।

कक्षा पूरी तरह से परिभाषित नहीं है

यह त्रुटि तब उत्पन्न होती है जब पाइडेंटिक-मान्य प्रकार (जैसे BaseModel का उपवर्ग, या पाइडेंटिक 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}})

बेसमॉडल उपवर्गों के लिए, इसे प्रकार को परिभाषित करके और फिर .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__ विधि का उपयोग करना चाहिए।

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

बिना किसी टैग के कॉल करने योग्य विभेदक मामला

यह त्रुटि तब उत्पन्न होती है जब कॉल करने योग्य 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 के बजाय [टाइपिंग.टाइप्डडिक्ट][] का उपयोग करते हैं।

मॉडल पैरेंट फ़ील्ड ओवरराइड किया गया

यह त्रुटि तब उत्पन्न होती है जब बेस क्लास पर परिभाषित फ़ील्ड को गैर-एनोटेटेड विशेषता द्वारा ओवरराइड किया गया था।

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'

कीवर्ड तर्क हटा दिए गए

यह त्रुटि तब उत्पन्न होती है जब पाइडेंटिक V2 में कीवर्ड तर्क उपलब्ध नहीं होते हैं।

उदाहरण के लिए, regex पाइडेंटिक 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 स्कीमा पहले से ही उपयोग किया जा चुका है

यह त्रुटि तब उत्पन्न होती है जब JSON स्कीमा जनरेटर का उपयोग JSON स्कीमा उत्पन्न करने के लिए पहले ही किया जा चुका होता है। नया JSON स्कीमा जनरेट करने के लिए आपको एक नया इंस्टेंस बनाना होगा।

बेसमॉडल इंस्टेंटियेटेड

यह त्रुटि तब उत्पन्न होती है जब आप BaseModel सीधे इंस्टेंटियेट करते हैं। पाइडेंटिक मॉडल को 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 कॉन्फिग बेस

यह त्रुटि तब उत्पन्न होती है जब आप 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

इंस्टेंस विधि पर सत्यापनकर्ता

यह त्रुटि तब उत्पन्न होती है जब आप किसी इंस्टेंस विधि पर सत्यापनकर्ता लागू करते हैं।

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 इंस्टेंस विधियों पर लागू किया जाना चाहिए।

यह त्रुटि तब उत्पन्न होती है जब आप 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

पाइडेंटिक V2 में field और config पैरामीटर उपलब्ध नहीं हैं। कृपया इसके बजाय info पैरामीटर का उपयोग करें।

आप कॉन्फ़िगरेशन को info.config के माध्यम से एक्सेस कर सकते हैं, लेकिन यह किसी ऑब्जेक्ट के बजाय एक शब्दकोश है जैसा कि यह Pydantic V1 में था।

field तर्क अब उपलब्ध नहीं है.

पाइडेंटिक 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

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 सेटिंग्स

पाइडेंटिक डेटाक्लास पर 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.

dataclass फ़ील्ड पर असंगत 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} पर किया जाता है

यह त्रुटि तब उत्पन्न होती है जब 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 डेकोरेटर का उपयोग उस वर्ग पर किया जाता है जो पहले से ही एक पाइडेंटिक मॉडल है।

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'

---

本文总阅读量次