पाइडेंटिक पाइथॉन मानक लाइब्रेरी से कई सामान्य प्रकारों का समर्थन करता है। यदि आपको कठोर प्रसंस्करण की आवश्यकता है तो सख्त प्रकार देखें, जिसमें यह भी शामिल है कि क्या आपको अनुमत मानों को सीमित करने की आवश्यकता है (उदाहरण के लिए सकारात्मक int आवश्यकता है)।

बूलियन्स

यदि मान निम्न में से एक नहीं है तो एक मानक bool फ़ील्ड एक ValidationError बढ़ाएगा:

• एक वैध बूलियन (यानी True या False ),
• पूर्णांक 0 या 1 ,
• एक str जिसे जब लोअरकेस में बदला जाता है तो वह इनमें से एक होता है '0', 'off', 'f', 'false', 'n', 'no', '1', 'on', 't', 'true', 'y', 'yes'
• एक bytes जो str में डिकोड होने पर पिछले नियम के अनुसार मान्य है

!!! ध्यान दें यदि आप सख्त बूलियन तर्क चाहते हैं (उदाहरण के लिए एक फ़ील्ड जो केवल True और False की अनुमति देता है) तो आप StrictBool उपयोग कर सकते हैं।

इनमें से कुछ व्यवहारों को प्रदर्शित करने वाली एक स्क्रिप्ट यहां दी गई है:

from pydantic import BaseModel, ValidationError


class BooleanModel(BaseModel):
    bool_value: bool


print(BooleanModel(bool_value=False))
#> bool_value=False
print(BooleanModel(bool_value='False'))
#> bool_value=False
print(BooleanModel(bool_value=1))
#> bool_value=True
try:
    BooleanModel(bool_value=[])
except ValidationError as e:
    print(str(e))
    """
    1 validation error for BooleanModel
    bool_value
      Input should be a valid boolean [type=bool_type, input_value=[], input_type=list]
    """

दिनांक समय प्रकार

पाइडेंटिक निम्नलिखित डेटाटाइम प्रकारों का समर्थन करता है:

datetime.datetime

• datetime फ़ील्ड प्रकार के मान स्वीकार करेंगे:

  • datetime ; एक मौजूदा datetime ऑब्जेक्ट
  • int या float ; 1 जनवरी 1970 से यूनिक्स समय के रूप में माना जाता है, अर्थात सेकंड (यदि >= -2e10 और <= 2e10 ) या मिलीसेकंड (यदि < -2e10 या > 2e10 )
  • str ; निम्नलिखित प्रारूप स्वीकार किए जाते हैं:
    • YYYY-MM-DD[T]HH:MM[:SS[.ffffff]][Z or [±]HH[:]MM]
    • YYYY-MM-DD शिथिल मोड में स्वीकार किया जाता है, लेकिन सख्त मोड में नहीं
    • int या एक स्ट्रिंग के रूप में float (यूनिक्स समय के रूप में माना जाता है)
  • datetime.date उदाहरण लैक्स मोड में स्वीकार किए जाते हैं, लेकिन सख्त मोड में नहीं

  from datetime import datetime

  from pydantic import BaseModel

  class Event(BaseModel): dt: datetime = None

  event = Event(dt='2032-04-23T10:20:30.400+02:30')

  print(event.model_dump()) """ {'dt': datetime.datetime(2032, 4, 23, 10, 20, 30, 400000, tzinfo=TzInfo(+02:30))} """

datetime.date

• date फ़ील्ड प्रकार के मान स्वीकार करेंगे:

  • date ; एक मौजूदा date वस्तु
  • int या float ; उपरोक्त datetime के लिए वर्णित अनुसार ही संभाला गया
  • str ; निम्नलिखित प्रारूप स्वीकार किए जाते हैं:
    • YYYY-MM-DD
    • int या एक स्ट्रिंग के रूप में float (यूनिक्स समय के रूप में माना जाता है)

  from datetime import date

  from pydantic import BaseModel

  class Birthday(BaseModel): d: date = None

  my_birthday = Birthday(d=1679616000.0)

  print(my_birthday.model_dump())

  >

datetime.time

• time फ़ील्ड प्रकार के मान स्वीकार करेंगे:

  • time ; एक मौजूदा time वस्तु
  • str ; निम्नलिखित प्रारूप स्वीकार किए जाते हैं:
    • HH:MM[:SS[.ffffff]][Z or [±]HH[:]MM]

  from datetime import time

  from pydantic import BaseModel

  class Meeting(BaseModel): t: time = None

  m = Meeting(t=time(4, 8, 16))

  print(m.model_dump())

  >

