!!! Warnung „🚧 Work in Progress“ Diese Seite ist in Arbeit.

JSON¶

Json-Parsing¶

??? API „API-Dokumentation“ pydantic.main.BaseModel.model_validate_json pydantic.type_adapter.TypeAdapter.validate_json pydantic_core.from_json

Pydantic bietet integriertes JSON-Parsing, mit dem Folgendes erreicht werden kann:

Erhebliche Leistungsverbesserungen ohne die Kosten für die Nutzung einer Drittanbieter-Bibliothek
Unterstützung für benutzerdefinierte Fehler
Unterstützung strict Spezifikationen

Hier ist ein Beispiel für die integrierte JSON-Analyse von Pydantic über die Methode model_validate_json, die die Unterstützung für strict Spezifikationen beim Parsen von JSON-Daten zeigt, die nicht mit den Typanmerkungen des Modells übereinstimmen:

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]
    """

JSON hat keine date oder Tupeltypen, aber Pydantic weiß, dass dies Strings und Arrays als Eingaben zulässt, wenn JSON direkt analysiert wird.
Wenn Sie dieselben Werte an die Methode model_validate übergeben, löst Pydantic einen Validierungsfehler aus, da die strict Konfiguration aktiviert ist.

In Version 2.5.0 und höher verwendet Pydantic jiter , einen schnellen und iterierbaren JSON-Parser, um JSON-Daten zu analysieren. Die Verwendung jiter im Vergleich zu serde führt zu bescheidenen Leistungsverbesserungen, die in Zukunft noch besser werden.

Der jiter -JSON-Parser ist fast vollständig mit dem serde JSON-Parser kompatibel. Eine bemerkenswerte Verbesserung besteht darin, dass jiter die Deserialisierung von inf und NaN -Werten unterstützt. Zukünftig soll jiter es Support-Validierungsfehlern ermöglichen, die Position in der ursprünglichen JSON-Eingabe einzubeziehen, die den ungültigen Wert enthielt.

Teilweise JSON-Analyse¶

Ab v2.7.0 bietet der JSON-Parser von Pydantic Unterstützung für teilweises JSON-Parsing, das über pydantic_core.from_json verfügbar gemacht wird. Hier ist ein Beispiel dieser Funktion in Aktion:

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

Die JSON-Liste ist unvollständig – es fehlt ein abschließendes "]
Wenn allow_partial auf False (Standardeinstellung) gesetzt ist, tritt ein Analysefehler auf.
Wenn allow_partial auf True gesetzt ist, wird ein Teil der Eingabe erfolgreich deserialisiert.

Dies funktioniert auch für die Deserialisierung von Teilwörterbüchern. Zum Beispiel:

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']}

!!! Tipp „ LLM Ausgabe validieren“ Diese Funktion ist besonders nützlich für die Validierung LLM Ausgaben. Wir haben einige Blogbeiträge zu diesem Thema geschrieben, die Sie hier finden.

Wir gehen davon aus, dass wir in zukünftigen Versionen von Pydantic die Unterstützung für diese Funktion durch die anderen JSON-Validierungsfunktionen von Pydantic erweitern werden (pydantic.main.BaseModel.model_validate_json und pydantic.type_adapter.TypeAdapter.validate_json) oder Modellkonfiguration. Bleiben Sie dran 🚀!

Im Moment können Sie pydantic_core.from_json in Kombination mit verwenden pydantic.main.BaseModel.model_validate, um das gleiche Ergebnis zu erzielen. Hier ist ein Beispiel:

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'])

!!! Tipp Damit die teilweise JSON-Analyse zuverlässig funktioniert, sollten alle Felder im Modell Standardwerte haben.

Schauen Sie sich das folgende Beispiel an, um einen detaillierteren Einblick in die Verwendung von Standardwerten bei teilweiser JSON-Analyse zu erhalten:

!!! Beispiel „Standardwerte mit teilweiser JSON-Analyse verwenden“

```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)
```

Zeichenfolgen zwischenspeichern¶

Ab v2.7.0 bietet der JSON-Parser von Pydantic Unterstützung für die Konfiguration, wie Python-Strings während der JSON-Analyse und -Validierung zwischengespeichert werden (wenn Python-Strings während der Python-Validierung aus Rust-Strings erstellt werden, z. B. nach strip_whitespace=True ). Die Einstellung cache_strings wird sowohl über model config als auch über pydantic_core.from_json verfügbar gemacht.

Die Einstellung cache_strings kann einen der folgenden Werte annehmen:

True oder 'all' (Standard): Alle Zeichenfolgen zwischenspeichern
'keys' : Nur Wörterbuchschlüssel zwischenspeichern. Dies gilt nur bei Verwendung mit pydantic_core.from_json oder beim Parsen von JSON mit Json
False oder 'none' : kein Caching

Die Verwendung der String-Caching-Funktion führt zu Leistungsverbesserungen, erhöht jedoch die Speichernutzung geringfügig.

!!! Hinweis „Details zum String-Caching“

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-Serialisierung¶

??? API „API-Dokumentation“ pydantic.main.BaseModel.model_dump_json
pydantic.type_adapter.TypeAdapter.dump_json
pydantic_core.to_json

Weitere Informationen zur JSON-Serialisierung finden Sie auf der Seite Serialisierungskonzepte .

本文总阅读量次