विषय पर बढ़ें

!!! चेतावनी "🚧 कार्य प्रगति पर है" यह पृष्ठ कार्य प्रगति पर है।

JSON

जेसन पार्सिंग

??? एपीआई "एपीआई दस्तावेज़ीकरण" pydantic.main.BaseModel.model_validate_json pydantic.type_adapter.TypeAdapter.validate_json pydantic_core.from_json

पाइडेंटिक अंतर्निहित JSON पार्सिंग प्रदान करता है, जो प्राप्त करने में मदद करता है:

  • तृतीय पक्ष लाइब्रेरी का उपयोग करने की लागत के बिना महत्वपूर्ण प्रदर्शन सुधार
  • कस्टम त्रुटियों के लिए समर्थन
  • strict विशिष्टताओं के लिए समर्थन

यहां model_validate_json विधि के माध्यम से पाइडेंटिक के अंतर्निहित JSON पार्सिंग का एक उदाहरण दिया गया है, जो JSON डेटा को पार्स करते समय strict विनिर्देशों के लिए समर्थन प्रदर्शित करता है जो मॉडल के प्रकार एनोटेशन से मेल नहीं खाता है:

from datetime import date
from typing import Tuple

from pydantic import BaseModel, ConfigDict, ValidationError


class Event(BaseModel):
    model_config = ConfigDict(strict=True)

    when: date
    where: Tuple[int, int]


json_data = '{"when": "1987-01-28", "where": [51, -1]}'
print(Event.model_validate_json(json_data))  # (1)!
#> when=datetime.date(1987, 1, 28) where=(51, -1)

try:
    Event.model_validate({'when': '1987-01-28', 'where': [51, -1]})  # (2)!
except ValidationError as e:
    print(e)
    """
    2 validation errors for Event
    when
      Input should be a valid date [type=date_type, input_value='1987-01-28', input_type=str]
    where
      Input should be a valid tuple [type=tuple_type, input_value=[51, -1], input_type=list]
    """
  1. JSON में कोई date या टुपल प्रकार नहीं है, लेकिन Pydantic जानता है कि JSON को सीधे पार्स करते समय क्रमशः स्ट्रिंग और एरे को इनपुट के रूप में अनुमति देता है।
  2. यदि आप समान मानों को model_validate विधि में पास करते हैं, तो Pydantic एक सत्यापन त्रुटि उत्पन्न करेगा क्योंकि strict कॉन्फ़िगरेशन सक्षम है।

V2.5.0 और इसके बाद के संस्करण में, Pydantic JSON डेटा को पार्स करने के लिए jiter , एक तेज़ और पुनरावर्तनीय JSON पार्सर का उपयोग करता है। serde की तुलना में jiter उपयोग करने से प्रदर्शन में मामूली सुधार होता है जो भविष्य में और भी बेहतर हो जाएगा।

jiter JSON पार्सर लगभग पूरी तरह से serde JSON पार्सर के साथ संगत है, जिसमें एक उल्लेखनीय वृद्धि यह है कि jiter inf और NaN मानों के डिसेरिएलाइज़ेशन का समर्थन करता है। भविष्य में, jiter उद्देश्य मूल JSON इनपुट में उस स्थान को शामिल करने के लिए समर्थन सत्यापन त्रुटियों को सक्षम करना है जिसमें अमान्य मान शामिल है।

आंशिक JSON पार्सिंग

v2.7.0 से शुरू होकर , पाइडेंटिक का JSON पार्सर आंशिक JSON पार्सिंग के लिए समर्थन प्रदान करता है, जो pydantic_core.from_json के माध्यम से उजागर होता है। यहां क्रिया में इस सुविधा का एक उदाहरण दिया गया है:

from pydantic_core import from_json

partial_json_data = '["aa", "bb", "c'  # (1)!

try:
    result = from_json(partial_json_data, allow_partial=False)
except ValueError as e:
    print(e)  # (2)!
    #> EOF while parsing a string at line 1 column 15

result = from_json(partial_json_data, allow_partial=True)
print(result)  # (3)!
#> ['aa', 'bb']
  1. JSON सूची अधूरी है - इसमें कोई समापन नहीं है "]
  2. जब allow_partial False (डिफ़ॉल्ट) पर सेट किया जाता है, तो एक पार्सिंग त्रुटि उत्पन्न होती है।
  3. जब allow_partial को True पर सेट किया जाता है, तो इनपुट का हिस्सा सफलतापूर्वक डिसेरिएलाइज़ हो जाता है।

यह आंशिक शब्दकोशों को अक्रमांकित करने के लिए भी काम करता है। उदाहरण के लिए:

from pydantic_core import from_json

partial_dog_json = '{"breed": "lab", "name": "fluffy", "friends": ["buddy", "spot", "rufus"], "age'
dog_dict = from_json(partial_dog_json, allow_partial=True)
print(dog_dict)
#> {'breed': 'lab', 'name': 'fluffy', 'friends': ['buddy', 'spot', 'rufus']}

!!! टिप " LLM आउटपुट को मान्य करना" यह सुविधा LLM आउटपुट को मान्य करने के लिए विशेष रूप से फायदेमंद है। हमने इस विषय पर कुछ ब्लॉग पोस्ट लिखे हैं, जिन्हें आप यहां पा सकते हैं।