datetime.timedelta

• timedelta फ़ील्ड प्रकार के मान स्वीकार करेंगे:

  • timedelta ; एक मौजूदा timedelta ऑब्जेक्ट
  • int या float ; सेकंड माना जाता है
  • str ; निम्नलिखित प्रारूप स्वीकार किए जाते हैं:
    • [-][DD]D[,][HH:MM:]SS[.ffffff]
      • उदाहरण: '1d,01:02:03.000004' या '1D01:02:03.000004' या '01:02:03'
    • [±]P[DD]DT[HH]H[MM]M[SS]S (टाइमडेल्टा के लिए आईएसओ 8601 प्रारूप)

  from datetime import timedelta

  from pydantic import BaseModel

  class Model(BaseModel): td: timedelta = None

  m = Model(td='P3DT12H30M5S')

  print(m.model_dump())

  >

संख्या प्रकार

पाइडेंटिक पायथन मानक लाइब्रेरी से निम्नलिखित संख्यात्मक प्रकारों का समर्थन करता है:

int

• Pydantic int(v) का उपयोग प्रकारों को int से जोड़ने के लिए करता है; डेटा रूपांतरण के दौरान जानकारी के नुकसान के विवरण के लिए डेटा रूपांतरण देखें।

float

• पाइडेंटिक फ़्लोट के मानों को बाध्य करने के लिए float(v) उपयोग करता है।

enum.IntEnum

• सत्यापन: पाइडेंटिक जाँच करता है कि मान एक वैध IntEnum उदाहरण है।
• enum.IntEnum के उपवर्ग के लिए सत्यापन: जाँचता है कि मान पूर्णांक enum का एक वैध सदस्य है; अधिक विवरण के लिए एनम और विकल्प देखें।

decimal.Decimal

• सत्यापन: पाइडेंटिक मान को एक स्ट्रिंग में बदलने का प्रयास करता है, फिर स्ट्रिंग को Decimal(v) पर भेजता है।

• क्रमबद्धता: पाइडेंटिक [Decimal][दशमलव.दशमलव] प्रकारों को स्ट्रिंग के रूप में क्रमबद्ध करता है। यदि आप चाहें तो इस व्यवहार को ओवरराइड करने के लिए आप एक कस्टम सीरियलाइज़र का उपयोग कर सकते हैं। उदाहरण के लिए:

  from decimal import Decimal

  from typing_extensions import Annotated

  from pydantic import BaseModel, PlainSerializer

  class Model(BaseModel): x: Decimal y: Annotated[ Decimal, PlainSerializer( lambda x: float(x), return_type=float, when_used='json' ), ]

  my_model = Model(x=Decimal('1.1'), y=Decimal('2.1'))

  print(my_model.model_dump()) # (1)!

  >

  print(my_model.model_dump(mode='json')) # (2)!

  >

  print(my_model.model_dump_json()) # (3)!

  >

• model_dump का उपयोग करते हुए, x और y दोनों Decimal प्रकार के उदाहरण बने रहते हैं

• mode='json' के साथ model_dump का उपयोग करके, x एक string के रूप में क्रमबद्ध किया जाता है, और y कस्टम सीरियलाइज़र लागू होने के कारण एक float के रूप में क्रमबद्ध किया जाता है।
• model_dump_json का उपयोग करके, x एक string के रूप में क्रमबद्ध किया जाता है, और y कस्टम सीरियलाइज़र लागू होने के कारण एक float के रूप में क्रमबद्ध किया जाता है।

[Enum][एनम.एनम]

पाइडेंटिक विकल्पों को परिभाषित करने के लिए पायथन के मानक enum कक्षाओं का उपयोग करता है।

enum.Enum जाँचता है कि मान एक वैध Enum उदाहरण है। enum.Enum का उपवर्ग जाँचता है कि मान enum का वैध सदस्य है।

from enum import Enum, IntEnum

from pydantic import BaseModel, ValidationError


class FruitEnum(str, Enum):
    pear = 'pear'
    banana = 'banana'


class ToolEnum(IntEnum):
    spanner = 1
    wrench = 2


class CookingModel(BaseModel):
    fruit: FruitEnum = FruitEnum.pear
    tool: ToolEnum = ToolEnum.spanner


