सत्यापन त्रुटियाँ

पाइडेंटिक उपयोगी सत्यापन त्रुटियाँ प्रदान करने का प्रयास करता है। पाइडेंटिक के साथ काम करते समय उपयोगकर्ताओं द्वारा सामना की जा सकने वाली सामान्य सत्यापन त्रुटियों के विवरण नीचे दिए गए हैं, साथ ही उन्हें ठीक करने के बारे में कुछ सुझाव भी दिए गए हैं।

तर्क_प्रकार

यह त्रुटि तब उत्पन्न होती है जब सत्यापन के दौरान किसी फ़ंक्शन के तर्क के रूप में पारित की जाने वाली वस्तु tuple , list या dict नहीं होती है। क्योंकि NamedTuple अपने कार्यान्वयन में फ़ंक्शन कॉल का उपयोग करता है, यह इस त्रुटि को उत्पन्न करने का एक तरीका है:

from typing import NamedTuple

from pydantic import BaseModel, ValidationError


class MyNamedTuple(NamedTuple):
    x: int


class MyModel(BaseModel):
    field: MyNamedTuple


try:
    MyModel.model_validate({'field': 'invalid'})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'arguments_type'

अभिकथन_त्रुटि

यह त्रुटि तब उत्पन्न होती है जब सत्यापन के दौरान एक असफल assert कथन सामने आता है:

from pydantic import BaseModel, ValidationError, field_validator


class Model(BaseModel):
    x: int

    @field_validator('x')
    @classmethod
    def force_x_positive(cls, v):
        assert v > 0
        return v


