U Qh93@s6UdZddlmZddlZddlZddlmZddlm Z mZm Z m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZmZmZddlmZejd krdd lmZn dd lmZejd krdd lmZmZm Z ndd lmZmZm Z ejd krddlm!Z!n ddlm!Z!er$ddl"m#Z#n.zddl"m#Z#Wne$k rPe%Z#YnXe!dZ&GdddeddZ'dZ(de)d<GdddeZ*Gddde*eZ+GdddeZ,e!dZ-Gdd d eddZ.d!d d"d#d$Z/eegefZ0eee*gefZ1eeegefZ2eeee+gefZ3ee0e1e2e3fZ4e!d%Z5Gd&d'd'eddZ6dddd(d)d*d+d+d,d-d'd.d/d0Z7Gd1d2d2eZ8eee8gefZ9eee8e*gefZ:eeee8gefZ;eeee8e+gefZddddd(d5d6d+d+d,d,d-d4d7d8d9Z?Gd:d;d;eddZ@dd-d;d?d@dAZAGdBdCdCeddZBde@eBeDfZFGdNdOdOeddZGddPdQdOdRdSdTZHGdUdVdVeddZIdddWd>dJdPdQdVdXdYdZZJGd[d\d\eddZKdddd]dPdQd^d\d_d`daZLGdbdcdceddZMdddd]dPdQd^dcd_dddeZNGdfdgdgeddZOdd+dPdQd^dgdhdidjZPGdkdldleddZQddddddddddm dndndndndnd+dPdQd^dldo dpdqZRGdrdsdseddZSdddddddddddt d+dududududud+dPdQd^dsdv dwdxZTGdydzdzeddZUddddddddddddd{ d+d|d|d|d|d|dndnd+dPdQd^dzd} d~dZVGdddeddZWdddddd+dPdQd^ddhddZXGdddeddZYddddddddddddd ddndnd+d+d+dd+d+dPdQd^dd ddZZGdddeddZ[ddddddddndnd+dPdQd^ddddZ\GdddeddZ]ddddddddddd d+ddddddndPdQd^dd ddZ^GdddeddZ_ddddddddddd d+dddddddPdQd^dd ddZ`GdddeddZaddddddddddddd d+dddddddnddPdQd^dd ddZbGdddeddZcdddddddddd d+ddddddPdQd^dd ddZdGdddeddZedddd]ddPdQd^ddddZfGdddeddZgdddddddddddd+dPdQd^dd ddZhe!dZiGddĄdeddZjdddddŜddPdPdQd^ddƜddȄZkGddʄdeddZldddddŜdIdPdPdQd^ddƜdd̄ZmGdd΄deddZndddd]dPdQd^dd_ddЄZoGdd҄deddZpddddddӜdd+dPdQd^dd՜ddׄZqGddلdeddZrdddڜddddܜddބZseereFfZtGdddeddZudddddddddd,dndnd+d+dPdQddd ddZvdddddddd,d+dPdQdddddZwd dddddddd,dndnd+dPdQdddddZxGdddeddZydddddddddddndndnd+d+dPdQddd ddZzGdddeddZ{d ddddddddd,dndnd+d+dPdQd^dd ddZ|GdddeddZ}d ddddddddd,dndnd+d+dPdQd^dd ddZ~GdddeddZd ddddddd,dndndPdQdddddZeeeefZGdddeddZdddڜddddܜddZeeeFfZGdd d eddZd dddddddd,d,dndnd+dPdQd^d d d d ZeegefZGd ddeZeee,gefZGdddeddZeeefZGdddeddZGdddeddZdddddddJdPd,dQd^ddddZddddddddJdPdPd,dQd^ddddZGdd d eddZdddddddJdPd,dQd^d dd!d"Zddddd#ddJdPdPdQd^d d$d%d&ZGd'd(d(eZeeegefZGd)d*d*eZeeee,gefZGd+d,d,eddZeeefZGd-d.d.eddZdddddd/dJdPd,dQd^d.dd0d1Zdddddd2d3dJdPd,dPdQd^d.d4d5d6ZGd7d8d8eddZdddddddPd,dQd^d8d9d:d;ZddddddddPdPd,dQd^d8d<d=d>ZGd?d@d@eddZe#dddddddddA dJddBd+dCd+d+dPdQd^d@dD dEdFZGdGdHdHeddZddddddJd+dPdQd^dHdIdJdKZGdLdMdMeddZddddddddddN dOd+dPdPdPdQd+dPdQd^dMdR dSdTZGdUdVdVeddZdddddddddWdXdYdPdPdZd+d+dPdQd^dVd[ d\d]ZGd^d_d_eddZdddd]ddPdQd^d_d`dadbZGdcddddeddZddddddJdJd+dPdQd^dddedfdgZGdhdidieddZdddd]dJdJdPdQd^didjdkdlZGdmdndneddZddddddodJd+dpdPd+dQdndqdrdsZGdtdudueddZddddddddddddv dwdxdyd+d,dzd+d+dPdQd^d{dud| d}d~ZGdddeddZdddddddJdpdPd+d+dQddddZGdddeddZddddddddddd ddPdyd+d,dzd+d+dPdQd^dd ddZGdddeddZddddddddddddd dIdJdxd+d+dPdd+d+dzd{dPdQd^ddddZGdddeddZdddddddddd>dJd+d+d+dpdPd+dQd+dd ddZGdddeddZddddddddd>ddd+d+dPdQd^dzdd ddZGdddeddZdddddddddddd dIdJddxdPd+dd+dPdQd^d+d+d{ddddZGdddeddZdddd>dJddpddddZe!dZde)d<GdddeddZdddddddddd+d,dd,dPdQd^dd ddZGdddeddZdddddddJddPd,dPdQd^ddddZGdddeddZddddddœdJd>dPddPdQd^ddĜdŐdƄZGdǐdȄdeddZȐddddd]d,dPdQd^dȐdɜdʐd˄ZGd̐d̈́deddZdddddddddddΜ dndd+dPdndPd+dPdQd^d͐dМ dѐd҄ZGdӐdԄdeddZdddddddddddΜ dndd+dPdndPd+dPdQd^dԐdМ dՐdքZGdאd؄deddZdJddؐdٜdڐdۄZGdܐd݄deddZАdd>dPdQd^dݐdޜdߐdZdZeҐseeGeKeMeOeQeSeUeYe[e]e_eaeceeegejeleneueye{e}eeeeeeeeeeeeeeeeeeeeeeeeeeepeWf2Zne!dZe!dZe!dZdddddZeddd>dJdddZedddZeddd>dJdddZedddZedd3d>dJdddZedddZeddd>dddZedddZe,eeedZere,Zd>ddddZdS(ze This module contains definitions to build schemas which `pydantic_core` can validate and serialize. ) annotationsN)Mapping)datedatetimetime timedelta)Decimal) TYPE_CHECKINGAnyCallableDictHashableListPatternSetTupleTypeUnion) deprecated) ) TypedDict)r )ProtocolRequired TypeAlias)r )Literal)PydanticUndefined)ZallowZforbidignorec@seZdZUdZded<ded<ded<ded<ded <ded <d ed <ded <ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<d ed!<d"ed#<d$S)% CoreConfigat Base class for schema configuration options. Attributes: title: The name of the configuration. strict: Whether the configuration should strictly adhere to specified rules. extra_fields_behavior: The behavior for handling extra fields. typed_dict_total: Whether the TypedDict should be considered total. Default is `True`. from_attributes: Whether to use attributes for models, dataclasses, and tagged union keys. loc_by_alias: Whether to use the used alias (or first alias for "field required" errors) instead of `field_names` to construct error `loc`s. Default is `True`. revalidate_instances: Whether instances of models and dataclasses should re-validate. Default is 'never'. validate_default: Whether to validate default values during validation. Default is `False`. populate_by_name: Whether an aliased field may be populated by its name as given by the model attribute, as well as the alias. (Replaces 'allow_population_by_field_name' in Pydantic v1.) Default is `False`. str_max_length: The maximum length for string fields. str_min_length: The minimum length for string fields. str_strip_whitespace: Whether to strip whitespace from string fields. str_to_lower: Whether to convert string fields to lowercase. str_to_upper: Whether to convert string fields to uppercase. allow_inf_nan: Whether to allow infinity and NaN values for float fields. Default is `True`. ser_json_timedelta: The serialization option for `timedelta` values. Default is 'iso8601'. ser_json_bytes: The serialization option for `bytes` values. Default is 'utf8'. ser_json_inf_nan: The serialization option for infinity and NaN values in float fields. Default is 'null'. val_json_bytes: The validation option for `bytes` values, complementing ser_json_bytes. Default is 'utf8'. hide_input_in_errors: Whether to hide input data from `ValidationError` representation. validation_error_cause: Whether to add user-python excs to the __cause__ of a ValidationError. Requires exceptiongroup backport pre Python 3.11. coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode). regex_engine: The regex engine to use for regex pattern validation. Default is 'rust-regex'. See `StringSchema`. cache_strings: Whether to cache strings. Default is `True`, `True` or `'all'` is required to cache strings during general validation since validators don't know if they're in a key or a value. strtitleboolstrict ExtraBehaviorZextra_fields_behaviorZtyped_dict_totalfrom_attributesZ loc_by_alias2Literal[('always', 'never', 'subclass-instances')]revalidate_instancesvalidate_defaultpopulate_by_nameintZstr_max_lengthZstr_min_lengthZstr_strip_whitespaceZ str_to_lowerZ str_to_upper allow_inf_nanzLiteral[('iso8601', 'float')]Zser_json_timedeltaz"Literal[('utf8', 'base64', 'hex')]Zser_json_bytesz)Literal[('null', 'constants', 'strings')]Zser_json_inf_nanZval_json_bytesZhide_input_in_errorsZvalidation_error_causecoerce_numbers_to_str$Literal[('rust-regex', 'python-re')] regex_enginez-Union[bool, Literal[('all', 'keys', 'none')]]Z cache_stringsN)__name__ __module__ __qualname____doc____annotations__r5r5?./venv/lib/python3.8/site-packages/pydantic_core/core_schema.pyr /s2 #r F)totalz2set[int | str] | dict[int | str, IncExCall] | Noner IncExCallc@seZdZeddddZeddddZedddd Zed dd d Zed dddZed dddZ ed dddZ ed dddZ ed dddZ d dddZ d dddZd dddZd dddZd S)!SerializationInfor8returncCsdSNr5selfr5r5r6include|szSerializationInfo.includecCsdSr<r5r=r5r5r6excludeszSerializationInfo.exclude Any | NonecCsdS)zCurrent serialization context.Nr5r=r5r5r6contextszSerializationInfo.contextr!cCsdSr<r5r=r5r5r6modeszSerializationInfo.moder#cCsdSr<r5r=r5r5r6by_aliasszSerializationInfo.by_aliascCsdSr<r5r=r5r5r6 exclude_unsetszSerializationInfo.exclude_unsetcCsdSr<r5r=r5r5r6exclude_defaultssz"SerializationInfo.exclude_defaultscCsdSr<r5r=r5r5r6 exclude_noneszSerializationInfo.exclude_nonecCsdSr<r5r=r5r5r6serialize_as_anysz"SerializationInfo.serialize_as_anycCsdSr<r5r=r5r5r6 round_tripzSerializationInfo.round_tripcCsdSr<r5r=r5r5r6 mode_is_jsonrJzSerializationInfo.mode_is_jsoncCsdSr<r5r=r5r5r6__str__rJzSerializationInfo.__str__cCsdSr<r5r=r5r5r6__repr__rJzSerializationInfo.__repr__N)r0r1r2propertyr?r@rBrCrDrErFrGrHrIrKrLrMr5r5r5r6r9{s,r9c@seZdZeddddZdS)FieldSerializationInfor!r:cCsdSr<r5r=r5r5r6 field_namesz!FieldSerializationInfo.field_nameN)r0r1r2rNrPr5r5r5r6rOsrOc@sjeZdZdZeddddZeddddZed dd d Zed dd dZeddddZ dS)ValidationInfoz2 Argument passed to validation functions. rAr:cCsdS)zCurrent validation context.Nr5r=r5r5r6rBszValidationInfo.contextCoreConfig | NonecCsdS)z/The CoreConfig that applies to this validation.Nr5r=r5r5r6configszValidationInfo.configzLiteral[('python', 'json')]cCsdS)z2The type of input data we are currently validatingNr5r=r5r5r6rCszValidationInfo.modeDict[str, Any]cCsdS)z(The data being validated for this model.Nr5r=r5r5r6dataszValidationInfo.data str | NonecCsdS)zw The name of the current field being validated if this validator is attached to a model field. Nr5r=r5r5r6rPszValidationInfo.field_nameN) r0r1r2r3rNrBrSrCrUrPr5r5r5r6rQsrQ)noner+r#floatr!bytes bytearraylisttupleset frozenset generatordictrrrrurlmulti-host-urljsonuuidanyc@seZdZUded<dS)SimpleSerSchemaz$Required[ExpectedSerializationTypes]typeNr0r1r2r4r5r5r5r6rfs rfExpectedSerializationTypes)rgr;cCs t|dS)z{ Returns a schema for serialization with a custom type. Args: type: The type to use for serialization rg)rfrjr5r5r6simple_ser_schemasrk)alwaysz unless-nonercjson-unless-nonec@s>eZdZUded<ded<ded<ded<ded <d ed <d S) PlainSerializerFunctionSerSchema#Required[Literal['function-plain']]rgzRequired[SerializerFunction]functionr#is_field_serializerinfo_arg CoreSchema return_schemaWhenUsed when_usedNrhr5r5r5r6rn s rnrl)rqrrrtrvSerializerFunctionz bool | NonezCoreSchema | Noneru)rprqrrrtrvr;cCs |dkr d}td|||||dS)a Returns a schema for serialization with a function, can be either a "general" or "field" function. Args: function: The function to use for serialization is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument, and `info` includes `field_name` info_arg: Whether the function takes an `info` argument return_schema: Schema to use for serializing return value when_used: When the function should be called rlNfunction-plain)rgrprqrrrtrv_dict_not_none)rprqrrrtrvr5r5r6$plain_serializer_function_ser_schemasr{c@s eZdZdddddddZdS)SerializerFunctionWrapHandlerNr zint | str | None) input_value index_keyr;cCsdSr<r5)r>r}r~r5r5r6__call__4rJz&SerializerFunctionWrapHandler.__call__)Nr0r1r2rr5r5r5r6r|3sr|c@sFeZdZUded<ded<ded<ded<ded <ded <d ed <d S)WrapSerializerFunctionSerSchema"Required[Literal['function-wrap']]rgz Required[WrapSerializerFunction]rpr#rqrrrsschemartrurvNrhr5r5r5r6rGs r)rqrrrrtrvWrapSerializerFunction)rprqrrrrtrvr;c Cs"|dkr d}td||||||dS)aE Returns a schema for serialization with a wrap function, can be either a "general" or "field" function. Args: function: The function to use for serialization is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument, and `info` includes `field_name` info_arg: Whether the function takes an `info` argument schema: The schema to use for the inner serialization return_schema: Schema to use for serializing return value when_used: When the function should be called rlN function-wrap)rgrprqrrrrtrvry)rprqrrrrtrvr5r5r6#wrap_serializer_function_ser_schemaQsrc@s&eZdZUded<ded<ded<dS)FormatSerSchemazRequired[Literal['format']]rg Required[str]formatting_stringrurvNrhr5r5r5r6rts rrm)rvr!)rrvr;cCs|dkr d}td||dS)z Returns a schema for serialization using python's `format` method. Args: formatting_string: String defining the format to use when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default rmNformat)rgrrvry)rrvr5r5r6format_ser_schemazsrc@seZdZUded<ded<dS)ToStringSerSchemazRequired[Literal['to-string']]rgrurvNrhr5r5r5r6rs r)rvr;cCstdd}|dkr||d<|S)z Returns a schema for serialization using python's `str()` / `__str__` method. Args: when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default z to-stringrjrmrv)r`)rvsr5r5r6to_string_ser_schemas rc@s&eZdZUded<ded<ded<dS)ModelSerSchemaRequired[Literal['model']]rgRequired[Type[Any]]clsRequired[CoreSchema]rNrhr5r5r5r6rs r Type[Any]rs)rrr;cCstd||dS)z Returns a schema for serialization using a model. Args: cls: The expected class type, used to generate warnings if the wrong type is passed schema: Internal schema to use to serialize the model dict model)rgrr)r)rrr5r5r6model_ser_schemasrc@s.eZdZUded<ded<ded<ded<d S) InvalidSchemazRequired[Literal['invalid']]rgr!refrTmetadata SerSchema serializationNrhr5r5r5r6rs rrVzDict[str, Any] | None)rrr;cCstd||dS)a] Returns an invalid schema, used to indicate that a schema is invalid. Returns a schema that matches any value, e.g.: Args: ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core invalid)rgrrry)rrr5r5r6invalid_schemas rc@s6eZdZUded<ded<ded<ded<d ed <d S) ComputedFieldz#Required[Literal['computed-field']]rgr property_namerrtr!aliasrTrNrhr5r5r5r6rs r)rr)rrtrrr;cCstd||||dS)a ComputedFields are properties of a model or dataclass that are included in serialization. Args: property_name: The name of the property on the model or dataclass return_schema: The schema used for the type returned by the computed field alias: The name to use in the serialized output metadata: Any other information you want to include with the schema, not used by pydantic-core computed-field)rgrrtrrry)rrtrrr5r5r6computed_fields rc@s.eZdZUded<ded<ded<ded<d S) AnySchemazRequired[Literal['any']]rgr!rrTrrrNrhr5r5r5r6rs rrrrzSerSchema | None)rrrr;cCstd|||dS)a Returns a schema that matches any value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.any_schema() v = SchemaValidator(schema) assert v.validate_python(1) == 1 ``` Args: ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rergrrrryrr5r5r6 any_schemasrc@s.eZdZUded<ded<ded<ded<d S) NoneSchemazRequired[Literal['none']]rgr!rrTrrrNrhr5r5r5r6rs rcCstd|||dS)a Returns a schema that matches a None value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.none_schema() v = SchemaValidator(schema) assert v.validate_python(None) is None ``` Args: ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rWrryrr5r5r6 none_schema src@s6eZdZUded<ded<ded<ded<d ed <d S) BoolSchemazRequired[Literal['bool']]rgr#r$r!rrTrrrNrhr5r5r5r6r s r)r$rrrr;cCstd||||dS)ae Returns a schema that matches a bool value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.bool_schema() v = SchemaValidator(schema) assert v.validate_python('True') is True ``` Args: strict: Whether the value should be a bool or a value that can be converted to a bool ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r#rgr$rrrryr$rrrr5r5r6 bool_schema(src@s^eZdZUded<ded<ded<ded<ded<ded<d ed <d ed <d ed<ded<dS) IntSchemazRequired[Literal['int']]rgr+ multiple_oflegeltgtr#r$r!rrTrrrNrhr5r5r5r6rBs r rrrrrr$rrrz int | None) rrrrrr$rrrr;c Cstd|||||||||d S)a Returns a schema that matches a int value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.int_schema(multiple_of=2, le=6, ge=2) v = SchemaValidator(schema) assert v.validate_python('4') == 4 ``` Args: multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number strict: Whether the value should be a int or a value that can be converted to a int ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r+) rgrrrrrr$rrrryrr5r5r6 int_schemaOs"rc@sfeZdZUded<ded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<dS) FloatSchemazRequired[Literal['float']]rgr#r,rXrrrrrr$r!rrTrrrNrhr5r5r5r6rs r r,rrrrrr$rrrz float | None) r,rrrrrr$rrrr;c Cstd|||||||||| d S)a Returns a schema that matches a float value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.float_schema(le=0.8, ge=0.2) v = SchemaValidator(schema) assert v.validate_python('0.5') == 0.5 ``` Args: allow_inf_nan: Whether to allow inf and nan values multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number strict: Whether the value should be a float or a value that can be converted to a float ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rX) rgr,rrrrrr$rrrryrr5r5r6 float_schemas$rc@sveZdZUded<ded<ded<ded<ded<ded <ded <d ed <d ed <ded<ded<ded<ded<dS) DecimalSchemazRequired[Literal['decimal']]rgr#r,rrrrrrr+ max_digitsdecimal_placesr$r!rrTrrrNrhr5r5r5r6rs r r,rrrrrrrr$rrrzDecimal | None) r,rrrrrrrr$rrrr;c Cs"td|||||||||| | | d S)a Returns a schema that matches a decimal value, e.g.: ```py from decimal import Decimal from pydantic_core import SchemaValidator, core_schema schema = core_schema.decimal_schema(le=0.8, ge=0.2) v = SchemaValidator(schema) assert v.validate_python('0.5') == Decimal('0.5') ``` Args: allow_inf_nan: Whether to allow inf and nan values multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number max_digits: The maximum number of decimal digits allowed decimal_places: The maximum number of decimal places allowed strict: Whether the value should be a float or a value that can be converted to a float ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema decimal) rgrrrrrrrr,r$rrrryrr5r5r6decimal_schemas)rc@s6eZdZUded<ded<ded<ded<d ed <d S) ComplexSchemazRequired[Literal['complex']]rgr#r$r!rrTrrrNrhr5r5r5r6r s rrcCstd||||dS)a Returns a schema that matches a complex value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.complex_schema() v = SchemaValidator(schema) assert v.validate_python('1+2j') == complex(1, 2) assert v.validate_python(complex(1, 2)) == complex(1, 2) ``` Args: strict: Whether the value should be a complex object instance or a value that can be converted to a complex object ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema complexrryrr5r5r6complex_schemasrc@sveZdZUded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<ded<ded<ded<dS) StringSchemazRequired[Literal['str']]rgzUnion[str, Pattern[str]]patternr+ max_length min_lengthr#strip_whitespaceto_lowerto_upperr.r/r$r-r!rrTrrrNrhr5r5r5r6r4s r rrrrrrr/r$r-rrrzstr | Pattern[str] | Nonez+Literal[('rust-regex', 'python-re')] | None) rrrrrrr/r$r-rrrr;c Cs"td|||||||||| | | d S)aC Returns a schema that matches a string value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.str_schema(max_length=10, min_length=2) v = SchemaValidator(schema) assert v.validate_python('hello') == 'hello' ``` Args: pattern: A regex pattern that the value must match max_length: The value must be at most this length min_length: The value must be at least this length strip_whitespace: Whether to strip whitespace from the value to_lower: Whether to convert the value to lowercase to_upper: Whether to convert the value to uppercase regex_engine: The regex engine to use for pattern validation. Default is 'rust-regex'. - `rust-regex` uses the [`regex`](https://docs.rs/regex) Rust crate, which is non-backtracking and therefore more DDoS resistant, but does not support all regex features. - `python-re` use the [`re`](https://docs.python.org/3/library/re.html) module, which supports all regex features, but may be slower. strict: Whether the value should be a string or a value that can be converted to a string coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode). ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r!) rgrrrrrrr/r$r-rrrryrr5r5r6 str_schemaDs-rc@sFeZdZUded<ded<ded<ded<ded <d ed <d ed <dS) BytesSchemazRequired[Literal['bytes']]rgr+rrr#r$r!rrTrrrNrhr5r5r5r6rs rrrr$rrr)rrr$rrrr;c Cstd||||||dS)a Returns a schema that matches a bytes value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.bytes_schema(max_length=10, min_length=2) v = SchemaValidator(schema) assert v.validate_python(b'hello') == b'hello' ``` Args: max_length: The value must be at most this length min_length: The value must be at least this length strict: Whether the value should be a bytes or a value that can be converted to a bytes ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rY)rgrrr$rrrryrr5r5r6 bytes_schemasrc@sfeZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<dS) DateSchemazRequired[Literal['date']]rgr#r$rrrrrLiteral[('past', 'future')]now_opr+now_utc_offsetr!rrTrrrNrhr5r5r5r6rs r r$rrrrrrrrrz date | Nonez"Literal[('past', 'future')] | None) r$rrrrrrrrrr;c Cstd|||||||||| d S)a Returns a schema that matches a date value, e.g.: ```py from datetime import date from pydantic_core import SchemaValidator, core_schema schema = core_schema.date_schema(le=date(2020, 1, 1), ge=date(2019, 1, 1)) v = SchemaValidator(schema) assert v.validate_python(date(2019, 6, 1)) == date(2019, 6, 1) ``` Args: strict: Whether the value should be a date or a value that can be converted to a date le: The value must be less than or equal to this date ge: The value must be greater than or equal to this date lt: The value must be strictly less than this date gt: The value must be strictly greater than this date now_op: The value must be in the past or future relative to the current date now_utc_offset: The value must be in the past or future relative to the current date with this utc offset ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rgr$rrrrrrrrrryrr5r5r6 date_schemas%rc@sfeZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<dS) TimeSchemazRequired[Literal['time']]rgr#r$rrrrr'Union[Literal[('aware', 'naive')], int] tz_constraintLiteral[('truncate', 'error')]microseconds_precisionr!rrTrrrNrhr5r5r5r6rs rtruncate r$rrrrrrrrrz time | Nonez(Literal[('aware', 'naive')] | int | Noner) r$rrrrrrrrrr;c Cstd|||||||||| d S)a Returns a schema that matches a time value, e.g.: ```py from datetime import time from pydantic_core import SchemaValidator, core_schema schema = core_schema.time_schema(le=time(12, 0, 0), ge=time(6, 0, 0)) v = SchemaValidator(schema) assert v.validate_python(time(9, 0, 0)) == time(9, 0, 0) ``` Args: strict: Whether the value should be a time or a value that can be converted to a time le: The value must be less than or equal to this time ge: The value must be greater than or equal to this time lt: The value must be strictly less than this time gt: The value must be strictly greater than this time tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rgr$rrrrrrrrrryrr5r5r6 time_schemas%rc@sveZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<dS)DatetimeSchemazRequired[Literal['datetime']]rgr#r$rrrrrrrrrr+rrrr!rrTrrrNrhr5r5r5r6r9s r r$rrrrrrrrrrrzdatetime | None) r$rrrrrrrrrrrr;c Cs"td|||||||||| | | d S)a Returns a schema that matches a datetime value, e.g.: ```py from datetime import datetime from pydantic_core import SchemaValidator, core_schema schema = core_schema.datetime_schema() v = SchemaValidator(schema) now = datetime.now() assert v.validate_python(str(now)) == now ``` Args: strict: Whether the value should be a datetime or a value that can be converted to a datetime le: The value must be less than or equal to this datetime ge: The value must be greater than or equal to this datetime lt: The value must be strictly less than this datetime gt: The value must be strictly greater than this datetime now_op: The value must be in the past or future relative to the current datetime tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset TODO: use of a tzinfo where offset changes based on the datetime is not yet supported now_utc_offset: The value must be in the past or future relative to the current datetime with this utc offset microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rgr$rrrrrrrrrrrryrr5r5r6datetime_schemaKs+rc@s^eZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<dS)TimedeltaSchemazRequired[Literal['timedelta']]rgr#r$rrrrrrrr!rrTrrrNrhr5r5r5r6rs r r$rrrrrrrrztimedelta | None) r$rrrrrrrrr;c Cstd|||||||||d S)a] Returns a schema that matches a timedelta value, e.g.: ```py from datetime import timedelta from pydantic_core import SchemaValidator, core_schema schema = core_schema.timedelta_schema(le=timedelta(days=1), ge=timedelta(days=0)) v = SchemaValidator(schema) assert v.validate_python(timedelta(hours=12)) == timedelta(hours=12) ``` Args: strict: Whether the value should be a timedelta or a value that can be converted to a timedelta le: The value must be less than or equal to this timedelta ge: The value must be greater than or equal to this timedelta lt: The value must be strictly less than this timedelta gt: The value must be strictly greater than this timedelta microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rgr$rrrrrrrrryrr5r5r6timedelta_schemas#rc@s6eZdZUded<ded<ded<ded<d ed <d S) LiteralSchemazRequired[Literal['literal']]rgRequired[List[Any]]expectedr!rrTrrrNrhr5r5r5r6rs rz list[Any])rrrrr;cCstd||||dS)a[ Returns a schema that matches a literal value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.literal_schema(['hello', 'world']) v = SchemaValidator(schema) assert v.validate_python('hello') == 'hello' ``` Args: expected: The value must be one of these values ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema literal)rgrrrrry)rrrrr5r5r6literal_schemasrc@sVeZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<ded<dS) EnumSchemazRequired[Literal['enum']]rg Required[Any]rrmembersz Literal[('str', 'int', 'float')]sub_typezCallable[[Any], Any]missingr#r$r!rrTrrrNrhr5r5r5r6rs r)rrr$rrrr z'Literal[('str', 'int', 'float')] | NonezCallable[[Any], Any] | None) rrrrr$rrrr;c Cstd||||||||d S)a Returns a schema that matches an enum value, e.g.: ```py from enum import Enum from pydantic_core import SchemaValidator, core_schema class Color(Enum): RED = 1 GREEN = 2 BLUE = 3 schema = core_schema.enum_schema(Color, list(Color.__members__.values())) v = SchemaValidator(schema) assert v.validate_python(2) is Color.GREEN ``` Args: cls: The enum class members: The members of the enum, generally `list(MyEnum.__members__.values())` sub_type: The type of the enum, either 'str' or 'int' or None for plain enums missing: A function to use when the value is not found in the enum, from `_missing_` strict: Whether to use strict mode, defaults to False ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema enum) rgrrrrr$rrrry)rrrrr$rrrr5r5r6 enum_schemas&r)Znullr#r+rXr!r[r`c@s>eZdZUded<ded<ded<ded<ded <d ed <d S) IsInstanceSchemaz Required[Literal['is-instance']]rgrrr!cls_reprrrTrrrNrhr5r5r5r6r+s r)rrrr)rrrrrr;cCstd|||||dS)a Returns a schema that checks if a value is an instance of a class, equivalent to python's `isinstance` method, e.g.: ```py from pydantic_core import SchemaValidator, core_schema class A: pass schema = core_schema.is_instance_schema(cls=A) v = SchemaValidator(schema) v.validate_python(A()) ``` Args: cls: The value must be an instance of this class cls_repr: If provided this string is used in the validator name instead of `repr(cls)` ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema is-instancergrrrrrryrrrrrr5r5r6is_instance_schema4src@s>eZdZUded<ded<ded<ded<ded <d ed <d S) IsSubclassSchemaz Required[Literal['is-subclass']]rgrrr!rrrTrrrNrhr5r5r5r6rVs rcCstd|||||dS)a Returns a schema that checks if a value is a subtype of a class, equivalent to python's `issubclass` method, e.g.: ```py from pydantic_core import SchemaValidator, core_schema class A: pass class B(A): pass schema = core_schema.is_subclass_schema(cls=A) v = SchemaValidator(schema) v.validate_python(B) ``` Args: cls: The value must be a subclass of this class cls_repr: If provided this string is used in the validator name instead of `repr(cls)` ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema is-subclassrryrr5r5r6is_subclass_schema_s rc@s.eZdZUded<ded<ded<ded<d S) CallableSchemazRequired[Literal['callable']]rgr!rrTrrrNrhr5r5r5r6rs rcCstd|||dS)a, Returns a schema that checks if a value is callable, equivalent to python's `callable` method, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.callable_schema() v = SchemaValidator(schema) v.validate_python(min) ``` Args: ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema callablerryrr5r5r6callable_schemasrc@s>eZdZUded<ded<ded<ded<d ed <d ed <d S) UuidSchemazRequired[Literal['uuid']]rgzLiteral[(1, 3, 4, 5)]versionr#r$r!rrTrrrNrhr5r5r5r6rs rrr$rrrzLiteral[(1, 3, 4, 5)] | None)rr$rrrr;cCstd|||||dS)Nrd)rgrr$rrrryrr5r5r6 uuid_schemasrc@s&eZdZUded<ded<ded<dS)IncExSeqSerSchemaz-Required[Literal['include-exclude-sequence']]rgzSet[int]r?r@Nrhr5r5r5r6rs rr?r@zSet[int] | None)r?r@r;cCstd||dS)Nzinclude-exclude-sequencergr?r@ryrr5r5r6filter_seq_schemasrc@sVeZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<dS) ListSchemazRequired[Literal['list']]rgrs items_schemar+rrr# fail_fastr$r!rrTrIncExSeqOrElseSerSchemarNrhr5r5r5r6rs r)rrrr$rrrzIncExSeqOrElseSerSchema | None) rrrrr$rrrr;c Cstd||||||||d S)a Returns a schema that matches a list value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.list_schema(core_schema.int_schema(), min_length=0, max_length=10) v = SchemaValidator(schema) assert v.validate_python(['4']) == [4] ``` Args: items_schema: The value must be a list of items that match this schema min_length: The value must be a list with at least this many items max_length: The value must be a list with at most this many items fail_fast: Stop validation on the first error strict: The value must be a list with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r[ rgrrrrr$rrrryrrrrr$rrrr5r5r6 list_schemas r) extras_schemar$rrrzlist[CoreSchema] TupleSchema)rrr$rrrr;cCs4|dk rt|}||g}nd}t||||||dS)a Returns a schema that matches a tuple of schemas, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.tuple_positional_schema( [core_schema.int_schema(), core_schema.str_schema()] ) v = SchemaValidator(schema) assert v.validate_python((1, 'hello')) == (1, 'hello') ``` Args: items_schema: The value must be a tuple with items that match these schemas extras_schema: The value must be a tuple with items that match this schema This was inspired by JSON schema's `prefixItems` and `items` fields. In python's `typing.Tuple`, you can't specify a type for "extra" items -- they must all be the same type if the length is variable. So this field won't be set from a `typing.Tuple` annotation on a pydantic model. strict: The value must be a tuple with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema N)rvariadic_item_indexr$rrr)len tuple_schema)rrr$rrrr r5r5r6tuple_positional_schemas! r )rrr$rrr)rrrr$rrrr;c Cs t|p tgd||||||dS)a Returns a schema that matches a tuple of a given schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.tuple_variable_schema( items_schema=core_schema.int_schema(), min_length=0, max_length=10 ) v = SchemaValidator(schema) assert v.validate_python(('1', 2, 3)) == (1, 2, 3) ``` Args: items_schema: The value must be a tuple with items that match this schema min_length: The value must be a tuple with at least this many items max_length: The value must be a tuple with at most this many items strict: The value must be a tuple with exactly this many items ref: Optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r)rr rrr$rrr)r r)rrrr$rrrr5r5r6tuple_variable_schema/s  rc@s^eZdZUded<ded<ded<ded<ded<d ed <d ed <d ed <ded<ded<dS)r zRequired[Literal['tuple']]rgRequired[List[CoreSchema]]rr+r rrr#rr$r!rrTrrrNrhr5r5r5r6r [s )r rrrr$rrr) rr rrrr$rrrr;c Cstd|||||||||d S)a Returns a schema that matches a tuple of schemas, with an optional variadic item, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.tuple_schema( [core_schema.int_schema(), core_schema.str_schema(), core_schema.float_schema()], variadic_item_index=1, ) v = SchemaValidator(schema) assert v.validate_python((1, 'hello', 'world', 1.5)) == (1, 'hello', 'world', 1.5) ``` Args: items_schema: The value must be a tuple with items that match these schemas variadic_item_index: The index of the schema in `items_schema` to be treated as variadic (following PEP 646) min_length: The value must be a tuple with at least this many items max_length: The value must be a tuple with at most this many items fail_fast: Stop validation on the first error strict: The value must be a tuple with exactly this many items ref: Optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r\) rgrr rrrr$rrrry) rr rrrr$rrrr5r5r6r hs%r c@sVeZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<dS) SetSchemazRequired[Literal['set']]rgrsrr+rrr#rr$r!rrTrrrNrhr5r5r5r6rs rc Cstd||||||||d S)a Returns a schema that matches a set of a given schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.set_schema( items_schema=core_schema.int_schema(), min_length=0, max_length=10 ) v = SchemaValidator(schema) assert v.validate_python({1, '2', 3}) == {1, 2, 3} ``` Args: items_schema: The value must be a set with items that match this schema min_length: The value must be a set with at least this many items max_length: The value must be a set with at most this many items fail_fast: Stop validation on the first error strict: The value must be a set with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r]rryrr5r5r6 set_schemas"rc@sVeZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<dS)FrozenSetSchemazRequired[Literal['frozenset']]rgrsrr+rrr#rr$r!rrTrrrNrhr5r5r5r6rs rc Cstd||||||||d S)a Returns a schema that matches a frozenset of a given schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.frozenset_schema( items_schema=core_schema.int_schema(), min_length=0, max_length=10 ) v = SchemaValidator(schema) assert v.validate_python(frozenset(range(3))) == frozenset({0, 1, 2}) ``` Args: items_schema: The value must be a frozenset with items that match this schema min_length: The value must be a frozenset with at least this many items max_length: The value must be a frozenset with at most this many items fail_fast: Stop validation on the first error strict: The value must be a frozenset with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r^rryrr5r5r6frozenset_schemas"rc@sFeZdZUded<ded<ded<ded<ded <d ed <d ed <dS)GeneratorSchemazRequired[Literal['generator']]rgrsrr+rrr!rrTrrrNrhr5r5r5r6rs r)rrrrr)rrrrrrr;c Cstd||||||dS)a Returns a schema that matches a generator value, e.g.: ```py from typing import Iterator from pydantic_core import SchemaValidator, core_schema def gen() -> Iterator[int]: yield 1 schema = core_schema.generator_schema(items_schema=core_schema.int_schema()) v = SchemaValidator(schema) v.validate_python(gen()) ``` Unlike other types, validated generators do not raise ValidationErrors eagerly, but instead will raise a ValidationError when a violating value is actually read from the generator. This is to ensure that "validated" generators retain the benefit of lazy evaluation. Args: items_schema: The value must be a generator with items that match this schema min_length: The value must be a generator that yields at least this many items max_length: The value must be a generator that yields at most this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r_)rgrrrrrrry)rrrrrrr5r5r6generator_schemas$rc@s&eZdZUded<ded<ded<dS)IncExDictSerSchemaz)Required[Literal['include-exclude-dict']]rg IncExDictr?r@Nrhr5r5r5r6rMs rzIncExDict | NonecCstd||dS)Nzinclude-exclude-dictrryrr5r5r6filter_dict_schemaSsrc@sVeZdZUded<ded<ded<ded<ded<d ed <d ed <d ed<ded<dS) DictSchemazRequired[Literal['dict']]rgrs keys_schema values_schemar+rrr#r$r!rrTrIncExDictOrElseSerSchemarNrhr5r5r5r6rZs r) rrrrr$rrrr;c Cstd||||||||d S)a Returns a schema that matches a dict value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.dict_schema( keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema() ) v = SchemaValidator(schema) assert v.validate_python({'a': '1', 'b': 2}) == {'a': 1, 'b': 2} ``` Args: keys_schema: The value must be a dict with keys that match this schema values_schema: The value must be a dict with values that match this schema min_length: The value must be a dict with at least this many items max_length: The value must be a dict with at most this many items strict: Whether the keys and values should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r`) rgrrrrr$rrrry)rrrrr$rrrr5r5r6 dict_schemafs"rc@seZdZUded<ded<dS)NoInfoValidatorFunctionSchemaLiteral['no-info']rgNoInfoValidatorFunctionrpNrhr5r5r5r6rs rc@s&eZdZUded<ded<ded<dS)WithInfoValidatorFunctionSchemaRequired[Literal['with-info']]rgz#Required[WithInfoValidatorFunction]rpr!rPNrhr5r5r5r6r!s r!c@s6eZdZUded<ded<ded<ded<d ed <d S) _ValidatorFunctionSchemaRequired[ValidationFunction]rprrr!rrTrrrNrhr5r5r5r6r#s r#c@seZdZUded<ded<dS)BeforeValidatorFunctionSchemaz$Required[Literal['function-before']]rgrsjson_schema_input_schemaNrhr5r5r5r6r%s r%)rr&rrr )rprrr&rrr;c Cstdd|d|||||dS)a= Returns a schema that calls a validator function before validating, no `info` argument is provided, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: bytes) -> str: return v.decode() + 'world' func_schema = core_schema.no_info_before_validator_function( function=fn, schema=core_schema.str_schema() ) schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)}) v = SchemaValidator(schema) assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'} ``` Args: function: The validator function to call schema: The schema to validate the output of the validator function ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema function-beforeno-inforgrprgrprrr&rrryrprrr&rrr5r5r6!no_info_before_validator_functions#r,)rPrr&rrWithInfoValidatorFunction)rprrPrr&rrr;c Cs tdtd||d|||||dS)a Returns a schema that calls a validator function before validation, the function is called with an `info` argument, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: bytes, info: core_schema.ValidationInfo) -> str: assert info.data is not None assert info.field_name is not None return v.decode() + 'world' func_schema = core_schema.with_info_before_validator_function( function=fn, schema=core_schema.str_schema(), field_name='a' ) schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)}) v = SchemaValidator(schema) assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'} ``` Args: function: The validator function to call field_name: The name of the field schema: The schema to validate the output of the validator function ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r' with-inforgrprPr*ry)rprrPrr&rrr5r5r6#with_info_before_validator_functions( r0c@seZdZUded<dS)AfterValidatorFunctionSchemaz#Required[Literal['function-after']]rgNrhr5r5r5r6r1s r1c Cstdd|d|||||dS)a) Returns a schema that calls a validator function after validating, no `info` argument is provided, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str) -> str: return v + 'world' func_schema = core_schema.no_info_after_validator_function(fn, core_schema.str_schema()) schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)}) v = SchemaValidator(schema) assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'} ``` Args: function: The validator function to call after the schema is validated schema: The schema to validate before the validator function ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema function-afterr(r)r*ryr+r5r5r6 no_info_after_validator_functions!r3)rPrrr)rprrPrrrr;cCstdtd||d||||dS)a Returns a schema that calls a validator function after validation, the function is called with an `info` argument, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str, info: core_schema.ValidationInfo) -> str: assert info.data is not None assert info.field_name is not None return v + 'world' func_schema = core_schema.with_info_after_validator_function( function=fn, schema=core_schema.str_schema(), field_name='a' ) schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)}) v = SchemaValidator(schema) assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'} ``` Args: function: The validator function to call after the schema is validated schema: The schema to validate before the validator function field_name: The name of the field this validators is applied to, if any ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r2r.r/)rgrprrrrry)rprrPrrrr5r5r6"with_info_after_validator_functionIs& r4c@s eZdZdddddddZdS)ValidatorFunctionWrapHandlerNr zstr | int | None)r}outer_locationr;cCsdSr<r5)r>r}r6r5r5r6rzsz%ValidatorFunctionWrapHandler.__call__)Nrr5r5r5r6r5ysr5c@seZdZUded<ded<dS)!NoInfoWrapValidatorFunctionSchemarrgNoInfoWrapValidatorFunctionrpNrhr5r5r5r6r7s r7c@s&eZdZUded<ded<ded<dS)#WithInfoWrapValidatorFunctionSchemar"rgz'Required[WithInfoWrapValidatorFunction]rpr!rPNrhr5r5r5r6r9s r9c@sFeZdZUded<ded<ded<ded<d ed <d ed <d ed<dS)WrapValidatorFunctionSchemarrgzRequired[WrapValidatorFunction]rprrr!rrsr&rTrrrNrhr5r5r5r6r:s r:r8c Cstdd|d|||||dS)a Returns a schema which calls a function with a `validator` callable argument which can optionally be used to call inner validation with the function logic, this is much like the "onion" implementation of middleware in many popular web frameworks, no `info` argument is passed, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn( v: str, validator: core_schema.ValidatorFunctionWrapHandler, ) -> str: return validator(input_value=v) + 'world' schema = core_schema.no_info_wrap_validator_function( function=fn, schema=core_schema.str_schema() ) v = SchemaValidator(schema) assert v.validate_python('hello ') == 'hello world' ``` Args: function: The validator function to call schema: The schema to validate the output of the validator function ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rr(r)rgrprr&rrrryr+r5r5r6no_info_wrap_validator_functions&r<)rPr&rrrWithInfoWrapValidatorFunction)rprrPr&rrrr;c Cs tdtd||d|||||dS)a[ Returns a schema which calls a function with a `validator` callable argument which can optionally be used to call inner validation with the function logic, this is much like the "onion" implementation of middleware in many popular web frameworks, an `info` argument is also passed, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn( v: str, validator: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo, ) -> str: return validator(input_value=v) + 'world' schema = core_schema.with_info_wrap_validator_function( function=fn, schema=core_schema.str_schema() ) v = SchemaValidator(schema) assert v.validate_python('hello ') == 'hello world' ``` Args: function: The validator function to call schema: The schema to validate the output of the validator function field_name: The name of the field this validators is applied to, if any json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rr.r/r;ry)rprrPr&rrrr5r5r6!with_info_wrap_validator_functions) r>c@s>eZdZUded<ded<ded<ded<d ed <d ed <d S)PlainValidatorFunctionSchemarorgr$rpr!rrsr&rTrrrNrhr5r5r5r6r? s r?)rprr&rrr;cCstdd|d||||dS)a[ Returns a schema that uses the provided function for validation, no `info` argument is passed, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str) -> str: assert 'hello' in v return v + 'world' schema = core_schema.no_info_plain_validator_function(function=fn) v = SchemaValidator(schema) assert v.validate_python('hello ') == 'hello world' ``` Args: function: The validator function to call ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rxr(r)rgrprr&rrry)rprr&rrr5r5r6 no_info_plain_validator_function srA)rprPrr&rrr;cCstdtd||d||||dS)a Returns a schema that uses the provided function for validation, an `info` argument is passed, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str, info: core_schema.ValidationInfo) -> str: assert 'hello' in v return v + 'world' schema = core_schema.with_info_plain_validator_function(function=fn) v = SchemaValidator(schema) assert v.validate_python('hello ') == 'hello world' ``` Args: function: The validator function to call field_name: The name of the field this validators is applied to, if any ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rxr.r/r@ry)rprPrr&rrr5r5r6"with_info_plain_validator_function4 s  rBc@sfeZdZUded<ded<ded<ded<d ed <d ed <d ed <d ed<ded<ded<ded<dS)WithDefaultSchemazRequired[Literal['default']]rgrrr defaultz9Union[Callable[[], Any], Callable[[Dict[str, Any]], Any]]default_factoryr#default_factory_takes_dataz%Literal[('raise', 'omit', 'default')]on_errorr)r$r!rrTrrrNrhr5r5r5r6rC^ s rC) rDrErFrGr)r$rrrz?Union[Callable[[], Any], Callable[[Dict[str, Any]], Any], None]z,Literal[('raise', 'omit', 'default')] | None) rrDrErFrGr)r$rrrr;c Cs0td||||||||| d } |tk r,|| d<| S)a Returns a schema that adds a default value to the given schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.with_default_schema(core_schema.str_schema(), default='hello') wrapper_schema = core_schema.typed_dict_schema( {'a': core_schema.typed_dict_field(schema)} ) v = SchemaValidator(wrapper_schema) assert v.validate_python({}) == v.validate_python({'a': 'hello'}) ``` Args: schema: The schema to add a default value to default: The default value to use default_factory: A callable that returns the default value to use default_factory_takes_data: Whether the default factory takes a validated data argument on_error: What to do if the schema validation fails. One of 'raise', 'omit', 'default' validate_default: Whether the default value should be validated strict: Whether the underlying schema should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rD) rgrrErFrGr)r$rrr)rzr) rrDrErFrGr)r$rrrrr5r5r6with_default_schemal s' rHc@s>eZdZUded<ded<ded<ded<d ed <d ed <d S)NullableSchemazRequired[Literal['nullable']]rgrrr#r$r!rrTrrrNrhr5r5r5r6rI s rI)rr$rrrr;cCstd|||||dS)a Returns a schema that matches a nullable value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.nullable_schema(core_schema.str_schema()) v = SchemaValidator(schema) assert v.validate_python(None) is None ``` Args: schema: The schema to wrap strict: Whether the underlying schema should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema nullable)rgrr$rrrry)rr$rrrr5r5r6nullable_schema srKc@sfeZdZUded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<dS) UnionSchemazRequired[Literal['union']]rgz9Required[List[Union[CoreSchema, Tuple[CoreSchema, str]]]]choicesr# auto_collapser!custom_error_typecustom_error_message!Dict[str, Union[str, int, float]]custom_error_contextz#Literal[('smart', 'left_to_right')]rCr$rrTrrrNrhr5r5r5r6rL s rL) rNrOrPrRrCr$rrrz)list[CoreSchema | tuple[CoreSchema, str]]zdict[str, str | int] | Nonez*Literal[('smart', 'left_to_right')] | None) rMrNrOrPrRrCr$rrrr;c Cstd|||||||||| d S)a Returns a schema that matches a union value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()]) v = SchemaValidator(schema) assert v.validate_python('hello') == 'hello' assert v.validate_python(1) == 1 ``` Args: choices: The schemas to match. If a tuple, the second item is used as the label for the case. auto_collapse: whether to automatically collapse unions with one element to the inner validator, default true custom_error_type: The custom error type to use if the validation fails custom_error_message: The custom error message to use if the validation fails custom_error_context: The custom error context to use if the validation fails mode: How to select which choice to return * `smart` (default) will try to return the choice which is the closest match to the input value * `left_to_right` will return the first choice in `choices` which succeeds validation strict: Whether the underlying schemas should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema union) rgrMrNrOrPrRrCr$rrrry) rMrNrOrPrRrCr$rrrr5r5r6 union_schema s'rTc@sfeZdZUded<ded<ded<ded<ded <d ed <d ed <d ed<ded<ded<ded<dS)TaggedUnionSchemaz!Required[Literal['tagged-union']]rgz$Required[Dict[Hashable, CoreSchema]]rMzcRequired[Union[str, List[Union[str, int]], List[List[Union[str, int]]], Callable[[Any], Hashable]]] discriminatorr!rOrPrQrRr#r$r&rrTrrrNrhr5r5r5r6rU s rU)rOrPrRr$r&rrrzDict[Any, CoreSchema]zDstr | list[str | int] | list[list[str | int]] | Callable[[Any], Any]z#dict[str, int | str | float] | None) rMrVrOrPrRr$r&rrrr;c Cstd|||||||||| d S)a Returns a schema that matches a tagged union value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema apple_schema = core_schema.typed_dict_schema( { 'foo': core_schema.typed_dict_field(core_schema.str_schema()), 'bar': core_schema.typed_dict_field(core_schema.int_schema()), } ) banana_schema = core_schema.typed_dict_schema( { 'foo': core_schema.typed_dict_field(core_schema.str_schema()), 'spam': core_schema.typed_dict_field( core_schema.list_schema(items_schema=core_schema.int_schema()) ), } ) schema = core_schema.tagged_union_schema( choices={ 'apple': apple_schema, 'banana': banana_schema, }, discriminator='foo', ) v = SchemaValidator(schema) assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123} assert v.validate_python({'foo': 'banana', 'spam': [1, 2, 3]}) == { 'foo': 'banana', 'spam': [1, 2, 3], } ``` Args: choices: The schemas to match When retrieving a schema from `choices` using the discriminator value, if the value is a str, it should be fed back into the `choices` map until a schema is obtained (This approach is to prevent multiple ownership of a single schema in Rust) discriminator: The discriminator to use to determine the schema to use * If `discriminator` is a str, it is the name of the attribute to use as the discriminator * If `discriminator` is a list of int/str, it should be used as a "path" to access the discriminator * If `discriminator` is a list of lists, each inner list is a path, and the first path that exists is used * If `discriminator` is a callable, it should return the discriminator when called on the value to validate; the callable can return `None` to indicate that there is no matching discriminator present on the input custom_error_type: The custom error type to use if the validation fails custom_error_message: The custom error message to use if the validation fails custom_error_context: The custom error context to use if the validation fails strict: Whether the underlying schemas should be validated with strict mode from_attributes: Whether to use the attributes of the object to retrieve the discriminator value ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema tagged-union) rgrMrVrOrPrRr$r&rrrry) rMrVrOrPrRr$r&rrrr5r5r6tagged_union_schema sDrXc@s6eZdZUded<ded<ded<ded<d ed <d S) ChainSchemazRequired[Literal['chain']]rgrstepsr!rrTrrrNrhr5r5r5r6rYr s rY)rZrrrr;cCstd||||dS)a_ Returns a schema that chains the provided validation schemas, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str, info: core_schema.ValidationInfo) -> str: assert 'hello' in v return v + ' world' fn_schema = core_schema.with_info_plain_validator_function(function=fn) schema = core_schema.chain_schema( [fn_schema, fn_schema, fn_schema, core_schema.str_schema()] ) v = SchemaValidator(schema) assert v.validate_python('hello') == 'hello world world world' ``` Args: steps: The schemas to chain ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema chain)rgrZrrrry)rZrrrr5r5r6 chain_schemaz sr\c@sFeZdZUded<ded<ded<ded<ded <d ed <d ed <dS)LaxOrStrictSchemaz"Required[Literal['lax-or-strict']]rgr lax_schema strict_schemar#r$r!rrTrrrNrhr5r5r5r6r] s r])r^r_r$rrrr;c Cstd||||||dS)a Returns a schema that uses the lax or strict schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str, info: core_schema.ValidationInfo) -> str: assert 'hello' in v return v + ' world' lax_schema = core_schema.int_schema(strict=False) strict_schema = core_schema.int_schema(strict=True) schema = core_schema.lax_or_strict_schema( lax_schema=lax_schema, strict_schema=strict_schema, strict=True ) v = SchemaValidator(schema) assert v.validate_python(123) == 123 schema = core_schema.lax_or_strict_schema( lax_schema=lax_schema, strict_schema=strict_schema, strict=False ) v = SchemaValidator(schema) assert v.validate_python('123') == 123 ``` Args: lax_schema: The lax schema to use strict_schema: The strict schema to use strict: Whether the strict schema should be used ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema lax-or-strict)rgr^r_r$rrrry)r^r_r$rrrr5r5r6lax_or_strict_schema s+rac@s>eZdZUded<ded<ded<ded<ded <d ed <d S) JsonOrPythonSchemaz#Required[Literal['json-or-python']]rgr json_schema python_schemar!rrTrrrNrhr5r5r5r6rb s rb)rcrdrrrr;cCstd|||||dS)a Returns a schema that uses the Json or Python schema depending on the input: ```py from pydantic_core import SchemaValidator, ValidationError, core_schema v = SchemaValidator( core_schema.json_or_python_schema( json_schema=core_schema.int_schema(), python_schema=core_schema.int_schema(strict=True), ) ) assert v.validate_json('"123"') == 123 try: v.validate_python('123') except ValidationError: pass else: raise AssertionError('Validation should have failed') ``` Args: json_schema: The schema to use for Json inputs python_schema: The schema to use for Python inputs ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema json-or-python)rgrcrdrrrry)rcrdrrrr5r5r6json_or_python_schema s&rfc@sFeZdZUded<ded<ded<ded<d ed <ded <d ed <dS)TypedDictFieldz%Required[Literal['typed-dict-field']]rgrrr#required>Union[str, List[Union[str, int]], List[List[Union[str, int]]]]validation_aliasr!serialization_aliasserialization_excluderTrNrhr5r5r5r6rg s rg)rhrjrkrlrz4str | list[str | int] | list[list[str | int]] | None)rrhrjrkrlrr;c Cstd||||||dS)a Returns a schema that matches a typed dict field, e.g.: ```py from pydantic_core import core_schema field = core_schema.typed_dict_field(schema=core_schema.int_schema(), required=True) ``` Args: schema: The schema to use for the field required: Whether the field is required, otherwise uses the value from `total` on the typed dict validation_alias: The alias(es) to use to find the field in the validation data serialization_alias: The alias to use as a key when serializing serialization_exclude: Whether to exclude the field when serializing metadata: Any other information you want to include with the schema, not used by pydantic-core typed-dict-field)rgrrhrjrkrlrry)rrhrjrkrlrr5r5r6typed_dict_field srnc@sveZdZUded<ded<ded<ded<d ed <d ed <d ed<d ed<d ed<ded<ded<ded<ded<dS)TypedDictSchemazRequired[Literal['typed-dict']]rgz#Required[Dict[str, TypedDictField]]fieldsrrList[ComputedField]computed_fieldsr#r$rsrr%extra_behaviorr7r*r!rrTrrrr rSNrhr5r5r5r6roD s ro) rrrr$rrsr7r*rrrrSzDict[str, TypedDictField]zType[Any] | Nonezlist[ComputedField] | NonezExtraBehavior | NonerR) rprrrr$rrsr7r*rrrrSr;c Cs"td|||||||||| | | d S)a( Returns a schema that matches a typed dict, e.g.: ```py from typing_extensions import TypedDict from pydantic_core import SchemaValidator, core_schema class MyTypedDict(TypedDict): a: str wrapper_schema = core_schema.typed_dict_schema( {'a': core_schema.typed_dict_field(core_schema.str_schema())}, cls=MyTypedDict ) v = SchemaValidator(wrapper_schema) assert v.validate_python({'a': 'hello'}) == {'a': 'hello'} ``` Args: fields: The fields to use for the typed dict cls: The class to use for the typed dict computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model strict: Whether the typed dict is strict extras_schema: The extra validator to use for the typed dict ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core extra_behavior: The extra behavior to use for the typed dict total: Whether the typed dict is total, otherwise uses `typed_dict_total` from config populate_by_name: Whether the typed dict should populate by name serialization: Custom serialization schema typed-dict) rgrprrrr$rrsr7r*rrrrSry) rprrrr$rrsr7r*rrrrSr5r5r6typed_dict_schemaU s.ruc@sFeZdZUded<ded<ded<ded<d ed <d ed <d ed <dS) ModelFieldz Required[Literal['model-field']]rgrrrirjr!rkr#rlfrozenrTrNrhr5r5r5r6rv s rv)rjrkrlrwr)rrjrkrlrwrr;c Cstd||||||dS)aq Returns a schema for a model field, e.g.: ```py from pydantic_core import core_schema field = core_schema.model_field(schema=core_schema.int_schema()) ``` Args: schema: The schema to use for the field validation_alias: The alias(es) to use to find the field in the validation data serialization_alias: The alias to use as a key when serializing serialization_exclude: Whether to exclude the field when serializing frozen: Whether the field is frozen metadata: Any other information you want to include with the schema, not used by pydantic-core model-field)rgrrjrkrlrwrry)rrjrkrlrwrr5r5r6 model_field sryc@sneZdZUded<ded<ded<ded<d ed <d ed <d ed<d ed<d ed<ded<ded<ded<dS)ModelFieldsSchemaz!Required[Literal['model-fields']]rgzRequired[Dict[str, ModelField]]rpr! model_namerqrrr#r$rsrr%rsr*r&rrTrrrNrhr5r5r5r6rz s rz) r{rrr$rrsr*r&rrrzDict[str, ModelField]) rpr{rrr$rrsr*r&rrrr;c Cs td|||||||||| | d S)a Returns a schema that matches a typed dict, e.g.: ```py from pydantic_core import SchemaValidator, core_schema wrapper_schema = core_schema.model_fields_schema( {'a': core_schema.model_field(core_schema.str_schema())} ) v = SchemaValidator(wrapper_schema) print(v.validate_python({'a': 'hello'})) #> ({'a': 'hello'}, None, {'a'}) ``` Args: fields: The fields to use for the typed dict model_name: The name of the model, used for error messages, defaults to "Model" computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model strict: Whether the typed dict is strict extras_schema: The extra validator to use for the typed dict ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core extra_behavior: The extra behavior to use for the typed dict populate_by_name: Whether the typed dict should populate by name from_attributes: Whether the typed dict should be populated from attributes serialization: Custom serialization schema model-fields) rgrpr{rrr$rrsr*r&rrrry) rpr{rrr$rrsr*r&rrrr5r5r6model_fields_schema s)r}c@seZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<d ed<d ed<ded<ded<d ed<ded<ded<dS) ModelSchemarrgrrrgeneric_originrrr# custom_init root_modelr! post_initr'r(r$rwr%rsr rSrrTrrrNrhr5r5r5r6r~ s r~) rrrrr(r$rwrsrSrrrz9Literal[('always', 'never', 'subclass-instances')] | None)rrrrrrr(r$rwrsrSrrrr;c Cs&td|||||||||| | | | | dS)a( A model schema generally contains a typed-dict schema. It will run the typed dict validator, then create a new class and set the dict and fields set returned from the typed dict validator to `__dict__` and `__pydantic_fields_set__` respectively. Example: ```py from pydantic_core import CoreConfig, SchemaValidator, core_schema class MyModel: __slots__ = ( '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__', ) schema = core_schema.model_schema( cls=MyModel, config=CoreConfig(str_max_length=5), schema=core_schema.model_fields_schema( fields={'a': core_schema.model_field(core_schema.str_schema())}, ), ) v = SchemaValidator(schema) assert v.isinstance_python({'a': 'hello'}) is True assert v.isinstance_python({'a': 'too long'}) is False ``` Args: cls: The class to use for the model schema: The schema to use for the model generic_origin: The origin type used for this model, if it's a parametrized generic. Ex, if this model schema represents `SomeModel[int]`, generic_origin is `SomeModel` custom_init: Whether the model has a custom init method root_model: Whether the model is a `RootModel` post_init: The call after init to use for the model revalidate_instances: whether instances of models and dataclasses (including subclass instances) should re-validate defaults to config.revalidate_instances, else 'never' strict: Whether the model is strict frozen: Whether the model is frozen extra_behavior: The extra behavior to use for the model, used in serialization config: The config to use for the model ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r)rgrrrrrrr(r$rwrsrSrrrry)rrrrrrr(r$rwrsrSrrrr5r5r6 model_schema s"Brc@sfeZdZUded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<ded<dS)DataclassFieldz$Required[Literal['dataclass-field']]rgrnamerrr#kw_onlyinit init_onlyrwrirjr!rkrlrTrNrhr5r5r5r6rs s r)rrrrjrkrlrrw) rrrrrrjrkrlrrwr;c Cstd|||||||||| d S)a Returns a schema for a dataclass field, e.g.: ```py from pydantic_core import SchemaValidator, core_schema field = core_schema.dataclass_field( name='a', schema=core_schema.str_schema(), kw_only=False ) schema = core_schema.dataclass_args_schema('Foobar', [field]) v = SchemaValidator(schema) assert v.validate_python({'a': 'hello'}) == ({'a': 'hello'}, None) ``` Args: name: The name to use for the argument parameter schema: The schema to use for the argument parameter kw_only: Whether the field can be set with a positional argument as well as a keyword argument init: Whether the field should be validated during initialization init_only: Whether the field should be omitted from `__dict__` and passed to `__post_init__` validation_alias: The alias(es) to use to find the field in the validation data serialization_alias: The alias to use as a key when serializing serialization_exclude: Whether to exclude the field when serializing metadata: Any other information you want to include with the schema, not used by pydantic-core frozen: Whether the field is frozen dataclass-field) rgrrrrrrjrkrlrrwry) rrrrrrjrkrlrrwr5r5r6dataclass_field s'rc@s^eZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<ded<ded<dS)DataclassArgsSchemaz#Required[Literal['dataclass-args']]rgrdataclass_namezRequired[List[DataclassField]]rprqrrr#r*collect_init_onlyr!rrTrrrr%rsNrhr5r5r5r6r s r)rrr*rrrrrszlist[DataclassField]zList[ComputedField] | None) rrprrr*rrrrrsr;c Cstd|||||||||d S)a Returns a schema for validating dataclass arguments, e.g.: ```py from pydantic_core import SchemaValidator, core_schema field_a = core_schema.dataclass_field( name='a', schema=core_schema.str_schema(), kw_only=False ) field_b = core_schema.dataclass_field( name='b', schema=core_schema.bool_schema(), kw_only=False ) schema = core_schema.dataclass_args_schema('Foobar', [field_a, field_b]) v = SchemaValidator(schema) assert v.validate_python({'a': 'hello', 'b': True}) == ({'a': 'hello', 'b': True}, None) ``` Args: dataclass_name: The name of the dataclass being validated fields: The fields to use for the dataclass computed_fields: Computed fields to use when serializing the dataclass populate_by_name: Whether to populate by name collect_init_only: Whether to collect init only fields into a dict to pass to `__post_init__` ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema extra_behavior: How to handle extra fields dataclass-args) rgrrprrr*rrrrrsry) rrprrr*rrrrrsr5r5r6dataclass_args_schema s(rc@seZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<d ed<d ed<d ed<ded<ded<d ed<ded<dS)DataclassSchemazRequired[Literal['dataclass']]rgrrrrrrzRequired[List[str]]rpr!cls_namer#rr'r(r$rwrrTrrrslotsr rSNrhr5r5r5r6r s r) rrrr(r$rrrrwrrS List[str])rrrprrrr(r$rrrrwrrSr;c Cs&td|||||||||| | | | | dS)a Returns a schema for a dataclass. As with `ModelSchema`, this schema can only be used as a field within another schema, not as the root type. Args: cls: The dataclass type, used to perform subclass checks schema: The schema to use for the dataclass fields fields: Fields of the dataclass, this is used in serialization and in validation during re-validation and while validating assignment generic_origin: The origin type used for this dataclass, if it's a parametrized generic. Ex, if this model schema represents `SomeDataclass[int]`, generic_origin is `SomeDataclass` cls_name: The name to use in error locs, etc; this is useful for generics (default: `cls.__name__`) post_init: Whether to call `__post_init__` after validation revalidate_instances: whether instances of models and dataclasses (including subclass instances) should re-validate defaults to config.revalidate_instances, else 'never' strict: Whether to require an exact instance of `cls` ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema frozen: Whether the dataclass is frozen slots: Whether `slots=True` on the dataclass, means each field is assigned independently, rather than simply setting `__dict__`, default false dataclass)rgrrrprrrr(r$rrrrwrrSry)rrrprrrr(r$rrrrwrrSr5r5r6dataclass_schema s"(rc@s.eZdZUded<ded<ded<ded<d S) ArgumentsParameterrrrrzELiteral[('positional_only', 'positional_or_keyword', 'keyword_only')]rCrirNrhr5r5r5r6rG s r)rCrzLLiteral[('positional_only', 'positional_or_keyword', 'keyword_only')] | None)rrrCrr;cCst||||dS)a Returns a schema that matches an argument parameter, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param = core_schema.arguments_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) schema = core_schema.arguments_schema([param]) v = SchemaValidator(schema) assert v.validate_python(('hello',)) == (('hello',), {}) ``` Args: name: The name to use for the argument parameter schema: The schema to use for the argument parameter mode: The mode to use for the argument parameter alias: The alias to use for the argument parameter rrrCrryrr5r5r6arguments_parameterN sr)Zuniformzunpacked-typed-dict VarKwargsModec@sVeZdZUded<ded<ded<ded<d ed <ded <d ed <ded<ded<dS)ArgumentsSchemazRequired[Literal['arguments']]rgz"Required[List[ArgumentsParameter]]arguments_schemar#r*rsvar_args_schemarvar_kwargs_modevar_kwargs_schemar!rrTrrrNrhr5r5r5r6ro s r)r*rrrrrrzlist[ArgumentsParameter]zVarKwargsMode | None) argumentsr*rrrrrrr;c Cstd||||||||d S)a Returns a schema that matches an arguments schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param_a = core_schema.arguments_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) param_b = core_schema.arguments_parameter( name='b', schema=core_schema.bool_schema(), mode='positional_only' ) schema = core_schema.arguments_schema([param_a, param_b]) v = SchemaValidator(schema) assert v.validate_python(('hello', True)) == (('hello', True), {}) ``` Args: arguments: The arguments to use for the arguments schema populate_by_name: Whether to populate by name var_args_schema: The variable args schema to use for the arguments schema var_kwargs_mode: The validation mode to use for variadic keyword arguments. If `'uniform'`, every value of the keyword arguments will be validated against the `var_kwargs_schema` schema. If `'unpacked-typed-dict'`, the `var_kwargs_schema` argument must be a [`typed_dict_schema`][pydantic_core.core_schema.typed_dict_schema] var_kwargs_schema: The variable kwargs schema to use for the arguments schema ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rgrr*rrrrrrry)rr*rrrrrrr5r5r6r{ s(rc@sNeZdZUded<ded<ded<ded<d ed <ded <d ed <ded<dS) CallSchemazRequired[Literal['call']]rgrrzRequired[Callable[..., Any]]rpr! function_namersrtrrTrrrNrhr5r5r5r6r s r)rrtrrrzCallable[..., Any])rrprrtrrrr;c Cstd|||||||dS)a- Returns a schema that matches an arguments schema, then calls a function, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param_a = core_schema.arguments_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) param_b = core_schema.arguments_parameter( name='b', schema=core_schema.bool_schema(), mode='positional_only' ) args_schema = core_schema.arguments_schema([param_a, param_b]) schema = core_schema.call_schema( arguments=args_schema, function=lambda a, b: a + str(not b), return_schema=core_schema.str_schema(), ) v = SchemaValidator(schema) assert v.validate_python((('hello', True))) == 'helloFalse' ``` Args: arguments: The arguments to use for the arguments schema function: The function to use for the call schema function_name: The function name to use for the call schema, if not provided `function.__name__` is used return_schema: The return schema to use for the call schema ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema call)rgrrprrtrrrry)rrprrtrrrr5r5r6 call_schema s*rc@sNeZdZUded<ded<ded<ded<d ed <ded <d ed <ded<dS)CustomErrorSchemaz!Required[Literal['custom-error']]rgrrrrOr!rPrQrRrrTrrrNrhr5r5r5r6r s r)rPrRrrrzdict[str, Any] | None)rrOrPrRrrrr;c Cstd|||||||dS)a Returns a schema that matches a custom error value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.custom_error_schema( schema=core_schema.int_schema(), custom_error_type='MyError', custom_error_message='Error msg', ) v = SchemaValidator(schema) v.validate_python(1) ``` Args: schema: The schema to use for the custom error schema custom_error_type: The custom error type to use for the custom error schema custom_error_message: The custom error message to use for the custom error schema custom_error_context: The custom error context to use for the custom error schema ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema custom-error)rgrrOrPrRrrrry)rrOrPrRrrrr5r5r6custom_error_schema s"rc@s6eZdZUded<ded<ded<ded<d ed <d S) JsonSchemazRequired[Literal['json']]rgrsrr!rrTrrrNrhr5r5r5r6r*s r)rrrrr;cCstd||||dS)a Returns a schema that matches a JSON value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema dict_schema = core_schema.model_fields_schema( { 'field_a': core_schema.model_field(core_schema.str_schema()), 'field_b': core_schema.model_field(core_schema.bool_schema()), }, ) class MyModel: __slots__ = ( '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__', ) field_a: str field_b: bool json_schema = core_schema.json_schema(schema=dict_schema) schema = core_schema.model_schema(cls=MyModel, schema=json_schema) v = SchemaValidator(schema) m = v.validate_python('{"field_a": "hello", "field_b": true}') assert isinstance(m, MyModel) ``` Args: schema: The schema to use for the JSON schema ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rc)rgrrrrry)rrrrr5r5r6rc2s+rcc@sfeZdZUded<ded<ded<ded<d ed <ded <d ed <ded <d ed<ded<ded<dS) UrlSchemazRequired[Literal['url']]rgr+rrallowed_schemesr# host_requiredr! default_host default_port default_pathr$rrTrrrNrhr5r5r5r6r`s r rrrrrrr$rrrzlist[str] | None) rrrrrrr$rrrr;c Cstd|||||||||| d S)a Returns a schema that matches a URL value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.url_schema() v = SchemaValidator(schema) print(v.validate_python('https://example.com')) #> https://example.com/ ``` Args: max_length: The maximum length of the URL allowed_schemes: The allowed URL schemes host_required: Whether the URL must have a host default_host: The default host to use if the URL does not have a host default_port: The default port to use if the URL does not have a port default_path: The default path to use if the URL does not have a path strict: Whether to use strict URL parsing ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema ra rgrrrrrrr$rrrryrr5r5r6 url_schemans%rc@sfeZdZUded<ded<ded<ded<d ed <ded <d ed <ded <d ed<ded<ded<dS)MultiHostUrlSchemaz#Required[Literal['multi-host-url']]rgr+rrrr#rr!rrrr$rrTrrrNrhr5r5r5r6rs rc Cstd|||||||||| d S)a& Returns a schema that matches a URL value with possibly multiple hosts, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.multi_host_url_schema() v = SchemaValidator(schema) print(v.validate_python('redis://localhost,0.0.0.0,127.0.0.1')) #> redis://localhost,0.0.0.0,127.0.0.1 ``` Args: max_length: The maximum length of the URL allowed_schemes: The allowed URL schemes host_required: Whether the URL must have a host default_host: The default host to use if the URL does not have a host default_port: The default port to use if the URL does not have a port default_path: The default path to use if the URL does not have a path strict: Whether to use strict URL parsing ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rbrryrr5r5r6multi_host_url_schemas%rc@s6eZdZUded<ded<ded<ded<d ed <d S) DefinitionsSchemaz Required[Literal['definitions']]rgrrr definitionsrTrrrNrhr5r5r5r6rs r)rrr;cCstd||dS)ab Build a schema that contains both an inner schema and a list of definitions which can be used within the inner schema. ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.definitions_schema( core_schema.list_schema(core_schema.definition_reference_schema('foobar')), [core_schema.int_schema(ref='foobar')], ) v = SchemaValidator(schema) assert v.validate_python([1, 2, '3']) == [1, 2, 3] ``` Args: schema: The inner schema definitions: List of definitions which can be referenced within inner schema r)rgrr)r)rrr5r5r6definitions_schemasrc@s6eZdZUded<ded<ded<ded<d ed <d S) DefinitionReferenceSchemaz#Required[Literal['definition-ref']]rgr schema_refr!rrTrrrNrhr5r5r5r6rs r)rrrrr;cCstd||||dS)aw Returns a schema that points to a schema stored in "definitions", this is useful for nested recursive models and also when you want to define validators separately from the main schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema_definition = core_schema.definition_reference_schema('list-schema') schema = core_schema.definitions_schema( schema=schema_definition, definitions=[ core_schema.list_schema(items_schema=schema_definition, ref='list-schema'), ], ) v = SchemaValidator(schema) assert v.validate_python([()]) == [[]] ``` Args: schema_ref: The schema ref to use for the definition reference schema metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema definition-ref)rgrrrrry)rrrrr5r5r6definition_reference_schema sr)2rrerWr#r+rXrr!rYrrrrrrrrrr[r\r]r^r_r`r2r'rrxrDrJrSrWr[r`rertr|rrrrrrrcrarbrrrdr)rxrrmr)dZno_such_attributeZ json_invalidZ json_typeZneeds_python_objectZrecursion_looprZ frozen_fieldZfrozen_instanceZextra_forbiddenZ invalid_keyZget_attribute_errorZ model_typeZmodel_attributes_typeZdataclass_typeZdataclass_exact_typeZ none_requiredZ greater_thanZgreater_than_equalZ less_thanZless_than_equalrZ finite_numberZ too_shortZtoo_longZ iterable_typeZiteration_errorZ string_typeZstring_sub_typeZstring_unicodeZstring_too_shortZstring_too_longZstring_pattern_mismatchrZ dict_typeZ mapping_typeZ list_typeZ tuple_typeZset_typeZ bool_typeZ bool_parsingZint_typeZ int_parsingZint_parsing_sizeZint_from_floatZ float_typeZ float_parsingZ bytes_typeZbytes_too_shortZbytes_too_longZbytes_invalid_encodingZ value_errorZassertion_errorZ literal_errorZ date_typeZ date_parsingZdate_from_datetime_parsingZdate_from_datetime_inexactZ date_pastZ date_futureZ time_typeZ time_parsingZ datetime_typeZdatetime_parsingZdatetime_object_invalidZdatetime_from_date_parsingZ datetime_pastZdatetime_futureZtimezone_naiveZtimezone_awareZtimezone_offsetZtime_delta_typeZtime_delta_parsingZfrozen_set_typeZis_instance_ofZis_subclass_ofZ callable_typeZunion_tag_invalidZunion_tag_not_foundZarguments_typeZmissing_argumentZunexpected_keyword_argumentZmissing_keyword_only_argumentZunexpected_positional_argumentZ missing_positional_only_argumentZmultiple_argument_valuesZurl_typeZ url_parsingZurl_syntax_violationZ url_too_longZ url_schemeZ uuid_typeZ uuid_parsingZ uuid_versionZ decimal_typeZdecimal_parsingZdecimal_max_digitsZdecimal_max_placesZdecimal_whole_digitsZ complex_typeZcomplex_str_parsing)kwargsr;cKsdd|DS)NcSsi|]\}}|dk r||qSr<r5).0kvr5r5r6 sz"_dict_not_none..)items)rr5r5r6rz srzc`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.)rprPrcKs"tdtt||fd|i|S)NrrPwarningswarnDeprecationWarningr0rprPrrr5r5r6field_before_validator_functions re`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.cOstdtt||S)Nrrargsrr5r5r6!general_before_validator_functions ra`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.cKs"tdtt||fd|i|S)NrrPrrrr4rr5r5r6field_after_validator_function's rc`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.cOstdtt||S)Nrrrr5r5r6 general_after_validator_function0s r_`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.cKs"tdtt||fd|i|S)NrrPrrrr>rr5r5r6field_wrap_validator_function9s ra`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.cOstdtt||S)Nrrrr5r5r6general_wrap_validator_functionDs ra`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.)rprPcKs tdtt|fd|i|S)NrrPrrrrB)rprPrr5r5r6field_plain_validator_functionMs rc`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.cOstdtt||S)Nrrrr5r5r6 general_plain_validator_functionVs r)FieldValidationInfoZFieldValidatorFunctionZGeneralValidatorFunctionZFieldWrapValidatorFunctionobject) attr_namer;cCsXt|}|dkr$td|dn0ddl}d|d|jd}|j|tdd|SdS) Nz)module 'pydantic_core' has no attribute ''r`z` is deprecated, use `z ` instead.) stacklevel)_deprecated_import_lookupgetAttributeErrorrr0rr)rZnew_attrrmsgr5r5r6 __getattr__js r)NN)NNNN)N)N)N)N)N)NN)N)NNN)r3Z __future__rZ _annotationssysrZcollections.abcrrrrrrrtypingr r r r r rrrrrrZtyping_extensionsr version_inforrrrrZ pydantic_corer ImportErrorrr%r r8r4r9rOrQrirfrkZ$GeneralPlainNoInfoSerializerFunctionZ"GeneralPlainInfoSerializerFunctionZ"FieldPlainNoInfoSerializerFunctionZ FieldPlainInfoSerializerFunctionrwrurnr{r|Z#GeneralWrapNoInfoSerializerFunctionZ!GeneralWrapInfoSerializerFunctionZ!FieldWrapNoInfoSerializerFunctionZFieldWrapInfoSerializerFunctionrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrZJsonTyperrrrrrrrrrrrrr rr r rrrrrrr+r!rrrrrrr rr-r!ZValidationFunctionr#r%r,r0r1r3r4r5r8r7r=r9ZWrapValidatorFunctionr:r<r>r?rArBrCrHrIrKrLrTrUrXrYr\r]rarbrfrgrnrorurvryrzr}r~rrrrrrrrrrrrrrrrrrcrrrrrrrrZMYPYrsZCoreSchemaTypeZCoreSchemaFieldTypeZ ErrorTyperzrrrrrrrrrrrr5r5r5r6sp   4       I &"     #     $0&3*: "*> '&4&4*<$1 "4 " %    "12 ,$3 "/ "/ $/$  *0  *2,3*0*0 *5,4 (+**48 $666S ""&6 $0 *%>? *%89@U2646@; (05,6,. ".2424  "95 h