print(CookingModel())
#> fruit=<FruitEnum.pear: 'pear'> tool=<ToolEnum.spanner: 1>
print(CookingModel(tool=2, fruit='banana'))
#> fruit=<FruitEnum.banana: 'banana'> tool=<ToolEnum.wrench: 2>
try:
    CookingModel(fruit='other')
except ValidationError as e:
    print(e)
    """
    1 validation error for CookingModel
    fruit
      Input should be 'pear' or 'banana' [type=enum, input_value='other', input_type=str]
    """

सूचियाँ और टुपल्स

list

list, tuple, set, frozenset, [deque][संग्रह.डेक], या जेनरेटर और list में डालने की अनुमति देता है। जब एक सामान्य पैरामीटर प्रदान किया जाता है, तो सूची के सभी आइटमों पर उचित सत्यापन लागू किया जाता है।

typing.List

उपरोक्त list के समान ही संभाला गया।

from typing import List, Optional

from pydantic import BaseModel


class Model(BaseModel):
    simple_list: Optional[list] = None
    list_of_ints: Optional[List[int]] = None


print(Model(simple_list=['1', '2', '3']).simple_list)
#> ['1', '2', '3']
print(Model(list_of_ints=['1', '2', '3']).list_of_ints)
#> [1, 2, 3]

tuple

list, tuple, set, frozenset, [deque][कलेक्शन.डेक], या जनरेटर और कास्ट को tuple की अनुमति देता है। जब सामान्य पैरामीटर प्रदान किए जाते हैं, तो टुपल के संबंधित आइटम पर उचित सत्यापन लागू किया जाता है

typing.Tuple

उपरोक्त tuple के समान ही संभाला गया।

from typing import Optional, Tuple

from pydantic import BaseModel


class Model(BaseModel):
    simple_tuple: Optional[tuple] = None
    tuple_of_different_types: Optional[Tuple[int, float, bool]] = None


print(Model(simple_tuple=[1, 2, 3, 4]).simple_tuple)
#> (1, 2, 3, 4)
print(Model(tuple_of_different_types=[3, 2, 1]).tuple_of_different_types)
#> (3, 2.0, True)

typing.NamedTuple

typing.NamedTuple के उपवर्ग tuple के समान हैं, लेकिन दिए गए namedtuple वर्ग के उदाहरण बनाते हैं।

collections.namedtuple के उपवर्ग typing.NamedTuple के उपवर्ग के समान हैं, लेकिन चूंकि फ़ील्ड प्रकार निर्दिष्ट नहीं हैं, इसलिए सभी फ़ील्ड को Any प्रकार के रूप में माना जाता है।

from typing import NamedTuple

from pydantic import BaseModel, ValidationError


class Point(NamedTuple):
    x: int
    y: int


class Model(BaseModel):
    p: Point


