प्रायोगिक विशेषताएँ¶

इस अनुभाग में आपको पाइडेंटिक में नई, प्रयोगात्मक सुविधाओं के लिए दस्तावेज़ मिलेंगे। ये सुविधाएँ परिवर्तन या निष्कासन के अधीन हैं, और हम इन्हें पाइडेंटिक का स्थायी हिस्सा बनाने से पहले प्रतिक्रिया और सुझावों की तलाश कर रहे हैं।

प्रायोगिक सुविधाओं पर अधिक जानकारी के लिए हमारी संस्करण नीति देखें।

प्रतिक्रिया¶

हम प्रयोगात्मक सुविधाओं पर प्रतिक्रिया का स्वागत करते हैं! कृपया अपने विचार, अनुरोध या सुझाव साझा करने के लिए पाइडेंटिक गिटहब रिपॉजिटरी पर एक मुद्दा खोलें।

हम आपको मौजूदा फीडबैक को पढ़ने और मौजूदा मुद्दों पर अपने विचार जोड़ने के लिए भी प्रोत्साहित करते हैं।

आयात पर चेतावनियाँ¶

जब आप experimental मॉड्यूल से एक प्रयोगात्मक सुविधा आयात करते हैं, तो आपको एक चेतावनी संदेश दिखाई देगा कि सुविधा प्रयोगात्मक है। आप इस चेतावनी को निम्नलिखित से अक्षम कर सकते हैं:

import warnings

from pydantic import PydanticExperimentalWarning

warnings.filterwarnings('ignore', category=PydanticExperimentalWarning)

पाइपलाइन एपीआई¶

पाइडेंटिक v2.8.0 ने एक प्रयोगात्मक "पाइपलाइन" एपीआई पेश किया जो मौजूदा एपीआई की तुलना में अधिक प्रकार-सुरक्षित तरीके से पार्सिंग (सत्यापन), बाधाओं और परिवर्तनों की रचना करने की अनुमति देता है। यह एपीआई परिवर्तन या निष्कासन के अधीन है, हम इसे पाइडेंटिक का स्थायी हिस्सा बनाने से पहले प्रतिक्रिया और सुझावों की तलाश कर रहे हैं।

??? एपीआई "एपीआई दस्तावेज़ीकरण" [pydantic.experimental.pipeline][पाइडेंटिक.एक्सपेरिमेंटल.पाइपलाइन]

आम तौर पर, पाइपलाइन एपीआई का उपयोग सत्यापन के दौरान आने वाले डेटा पर लागू करने के लिए चरणों के अनुक्रम को परिभाषित करने के लिए किया जाता है। पाइपलाइन एपीआई को मौजूदा पाइडेंटिक एपीआई की तुलना में अधिक प्रकार-सुरक्षित और कंपोज़ेबल बनाया गया है।

पाइपलाइन में प्रत्येक चरण हो सकता है:

एक सत्यापन चरण जो दिए गए प्रकार पर पाइडेंटिक सत्यापन चलाता है
एक परिवर्तन चरण जो डेटा को संशोधित करता है
एक बाधा कदम जो किसी शर्त के विरुद्ध डेटा की जाँच करता है
एक विधेय चरण जो किसी शर्त के विरुद्ध डेटा की जाँच करता है और यदि वह False लौटाता है तो एक त्रुटि उत्पन्न करता है

ध्यान दें कि निम्नलिखित उदाहरण जटिलता की कीमत पर संपूर्ण होने का प्रयास करता है: यदि आप स्वयं को टाइप एनोटेशन में इतने सारे परिवर्तन लिखते हुए पाते हैं तो आप एक UserIn और UserOut मॉडल (नीचे उदाहरण) या इसी तरह के मॉडल पर विचार करना चाह सकते हैं जहां आप idomatic के माध्यम से परिवर्तन करते हैं सादा पायथन कोड। ये एपीआई उन स्थितियों के लिए हैं जहां कोड बचत महत्वपूर्ण है और अतिरिक्त जटिलता अपेक्षाकृत छोटी है।

from __future__ import annotations

from datetime import datetime

from typing_extensions import Annotated

from pydantic import BaseModel
from pydantic.experimental.pipeline import validate_as, validate_as_deferred