try:
    Model(x=-1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'assertion_error'

बूल_पार्सिंग

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक स्ट्रिंग है जो बूलियन के लिए जबरदस्ती के लिए मान्य नहीं है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: bool


Model(x='true')  # OK

try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bool_parsing'

बूल_प्रकार

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार bool फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: bool


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bool_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान bool का उदाहरण नहीं होता है।

बाइट्स_बहुत_लंबा

यह त्रुटि तब उत्पन्न होती है जब bytes मान की लंबाई फ़ील्ड की max_length बाधा से अधिक होती है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: bytes = Field(max_length=3)


try:
    Model(x=b'test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bytes_too_long'

बाइट्स_बहुत_छोटा

यह त्रुटि तब उत्पन्न होती है जब bytes मान की लंबाई फ़ील्ड की min_length बाधा से कम होती है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: bytes = Field(min_length=3)


try:
    Model(x=b't')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bytes_too_short'

बाइट्स_प्रकार

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार bytes फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: bytes


try:
    Model(x=123)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bytes_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान bytes का उदाहरण नहीं होता है।

कॉल करने योग्य_प्रकार

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान Callable के रूप में मान्य नहीं होता है:

from typing import Any, Callable

from pydantic import BaseModel, ImportString, ValidationError


class Model(BaseModel):
    x: ImportString[Callable[[Any], Any]]


Model(x='math:cos')  # OK

try:
    Model(x='os.path')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'callable_type'

dataclass_exact_type

यह त्रुटि तब उत्पन्न होती है जब डेटाक्लास को strict=True के साथ मान्य किया जाता है और इनपुट डेटाक्लास का उदाहरण नहीं है:

import pydantic.dataclasses
from pydantic import TypeAdapter, ValidationError


@pydantic.dataclasses.dataclass
class MyDataclass:
    x: str


adapter = TypeAdapter(MyDataclass)

print(adapter.validate_python(MyDataclass(x='test'), strict=True))
#> MyDataclass(x='test')
print(adapter.validate_python({'x': 'test'}))
#> MyDataclass(x='test')

try:
    adapter.validate_python({'x': 'test'}, strict=True)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'dataclass_exact_type'

डेटाक्लास_प्रकार

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान dataclass फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import ValidationError, dataclasses


@dataclasses.dataclass
class Inner:
    x: int


@dataclasses.dataclass
class Outer:
    y: Inner


Outer(y=Inner(x=1))  # OK

try:
    Outer(y=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'dataclass_type'

date_from_datetime_inexact

यह त्रुटि तब उत्पन्न होती है जब date फ़ील्ड के लिए प्रदान किए गए इनपुट datetime मान में गैर-शून्य समय घटक होता है। date प्रकार के फ़ील्ड में पार्स करने के लिए टाइमस्टैंप के लिए, समय के सभी घटक शून्य होने चाहिए:

from datetime import date, datetime

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: date


Model(x='2023-01-01')  # OK
Model(x=datetime(2023, 1, 1))  # OK

try:
    Model(x=datetime(2023, 1, 1, 12))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_from_datetime_inexact'

date_from_datetime_parsing

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक स्ट्रिंग है जिसे date फ़ील्ड के लिए पार्स नहीं किया जा सकता है:

from datetime import date

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: date


try:
    Model(x='XX1494012000')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_from_datetime_parsing'

date_future

यह त्रुटि तब उत्पन्न होती है जब FutureDate फ़ील्ड के लिए प्रदान किया गया इनपुट मान भविष्य में नहीं होता है:

from datetime import date

from pydantic import BaseModel, FutureDate, ValidationError


class Model(BaseModel):
    x: FutureDate


try:
    Model(x=date(2000, 1, 1))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_future'

date_parsing

यह त्रुटि JSON को सत्यापित करते समय उत्पन्न होती है जहां इनपुट मान एक स्ट्रिंग है जिसे date फ़ील्ड के लिए पार्स नहीं किया जा सकता है:

import json
from datetime import date

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: date = Field(strict=True)


try:
    Model.model_validate_json(json.dumps({'x': '1'}))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_parsing'

date_past

यह त्रुटि तब उत्पन्न होती है जब PastDate फ़ील्ड के लिए प्रदान किया गया मान अतीत में नहीं होता है:

from datetime import date, timedelta

from pydantic import BaseModel, PastDate, ValidationError


class Model(BaseModel):
    x: PastDate


try:
    Model(x=date.today() + timedelta(1))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_past'

date_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार date फ़ील्ड के लिए मान्य नहीं होता है:

from datetime import date

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: date


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान date का उदाहरण नहीं होता है।

datetime_from_date_parsing

!!! नोट इस त्रुटि के लिए समर्थन, साथ ही yyyy-MM-DD तिथियों से डेटाटाइम को पार्स करने के लिए समर्थन v2.6.0 में जोड़ा जाएगा

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक स्ट्रिंग है जिसे datetime फ़ील्ड के लिए पार्स नहीं किया जा सकता है:

from datetime import datetime

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: datetime


try:
    # there is no 13th month
    Model(x='2023-13-01')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_from_date_parsing'

datetime_future

यह त्रुटि तब उत्पन्न होती है जब FutureDatetime फ़ील्ड के लिए प्रदान किया गया मान भविष्य में नहीं होता है:

from datetime import datetime

from pydantic import BaseModel, FutureDatetime, ValidationError


class Model(BaseModel):
    x: FutureDatetime


try:
    Model(x=datetime(2000, 1, 1))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_future'

datetime_object_invalid

यह त्रुटि तब उत्पन्न होती है जब datetime ऑब्जेक्ट के बारे में कुछ मान्य नहीं होता है:

from datetime import datetime, tzinfo

from pydantic import AwareDatetime, BaseModel, ValidationError


class CustomTz(tzinfo):
    # utcoffset is not implemented!

    def tzname(self, _dt):
        return 'CustomTZ'


class Model(BaseModel):
    x: AwareDatetime


try:
    Model(x=datetime(2023, 1, 1, tzinfo=CustomTz()))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_object_invalid'

datetime_parsing

यह त्रुटि तब उत्पन्न होती है जब मान एक स्ट्रिंग है जिसे datetime फ़ील्ड के लिए पार्स नहीं किया जा सकता है:

import json
from datetime import datetime

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: datetime = Field(strict=True)


try:
    Model.model_validate_json(json.dumps({'x': 'not a datetime'}))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_parsing'

datetime_past

यह त्रुटि तब उत्पन्न होती है जब PastDatetime फ़ील्ड के लिए प्रदान किया गया मान अतीत में नहीं होता है:

from datetime import datetime, timedelta

from pydantic import BaseModel, PastDatetime, ValidationError


class Model(BaseModel):
    x: PastDatetime


try:
    Model(x=datetime.now() + timedelta(100))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_past'

datetime_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार datetime फ़ील्ड के लिए मान्य नहीं होता है:

from datetime import datetime

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: datetime


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान datetime का उदाहरण नहीं होता है।

decimal_max_digits

यह त्रुटि तब उत्पन्न होती है जब Decimal के लिए प्रदान किए गए मान में बहुत अधिक अंक होते हैं:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(max_digits=3)


try:
    Model(x='42.1234')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_max_digits'

decimal_max_places

यह त्रुटि तब उत्पन्न होती है जब Decimal के लिए प्रदान किए गए मान में दशमलव बिंदु के बाद बहुत अधिक अंक होते हैं:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(decimal_places=3)


try:
    Model(x='42.1234')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_max_places'

decimal_parsing

यह त्रुटि तब उत्पन्न होती है जब Decimal के लिए प्रदान किए गए मान को दशमलव संख्या के रूप में पार्स नहीं किया जा सकता है:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(decimal_places=3)


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_parsing'

decimal_type

यह त्रुटि तब उत्पन्न होती है जब Decimal के लिए प्रदान किया गया मान गलत प्रकार का होता है:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(decimal_places=3)


try:
    Model(x=[1, 2, 3])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान Decimal का उदाहरण नहीं होता है।

decimal_whole_digits

यह त्रुटि तब उत्पन्न होती है जब Decimal के लिए प्रदान किए गए मान में दशमलव बिंदु से पहले max_digits - decimal_places (जब तक दोनों निर्दिष्ट हैं) की तुलना में अधिक अंक होते हैं:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(max_digits=6, decimal_places=3)


try:
    Model(x='12345.6')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_whole_digits'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान Decimal का उदाहरण नहीं होता है।

dict_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार किसी dict फ़ील्ड के लिए dict नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: dict


try:
    Model(x=['1', '2'])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'dict_type'

enum

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान किसी enum फ़ील्ड सदस्यों में मौजूद नहीं होता है:

from enum import Enum

from pydantic import BaseModel, ValidationError


class MyEnum(str, Enum):
    option = 'option'


class Model(BaseModel):
    x: MyEnum


try:
    Model(x='other_option')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'enum'

extra_forbidden

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान में अतिरिक्त फ़ील्ड होते हैं, लेकिन model_config['extra'] == 'forbid' :

from pydantic import BaseModel, ConfigDict, ValidationError


class Model(BaseModel):
    x: str

    model_config = ConfigDict(extra='forbid')


try:
    Model(x='test', y='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'extra_forbidden'

आप अतिरिक्त विशेषताएँ अनुभाग में extra कॉन्फ़िगरेशन के बारे में अधिक पढ़ सकते हैं।

finite_number

यह त्रुटि तब उत्पन्न होती है जब मान अनंत होता है, या सत्यापन के दौरान 64-बिट फ़्लोटिंग पॉइंट संख्या के रूप में प्रदर्शित होने के लिए बहुत बड़ा होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x=2.2250738585072011e308)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'finite_number'

float_parsing

यह त्रुटि तब उत्पन्न होती है जब मान एक स्ट्रिंग है जिसे float के रूप में पार्स नहीं किया जा सकता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: float


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'float_parsing'

float_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार float फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: float


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'float_type'

frozen_field

यह त्रुटि तब उत्पन्न होती है जब आप frozen=True वाले किसी फ़ील्ड को मान निर्दिष्ट करने का प्रयास करते हैं, या ऐसे फ़ील्ड को हटाने का प्रयास करते हैं:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field('test', frozen=True)


model = Model()

try:
    model.x = 'test1'
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_field'

try:
    del model.x
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_field'

frozen_instance

यह त्रुटि तब उत्पन्न होती है जब model_config['frozen] == True और आप किसी भी फ़ील्ड को हटाने या नया मान निर्दिष्ट करने का प्रयास करते हैं:

from pydantic import BaseModel, ConfigDict, ValidationError


class Model(BaseModel):
    x: int

    model_config = ConfigDict(frozen=True)


m = Model(x=1)

try:
    m.x = 2
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_instance'

try:
    del m.x
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_instance'

frozen_set_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार frozenset फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: frozenset


try:
    model = Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_set_type'

get_attribute_error

यह त्रुटि तब सामने आती है जब model_config['from_attributes'] == True और विशेषताएँ पढ़ते समय एक त्रुटि उत्पन्न होती है:

from pydantic import BaseModel, ConfigDict, ValidationError


class Foobar:
    def __init__(self):
        self.x = 1

    @property
    def y(self):
        raise RuntimeError('intentional error')


class Model(BaseModel):
    x: int
    y: str

    model_config = ConfigDict(from_attributes=True)


try:
    Model.model_validate(Foobar())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'get_attribute_error'

greater_than

यह त्रुटि तब उत्पन्न होती है जब मान फ़ील्ड की gt बाधा से अधिक नहीं होता है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(gt=10)


try:
    Model(x=10)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'greater_than'

greater_than_equal

यह त्रुटि तब उत्पन्न होती है जब मान फ़ील्ड की ge बाधा से अधिक या उसके बराबर नहीं होता है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(ge=10)


try:
    Model(x=9)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'greater_than_equal'

int_from_float

जब आप किसी int फ़ील्ड के लिए float मान प्रदान करते हैं तो यह त्रुटि उत्पन्न होती है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x=0.5)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_from_float'

int_parsing

यह त्रुटि तब उत्पन्न होती है जब मान को int के रूप में पार्स नहीं किया जा सकता:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_parsing'

int_parsing_size

यह त्रुटि तब उत्पन्न होती है जब पायथन str से int पार्सिंग की अधिकतम सीमा के बाहर एक स्ट्रिंग से पायथन या JSON मान को पार्स करने का प्रयास किया जाता है:

import json

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


# from Python
assert Model(x='1' * 4_300).x == int('1' * 4_300)  # OK

too_long = '1' * 4_301
try:
    Model(x=too_long)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_parsing_size'

# from JSON
try:
    Model.model_validate_json(json.dumps({'x': too_long}))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_parsing_size'

int_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार किसी int फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_type'

invalid_key

यह त्रुटि तब उत्पन्न होती है जब एक dict सत्यापित करने का प्रयास किया जाता है जिसमें एक कुंजी होती है जो str का उदाहरण नहीं है:

from pydantic import BaseModel, ConfigDict, ValidationError


class Model(BaseModel):
    x: int

    model_config = ConfigDict(extra='allow')


try:
    Model.model_validate({'x': 1, b'y': 2})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'invalid_key'

is_instance_of

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान अपेक्षित प्रकार का उदाहरण नहीं होता है:

from pydantic import BaseModel, ConfigDict, ValidationError


class Nested:
    x: str


class Model(BaseModel):
    y: Nested

    model_config = ConfigDict(arbitrary_types_allowed=True)


try:
    Model(y='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'is_instance_of'

is_subclass_of

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान अपेक्षित प्रकार का उपवर्ग नहीं होता है:

from typing import Type

from pydantic import BaseModel, ValidationError


class Nested:
    x: str


class Model(BaseModel):
    y: Type[Nested]


try:
    Model(y='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'is_subclass_of'

iterable_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान Iterable के रूप में मान्य नहीं होता है:

from typing import Iterable

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    y: Iterable


try:
    Model(y=123)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'iterable_type'

iteration_error

पुनरावृत्ति के दौरान कोई त्रुटि होने पर यह त्रुटि उत्पन्न होती है:

from typing import List

from pydantic import BaseModel, ValidationError


def gen():
    yield 1
    raise RuntimeError('error')


class Model(BaseModel):
    x: List[int]


try:
    Model(x=gen())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'iteration_error'

json_invalid

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान वैध JSON स्ट्रिंग नहीं होता है:

from pydantic import BaseModel, Json, ValidationError


class Model(BaseModel):
    x: Json


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'json_invalid'

json_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान उस प्रकार का होता है जिसे JSON के रूप में पार्स नहीं किया जा सकता है:

from pydantic import BaseModel, Json, ValidationError


class Model(BaseModel):
    x: Json


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'json_type'

less_than

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान फ़ील्ड की lt बाधा से कम नहीं होता है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(lt=10)


try:
    Model(x=10)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'less_than'

less_than_equal

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान फ़ील्ड की le से कम या उसके बराबर नहीं होता है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(le=10)


try:
    Model(x=11)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'less_than_equal'

list_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार किसी list फ़ील्ड के लिए मान्य नहीं होता है:

from typing import List

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: List[int]


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'list_type'

literal_error

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान अपेक्षित शाब्दिक मानों में से एक नहीं होता है:

from typing_extensions import Literal

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: Literal['a', 'b']


Model(x='a')  # OK

try:
    Model(x='c')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'literal_error'

mapping_type

यह त्रुटि तब उत्पन्न होती है जब Mapping प्रोटोकॉल, जैसे .items() से विधियों में कॉल में विफलता के कारण सत्यापन के दौरान कोई समस्या उत्पन्न होती है:

from collections.abc import Mapping
from typing import Dict

from pydantic import BaseModel, ValidationError


class BadMapping(Mapping):
    def items(self):
        raise ValueError()

    def __iter__(self):
        raise ValueError()

    def __getitem__(self, key):
        raise ValueError()

    def __len__(self):
        return 1


class Model(BaseModel):
    x: Dict[str, str]


try:
    Model(x=BadMapping())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'mapping_type'

missing

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान से आवश्यक फ़ील्ड गायब होते हैं:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: str


try:
    Model()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing'

missing_argument

यह त्रुटि तब उत्पन्न होती है जब एक आवश्यक स्थिति-या-कीवर्ड तर्क को validate_call से सजाए गए फ़ंक्शन में पारित नहीं किया जाता है:

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int):
    return a


try:
    foo()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing_argument'

missing_keyword_only_argument

यह त्रुटि तब उत्पन्न होती है जब एक आवश्यक कीवर्ड-केवल तर्क को validate_call से सजाए गए फ़ंक्शन में पास नहीं किया जाता है:

from pydantic import ValidationError, validate_call


@validate_call
def foo(*, a: int):
    return a


try:
    foo()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing_keyword_only_argument'

missing_positional_only_argument

यह त्रुटि तब उत्पन्न होती है जब एक आवश्यक स्थिति-मात्र तर्क को validate_call से सजाए गए फ़ंक्शन में पारित नहीं किया जाता है:

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int, /):
    return a


try:
    foo()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing_positional_only_argument'

model_attributes_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक वैध शब्दकोश, मॉडल उदाहरण या उदाहरण नहीं होता है जिससे फ़ील्ड निकाले जा सकते हैं:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    a: int
    b: int


# simply validating a dict
print(Model.model_validate({'a': 1, 'b': 2}))
#> a=1 b=2


class CustomObj:
    def __init__(self, a, b):
        self.a = a
        self.b = b


# using from attributes to extract fields from an objects
print(Model.model_validate(CustomObj(3, 4), from_attributes=True))
#> a=3 b=4

try:
    Model.model_validate('not an object', from_attributes=True)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'model_attributes_type'

model_type

यह त्रुटि तब उत्पन्न होती है जब किसी मॉडल का इनपुट मॉडल या निर्देश का उदाहरण नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    a: int
    b: int


# simply validating a dict
m = Model.model_validate({'a': 1, 'b': 2})
print(m)
#> a=1 b=2

# validating an existing model instance
print(Model.model_validate(m))
#> a=1 b=2

try:
    Model.model_validate('not an object')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'model_type'

multiple_argument_values

यह त्रुटि तब उत्पन्न होती है जब आप validate_call से सजाए गए फ़ंक्शन को कॉल करते समय एक ही तर्क के लिए एकाधिक मान प्रदान करते हैं:

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int):
    return a


try:
    foo(1, a=2)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'multiple_argument_values'

multiple_of

यह त्रुटि तब उत्पन्न होती है जब इनपुट किसी फ़ील्ड के multiple_of अवरोध का गुणज नहीं होता है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(multiple_of=5)


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'multiple_of'

no_such_attribute

यह त्रुटि तब उत्पन्न होती है जब कॉन्फ़िगरेशन में validate_assignment=True , और आप किसी ऐसे गुण के लिए मान निर्दिष्ट करने का प्रयास करते हैं जो मौजूदा फ़ील्ड नहीं है:

from pydantic import ConfigDict, ValidationError, dataclasses


@dataclasses.dataclass(config=ConfigDict(validate_assignment=True))
class MyDataclass:
    x: int


m = MyDataclass(x=1)
try:
    m.y = 10
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'no_such_attribute'

none_required

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान उस फ़ील्ड के लिए None है जिसके लिए किसी की आवश्यकता None है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: None


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'none_required'

!!! नोट जब आपके मॉडल में फ़ील्ड नाम और उसके प्रकार के बीच नामकरण टकराव होता है तो आपको इस त्रुटि का सामना करना पड़ सकता है। अधिक विशेष रूप से, यह त्रुटि तब उत्पन्न होने की संभावना है जब उस फ़ील्ड का डिफ़ॉल्ट मान None है।

For example, the following would yield the `none_required` validation error since the field `int` is set to a default value of `None` and has the exact same name as its type, which causes problems with validation.
```py
from typing import Optional

from pydantic import BaseModel


class M1(BaseModel):
    int: Optional[int] = None


m = M1(int=123)  # errors
```

recursion_loop

चक्रीय संदर्भ का पता चलने पर यह त्रुटि उत्पन्न होती है:

from typing import List

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: List['Model']


d = {'x': []}
d['x'].append(d)
try:
    Model(**d)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'recursion_loop'

set_type

यह त्रुटि तब उत्पन्न होती है जब मान प्रकार किसी set फ़ील्ड के लिए मान्य नहीं होता है:

from typing import Set

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: Set[int]


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'set_type'

string_pattern_mismatch

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान फ़ील्ड के pattern बाधा से मेल नहीं खाता:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field(pattern='test')


try:
    Model(x='1')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_pattern_mismatch'

string_sub_type

यह त्रुटि तब उत्पन्न होती है जब फ़ील्ड सख्त होने पर मान str के सख्त उपप्रकार का उदाहरण होता है:

from enum import Enum

from pydantic import BaseModel, Field, ValidationError


class MyEnum(str, Enum):
    foo = 'foo'


class Model(BaseModel):
    x: str = Field(strict=True)


try:
    Model(x=MyEnum.foo)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_sub_type'

string_too_long

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक स्ट्रिंग होती है जिसकी लंबाई फ़ील्ड की max_length बाधा से अधिक होती है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field(max_length=3)


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_too_long'

string_too_short

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक स्ट्रिंग होती है जिसकी लंबाई फ़ील्ड की min_length बाधा से कम होती है:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field(min_length=3)


try:
    Model(x='t')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_too_short'

string_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार str फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: str


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान str का उदाहरण नहीं होता है।

string_unicode

यह त्रुटि तब उत्पन्न होती है जब मान को यूनिकोड स्ट्रिंग के रूप में पार्स नहीं किया जा सकता है:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: str


try:
    Model(x=b'\x81')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_unicode'

time_delta_parsing

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक स्ट्रिंग है जिसे timedelta फ़ील्ड के लिए पार्स नहीं किया जा सकता है:

from datetime import timedelta

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: timedelta


try:
    Model(x='t')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_delta_parsing'

time_delta_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार timedelta फ़ील्ड के लिए मान्य नहीं होता है:

from datetime import timedelta

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: timedelta


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_delta_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान timedelta का उदाहरण नहीं होता है।

time_parsing

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान एक स्ट्रिंग है जिसे time फ़ील्ड के लिए पार्स नहीं किया जा सकता है:

from datetime import time

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: time


try:
    Model(x='25:20:30.400')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_parsing'

time_type

यह त्रुटि तब उत्पन्न होती है जब मान प्रकार किसी time फ़ील्ड के लिए मान्य नहीं होता है:

from datetime import time

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: time


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान time का उदाहरण नहीं होता है।

timezone_aware

यह त्रुटि तब उत्पन्न होती है जब समयक्षेत्र-जागरूक datetime फ़ील्ड के लिए प्रदान किए गए datetime मान में समयक्षेत्र की जानकारी नहीं होती है:

from datetime import datetime

from pydantic import AwareDatetime, BaseModel, ValidationError


class Model(BaseModel):
    x: AwareDatetime


try:
    Model(x=datetime.now())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'timezone_aware'

timezone_naive

यह त्रुटि तब उत्पन्न होती है जब टाइमज़ोन-नाइव datetime फ़ील्ड के लिए प्रदान किए गए datetime मान में टाइमज़ोन जानकारी होती है:

from datetime import datetime, timezone

from pydantic import BaseModel, NaiveDatetime, ValidationError


class Model(BaseModel):
    x: NaiveDatetime


try:
    Model(x=datetime.now(tz=timezone.utc))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'timezone_naive'

too_long

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान की लंबाई फ़ील्ड की max_length बाधा से अधिक होती है:

from typing import List

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: List[int] = Field(max_length=3)


try:
    Model(x=[1, 2, 3, 4])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'too_long'

too_short

यह त्रुटि तब उत्पन्न होती है जब मान लंबाई फ़ील्ड की min_length बाधा से कम होती है:

from typing import List

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: List[int] = Field(min_length=3)


try:
    Model(x=[1, 2])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'too_short'

tuple_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार tuple फ़ील्ड के लिए मान्य नहीं होता है:

from typing import Tuple

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: Tuple[int]


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'tuple_type'

यह त्रुटि सख्त फ़ील्ड के लिए भी उठाई जाती है जब इनपुट मान tuple का उदाहरण नहीं होता है।

unexpected_keyword_argument

यह त्रुटि तब उत्पन्न होती है जब आप validate_call से सजाए गए फ़ंक्शन को कॉल करते समय केवल स्थितीय तर्क के लिए कीवर्ड द्वारा मान प्रदान करते हैं:

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int, /):
    return a


try:
    foo(a=2)
except ValidationError as exc:
    print(repr(exc.errors()[1]['type']))
    #> 'unexpected_keyword_argument'

इसे pydantic.dataclasses और extra=forbid उपयोग करते समय भी उठाया जाता है:

from pydantic import TypeAdapter, ValidationError
from pydantic.dataclasses import dataclass


@dataclass(config={'extra': 'forbid'})
class Foo:
    bar: int


try:
    TypeAdapter(Foo).validate_python({'bar': 1, 'foobar': 2})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'unexpected_keyword_argument'

unexpected_positional_argument

यह त्रुटि तब उत्पन्न होती है जब आप validate_call से सजाए गए फ़ंक्शन को कॉल करते समय कीवर्ड-केवल तर्क के लिए एक स्थितीय मान प्रदान करते हैं:

from pydantic import ValidationError, validate_call


@validate_call
def foo(*, a: int):
    return a


try:
    foo(2)
except ValidationError as exc:
    print(repr(exc.errors()[1]['type']))
    #> 'unexpected_positional_argument'

union_tag_invalid

यह त्रुटि तब उत्पन्न होती है जब इनपुट का विवेचक अपेक्षित मानों में से एक नहीं होता है:

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, ValidationError


class BlackCat(BaseModel):
    pet_type: Literal['blackcat']


class WhiteCat(BaseModel):
    pet_type: Literal['whitecat']


class Model(BaseModel):
    cat: Union[BlackCat, WhiteCat] = Field(..., discriminator='pet_type')


try:
    Model(cat={'pet_type': 'dog'})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'union_tag_invalid'

union_tag_not_found

यह त्रुटि तब उत्पन्न होती है जब इनपुट से विभेदक मान निकालना संभव नहीं होता है:

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, ValidationError


class BlackCat(BaseModel):
    pet_type: Literal['blackcat']


class WhiteCat(BaseModel):
    pet_type: Literal['whitecat']


class Model(BaseModel):
    cat: Union[BlackCat, WhiteCat] = Field(..., discriminator='pet_type')


try:
    Model(cat={'name': 'blackcat'})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'union_tag_not_found'

url_parsing

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान को URL के रूप में पार्स नहीं किया जा सकता:

from pydantic import AnyUrl, BaseModel, ValidationError


class Model(BaseModel):
    x: AnyUrl


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_parsing'

url_scheme

यह त्रुटि तब उत्पन्न होती है जब यूआरएल योजना फ़ील्ड के यूआरएल प्रकार के लिए मान्य नहीं है:

from pydantic import BaseModel, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl


try:
    Model(x='ftp://example.com')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_scheme'

url_syntax_violation

यह त्रुटि तब उत्पन्न होती है जब URL सिंटैक्स मान्य नहीं होता है:

from pydantic import BaseModel, Field, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl = Field(strict=True)


try:
    Model(x='http:////example.com')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_syntax_violation'

url_too_long

यह त्रुटि तब उत्पन्न होती है जब URL की लंबाई 2083 से अधिक होती है:

from pydantic import BaseModel, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl


try:
    Model(x='x' * 2084)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_too_long'

url_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार URL फ़ील्ड के लिए मान्य नहीं होता है:

from pydantic import BaseModel, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_type'

uuid_parsing

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार UUID फ़ील्ड के लिए मान्य नहीं होता है:

from uuid import UUID

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    u: UUID


try:
    Model(u='12345678-124-1234-1234-567812345678')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'uuid_parsing'

uuid_type

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार UUID फ़ील्ड (str, बाइट्स या UUID) के लिए मान्य उदाहरण नहीं है:

from uuid import UUID

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    u: UUID


try:
    Model(u=1234567812412341234567812345678)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'uuid_type'

uuid_version

यह त्रुटि तब उत्पन्न होती है जब इनपुट मान का प्रकार यूयूआईडी संस्करण से मेल नहीं खाता है:

from pydantic import UUID5, BaseModel, ValidationError


class Model(BaseModel):
    u: UUID5


try:
    Model(u='a6cc5730-2261-11ee-9c43-2eb5a363657c')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'uuid_version'

value_error

यह त्रुटि तब उत्पन्न होती है जब सत्यापन के दौरान कोई ValueError उठाया जाता है:

from pydantic import BaseModel, ValidationError, field_validator


class Model(BaseModel):
    x: str

    @field_validator('x')
    @classmethod
    def repeat_b(cls, v):
        raise ValueError()


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'value_error'

---

本文总阅读量次