try:
    Model(p=('1.3', '2'))
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    p.0
      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='1.3', input_type=str]
    """

डेक

[deque][संग्रह.डेक]

list, tuple, set, frozenset, [deque][कलेक्शन.डेक], या जनरेटर और कास्ट को [deque][कलेक्शन.डेक] की अनुमति देता है। जब सामान्य पैरामीटर प्रदान किए जाते हैं, तो deque के संबंधित आइटम पर उचित सत्यापन लागू किया जाता है।

typing.Deque

उपरोक्त deque के समान ही संभाला गया।

from typing import Deque, Optional

from pydantic import BaseModel


class Model(BaseModel):
    deque: Optional[Deque[int]] = None


print(Model(deque=[1, 2, 3]).deque)
#> deque([1, 2, 3])

सेट

set

list, tuple, set, frozenset, [deque][संग्रह.डेक], या जेनरेटर और set में डालने की अनुमति देता है। जब एक सामान्य पैरामीटर प्रदान किया जाता है, तो सेट के सभी आइटमों पर उचित सत्यापन लागू किया जाता है।

typing.Set

ऊपर set के अनुसार ही संभाला गया।

from typing import Optional, Set

from pydantic import BaseModel


class Model(BaseModel):
    simple_set: Optional[set] = None
    set_of_ints: Optional[Set[int]] = None


print(Model(simple_set={'1', '2', '3'}).simple_set)
#> {'1', '2', '3'}
print(Model(simple_set=['1', '2', '3']).simple_set)
#> {'1', '2', '3'}
print(Model(set_of_ints=['1', '2', '3']).set_of_ints)
#> {1, 2, 3}

frozenset

list, tuple, set, frozenset, [deque][कलेक्शन.डेक], या जनरेटर और कास्ट को frozenset की अनुमति देता है। जब एक सामान्य पैरामीटर प्रदान किया जाता है, तो जमे हुए सेट की सभी वस्तुओं पर उचित सत्यापन लागू किया जाता है।

typing.FrozenSet

ऊपर frozenset के समान ही संभाला गया।

from typing import FrozenSet, Optional

from pydantic import BaseModel


class Model(BaseModel):
    simple_frozenset: Optional[frozenset] = None
    frozenset_of_ints: Optional[FrozenSet[int]] = None


m1 = Model(simple_frozenset=['1', '2', '3'])
print(type(m1.simple_frozenset))
#> <class 'frozenset'>
print(sorted(m1.simple_frozenset))
#> ['1', '2', '3']

m2 = Model(frozenset_of_ints=['1', '2', '3'])
print(type(m2.frozenset_of_ints))
#> <class 'frozenset'>
print(sorted(m2.frozenset_of_ints))
#> [1, 2, 3]

अन्य पुनरावृत्तियाँ

typing.Sequence

इसका उपयोग तब किया जाता है जब प्रदान किया गया मूल्य Sequence एबीसी की आवश्यकताओं को पूरा करना चाहिए, और कंटेनर में मूल्यों का उत्सुकता से सत्यापन करना वांछनीय है। ध्यान दें कि जब सत्यापन कंटेनर के मूल्यों पर किया जाना चाहिए, तो कंटेनर का प्रकार संरक्षित नहीं किया जा सकता है क्योंकि सत्यापन अंततः मूल्यों को प्रतिस्थापित कर सकता है। हम गारंटी देते हैं कि मान्य मान वैध typing.Sequence होगा, लेकिन इसका प्रकार प्रदान किए गए से भिन्न हो सकता है (आम तौर पर, यह एक list बन जाएगा)।

typing.Iterable

इसका उपयोग तब किया जाता है जब प्रदान किया गया मान पुनरावर्तनीय हो सकता है जिसका उपभोग नहीं किया जाना चाहिए। पार्सिंग और सत्यापन पर अधिक विवरण के लिए नीचे अनंत जेनरेटर देखें। typing.Sequence के समान, हम गारंटी देते हैं कि मान्य परिणाम वैध typing.Iterable होगा, लेकिन इसका प्रकार प्रदान किए गए से भिन्न हो सकता है। विशेष रूप से, भले ही एक गैर-जनरेटर प्रकार जैसे कि एक list प्रदान की जाती है, प्रकार के क्षेत्र का पोस्ट-सत्यापन मूल्य typing.Iterable एक जनरेटर होगा।

यहां typing.Sequence का उपयोग करके एक सरल उदाहरण दिया गया है:

from typing import Sequence

from pydantic import BaseModel


class Model(BaseModel):
    sequence_of_ints: Sequence[int] = None


print(Model(sequence_of_ints=[1, 2, 3, 4]).sequence_of_ints)
#> [1, 2, 3, 4]
print(Model(sequence_of_ints=(1, 2, 3, 4)).sequence_of_ints)
#> (1, 2, 3, 4)

अनंत जेनरेटर

यदि आपके पास एक जनरेटर है जिसे आप सत्यापित करना चाहते हैं, तो भी आप ऊपर बताए अनुसार Sequence उपयोग कर सकते हैं। उस स्थिति में, जनरेटर का उपभोग किया जाएगा और एक सूची के रूप में मॉडल पर संग्रहीत किया जाएगा और इसके मूल्यों को Sequence के प्रकार पैरामीटर (उदाहरण के लिए Sequence[int] में int ) के विरुद्ध मान्य किया जाएगा।

हालाँकि, यदि आपके पास एक जनरेटर है जिसे आप उत्सुकता से उपभोग नहीं करना चाहते हैं (उदाहरण के लिए एक अनंत जनरेटर या रिमोट डेटा लोडर), तो आप Iterable प्रकार के फ़ील्ड का उपयोग कर सकते हैं:

from typing import Iterable

from pydantic import BaseModel


class Model(BaseModel):
    infinite: Iterable[int]


def infinite_ints():
    i = 0
    while True:
        yield i
        i += 1


m = Model(infinite=infinite_ints())
print(m)
"""
infinite=ValidatorIterator(index=0, schema=Some(Int(IntValidator { strict: false })))
"""

for i in m.infinite:
    print(i)
    #> 0
    #> 1
    #> 2
    #> 3
    #> 4
    #> 5
    #> 6
    #> 7
    #> 8
    #> 9
    #> 10
    if i == 10:
        break

!!! चेतावनी प्रारंभिक सत्यापन के दौरान, Iterable फ़ील्ड केवल एक साधारण जांच करते हैं कि प्रदान किया गया तर्क पुनरावर्तनीय है। इसे उपभोग होने से रोकने के लिए, प्राप्त मूल्यों का कोई सत्यापन उत्सुकता से नहीं किया जाता है।

हालाँकि प्राप्त मूल्यों को उत्सुकता से मान्य नहीं किया जाता है, फिर भी उन्हें प्राप्त होने पर मान्य किया जाता है, और उचित होने पर उपज समय पर एक ValidationError बढ़ाएगा:

from typing import Iterable

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    int_iterator: Iterable[int]


def my_iterator():
    yield 13
    yield '27'
    yield 'a'


m = Model(int_iterator=my_iterator())
print(next(m.int_iterator))
#> 13
print(next(m.int_iterator))
#> 27
try:
    next(m.int_iterator)
except ValidationError as e:
    print(e)
    """
    1 validation error for ValidatorIterator
    2
      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='a', input_type=str]
    """

मानचित्रण के प्रकार

dict

dict(v) का उपयोग किसी शब्दकोश को परिवर्तित करने के प्रयास के लिए किया जाता है। उप-प्रकार की बाधाओं के लिए नीचे typing.Dict देखें।

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: dict


m = Model(x={'foo': 1})
print(m.model_dump())
#> {'x': {'foo': 1}}

try:
    Model(x='test')
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    x
      Input should be a valid dictionary [type=dict_type, input_value='test', input_type=str]
    """

typing.Dict

from typing import Dict

from pydantic import BaseModel, ValidationError


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


m = Model(x={'foo': 1})
print(m.model_dump())
#> {'x': {'foo': 1}}

try:
    Model(x={'foo': '1'})
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    x
      Input should be a valid dictionary [type=dict_type, input_value='test', input_type=str]
    """

टाइप किया हुआ डिक्ट

!!! नोट यह Python 3.8 की तरह Python मानक लाइब्रेरी की एक नई सुविधा है। 3.12 से पहले typing.TypedDict में सीमाओं के कारण, Python <3.12 के लिए टाइपिंग-एक्सटेंशन पैकेज आवश्यक है। आपको typing के बजाय typing_extensions से TypedDict आयात करने की आवश्यकता होगी और यदि आप ऐसा नहीं करते हैं तो बिल्ड टाइम त्रुटि प्राप्त होगी।

[TypedDict][टाइपिंग.टाइप्डडिक्ट] एक शब्दकोश प्रकार की घोषणा करता है जो अपेक्षा करता है कि उसके सभी उदाहरणों में कुंजियों का एक निश्चित सेट हो, जहां प्रत्येक कुंजी एक सुसंगत प्रकार के मान से जुड़ी हो।

यह dict के समान है लेकिन पाइडेंटिक शब्दकोश को मान्य करेगा क्योंकि कुंजियाँ एनोटेट की गई हैं।

from typing_extensions import TypedDict

from pydantic import TypeAdapter, ValidationError


class User(TypedDict):
    name: str
    id: int


ta = TypeAdapter(User)

print(ta.validate_python({'name': 'foo', 'id': 1}))
#> {'name': 'foo', 'id': 1}

try:
    ta.validate_python({'name': 'foo'})
except ValidationError as e:
    print(e)
    """
    1 validation error for typed-dict
    id
      Field required [type=missing, input_value={'name': 'foo'}, input_type=dict]
    """

TypedDict से प्राप्त मॉडल को बदलने के लिए आप __pydantic_config__ परिभाषित कर सकते हैं। अधिक विवरण के लिए ConfigDict API संदर्भ देखें।

from typing import Optional

from typing_extensions import TypedDict

from pydantic import ConfigDict, TypeAdapter, ValidationError


# `total=False` means keys are non-required
class UserIdentity(TypedDict, total=False):
    name: Optional[str]
    surname: str


class User(TypedDict):
    __pydantic_config__ = ConfigDict(extra='forbid')

    identity: UserIdentity
    age: int


ta = TypeAdapter(User)

print(
    ta.validate_python(
        {'identity': {'name': 'Smith', 'surname': 'John'}, 'age': 37}
    )
)
#> {'identity': {'name': 'Smith', 'surname': 'John'}, 'age': 37}

print(
    ta.validate_python(
        {'identity': {'name': None, 'surname': 'John'}, 'age': 37}
    )
)
#> {'identity': {'name': None, 'surname': 'John'}, 'age': 37}

print(ta.validate_python({'identity': {}, 'age': 37}))
#> {'identity': {}, 'age': 37}


try:
    ta.validate_python(
        {'identity': {'name': ['Smith'], 'surname': 'John'}, 'age': 24}
    )
except ValidationError as e:
    print(e)
    """
    1 validation error for typed-dict
    identity.name
      Input should be a valid string [type=string_type, input_value=['Smith'], input_type=list]
    """

try:
    ta.validate_python(
        {
            'identity': {'name': 'Smith', 'surname': 'John'},
            'age': '37',
            'email': 'john.smith@me.com',
        }
    )
except ValidationError as e:
    print(e)
    """
    1 validation error for typed-dict
    email
      Extra inputs are not permitted [type=extra_forbidden, input_value='john.smith@me.com', input_type=str]
    """

प्रतिदेय

पार्सिंग और सत्यापन पर अधिक विवरण के लिए नीचे देखें

फ़ील्ड इस प्रकार के भी हो सकते हैं [Callable][टाइपिंग। कॉल करने योग्य]:

from typing import Callable

from pydantic import BaseModel


class Foo(BaseModel):
    callback: Callable[[int], int]


m = Foo(callback=lambda x: x)
print(m)
#> callback=<function <lambda> at 0x0123456789ab>

!!! चेतावनी कॉल करने योग्य फ़ील्ड केवल एक साधारण जांच करते हैं कि तर्क कॉल करने योग्य है; तर्कों, उनके प्रकारों या रिटर्न प्रकार का कोई सत्यापन नहीं किया जाता है।

आईपी एड्रेस प्रकार

• ipaddress.IPv4Address: मान को IPv4Address(v) पर पास करके सत्यापन के लिए प्रकार का ही उपयोग करता है।
• ipaddress.IPv4Interface: मान को IPv4Address(v) पर पास करके सत्यापन के लिए प्रकार का ही उपयोग करता है।
• ipaddress.IPv4Network: मान को IPv4Network(v) पर पास करके सत्यापन के लिए प्रकार का ही उपयोग करता है।
• ipaddress.IPv6Address: मान को IPv6Address(v) पर पास करके सत्यापन के लिए प्रकार का ही उपयोग करता है।
• ipaddress.IPv6Interface: मान को IPv6Interface(v) पर पास करके सत्यापन के लिए प्रकार का ही उपयोग करता है।
• ipaddress.IPv6Network: मान को IPv6Network(v) पर पास करके सत्यापन के लिए प्रकार का ही उपयोग करता है।

अन्य कस्टम आईपी एड्रेस प्रकारों के लिए नेटवर्क प्रकार देखें।

यूयूआईडी

UUID के लिए, Pydantic मान को UUID(v) पर पास करके सत्यापन के लिए स्वयं प्रकार का उपयोग करने का प्रयास करता है। bytes और bytearray के लिए UUID(bytes=v) का फ़ॉलबैक है।

यदि आप यूयूआईडी संस्करण को प्रतिबंधित करना चाहते हैं, तो आप निम्न प्रकारों की जांच कर सकते हैं:

• UUID1: UUID संस्करण 1 की आवश्यकता है।
• UUID3: UUID संस्करण 3 की आवश्यकता है।
• UUID4: UUID संस्करण 4 की आवश्यकता है।
• UUID5: UUID संस्करण 5 की आवश्यकता है।

मिलन

पाइडेंटिक के पास यूनियन सत्यापन के लिए व्यापक समर्थन है, दोनों typing.Union और पायथन 3.10 के पाइप सिंटैक्स ( A | B ) समर्थित हैं। कॉन्सेप्ट डॉक्स के Unions अनुभाग में और पढ़ें।

[Type][टाइपिंग.टाइप] और [TypeVar][टाइपिंग.टाइपवार]

type

पाइडेंटिक यह निर्दिष्ट करने के लिए type[T] के उपयोग का समर्थन करता है कि एक फ़ील्ड केवल उन वर्गों को स्वीकार कर सकता है (उदाहरण नहीं) जो T के उपवर्ग हैं।

typing.Type

उपरोक्त type के समान ही संभाला गया।

from typing import Type

from pydantic import BaseModel, ValidationError


class Foo:
    pass


class Bar(Foo):
    pass


class Other:
    pass


class SimpleModel(BaseModel):
    just_subclasses: Type[Foo]


SimpleModel(just_subclasses=Foo)
SimpleModel(just_subclasses=Bar)
try:
    SimpleModel(just_subclasses=Other)
except ValidationError as e:
    print(e)
    """
    1 validation error for SimpleModel
    just_subclasses
      Input should be a subclass of Foo [type=is_subclass_of, input_value=<class '__main__.Other'>, input_type=type]
    """

आप यह निर्दिष्ट करने के लिए भी Type उपयोग कर सकते हैं कि किसी वर्ग को अनुमति है।

from typing import Type

from pydantic import BaseModel, ValidationError


class Foo:
    pass


class LenientSimpleModel(BaseModel):
    any_class_goes: Type


LenientSimpleModel(any_class_goes=int)
LenientSimpleModel(any_class_goes=Foo)
try:
    LenientSimpleModel(any_class_goes=Foo())
except ValidationError as e:
    print(e)
    """
    1 validation error for LenientSimpleModel
    any_class_goes
      Input should be a type [type=is_type, input_value=<__main__.Foo object at 0x0123456789ab>, input_type=Foo]
    """

typing.TypeVar

[TypeVar][टाइपिंग.टाइपवार] या तो अप्रतिबंधित, प्रतिबंधित या बाध्य के साथ समर्थित है।

from typing import TypeVar

from pydantic import BaseModel

Foobar = TypeVar('Foobar')
BoundFloat = TypeVar('BoundFloat', bound=float)
IntStr = TypeVar('IntStr', int, str)


class Model(BaseModel):
    a: Foobar  # equivalent of ": Any"
    b: BoundFloat  # equivalent of ": float"
    c: IntStr  # equivalent of ": Union[int, str]"


print(Model(a=[1], b=4.2, c='x'))
#> a=[1] b=4.2 c='x'

# a may be None
print(Model(a=None, b=1, c=1))
#> a=None b=1.0 c=1

कोई भी प्रकार नहीं

None, type(None) , या Literal[None] सभी टाइपिंग विनिर्देश के अनुसार समकक्ष हैं। केवल None मान की अनुमति देता है।

स्ट्रिंग्स

str : स्ट्रिंग्स को वैसे ही स्वीकार किया जाता है जैसे कि है। bytes और bytearray v.decode() उपयोग करके परिवर्तित किया जाता है। str s inheriting from v.value` का are converted using । अन्य सभी प्रकार त्रुटि उत्पन्न करते हैं।

!!! चेतावनी "स्ट्रिंग्स अनुक्रम नहीं हैं"

While instances of `str` are technically valid instances of the `Sequence[str]` protocol from a type-checker's point of
view, this is frequently not intended as is a common source of bugs.

As a result, Pydantic raises a `ValidationError` if you attempt to pass a `str` or `bytes` instance into a field of type
`Sequence[str]` or `Sequence[bytes]`:


from typing import Optional, Sequence

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    sequence_of_strs: Optional[Sequence[str]] = None
    sequence_of_bytes: Optional[Sequence[bytes]] = None


print(Model(sequence_of_strs=['a', 'bc']).sequence_of_strs)
#> ['a', 'bc']
print(Model(sequence_of_strs=('a', 'bc')).sequence_of_strs)
#> ('a', 'bc')
print(Model(sequence_of_bytes=[b'a', b'bc']).sequence_of_bytes)
#> [b'a', b'bc']
print(Model(sequence_of_bytes=(b'a', b'bc')).sequence_of_bytes)
#> (b'a', b'bc')


try:
    Model(sequence_of_strs='abc')
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    sequence_of_strs
      'str' instances are not allowed as a Sequence value [type=sequence_str, input_value='abc', input_type=str]
    """
