F j#q z%SrSSKJr SSKrSSKrSSKJrJrJ r SSK J r J r J r J r SSKJr SSKJr SSKJrJrJrJrJr SS KJrJr \R6S :aSS KJr OSS KJr \R6S :a SS KJrJrJr O SS KJrJrJr \(aSSK J!r! OSSK J!r! \Sr$"SS\SS9r%Sr&S\'S'\"SSSS9r("SS\\(5r)"SS\)\(\5r*"SS \\(5r+\S!r,"S"S#\SS9r-GSGS$jr.\\/\4r/\\\)\/\4r0\\\/\4r1\\\\*\/\4r2\\/\0\1\24r3\S%r4"S&S'\SS9r5SSSS(S).GSHS*jjr6"S+S,\5r7\\\7/\4r8\\\7\)\/\4r9\\\\7/\4r:\\\\7\*\/\4r;\\8\9\:\;4r<"S-S.\SS9r=SSSSS(S/.GSIS0jjr>"S1S2\SS9r?S3S4.GSJS5jjr@"S6S7\SS9rAS3S4.GSKS8jjrB"S9S:\SS9rCGSLS;jrD\\-\5\=\?\A\C4rE"S<S=\SS9rFGSMGSNS>jjrG"S?S@\SS9rHSSSSA.GSOSBjjrI"SCSD\SS9rJSSSSE.GSPSFjjrK"SGSH\SS9rLSSSSE.GSQSIjjrM"SJSK\SS9rNGSRGSSSLjjrO"SMSN\SS9rPSSSSSSSSSSO. GSTSPjjrQ"SQSR\SS9rRSSSSSSSSSSSS. GSUSTjjrS"SUSV\SS9rTSSSSSSSSSSSSSW. GSVSXjjrU"SYSZ\SS9rVSSSSS[.GSWS\jjrW"S]S^\SS9rXSSSSSSSSSSSSS_. GSXS`jjrY"SaSb\SS9rZSSSSSSSc.GSYSdjjr["SeSf\SS9r\SSSSSSSSSSSg. GSZShjjr]"SiSj\SS9r^SSSSSSSkSSSSl. GS[Smjjr_"SnSo\SS9r`SSSSSSSSSkSSSSp. GS\Sqjjra"SrSs\SS9rbSSSSSSkSSSSt. GS]Sujjrc"SvSw\SS9rdSSSSE.GS^Sxjjre"SySz\SS9rfSSSSSSS{.GS_S|jjrg"S}S~\SS9rhGSMGS`Sjjri\Srj"SS\SS9rkSSSSS.GSaSjjrl"SS\SS9rmSSSSS.GSbSjjrn"SS\SS9roSSSSE.GScSjjrp"SS\SS9rqSSSSSS.GSdSjjrr"SS\SS9rsSSS.GSeSjjrt\\s\E4ru"SS\SS9rvGSfSSSSSSSS.GSgSjjjrwSSSSSS.GShSjjrxGSfSSSSSSS.GSiSjjjry"SS\SS9rzSSSSSSSSS.GSjSjjr{"SS\SS9r|GSfSSSSSSSS.GSkSjjjr}"SS\SS9r~GSfSSSSSSSS.GSlSjjjr"SS\SS9rGSfSSSSSS.GSmSjjjr\\\\4r"SS\SS9rSSS.GSnSjjr\\\E4r"SS\SS9rGSMSSSSSSSS.GSoSjjjr\\/\4r"SS\5r\\\+\/\4r"SS\SS9r\\\4r"SS\SS9r"SS\SS9rSSSSS.GSpSjjrSSSSSS.GSqSjjr"SS\SS9rSSSSS.GSrSjjrSSSSS.GSsSjjr"SS\5r\\\/\4r"SS\5r\\\\+\/\4r"SS\SS9r\\\4r"SS\SS9rSSSSS.GStSjjrSSSSSS.GSuSjjr"SS\SS9rSSSSS.GSvSjjrSSSSSS.GSwSjjr"SS\SS9r\!SSSSSSSSS. GSxSjjr"SS\SS9rSSSSS[.GSySjjr"SS\SS9rSSSSSSSSS.GSzSjjr"SS\SS9rSSSSSSSSS.GS{Sjjr"SS\SS9rSSSSE.GS|Sjjr"SS\SS9rSSSSS[.GS}Sjjr"SS\SS9rSSSSE.GS~Sjjr"SS\SS9rSSSSSSS.GSSjjr"SS\SS9rSSSSSSSSSSSS. GSSjjr"SS\SS9rSSSSSSS.GSSjjr"SS\SS9rSSSSSSSSSSS. GSSjjr"SS\SS9rSSSSSSSSSSSSS. GSSjjr"SS\SS9rSSSSSSSSSS. GSSjjr"SGS\SS9rSSSSSSGS.GSGSjjr"GSGS\SS9rSSSSSSSSSSSGS. GSGSjjr"GSGS\SS9rSSGS .GSGS jjr\GS rS\'GS '"GS GS\SS9rSSSSSSSSGS.GSGSjjr"GSGS\SS9rSSGS .GSGSjjr"GSGS\SS9rSSSSSSGS.GSGSjjr"GSGS\SS9rSSSSSGS.GSGSjjr"GSGS\SS9rSSSSSGS.GSGSjjr"GS GS!\SS9rGSfSSSSE.GSGS"jjjr"GS#GS$\SS9rSSSSSSSSSSSGS%. GSGS&jjr"GS'GS(\SS9rSSSSSSSSSSSGS%. GSGS)jjr"GS*GS+\SS9rGSGS,jr"GS-GS.\SS9rGSGSGS/jjrSr\(do\/\FP\JP\LP\NP\PP\RP\TP\XP\ZP\\P\^P\`P\bP\dP\hP\fP\kP\mP\oP\vP\zP\|P\~P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\qP\VP7rO\GS0r\GS1r\GS2rGSGS3jrGSGS4jr\"GS55GSGS6j5r\"GS75GS85r\"GS95GSGS:j5r\"GS;5GS<5r\"GS=5GSGS>j5r\"GS?5GS@5r\"GSA5GSGSBj5r\"GSC5GSD5r\+\\\GSE.r\(a\+rGSGSFjrg!\"a \#"5r!G Nf=f(ze This module contains definitions to build schemas which `pydantic_core` can validate and serialize. ) annotationsN) GeneratorHashableMapping)datedatetimetime timedelta)Decimal)Pattern) TYPE_CHECKINGAnyCallableLiteralUnion)TypeVar deprecated) ) TypedDict)r )ProtocolRequired TypeAlias)PydanticUndefined)allowforbidignorec<\rSrSr%SrS\S'S\S'S\S'S\S 'S\S 'S\S 'S \S 'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S 'S\S!'S"\S#'S$\S%'S\S&'S\S''S\S('S\S)'S\S*'S+rg,)- CoreConfig+a 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`. 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'. Note that if ser_json_temporal is set, then this param will be ignored. ser_json_temporal: The serialization option for datetime like values. Default is 'iso8601'. The types this covers are datetime, date, time and timedelta. If this is set, it will take precedence over ser_json_timedelta 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. validate_by_alias: Whether to use the field's alias when validating against the provided input data. Default is `True`. validate_by_name: Whether to use the field's name when validating against the provided input data. Default is `False`. Replacement for `populate_by_name`. serialize_by_alias: Whether to serialize by alias. Default is `False`, expected to change to `True` in V3. polymorphic_serialization: Whether to enable polymorphic serialization for models and dataclasses. Default is `False`. url_preserve_empty_path: Whether to preserve empty URL paths when validating values for a URL type. Defaults to `False`. strtitleboolstrict ExtraBehaviorextra_fields_behaviortyped_dict_totalfrom_attributes loc_by_alias0Literal['always', 'never', 'subclass-instances']revalidate_instancesvalidate_defaultintstr_max_lengthstr_min_lengthstr_strip_whitespace str_to_lower str_to_upper allow_inf_nanzLiteral['iso8601', 'float']ser_json_timedeltaz-Literal['iso8601', 'seconds', 'milliseconds']ser_json_temporalz Literal['utf8', 'base64', 'hex']ser_json_bytesz'Literal['null', 'constants', 'strings']ser_json_inf_nanval_json_byteshide_input_in_errorsvalidation_error_causecoerce_numbers_to_str"Literal['rust-regex', 'python-re'] regex_enginez+Union[bool, Literal['all', 'keys', 'none']] cache_stringsvalidate_by_aliasvalidate_by_nameserialize_by_aliaspolymorphic_serializationurl_preserve_empty_pathN)__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__rECc:\Py\emelo-reg\venv\Lib\site-packages\pydantic_core/core_schema.pyr r +s(T J L((JJ33DD44==44  44>>##!!rMr F)totalz2set[int | str] | dict[int | str, IncExCall] | Noner IncExCallContextTTz Any | None) covariantdefaultc&\rSrSrSr\SSj5r\SSj5r\SSj5r\SSj5r \SSj5r \SSj5r \SS j5r \SS j5r \SS j5r\SS j5r\SS j5r\SSj5rSSjrSSjrSSjrSrg)SerializationInfoz%Extra data used during serialization.cg)z0The `include` argument set during serialization.NrEselfs rNincludeSerializationInfo.include rMcg)z0The `exclude` argument set during serialization.NrErXs rNexcludeSerializationInfo.excluder\rMcg)z"The current serialization context.NrErXs rNcontextSerializationInfo.contextr\rMcg)z0The serialization mode set during serialization.NrErXs rNmodeSerializationInfo.moder\rMcg)z1The `by_alias` argument set during serialization.NrErXs rNby_aliasSerializationInfo.by_aliasr\rMcg)z6The `exclude_unset` argument set during serialization.NrErXs rN exclude_unsetSerializationInfo.exclude_unsetr\rMcg)z9The `exclude_defaults` argument set during serialization.NrErXs rNexclude_defaults"SerializationInfo.exclude_defaultsr\rMcg)z5The `exclude_none` argument set during serialization.NrErXs rN exclude_noneSerializationInfo.exclude_noner\rMcg)z@The `exclude_computed_fields` argument set during serialization.NrErXs rNexclude_computed_fields)SerializationInfo.exclude_computed_fieldsr\rMcg)z9The `serialize_as_any` argument set during serialization.NrErXs rNserialize_as_any"SerializationInfo.serialize_as_anyr\rMcg)zJThe `polymorphic_serialization` argument set during serialization, if any.NrErXs rNrC+SerializationInfo.polymorphic_serializationr\rMcg)z3The `round_trip` argument set during serialization.NrErXs rN round_tripSerializationInfo.round_tripr\rMcgNrErXs rN mode_is_jsonSerializationInfo.mode_is_jsonsCrMcgr~rErXs rN__str__SerializationInfo.__str__scrMcgr~rErXs rN__repr__SerializationInfo.__repr__ssrMrEN)returnrPrrQ)rzLiteral['python', 'json'] | str)rr$)r bool | Nonerr")rFrGrHrIrJpropertyrZr^rardrgrjrmrprsrvrCr{rrrrLrErMrNrUrUs/                         (!"rMrUc,\rSrSrSr\SSj5rSrg)FieldSerializationInfoz+Extra data used during field serialization.cg)z/The name of the current field being serialized.NrErXs rN field_name!FieldSerializationInfo.field_namer\rMrENr)rFrGrHrIrJrrrLrErMrNrrs5   rMrc|\rSrSrSr\S Sj5r\S Sj5r\S Sj5r\S Sj5r \SSj5r Sr g )ValidationInfoz"Extra data used during validation.cg)zThe current validation context.NrErXs rNraValidationInfo.contextr\rMcg)z/The CoreConfig that applies to this validation.NrErXs rNconfigValidationInfo.configr\rMcg)z3The type of input data we are currently validating.NrErXs rNrdValidationInfo.moder\rMcg)z(The data being validated for this model.NrErXs rNdataValidationInfo.datar\rMcg)z_ The name of the current field being validated if this validator is attached to a model field. NrErXs rNrValidationInfo.field_names rMrENr)rCoreConfig | None)rzLiteral['python', 'json'])rdict[str, Any])r str | None) rFrGrHrIrJrrarrdrrrLrErMrNrrsg,           rMr)noner.r$floatr"bytes bytearraylisttupleset frozenset generatordictrrr r urlmulti-host-urljsonuuidanyc \rSrSr%S\S'Srg)SimpleSerSchemaiz$Required[ExpectedSerializationTypes]typerENrFrGrHrIrKrLrErMrNrrs ..rMrc[US9$)zk Returns a schema for serialization with a custom type. Args: type: The type to use for serialization r)rrs rNsimple_ser_schemars  %%rM)alwaysz unless-nonerjson-unless-nonecR\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S rg) PlainSerializerFunctionSerSchemai6#Required[Literal['function-plain']]rzRequired[SerializerFunction]functionr$is_field_serializerinfo_arg CoreSchema return_schemaWhenUsed when_usedrENrrErMrNrr6s% --**NrMrr)rrrrc .US:XaSn[SUUUUUS9$)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 rNfunction-plain)rrrrrr_dict_not_none)rrrrrs rN$plain_serializer_function_ser_schemar?s0&H  /#  rMc"\rSrSrSSSjjrSrg)SerializerFunctionWrapHandleri_Ncgr~rE)rY input_value index_keys rN__call__&SerializerFunctionWrapHandler.__call__`sX[rMrEr~)rrrzint | str | NonerrrFrGrHrIrrLrErMrNrr_s[[rMrc\\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S 'Srg)WrapSerializerFunctionSerSchemais"Required[Literal['function-wrap']]rz Required[WrapSerializerFunction]rr$rrrschemarrrrENrrErMrNrrss+ ,,..N rMr)rrrrrc 0US:XaSn[SUUUUUUS9$)a 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 rN function-wrap)rrrrrrrr)rrrrrrs rN#wrap_serializer_function_ser_schemar}s3*H  /# rMc4\rSrSr%S\S'S\S'S\S'Srg ) FormatSerSchemaizRequired[Literal['format']]r Required[str]formatting_stringrrrENrrErMrNrrs %%$$rMrr)rc&US:XaSn[SXS9$)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 rNformat)rrrr)rrs rNformat_ser_schemars && x;L bbrMc*\rSrSr%S\S'S\S'Srg)ToStringSerSchemaizRequired[Literal['to-string']]rrrrENrrErMrNrrs ((rMrc,[SS9nUS:waXS'U$)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-stringrrr)r)rss rNto_string_ser_schemars# +A&&"+ HrMc4\rSrSr%S\S'S\S'S\S'Srg ) ModelSerSchemaiRequired[Literal['model']]rRequired[type[Any]]clsRequired[CoreSchema]rrENrrErMrNrrs $$   rMrc[SXS9$)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)rrr)r)rrs rNmodel_ser_schemars wC ??rMc>\rSrSr%S\S'S\S'S\S'S\S 'S rg ) InvalidSchemaizRequired[Literal['invalid']]rr"refrmetadata SerSchema serializationrENrrErMrNrrs && HrMrc[SXS9$)a Returns an invalid schema, used to indicate that a schema is invalid. 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)rrrr)rrs rNinvalid_schemars yc EErMcR\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'Srg) ComputedFieldiz#Required[Literal['computed-field']]rr property_namerrr"aliasCallable[[Any], bool]serialization_exclude_ifrrrENrrErMrNrrs% --  '' J33rMr)rrrc [SUUUUUS9$)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)rrrrrrr)rrrrrs rNcomputed_fieldrs#"  ##!9  rMc>\rSrSr%S\S'S\S'S\S'S\S 'S rg ) AnySchemaizRequired[Literal['any']]rr"rrrrrrENrrErMrNrrs "" HrMrrrrc[SXUS9$)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 rrrrrrrs rN any_schemar"s& u#P] ^^rMc>\rSrSr%S\S'S\S'S\S'S\S 'S rg ) NoneSchemai8zRequired[Literal['none']]rr"rrrrrrENrrErMrNrr8s ## HrMrc[SXUS9$)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 rrrrs rN none_schemar ?s& v3Q^ __rMcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg ) BoolSchemaiUzRequired[Literal['bool']]rr$r%r"rrrrrrENrrErMrNr r Us ## L HrMr c[SXX#S9$)a1 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$rr%rrrrr%rrrs rN bool_schemar]s. vf nnrMcz\rSrSr%S\S'S\S'S\S'S\S'S\S'S\S 'S \S 'S \S 'S\S'S\S'Srg) IntSchemaiwzRequired[Literal['int']]rr. multiple_oflegeltgtr$r%r"rrrrrrENrrErMrNrrws8 "" G G G G L HrMr rrrrrr%rrrc &[SUUUUUUUUUS9 $)am 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.) rrrrrrr%rrrrrs rN int_schemars0D    #  rMc\rSrSr%S\S'S\S'S\S'S\S'S\S 'S\S 'S\S 'S\S 'S \S'S\S'S\S'Srg) FloatSchemaizRequired[Literal['float']]rr$r4rrrrrrr%r"rrrrrrENrrErMrNrrs> $$ I I I I L HrMr r4rrrrrr%rrrc ([SUUUUUUUUUU S9 $)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 r) rr4rrrrrr%rrrrrs rN float_schemars3H  #  #  rMc\rSrSr%S\S'S\S'S\S'S\S'S\S 'S\S 'S\S 'S \S 'S \S'S\S'S\S'S\S'S\S'Srg) DecimalSchemaizRequired[Literal['decimal']]rr$r4r rrrrrr. max_digitsdecimal_placesr%r"rrrrrrENrrErMrNr!r!sI &&KKKKO L HrMr! r4rrrrrr"r#r%rrrc ,[SUUUUUUUUUU U U S9 $)aN 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) rrrrrr"r#rr4r%rrrrr$s rNdecimal_schemar's9R   %# # rMcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg ) ComplexSchemai?zRequired[Literal['complex']]rr$r%r"rrrrrrENrrErMrNr)r)?s && L HrMr)rc[SUUUUS9$)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 complexrrrs rNcomplex_schemar,Gs 2   #  rMc\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S 'S \S'S \S'S \S'S\S'S\S'S\S'Srg) StringSchemaiizRequired[Literal['str']]rzUnion[str, Pattern[str]]patternr. max_length min_lengthr$strip_whitespaceto_lowerto_upperr=r>r%r<r"rrrrrrENrrErMrNr.r.isJ "" %%OONN44 L HrMr. r/r0r1r2r3r4r>r%r<rrrc ,[SUUUUUUUUUU U U S9 $)a 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") rr/r0r1r2r3r4r>r%r<rrrrr5s rN str_schemar7ys9Z  )!3 # rMc\\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S'Srg) BytesSchemaizRequired[Literal['bytes']]rr.r0r1r$r%r"rrrrrrENrrErMrNr9r9s( $$OO L HrMr9r0r1r%rrrc  [SUUUUUUS9$)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 r)rr0r1r%rrrrr:s rN bytes_schemar<s&8   # rMc\rSrSr%S\S'S\S'S\S'S\S'S\S 'S\S 'S \S 'S \S'S\S'S\S'S\S'Srg) DateSchemaizRequired[Literal['date']]rr$r%rrrrrLiteral['past', 'future']now_opr.now_utc_offsetr"rrrrrrENrrErMrNr>r>s@ ## L H H H H %% HrMr> r%rrrrr@rArrrc ([SUUUUUUUUUU S9 $)a0 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) rr%rrrrr@rArrrrrBs rN date_schemarDs3J   % #  rMc\rSrSr%S\S'S\S'S\S'S\S'S\S 'S\S 'S \S 'S \S'S\S'S\S'S\S'Srg) TimeSchemai,zRequired[Literal['time']]rr$r%r rrrr%Union[Literal['aware', 'naive'], int] tz_constraintLiteral['truncate', 'error']microseconds_precisionr"rrrrrrENrrErMrNrFrF,s> ## L H H H H8888 HrMrFtruncate r%rrrrrHrJrrrc ([SUUUUUUUUUU S9 $)a8 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 ) rr%rrrrrHrJrrrrrLs rN time_schemarN:s3J   #5 #  rMc\rSrSr%S\S'S\S'S\S'S\S'S\S 'S\S 'S \S 'S \S'S\S'S\S'S\S'S\S'S\S'Srg)DatetimeSchemainzRequired[Literal['datetime']]rr$r%rrrrrr?r@rGrHr.rArIrJr"rrrrrrENrrErMrNrPrPnsL '' LLLLL %%8888 HrMrP r%rrrrr@rHrArJrrrc ,[SUUUUUUUUUU U U S9 $)ad 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) rr%rrrrr@rHrArJrrrrrQs rNdatetime_schemarSs9V   #%5 # rMcz\rSrSr%S\S'S\S'S\S'S\S'S\S 'S\S 'S \S 'S \S'S\S'S\S'Srg)TimedeltaSchemaizRequired[Literal['timedelta']]rr$r%r rrrrrIrJr"rrrrrrENrrErMrNrUrUs8 (( LMMMM88 HrMrU r%rrrrrJrrrc &[SUUUUUUUUUS9 $)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 ) rr%rrrrrJrrrrrVs rNtimedelta_schemarXs0F   5 #  rMcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg ) LiteralSchemaizRequired[Literal['literal']]rRequired[list[Any]]expectedr"rrrrrrENrrErMrNrZrZs &&!! HrMrZc[SXX#S9$)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)rr\rrrr)r\rrrs rNliteral_schemar_s0 y8x uurMcp\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S\S'S\S'S\S'Srg) EnumSchemaizRequired[Literal['enum']]r Required[Any]rr[memberszLiteral['str', 'int', 'float']sub_typezCallable[[Any], Any]missingr$r%r"rrrrrrENrrErMrNraras6 ##   ,, !! L HrMra)rdrer%rrrc $[SUUUUUUUUS9 $)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) rrrcrdrer%rrrr)rrcrdrer%rrrs rN enum_schemarh)s-L    #  rMc4\rSrSr%S\S'S\S'S\S'Srg ) MissingSentinelSchemai\z%Required[Literal['missing-sentinel']]rrrrrrENrrErMrNrjrj\s //rMrjc[SUUS9$)z,Returns a schema for the `MISSING` sentinel.missing-sentinel)rrrr)rrs rNmissing_sentinel_schemarmbs  # rM)nullr$r.rr"rrcR\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S rg)IsInstanceSchemaisz Required[Literal['is-instance']]rrbrr"cls_reprrrrrrrENrrErMrNrprpss$ ** M HrMrp)rqrrrc [SXX#US9$)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-instancerrrqrrrrrrqrrrs rNis_instance_schemarv|s:  Cbo rMcR\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S rg)IsSubclassSchemaiz Required[Literal['is-subclass']]rrrr"rqrrrrrrENrrErMrNrxrxs$ ** M HrMrxc [SXX#US9$)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-subclassrtrrus rNis_subclass_schemar{s@  Cbo rMc>\rSrSr%S\S'S\S'S\S'S\S 'S rg ) CallableSchemaizRequired[Literal['callable']]rr"rrrrrrENrrErMrNr}r}s '' HrMr}c[SXUS9$)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 callablerrrs rNcallable_schemars& zsUb ccrMcR\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'Srg) UuidSchemaizRequired[Literal['uuid']]rzLiteral[1, 3, 4, 5, 7]versionr$r%r"rrrrrrENrrErMrNrrs$ ## ## L HrMrrr%rrrc [SXX#US9$)Nr)rrr%rrrrrs rN uuid_schemars  W_l rMc4\rSrSr%S\S'S\S'S\S'Srg) IncExSeqSerSchemaiz-Required[Literal['include-exclude-sequence']]rzset[int]rZr^rENrrErMrNrrs 77  rMrrZr^c[SXS9$)Nzinclude-exclude-sequencerrZr^rrs rNfilter_seq_schemars 97 \\rMcp\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'S\S'Srg) ListSchemai zRequired[Literal['list']]rr items_schemar.r1r0r$ fail_fastr%r"rrrIncExSeqOrElseSerSchemarrENrrErMrNrr s3 ##OOO L H**rMr)r1r0rr%rrrc $[SUUUUUUUUS9 $)aV 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 rrr1r0rr%rrrrrr1r0rr%rrrs rN list_schemars-@  ! #  rM) extras_schemar%rrr TupleSchemac JUb[U5nX/-nOSn[UUUUUUS9$)aE 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%rrrrs rNtuple_positional_schemarFsEB !,/#o5 " !/ #  rM)r1r0r%rrrc F[U=(d [5/SUUUUUUS9$)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)rrr1r0r%rrr)rr)rr1r0r%rrrs rNtuple_variable_schemarws4@ "2jl3 #  rMcz\rSrSr%S\S'S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S\S'S\S'Srg)rizRequired[Literal['tuple']]rRequired[list[CoreSchema]]rr.rr1r0r$rr%r"rrrrrrENrrErMrNrrs9 $$,,OOO L H**rM)rr1r0rr%rrrc &[SUUUUUUUUUS9 $)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) rrrr1r0rr%rrrr) rrr1r0rr%rrrs rNrrs0J  !/ #  rMcp\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'S\S'Srg) SetSchemaizRequired[Literal['set']]rrrr.r1r0r$rr%r"rrrrrrENrrErMrNrrs3 ""OOO L HrMrc $[SUUUUUUUUS9 $)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 rrrrs rN set_schemars-D  ! #  rMcp\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'S\S'Srg)FrozenSetSchemaizRequired[Literal['frozenset']]rrrr.r1r0r$rr%r"rrrrrrENrrErMrNrrs3 ((OOO L HrMrc $[SUUUUUUUUS9 $)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 rrrrs rNfrozenset_schemar*s-D  ! #  rMc\\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S'Srg)GeneratorSchemaiYzRequired[Literal['generator']]rrrr.r1r0r"rrrrrrENrrErMrNrrYs) ((OO H**rMr)r1r0rrrc  [SUUUUUUS9$)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)rrr1r0rrrr)rr1r0rrrs rNgenerator_schemarcs'H  ! # rMc4\rSrSr%S\S'S\S'S\S'Srg) IncExDictSerSchemaiz)Required[Literal['include-exclude-dict']]r IncExDictrZr^rENrrErMrNrrs 33  rMrc[SXS9$)Nzinclude-exclude-dictrrrs rNfilter_dict_schemars 5w XXrMcz\rSrSr%S\S'S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S\S'S\S'Srg) DictSchemaizRequired[Literal['dict']]rr keys_schema values_schemar.r1r0r$rr%r"rrrIncExDictOrElseSerSchemarrENrrErMrNrrs9 ##OOO L H++rMrc &[SUUUUUUUUUS9 $)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 fail_fast: Stop validation on the first error 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) rrrr1r0rr%rrrr) rrr1r0rr%rrrs rN dict_schemars0H  # #  rMc*\rSrSr%S\S'S\S'Srg)NoInfoValidatorFunctionSchemaiLiteral['no-info']rNoInfoValidatorFunctionrrENrrErMrNrrs %%rMrc4\rSrSr%S\S'S\S'S\S'Srg ) WithInfoValidatorFunctionSchemaiRequired[Literal['with-info']]rz#Required[WithInfoValidatorFunction]rr"rrENrrErMrNrrs ((11OrMrcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg )_ValidatorFunctionSchemaiRequired[ValidationFunction]rrrr"rrrrrrENrrErMrNrrs**  HrMrc*\rSrSr%S\S'S\S'Srg)BeforeValidatorFunctionSchemaiz$Required[Literal['function-before']]rrjson_schema_input_schemarENrrErMrNrrs ..((rMr)rrrrc &[SSUS.UUUUUS9$)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-inforrrrrrrrrrrrrrrrs rN!no_info_before_validator_functionrs,F  #: !9# rM)rrrrrc jUb[R"S[SS9 [S[SXS9UUUUUS9$)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() ) 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 this validator is applied to, if any (deprecated) 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 zThe `field_name` argument on `with_info_before_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead. stacklevelr with-inforrrrwarningswarnDeprecationWarningr)rrrrrrrs rN#with_info_before_validator_functionr2sNP  e   [8[ !9# rMc \rSrSr%S\S'Srg)AfterValidatorFunctionSchemailz#Required[Literal['function-after']]rrENrrErMrNrrls --rMrc &[SSUS.UUUUUS9$)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-afterrrrrrs rN no_info_after_validator_functionrps,B  #: !9# rM)rrrrc hUb[R"S[SS9 [S[SXS9UUUUS9$)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() ) 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 validator is applied to, if any (deprecated) 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 zThe `field_name` argument on `with_info_after_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrr)rrrrrrr)rrrrrrs rN"with_info_after_validator_functionrsKL  d   [8[ #  rMc"\rSrSrSSSjjrSrg)ValidatorFunctionWrapHandleriNcgr~rE)rYrouter_locations rNr%ValidatorFunctionWrapHandler.__call__s rMrEr~)rrrzstr | int | NonerrrrErMrNrrs   rMrc*\rSrSr%S\S'S\S'Srg)!NoInfoWrapValidatorFunctionSchemairrNoInfoWrapValidatorFunctionrrENrrErMrNrrs ))rMrc4\rSrSr%S\S'S\S'S\S'Srg ) #WithInfoWrapValidatorFunctionSchemairrz'Required[WithInfoWrapValidatorFunction]rr"rrENrrErMrNrrs ((55OrMrc\\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S\S'Srg)WrapValidatorFunctionSchemairrzRequired[WrapValidatorFunction]rrrr"rrrrrrrrENrrErMrNrrs+ ,,--  H((rMrc &[SSUS.UUUUUS9$)az 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 rrrrrrrrrrrrs rNno_info_wrap_validator_functionrs,L  #:!9 # rM)rrrrrc jUb[R"S[SS9 [S[SXS9UUUUUS9$)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 validator is applied to, if any (deprecated) 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 zThe `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrrrr)rrrrrrrs rN!with_info_wrap_validator_functionr) sNR  c   [8[!9 # rMcR\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'Srg)PlainValidatorFunctionSchemaid rrrrr"rrrrrrrrENrrErMrNrrd s% --** H((rMrc $[SSUS.UUUUS9$)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 rrrrrrrrrr)rrrrrs rN no_info_plain_validator_functionrm s(<  #: !9#  rMc hUb[R"S[SS9 [S[SXS9UUUUS9$)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 validator is applied to, if any (deprecated) 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 zThe `field_name` argument on `with_info_plain_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrrrr)rrrrrrs rN"with_info_plain_validator_functionr sK@  d   [8[ !9#  rMc\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S \S'S\S'S\S'S\S'Srg)WithDefaultSchemai zRequired[Literal['default']]rrrrrSz9Union[Callable[[], Any], Callable[[dict[str, Any]], Any]]default_factoryr$default_factory_takes_dataz#Literal['raise', 'omit', 'default']on_errorr-r%r"rrrrrrENrrErMrNrr sA &&  LNN $$11 L HrMr) rSrrrr-r%rrrc D[SUUUUUUUUU S9 n U[LaXS'U $)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 rS) rrrrrr-r%rrr)rr) rrSrrrr-r%rrrrs rNwith_default_schemar sDN  '#=) # A'') HrMcR\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'Srg)NullableSchemai zRequired[Literal['nullable']]rrrr$r%r"rrrrrrENrrErMrNrr s$ ''  L HrMrc [SXX#US9$)ac 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)rrr%rrrr)rr%rrrs rNnullable_schemar s4  3an rMc\rSrSr%S\S'S\S'S\S'S\S 'S\S 'S \S 'S \S'S\S'S\S'S\S'S\S'Srg) UnionSchemai4 zRequired[Literal['union']]rz9Required[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']rdr%rrrrrrENrrErMrNrr4 sB $$ FF;; ++ L HrMr)rrr r rdrrrc &[SUUUUUUUUUS9 $)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 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) rrrrr r rdrrrr) rrrr r rdrrrs rN union_schemarC s0J  #+11  #  rMc\rSrSr%S\S'S\S'S\S'S\S 'S\S 'S \S 'S \S'S \S'S\S'S\S'S\S'Srg)TaggedUnionSchemaiv z!Required[Literal['tagged-union']]rz$Required[dict[Hashable, CoreSchema]]rzcRequired[Union[str, list[Union[str, int]], list[list[Union[str, int]]], Callable[[Any], Hashable]]] discriminatorr"rr r r r$r%r)rrrrrrENrrErMrNrrv sB ++ 11vv;; L HrMr)rr r r%r)rrrc([SUUUUUUUUUU S9 $)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) rrrrr r r%r)rrrr) rrrr r r%r)rrrs rNtagged_union_schemar s3H  #+11' #  rMcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg ) ChainSchemai zRequired[Literal['chain']]rrstepsr"rrrrrrENrrErMrNrr s $$ %% HrMrc[SXX#S9$)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)rrrrrr)rrrrs rN chain_schemar s> wex mmrMc\\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S'Srg)LaxOrStrictSchemai z"Required[Literal['lax-or-strict']]rr lax_schema strict_schemar$r%r"rrrrrrENrrErMrNrr s* ,,$$'' L HrMrc  [SUUUUUUS9$)a8 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)rrrr%rrrr)rrr%rrrs rNlax_or_strict_schemar! s'V  # # rMcR\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S rg)JsonOrPythonSchemaiA z#Required[Literal['json-or-python']]rr json_schema python_schemar"rrrrrrENrrErMrNr#r#A s% --%%'' HrMr#c [SUUUUUS9$)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)rr$r%rrrr)r$r%rrrs rNjson_or_python_schemar(J s$L  # #  rMcf\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S\S 'S \S'S\S'Srg)TypedDictFieldiz z%Required[Literal['typed-dict-field']]rrrr$required>Union[str, list[Union[str, int]], list[list[Union[str, int]]]]validation_aliasr"serialization_aliasserialization_excluderrrrrENrrErMrNr*r*z s1 //  NTT33rMr*)r+r-r.r/rrc "[SUUUUUUUS9$)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 serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value. metadata: Any other information you want to include with the schema, not used by pydantic-core typed-dict-field)rrr+r-r.r/rrr)rr+r-r.r/rrs rNtyped_dict_fieldr2 s)8  )/3!9  rMc\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S\S'S\S'S \S'S\S'S\S'S\S'S\S'Srg)TypedDictSchemai zRequired[Literal['typed-dict']]rz#Required[dict[str, TypedDictField]]fields type[Any]rr"cls_namelist[ComputedField]computed_fieldsr$r%rrr&extra_behaviorrOrrrrrr rrENrrErMrNr4r4 sK )) // NM(( L!! K H rMr4) rr7r9r%rr:rOrrrrc ,[SUUUUUUUUUU U U S9 $)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 cls_name: The name to use in error locations. Falls back to `cls.__name__`, or the validator name if no class is provided. 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 serialization: Custom serialization schema typed-dict) rr5rr7r9r%rr:rOrrrrr) r5rr7r9r%rr:rOrrrrs rNtyped_dict_schemar= s9^   '#% # rMcf\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S\S'Srg) ModelFieldi z Required[Literal['model-field']]rrrr,r-r"r.r$r/rrfrozenrrrENrrErMrNr?r? s1 **  TT33 LrMr?)r-r.r/rr@rc "[SUUUUUUUS9$)a 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 serialization_exclude_if: A Callable that determines whether to exclude a field during serialization based on its value. frozen: Whether the field is frozen metadata: Any other information you want to include with the schema, not used by pydantic-core model-field)rrr-r.r/rr@rr)rr-r.r/rr@rs rN model_fieldrC s)8  )/3!9  rMc\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S\S'S \S'S\S'S\S'S\S'Srg)ModelFieldsSchemai1 z!Required[Literal['model-fields']]rzRequired[dict[str, ModelField]]r5r" model_namer8r9r$r%rrextras_keys_schemar&r:r)rrrrrrENrrErMrNrErE1 sG ++ ++O(( L""!! HrMrE) rFr9r%rrGr:r)rrrc *[SUUUUUUUUUU U S9 $)a Returns a schema that matches the fields of a Pydantic model, 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 of the model 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 model is strict extras_schema: The schema to use when validating extra input data extras_keys_schema: The schema to use when validating the keys of extra input data 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 model fields from_attributes: Whether the model fields should be populated from attributes serialization: Custom serialization schema model-fields) rr5rFr9r%rrGr:r)rrrr) r5rFr9r%rrGr:r)rrrs rNmodel_fields_schemarJ@ s6R  '#-%' #  rMc\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S\S'S \S'S \S'S\S'S\S'S \S'S\S'S\S'Srg) ModelSchemaiy rrrrr6generic_originrrr$ custom_init root_modelr" post_initr+r,r%r@r&r:r rrrrrrrENrrErMrNrLrLy sX $$   NJJ L L!!  HrMrL) rMrNrOrPr,r%r@r:rrrrc 0[SUUUUUUUUUU U U U U S9$)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)rrrMrrNrOrPr,r%r@r:rrrrr)rrrMrNrOrPr,r%r@r:rrrrs rN model_schemarR s?D   %1% # rMc\rSrSr%S\S'S\S'S\S'S\S 'S\S 'S\S 'S\S 'S \S'S\S'S\S'S\S'S\S'Srg)DataclassFieldi z$Required[Literal['dataclass-field']]rrnamerrr$kw_onlyinit init_onlyr@r,r-r"r.r/rrrrrENrrErMrNrTrT sF ..   M JO LTT33rMrT) rVrWrXr-r.r/rrr@c *[SUUUUUUUUU UU S9 $)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 serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value. metadata: Any other information you want to include with the schema, not used by pydantic-core frozen: Whether the field is frozen dataclass-field) rrUrrVrWrXr-r.r/rrr@r) rUrrVrWrXr-r.r/rrr@s rNdataclass_fieldr[ s6R    )/3!9  rMcp\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S\S'S\S'S\S'Srg)DataclassArgsSchemai( z#Required[Literal['dataclass-args']]rrdataclass_namezRequired[list[DataclassField]]r5r8r9r$collect_init_onlyr"rrrrrr&r:rENrrErMrNr]r]( s7 --!! **(( H!!rMr])r9r_rrrr:c $[SUUUUUUUUS9 $)aM 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 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) rr^r5r9r_rrrr:r)r^r5r9r_rrrr:s rNdataclass_args_schemarb4 s-L  %'+ #%  rMc\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S\S'S\S'S\S'S\S'S \S'S\S'S\S'S\S'S\S'Srg)DataclassSchemaig zRequired[Literal['dataclass']]rrrr6rMrrzRequired[list[str]]r5r"r7r$rPr+r,r%r@rrrrrslotsr rrENrrErMrNrdrdg sV ((   MOJJ L L H K rMrd) rMr7rPr,r%rrrr@rerc 0[SUUUUUUUUUU U U U U S9$)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)rrrMr5r7rrPr,r%rrrr@rerr)rrr5rMr7rPr,r%rrrr@rers rNdataclass_schemarhy s?P   %1 # rMc>\rSrSr%S\S'S\S'S\S'S\S 'S rg ) ArgumentsParameteri rrUrrzCLiteral['positional_only', 'positional_or_keyword', 'keyword_only']rdr,rrENrrErMrNrjrj s   MM IIrMrj)rdrc[XX#S9$)aU 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 rUrrdrrrls rNarguments_parameterrm s6 t KKrM)uniformzunpacked-typed-dict VarKwargsModecz\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'S\S'S\S'Srg)ArgumentsSchemai zRequired[Literal['arguments']]rz"Required[list[ArgumentsParameter]]arguments_schemar$rAr@rvar_args_schemarovar_kwargs_modevar_kwargs_schemar"rrrrrrENrrErMrNrqrq s= ((88""!! HrMrq)rAr@rsrtrurrrc &[SUUUUUUUUUS9 $)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 validate_by_name: Whether to populate by the parameter names, defaults to `False`. validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`. 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 arguments) rrrrAr@rsrtrurrrr) rwrAr@rsrtrurrrs rNrrrr s0T  ")+''+ #  rMc>\rSrSr%S\S'S\S'S\S'S\S 'S rg ) ArgumentsV3Parameteri!rrUrrzLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict']rdr,rrENrrErMrNryry!s!     JIrMryc[XX#S9$)a_ Returns a schema that matches an argument parameter, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param = core_schema.arguments_v3_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) schema = core_schema.arguments_v3_schema([param]) v = SchemaValidator(schema) assert v.validate_python({'a': '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 rlrrls rNarguments_v3_parameterr{/sF t KKrMcf\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S'S\S'Srg)ArgumentsV3SchemaiUz!Required[Literal['arguments-v3']]rz$Required[list[ArgumentsV3Parameter]]rrr$rAr@zLiteral['forbid', 'ignore']r:r"rrrrrrENrrErMrNr}r}Us1 ++::// HrMr})rAr@r:rrrc "[SUUUUUUUS9$)a Returns a schema that matches an arguments schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param_a = core_schema.arguments_v3_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) param_b = core_schema.arguments_v3_parameter( name='kwargs', schema=core_schema.bool_schema(), mode='var_kwargs_uniform' ) schema = core_schema.arguments_v3_schema([param_a, param_b]) v = SchemaValidator(schema) assert v.validate_python({'a': 'hi', 'kwargs': {'b': True}}) == (('hi',), {'b': True}) ``` This schema is currently not used by other Pydantic components. In V3, it will most likely become the default arguments schema for the `'call'` schema. Args: arguments: The arguments to use for the arguments schema. validate_by_name: Whether to populate by the parameter names, defaults to `False`. validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`. extra_behavior: The extra behavior to use. 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. arguments-v3)rrrrAr@r:rrrr)rwrAr@r:rrrs rNarguments_v3_schemar`s*N  ")+% #  rMcf\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S\S 'S \S'S\S'Srg) CallSchemaizRequired[Literal['call']]rrrrzRequired[Callable[..., Any]]rr" function_namerrrrrrrrENrrErMrNrrs1 ##**** HrMr)rrrrrc "[SUUUUUUUS9$)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)rrrrrrrrrr)rwrrrrrrs rN call_schemars*T  "## #  rMcf\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S\S 'S \S'S\S'Srg)CustomErrorSchemaiz!Required[Literal['custom-error']]rrrrrr"r r r rrrrrrENrrErMrNrrs1 ++  $$;; HrMr)r r rrrc "[SUUUUUUUS9$)av 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)rrrr r rrrr)rrr r rrrs rNcustom_error_schemars*D  +11 #  rMcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg ) JsonSchemai zRequired[Literal['json']]rrrr"rrrrrrENrrErMrNrr s ##  HrMrc[SXX#S9$)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 r)rrrrrr)rrrrs rNr$r$sV vf nnrMc\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S\S 'S \S 'S\S'S \S'S\S'S\S'Srg) UrlSchemaiCzRequired[Literal['url']]rr.r0 list[str]allowed_schemesr$ host_requiredr" default_host default_port default_pathr%rrrrrrENrrErMrNrrCsA ""O L HrMr r0rrrrrpreserve_empty_pathr%rrrc *[SUUUUUUUUUU U S9 $)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 preserve_empty_path: Whether to preserve an empty path or convert it to '/', default False 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 r rr0rrrrrrr%rrrrrs rN url_schemarQs6N  '#!!!/ #  rMc\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S\S 'S \S 'S\S'S \S'S\S'S\S'Srg)MultiHostUrlSchemaiz#Required[Literal['multi-host-url']]rr.r0rrr$rr"rrrr%rrrrrrENrrErMrNrrsA --O L HrMrc *[SUUUUUUUUUU U S9 $)a5 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 preserve_empty_path: Whether to preserve an empty path or convert it to '/', default False 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 rrrrs rNmulti_host_url_schemars6N  '#!!!/ #  rMcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg )DefinitionsSchemaiz Required[Literal['definitions']]rrrr definitionsrrrrrENrrErMrNrrs **  ++rMrc[SXS9$)a& 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)rrr)r)rrs rNdefinitions_schemars( - XXrMcH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg )DefinitionReferenceSchemaiz#Required[Literal['definition-ref']]rr schema_refr"rrrrrrENrrErMrNrrs -- HrMrc[SXX#S9$)a+ 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)rrrrrr)rrrrs rNdefinition_reference_schemars:  * rM)4rrrr$r.rr&r"rrr rr r^rlrgrsrzrrrrrrrrrrrrSrr rrr r'r<rIrrargrwrrrrrrrrrr+)rBrZr1r)hno_such_attribute json_invalid json_typeneeds_python_objectrecursion_loopre frozen_fieldfrozen_instanceextra_forbidden invalid_keyget_attribute_error model_typemodel_attributes_typedataclass_typedataclass_exact_typedefault_factory_not_called none_required greater_thangreater_than_equal less_thanless_than_equalr finite_number too_shorttoo_long iterable_typeiteration_error string_typestring_sub_typestring_unicodestring_too_shortstring_too_longstring_pattern_mismatchstring_not_asciirg dict_type mapping_type list_type tuple_typeset_typeset_item_not_hashable bool_type bool_parsingint_type int_parsingint_parsing_sizeint_from_float float_type float_parsing bytes_typebytes_too_shortbytes_too_longbytes_invalid_encoding value_errorassertion_error literal_errormissing_sentinel_error date_type date_parsingdate_from_datetime_parsingdate_from_datetime_inexact date_past date_future time_type time_parsing datetime_typedatetime_parsingdatetime_object_invaliddatetime_from_date_parsing datetime_pastdatetime_futuretimezone_naivetimezone_awaretimezone_offsettime_delta_typetime_delta_parsingfrozen_set_typeis_instance_ofis_subclass_of callable_typeunion_tag_invalidunion_tag_not_foundarguments_typemissing_argumentunexpected_keyword_argumentmissing_keyword_only_argumentunexpected_positional_argument missing_positional_only_argumentmultiple_argument_valuesurl_type url_parsingurl_syntax_violation url_too_long url_scheme uuid_type uuid_parsing uuid_version decimal_typedecimal_parsingdecimal_max_digitsdecimal_max_placesdecimal_whole_digits complex_typecomplex_str_parsingc bUR5VVs0sH upUcM X_M snn$s snnfr~)items)kwargskvs rNrrs(#\\^ =^TQqDAD^ == =s ++c#h# USH%n[U[5(a USv M!Uv M' g7f)z/Iterate over the choices of a `'union'` schema.rrN) isinstancer)rchoices rNiter_union_choicesrs/y) fe $ $)OL *s02c`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.c T[R"S[5 [X4SU0UD6$)Nrrrrrrrrrrs rNfield_before_validator_functionrs, MMm /x aJ aZ` aarMe`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.cN[R"S[5 [U0UD6$)Nrrargsrs rN!general_before_validator_functionr"s& MMo / ? ??rMa`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.c T[R"S[5 [X4SU0UD6$)Nr#rrrrrrs rNfield_after_validator_functionr&!s, MMk .h `: `Y_ ``rMc`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.cN[R"S[5 [U0UD6$)Nr'r%r s rN general_after_validator_functionr)*& MMm .t >v >>rM_`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.c T[R"S[5 [X4SU0UD6$)Nr+rrrrrrs rNfield_wrap_validator_functionr.3s. MMi -X _* _X^ __rMa`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.cN[R"S[5 [U0UD6$)Nr/r-r s rNgeneral_wrap_validator_functionr1>s& MMk -d =f ==rMa`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.c T[R"S[5 [U4SU0UD6$)Nr2rrrrr)rrrs rNfield_plain_validator_functionr5Gs, MMk .h X: XQW XXrMc`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.cN[R"S[5 [U0UD6$)Nr6r4r s rN general_plain_validator_functionr8Pr*rM)FieldValidationInfoFieldValidatorFunctionGeneralValidatorFunctionFieldWrapValidatorFunctionc[RU5nUc[SUS35eSSKnSUSURS3nUR "U[ SS9 U$) Nz)module 'pydantic_core' has no attribute ''r`z` is deprecated, use `z ` instead.r)_deprecated_import_lookupgetAttributeErrorrrFrr) attr_namenew_attrrmsgs rN __getattr__rGdsc(,,Y7HH STUVV)283D3D2EZP c-!<rM)rExpectedSerializationTypesrr) rSerializerFunctionrrrrrCoreSchema | Nonerrrr)rWrapSerializerFunctionrrrrrrJrrJrrrr)rr"rrrr)rrrr)rr6rrrr)NN)rrrdict[str, Any] | Nonerr) rr"rrrrrCallable[[Any], bool] | NonerrLrr)rrrrLrSerSchema | Nonerr)rrrrLrrNrr)NNNN) r%rrrrrLrrNrr )r int | NonerrOrrOrrOrrOr%rrrrrLrrNrr)r4rr float | NonerrPrrPrrPrrPr%rrrrrLrrNrr)r4rrDecimal | NonerrQrrQrrQrrQr"rOr#rOr%rrrrrLrrNrr!) r%rrrrrLrrNrr))r/zstr | Pattern[str] | Noner0rOr1rOr2rr3rr4rr>z)Literal['rust-regex', 'python-re'] | Noner%rr<rrrrrLrrNrr.)r0rOr1rOr%rrrrrLrrNrr9)r%rr date | NonerrRrrRrrRr@ Literal['past', 'future'] | NonerArOrrrrLrrNrr>)r%rr time | NonerrTrrTrrTrH&Literal['aware', 'naive'] | int | NonerJrIrrrrLrrNrrF)r%rrdatetime | NonerrVrrVrrVr@rSrHrUrArOrJrIrrrrLrrNrrP)r%rrtimedelta | NonerrWrrWrrWrJrIrrrrLrrNrrU) r\ list[Any]rrrrLrrNrrZ)rrrcrXrdz%Literal['str', 'int', 'float'] | NonerezCallable[[Any], Any] | Noner%rrrrrLrrNrra)rrLrrNrrj) rrrqrrrrrLrrNrrp) rr6rqrrrrrLrrNrrp)rrrrLrrNrr}) rz#Literal[1, 3, 4, 5, 6, 7, 8] | Noner%rrrrrLrrNrr)rZset[int] | Noner^rYrrr~)rrJr1rOr0rOrrr%rrrrrLrIncExSeqOrElseSerSchema | Nonerr)rlist[CoreSchema]rrJr%rrrrrLrrZrr)rrJr1rOr0rOr%rrrrrLrrZrr)rr[rrOr1rOr0rOrrr%rrrrrLrrZrr)rrJr1rOr0rOrrr%rrrrrLrrNrr)rrJr1rOr0rOrrr%rrrrrLrrNrr)rrJr1rOr0rOrrrrLrrZrr)rZIncExDict | Noner^r\rr)rrJrrJr1rOr0rOrrr%rrrrrLrrNrr)rrrrrrrrJrrLrrNrr)rWithInfoValidatorFunctionrrrrrrrrJrrLrrNrr)rrrrrrrrJrrLrrNrr)rr]rrrrrrrrLrrNrr)rrrrrrrrJrrLrrNrr)rWithInfoWrapValidatorFunctionrrrrrrJrrrrLrrNrr) rrrrrrJrrLrrNrr)rr]rrrrrrJrrLrrNrr)rrrSrrz?Union[Callable[[], Any], Callable[[dict[str, Any]], Any], None]rrrz*Literal['raise', 'omit', 'default'] | Noner-rr%rrrrrLrrNrr) rrr%rrrrrLrrNrr)rz)list[CoreSchema | tuple[CoreSchema, str]]rrrrr rr zdict[str, str | int] | Nonerdz(Literal['smart', 'left_to_right'] | NonerrrrLrrNrr)rzdict[Any, CoreSchema]rzDstr | list[str | int] | list[list[str | int]] | Callable[[Any], Any]rrr rr z#dict[str, int | str | float] | Noner%rr)rrrrrLrrNrr) rr[rrrrLrrNrr)rrrrr%rrrrrLrrNrr) r$rr%rrrrrLrrNrr#)rrr+rr-4str | list[str | int] | list[list[str | int]] | Noner.rr/rrrLrrMrr*)r5zdict[str, TypedDictField]rtype[Any] | Noner7rr9list[ComputedField] | Noner%rrrJr:ExtraBehavior | NonerOrrrrrLrrNrrrr4)rrr-r_r.rr/rrrMr@rrrLrr?)r5zdict[str, ModelField]rFrr9rar%rrrJrGrJr:rbr)rrrrrLrrNrrE)rr6rrrMr`rNrrOrrPrr,7Literal['always', 'never', 'subclass-instances'] | Noner%rr@rr:rbrrrrrrLrrNrrL)rUr"rrrVrrWrrXrr-r_r.rr/rrrLrrMr@rrrT)r^r"r5zlist[DataclassField]r9rar_rrrrrLrrNr:rbrr])rr6rrr5rrMr`r7rrPrr,rcr%rrrrrLrrNr@rrerrrrrd) rUr"rrrdzJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Nonerr_rrj)rwzlist[ArgumentsParameter]rArr@rrsrJrtzVarKwargsMode | NonerurJrrrrLrrNrrq) rUr"rrrdzLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict'] | Nonerr_rry)rwzlist[ArgumentsV3Parameter]rArr@rr:z"Literal['forbid', 'ignore'] | NonerrrrLrrNrr})rwrrzCallable[..., Any]rrrrJrrrrLrrNrr)rrrr"r rr rLrrrrLrrNrr) rrJrrrrLrrNrr)r0rOrlist[str] | NonerrrrrrOrrrrr%rrrrrLrrNrr)r0rOrrdrrrrrrOrrrrr%rrrrrLrrNrr)rrrr[rr)NNN) rr"rrrrLrrNrr)rrrr)rrrzGenerator[CoreSchema])rr]rr"rr)rr^rr"rr)rr]rr")rDr"robject)rJ __future__r _annotationssysrcollections.abcrrrrrr r r&r rer typingr rrrrtyping_extensionsrr version_inforrrr pydantic_corer ImportErrorrer&r rPrKrQrUrrrHrr$GeneralPlainNoInfoSerializerFunction"GeneralPlainInfoSerializerFunction"FieldPlainNoInfoSerializerFunction FieldPlainInfoSerializerFunctionrIrrrr#GeneralWrapNoInfoSerializerFunction!GeneralWrapInfoSerializerFunction!FieldWrapNoInfoSerializerFunctionFieldWrapInfoSerializerFunctionrKrrrrrrrrrrrrrrrrr r rrrrrr!r'r)r,r.r7r9r<r>rDrFrNrPrSrUrXrZr_rarhrjrmJsonTyperprvrxr{r}rrrrrrrrrrrrrrrrrrrr.r"rrrrrrrrr]rValidationFunctionrrrrrrrrrrr^rWrapValidatorFunctionrrrrrrrrrrrrrrrrrr!r#r(r*r2r4r=r?rCrErJrLrRrTr[r]rbrdrhrjrmrorqrrryr{r}rrrrrrr$rrrrrrrrMYPYrCoreSchemaTypeCoreSchemaFieldType ErrorTyperrrr"r&r)r.r1r5r8rAr9rGrErMrNrs_& 3 8844??1g+ g??44/ %3 34 R"%R"jL 9K :| DC#*C#L .x8(  Xh' @% 4/iu/&(0s ';$%-s4Ec4J.KS.P%Q"%-sCj#o%>"#+S#7Mc7R,SUX,X#Y (&&$& F Gy(, '+"  %  %   &@\H\ '/5R/SUX/X&Y#$,c3PRcdgRh-ikn-n$o!$,c38U-VX[-[$\!"*C6SUkloUp+qsv+v"w'%%#%iu(, $'+" $ %     %  % Fiu HZ c c  3E   !Ye! @ $#   IU F FIU=A&*    ;  $ 6 im_ _)>_Vf__,%im` `)>`Vf``,%&*&* o o o$o$ o  o4   #&*&*-- -  -  -  - - -$-$--` )5  "& $&*&*000  0  0  0 0 0 0$0$00f IU $"&"&!!%&*&*77 7  7  7  7 777 7 7$7$77tIU&*&*   $  $   D 9E $*.!!$(  >B)-&*&*; &;; ; " ;  ;;<; ;'; ;$;$;;|)5"!&*&*$$$  $  $ $ $$$$N % $/3!%&*&*1 1 1  1  1  1 -11 1$1$11h %  <@;E&*&*1 1 1  1  1  1:191 1$1$11hYe(/3<@!%;E&*&*9 9 9  9  9  9 -9:9999 9$9$99x iu ;E&*&*. . .  .  .  .9. .$.$..bIU&*&* vv v$ v $ v  v6 %  7;+/&*&*0 0 04 0 ) 0  0 0$0$00fIU'+&* # #   H Iy &*&*     $  $ Dy &*&* " ""  " $ " $ ""JYeimd d)>dVfdd,%48&*&*  0      $  $    59UY]] 19 <= +% +'+*"!!&*48*#** *  *  * *$*2**b(,&*48-"-%-  -  - $ -2--d'+)"!&*48)#)) )  )  )$)2))X +)5 + '+!!!&*480"0$0 0  0  0 0 0$0200f   '+,"!!&*&*,#,, ,  ,  , ,$,$,,^ iu '+,"!!&*&*,#,, ,  ,  , ,$,$,,^+iu+'+,"!&*48,#,, ,  , $ ,2,,^ c3h % 7;X\YY!!3Y!>? ,% ,&*'+/"!!&*&*/"/$/ /  /  / / /$/$//f#C5#:.&I& %c>#+>%?%DEiu 8:YYZy)$ )5 $"&$('+8<59&*&*0 600" 0 % 0 6 0 30 0$0$00f   $%)'+@D#'&*&*P "PWP" P % P > P P!P P$P$PPf)5&*&* n n n$ n $ n  nD &*&*333  3  3 $ 3$33l%&*&* ---  - $ - $ --`4Ye4!MQ&*)-&*=A% %%K % $ % ' %$%;%%Piu(!26'++/&*&* $= %= = = 0 =  =%=)= = =$=$= ==@%NR&*)-=A&*% %K%$ % ' % ; % %$%%P   $"26'+,0+/#'&*&*6 !660 6  6 % 6*6)6!6 6$6$66r)5,(,#" TX+/ $&*&*R R R% R  R  RRRR R R)R R R$R$R !Rj 4Ye 4& !MQ&*)-&*=A6 6 6 6  6  6K6$6'6$6;6 66r ")5 " 37%)&*&*+/00 00 0 # 0  0$0$0)00fiu.(,!TX&*&* $8 8 8 8 % 8  88R8 8 8$8$8 8 8 8 !8vJ%JX\BF L L L U L @ L  L<##CD yD iu  %)%))-,0+/&*&*5'5"5# 5 ' 5 * 5)5 5$5$55p J9E J4BF#L #L #L #L @#L#LL %)%)9=&*&*0)0"0# 0 7 0  0$0$00f%!%'+&*&*33 3 3 % 3  3$3$33l (,26&*&*+ ++% + 0 +  +$+$++\%!%+o&*&* +o +o +o$ +o $ +o  +o+o\    "(,!%###'+&*&*44&4 4  4  44%4 4 4$4$44n %  "(,!%###'+&*&*44&4 4  4  44%4 4 4$4$44n Y. &*&*  $$   D  3  3 3 3  3   3   3   3  3  3  3  3  3  3  3  3  3  !3 " #3 $ %3 & '3 ( )3 * +3 , -3 . /3 0 13 2 %33 4 &53 6 $73 8 %93 : ;3 < =3 > ?3 @ A3 B C3 D E3 F G3 H I3 J K3 L M3 N O3 P Q3 R S3 T U3 V W3 X Y3 Z [3 \ ]3 ^ _3 ` a3 b "c3 d e3 f g3 5Jl 35nde gi  X> qrbsb st@u@ opaqa qr?s? mn`+`9<`FP`o` op>q> opYqY qr?s?*7 9"? ( AJ %"H%sx)) x:9x: