hm UdZddlmZddlZddlZddlmZmZddl m Z m Z m Z m Z ddl mZddlmZddlmZmZmZmZmZdd lmZmZej4d krdd lmZndd lmZej4d kr dd lmZmZmZn dd lmZmZmZerddlm Z n ddlm Z edZ#GddedZ$dZ%de&d<edddZ'Gddee'Z(Gdde(e'eZ)Gdd ee'Z*ed!Z+Gd"d#edZ,dFd$Z-eegefZ.eee(egefZ/eeegefZ0eeee)egefZ1ee.e/e0e1fZ2ed%Z3 Gd&d'edZ4dddd(d) dGd*Z5Gd+d,eZ6eee6gefZ7eee6e(egefZ8eeee6gefZ9eeee6e)egefZ:ee7e8e9e:fZ;Gd-d.edZd3d4dId5Z?Gd6d7edZ@d3d4dJd8ZAGd9d:edZBdKd;ZCee,e4ee@eBfZDGd<d=edZEdLdMd>ZFGd?d@edZGdddA dNdBZHGdCdDedZIddddE dOdFZJGdGdHedZKddddE dPdIZLGdJdKedZM dQ dRdLZNGdMdNedZOddddddddddO dSdPZPGdQdRedZQdddddddddddS dTdTZRGdUdVedZSdddddddddddddW dUdXZTGdYdZedZUddddd[ dVd\ZVGd]d^edZWddddddddddddd_ dWd`ZXGdadbedZYdddddddc dXddZZGdedfedZ[dddddddddddg dYdhZ\GdidjedZ]dddddddkddddl dZdmZ^GdndoedZ_dddddddddkddddp d[dqZ`GdrdsedZaddddddkddddt d\duZbGdvdwedZcddddE d]dxZdGdydzedZeddddddd{ d^d|ZfGd}d~edZg dL d_dZhedZiGddedZjddddd d`dZkGddedZlddddd dadZmGddedZnddddE dbdZoGddedZpdddddd dcdZqGddedZrddddddZseereDfZtGddedZu dedddddddd dfdZvdddddd dgdZw deddddddd dhdZxGddedZyddddddddd didZzGddedZ{ dedddddddd djdZ|GddedZ} dedddddddd dkdZ~GddedZ dedddddd dldZeeeefZGddedZddddmdZeeeDfZGddedZ dLdddddddd dndZeegefZGddeZeee*egefZGddedZeeefZGddedZGddedZddddd dodZdddddd dpdZGddedZddddd dqdZddddd drdZGddeZeeegefZGd„deZeeee*egefZGdĄdedZeeefZGdƄdedZddddd dsdȄZddddddɜ dtdʄZGd˄dedZddddd dud̈́Zdddddd dvd΄ZGdτdedZe dddddddddќ dwd҄ZGdӄdedZddddd[ dxdՄZGdքdedZddddddddd؜ dydلZGdڄdedZdddddddddܜ dzd݄ZGdބdedZddddE d{dZGddedZddddd[ d|dZGddedZddddE d}dZGddedZddddddd d~dZGddedZdddddddddddd ddZGddedZddddddd ddZGddedZddddddddddd ddZGddedZddddddddddddd ddZGddedZdddddddddd ddZGddedZddddddd ddZGddedZdddddddddddd ddZGddedZddd  dd Zed Zde&d <Gd dedZddddddddd ddZGddedZddd  ddZGddedZddddddd ddZGddedZdddddd ddZGddedZdddddd ddZGd d!edZ deddddE dd"ZGd#d$edZdddddddddddd% dd&ZGd'd(edZdddddddddddd% dd)ZGd*d+edZӐdd,ZGd-d.edZ d dd/ZdZesoegeEeIeKeMeOeQeSeWeYe[e]e_eaecegeeejeleneueye{e}eeeeeeeeeeeeeeeeeeeÑeǑeɑeˑe͑eϑeёeӑeՑepeUZn ed0Zed1Zed2Zېdd3Zed4dd5Zed6d7Zed8dd9Zed:d;Zed< dd=Zed>d?Zed@ddAZedBdCZe*eeedDZere*ZddEZy#e!$r e"Z Y wxYw(ze This module contains definitions to build schemas which `pydantic_core` can validate and serialize. ) annotationsN)HashableMapping)datedatetimetime timedelta)Decimal)Pattern) TYPE_CHECKINGAnyCallableLiteralUnion)TypeVar deprecated) ) TypedDict)r )ProtocolRequired TypeAlias)PydanticUndefined)allowforbidignorec*eZdZUdZded<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(<y))* CoreConfiga 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. 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_aliasurl_preserve_empty_pathN)__name__ __module__ __qualname____doc____annotations__>D:\jyotish\venv\Lib\site-packages\pydantic_core/core_schema.pyrr+s'R J L((JJ33DD44==44  44>>!!rHrF)totalz2set[int | str] | dict[int | str, IncExCall] | Noner IncExCallContextTTz Any | None) covariantdefaultceZdZdZeddZeddZeddZeddZeddZ eddZ eddZ edd Z edd Z edd Zedd Zdd ZddZddZy)SerializationInfoz%Extra data used during serialization.cy)z0The `include` argument set during serialization.NrGselfs rIincludezSerializationInfo.include rHcy)z0The `exclude` argument set during serialization.NrGrRs rIexcludezSerializationInfo.excluderUrHcy)z"The current serialization context.NrGrRs rIcontextzSerializationInfo.contextrUrHcy)z0The serialization mode set during serialization.NrGrRs rImodezSerializationInfo.moderUrHcy)z1The `by_alias` argument set during serialization.NrGrRs rIby_aliaszSerializationInfo.by_aliasrUrHcy)z6The `exclude_unset` argument set during serialization.NrGrRs rI exclude_unsetzSerializationInfo.exclude_unsetrUrHcy)z9The `exclude_defaults` argument set during serialization.NrGrRs rIexclude_defaultsz"SerializationInfo.exclude_defaultsrUrHcy)z5The `exclude_none` argument set during serialization.NrGrRs rI exclude_nonezSerializationInfo.exclude_nonerUrHcy)z@The `exclude_computed_fields` argument set during serialization.NrGrRs rIexclude_computed_fieldsz)SerializationInfo.exclude_computed_fieldsrUrHcy)z9The `serialize_as_any` argument set during serialization.NrGrRs rIserialize_as_anyz"SerializationInfo.serialize_as_anyrUrHcy)z3The `round_trip` argument set during serialization.NrGrRs rI round_tripzSerializationInfo.round_triprUrHcyNrGrRs rI mode_is_jsonzSerializationInfo.mode_is_jsonsCrHcyrkrGrRs rI__str__zSerializationInfo.__str__scrHcyrkrGrRs rI__repr__zSerializationInfo.__repr__ssrHN)returnrKrqrL)rqzLiteral['python', 'json'] | str)rqr"rqr )rBrCrDrEpropertyrTrWrYr[r]r_rarcrergrirlrnrprGrHrIrPrPs/                       (!"rHrPc"eZdZdZeddZy)FieldSerializationInfoz+Extra data used during field serialization.cy)z/The name of the current field being serialized.NrGrRs rI field_namez!FieldSerializationInfo.field_namerUrHNrs)rBrCrDrErtrxrGrHrIrvrvs5   rHrvcjeZdZdZeddZed dZed dZed dZed dZ y) ValidationInfoz"Extra data used during validation.cy)zThe current validation context.NrGrRs rIrYzValidationInfo.contextrUrHcy)z/The CoreConfig that applies to this validation.NrGrRs rIconfigzValidationInfo.configrUrHcy)z3The type of input data we are currently validating.NrGrRs rIr[zValidationInfo.moderUrHcy)z(The data being validated for this model.NrGrRs rIdatazValidationInfo.datarUrHcy)zw The name of the current field being validated if this validator is attached to a model field. NrGrRs rIrxzValidationInfo.field_names rHNrr)rqCoreConfig | None)rqzLiteral['python', 'json'])rqdict[str, Any])rq str | None) rBrCrDrErtrYr}r[rrxrGrHrIrzrzsg,           rHrz)noner,r"floatr bytes bytearraylisttupleset frozenset generatordictrrrr urlmulti-host-urljsonuuidanyceZdZUded<y)SimpleSerSchemaz$Required[ExpectedSerializationTypes]typeNrBrCrDrFrGrHrIrrs ..rHrct|S)z{ Returns a schema for serialization with a custom type. Args: type: The type to use for serialization r)rrs rIsimple_ser_schemar s  %%rH)alwaysz unless-nonerjson-unless-nonecJeZdZUded<ded<ded<ded<ded <d ed <y ) PlainSerializerFunctionSerSchema#Required[Literal['function-plain']]rzRequired[SerializerFunction]functionr"is_field_serializerinfo_arg CoreSchema return_schemaWhenUsed when_usedNrrGrHrIrr/s% --**NrHrr)rrrrc2|dk(rd}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 rI$plain_serializer_function_ser_schemar8s0&H  /#  rHceZdZdddZy)SerializerFunctionWrapHandlerNcyrkrG)rS input_value index_keys rI__call__z&SerializerFunctionWrapHandler.__call__YsX[rHrk)rr rzint | str | Nonerqr rBrCrDrrGrHrIrrXs[rHrcTeZdZUded<ded<ded<ded<ded <ded <d ed <y )WrapSerializerFunctionSerSchema"Required[Literal['function-wrap']]rz Required[WrapSerializerFunction]rr"rrrschemarrrNrrGrHrIrrls+ ,,..N rHr)rrrrrc 4|dk(rd}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 rI#wrap_serializer_function_ser_schemarvs3*H  /# rHc,eZdZUded<ded<ded<y)FormatSerSchemazRequired[Literal['format']]r Required[str]formatting_stringrrNrrGrHrIrrs %%$$rHrr)rc,|dk(rd}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 rIformat_ser_schemars#&& x;LXa bbrHc"eZdZUded<ded<y)ToStringSerSchemazRequired[Literal['to-string']]rrrNrrGrHrIrrs ((rHrc2td}|dk7r||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 rIto_string_ser_schemars% +A&&"+ HrHc,eZdZUded<ded<ded<y)ModelSerSchemaRequired[Literal['model']]rRequired[type[Any]]clsRequired[CoreSchema]rNrrGrHrIrrs $$   rHrctd||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 rImodel_ser_schemars wC ??rHc6eZdZUded<ded<ded<ded<y ) InvalidSchemazRequired[Literal['invalid']]rr refrmetadata SerSchema serializationNrrGrHrIrrs && HrHrctd||S)a] Returns an invalid schema, used to indicate that a schema is invalid. Returns a schema that matches any value, e.g.: Args: ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core invalid)rrrr)rrs rIinvalid_schemars ycH EErHc@eZdZUded<ded<ded<ded<d ed <y ) ComputedFieldz#Required[Literal['computed-field']]rr property_namerrr aliasrrNrrGrHrIrrs --  '' JrHr)rrc"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)rrrrrr)rrrrs rIcomputed_fieldrs  ]-_dow rHc6eZdZUded<ded<ded<ded<y ) AnySchemazRequired[Literal['any']]rr rrrrrNrrGrHrIrr s "" HrHrrrrc 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 rI any_schemars& u#P] ^^rHc6eZdZUded<ded<ded<ded<y ) NoneSchemazRequired[Literal['none']]rr rrrrrNrrGrHrIrr(s ## HrHrc 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 rI none_schemar/s& v3Q^ __rHc@eZdZUded<ded<ded<ded<d ed <y ) BoolSchemazRequired[Literal['bool']]rr"r#r rrrrrNrrGrHrIrrEs ## L HrHrc"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 rI bool_schemarMs. vf#`m nnrHcreZdZUded<ded<ded<ded<ded<ded<d ed <d ed <d ed<ded<y) IntSchemazRequired[Literal['int']]rr, multiple_oflegeltgtr"r#r rrrrrNrrGrHrIrrgs8 "" G G G G L HrHr rrrrrr#rrrc ,td||||||||| 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 rI int_schemarts0D    #  rHc|eZdZUded<ded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<y) FloatSchemazRequired[Literal['float']]rr"r2rrrrrrr#r rrrrrNrrGrHrIrrs> $$ I I I I L HrHr r2rrrrrr#rrrc .td||||||||||  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) rr2rrrrrr#rrrrrs rI float_schemars3H  #  #  rHceZdZUded<ded<ded<ded<ded<ded <ded <d ed <d ed <ded<ded<ded<ded<y) DecimalSchemazRequired[Literal['decimal']]rr"r2r rrrrrr, max_digitsdecimal_placesr#r rrrrrNrrGrHrIrrsI &&KKKKO L HrHr r2rrrrrrrr#rrrc 2td|||||||||| | |  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) rrrrrrrrr2r#rrrrrs rIdecimal_schemars9R   %# # rHc@eZdZUded<ded<ded<ded<d ed <y ) ComplexSchemazRequired[Literal['complex']]rr"r#r rrrrrNrrGrHrIrr/s && L HrHrrc"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 rIcomplex_schemar 7s 2   #  rHceZdZUded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<ded<ded<ded<y) StringSchemazRequired[Literal['str']]rzUnion[str, Pattern[str]]patternr, max_length min_lengthr"strip_whitespaceto_lowerto_upperr;r<r#r:r rrrrrNrrGrHrIr r YsJ "" %%OONN44 L HrHr  r rrrrrr<r#r:rrrc 2td|||||||||| | |  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 rrrrrr<r#r:rrrrrs rI str_schemaris9Z  )!3 # rHcTeZdZUded<ded<ded<ded<ded <d ed <d ed <y) BytesSchemazRequired[Literal['bytes']]rr,rrr"r#r rrrrrNrrGrHrIrrs( $$OO L HrHrrrr#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)rrrr#rrrrrs rI bytes_schemars&8   # rHc|eZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<y) DateSchemazRequired[Literal['date']]rr"r#rrrrrLiteral['past', 'future']now_opr,now_utc_offsetr rrrrrNrrGrHrIrrs@ ## L H H H H %% HrHr r#rrrrrrrrrc .td||||||||||  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#rrrrrrrrrrr s rI date_schemar"s3J   % #  rHc|eZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<y) TimeSchemazRequired[Literal['time']]rr"r#rrrrr%Union[Literal['aware', 'naive'], int] tz_constraintLiteral['truncate', 'error']microseconds_precisionr rrrrrNrrGrHrIr$r$s> ## L H H H H8888 HrHr$truncate r#rrrrr&r(rrrc .td||||||||||  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&r(rrrrr*s rI time_schemar,*s3J   #5 #  rHceZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<y)DatetimeSchemazRequired[Literal['datetime']]rr"r#rrrrrrrr%r&r,rr'r(r rrrrrNrrGrHrIr.r.^sL '' LLLLL %%8888 HrHr. r#rrrrrr&rr(rrrc 2td|||||||||| | |  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#rrrrrr&rr(rrrrr/s rIdatetime_schemar1ps9V   #%5 # rHcreZdZUded<ded<ded<ded<ded<ded <d ed <d ed <ded<ded<y)TimedeltaSchemazRequired[Literal['timedelta']]rr"r#r rrrrr'r(r rrrrrNrrGrHrIr3r3s8 (( LMMMM88 HrHr3 r#rrrrr(rrrc ,td||||||||| 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#rrrrr(rrrrr4s rItimedelta_schemar6s0F   5 #  rHc@eZdZUded<ded<ded<ded<d ed <y ) LiteralSchemazRequired[Literal['literal']]rRequired[list[Any]]expectedr rrrrrNrrGrHrIr8r8s &&!! HrHr8c"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)rr:rrrr)r:rrrs rIliteral_schemar=s0 y8xgt uurHcheZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<ded<y) EnumSchemazRequired[Literal['enum']]r Required[Any]rr9memberszLiteral['str', 'int', 'float']sub_typezCallable[[Any], Any]missingr"r#r rrrrrNrrGrHrIr?r? s6 ##   ,, !! L HrHr?)rBrCr#rrrc *td|||||||| 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) rrrArBrCr#rrrr)rrArBrCr#rrrs rI enum_schemarFs-L    #  rHc,eZdZUded<ded<ded<y)MissingSentinelSchemaz%Required[Literal['missing-sentinel']]rrrrrNrrGrHrIrHrHLs //rHrHctd||S)z,Returns a schema for the `MISSING` sentinel.missing-sentinel)rrrr)rrs rImissing_sentinel_schemarKRs  # rH)nullr"r,rr rrcJeZdZUded<ded<ded<ded<ded <d ed <y ) IsInstanceSchemaz Required[Literal['is-instance']]rr@rr cls_reprrrrrrNrrGrHrIrNrNcs$ ** M HrHrN)rOrrrc$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 rIis_instance_schemarTls:  hC(bo rHcJeZdZUded<ded<ded<ded<ded <d ed <y ) IsSubclassSchemaz Required[Literal['is-subclass']]rrrr rOrrrrrNrrGrHrIrVrVs$ ** M HrHrVc$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 rIis_subclass_schemarYs @  hC(bo rHc6eZdZUded<ded<ded<ded<y ) CallableSchemazRequired[Literal['callable']]rr rrrrrNrrGrHrIr[r[s '' HrHr[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 rIcallable_schemar^s& zsXUb ccrHcJeZdZUded<ded<ded<ded<d ed <d ed <y ) UuidSchemazRequired[Literal['uuid']]rzLiteral[1, 3, 4, 5, 7]versionr"r#r rrrrrNrrGrHrIr`r`s$ ## ## L HrHr`rar#rrrc$td|||||S)Nr)rrar#rrrrrbs rI uuid_schemards  WVx_l rHc,eZdZUded<ded<ded<y)IncExSeqSerSchemaz-Required[Literal['include-exclude-sequence']]rzset[int]rTrWNrrGrHrIrfrfs 77  rHrfrTrWctd||S)Nzinclude-exclude-sequencerrTrWrrgs rIfilter_seq_schemarjs 97T[ \\rHcheZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<y) ListSchemazRequired[Literal['list']]rr items_schemar,rrr" fail_fastr#r rrrIncExSeqOrElseSerSchemarNrrGrHrIrlrls3 ##OOO L H**rHrl)rrrnr#rrrc *td|||||||| 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 rrmrrrnr#rrrrrmrrrnr#rrrs rI list_schemarss-@  ! #  rH) extras_schemar#rrr TupleSchemacP|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)rmvariadic_item_indexr#rrr)len tuple_schema)rmrtr#rrrrws rItuple_positional_schemarz6sGB !,/#}o5 " !/ #  rH)rrr#rrrc Bt|xs 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)rmrwrrr#rrr)ryr)rmrrr#rrrs rItuple_variable_schemar|gs4@ "2jl3 #  rHcreZdZUded<ded<ded<ded<ded<d ed <d ed <d ed <ded<ded<y)ruzRequired[Literal['tuple']]rRequired[list[CoreSchema]]rmr,rwrrr"rnr#r rrrrorNrrGrHrIrurus9 $$,,OOO L H**rH)rwrrrnr#rrrc ,td||||||||| 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) rrmrwrrrnr#rrrr) rmrwrrrnr#rrrs rIryrys0J  !/ #  rHcheZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<y) SetSchemazRequired[Literal['set']]rrrmr,rrr"rnr#r rrrrrNrrGrHrIrrs3 ""OOO L HrHrc *td|||||||| 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 rrqrrrs rI set_schemars-D  ! #  rHcheZdZUded<ded<ded<ded<ded <ded <d ed <d ed<ded<y)FrozenSetSchemazRequired[Literal['frozenset']]rrrmr,rrr"rnr#r rrrrrNrrGrHrIrrs3 ((OOO L HrHrc *td|||||||| 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 rrqrrrs rIfrozenset_schemars-D  ! #  rHcTeZdZUded<ded<ded<ded<ded <d ed <d ed <y)GeneratorSchemazRequired[Literal['generator']]rrrmr,rrr rrrrorNrrGrHrIrrIs) ((OO H**rHr)rrrrrc &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)rrmrrrrrr)rmrrrrrs rIgenerator_schemarSs'H  ! # rHc,eZdZUded<ded<ded<y)IncExDictSerSchemaz)Required[Literal['include-exclude-dict']]r IncExDictrTrWNrrGrHrIrrs 33  rHrctd||S)Nzinclude-exclude-dictrirrgs rIfilter_dict_schemars 5wPW XXrHcreZdZUded<ded<ded<ded<ded<d ed <d ed <d ed <ded<ded<y) DictSchemazRequired[Literal['dict']]rr keys_schema values_schemar,rrr"rnr#r rrrIncExDictOrElseSerSchemarNrrGrHrIrrs9 ##OOO L H++rHrc ,td||||||||| 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) rrrrrrnr#rrrr) rrrrrnr#rrrs rI dict_schemars0H  # #  rHc"eZdZUded<ded<y)NoInfoValidatorFunctionSchemaLiteral['no-info']rNoInfoValidatorFunctionrNrrGrHrIrrs %%rHrc,eZdZUded<ded<ded<y)WithInfoValidatorFunctionSchemaRequired[Literal['with-info']]rz#Required[WithInfoValidatorFunction]rr rxNrrGrHrIrrs ((11OrHrc@eZdZUded<ded<ded<ded<d ed <y ) _ValidatorFunctionSchemaRequired[ValidationFunction]rrrr rrrrrNrrGrHrIrrs**  HrHrc"eZdZUded<ded<y)BeforeValidatorFunctionSchemaz$Required[Literal['function-before']]rrjson_schema_input_schemaNrrGrHrIrrs ..((rHr)rrrrc ,tdd|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 rI!no_info_before_validator_functionrs,F  #: !9# rH)rxrrrrc z|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 zThe `field_name` argument on `with_info_before_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead. stacklevelr with-inforrrxrwarningswarnDeprecationWarningr)rrrxrrrrs rI#with_info_before_validator_functionr"sQP  e   [8PZ[ !9# rHceZdZUded<y)AfterValidatorFunctionSchemaz#Required[Literal['function-after']]rNrrGrHrIrr\s --rHrc ,tdd|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 rI no_info_after_validator_functionr`s,B  #: !9# rH)rxrrrcx|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 zThe `field_name` argument on `with_info_after_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrr)rrrrrrr)rrrxrrrs rI"with_info_after_validator_functionrsNL  d   [8PZ[ #  rHceZdZdddZy)ValidatorFunctionWrapHandlerNcyrkrG)rSrouter_locations rIrz%ValidatorFunctionWrapHandler.__call__s rHrk)rr rzstr | int | Nonerqr rrGrHrIrrs rHrc"eZdZUded<ded<y)!NoInfoWrapValidatorFunctionSchemarrNoInfoWrapValidatorFunctionrNrrGrHrIrrs ))rHrc,eZdZUded<ded<ded<y)#WithInfoWrapValidatorFunctionSchemarrz'Required[WithInfoWrapValidatorFunction]rr rxNrrGrHrIrrs ((55OrHrcTeZdZUded<ded<ded<ded<d ed <d ed <d ed<y)WrapValidatorFunctionSchemarrzRequired[WrapValidatorFunction]rrrr rrrrrrrNrrGrHrIrrs+ ,,--  H((rHrc ,tdd|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 rIno_info_wrap_validator_functionrs,L  #:!9 # rH)rxrrrrc z|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 zThe `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrrrr)rrrxrrrrs rI!with_info_wrap_validator_functionr sQR  c   [8PZ[!9 # rHcJeZdZUded<ded<ded<ded<d ed <d ed <y )PlainValidatorFunctionSchemarrrrr rrrrrrrNrrGrHrIrrT s% --** H((rHrc*tdd|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 rI no_info_plain_validator_functionr] s(<  #: !9#  rHcx|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 zThe `field_name` argument on `with_info_plain_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rrrrrrr)rrxrrrrs rI"with_info_plain_validator_functionr sN@  d   [8PZ[ !9#  rHc|eZdZUded<ded<ded<ded<d ed <d ed <d ed <d ed<ded<ded<ded<y)WithDefaultSchemazRequired[Literal['default']]rrrr rNz9Union[Callable[[], Any], Callable[[dict[str, Any]], Any]]default_factoryr"default_factory_takes_dataz#Literal['raise', 'omit', 'default']on_errorr+r#r rrrrrNrrGrHrIrr sA &&  LNN $$11 L HrHr) rNrrrr+r#rrrc Jtd|||||||||  } |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 rN) rrrrrr+r#rrr)rr) rrNrrrr+r#rrrrs rIwith_default_schemar sFN  '#=) # A'') HrHcJeZdZUded<ded<ded<ded<d ed <d ed <y )NullableSchemazRequired[Literal['nullable']]rrrr"r#r rrrrrNrrGrHrIrr s$ ''  L HrHrc$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 rInullable_schemar s4  v3an rHc|eZdZUded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<y) 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#rrrrrNrrGrHrIrr$ sB $$ FF;; ++ L HrHr)rrrrr[rrrc ,td||||||||| 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) rrrrrrr[rrrr) rrrrrr[rrrs rI union_schemar3 s0J  #+11  #  rHc|eZdZUded<ded<ded<ded<ded <d ed <d ed <d ed<ded<ded<ded<y)TaggedUnionSchemaz!Required[Literal['tagged-union']]rz$Required[dict[Hashable, CoreSchema]]rzcRequired[Union[str, list[Union[str, int]], list[list[Union[str, int]]], Callable[[Any], Hashable]]] discriminatorr rrrrr"r#r'rrrrrNrrGrHrIrrf sB ++ 11vv;; L HrHr)rrrr#r'rrrc .td||||||||||  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) rrrrrrr#r'rrrr) rrrrrr#r'rrrs rItagged_union_schemart s3H  #+11' #  rHc@eZdZUded<ded<ded<ded<d ed <y ) ChainSchemazRequired[Literal['chain']]rr~stepsr rrrrrNrrGrHrIrr s $$ %% HrHrc"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)rrrrrr)rrrrs rI chain_schemar s> wex_l mmrHcTeZdZUded<ded<ded<ded<ded <d ed <d ed <y)LaxOrStrictSchemaz"Required[Literal['lax-or-strict']]rr lax_schema strict_schemar"r#r rrrrrNrrGrHrIrr s* ,,$$'' L HrHrc &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)rrrr#rrrr)rrr#rrrs rIlax_or_strict_schemar s'V  # # rHcJeZdZUded<ded<ded<ded<ded <d ed <y ) JsonOrPythonSchemaz#Required[Literal['json-or-python']]rr json_schema python_schemar rrrrrNrrGrHrIrr1 s% --%%'' HrHrc$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)rrrrrrr)rrrrrs rIjson_or_python_schemar: s$L  # #  rHc^eZdZUded<ded<ded<ded<d ed <ded <d ed <ded<y)TypedDictFieldz%Required[Literal['typed-dict-field']]rrrr"required>Union[str, list[Union[str, int]], list[list[Union[str, int]]]]validation_aliasr serialization_aliasserialization_excluderrCallable[[Any], bool]serialization_exclude_ifNrrGrHrIrrj s1 //  NTT33rHr)rr r r rrc (td|||||||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)rrrr r r rrr)rrr r r rrs rItyped_dict_fieldru s)8  )/3!9  rHceZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<d ed<ded<ded<ded<ded<y)TypedDictSchemazRequired[Literal['typed-dict']]rz#Required[dict[str, TypedDictField]]fields type[Any]rr cls_namelist[ComputedField]computed_fieldsr"r#rrtr$extra_behaviorrJrrrrrrr}NrrGrHrIrr sK )) // NM(( L!! K H rHr) rrrr#rtrrJrrrr}c 2td|||||||||| | |  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) rrrrrr#rtrrJrrrr}r) rrrrr#rtrrJrrrr}s rItyped_dict_schemar s9^   '#% # rHc^eZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<y) ModelFieldz Required[Literal['model-field']]rrrr r r r r"r r rfrozenrrNrrGrHrIrr s1 **  TT33 LrHr)r r r rrrc (td|||||||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 rrrr)rr r r rrrs rI model_fieldr" s)8  )/3!9  rHceZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<d ed<ded<ded<ded<y)ModelFieldsSchemaz!Required[Literal['model-fields']]rzRequired[dict[str, ModelField]]rr model_namerrr"r#rrtextras_keys_schemar$rr'rrrrrNrrGrHrIr$r$! sG ++ ++O(( L""!! HrHr$) r%rr#rtr&rr'rrrc 0td|||||||||| |  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) rrr%rr#rtr&rr'rrrr) rr%rr#rtr&rr'rrrs rImodel_fields_schemar)0 s6R  '#-%' #  rHceZdZUded<ded<ded<ded<d ed <d ed <d ed <ded<d ed<d ed<ded<ded<d ed<ded<ded<y) ModelSchemarrrrrgeneric_originrrr" custom_init root_modelr post_initr)r*r#rr$rrr}rrrrrNrrGrHrIr+r+i sX $$   NJJ L L!!  HrHr+) r,r-r.r/r*r#rrr}rrrc 6td|||||||||| | | | | 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-r.r/r*r#rrr}rrrr)rrr,r-r.r/r*r#rrr}rrrs rI model_schemar1{ s?D   %1% # rHceZdZUded<ded<ded<ded<ded <ded <ded <d ed <ded<ded<ded<ded<y)DataclassFieldz$Required[Literal['dataclass-field']]rrnamerrr"kw_onlyinit init_onlyrr r r r r rrr rNrrGrHrIr3r3 sF ..   M JO LTT33rHr3) r5r6r7r r r rrrc 0td||||||||| ||  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) rr4rr5r6r7r r r rrrr) r4rr5r6r7r r r rrrs rIdataclass_fieldr: s6R    )/3!9  rHcheZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<ded<y)DataclassArgsSchemaz#Required[Literal['dataclass-args']]rrdataclass_namezRequired[list[DataclassField]]rrrr"collect_init_onlyr rrrrrr$rNrrGrHrIr<r< s7 --!! **(( H!!rHr<)rr>rrrrc *td|||||||| 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) rr=rrr>rrrrr)r=rrr>rrrrs rIdataclass_args_schemarA$ s-L  %'+ #%  rHceZdZUded<ded<ded<ded<d ed <d ed <d ed<ded<d ed<d ed<d ed<ded<ded<d ed<ded<y)DataclassSchemazRequired[Literal['dataclass']]rrrrr,rrzRequired[list[str]]rr rr"r/r)r*r#rrrrrrslotsrr}NrrGrHrIrCrCW sV ((   MOJJ L L H K rHrC) r,rr/r*r#rrrrrDr}c 6td|||||||||| | | | | 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,rrrr/r*r#rrrrrDr}r)rrrr,rr/r*r#rrrrrDr}s rIdataclass_schemarGi s?P   %1 # rHc6eZdZUded<ded<ded<ded<y ) ArgumentsParameterrr4rrzCLiteral['positional_only', 'positional_or_keyword', 'keyword_only']r[r rNrrGrHrIrIrI s   MM IIrHrI)r[rc 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 r4rr[rrrKs rIarguments_parameterrL s6 tFU KKrH)uniformzunpacked-typed-dict VarKwargsModecreZdZUded<ded<ded<ded<ded <d ed <ded <d ed<ded<ded<y)ArgumentsSchemazRequired[Literal['arguments']]rz"Required[list[ArgumentsParameter]]arguments_schemar"r?r>rvar_args_schemarNvar_kwargs_modevar_kwargs_schemar rrrrrNrrGrHrIrPrP s= ((88""!! HrHrP)r?r>rRrSrTrrrc ,td||||||||| 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 arguments) rrQr?r>rRrSrTrrrr) rVr?r>rRrSrTrrrs rIrQrQ s0T  ")+''+ #  rHc6eZdZUded<ded<ded<ded<y ) ArgumentsV3Parameterrr4rrzLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict']r[r rNrrGrHrIrXrXs!     JIrHrXc 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 rKrrKs rIarguments_v3_parameterrZsF tFU KKrHc^eZdZUded<ded<ded<ded<ded <d ed <d ed <ded<y)ArgumentsV3Schemaz!Required[Literal['arguments-v3']]rz$Required[list[ArgumentsV3Parameter]]rQr"r?r>zLiteral['forbid', 'ignore']rr rrrrrNrrGrHrIr\r\Es1 ++::// HrHr\)r?r>rrrrc (td|||||||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)rrQr?r>rrrrr)rVr?r>rrrrs rIarguments_v3_schemar_Ps*N  ")+% #  rHc^eZdZUded<ded<ded<ded<d ed <ded <d ed <ded<y) CallSchemazRequired[Literal['call']]rrrQzRequired[Callable[..., Any]]rr function_namerrrrrrrNrrGrHrIraras1 ##**** HrHra)rbrrrrc (td|||||||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)rrQrrbrrrrr)rVrrbrrrrs rI call_schemares*T  "## #  rHc^eZdZUded<ded<ded<ded<d ed <ded <d ed <ded<y)CustomErrorSchemaz!Required[Literal['custom-error']]rrrrrr rrrrrrrrNrrGrHrIrgrgs1 ++  $$;; HrHrg)rrrrrc (td|||||||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 rIcustom_error_schemarjs*D  +11 #  rHc@eZdZUded<ded<ded<ded<d ed <y ) JsonSchemazRequired[Literal['json']]rrrr rrrrrNrrGrHrIrlrls ##  HrHrlc"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 rIrrsV vf#`m nnrHc|eZdZUded<ded<ded<ded<d ed <ded <d ed <ded <d ed<ded<ded<y) UrlSchemazRequired[Literal['url']]rr,r list[str]allowed_schemesr" host_requiredr default_host default_port default_pathr#rrrrrNrrGrHrIroro3sA ""O L HrHro rrqrrrsrtrupreserve_empty_pathr#rrrc 0td|||||||||| |  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 rrrqrrrsrtrurwr#rrrrrvs rI url_schemarzAs6N  '#!!!/ #  rHc|eZdZUded<ded<ded<ded<d ed <ded <d ed <ded <d ed<ded<ded<y)MultiHostUrlSchemaz#Required[Literal['multi-host-url']]rr,rrprqr"rrr rsrtrur#rrrrrNrrGrHrIr|r|xsA --O L HrHr|c 0td|||||||||| |  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 rryrrvs rImulti_host_url_schemar~s6N  '#!!!/ #  rHc@eZdZUded<ded<ded<ded<d ed <y ) DefinitionsSchemaz Required[Literal['definitions']]rrrr~ definitionsrrrrNrrGrHrIrrs **  ++rHrctd||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 rIdefinitions_schemars( -K XXrHc@eZdZUded<ded<ded<ded<d ed <y ) DefinitionReferenceSchemaz#Required[Literal['definition-ref']]rr schema_refr rrrrrNrrGrHrIrrs -- HrHrc"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 rIdefinition_reference_schemars:  *#`m rH)4rrrr"r,rrr rrrrr r<rJrErQrXr]rrrrrrrrrrrNrrrrrrrr(rr@rFrVr^rdrirrrrrrr )r!r9rr)gno_such_attribute json_invalid json_typeneeds_python_objectrecursion_looprC 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_mismatchrE dict_type mapping_type list_type tuple_typeset_typeset_item_not_hashable bool_type bool_parsingint_type int_parsingint_parsing_sizeint_from_float float_type float_parsing bytes_typebytes_too_shortbytes_too_longbytes_invalid_encoding value_errorassertion_error literal_errormissing_sentinel_error date_type date_parsingdate_from_datetime_parsingdate_from_datetime_inexact date_past date_future time_type time_parsing datetime_typedatetime_parsingdatetime_object_invaliddatetime_from_date_parsing datetime_pastdatetime_futuretimezone_naivetimezone_awaretimezone_offsettime_delta_typetime_delta_parsingfrozen_set_typeis_instance_ofis_subclass_of callable_typeunion_tag_invalidunion_tag_not_foundarguments_typemissing_argumentunexpected_keyword_argumentmissing_keyword_only_argumentunexpected_positional_argument missing_positional_only_argumentmultiple_argument_valuesurl_type url_parsingurl_syntax_violation url_too_long url_scheme uuid_type uuid_parsing uuid_version decimal_typedecimal_parsingdecimal_max_digitsdecimal_max_placesdecimal_whole_digits complex_typecomplex_str_parsingc \|jDcic] \}}| || c}}Scc}}wrk)items)kwargskvs rIrrs,#\\^ =^TQq}AqD^ == =s ((c`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.c Ttjdtt||fd|i|S)Nrrxrrrrrrxrrs rIfield_before_validator_functionrs. MMm /x aJ aZ` aarHe`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.cLtjdtt|i|S)Nrrargsrs rI!general_before_validator_functionrs& MMo / ? ??rHa`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.c Ttjdtt||fd|i|S)Nrrxrrrrrs rIfield_after_validator_functionrs. MMk .h `: `Y_ ``rHc`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.cLtjdtt|i|S)Nrrrs rI general_after_validator_functionr& MMm .t >v >>rH_`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.c Ttjdtt||fd|i|S)Nrrxrrrrrs rIfield_wrap_validator_functionrs0 MMi -Xv _* _X^ __rHa`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.cLtjdtt|i|S)Nr rrs rIgeneral_wrap_validator_functionr $s& MMk -d =f ==rHa`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.c Rtjdtt|fd|i|S)Nr rxrrrr)rrxrs rIfield_plain_validator_functionr-s, MMk .h X: XQW XXrHc`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.cLtjdtt|i|S)Nrrrs rI general_plain_validator_functionr6rrH)FieldValidationInfoFieldValidatorFunctionGeneralValidatorFunctionFieldWrapValidatorFunctionctj|}|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_lookupgetAttributeErrorrrBrr) attr_namenew_attrrmsgs rI __getattr__r!Jse(,,Y7HH STUVV)283D3D2EZP c-!<rH)rExpectedSerializationTypesrqr) rSerializerFunctionr bool | Nonerr$rCoreSchema | Nonerrrqr)rWrapSerializerFunctionrr$rr$rr%rr%rrrqr)rr rrrqr)rrrqr)rrrrrqr)NN)rrrdict[str, Any] | Nonerqr) rr rrrrrr'rqr)rrrr'rSerSchema | Nonerqr)rrrr'rr(rqr)NNNN) r#r$rrrr'rr(rqr)r int | Nonerr)rr)rr)rr)r#r$rrrr'rr(rqr)r2r$r float | Nonerr*rr*rr*rr*r#r$rrrr'rr(rqr)r2r$rDecimal | Nonerr+rr+rr+rr+rr)rr)r#r$rrrr'rr(rqr) r#r$rrrr'rr(rqr)r zstr | Pattern[str] | Nonerr)rr)rr$rr$rr$r<z)Literal['rust-regex', 'python-re'] | Noner#r$r:r$rrrr'rr(rqr )rr)rr)r#r$rrrr'rr(rqr)r#r$r date | Nonerr,rr,rr,r Literal['past', 'future'] | Nonerr)rrrr'rr(rqr)r#r$r time | Nonerr.rr.rr.r&&Literal['aware', 'naive'] | int | Noner(r'rrrr'rr(rqr$)r#r$rdatetime | Nonerr0rr0rr0rr-r&r/rr)r(r'rrrr'rr(rqr.)r#r$rtimedelta | Nonerr1rr1rr1r(r'rrrr'rr(rqr3) r: list[Any]rrrr'rr(rqr8)rr rAr2rBz%Literal['str', 'int', 'float'] | NonerCzCallable[[Any], Any] | Noner#r$rrrr'rr(rqr?)rr'rr(rqrH) rr rOrrrrr'rr(rqrN) rrrOrrrrr'rr(rqrN)rrrr'rr(rqr[) raz#Literal[1, 3, 4, 5, 6, 7, 8] | Noner#r$rrrr'rr(rqr`)rTset[int] | NonerWr3rqrfrk)rmr%rr)rr)rnr$r#r$rrrr'rIncExSeqOrElseSerSchema | Nonerqrl)rmlist[CoreSchema]rtr%r#r$rrrr'rr4rqru)rmr%rr)rr)r#r$rrrr'rr4rqru)rmr5rwr)rr)rr)rnr$r#r$rrrr'rr4rqru)rmr%rr)rr)rnr$r#r$rrrr'rr(rqr)rmr%rr)rr)rnr$r#r$rrrr'rr(rqr)rmr%rr)rr)rrrr'rr4rqr)rTIncExDict | NonerWr6rqr)rr%rr%rr)rr)rnr$r#r$rrrr'rr(rqr)rrrrrrrr%rr'rr(rqr)rWithInfoValidatorFunctionrrrxrrrrr%rr'rr(rqr)rrrrrrrr%rr'rr(rqr)rr7rrrxrrrrr'rr(rqr)rrrrrrrr%rr'rr(rqr)rWithInfoWrapValidatorFunctionrrrxrrr%rrrr'rr(rqr) rrrrrr%rr'rr(rqr)rr7rxrrrrr%rr'rr(rqr)rrrNr rz?Union[Callable[[], Any], Callable[[dict[str, Any]], Any], None]rr$rz*Literal['raise', 'omit', 'default'] | Noner+r$r#r$rrrr'rr(rqr) rrr#r$rrrr'rr(rqr)rz)list[CoreSchema | tuple[CoreSchema, str]]rr$rrrrrzdict[str, str | int] | Noner[z(Literal['smart', 'left_to_right'] | Nonerrrr'rr(rqr)rzdict[Any, CoreSchema]rzDstr | list[str | int] | list[list[str | int]] | Callable[[Any], Any]rrrrrz#dict[str, int | str | float] | Noner#r$r'r$rrrr'rr(rqr) rr5rrrr'rr(rqr)rrrrr#r$rrrr'rr(rqr) rrrrrrrr'rr(rqr)rrrr$r 4str | list[str | int] | list[list[str | int]] | Noner rr r$rr'rCallable[[Any], bool] | Nonerqr)rzdict[str, TypedDictField]rtype[Any] | Nonerrrlist[ComputedField] | Noner#r$rtr%rExtraBehavior | NonerJr$rrrr'rr(r}rrqr)rrr r9r rr r$rr:rr$rr'rqr)rzdict[str, ModelField]r%rrr<r#r$rtr%r&r%rr=r'r$rrrr'rr(rqr$)rrrrr,r;r-r$r.r$r/rr*7Literal['always', 'never', 'subclass-instances'] | Noner#r$rr$rr=r}rrrrr'rr(rqr+)r4r rrr5r$r6r$r7r$r r9r rr r$rr'rr:rr$rqr3)r=r rzlist[DataclassField]rr<r>r$rrrr'rr(rr=rqr<)rrrrrrpr,r;rrr/r$r*r>r#r$rrrr'rr(rr$rDr$r}rrqrC) r4r rrr[zJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Nonerr9rqrI)rVzlist[ArgumentsParameter]r?r$r>r$rRr%rSzVarKwargsMode | NonerTr%rrrr'rr(rqrP) r4r rrr[zLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict'] | Nonerr9rqrX)rVzlist[ArgumentsV3Parameter]r?r$r>r$rz"Literal['forbid', 'ignore'] | Nonerrrr'rr(rqr\)rVrrzCallable[..., Any]rbrrr%rrrr'rr(rqra)rrrr rrrr'rrrr'rr(rqrg) rr%rrrr'rr(rqrl)rr)rqlist[str] | Nonerrr$rsrrtr)rurrwr$r#r$rrrr'rr(rqro)rr)rqr?rrr$rsrrtr)rurrwr$r#r$rrrr'rr(rqr|)rrrr5rqr)NNN) rr rrrr'rr(rqr)rr rqr )rr7rxr rr)rr8rxr rr)rr7rxr )rr rqobject)rE __future__r _annotationssysrcollections.abcrrrrrr rr rer typingr r rrrtyping_extensionsrr version_inforrrr pydantic_corer ImportErrorr@r$rrKrFrLrPrvrzr"rr$GeneralPlainNoInfoSerializerFunction"GeneralPlainInfoSerializerFunction"FieldPlainNoInfoSerializerFunction FieldPlainInfoSerializerFunctionr#rrrr#GeneralWrapNoInfoSerializerFunction!GeneralWrapInfoSerializerFunction!FieldWrapNoInfoSerializerFunctionFieldWrapInfoSerializerFunctionr&rrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrr"r$r,r.r1r3r6r8r=r?rFrHrKJsonTyperNrTrVrYr[r^r`rdrfrjrorlrsrzr|ruryrrrrrrrr,r rrrrrrrrr7rValidationFunctionrrrrrrrrrrr8rWrapValidatorFunctionrrrrrrrrrrrrrrrrrrrrrrrrrr"r$r)r+r1r3r:r<rArCrGrIrLrNrPrQrXrZr\r_rarergrjrlrrorzr|r~rrrrMYPYrCoreSchemaTypeCoreSchemaFieldType ErrorTyperrrrrrr rrrrr!rGrHrIrZs!& 3 -44??1g+ g??44/ %3 34 P"%P"fL 9K :| D>#*>#B .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  3E  !Ye! @ $#   IU FIUKOrv'1=GZo" im_ _)>_Vf__,%im` `)>`Vf``,%&*&* o o o$o$ o  o4   #&*&*-- -  -  -  - - -$-$--` )5  "& $&*&*000  0  0  0 0 0 0$0$00f IU $"&"&!!%&*&*77 7  7  7  7 777 7 7$7$77tIU&*&*   $  $   D 9E $*.!!$(  >B)-&*&*; &;; ; " ;  ;;<; ;'; ;$;$;;|)5"!&*&*$$$  $  $ $ $$$$N % $/3!%&*&*1 1 1  1  1  1 -11 1$1$11h %  <@;E&*&*1 1 1  1  1  1:191 1$1$11hYe(/3<@!%;E&*&*9 9 9  9  9  9 -9:9999 9$9$99x iu ;E&*&*. . .  .  .  .9. .$.$..bIU&*&* vv v$ v $ v  v6 %  7;+/&*&*0 0 04 0 ) 0  0 0$0$00fIU'+&* # #   H Iy &*&*     $  $ Dy &*&* " ""  " $ " $ ""JYeimd d)>dVfdd,%48&*&*  0      $  $    59UY] 19 <= +% +'+*"!!&*48*#** *  *  * *$*2**b(,&*48-"-%-  -  - $ -2--d'+)"!&*48)#)) )  )  )$)2))X +)5 + '+!!!&*480"0$0 0  0  0 0 0$0200f   '+,"!!&*&*,#,, ,  ,  , ,$,$,,^ iu '+,"!!&*&*,#,, ,  ,  , ,$,$,,^+iu+'+,"!&*48,#,, ,  , $ ,2,,^ c3h % 7;X\Y!!3Y!>? ,% ,&*'+/"!!&*&*/"/$/ /  /  / / /$/$//f#C5#:.&I& %c>#+>%?%DEiu 8:YYZy)$ )5 $"&$('+8<59&*&*0 600" 0 % 0 6 0 30 0$0$00f   $%)'+@D#'&*&*P "PWP" P % P > P P!P P$P$PPf)5&*&* n n n$ n $ n  nD &*&*333  3  3 $ 3$33l%&*&* ---  - $ - $ --`4Ye4!MQ&*)-&*=A% %%K % $ % ' %$%;%%Piu(!26'++/&*&* $= %= = = 0 =  =%=)= = =$=$= ==@%NR&*)-=A&*% %K%$ % ' % ; % %$%%P   $"26'+,0+/#'&*&*6 !660 6  6 % 6*6)6!6 6$6$66r)5,(,#" TX+/ $&*&*R R R% R  R  RRRR R R)R R R$R$R !Rj 4Ye 4& !MQ&*)-&*=A6 6 6 6  6  6K6$6'6$6;6 66r ")5 " 37%)&*&*+/00 00 0 # 0  0$0$0)00fiu.(,!TX&*&* $8 8 8 8 % 8  88R8 8 8$8$8 8 8 8 !8vJ%JX\BF L L L U L @ L  L<##CD yD iu  %)%))-,0+/&*&*5'5"5# 5 ' 5 * 5)5 5$5$55p J9E J4BF#L #L #L #L @#L#LL %)%)9=&*&*0)0"0# 0 7 0  0$0$00f%!%'+&*&*33 3 3 % 3  3$3$33l (,26&*&*+ ++% + 0 +  +$+$++\%!%+o&*&* +o +o +o$ +o $ +o  +o\    "(,!%###'+&*&*44&4 4  4  44%4 4 4$4$44n %  "(,!%###'+&*&*44&4 4  4  44%4 4 4$4$44n Y. &*&*  $$   D  3  3 3 3  3   3   3   3  3  3  3  3  3  3  3  3  3  !3 " #3 $ %3 & '3 ( )3 * +3 , -3 . /3 0 13 2 %33 4 &53 6 $73 8 %93 : ;3 < =3 > ?3 @ A3 B C3 D E3 F G3 H I3 J K3 L M3 N O3 P Q3 R S3 T U3 V W3 X Y3 Z [3 \ ]3 ^ _3 ` a3 b "c3 d e3 f g3 5Jl 35nde fh  V> qrbsb st@u@ opaqa qr?s? mn`+`9<`FP`o` op>q> opYqY qr?s?*7 9"? ( MI %"H%sy yy