Validierungsfehler

Pydantic versucht, nützliche Validierungsfehler bereitzustellen. Nachfolgend finden Sie Details zu häufigen Validierungsfehlern, die bei der Arbeit mit pydantic auftreten können, sowie einige Vorschläge zu deren Behebung.

`arguments_type`¶

Dieser Fehler wird ausgelöst, wenn ein Objekt, das während der Validierung als Argumente an eine Funktion übergeben würde, kein tuple , list oder dict ist. Da NamedTuple in seiner Implementierung Funktionsaufrufe verwendet, ist dies eine Möglichkeit, diesen Fehler zu erzeugen:

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'

`assertion_error`¶

Dieser Fehler wird ausgelöst, wenn während der Validierung eine fehlerhafte assert -Anweisung auftritt:

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'

`bool_parsing`¶

Dieser Fehler wird ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, die für die Umwandlung in einen booleschen Wert nicht gültig ist:

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_type`¶

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein bool Feld nicht gültig ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von bool ist.

`bytes_too_long`¶

Dieser Fehler wird ausgelöst, wenn die Länge eines bytes größer ist als die max_length Einschränkung des Felds:

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_too_short`¶

Dieser Fehler wird ausgelöst, wenn die Länge eines bytes kleiner als die min_length Einschränkung des Felds ist:

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_type`¶

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein bytes nicht gültig ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von bytes ist.

`callable_type`¶

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht als Callable gültig ist:

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

Dieser Fehler wird ausgelöst, wenn eine Datenklasse mit strict=True validiert wird und die Eingabe keine Instanz der Datenklasse ist:

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_type`¶

Dieser Fehler wird ausgelöst, wenn der Eingabewert für ein dataclass ungültig ist:

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

Dieser Fehler wird ausgelöst, wenn der für ein Datumsfeld bereitgestellte Eingabewert für datetime date eine Zeitkomponente ungleich Null aufweist. Damit ein Zeitstempel in ein Feld vom Typ date analysiert werden kann, müssen alle Zeitkomponenten Null sein:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, die nicht für ein date analysiert werden kann:

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

Dieser Fehler wird ausgelöst, wenn der für ein FutureDate -Feld bereitgestellte Eingabewert nicht in der Zukunft liegt:

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

Dieser Fehler wird bei der Validierung von JSON ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, die nicht für ein date geparst werden kann:

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

Dieser Fehler wird ausgelöst, wenn der für ein PastDate -Feld bereitgestellte Wert nicht in der Vergangenheit liegt:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein date ungültig ist:

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'

Dieser Fehler wird auch bei strikten Feldern ausgelöst, wenn der Eingabewert keine Instanz von date ist.

`datetime_from_date_parsing`¶

!!! Hinweis In v2.6.0 wird Unterstützung für diesen Fehler sowie Unterstützung für das Parsen von Datums- und Uhrzeitangaben aus dem Datum yyyy-MM-DD hinzugefügt

Dieser Fehler wird ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, die nicht für ein datetime -Feld analysiert werden kann:

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

Dieser Fehler wird ausgelöst, wenn der für ein FutureDatetime -Feld bereitgestellte Wert nicht in der Zukunft liegt:

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

Dieser Fehler wird ausgelöst, wenn etwas am datetime -Objekt ungültig ist:

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

Dieser Fehler wird ausgelöst, wenn der Wert eine Zeichenfolge ist, die nicht für ein datetime -Feld analysiert werden kann:

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

Dieser Fehler wird ausgelöst, wenn der für ein PastDatetime -Feld bereitgestellte Wert nicht in der Vergangenheit liegt:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein datetime -Feld ungültig ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von datetime ist.

`decimal_max_digits`¶

Dieser Fehler wird ausgelöst, wenn der für eine Decimal angegebene Wert zu viele Ziffern aufweist:

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

Dieser Fehler wird ausgelöst, wenn der für eine Decimal angegebene Wert zu viele Stellen nach dem Dezimalpunkt aufweist:

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

Dieser Fehler wird ausgelöst, wenn der für eine Decimal angegebene Wert nicht als Dezimalzahl geparst werden konnte:

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

Dieser Fehler wird ausgelöst, wenn der für eine Decimal angegebene Wert vom falschen Typ ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von Decimal ist.

`decimal_whole_digits`¶

Dieser Fehler wird ausgelöst, wenn der für eine Decimal angegebene Wert mehr Ziffern vor dem Dezimalpunkt hat als max_digits - decimal_places (sofern beide angegeben sind):

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von Decimal ist.

`dict_type`¶

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein dict nicht dict ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert in den Elementen eines enum nicht vorhanden ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert zusätzliche Felder enthält, aber 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'

Weitere Informationen zur extra Konfiguration finden Sie im Abschnitt Zusätzliche Attribute.

`finite_number`¶