try:
    Model(sequence_of_bytes=b'abc')
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    sequence_of_bytes
      'bytes' instances are not allowed as a Sequence value [type=sequence_str, input_value=b'abc', input_type=bytes]
    """

बाइट्स

bytes को वैसे ही स्वीकार किया जाता है। bytearray bytes(v) का उपयोग करके परिवर्तित किया जाता है। str v.encode() उपयोग करके परिवर्तित किया जाता है। int , float और Decimal str(v).encode() उपयोग करके मजबूर किया जाता है। अधिक विवरण के लिए बाइटसाइज़ देखें।

typing.Literal

पाइडेंटिक यह निर्दिष्ट करने के हल्के तरीके के रूप में typing.Literal के उपयोग का समर्थन करता है कि कोई फ़ील्ड केवल विशिष्ट शाब्दिक मान स्वीकार कर सकता है:

from typing import Literal

from pydantic import BaseModel, ValidationError


class Pie(BaseModel):
    flavor: Literal['apple', 'pumpkin']


Pie(flavor='apple')
Pie(flavor='pumpkin')
try:
    Pie(flavor='cherry')
except ValidationError as e:
    print(str(e))
    """
    1 validation error for Pie
    flavor
      Input should be 'apple' or 'pumpkin' [type=literal_error, input_value='cherry', input_type=str]
    """

इस फ़ील्ड प्रकार का एक लाभ यह है कि इसका उपयोग कस्टम सत्यापनकर्ता घोषित किए बिना एक या अधिक विशिष्ट मानों के साथ समानता की जांच करने के लिए किया जा सकता है:

from typing import ClassVar, List, Literal, Union

from pydantic import BaseModel, ValidationError


class Cake(BaseModel):
    kind: Literal['cake']
    required_utensils: ClassVar[List[str]] = ['fork', 'knife']


class IceCream(BaseModel):
    kind: Literal['icecream']
    required_utensils: ClassVar[List[str]] = ['spoon']


class Meal(BaseModel):
    dessert: Union[Cake, IceCream]


print(type(Meal(dessert={'kind': 'cake'}).dessert).__name__)
#> Cake
print(type(Meal(dessert={'kind': 'icecream'}).dessert).__name__)
#> IceCream
try:
    Meal(dessert={'kind': 'pie'})
except ValidationError as e:
    print(str(e))
    """
    2 validation errors for Meal
    dessert.Cake.kind
      Input should be 'cake' [type=literal_error, input_value='pie', input_type=str]
    dessert.IceCream.kind
      Input should be 'icecream' [type=literal_error, input_value='pie', input_type=str]
    """

एनोटेटेड Union में उचित क्रम के साथ, आप इसका उपयोग घटती विशिष्टता के प्रकारों को पार्स करने के लिए कर सकते हैं:

from typing import Literal, Optional, Union

from pydantic import BaseModel


class Dessert(BaseModel):
    kind: str


class Pie(Dessert):
    kind: Literal['pie']
    flavor: Optional[str]


class ApplePie(Pie):
    flavor: Literal['apple']


class PumpkinPie(Pie):
    flavor: Literal['pumpkin']


class Meal(BaseModel):
    dessert: Union[ApplePie, PumpkinPie, Pie, Dessert]


print(type(Meal(dessert={'kind': 'pie', 'flavor': 'apple'}).dessert).__name__)
#> ApplePie
print(type(Meal(dessert={'kind': 'pie', 'flavor': 'pumpkin'}).dessert).__name__)
#> PumpkinPie
print(type(Meal(dessert={'kind': 'pie'}).dessert).__name__)
#> Dessert
print(type(Meal(dessert={'kind': 'cake'}).dessert).__name__)
#> Dessert

[typing.Any भी][]

None सहित किसी भी मान की अनुमति देता है।

typing.Annotated

PEP-593 के अनुसार, किसी अन्य प्रकार को मनमाने मेटाडेटा के साथ लपेटने की अनुमति देता है। Annotated संकेत में Field फ़ंक्शन के लिए एक एकल कॉल हो सकती है, लेकिन अन्यथा अतिरिक्त मेटाडेटा को अनदेखा कर दिया जाता है और रूट प्रकार का उपयोग किया जाता है।

typing.Pattern

नियमित अभिव्यक्ति पैटर्न बनाने के लिए इनपुट मान को re.compile(v) में पास करने का कारण बनेगा।

pathlib.Path

मान को Path(v) पर पास करके सत्यापन के लिए बस प्रकार का ही उपयोग करता है।

---

本文总阅读量次