पाइडेंटिक के भविष्य के संस्करणों में, हम पाइडेंटिक के अन्य JSON सत्यापन कार्यों के माध्यम से इस सुविधा के लिए समर्थन का विस्तार करने की उम्मीद करते हैं (pydantic.main.BaseModel.model_validate_json और pydantic.type_adapter.TypeAdapter.validate_json) या मॉडल कॉन्फ़िगरेशन। बने रहें 🚀!

अभी के लिए, आप pydantic_core.from_json का उपयोग के साथ संयोजन में कर सकते हैं pydantic.main.BaseModel.model_validate समान परिणाम प्राप्त करने के लिए। यहाँ एक उदाहरण है:

from pydantic_core import from_json

from pydantic import BaseModel


class Dog(BaseModel):
    breed: str
    name: str
    friends: list


partial_dog_json = '{"breed": "lab", "name": "fluffy", "friends": ["buddy", "spot", "rufus"], "age'
dog = Dog.model_validate(from_json(partial_dog_json, allow_partial=True))
print(repr(dog))
#> Dog(breed='lab', name='fluffy', friends=['buddy', 'spot', 'rufus'])

!!! टिप आंशिक JSON पार्सिंग के विश्वसनीय रूप से काम करने के लिए, मॉडल के सभी फ़ील्ड में डिफ़ॉल्ट मान होने चाहिए।

आंशिक JSON पार्सिंग के साथ डिफ़ॉल्ट मानों का उपयोग करने के तरीके के बारे में अधिक गहराई से जानने के लिए निम्नलिखित उदाहरण देखें:

!!! उदाहरण "आंशिक JSON पार्सिंग के साथ डिफ़ॉल्ट मानों का उपयोग करना"

```py
from typing import Any, Optional, Tuple

import pydantic_core
from typing_extensions import Annotated

from pydantic import BaseModel, ValidationError, WrapValidator


def default_on_error(v, handler) -> Any:
    """
    Raise a PydanticUseDefault exception if the value is missing.

    This is useful for avoiding errors from partial
    JSON preventing successful validation.
    """
    try:
        return handler(v)
    except ValidationError as exc:
        # there might be other types of errors resulting from partial JSON parsing
        # that you allow here, feel free to customize as needed
        if all(e['type'] == 'missing' for e in exc.errors()):
            raise pydantic_core.PydanticUseDefault()
        else:
            raise


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


class MyModel(BaseModel):
    foo: Optional[str] = None
    bar: Annotated[
        Optional[Tuple[str, int]], WrapValidator(default_on_error)
    ] = None
    nested: Annotated[
        Optional[NestedModel], WrapValidator(default_on_error)
    ] = None


m = MyModel.model_validate(
    pydantic_core.from_json('{"foo": "x", "bar": ["world",', allow_partial=True)
)
print(repr(m))
#> MyModel(foo='x', bar=None, nested=None)


m = MyModel.model_validate(
    pydantic_core.from_json(
        '{"foo": "x", "bar": ["world", 1], "nested": {"x":', allow_partial=True
    )
)
print(repr(m))
#> MyModel(foo='x', bar=('world', 1), nested=None)
```

कैशिंग स्ट्रिंग्स

v2.7.0 से शुरू होकर , पाइडेंटिक का JSON पार्सर यह कॉन्फ़िगर करने के लिए समर्थन प्रदान करता है कि JSON पार्सिंग और सत्यापन के दौरान पायथन स्ट्रिंग्स को कैसे कैश किया जाता है (जब पायथन स्ट्रिंग्स को पायथन सत्यापन के दौरान रस्ट स्ट्रिंग्स से बनाया जाता है, उदाहरण के लिए strip_whitespace=True के बाद)। cache_strings सेटिंग मॉडल कॉन्फिग और pydantic_core.from_json दोनों के माध्यम से प्रदर्शित होती है।

cache_strings सेटिंग निम्नलिखित में से कोई भी मान ले सकती है:

  • True या 'all' (डिफ़ॉल्ट): सभी स्ट्रिंग्स को कैश करें
  • 'keys' : केवल शब्दकोश कुंजियाँ कैश करें, यह केवल तभी लागू होता है जब pydantic_core.from_json के साथ प्रयोग किया जाता है या जब JSON को Json का उपयोग करके पार्स किया जाता है
  • False या 'none' : कोई कैशिंग नहीं

स्ट्रिंग कैशिंग सुविधा का उपयोग करने से प्रदर्शन में सुधार होता है, लेकिन मेमोरी उपयोग थोड़ा बढ़ जाता है।

!!! नोट "स्ट्रिंग कैशिंग विवरण"

1. Strings are cached using a fully associative cache with a size of
[16,384](https://github.com/pydantic/jiter/blob/5bbdcfd22882b7b286416b22f74abd549c7b2fd7/src/py_string_cache.rs#L113).
2. Only strings where `len(string) < 64` are cached.
3. There is some overhead to looking up the cache, which is normally worth it to avoid constructing strings.
However, if you know there will be very few repeated strings in your data, you might get a performance boost by disabling this setting with `cache_strings=False`.

JSON क्रमांकन

??? एपीआई "एपीआई दस्तावेज़ीकरण" pydantic.main.BaseModel.model_dump_json
pydantic.type_adapter.TypeAdapter.dump_json
pydantic_core.to_json

JSON क्रमांकन पर अधिक जानकारी के लिए, क्रमांकन अवधारणा पृष्ठ देखें।

本文总阅读量次