Dieser Fehler wird ausgelöst, wenn der Wert unendlich oder zu groß ist, um während der Validierung als 64-Bit-Gleitkommazahl dargestellt zu werden:

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

Dieser Fehler wird ausgelöst, wenn der Wert eine Zeichenfolge ist, die nicht als float geparst werden kann:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein float -Feld nicht gültig ist:

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

Dieser Fehler wird ausgelöst, wenn Sie versuchen, einem Feld mit frozen=True einen Wert zuzuweisen oder ein solches Feld zu löschen:

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

Dieser Fehler wird ausgelöst, wenn model_config['frozen] == True und Sie versuchen, eines der Felder zu löschen oder ihm einen neuen Wert zuzuweisen:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein frozenset -Feld nicht gültig ist:

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

Dieser Fehler wird ausgelöst, wenn model_config['from_attributes'] == True und beim Lesen der Attribute wird ein Fehler ausgelöst:

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

Dieser Fehler wird ausgelöst, wenn der Wert nicht größer als die gt -Einschränkung des Feldes ist:

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

Dieser Fehler wird ausgelöst, wenn der Wert nicht größer oder gleich der ge Einschränkung des Feldes ist:

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

Dieser Fehler wird ausgelöst, wenn Sie einen float Wert für ein int -Feld angeben:

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

Dieser Fehler wird ausgelöst, wenn der Wert nicht als int geparst werden kann:

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

Dieser Fehler wird ausgelöst, wenn versucht wird, einen Python- oder JSON-Wert aus einer Zeichenfolge zu analysieren, die außerhalb des maximalen Bereichs liegt, den die Python- str zu int -Analyse zulässt:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein int -Feld nicht gültig ist:

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

Dieser Fehler wird ausgelöst, wenn versucht wird, ein dict zu validieren, dessen Schlüssel keine Instanz von str ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert keine Instanz des erwarteten Typs ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert keine Unterklasse des erwarteten Typs ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht als Iterable gültig ist:

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

Dieser Fehler wird ausgelöst, wenn während der Iteration ein Fehler auftritt:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert keine gültige JSON-Zeichenfolge ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert von einem Typ ist, der nicht als JSON geparst werden kann:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht kleiner als die lt Beschränkung des Feldes ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht kleiner oder gleich der le des Feldes ist:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein list ungültig ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht einer der erwarteten Literalwerte ist:

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

Dieser Fehler wird ausgelöst, wenn während der Validierung aufgrund eines Fehlers beim Aufruf der Methoden aus dem Mapping -Protokoll ein Problem auftritt, z. B. .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`¶

Dieser Fehler wird ausgelöst, wenn erforderliche Felder im Eingabewert fehlen:

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

Dieser Fehler wird ausgelöst, wenn ein erforderliches Positions- oder Schlüsselwortargument nicht an eine mit validate_call dekorierte Funktion übergeben wird:

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

Dieser Fehler wird ausgelöst, wenn ein erforderliches Argument, das nur aus Schlüsselwörtern besteht, nicht an eine Funktion übergeben wird, die mit validate_call versehen ist:

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

Dieser Fehler wird ausgelöst, wenn ein erforderliches Nur-Positionsargument nicht an eine mit validate_call dekorierte Funktion übergeben wird:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert kein gültiges Wörterbuch, keine gültige Modellinstanz oder Instanz ist, aus der Felder extrahiert werden können:

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

Dieser Fehler wird ausgelöst, wenn die Eingabe in ein Modell keine Instanz des Modells oder Diktats ist:

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

Dieser Fehler wird ausgelöst, wenn Sie mehrere Werte für ein einzelnes Argument angeben, während Sie eine mit validate_call dekorierte Funktion aufrufen:

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

Dieser Fehler wird ausgelöst, wenn die Eingabe kein Vielfaches der multiple_of Einschränkung eines Feldes ist:

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

Dieser Fehler wird ausgelöst, wenn validate_assignment=True in der Konfiguration und Sie versuchen, einem Attribut, das kein vorhandenes Feld ist, einen Wert zuzuweisen:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht None für ein Feld ist, das None erfordert:

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'

!!! Hinweis Dieser Fehler kann auftreten, wenn in Ihrem Modell eine Namenskollision zwischen einem Feldnamen und seinem Typ vorliegt. Genauer gesagt wird dieser Fehler wahrscheinlich ausgelöst, wenn der Standardwert dieses Felds None ist.

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

Dieser Fehler wird ausgelöst, wenn eine zyklische Referenz erkannt wird:

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

Dieser Fehler wird ausgelöst, wenn der Werttyp für ein set Feld ungültig ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht mit der pattern des Feldes übereinstimmt:

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

Dieser Fehler wird ausgelöst, wenn der Wert eine Instanz eines strikten Untertyps von str ist und das Feld strikt ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, deren Länge größer als die max_length Einschränkung des Feldes ist:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, deren Länge kleiner als die min_length des Felds ist:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein str Feld nicht gültig ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von str ist.

`string_unicode`¶

Dieser Fehler wird ausgelöst, wenn der Wert nicht als Unicode-Zeichenfolge analysiert werden kann:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, die nicht für ein timedelta -Feld analysiert werden kann:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein timedelta Feld nicht gültig ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von timedelta ist.

`time_parsing`¶

Dieser Fehler wird ausgelöst, wenn der Eingabewert eine Zeichenfolge ist, die für ein time nicht analysiert werden kann:

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

Dieser Fehler wird ausgelöst, wenn der Werttyp für ein time ungültig ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine time ist.

`timezone_aware`¶

Dieser Fehler wird ausgelöst, wenn der datetime Wert, der für ein datetime -Feld mit Zeitzonenerkennung bereitgestellt wird, keine Zeitzoneninformationen enthält:

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

Dieser Fehler wird ausgelöst, wenn der für ein Zeitzonen-naives datetime bereitgestellte datetime Wert Zeitzoneninformationen enthält:

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

Dieser Fehler wird ausgelöst, wenn die Länge des Eingabewerts größer ist als die max_length Einschränkung des Feldes:

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

Dieser Fehler wird ausgelöst, wenn die Wertlänge kleiner als die min_length des Felds ist:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein tuple ungültig ist:

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'

Dieser Fehler wird auch für strikte Felder ausgelöst, wenn der Eingabewert keine Instanz von tuple ist.

`unexpected_keyword_argument`¶

Dieser Fehler wird ausgelöst, wenn Sie einen Wert per Schlüsselwort für ein Nur-Positionsargument angeben, während Sie eine mit validate_call dekorierte Funktion aufrufen:

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'

Es wird auch bei Verwendung von pydantic.dataclasses und extra=forbid ausgelöst:

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

Dieser Fehler wird ausgelöst, wenn Sie einen Positionswert für ein Nur-Schlüsselwort-Argument angeben, während Sie eine mit validate_call dekorierte Funktion aufrufen:

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

Dieser Fehler wird ausgelöst, wenn der Diskriminator der Eingabe nicht einem der erwarteten Werte entspricht:

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

Dieser Fehler wird ausgelöst, wenn es nicht möglich ist, einen Diskriminatorwert aus der Eingabe zu extrahieren:

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

Dieser Fehler wird ausgelöst, wenn der Eingabewert nicht als URL geparst werden kann:

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

Dieser Fehler wird ausgelöst, wenn das URL-Schema für den URL-Typ des Felds nicht gültig ist:

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

Dieser Fehler wird ausgelöst, wenn die URL-Syntax ungültig ist:

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

Dieser Fehler wird ausgelöst, wenn die URL-Länge größer als 2083 ist:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein URL-Feld nicht gültig ist:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts für ein UUID-Feld nicht gültig ist:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts keine gültige Instanz für ein UUID-Feld (str, bytes oder UUID) ist:

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

Dieser Fehler wird ausgelöst, wenn der Typ des Eingabewerts nicht mit der UUID-Version übereinstimmt:

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

Dieser Fehler wird ausgelöst, wenn während der Validierung ein ValueError auftritt:

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'

本文总阅读量次

Validierungsfehler

arguments_type¶

assertion_error¶

bool_parsing¶

bool_type¶

bytes_too_long¶

bytes_too_short¶

bytes_type¶

callable_type¶

dataclass_exact_type¶

dataclass_type¶

date_from_datetime_inexact¶

date_from_datetime_parsing¶

date_future¶

date_parsing¶

date_past¶

date_type¶

datetime_from_date_parsing¶

datetime_future¶

datetime_object_invalid¶

datetime_parsing¶

datetime_past¶

datetime_type¶

decimal_max_digits¶

decimal_max_places¶

decimal_parsing¶

decimal_type¶

decimal_whole_digits¶

dict_type¶

enum¶

extra_forbidden¶

finite_number¶

float_parsing¶

float_type¶

frozen_field¶

frozen_instance¶

frozen_set_type¶

get_attribute_error¶

greater_than¶

greater_than_equal¶

int_from_float¶

int_parsing¶

int_parsing_size¶

int_type¶

invalid_key¶

is_instance_of¶

is_subclass_of¶

iterable_type¶

iteration_error¶

json_invalid¶

json_type¶

less_than¶

less_than_equal¶

list_type¶

literal_error¶

mapping_type¶

missing¶

missing_argument¶

missing_keyword_only_argument¶

missing_positional_only_argument¶

model_attributes_type¶

model_type¶

multiple_argument_values¶

multiple_of¶

no_such_attribute¶

none_required¶

recursion_loop¶

set_type¶

string_pattern_mismatch¶

string_sub_type¶

string_too_long¶

string_too_short¶

string_type¶

string_unicode¶

time_delta_parsing¶

time_delta_type¶

time_parsing¶

time_type¶

timezone_aware¶

timezone_naive¶