class User(BaseModel):
    name: Annotated[str, validate_as(str).str_lower()]  # (1)!
    age: Annotated[int, validate_as(int).gt(0)]  # (2)!
    username: Annotated[str, validate_as(str).str_pattern(r'[a-z]+')]  # (3)!
    password: Annotated[
        str,
        validate_as(str)
        .transform(str.lower)
        .predicate(lambda x: x != 'password'),  # (4)!
    ]
    favorite_number: Annotated[  # (5)!
        int,
        (validate_as(int) | validate_as(str).str_strip().validate_as(int)).gt(
            0
        ),
    ]
    friends: Annotated[list[User], validate_as(...).len(0, 100)]  # (6)!
    family: Annotated[  # (7)!
        list[User],
        validate_as_deferred(lambda: list[User]).transform(lambda x: x[1:]),
    ]
    bio: Annotated[
        datetime,
        validate_as(int)
        .transform(lambda x: x / 1_000_000)
        .validate_as(...),  # (8)!
    ]

एक स्ट्रिंग को छोटा करें.
किसी पूर्णांक को शून्य से बड़ा होने से रोकें।
रेगेक्स पैटर्न से मेल खाने के लिए एक स्ट्रिंग को सीमित करें।
आप निम्न स्तर के परिवर्तन, अवरोध और विधेय विधियों का भी उपयोग कर सकते हैं।
| का प्रयोग करें या & ऑपरेटर्स चरणों को संयोजित करने के लिए (जैसे तार्किक OR या AND)।
validate_as(...) Ellipsis के साथ कॉल करना, ... जैसा कि पहले स्थितीय तर्क का तात्पर्य है validate_as(<field type>) । किसी भी प्रकार को स्वीकार करने के लिए validate_as(Any) उपयोग करें।
पुनरावर्ती प्रकारों के लिए आप प्रकार को परिभाषित करने से पहले ही संदर्भित करने के लिए validate_as_deferred उपयोग कर सकते हैं।
आप प्री या पोस्ट प्रोसेसिंग करने के लिए अन्य चरणों से पहले या बाद में validate_as() कॉल कर सकते हैं।

`BeforeValidator` , `AfterValidator` और `WrapValidator` से मैपिंग¶

validate_as विधि BeforeValidator , AfterValidator और WrapValidator परिभाषित करने का एक अधिक प्रकार-सुरक्षित तरीका है:

from typing_extensions import Annotated

from pydantic.experimental.pipeline import transform, validate_as

# BeforeValidator
Annotated[int, validate_as(str).str_strip().validate_as(...)]  # (1)!
# AfterValidator
Annotated[int, transform(lambda x: x * 2)]  # (2)!
# WrapValidator
Annotated[
    int,
    validate_as(str)
    .str_strip()
    .validate_as(...)
    .transform(lambda x: x * 2),  # (3)!
]

किसी स्ट्रिंग को पूर्णांक के रूप में पार्स करने से पहले उसमें से रिक्त स्थान को हटा दें।
किसी पूर्णांक को पार्स करने के बाद उसे 2 से गुणा करें।
एक स्ट्रिंग से रिक्त स्थान निकालें, इसे एक पूर्णांक के रूप में मान्य करें, फिर इसे 2 से गुणा करें।

वैकल्पिक पैटर्न¶

परिदृश्य के आधार पर उपयोग करने के लिए कई वैकल्पिक पैटर्न हैं। उदाहरण के तौर पर, ऊपर उल्लिखित UserIn और UserOut पैटर्न पर विचार करें:

from __future__ import annotations

from pydantic import BaseModel


class UserIn(BaseModel):
    favorite_number: int | str


class UserOut(BaseModel):
    favorite_number: int


def my_api(user: UserIn) -> UserOut:
    favorite_number = user.favorite_number
    if isinstance(favorite_number, str):
        favorite_number = int(user.favorite_number.strip())

    return UserOut(favorite_number=favorite_number)


assert my_api(UserIn(favorite_number=' 1 ')).favorite_number == 1

यह उदाहरण सादे मुहावरेदार पायथन कोड का उपयोग करता है जिसे उपरोक्त उदाहरणों की तुलना में समझना, टाइप-चेक करना आदि आसान हो सकता है। आपके द्वारा चुना गया दृष्टिकोण वास्तव में आपके उपयोग के मामले पर निर्भर होना चाहिए। सही पैटर्न चुनने के लिए आपको शब्दाडंबर, प्रदर्शन, अपने उपयोगकर्ताओं को सार्थक त्रुटियां लौटाने में आसानी आदि की तुलना करनी होगी। बस पाइपलाइन एपीआई जैसे उन्नत पैटर्न का दुरुपयोग करने से सावधान रहें क्योंकि आप ऐसा कर सकते हैं।

本文总阅读量次