fj#q UdZddlmZddlZddlZddlmZmZm Z ddl m Z m Z m Z m Z ddlmZddlmZddlmZmZmZmZmZdd lmZmZejd krdd lmZndd lmZejd kr dd lmZmZmZn dd lmZmZmZerddl m!Z!n ddl m!Z!n#e"$r e#Z!YnwxYwedZ$GddedZ%dZ&de'd<edddZ(Gddee(Z)Gdde)e(eZ*Gdd ee(Z+ed!Z,Gd"d#edZ-dd'Z.eegefZ/eee)egefZ0eeegefZ1eeee*egefZ2ee/e0e1e2fZ3ed(Z4 Gd)d*edZ5dddd+d,dd6Z6Gd7d8eZ7eee7gefZ8eee7e)egefZ9eeee7gefZ:eeee7e*egefZ;ee8e9e:e;fZ<Gd9d:edZ=ddddd+d;dd>Z>Gd?d@edZ?dAdBddEZ@GdFdGedZAdAdBddHZBGdIdJedZCddNZDee-e5e=e?eAeCfZEGdOdPedZFdddUZGGdVdWedZHddddXdd]ZIGd^d_edZJdddd`ddcZKGdddeedZLdddd`ddfZMGdgdhedZN dddjZOGdkdledZPddddddddddm ddtZQGdudvedZRdddddddddddw d dzZSGd{d|edZTddddddddddddd} d dZUGddedZVdddddd dZWGddedZXddddddddddddd d dZYGddedZZdddddddd dZ[GddedZ\ddddddddddd ddZ]GddedZ^ddddddddddd ddZ_GddedZ`ddddddddddddd ddZaGddedZbdddddddddd ddZcGddedZddddd`ddZeGddedZfddddddddd„ZgGdÄdedZh dddńZiedZjGdDŽdedZkdddddɜdd˄ZlGd̄dedZmdddddɜdd΄ZnGdτdedZodddd`ddфZpGd҄dedZqddddddԜddׄZrGd؄dedZsdddڜddބZteeseEfZuGd߄dedZv dddddddddddZwddddddddZx ddddddddddZyGddedZzdddddddddddZ{GddedZ| dddddddddddZ}GddedZ~ dddddddddd dZGddedZ dddddddd!dZeeeefZGddedZdddڜd"dZeeeEfZGddedZ dddddddddd#dZeegefZGddeZeee+egefZGddedZeeefZGdd edZGd d edZddddd d$dZddddddd%dZGddedZddddd d&dZdddddd'dZGddeZeeegefZGddeZeeee+egefZGddedZeeefZGdd edZddddd d(d"Zdddddd#d)d%ZGd&d'edZddddd d*d(Zddddddd+d)ZGd*d+edZe!ddddddddd, d,d4ZGd5d6edZdddddd-d7ZGd8d9edZddddddddd:d.dDZGdEdFedZdddddddddGd/dMZGdNdOedZdddd`d0dQZGdRdSedZdddddd1dVZGdWdXedZdddd`d2d[ZGd\d]edZddddddd^d3ddZGdedfedZddddddddddddg d4dsZGdtduedZdddddddvd5dxZGdydzedZddddddddddd{ d6dZGddedZddddddddddddd d7dZGddedZdddddddddd d8dZGddedZdddddddd9dZGddedZdddddddddddd d:dZGddedZdddd;dZedZde'd<GddedZdddddddddd<dZGddedZdddd=dZGddedZdddddddd>dZGddedZddddddd?dZGd„dedZddddddĜd@dńZGdƄdedZ ddddd`dAdȄZGdɄdedZdddddddddddd˜ dBdӄZGdԄdedZdddddddddddd˜ dCdքZGdׄdedZԐdDdڄZGdۄdedZ dEdFdބZdZesregeFeJeLeNePeReTeXeZe\e^e`ebedehefekemeoeveze|e~eeeeeeeeeeeeeeeeeeeđeȑeʑȇeΑeБeґeԑe֑eqeVRZn edZedZedZܐdGdZݐdHdZeddIdZeddZeddIdZeddZeddJdZeddZeddKdZeddZe+eeedZere+ZdLdZdS(Mze 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)allowforbidignorec6eZdZUdZded<ded<ded<ded<ded <ded <d ed <ded <ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded <d!ed"<d#ed$<ded%<ded&<ded'<ded(<ded)<d*S)+ CoreConfigau 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____doc____annotations__mC:\Users\Terasoftware\OneDrive\Desktop\faahhh\fyndo\fyndo\venv\Lib\site-packages\pydantic_core/core_schema.pyr r +sy((TJJJLLL((((JJJJ3333DDDD4444====4444    4444>>>>####!!!!!!rJr F)totalz2set[int | str] | dict[int | str, IncExCall] | Noner IncExCallContextTTz Any | None) covariantdefaultcJeZdZdZeddZeddZeddZedd Zedd Z edd Z edd Z eddZ eddZ eddZeddZeddZddZddZddZdS)SerializationInfoz%Extra data used during serialization.returnrMcdS)z0The `include` argument set during serialization.NrIselfs rKincludezSerializationInfo.include  rJcdS)z0The `exclude` argument set during serialization.NrIrUs rKexcludezSerializationInfo.excluderXrJrNcdS)z"The current serialization context.NrIrUs rKcontextzSerializationInfo.contextrXrJLiteral['python', 'json'] | strcdS)z0The serialization mode set during serialization.NrIrUs rKmodezSerializationInfo.moderXrJr#cdS)z1The `by_alias` argument set during serialization.NrIrUs rKby_aliaszSerializationInfo.by_aliasrXrJcdS)z6The `exclude_unset` argument set during serialization.NrIrUs rK exclude_unsetzSerializationInfo.exclude_unsetrXrJcdS)z9The `exclude_defaults` argument set during serialization.NrIrUs rKexclude_defaultsz"SerializationInfo.exclude_defaultsrXrJcdS)z5The `exclude_none` argument set during serialization.NrIrUs rK exclude_nonezSerializationInfo.exclude_nonerXrJcdS)z@The `exclude_computed_fields` argument set during serialization.NrIrUs rKexclude_computed_fieldsz)SerializationInfo.exclude_computed_fieldsrXrJcdS)z9The `serialize_as_any` argument set during serialization.NrIrUs rKserialize_as_anyz"SerializationInfo.serialize_as_anyrXrJ bool | NonecdS)zJThe `polymorphic_serialization` argument set during serialization, if any.NrIrUs rKrBz+SerializationInfo.polymorphic_serializationrXrJcdS)z3The `round_trip` argument set during serialization.NrIrUs rK round_tripzSerializationInfo.round_triprXrJcdSNrIrUs rK mode_is_jsonzSerializationInfo.mode_is_jsonrJr!cdSrqrIrUs rK__str__zSerializationInfo.__str__rsrJcdSrqrIrUs rK__repr__zSerializationInfo.__repr__rsrJN)rSrMrSrN)rSr])rSr#)rSrlrSr!)rDrErFrGpropertyrWrZr\r_rarcrergrirkrBrorrrurwrIrJrKrRrRs//    X    X    X    X    X    X    X    X    X    X    X    X ('''!!!!""""""rJrRc*eZdZdZeddZdS)FieldSerializationInfoz+Extra data used during field serialization.rSr!cdS)z/The name of the current field being serialized.NrIrUs rK field_namez!FieldSerializationInfo.field_namerXrJNry)rDrErFrGrzr~rIrJrKr|r|s855    X   rJr|ceZdZdZeddZeddZeddZedd Zedd Z d S)ValidationInfoz"Extra data used during validation.rSrNcdS)zThe current validation context.NrIrUs rKr\zValidationInfo.contextrXrJCoreConfig | NonecdS)z/The CoreConfig that applies to this validation.NrIrUs rKconfigzValidationInfo.configrXrJLiteral['python', 'json']cdS)z3The type of input data we are currently validating.NrIrUs rKr_zValidationInfo.moderXrJdict[str, Any]cdS)z(The data being validated for this model.NrIrUs rKdatazValidationInfo.datarXrJ str | NonecdS)zw The name of the current field being validated if this validator is attached to a model field. NrIrUs rKr~zValidationInfo.field_names rJNrx)rSr)rSr)rSr)rSr) rDrErFrGrzr\rr_rr~rIrJrKrrs,,    X    X    X    X    X   rJr)noner-r#floatr!bytes bytearraylisttupleset frozenset generatordictrrr r urlmulti-host-urljsonuuidanyceZdZUded<dS)SimpleSerSchemaz$Required[ExpectedSerializationTypes]typeNrDrErFrHrIrJrKrrs......rJrrExpectedSerializationTypesrSc"t|S)z{ Returns a schema for serialization with a custom type. Args: type: The type to use for serialization r)rrs rKsimple_ser_schemars  % % %%rJ)alwaysz unless-nonerjson-unless-nonecLeZdZUded<ded<ded<ded<ded <d ed <d S) PlainSerializerFunctionSerSchema#Required[Literal['function-plain']]rzRequired[SerializerFunction]functionr#is_field_serializerinfo_arg CoreSchema return_schemaWhenUsed when_usedNrrIrJrKrr6sW----****NNNrJrr)rrrrrSerializerFunctionrrlrrCoreSchema | Nonerrc<|dkrd}td|||||S)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 rK$plain_serializer_function_ser_schemar?s?&H  /#    rJceZdZdd dZdS) SerializerFunctionWrapHandlerN input_valuer index_keyint | str | NonerScdSrqrI)rVrrs rK__call__z&SerializerFunctionWrapHandler.__call__`rsrJrq)rrrrrSrrDrErFrrIrJrKrr_s[[[[[[[rJrcVeZdZUded<ded<ded<ded<ded <ded <d ed <d S)WrapSerializerFunctionSerSchema"Required[Literal['function-wrap']]rz Required[WrapSerializerFunction]rr#rrrschemarrrNrrIrJrKrrssc,,,,....NNNrJr)rrrrrWrapSerializerFunctionrc >|dkrd}td||||||S)aE Returns a schema for serialization with a wrap function, can be either a "general" or "field" function. Args: function: The function to use for serialization is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument, and `info` includes `field_name` info_arg: Whether the function takes an `info` argument schema: The schema to use for the inner serialization return_schema: Schema to use for serializing return value when_used: When the function should be called rN function-wrap)rrrrrrrr)rrrrrrs rK#wrap_serializer_function_ser_schemar}sB*H  /#   rJc.eZdZUded<ded<ded<dS)FormatSerSchemazRequired[Literal['format']]r Required[str]formatting_stringrrNrrIrJrKrrs6%%%%$$$$rJrr)rrr!c6|dkrd}td||S)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 rKformat_ser_schemars.&& x;LXa b b bbrJc$eZdZUded<ded<dS)ToStringSerSchemazRequired[Literal['to-string']]rrrNrrIrJrKrrs*((((rJrc<td}|dkr||d<|S)z Returns a schema for serialization using python's `str()` / `__str__` method. Args: when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default z to-stringrrr)r)rss rKto_string_ser_schemars0 +A&&#"+ HrJc.eZdZUded<ded<ded<dS)ModelSerSchemaRequired[Literal['model']]rRequired[type[Any]]clsRequired[CoreSchema]rNrrIrJrKrrs6$$$$      rJrr type[Any]rc&td||S)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 rKmodel_ser_schemars wC ? ? ??rJc8eZdZUded<ded<ded<ded<d S) InvalidSchemazRequired[Literal['invalid']]rr!refrmetadata SerSchema serializationNrrIrJrKrrsA&&&& HHHrJrrrrdict[str, Any] | Nonec&td||S)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 rKinvalid_schemars ycH E E EErJcLeZdZUded<ded<ded<ded<d ed <d ed <d S) ComputedFieldz#Required[Literal['computed-field']]rr property_namerrr!aliasCallable[[Any], bool]serialization_exclude_ifrrNrrIrJrKrrsW----    ''''JJJ3333rJr)rrrrrrCallable[[Any], bool] | Nonec,td|||||S)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 rKcomputed_fieldrs-"  ##!9    rJc8eZdZUded<ded<ded<ded<d S) AnySchemazRequired[Literal['any']]rr!rrrrrNrrIrJrKrrs?"""" HHHrJrrrrrSerSchema | Nonec(td|||S)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 rK any_schemar"s& u#P] ^ ^ ^^rJc8eZdZUded<ded<ded<ded<d S) NoneSchemazRequired[Literal['none']]rr!rrrrrNrrIrJrKrr8s?#### HHHrJrc(td|||S)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 rK none_schemar?s& v3Q^ _ _ __rJcBeZdZUded<ded<ded<ded<d ed <d S) BoolSchemazRequired[Literal['bool']]rr#r$r!rrrrrNrrIrJrKrrUsH####LLL HHHrJrr$c*td||||S)ae Returns a schema that matches a bool value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.bool_schema() v = SchemaValidator(schema) assert v.validate_python('True') is True ``` Args: strict: Whether the value should be a bool or a value that can be converted to a bool ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r#rr$rrrrr$rrrs rK bool_schemar]s. vf#`m n n nnrJcteZdZUded<ded<ded<ded<ded<ded<d ed <d ed <d ed<ded<dS) IntSchemazRequired[Literal['int']]rr- multiple_oflegeltgtr#r$r!rrrrrNrrIrJrKrrwsx"""" GGG GGG GGG GGGLLL HHHrJr rrrrrr$rrrr int | Nonerrrrc 4td||||||||| S)a Returns a schema that matches a int value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.int_schema(multiple_of=2, le=6, ge=2) v = SchemaValidator(schema) assert v.validate_python('4') == 4 ``` Args: multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number strict: Whether the value should be a int or a value that can be converted to a int ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r-) rrrrrrr$rrrrrs rK int_schemar s:D    #    rJc~eZdZUded<ded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<dS) FloatSchemazRequired[Literal['float']]rr#r3rrrrrrr$r!rrrrrNrrIrJrKr r s$$$$ III III III IIILLL HHHrJr  r3rrrrrr$rrrr3 float | Nonec 6td||||||||||  S)a Returns a schema that matches a float value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.float_schema(le=0.8, ge=0.2) v = SchemaValidator(schema) assert v.validate_python('0.5') == 0.5 ``` Args: allow_inf_nan: Whether to allow inf and nan values multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number strict: Whether the value should be a float or a value that can be converted to a float ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rr3rrrrrr$rrrrrs rK float_schemars=H  #  #    rJceZdZUded<ded<ded<ded<ded<ded <ded <d ed <d ed <ded<ded<ded<ded<dS) DecimalSchemazRequired[Literal['decimal']]rr#r3r rrrrrr- max_digitsdecimal_placesr$r!rrrrrNrrIrJrKrrs&&&&KKKKKKKKKKKKOOOLLL HHHrJr r3rrrrrrrr$rrrDecimal | Nonerrc :td|||||||||| | |  S)a Returns a schema that matches a decimal value, e.g.: ```py from decimal import Decimal from pydantic_core import SchemaValidator, core_schema schema = core_schema.decimal_schema(le=0.8, ge=0.2) v = SchemaValidator(schema) assert v.validate_python('0.5') == Decimal('0.5') ``` Args: allow_inf_nan: Whether to allow inf and nan values multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number max_digits: The maximum number of decimal digits allowed decimal_places: The maximum number of decimal places allowed strict: Whether the value should be a float or a value that can be converted to a float ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema decimal) rrrrrrrrr3r$rrrrrs rKdecimal_schemarsCR   %# #   rJcBeZdZUded<ded<ded<ded<d ed <d S) ComplexSchemazRequired[Literal['complex']]rr#r$r!rrrrrNrrIrJrKrr?sH&&&&LLL HHHrJrrc*td||||S)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 rKcomplex_schemarGs*2   #    rJceZdZUded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<ded<ded<ded<dS) StringSchemazRequired[Literal['str']]rzUnion[str, Pattern[str]]patternr- max_length min_lengthr#strip_whitespaceto_lowerto_upperr<r=r$r;r!rrrrrNrrIrJrKr!r!is""""%%%%OOOOOONNNNNN4444LLL HHHrJr! r"r#r$r%r&r'r=r$r;rrrr"str | Pattern[str] | Noner#r$r%r&r'r=)Literal['rust-regex', 'python-re'] | Noner;c :td|||||||||| | |  S)aC Returns a schema that matches a string value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.str_schema(max_length=10, min_length=2) v = SchemaValidator(schema) assert v.validate_python('hello') == 'hello' ``` Args: pattern: A regex pattern that the value must match max_length: The value must be at most this length min_length: The value must be at least this length strip_whitespace: Whether to strip whitespace from the value to_lower: Whether to convert the value to lowercase to_upper: Whether to convert the value to uppercase regex_engine: The regex engine to use for pattern validation. Default is 'rust-regex'. - `rust-regex` uses the [`regex`](https://docs.rs/regex) Rust crate, which is non-backtracking and therefore more DDoS resistant, but does not support all regex features. - `python-re` use the [`re`](https://docs.python.org/3/library/re.html) module, which supports all regex features, but may be slower. strict: Whether the value should be a string or a value that can be converted to a string coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode). ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r!) rr"r#r$r%r&r'r=r$r;rrrrr(s rK str_schemar,ysCZ  )!3 #   rJcVeZdZUded<ded<ded<ded<ded <d ed <d ed <dS) BytesSchemazRequired[Literal['bytes']]rr-r#r$r#r$r!rrrrrNrrIrJrKr.r.sZ$$$$OOOOOOLLL HHHrJr.r#r$r$rrrc .td||||||S)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)rr#r$r$rrrrr/s rK bytes_schemar1s08   #   rJc~eZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<dS) DateSchemazRequired[Literal['date']]rr#r$rrrrrLiteral['past', 'future']now_opr-now_utc_offsetr!rrrrrNrrIrJrKr3r3s####LLL HHH HHH HHH HHH%%%% HHHrJr3 r$rrrrr5r6rrr date | Noner5 Literal['past', 'future'] | Noner6c 6td||||||||||  S)a Returns a schema that matches a date value, e.g.: ```py from datetime import date from pydantic_core import SchemaValidator, core_schema schema = core_schema.date_schema(le=date(2020, 1, 1), ge=date(2019, 1, 1)) v = SchemaValidator(schema) assert v.validate_python(date(2019, 6, 1)) == date(2019, 6, 1) ``` Args: strict: Whether the value should be a date or a value that can be converted to a date le: The value must be less than or equal to this date ge: The value must be greater than or equal to this date lt: The value must be strictly less than this date gt: The value must be strictly greater than this date now_op: The value must be in the past or future relative to the current date now_utc_offset: The value must be in the past or future relative to the current date with this utc offset ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rr$rrrrr5r6rrrrr7s rK date_schemar;s=J   % #    rJc~eZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<dS) TimeSchemazRequired[Literal['time']]rr#r$r rrrr%Union[Literal['aware', 'naive'], int] tz_constraintLiteral['truncate', 'error']microseconds_precisionr!rrrrrNrrIrJrKr=r=,s####LLL HHH HHH HHH HHH88888888 HHHrJr=truncate r$rrrrr?rArrr time | Noner?&Literal['aware', 'naive'] | int | NonerAr@c 6td||||||||||  S)a Returns a schema that matches a time value, e.g.: ```py from datetime import time from pydantic_core import SchemaValidator, core_schema schema = core_schema.time_schema(le=time(12, 0, 0), ge=time(6, 0, 0)) v = SchemaValidator(schema) assert v.validate_python(time(9, 0, 0)) == time(9, 0, 0) ``` Args: strict: Whether the value should be a time or a value that can be converted to a time le: The value must be less than or equal to this time ge: The value must be greater than or equal to this time lt: The value must be strictly less than this time gt: The value must be strictly greater than this time tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r ) rr$rrrrr?rArrrrrCs rK time_schemarG:s=J   #5 #    rJceZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<dS)DatetimeSchemazRequired[Literal['datetime']]rr#r$rrrrrr4r5r>r?r-r6r@rAr!rrrrrNrrIrJrKrIrIns''''LLLLLLLLLLLLLLL%%%%88888888 HHHrJrI r$rrrrr5r?r6rArrrdatetime | Nonec :td|||||||||| | |  S)a Returns a schema that matches a datetime value, e.g.: ```py from datetime import datetime from pydantic_core import SchemaValidator, core_schema schema = core_schema.datetime_schema() v = SchemaValidator(schema) now = datetime.now() assert v.validate_python(str(now)) == now ``` Args: strict: Whether the value should be a datetime or a value that can be converted to a datetime le: The value must be less than or equal to this datetime ge: The value must be greater than or equal to this datetime lt: The value must be strictly less than this datetime gt: The value must be strictly greater than this datetime now_op: The value must be in the past or future relative to the current datetime tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset TODO: use of a tzinfo where offset changes based on the datetime is not yet supported now_utc_offset: The value must be in the past or future relative to the current datetime with this utc offset microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rr$rrrrr5r?r6rArrrrrJs rKdatetime_schemarMsCV   #%5 #   rJcteZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<dS)TimedeltaSchemazRequired[Literal['timedelta']]rr#r$r rrrrr@rAr!rrrrrNrrIrJrKrOrOsx((((LLLMMMMMMMMMMMM8888 HHHrJrO r$rrrrrArrrtimedelta | Nonec 4td||||||||| S)a] Returns a schema that matches a timedelta value, e.g.: ```py from datetime import timedelta from pydantic_core import SchemaValidator, core_schema schema = core_schema.timedelta_schema(le=timedelta(days=1), ge=timedelta(days=0)) v = SchemaValidator(schema) assert v.validate_python(timedelta(hours=12)) == timedelta(hours=12) ``` Args: strict: Whether the value should be a timedelta or a value that can be converted to a timedelta le: The value must be less than or equal to this timedelta ge: The value must be greater than or equal to this timedelta lt: The value must be strictly less than this timedelta gt: The value must be strictly greater than this timedelta microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r ) rr$rrrrrArrrrrPs rKtimedelta_schemarSs:F   5 #    rJcBeZdZUded<ded<ded<ded<d ed <d S) LiteralSchemazRequired[Literal['literal']]rRequired[list[Any]]expectedr!rrrrrNrrIrJrKrUrUsK&&&&!!!! HHHrJrUrW list[Any]c*td||||S)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)rrWrrrr)rWrrrs rKliteral_schemar[s0 y8xgt u u uurJcjeZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<ded<dS) EnumSchemazRequired[Literal['enum']]r Required[Any]rrVmemberszLiteral['str', 'int', 'float']sub_typezCallable[[Any], Any]missingr#r$r!rrrrrNrrIrJrKr]r]sx####    ,,,,!!!!LLL HHHrJr])r`rar$rrrrr_r`%Literal['str', 'int', 'float'] | NoneraCallable[[Any], Any] | Nonec 2td|||||||| S)a Returns a schema that matches an enum value, e.g.: ```py from enum import Enum from pydantic_core import SchemaValidator, core_schema class Color(Enum): RED = 1 GREEN = 2 BLUE = 3 schema = core_schema.enum_schema(Color, list(Color.__members__.values())) v = SchemaValidator(schema) assert v.validate_python(2) is Color.GREEN ``` Args: cls: The enum class members: The members of the enum, generally `list(MyEnum.__members__.values())` sub_type: The type of the enum, either 'str' or 'int' or None for plain enums missing: A function to use when the value is not found in the enum, from `_missing_` strict: Whether to use strict mode, defaults to False ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema enum) rrr_r`rar$rrrr)rr_r`rar$rrrs rK enum_schemarf)s7L    #    rJc.eZdZUded<ded<ded<dS)MissingSentinelSchemaz%Required[Literal['missing-sentinel']]rrrrrNrrIrJrKrhrh\s6////rJrhc&td||S)z,Returns a schema for the `MISSING` sentinel.missing-sentinel)rrrr)rrs rKmissing_sentinel_schemarkbs$  #   rJ)nullr#r-rr!rrcLeZdZUded<ded<ded<ded<ded <d ed <d S) IsInstanceSchemaz Required[Literal['is-instance']]rr^rr!cls_reprrrrrrNrrIrJrKrnrnssT****MMM HHHrJrn)rorrrroc,td|||||S)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-instancerrrorrrrrrorrrs rKis_instance_schemart|s):  hC(bo   rJcLeZdZUded<ded<ded<ded<ded <d ed <d S) IsSubclassSchemaz Required[Literal['is-subclass']]rrrr!rorrrrrNrrIrJrKrvrvsT****MMM HHHrJrvc,td|||||S)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-subclassrrrrss rKis_subclass_schemarys*@  hC(bo   rJc8eZdZUded<ded<ded<ded<d S) CallableSchemazRequired[Literal['callable']]rr!rrrrrNrrIrJrKr{r{s?'''' HHHrJr{c(td|||S)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 rKcallable_schemar~s& zsXUb c c ccrJcLeZdZUded<ded<ded<ded<d ed <d ed <d S) UuidSchemazRequired[Literal['uuid']]rzLiteral[1, 3, 4, 5, 7]versionr#r$r!rrrrrNrrIrJrKrrsT########LLL HHHrJrrr$rrrr#Literal[1, 3, 4, 5, 6, 7, 8] | Nonec,td|||||S)Nr)rrr$rrrrrs rK uuid_schemars)  WVx_l   rJc.eZdZUded<ded<ded<dS)IncExSeqSerSchemaz-Required[Literal['include-exclude-sequence']]rzset[int]rWrZNrrIrJrKrrs67777rJrrWrZrWset[int] | NonerZc&td||S)Nzinclude-exclude-sequencerrWrZrrs rKfilter_seq_schemars 97T[ \ \ \\rJcjeZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<dS) ListSchemazRequired[Literal['list']]rr items_schemar-r$r#r# fail_fastr$r!rrrIncExSeqOrElseSerSchemarNrrIrJrKrr so####OOOOOOOOOLLL HHH******rJr)r$r#rr$rrrrrIncExSeqOrElseSerSchema | Nonec 2td|||||||| S)a Returns a schema that matches a list value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.list_schema(core_schema.int_schema(), min_length=0, max_length=10) v = SchemaValidator(schema) assert v.validate_python(['4']) == [4] ``` Args: items_schema: The value must be a list of items that match this schema min_length: The value must be a list with at least this many items max_length: The value must be a list with at most this many items fail_fast: Stop validation on the first error strict: The value must be a list with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r rrr$r#rr$rrrrrr$r#rr$rrrs rK list_schemars7@  ! #    rJ) extras_schemar$rrrlist[CoreSchema]r TupleSchemac`|t|}||gz}nd}t||||||S)a Returns a schema that matches a tuple of schemas, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.tuple_positional_schema( [core_schema.int_schema(), core_schema.str_schema()] ) v = SchemaValidator(schema) assert v.validate_python((1, 'hello')) == (1, 'hello') ``` Args: items_schema: The value must be a tuple with items that match these schemas extras_schema: The value must be a tuple with items that match this schema This was inspired by JSON schema's `prefixItems` and `items` fields. In python's `typing.Tuple`, you can't specify a type for "extra" items -- they must all be the same type if the length is variable. So this field won't be set from a `typing.Tuple` annotation on a pydantic model. strict: The value must be a tuple with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema N)rvariadic_item_indexr$rrr)len tuple_schema)rrr$rrrrs rKtuple_positional_schemarFsXB#!,//#}o5 " !/ #    rJ)r$r#r$rrrc Nt|p tgd||||||S)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)rrr$r#r$rrr)rr)rr$r#r$rrrs rKtuple_variable_schemarws@@ "2jll3 #    rJcteZdZUded<ded<ded<ded<ded<d ed <d ed <d ed <ded<ded<dS)rzRequired[Literal['tuple']]rRequired[list[CoreSchema]]rr-rr$r#r#rr$r!rrrrrNrrIrJrKrrs{$$$$,,,,OOOOOOOOOLLL HHH******rJ)rr$r#rr$rrrrc 4td||||||||| S)a Returns a schema that matches a tuple of schemas, with an optional variadic item, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.tuple_schema( [core_schema.int_schema(), core_schema.str_schema(), core_schema.float_schema()], variadic_item_index=1, ) v = SchemaValidator(schema) assert v.validate_python((1, 'hello', 'world', 1.5)) == (1, 'hello', 'world', 1.5) ``` Args: items_schema: The value must be a tuple with items that match these schemas variadic_item_index: The index of the schema in `items_schema` to be treated as variadic (following PEP 646) min_length: The value must be a tuple with at least this many items max_length: The value must be a tuple with at most this many items fail_fast: Stop validation on the first error strict: The value must be a tuple with exactly this many items ref: Optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rrrr$r#rr$rrrr) rrr$r#rr$rrrs rKrrs:J  !/ #    rJcjeZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<dS) SetSchemazRequired[Literal['set']]rrrr-r$r#r#rr$r!rrrrrNrrIrJrKrrso""""OOOOOOOOOLLL HHHrJrc 2td|||||||| S)a Returns a schema that matches a set of a given schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.set_schema( items_schema=core_schema.int_schema(), min_length=0, max_length=10 ) v = SchemaValidator(schema) assert v.validate_python({1, '2', 3}) == {1, 2, 3} ``` Args: items_schema: The value must be a set with items that match this schema min_length: The value must be a set with at least this many items max_length: The value must be a set with at most this many items fail_fast: Stop validation on the first error strict: The value must be a set with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rrrrs rK set_schemars7D  ! #    rJcjeZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<dS)FrozenSetSchemazRequired[Literal['frozenset']]rrrr-r$r#r#rr$r!rrrrrNrrIrJrKrrso((((OOOOOOOOOLLL HHHrJrc 2td|||||||| S)a Returns a schema that matches a frozenset of a given schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.frozenset_schema( items_schema=core_schema.int_schema(), min_length=0, max_length=10 ) v = SchemaValidator(schema) assert v.validate_python(frozenset(range(3))) == frozenset({0, 1, 2}) ``` Args: items_schema: The value must be a frozenset with items that match this schema min_length: The value must be a frozenset with at least this many items max_length: The value must be a frozenset with at most this many items fail_fast: Stop validation on the first error strict: The value must be a frozenset with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rrrrs rKfrozenset_schemar*s7D  ! #    rJcVeZdZUded<ded<ded<ded<ded <d ed <d ed <dS)GeneratorSchemazRequired[Literal['generator']]rrrr-r$r#r!rrrrrNrrIrJrKrrYs]((((OOOOOO HHH******rJr)r$r#rrrc .td||||||S)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)rrr$r#rrrr)rr$r#rrrs rKgenerator_schemarcs1H  ! #   rJc.eZdZUded<ded<ded<dS)IncExDictSerSchemaz)Required[Literal['include-exclude-dict']]r IncExDictrWrZNrrIrJrKrrs63333rJrIncExDict | Nonec&td||S)Nzinclude-exclude-dictrrrs rKfilter_dict_schemars 5wPW X X XXrJcteZdZUded<ded<ded<ded<ded<d ed <d ed <d ed <ded<ded<dS) DictSchemazRequired[Literal['dict']]rr keys_schema values_schemar-r$r#r#rr$r!rrrIncExDictOrElseSerSchemarNrrIrJrKrrs{####OOOOOOOOOLLL HHH++++++rJrrrc 4td||||||||| S)a7 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) rrrr$r#rr$rrrr) rrr$r#rr$rrrs rK dict_schemars:H  # #    rJc$eZdZUded<ded<dS)NoInfoValidatorFunctionSchemaLiteral['no-info']rNoInfoValidatorFunctionrNrrIrJrKrrs*%%%%%%rJrc.eZdZUded<ded<ded<dS)WithInfoValidatorFunctionSchemaRequired[Literal['with-info']]rz#Required[WithInfoValidatorFunction]rr!r~NrrIrJrKrrs1((((1111OOOOOrJrcBeZdZUded<ded<ded<ded<d ed <d S) _ValidatorFunctionSchemaRequired[ValidationFunction]rrrr!rrrrrNrrIrJrKrrsK****     HHHrJrc$eZdZUded<ded<dS)BeforeValidatorFunctionSchemaz$Required[Literal['function-before']]rrjson_schema_input_schemaNrrIrJrKrrs*....((((((rJr)rrrrrrc 4tdd|d|||||S)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 rK!no_info_before_validator_functionrs9F  #:: !9#   rJ)r~rrrrWithInfoValidatorFunctionr~c |tjdtdtdtd|||||||S) 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 NzThe `field_name` argument on `with_info_before_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead. stacklevelr with-inforrr~rwarningswarnDeprecationWarningr)rrr~rrrrs rK#with_info_before_validator_functionr2spP   e      [8PZ[[[ !9#   rJceZdZUded<dS)AfterValidatorFunctionSchemaz#Required[Literal['function-after']]rNrrIrJrKrrls------rJrc 4tdd|d|||||S)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 rK no_info_after_validator_functionrps9B  #:: !9#   rJ)r~rrrc|tjdtdtdtd||||||S) 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 NzThe `field_name` argument on `with_info_after_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrr)rrrrrrr)rrr~rrrs rK"with_info_after_validator_functionrsmL   d      [8PZ[[[ #    rJceZdZdd dZdS) ValidatorFunctionWrapHandlerNrrouter_locationstr | int | NonerScdSrqrI)rVrrs rKrz%ValidatorFunctionWrapHandler.__call__s rJrq)rrrrrSrrrIrJrKrrs-       rJrc$eZdZUded<ded<dS)!NoInfoWrapValidatorFunctionSchemarrNoInfoWrapValidatorFunctionrNrrIrJrKrrs*))))))rJrc.eZdZUded<ded<ded<dS)#WithInfoWrapValidatorFunctionSchemarrz'Required[WithInfoWrapValidatorFunction]rr!r~NrrIrJrKrrs1((((5555OOOOOrJrcVeZdZUded<ded<ded<ded<d ed <d ed <d ed<dS)WrapValidatorFunctionSchemarrzRequired[WrapValidatorFunction]rrrr!rrrrrrrNrrIrJrKrrsc,,,,----     HHH((((rJrrc 4tdd|d|||||S)a Returns a schema which calls a function with a `validator` callable argument which can optionally be used to call inner validation with the function logic, this is much like the "onion" implementation of middleware in many popular web frameworks, no `info` argument is passed, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn( v: str, validator: core_schema.ValidatorFunctionWrapHandler, ) -> str: return validator(input_value=v) + 'world' schema = core_schema.no_info_wrap_validator_function( function=fn, schema=core_schema.str_schema() ) v = SchemaValidator(schema) assert v.validate_python('hello ') == 'hello world' ``` Args: function: The validator function to call schema: The schema to validate the output of the validator function ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rrrrrrrrrrrrs rKno_info_wrap_validator_functionrs9L  #::!9 #   rJ)r~rrrrWithInfoWrapValidatorFunctionc |tjdtdtdtd|||||||S) ag 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 NzThe `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrrrr)rrr~rrrrs rK!with_info_wrap_validator_functionr) spR   c      [8PZ[[[!9 #   rJcLeZdZUded<ded<ded<ded<d ed <d ed <d S)PlainValidatorFunctionSchemarrrrr!rrrrrrrNrrIrJrKrrd sW----**** HHH((((rJrc2tdd|d||||S)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 rK no_info_plain_validator_functionrm s5<  #:: !9#    rJc|tjdtdtdtd||||||S) 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 NzThe `field_name` argument on `with_info_plain_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrrrr)rr~rrrrs rK"with_info_plain_validator_functionr sm@   d      [8PZ[[[ !9#    rJc~eZdZUded<ded<ded<ded<d ed <d ed <d ed <d ed<ded<ded<ded<dS)WithDefaultSchemazRequired[Literal['default']]rrrrrPz9Union[Callable[[], Any], Callable[[dict[str, Any]], Any]]default_factoryr#default_factory_takes_dataz#Literal['raise', 'omit', 'default']on_errorr,r$r!rrrrrNrrIrJrKrr s&&&&    LLLNNNN$$$$1111LLL HHHrJr) rPrrrr,r$rrrrPr?Union[Callable[[], Any], Callable[[dict[str, Any]], Any], None]rr*Literal['raise', 'omit', 'default'] | Noner,c Ttd|||||||||  } |tur|| d<| S)a Returns a schema that adds a default value to the given schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.with_default_schema(core_schema.str_schema(), default='hello') wrapper_schema = core_schema.typed_dict_schema( {'a': core_schema.typed_dict_field(schema)} ) v = SchemaValidator(wrapper_schema) assert v.validate_python({}) == v.validate_python({'a': 'hello'}) ``` Args: schema: The schema to add a default value to default: The default value to use default_factory: A callable that returns the default value to use default_factory_takes_data: Whether the default factory takes a validated data argument on_error: What to do if the schema validation fails. One of 'raise', 'omit', 'default' validate_default: Whether the default value should be validated strict: Whether the underlying schema should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rP) rrrrrr,r$rrr)rr) rrPrrrr,r$rrrrs rKwith_default_schemar sUN  '#=) #   A'') HrJcLeZdZUded<ded<ded<ded<d ed <d ed <d S)NullableSchemazRequired[Literal['nullable']]rrrr#r$r!rrrrrNrrIrJrKrr sT''''    LLL HHHrJrc,td|||||S)a Returns a schema that matches a nullable value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.nullable_schema(core_schema.str_schema()) v = SchemaValidator(schema) assert v.validate_python(None) is None ``` Args: schema: The schema to wrap strict: Whether the underlying schema should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema nullable)rrr$rrrr)rr$rrrs rKnullable_schemar  s)4  v3an   rJc~eZdZUded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<dS) UnionSchemazRequired[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']r_r$rrrrrNrrIrJrKr r 4 s$$$$FFFF;;;;++++LLL HHHrJr )rrrrr_rrrr )list[CoreSchema | tuple[CoreSchema, str]]rrrrdict[str, str | int] | Noner_(Literal['smart', 'left_to_right'] | Nonec 4td||||||||| S)a? Returns a schema that matches a union value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()]) v = SchemaValidator(schema) assert v.validate_python('hello') == 'hello' assert v.validate_python(1) == 1 ``` Args: choices: The schemas to match. If a tuple, the second item is used as the label for the case. auto_collapse: whether to automatically collapse unions with one element to the inner validator, default true custom_error_type: The custom error type to use if the validation fails custom_error_message: The custom error message to use if the validation fails custom_error_context: The custom error context to use if the validation fails mode: How to select which choice to return * `smart` (default) will try to return the choice which is the closest match to the input value * `left_to_right` will return the first choice in `choices` which succeeds validation 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) rr rrrrr_rrrr) r rrrrr_rrrs rK union_schemarC s:J  #+11  #    rJc~eZdZUded<ded<ded<ded<ded <d ed <d ed <d ed<ded<ded<ded<dS)TaggedUnionSchemaz!Required[Literal['tagged-union']]rz$Required[dict[Hashable, CoreSchema]]r zcRequired[Union[str, list[Union[str, int]], list[list[Union[str, int]]], Callable[[Any], Hashable]]] discriminatorr!rrrrr#r$r(rrrrrNrrIrJrKrrv s++++1111vvvv;;;;LLL HHHrJr)rrrr$r(rrrdict[Any, CoreSchema]rDstr | list[str | int] | list[list[str | int]] | Callable[[Any], Any]#dict[str, int | str | float] | Noner(c 6td||||||||||  S)a Returns a schema that matches a tagged union value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema apple_schema = core_schema.typed_dict_schema( { 'foo': core_schema.typed_dict_field(core_schema.str_schema()), 'bar': core_schema.typed_dict_field(core_schema.int_schema()), } ) banana_schema = core_schema.typed_dict_schema( { 'foo': core_schema.typed_dict_field(core_schema.str_schema()), 'spam': core_schema.typed_dict_field( core_schema.list_schema(items_schema=core_schema.int_schema()) ), } ) schema = core_schema.tagged_union_schema( choices={ 'apple': apple_schema, 'banana': banana_schema, }, discriminator='foo', ) v = SchemaValidator(schema) assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123} assert v.validate_python({'foo': 'banana', 'spam': [1, 2, 3]}) == { 'foo': 'banana', 'spam': [1, 2, 3], } ``` Args: choices: The schemas to match When retrieving a schema from `choices` using the discriminator value, if the value is a str, it should be fed back into the `choices` map until a schema is obtained (This approach is to prevent multiple ownership of a single schema in Rust) discriminator: The discriminator to use to determine the schema to use * If `discriminator` is a str, it is the name of the attribute to use as the discriminator * If `discriminator` is a list of int/str, it should be used as a "path" to access the discriminator * If `discriminator` is a list of lists, each inner list is a path, and the first path that exists is used * If `discriminator` is a callable, it should return the discriminator when called on the value to validate; the callable can return `None` to indicate that there is no matching discriminator present on the input custom_error_type: The custom error type to use if the validation fails custom_error_message: The custom error message to use if the validation fails custom_error_context: The custom error context to use if the validation fails strict: Whether the underlying schemas should be validated with strict mode from_attributes: Whether to use the attributes of the object to retrieve the discriminator value ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema tagged-union) rr rrrrr$r(rrrr) r rrrrr$r(rrrs rKtagged_union_schemar! s=H  #+11' #    rJcBeZdZUded<ded<ded<ded<d ed <d S) ChainSchemazRequired[Literal['chain']]rrstepsr!rrrrrNrrIrJrKr#r# sK$$$$%%%% HHHrJr#r$c*td||||S)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)rr$rrrr)r$rrrs rK chain_schemar' s> wex_l m m mmrJcVeZdZUded<ded<ded<ded<ded <d ed <d ed <dS)LaxOrStrictSchemaz"Required[Literal['lax-or-strict']]rr lax_schema strict_schemar#r$r!rrrrrNrrIrJrKr)r) s`,,,,$$$$''''LLL HHHrJr)r*r+c .td||||||S)a Returns a schema that uses the lax or strict schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str, info: core_schema.ValidationInfo) -> str: assert 'hello' in v return v + ' world' lax_schema = core_schema.int_schema(strict=False) strict_schema = core_schema.int_schema(strict=True) schema = core_schema.lax_or_strict_schema( lax_schema=lax_schema, strict_schema=strict_schema, strict=True ) v = SchemaValidator(schema) assert v.validate_python(123) == 123 schema = core_schema.lax_or_strict_schema( lax_schema=lax_schema, strict_schema=strict_schema, strict=False ) v = SchemaValidator(schema) assert v.validate_python('123') == 123 ``` Args: lax_schema: The lax schema to use strict_schema: The strict schema to use strict: Whether the strict schema should be used ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema lax-or-strict)rr*r+r$rrrr)r*r+r$rrrs rKlax_or_strict_schemar. s1V  # #   rJcLeZdZUded<ded<ded<ded<ded <d ed <d S) JsonOrPythonSchemaz#Required[Literal['json-or-python']]rr json_schema python_schemar!rrrrrNrrIrJrKr0r0A sW----%%%%'''' HHHrJr0r1r2c,td|||||S)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)rr1r2rrrr)r1r2rrrs rKjson_or_python_schemar5J s.L  # #    rJc`eZdZUded<ded<ded<ded<d ed <ded <d ed <ded<dS)TypedDictFieldz%Required[Literal['typed-dict-field']]rrrr#required>Union[str, list[Union[str, int]], list[list[Union[str, int]]]]validation_aliasr!serialization_aliasserialization_excluderrrrNrrIrJrKr7r7z so////    NNNTTTT333333rJr7)r8r:r;r<rrr8r:4str | list[str | int] | list[list[str | int]] | Noner;r<c 0td|||||||S)aO 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)rrr8r:r;r<rrr)rr8r:r;r<rrs rKtyped_dict_fieldr@ s38  )/3!9    rJceZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<d ed<ded<ded<ded<ded<dS)TypedDictSchemazRequired[Literal['typed-dict']]rz#Required[dict[str, TypedDictField]]fieldsrrr!cls_namelist[ComputedField]computed_fieldsr#r$rrr%extra_behaviorrLrrrrrr rNrrIrJrKrBrB s))))////NNNMMM((((LLL!!!!KKK HHHrJrB) rrDrFr$rrGrLrrrrrCdict[str, TypedDictField]type[Any] | NonerDrFlist[ComputedField] | NonerGExtraBehavior | NonerLrrc :td|||||||||| | |  S)an 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) rrCrrDrFr$rrGrLrrrrr) rCrrDrFr$rrGrLrrrrs rKtyped_dict_schemarN sC^   '#% #   rJc`eZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<dS) ModelFieldz Required[Literal['model-field']]rrrr9r:r!r;r#r<rrfrozenrrNrrIrJrKrPrP so****    TTTT3333LLLrJrP)r:r;r<rrQrrQc 0td|||||||S)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<rrQrr)rr:r;r<rrQrs rK model_fieldrT s38  )/3!9    rJceZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<d ed<ded<ded<ded<dS)ModelFieldsSchemaz!Required[Literal['model-fields']]rzRequired[dict[str, ModelField]]rCr! model_namerErFr#r$rrextras_keys_schemar%rGr(rrrrrNrrIrJrKrVrV1 s++++++++OOO((((LLL""""!!!! HHHrJrV) rWrFr$rrXrGr(rrrdict[str, ModelField]rWrXc 8td|||||||||| |  S)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) rrCrWrFr$rrXrGr(rrrr) rCrWrFr$rrXrGr(rrrs rKmodel_fields_schemar\@ s@R  '#-%' #    rJceZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<d ed<d ed<ded<ded<d ed<ded<ded<dS) ModelSchemarrrrrgeneric_originrrr# custom_init root_modelr! post_initr*r+r$rQr%rGr rrrrrrNrrIrJrKr^r^y s$$$$    NNNJJJJLLLLLL!!!! HHHrJr^) r_r`rarbr+r$rQrGrrrrr_r`rarbr+7Literal['always', 'never', 'subclass-instances'] | Nonec >td|||||||||| | | | | S)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)rrr_rr`rarbr+r$rQrGrrrrr)rrr_r`rarbr+r$rQrGrrrrs rK model_schemare sID   %1% #   rJceZdZUded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<ded<ded<dS)DataclassFieldz$Required[Literal['dataclass-field']]rrnamerrr#kw_onlyinit init_onlyrQr9r:r!r;r<rrrrNrrIrJrKrgrg s....    MMMJJJOOOLLLTTTT333333rJrg) rirjrkr:r;r<rrrQrhrirjrkc 8td||||||||| ||  S)a6 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) rrhrrirjrkr:r;r<rrrQr) rhrrirjrkr:r;r<rrrQs rKdataclass_fieldrn s@R    )/3!9    rJcjeZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<ded<dS)DataclassArgsSchemaz#Required[Literal['dataclass-args']]rrdataclass_namezRequired[list[DataclassField]]rCrErFr#collect_init_onlyr!rrrrrr%rGNrrIrJrKrprp( s{----!!!!****(((( HHH!!!!!!rJrp)rFrrrrrrGrqlist[DataclassField]rrc 2td|||||||| S)a Returns a schema for validating dataclass arguments, e.g.: ```py from pydantic_core import SchemaValidator, core_schema field_a = core_schema.dataclass_field( name='a', schema=core_schema.str_schema(), kw_only=False ) field_b = core_schema.dataclass_field( name='b', schema=core_schema.bool_schema(), kw_only=False ) schema = core_schema.dataclass_args_schema('Foobar', [field_a, field_b]) v = SchemaValidator(schema) assert v.validate_python({'a': 'hello', 'b': True}) == ({'a': 'hello', 'b': True}, None) ``` Args: dataclass_name: The name of the dataclass being validated fields: The fields to use for the dataclass computed_fields: Computed fields to use when serializing the dataclass 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) rrqrCrFrrrrrrGr)rqrCrFrrrrrrGs rKdataclass_args_schemarv4 s7L  %'+ #%    rJceZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<d ed<d ed<d ed<ded<ded<d ed<ded<dS)DataclassSchemazRequired[Literal['dataclass']]rrrrr_rrzRequired[list[str]]rCr!rDr#rbr*r+r$rQrrrrrslotsr rNrrIrJrKrxrxg s((((    MMMOOOJJJJLLLLLL HHHKKKrJrx) r_rDrbr+r$rrrrQryr list[str]ryc >td|||||||||| | | | | S)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)rrr_rCrDrrbr+r$rrrrQryrr)rrrCr_rDrbr+r$rrrrQryrs rKdataclass_schemar}y sIP   %1 #   rJc8eZdZUded<ded<ded<ded<d S) ArgumentsParameterrrhrrzCLiteral['positional_only', 'positional_or_keyword', 'keyword_only']r_r9rNrrIrJrKrr sB    MMMMIIIIIIrJr)r_rJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Nonec(t||||S)a Returns a schema that matches an argument parameter, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param = core_schema.arguments_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) schema = core_schema.arguments_schema([param]) v = SchemaValidator(schema) assert v.validate_python(('hello',)) == (('hello',), {}) ``` Args: name: The name to use for the argument parameter schema: The schema to use for the argument parameter mode: The mode to use for the argument parameter alias: The alias to use for the argument parameter rhrr_rrrs rKarguments_parameterr s6 tFU K K KKrJ)uniformzunpacked-typed-dict VarKwargsModecteZdZUded<ded<ded<ded<ded <d ed <ded <d ed<ded<ded<dS)ArgumentsSchemazRequired[Literal['arguments']]rz"Required[list[ArgumentsParameter]]arguments_schemar#r@r?rvar_args_schemarvar_kwargs_modevar_kwargs_schemar!rrrrrNrrIrJrKrr s((((8888""""!!!! HHHrJr)r@r?rrrrrr argumentslist[ArgumentsParameter]r@r?rrVarKwargsMode | Nonerc 4td||||||||| S)aD 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 r) rrr@r?rrrrrrr) rr@r?rrrrrrs rKrr s:T  ")+''+ #    rJc8eZdZUded<ded<ded<ded<d S) ArgumentsV3ParameterrrhrrzLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict']r_r9rNrrIrJrKrr!sM    JIIIIIrJrLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict'] | Nonec(t||||S)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 rrrs rKarguments_v3_parameterr/sF tFU K K KKrJc`eZdZUded<ded<ded<ded<ded <d ed <d ed <ded<dS)ArgumentsV3Schemaz!Required[Literal['arguments-v3']]rz$Required[list[ArgumentsV3Parameter]]rr#r@r?zLiteral['forbid', 'ignore']rGr!rrrrrNrrIrJrKrrUso++++:::://// HHHrJr)r@r?rGrrrlist[ArgumentsV3Parameter]"Literal['forbid', 'ignore'] | Nonec 0td|||||||S)a4 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)rrr@r?rGrrrr)rr@r?rGrrrs rKarguments_v3_schemar`s4N  ")+% #    rJc`eZdZUded<ded<ded<ded<d ed <ded <d ed <ded<dS) CallSchemazRequired[Literal['call']]rrrzRequired[Callable[..., Any]]rr! function_namerrrrrrrNrrIrJrKrrso####******** HHHrJr)rrrrrCallable[..., Any]rc 0td|||||||S)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)rrrrrrrrr)rrrrrrrs rK call_schemars4T  "## #    rJc`eZdZUded<ded<ded<ded<d ed <ded <d ed <ded<dS)CustomErrorSchemaz!Required[Literal['custom-error']]rrrrrr!rrrrrrrrNrrIrJrKrrso++++    $$$$;;;; HHHrJr)rrrrrc 0td|||||||S)a Returns a schema that matches a custom error value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.custom_error_schema( schema=core_schema.int_schema(), custom_error_type='MyError', custom_error_message='Error msg', ) v = SchemaValidator(schema) v.validate_python(1) ``` Args: schema: The schema to use for the custom error schema custom_error_type: The custom error type to use for the custom error schema custom_error_message: The custom error message to use for the custom error schema custom_error_context: The custom error context to use for the custom error schema ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema custom-error)rrrrrrrrr)rrrrrrrs rKcustom_error_schemars4D  +11 #    rJcBeZdZUded<ded<ded<ded<d ed <d S) JsonSchemazRequired[Literal['json']]rrrr!rrrrrNrrIrJrKrr sK#### HHHrJrc*td||||S)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 rKr1r1sV vf#`m n n nnrJc~eZdZUded<ded<ded<ded<d ed <ded <d ed <ded <d ed<ded<ded<dS) UrlSchemazRequired[Literal['url']]rr-r#rzallowed_schemesr# host_requiredr! default_host default_port default_pathr$rrrrrNrrIrJrKrrCs""""OOOLLL HHHrJr r#rrrrrpreserve_empty_pathr$rrrrlist[str] | Nonerrrrrc 8td|||||||||| |  S)aB 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 rr#rrrrrrr$rrrrrs rK url_schemarQs@N  '#!!!/ #    rJc~eZdZUded<ded<ded<ded<d ed <ded <d ed <ded <d ed<ded<ded<dS)MultiHostUrlSchemaz#Required[Literal['multi-host-url']]rr-r#rzrr#rr!rrrr$rrrrrNrrIrJrKrrs----OOOLLL HHHrJrc 8td|||||||||| |  S)a Returns a schema that matches a URL value with possibly multiple hosts, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.multi_host_url_schema() v = SchemaValidator(schema) print(v.validate_python('redis://localhost,0.0.0.0,127.0.0.1')) #> redis://localhost,0.0.0.0,127.0.0.1 ``` Args: max_length: The maximum length of the URL allowed_schemes: The allowed URL schemes host_required: Whether the URL must have a host default_host: The default host to use if the URL does not have a host default_port: The default port to use if the URL does not have a port default_path: The default path to use if the URL does not have a path 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 rKmulti_host_url_schemars@N  '#!!!/ #    rJcBeZdZUded<ded<ded<ded<d ed <d S) DefinitionsSchemaz Required[Literal['definitions']]rrrr definitionsrrrrNrrIrJrKrrsN****    ++++rJrrc&td||S)ab Build a schema that contains both an inner schema and a list of definitions which can be used within the inner schema. ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.definitions_schema( core_schema.list_schema(core_schema.definition_reference_schema('foobar')), [core_schema.int_schema(ref='foobar')], ) v = SchemaValidator(schema) assert v.validate_python([1, 2, '3']) == [1, 2, 3] ``` Args: schema: The inner schema definitions: List of definitions which can be referenced within inner schema r)rrr)r)rrs rKdefinitions_schemars( -K X X XXrJcBeZdZUded<ded<ded<ded<d ed <d S) DefinitionReferenceSchemaz#Required[Literal['definition-ref']]rr schema_refr!rrrrrNrrIrJrKrrsK---- HHHrJrrc*td||||S)aw Returns a schema that points to a schema stored in "definitions", this is useful for nested recursive models and also when you want to define validators separately from the main schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema_definition = core_schema.definition_reference_schema('list-schema') schema = core_schema.definitions_schema( schema=schema_definition, definitions=[ core_schema.list_schema(items_schema=schema_definition, ref='list-schema'), ], ) v = SchemaValidator(schema) assert v.validate_python([()]) == [[]] ``` Args: schema_ref: The schema ref to use for the definition reference schema metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema definition-ref)rrrrrr)rrrrs rKdefinition_reference_schemars':  *#`m   rJ)4rrrr#r-rrr!rrr rr rZrjrerqrxr}rrrrrrrrrrrPr rr r&r-r4rMr[rrur|rrrrrrrrrrr)rSrmr?r)hno_such_attribute json_invalid json_typeneeds_python_objectrecursion_loopra 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_asciire 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_parsingkwargsc >d|DS)Nci|] \}}||| SrqrI).0kvs rK z"_dict_not_none..s# = = =TQq =Aq = = =rJ)items)r,s rKrrs = =V\\^^ = = ==rJrGenerator[CoreSchema]c#hK|dD]&}t|tr |dV"|V'dS)z/Iterate over the choices of a `'union'` schema.r rN) isinstancer)rchoices rKiter_union_choicesr8sPy) fe $ $ )OOOOLLLL rJc`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.c Vtjdtt||fd|i|S)Nr9r~rrrrrr~rr,s rKfield_before_validator_functionr=s< Mm /x a aJ aZ` a aarJe`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.cNtjdtt|i|S)Nr>r;argsr,s rK!general_before_validator_functionrBs1 Mo / ? ? ??rJa`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.c Vtjdtt||fd|i|S)NrCr~rrrrr<s rKfield_after_validator_functionrF!s< Mk .h ` `: `Y_ ` ``rJc`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.cNtjdtt|i|S)NrGrEr@s rK general_after_validator_functionrI*1 Mm .t >v > >>rJ_`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.c Vtjdtt||fd|i|S)NrKr~rrrrr<s rKfield_wrap_validator_functionrN3s> Mi -Xv _ _* _X^ _ __rJa`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.cNtjdtt|i|S)NrOrMr@s rKgeneral_wrap_validator_functionrQ>s1 Mk -d =f = ==rJa`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.c Ttjdtt|fd|i|S)NrRr~rrrr)rr~r,s rKfield_plain_validator_functionrUGs: Mk .h X X: XQW X XXrJc`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.cNtjdtt|i|S)NrVrTr@s rK general_plain_validator_functionrXPrJrJ)FieldValidationInfoFieldValidatorFunctionGeneralValidatorFunctionFieldWrapValidatorFunction attr_nameobjectct|}|td|dddl}d|d|jd}|j|t d|S) Nz)module 'pydantic_core' has no attribute ''r`z` is deprecated, use `z ` instead.r)_deprecated_import_lookupgetAttributeErrorrrDrr)r]new_attrrmsgs rK __getattr__rhdsz(,,Y77HUUUUVVVP)PP83DPPP c-!<<<<rJ)rrrSr) rrrrlrrlrrrrrSr)rrrrlrrlrrrrrrrSr)rr!rrrSr)rrrSr)rrrrrSr)NN)rrrrrSr) rr!rrrrrrrrrSr)rrrrrrrSr)rrrrrrrSr)NNNN) r$rlrrrrrrrSr)rr rr rr rr rr r$rlrrrrrrrSr)r3rlrrrrrrrrrrr$rlrrrrrrrSr )r3rlrrrrrrrrrrrr rr r$rlrrrrrrrSr) r$rlrrrrrrrSr)r"r)r#r r$r r%rlr&rlr'rlr=r*r$rlr;rlrrrrrrrSr!)r#r r$r r$rlrrrrrrrSr.)r$rlrr8rr8rr8rr8r5r9r6r rrrrrrrSr3)r$rlrrDrrDrrDrrDr?rErAr@rrrrrrrSr=)r$rlrrKrrKrrKrrKr5r9r?rEr6r rAr@rrrrrrrSrI)r$rlrrQrrQrrQrrQrAr@rrrrrrrSrO) rWrXrrrrrrrSrU)rrr_rXr`rbrarcr$rlrrrrrrrSr])rrrrrSrh) rrrorrrrrrrrSrn) rrrorrrrrrrrSrn)rrrrrrrSr{) rrr$rlrrrrrrrSr)rWrrZrrSrrq)rrr$r r#r rrlr$rlrrrrrrrSr)rrrrr$rlrrrrrrrSr)rrr$r r#r r$rlrrrrrrrSr)rrrr r$r r#r rrlr$rlrrrrrrrSr)rrr$r r#r rrlr$rlrrrrrrrSr)rrr$r r#r rrlr$rlrrrrrrrSr)rrr$r r#r rrrrrrrSr)rWrrZrrSr)rrrrr$r r#r rrlr$rlrrrrrrrSr)rrrrrrrrrrrrrSr)rrrrr~rrrrrrrrrrSr)rrrrrrrrrrrrrSr)rrrrr~rrrrrrrrSr)rrrrrrrrrrrrrSr)rrrrr~rrrrrrrrrrSr) rrrrrrrrrrrSr)rrr~rrrrrrrrrrSr)rrrPrrrrrlrrr,rlr$rlrrrrrrrSr) rrr$rlrrrrrrrSr)r rrrlrrrrrrr_rrrrrrrrSr )r rrrrrrrrrr$rlr(rlrrrrrrrSr) r$rrrrrrrrSr#)r*rr+rr$rlrrrrrrrSr)) r1rr2rrrrrrrrSr0)rrr8rlr:r=r;rr<rlrrrrrSr7)rCrHrrIrDrrFrJr$rlrrrGrKrLrlrrrrrrrrrSrB)rrr:r=r;rr<rlrrrQrlrrrSrP)rCrYrWrrFrJr$rlrrrXrrGrKr(rlrrrrrrrSrV)rrrrr_rIr`rlrarlrbrr+rcr$rlrQrlrGrKrrrrrrrrrSr^)rhr!rrrirlrjrlrkrlr:r=r;rr<rlrrrrrQrlrSrg)rqr!rCrsrFrJrrrlrrrrrrrGrKrSrp)rrrrrCrzr_rIrDrrbrlr+rcr$rlrrrrrrrQrlryrlrrrSrx) rhr!rrr_rrr=rSr)rrr@rlr?rlrrrrrrrrrrrrrSr) rhr!rrr_rrr=rSr)rrr@rlr?rlrGrrrrrrrrSr)rrrrrrrrrrrrrrrSr)rrrr!rrrrrrrrrrrSr) rrrrrrrrrSr)r#r rrrrlrrrr rrrrlr$rlrrrrrrrSr)r#r rrrrlrrrr rrrrlr$rlrrrrrrrSr)rrrrrSr)NNN) rr!rrrrrrrSr)r,rrSr)rr rSr4)rrr~r!rr)rrr~r!rr)rrr~r!)r]r!rSr^)rG __future__r _annotationssysrcollections.abcrrrrrr r rr rer typingr rrrrtyping_extensionsrr version_inforrrr pydantic_corer ImportErrorr^r%r rMrHrNrRr|rrrr$GeneralPlainNoInfoSerializerFunction"GeneralPlainInfoSerializerFunction"FieldPlainNoInfoSerializerFunction FieldPlainInfoSerializerFunctionrrrrr#GeneralWrapNoInfoSerializerFunction!GeneralWrapInfoSerializerFunction!FieldWrapNoInfoSerializerFunctionFieldWrapInfoSerializerFunctionrrrrrrrrrrrrrrrrrrrrrr r rrrrrr!r,r.r1r3r;r=rGrIrMrOrSrUr[r]rfrhrkJsonTypernrtrvryr{r~rrrrrrrrrrrrrrrrrrr-r!rrrrrrrrrrValidationFunctionrrrrrrrrrrrrWrapValidatorFunctionrrrrrrrrrr r rrr!r#r'r)r.r0r5r7r@rBrNrPrTrVr\r^rergrnrprvrxr}rrrrrrrrrrrrrrr1rrrrrrrrMYPYrCoreSchemaTypeCoreSchemaFieldType ErrorTyperr8r=rBrFrIrNrQrUrXrcrYrhrIrJrKrs% 322222 8888888888444444444444??????????????11111111g!+++++++      g5???????????4444444444 %/////// %3333333 %%%"FHH%34 R"R"R"R"R"%R"R"R"R"jL KKKK 7:| D D DC#C#C#C#C#*C#C#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 c c c c  3E       !!!!!Ye!!!! @@@@ $#   IU F F F F FIU=A&* 6 im______,%im``````,%&*&* ooooo4          #&*&*------`     )5     "& $&*&*000000f     IU    $"&"&!!%&*&*777777tIU&*&* D     9E    $*.!!$(  >B)-&*&*;;;;;;|)5"!&*&*$$$$$$N     %    $/3!%&*&*111111h     %     <@;E&*&*111111hYe(/3<@!%;E&*&*999999x     iu    ;E&*&*......bIU&*&* vvvvvv6     %     7;+/&*&*000000fIU'+&*      H Iy &*&* Dy &*&* """"""JYeimdddddd,%48&*&*        59UY]]]]]] 19 <= + + + + +% + + + +'+*"!!&*48******b(,&*48------d'+)"!&*48))))))X + + + + +)5 + + + + '+!!!&*48000000f          '+,"!!&*&*,,,,,,^     iu    '+,"!!&*&*,,,,,,^+++++iu++++'+,"!&*48,,,,,,^ c3h % 7;X\YYYYYY!!3Y!>? , , , , ,% , , , ,&*'+/"!!&*&*//////f#C5#:.&&&&&I&&& %c>#+>%?%DEiu 8:YYZy)))))$     )5    $"&$('+8<59&*&*000000f          $%)'+@D#'&*&*PPPPPPf)5&*&* nnnnnnD &*&*333333l%&*&* ------`44444Ye4444!MQ&*)-&*=A%%%%%%Piu(!26'++/&*&* $======@%NR&*)-=A&*%%%%%%P          $"26'+,0+/#'&*&*666666r)5,(,#" TX+/ $&*&*RRRRRRj 4 4 4 4 4Ye 4 4 4 4& !MQ&*)-&*=A666666r " " " " ")5 " " " " 37%)&*&*+/000000fiu.(,!TX&*&* $888888vJJJJJ%JJJJX\BF LLLLLL<##CD DDDD     iu     %)%))-,0+/&*&*555555p J J J J J9E J J J J4BF#L#L#L#L#L#LL %)%)9=&*&*000000f%!%'+&*&*333333l (,26&*&*++++++\%!%+o&*&* +o+o+o+o+o+o\           "(,!%###'+&*&*444444n     %     "(,!%###'+&*&*444444n YYYY. &*&* D  8.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 3 5JJl. 35nde gi  X>>>>  qrrbbbsrb  stt@@ut@  oppaaaqpa  qrr??sr?  mnn```on`  opp>>qp>  oppYYYqpY  qrr??sr?*7 9"? )(      s BB%$B%