+ ij\csFa0t$Rt^RIHt^RIt^RIt^RIHtH t ^RI H t H t H t H t ^RIHt^RIHt^RIHtHtHtHtHt^RIHtHt]P6ER8d^R IHtM^R IHt]P6ER8d ^R IHtHtHtM ^R IHtHtHt]'d^R I H!t!M^R I H!t!]ER,t$!R R ]RR7t%Rt&R]'R&]!RRRR7t(!RR]](,4t)!RR])](,]4t*!RR]](,4t+]ER,t,!RR]RR7t-RR lt.]].]3,t/]]])],.]3,t0]]].]3,t1]]]]*],.]3,t2]]/]0]1]23,t3]ER,t4!R#R$]RR7t5R%RR&RR'RR(R!/R)R*llt6!R+R,]4t7]]]7.]3,t8]]]7])],.]3,t9]]]]7.]3,t:]]]]7]*],.]3,t;]]8]9]:];3,t<!R-R.]RR7t=R%RR&RR/RR'RR(R!/R0R1llt>!R2R3]RR7t?R(R"/R4R5llt@!R6R7]RR7tAR(R"/R8R9lltB!R:R;]RR7tCR<R=ltD]]-]5]=]?]A]C3,tE!R>R?]RR7tFERR@RAlltG!RBRC]RR7tHRDRRER/RFRGlltI!RHRI]RR7tJRJRRERRKR/RLRMlltK!RNRO]RR7tLRJRRERRKR/RPRQlltM!RRRS]RR7tNERRTRUlltO!RVRW]RR7tPRXRRYRRZRR[RR\RR]RRJRRERRKR/ R^R_lltQ!R`Ra]RR7tRRbRRXRRYRRZRR[RR\RR]RRJRRERRKR/ RcRdlltS!ReRf]RR7tTRbRRXRRYRRZRR[RR\RRgRRhRR]RRJRRERRKR/ RiRjlltU!RkRl]RR7tVR]RRJRRERRKR/RmRnlltW!RoRp]RR7tXRqRRrRRsRRtRRuRRvRRwRR]RRxRRJRRERRKR/ RyRzlltY!R{R|]RR7tZRrRRsRR]RRJRRERRKR/R}R~llt[!RR]RR7t\R]RRYRRZRR[RR\RRRRRRJRRERRKR/ RRllt]!RR]RR7t^R]RRYRRZRR[RR\RRRRRRJRRERRKR/ RRllt_!RR]RR7t`R]RRYRRZRR[RR\RRRRRRRRRRJRRERRKR/ RRllta!RR]RR7tbR]RRYRRZRR[RR\RRRRJRRERRKR/ RRlltc!RR]RR7tdRJRRERRKR/RRllte!RR]RR7tfRRRRR]RRJRRERRKR/RRlltg!RR]RR7thERRRllti]ER,tj!RR]RR7tkRRRJRRERRKR/RRlltl!RR]RR7tmRRRJRRERRKR/RRlltn!RR]RR7toRJRRERRKR/RRlltp!RR]RR7tqRRR]RRJRRERRKR/RRlltr!RR]RR7tsRRRR/RRlltt]]s]E3,tu!RR]RR7tvERRsRRrRRRR]RRJRRERRKR/RRllltwRRR]RRJRRERRKR/RRlltxERRsRRrRR]RRJRRERRKR/RRlllty!RR]RR7tzRRRsRRrRRRR]RRJRRERRKR/RRllt{!RR]RR7t|ERRsRRrRRRR]RRJRRERRKR/RRlllt}!RR]RR7t~ERRsRRrRRRR]RRJRRERRKR/RRlllt!RR]RR7tERRsRRrRRJRRERRKR/RRlllt]]]]3,,t!RR]RR7tRRRR/RRllt]]]E3,t!RR]RR7tERRsRRrRRRR]RRJRRERRKR/RRlllt]].]3,t!RR]4t]]]+],.]3,t!RR]RR7t]]]3,t!RR]RR7t!RR]RR7tRJRRRRERRKR/RRlltRRRJRRRRERRKR/RRllt!RR]RR7tRJRRRRERRKR/RRlltRRRJRRERRKR/RRllt!RR]4t]]].]3,t!RR]4t]]]]+],.]3,t!RR]RR7t]]]3,t!RR]RR7tRJRRRRERRKR/RRlltRRRRRJRRERRKR/RRllt!RR]RR7tRJRRRRERRKR/RERlltRRRJRRRRERRKR/ERERllt!ERER]RR7tER]!ERRERRERRER RR]RRJRRERRKR/ ER ER llt!ER ER ]RR7tR]RRJRRERRKR/ERERllt!ERER]RR7tERRERRERRERRERRRJRRERRKR/ERERllt!ERER]RR7tERRERRERRR]RERRRJRRERRKR/ERERllt!ERER]RR7tRJRRERRKR/ER ER!llt!ER"ER#]RR7tR]RRJRRERRKR/ER$ER%llt!ER&ER']RR7tRJRRERRKR/ER(ER)llt!ER*ER+]RR7tER,RER-RER.RER/RRERER0R/ER1ER2llt!ER3ER4]RR7tER5RER6RER7RR]RRRER8RER9RRJRRERRKRER:R/ ER;ER<llt!ER=ER>]RR7tER-RER.RER/RER0RER?RRER/ER@ERAllt!ERBERC]RR7tERDRER7RR]RRRERERER8RERRRJRRERRKR/ ERFERGllt!ERHERI]RR7tERJRERKRERLRERMRERNRR]RER?RER8RER:RRJRRERRKR/ EROERPllt!ERQERR]RR7tERSRERTRERURER-RER.RER/RRERER0RER?R/ ERVERWllt!ERXERY]RR7tER7RERZRRJRRERRKRER8R/ER[ER\llt!ER]ER^]RR7tERJRER6RERMRERNRR]RRJRRERRKRER?RER_RER:R/ ER`ERallt!ERbERc]RR7tERRRDR/ERdERellt]ER,tR]'ERf&!ERgERh]RR7tERiRERjRERkRERlRERmRRJRRERRKR/ERnERollt!ERpERq]RR7tERRRDR/ERrERsllt!ERtERu]RR7tERiRERjRER8RRJRRERRKR/ERvERwllt!ERxERy]RR7tERzRR'RRJRRERRKR/ER{ER|llt!ER}ER~]RR7tERRERRRJRRERRKR/ERERllt!ERER]RR7tERRJRRERRKR/ERERlllt!ERER]RR7tRrRERRERRERRERRERRERRR]RRJRRERRKR/ ERERllt!ERER]RR7tRrRERRERRERRERRERRERRR]RRJRRERRKR/ ERERllt!ERER]RR7tERERlt!ERER]RR7tERERERlltRt]'gt].]FN]JN]LN]NN]PN]RN]TN]XN]ZN]\N]^N]`N]bN]dN]hN]fN]kN]mN]oN]vN]zN]|N]~N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]N]qN]VN5,tM]ER,t]ER,t]ER,tERERlt]!ER4ERERl4t]!ER4ER4t]!ER4ERERl4t]!ER4ER4t]!ER4ERERl4t]!ER4ER4t]!ER4ERERl4t]!ER4ER4tER]+ER]ER]ER]/t]'d]+tERERltR# ]"d ]#!4t!E Li;i(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)ProtocolRequired TypeAlias)PydanticUndefinedcs4]tRt^+t$RtR]R&R]R&R]R&R]R&R]R &R]R &R ]R &R]R &R]R&R]R&R]R&R]R&R]R&R]R&R]R&R]R&R]R&R]R&R]R&R]R&R]R&R]R &R!]R"&R#]R$&R]R%&R]R&&R]R'&R]R(&R)tR*#)+ 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`. strZtitleboolstrict ExtraBehaviorZextra_fields_behaviorZtyped_dict_totalfrom_attributesZ loc_by_alias0Literal['always', 'never', 'subclass-instances']revalidate_instancesvalidate_defaultintZstr_max_lengthZstr_min_lengthZstr_strip_whitespaceZ str_to_lowerZ str_to_upper allow_inf_nanzLiteral['iso8601', 'float']Zser_json_timedeltaz-Literal['iso8601', 'seconds', 'milliseconds']Zser_json_temporalz Literal['utf8', 'base64', 'hex']Zser_json_bytesz'Literal['null', 'constants', 'strings']Zser_json_inf_nanZval_json_bytesZhide_input_in_errorsZvalidation_error_causecoerce_numbers_to_str"Literal['rust-regex', 'python-re'] regex_enginez+Union[bool, Literal['all', 'keys', 'none']]Z cache_stringsvalidate_by_aliasvalidate_by_nameZserialize_by_aliasZurl_preserve_empty_pathN)__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__r%@/usr/lib64/python3.14/site-packages/pydantic_core/core_schema.pyrr+s'R J L((JJ33DD44==44  44>>!!r-rF)totalz2set[int | str] | dict[int | str, IncExCall] | Noner IncExCallContextTTz Any | None)Z covariantdefaultcs0]tRt^tRt]RRl4t]RRl4t]RRl4t]RR l4t ]R R l4t ]R R l4t ]RRl4t ]RRl4t ]RRl4t]RRl4t]RRl4tRRltRRltRRltRtR#) SerializationInfoz%Extra data used during serialization.cV^8dQhRR/#returnr0r%format"r. __annotate__SerializationInfo.__annotate__   r-c R#)z0The `include` argument set during serialization.Nr%self&r.includeZSerializationInfo.include r-cr4r5r%r8r:r.r;r<r=r-c r>)z0The `exclude` argument set during serialization.Nr%r?rAr.excludeZSerializationInfo.excluderCr-cr4r6r7r1r%r8r:r.r;r<   r-c r>)z"The current serialization context.Nr%r?rAr.contextZSerializationInfo.contextrCr-cr4)r6r7zLiteral['python', 'json'] | strr%r8r:r.r;r<s  5 r-c r>)z0The serialization mode set during serialization.Nr%r?rAr.modeZSerializationInfo.moderCr-cr4r6r7rr%r8r:r.r;r<s  $ r-c r>)z1The `by_alias` argument set during serialization.Nr%r?rAr.by_aliasZSerializationInfo.by_aliasrCr-cr4rIr%r8r:r.r;r<s  t r-c r>)z6The `exclude_unset` argument set during serialization.Nr%r?rAr. exclude_unsetZSerializationInfo.exclude_unsetrCr-cr4rIr%r8r:r.r;r<  $ r-c r>)z9The `exclude_defaults` argument set during serialization.Nr%r?rAr.exclude_defaultsZ"SerializationInfo.exclude_defaultsrCr-cr4rIr%r8r:r.r;r<s  d r-c r>)z5The `exclude_none` argument set during serialization.Nr%r?rAr. exclude_noneZSerializationInfo.exclude_nonerCr-cr4rIr%r8r:r.r;r<s   r-c r>)z@The `exclude_computed_fields` argument set during serialization.Nr%r?rAr.exclude_computed_fieldsZ)SerializationInfo.exclude_computed_fieldsrCr-cr4rIr%r8r:r.r;r<rLr-c r>)z9The `serialize_as_any` argument set during serialization.Nr%r?rAr.serialize_as_anyZ"SerializationInfo.serialize_as_anyrCr-cr4rIr%r8r:r.r;r<s  D r-c r>)z3The `round_trip` argument set during serialization.Nr%r?rAr. round_tripZSerializationInfo.round_triprCr-cr4rIr%r8r:r.r;r<s ''d'r-c R#Nr%r?rAr. mode_is_jsonZSerializationInfo.mode_is_jsonsCr-cr4r6r7rr%r8r:r.r;r<s !!!r-c rRrSr%r?rAr.__str__ZSerializationInfo.__str__scr-cr4rUr%r8r:r.r;r<s ""#"r-c rRrSr%r?rAr.__repr__ZSerializationInfo.__repr__ssr-r%N)r&r'r(r)r*propertyrBrDrGrHrJrKrMrNrOrPrQrTrVrWr,r%r-r.r3r3s/                       (!""r-r3cs0]tRt^tRt]RRl4tRtR#)FieldSerializationInfoz+Extra data used during field serialization.cr4rUr%r8r:r.r;Z#FieldSerializationInfo.__annotate__s  C r-c r>)z/The name of the current field being serialized.Nr%r?rAr. field_nameZ!FieldSerializationInfo.field_namerCr-r%N)r&r'r(r)r*rXrZr,r%r-r.rYrYs5   r-rYcs]tRt^tRt]RRl4t]RRl4t]RRl4t]RR l4t ]R R l4t R t R #)ValidationInfoz"Extra data used during validation.cr4rEr%r8r:r.r;ValidationInfo.__annotate__rFr-c r>)zThe current validation context.Nr%r?rAr.rGZValidationInfo.contextrCr-cr4)r6r7CoreConfig | Noner%r8r:r.r;r\s  ) r-c r>)z/The CoreConfig that applies to this validation.Nr%r?rAr.configZValidationInfo.configrCr-cr4)r6r7zLiteral['python', 'json']r%r8r:r.r;r\s  / r-c r>)z3The type of input data we are currently validating.Nr%r?rAr.rHZValidationInfo.moderCr-cr4)r6r7dict[str, Any]r%r8r:r.r;r\s  n r-c r>)z(The data being validated for this model.Nr%r?rAr.dataZValidationInfo.datarCr-cr4)r6r7 str | Noner%r8r:r.r;r\s  J r-c r>)z_ The name of the current field being validated if this validator is attached to a model field. Nr%r?rAr.rZZValidationInfo.field_names r-r%N) r&r'r(r)r*rXrGr^rHr`rZr,r%r-r.r[r[sg,           r-r[c"]tRtRt$R]R&RtR#)SimpleSerSchemaiz$Required[ExpectedSerializationTypes]typer%Nr&r'r(r)r+r,r%r-r.rcrcs ..r-rcc V^8dQhRRRR/#)r6rdExpectedSerializationTypesr7rcr%r8r:r.r;r; s&&6&?&r-cs\VR7#)zk Returns a schema for serialization with a custom type. Args: type: The type to use for serialization rd)rcrhrAr.simple_ser_schemari s  %%r-alwaysjson-unless-nonecT]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R tR#) PlainSerializerFunctionSerSchemai/#Required[Literal['function-plain']]rdzRequired[SerializerFunction]functionris_field_serializerinfo_arg CoreSchema return_schemaWhenUsed when_usedr%Nrer%r-r.rmrm/s% --**Nr-rmrprqrsruc 0V^8dQhRRRRRRRRRR R R /#) r6roSerializerFunctionrp bool | NonerqrsCoreSchema | Nonerurtr7rmr%r8r:r.r;r;8sF %  %   &r-c s6VR8XdRp\RVVVVVR7#)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 rjNfunction-plain)rdrorprqrsru_dict_not_none)rorprqrsru&$$$$r.$plain_serializer_function_ser_schemar~8s0&H  /#  r-c&]tRtRtRRRlltRtR#)SerializerFunctionWrapHandleriXNc$V^8dQhRRRRRR/#)r6 input_valuer index_keyzint | str | Noner7r%r8r:r.r;Z*SerializerFunctionWrapHandler.__annotate__Ys[[C[4D[SV[r-c rRrSr%)r@rr"""r.__call__Z&SerializerFunctionWrapHandler.__call__YsX[r-r%rSr&r'r(r)rr,r%r-r.rrXs[[r-rcs^]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R ]R &RtR#)WrapSerializerFunctionSerSchemail"Required[Literal['function-wrap']]rdz Required[WrapSerializerFunction]rorrprqrrschemarsrtrur%Nrer%r-r.rrls+ ,,..N r-rrcs4V^8dQhRRRRRRRRRRR R R R /#) r6roWrapSerializerFunctionrprxrqrryrsrurtr7rr%r8r:r.r;r;vsP  $ %     %  % r-c s8VR8XdRp\RVVVVVVR7#)a Returns a schema for serialization with a wrap function, can be either a "general" or "field" function. Args: function: The function to use for serialization is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument, and `info` includes `field_name` info_arg: Whether the function takes an `info` argument schema: The schema to use for the inner serialization return_schema: Schema to use for serializing return value when_used: When the function should be called rjN function-wrap)rdrorprqrrsrur{)rorprqrrsru&$$$$$r.#wrap_serializer_function_ser_schemarvs3*H  /# r-c6]tRtRt$R]R&R]R&R]R&RtR #) FormatSerSchemaizRequired[Literal['format']]rd Required[str]formatting_stringrtrur%Nrer%r-r.rrs %%$$r-rc$V^8dQhRRRRRR/#)r6rrrurtr7rr%r8r:r.r;r;s' c c cH c^m cr-cs.VR8XdRp\RWR7#)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 rkNr9)rdrrur{)rrus&$r.format_ser_schemars && x;L bbr-c,]tRtRt$R]R&R]R&RtR#)ToStringSerSchemaizRequired[Literal['to-string']]rdrtrur%Nrer%r-r.rrs ((r-rcrf)r6rurtr7rr%r8r:r.r;r;s   x  IZ  r-cs4\RR7pVR8wdWR&V#)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-stringrhrkru)dict)russ$ r.to_string_ser_schemars# +A&&"+ Hr-cr) ModelSerSchemaiRequired[Literal['model']]rdRequired[type[Any]]clsRequired[CoreSchema]rr%Nrer%r-r.rrs $$   r-rcr)r6r type[Any]rrrr7rr%r8r:r.r;r;s&@@)@Z@N@r-c\RWR7#)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)rdrr)r)rr&&r.model_ser_schemars wC ??r-c@]tRtRt$R]R&R]R&R]R&R]R &R tR #) InvalidSchemaizRequired[Literal['invalid']]rdrrefr_metadata SerSchema serializationr%Nrer%r-r.rrs && Hr-rcr)r6rrardict[str, Any] | Noner7rr%r8r:r.r;r;s( F F F5J FVc Fr-cr)aE 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)rdrrr{)rrrr.invalid_schemars yc EEr-cJ]tRtRt$R]R&R]R&R]R&R]R &R ]R &R tR #) ComputedFieldiz#Required[Literal['computed-field']]rdr property_namerrsraliasr_rr%Nrer%r-r.rrs --  '' Jr-rrrc ,V^8dQhRRRRRRRRR R /#) r6rrrsrrrrarrr7rr%r8r:r.r;r;s4'1=GZor-c\RWW#R7#)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)rdrrsrrr{)rrsrr&&$$r.computed_fieldrs  ]_d r-cr) AnySchemai zRequired[Literal['any']]rdrrr_rrrr%Nrer%r-r.rr s "" Hr-rrrc(V^8dQhRRRRRRRR/#) r6rrarrrSerSchema | Noner7rr%r8r:r.r;r;s2__ _)>_Vf__r-c\RWVR7#)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 anyrdrrrr{rrr$$$r. any_schemars& u#P] ^^r-cr) NoneSchemai(zRequired[Literal['none']]rdrrr_rrrr%Nrer%r-r.rr(s ## Hr-rcr) r6rrarrrrr7rr%r8r:r.r;r;/s2`` `)>`Vf``r-cr)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 nonerr{rrr. none_schemar/s& v3Q^ __r-cr) BoolSchemaiEzRequired[Literal['bool']]rdrrrrr_rrrr%Nrer%r-r.rrEs ## L Hr-rc r) r6rrxrrarrrrr7rr%r8r:r.r;r;MsAoo o o$o$ o  or-cr)a1 Returns a schema that matches a bool value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.bool_schema() v = SchemaValidator(schema) assert v.validate_python('True') is True ``` Args: strict: Whether the value should be a bool or a value that can be converted to a bool ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rrdrrrrr{rrrr&&&&r. bool_schemarMs. vf nnr-cs|]tRtRt$R]R&R]R&R]R&R]R&R]R&R]R &R ]R &R ]R &R]R&R]R&RtR#) IntSchemaigzRequired[Literal['int']]rdr multiple_oflegeltgtrrrrr_rrrr%Nrer%r-r.rrgs8 "" G G G G L Hr-rrrrrrrcs@V^8dQhRRRRRRRRRRRRR R R R R RRR/ #)r6r int | Nonerrrrrrxrrarrrrr7rr%r8r:r.r;r;tsn--- -  -  -  - - -$-$--r-c ,\RVVVVVVVVVR7 #)am Returns a schema that matches a int value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.int_schema(multiple_of=2, le=6, ge=2) v = SchemaValidator(schema) assert v.validate_python('4') == 4 ``` Args: multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number strict: Whether the value should be a int or a value that can be converted to a int ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rdrrrrrrrrrr{) rrrrrrrrr $$$$$$$$$r. int_schemarts0D    #  r-cs]tRtRt$R]R&R]R&R]R&R]R&R]R &R]R &R]R &R]R &R ]R&R]R&R]R&RtR#) FloatSchemaizRequired[Literal['float']]rdrrfloatrrrrrrrrr_rrrr%Nrer%r-r.rrs> $$ I I I I L Hr-rrcsDV^8dQhRRRRRRRRRRRRR RR R R R RRRR/ #)r6rrxrz float | Nonerrrrrrrarrrrr7rr%r8r:r.r;r;sx0000  0  0  0 0 0 0$0$00r-c .\RVVVVVVVVVV R7 #)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) rdrrrrrrrrrrr{) rrrrrrrrrr $$$$$$$$$$r. float_schemars3H  #  #  r-cs]tRtRt$R]R&R]R&R]R&R]R&R]R &R]R &R]R &R ]R &R ]R&R]R&R]R&R]R&R]R&RtR#) DecimalSchemaizRequired[Literal['decimal']]rdrrrrrrrrr max_digitsdecimal_placesrrrr_rrrr%Nrer%r-r.rrsI &&KKKKO L Hr-rrrcsLV^8dQhRRRRRRRRRRRRR R R R R RR RRRRRRR/ #)r6rrxrzDecimal | Nonerrrrrrrrrrarrrrr7rr%r8r:r.r;r;s777 7  7  7  7 777 7 7$7$77r-c s2\RVVVVVVVVVV V V R7 #)aN Returns a schema that matches a decimal value, e.g.: ```py from decimal import Decimal from pydantic_core import SchemaValidator, core_schema schema = core_schema.decimal_schema(le=0.8, ge=0.2) v = SchemaValidator(schema) assert v.validate_python('0.5') == Decimal('0.5') ``` Args: allow_inf_nan: Whether to allow inf and nan values multiple_of: The value must be a multiple of this number le: The value must be less than or equal to this number ge: The value must be greater than or equal to this number lt: The value must be strictly less than this number gt: The value must be strictly greater than this number max_digits: The maximum number of decimal digits allowed decimal_places: The maximum number of decimal places allowed strict: Whether the value should be a float or a value that can be converted to a float ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema decimal) rdrrrrrrrrrrrrr{) rrrrrrrrrrrr $$$$$$$$$$$$r.decimal_schemars9R   %# # r-cr) ComplexSchemai/zRequired[Literal['complex']]rdrrrrr_rrrr%Nrer%r-r.rr/s && L Hr-rc r) r6rrxrrarrrrr7rr%r8r:r.r;r;7s<  $  $   r-cs"\RVVVVR7#)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 complexrr{rs$$$$r.complex_schemar7s 2   #  r-cs]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R ]R &R ]R&R ]R&R ]R&R]R&R]R&R]R&RtR#) StringSchemaiYzRequired[Literal['str']]rdzUnion[str, Pattern[str]]patternr max_length min_lengthrstrip_whitespaceto_lowerto_upperr!r"rr rrr_rrrr%Nrer%r-r.rrYsJ "" %%OONN44 L Hr-rrrrrrrr"r csLV^8dQhRRRRRRRRRRR RR R R RR RRRRRRRRR/ #)r6rzstr | Pattern[str] | Nonerrrrrxrrr"z)Literal['rust-regex', 'python-re'] | Nonerr rrarrrrr7rr%r8r:r.r;r;is;; &;; ; " ;  ;;<; ;'; ;$;$;;r-c 2\RVVVVVVVVVV V V R7 #)a Returns a schema that matches a string value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.str_schema(max_length=10, min_length=2) v = SchemaValidator(schema) assert v.validate_python('hello') == 'hello' ``` Args: pattern: A regex pattern that the value must match max_length: The value must be at most this length min_length: The value must be at least this length strip_whitespace: Whether to strip whitespace from the value to_lower: Whether to convert the value to lowercase to_upper: Whether to convert the value to uppercase regex_engine: The regex engine to use for pattern validation. Default is 'rust-regex'. - `rust-regex` uses the [`regex`](https://docs.rs/regex) Rust crate, which is non-backtracking and therefore more DDoS resistant, but does not support all regex features. - `python-re` use the [`re`](https://docs.python.org/3/library/re.html) module, which supports all regex features, but may be slower. strict: Whether the value should be a string or a value that can be converted to a string coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode). ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rdrrrrrrr"rr rrrr{) rrrrrrr"rr rrrrr. str_schemaris9Z  )!3 # r-c^]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R ]R&RtR#) BytesSchemaizRequired[Literal['bytes']]rdrrrrrrrr_rrrr%Nrer%r-r.rrs( $$OO L Hr-rc4V^8dQhRRRRRRRRRR R R R R /#)r6rrrrrxrrarrrrr7rr%r8r:r.r;r;sP$$$$  $  $ $ $$$$r-c &\RVVVVVVR7#)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 bytes)rdrrrrrrr{)rrrrrrs$$$$$$r. bytes_schemars&8   # r-c]tRtRt$R]R&R]R&R]R&R]R&R]R &R]R &R ]R &R ]R&R]R&R]R&R]R&RtR#) DateSchemaizRequired[Literal['date']]rdrrrrrrrLiteral['past', 'future']now_oprnow_utc_offsetrrr_rrrr%Nrer%r-r.rrs@ ## L H H H H %% Hr-rrrcDV^8dQhRRRRRRRRRRRR R R R R RRRRRR/ #)r6rrxrz date | Nonerrrr Literal['past', 'future'] | Nonerrrrarrrrr7rr%r8r:r.r;r;sx11 1 1  1  1  1 -11 1$1$11r-c r)a0 Returns a schema that matches a date value, e.g.: ```py from datetime import date from pydantic_core import SchemaValidator, core_schema schema = core_schema.date_schema(le=date(2020, 1, 1), ge=date(2019, 1, 1)) v = SchemaValidator(schema) assert v.validate_python(date(2019, 6, 1)) == date(2019, 6, 1) ``` Args: strict: Whether the value should be a date or a value that can be converted to a date le: The value must be less than or equal to this date ge: The value must be greater than or equal to this date lt: The value must be strictly less than this date gt: The value must be strictly greater than this date now_op: The value must be in the past or future relative to the current date now_utc_offset: The value must be in the past or future relative to the current date with this utc offset ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rdrrrrrrrrrrr{) rrrrrrrrrrrr. date_schemars3J   % #  r-cr) TimeSchemaizRequired[Literal['time']]rdrrrrrrr%Union[Literal['aware', 'naive'], int] tz_constraintLiteral['truncate', 'error']microseconds_precisionrrr_rrrr%Nrer%r-r.rrs> ## L H H H H8888 Hr-rrrZtruncatecr)r6rrxrz time | Nonerrrr&Literal['aware', 'naive'] | int | Nonerrrrarrrrr7rr%r8r:r.r;r;*sx11 1 1  1  1  1:191 1$1$11r-c r)a8 Returns a schema that matches a time value, e.g.: ```py from datetime import time from pydantic_core import SchemaValidator, core_schema schema = core_schema.time_schema(le=time(12, 0, 0), ge=time(6, 0, 0)) v = SchemaValidator(schema) assert v.validate_python(time(9, 0, 0)) == time(9, 0, 0) ``` Args: strict: Whether the value should be a time or a value that can be converted to a time le: The value must be less than or equal to this time ge: The value must be greater than or equal to this time lt: The value must be strictly less than this time gt: The value must be strictly greater than this time tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rdrrrrrrrrrrr{) rrrrrrrrrrrr. time_schemar*s3J   #5 #  r-cs]tRtRt$R]R&R]R&R]R&R]R&R]R &R]R &R ]R &R ]R&R]R&R]R&R]R&R]R&R]R&RtR#)DatetimeSchemai^zRequired[Literal['datetime']]rdrrrrrrrrrrrrrrrrrr_rrrr%Nrer%r-r.rr^sL '' LLLLL %%8888 Hr-rcsLV^8dQhRRRRRRRRRRRR R R R R RRRRRRRRRR/ #)r6rrxrzdatetime | Nonerrrrrrrrrrrrrarrrrr7rr%r8r:r.r;r;ps99 9 9  9  9  9 -9:9999 9$9$99r-c r)ad Returns a schema that matches a datetime value, e.g.: ```py from datetime import datetime from pydantic_core import SchemaValidator, core_schema schema = core_schema.datetime_schema() v = SchemaValidator(schema) now = datetime.now() assert v.validate_python(str(now)) == now ``` Args: strict: Whether the value should be a datetime or a value that can be converted to a datetime le: The value must be less than or equal to this datetime ge: The value must be greater than or equal to this datetime lt: The value must be strictly less than this datetime gt: The value must be strictly greater than this datetime now_op: The value must be in the past or future relative to the current datetime tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset TODO: use of a tzinfo where offset changes based on the datetime is not yet supported now_utc_offset: The value must be in the past or future relative to the current datetime with this utc offset microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rdrrrrrrrrrrrrr{) rrrrrrrrrrrrrr.datetime_schemarps9V   #%5 # r-cs|]tRtRt$R]R&R]R&R]R&R]R&R]R &R]R &R ]R &R ]R&R]R&R]R&RtR#)TimedeltaSchemaizRequired[Literal['timedelta']]rdrrrrrrrrrrrr_rrrr%Nrer%r-r.rrs8 (( LMMMM88 Hr-rcs@V^8dQhRRRRRRRRRRRR R R R R RRRR/ #)r6rrxrztimedelta | Nonerrrrrrrarrrrr7rr%r8r:r.r;r;sn.. . .  .  .  .9. .$.$..r-c r)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) rdrrrrrrrrrr{) rrrrrrrrrrr.timedelta_schemars0F   5 #  r-cr) LiteralSchemaizRequired[Literal['literal']]rdRequired[list[Any]]expectedrrr_rrrr%Nrer%r-r.rrs &&!! Hr-rc r) r6r list[Any]rrarrrrr7rr%r8r:r.r;r;sCvvv v$ v $ v  vr-cr)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)rdrrrrr{)rrrr&$$$r.literal_schemars0 y8x uur-cr]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R]R&R]R&R]R&RtR#) EnumSchemai zRequired[Literal['enum']]rd Required[Any]rrmemberszLiteral['str', 'int', 'float']sub_typezCallable[[Any], Any]missingrrrrr_rrrr%Nrer%r-r.rr s6 ##   ,, !! L Hr-rr r c<V^8dQhRRRRRRRRR R R R R RRRRR/ #)r6rr r rr z%Literal['str', 'int', 'float'] | Noner zCallable[[Any], Any] | Nonerrxrrarrrrr7rr%r8r:r.r;r;sb00 0 04 0 ) 0  0 0$0$00r-c *\RVVVVVVVVR7 #)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) rdrr r r rrrrr{)rr r r rrrr&&$$$$$$r. enum_schemars-L    #  r-cr) MissingSentinelSchemaiLz%Required[Literal['missing-sentinel']]rdr_rrrr%Nrer%r-r.rrLs //r-rcr)r6rrrrr7rr%r8r:r.r;r;Rs&  # #  r-cs\RVVR7#)z,Returns a schema for the `MISSING` sentinel.missing-sentinel)rdrrr{)rrrr.missing_sentinel_schemarRs  # r-crl)IsInstanceSchemaicz Required[Literal['is-instance']]rdr rrcls_reprrr_rrrr%Nrer%r-r.rrcs$ ** M Hr-rrc rv) r6rr rrarrrrrr7rr%r8r:r.r;r;lsF    $  $ r-c  \RWW#VR7#)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-instancerdrrrrrr{rrrrrr}r.is_instance_schemarls:  Cbo r-crl)IsSubclassSchemaiz Required[Literal['is-subclass']]rdrrrrrr_rrrr%Nrer%r-r.rrs$ ** M Hr-rc rv) r6rrrrarrrrrr7rr%r8r:r.r;r;sF"" ""  " $ " $ ""r-c r)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-subclassrr{rr}r.is_subclass_schemars@  Cbo r-cr) CallableSchemaizRequired[Literal['callable']]rdrrr_rrrr%Nrer%r-r.rrs '' Hr-rcr) r6rrarrrrr7rr%r8r:r.r;r;s2dd d)>dVfddr-cr)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 callablerr{rrr.callable_schemar!s& zsUb ccr-cT]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &RtR#) UuidSchemaizRequired[Literal['uuid']]rdzLiteral[1, 3, 4, 5, 7]versionrrrrr_rrrr%Nrer%r-r.r#r#s$ ## ## L Hr-r#r$c 0V^8dQhRRRRRRRRR R R R /#) r6r$z#Literal[1, 3, 4, 5, 6, 7, 8] | Nonerrxrrarrrrr7r#r%r8r:r.r;r;sF   0      $  $  r-c s \RWW#VR7#)uuid)rdr$rrrrr{)r$rrrrs$$$$$r. uuid_schemar's  W_l r-c6]tRtRt$R]R&R]R&R]R&RtR#) IncExSeqSerSchemaiz-Required[Literal['include-exclude-sequence']]rdzset[int]rBrDr%Nrer%r-r.r)r)s 77  r-r)rBrDc$V^8dQhRRRRRR/#)r6rBzset[int] | NonerDr7r)r%r8r:r.r;r;s']]/]?]^o]r-c\RWR7#)zinclude-exclude-sequencerdrBrDr{rBrD$$r.filter_seq_schemar/s 97 \\r-cr]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R ]R &R]R&R]R&RtR#) ListSchemaizRequired[Literal['list']]rdrr items_schemarrrr fail_fastrrrr_rIncExSeqOrElseSerSchemarr%Nrer%r-r.r1r1s3 ##OOO L H**r-r1r3c<V^8dQhRRRRRRRRRRR R R R R RRR/ #)r6r2ryrrrr3rxrrrarrrIncExSeqOrElseSerSchema | Noner7r1r%r8r:r.r;r;sd**#** *  *  * *$*2**r-c r)aV Returns a schema that matches a list value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.list_schema(core_schema.int_schema(), min_length=0, max_length=10) v = SchemaValidator(schema) assert v.validate_python(['4']) == [4] ``` Args: items_schema: The value must be a list of items that match this schema min_length: The value must be a list with at least this many items max_length: The value must be a list with at most this many items fail_fast: Stop validation on the first error strict: The value must be a list with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema list rdr2rrr3rrrrr{r2rrr3rrrr&$$$$$$$r. list_schemar;s-@  ! #  r- extras_schemac4V^8dQhRRRRRRRRR R R R R R/#)r6r2list[CoreSchema]r<ryrrxrrarrrr6r7 TupleSchemar%r8r:r.r;r;6sP--"-%-  -  - $ -2--r-c sZVe\V4pW.,pMRp\VVVVVVR7#)aE Returns a schema that matches a tuple of schemas, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.tuple_positional_schema( [core_schema.int_schema(), core_schema.str_schema()] ) v = SchemaValidator(schema) assert v.validate_python((1, 'hello')) == (1, 'hello') ``` Args: items_schema: The value must be a tuple with items that match these schemas extras_schema: The value must be a tuple with items that match this schema This was inspired by JSON schema's `prefixItems` and `items` fields. In python's `typing.Tuple`, you can't specify a type for "extra" items -- they must all be the same type if the length is variable. So this field won't be set from a `typing.Tuple` annotation on a pydantic model. strict: The value must be a tuple with exactly this many items ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema N)r2variadic_item_indexrrrr)Zlen tuple_schema)r2r<rrrrr@s&$$$$$ r.tuple_positional_schemarB6sEB !,/#o5 " !/ #  r-c8V^8dQhRRRRRRRRRR R R R R RR/#)r6r2ryrrrrrxrrarrrr6r7r?r%r8r:r.r;r;gsZ))#)) )  )  )$)2))r-c sN\T;'g \4.^VVVVVVR7#)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 )r2r@rrrrrr)rAr)r2rrrrrr&$$$$$$r.tuple_variable_schemarEgs7@ "22jl3 #  r-cs|]tRtRt$R]R&R]R&R]R&R]R&R]R &R ]R &R ]R &R ]R&R]R&R]R&RtR#)r?izRequired[Literal['tuple']]rdRequired[list[CoreSchema]]r2rr@rrrr3rrrr_rr4rr%Nrer%r-r.r?r?s9 $$,,OOO L H**r-r?r@cs@V^8dQhRRRRRRRRRRR RR R R R RRRR/ #)r6r2r>r@rrrr3rxrrrarrrr6r7r?r%r8r:r.r;r;sn00"0$0 0  0  0 0 0$0200r-c r)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 tuple) rdr2r@rrr3rrrrr{) r2r@rrr3rrrr &$$$$$$$$r.rArAs0J  !/ #  r-cr0) SetSchemaizRequired[Literal['set']]rdrrr2rrrrr3rrrr_rrrr%Nrer%r-r.rIrIs3 ""OOO L Hr-rIcr5)r6r2ryrrrr3rxrrrarrrrr7rIr%r8r:r.r;r;sd,,#,, ,  ,  , ,$,$,,r-c r)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 setr8r{r9r:r. set_schemarKs-D  ! #  r-cr0)FrozenSetSchemaizRequired[Literal['frozenset']]rdrrr2rrrrr3rrrr_rrrr%Nrer%r-r.rLrLs3 ((OOO L Hr-rLcr5)r6r2ryrrrr3rxrrrarrrrr7rLr%r8r:r.r;r;sd,,#,, ,  ,  , ,$,$,,r-c r)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 frozensetr8r{r9r:r.frozenset_schemarNs-D  ! #  r-cs^]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R ]R&RtR#)GeneratorSchemaiIzRequired[Literal['generator']]rdrrr2rrrrrr_rr4rr%Nrer%r-r.rOrOIs) ((OO H**r-rOc4V^8dQhRRRRRRRRRR R R R R /#)r6r2ryrrrrrarrrr6r7rOr%r8r:r.r;r;SsP,,#,, ,  , $ ,2,,r-c r)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 generator)rdr2rrrrrr{)r2rrrrrrr.generator_schemarRSs'H  ! # r-cr() IncExDictSerSchemaiz)Required[Literal['include-exclude-dict']]rd IncExDictrBrDr%Nrer%r-r.rSrSs 33  r-rScr*)r6rBzIncExDict | NonerDr7rSr%r8r:r.r;r;s)YY#3YEUYasYr-cr+)zinclude-exclude-dictr,r{r-r.r.filter_dict_schemarUs 5w XXr-cs|]tRtRt$R]R&R]R&R]R&R]R&R]R &R ]R &R ]R &R ]R&R]R&R]R&RtR#) DictSchemaizRequired[Literal['dict']]rdrr keys_schema values_schemarrrrr3rrrr_rIncExDictOrElseSerSchemarr%Nrer%r-r.rVrVs9 ##OOO L H++r-rVcs@V^8dQhRRRRRRRRRRR RR R R R RRRR/ #)r6rWryrXrrrr3rxrrrarrrrr7rVr%r8r:r.r;r;sl//"/$/ /  /  / / /$/$//r-c r)a Returns a schema that matches a dict value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.dict_schema( keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema() ) v = SchemaValidator(schema) assert v.validate_python({'a': '1', 'b': 2}) == {'a': 1, 'b': 2} ``` Args: keys_schema: The value must be a dict with keys that match this schema values_schema: The value must be a dict with values that match this schema min_length: The value must be a dict with at least this many items max_length: The value must be a dict with at most this many items fail_fast: Stop validation on the first error strict: Whether the keys and values should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rdrWrXrrr3rrrrr{) rWrXrrr3rrrrs &&$$$$$$$r. dict_schemarZs0H  # #  r-cr)NoInfoValidatorFunctionSchemaiLiteral['no-info']rdNoInfoValidatorFunctionror%Nrer%r-r.r[r[s %%r-r[cr) WithInfoValidatorFunctionSchemaiRequired[Literal['with-info']]rdz#Required[WithInfoValidatorFunction]rorrZr%Nrer%r-r.r^r^s ((11Or-r^cr)_ValidatorFunctionSchemaiRequired[ValidationFunction]rorrrrr_rrrr%Nrer%r-r.r`r`s**  Hr-r`cr)BeforeValidatorFunctionSchemaiz$Required[Literal['function-before']]rdrrjson_schema_input_schemar%Nrer%r-r.rbrbs ..((r-rbrccr=)r6ror]rrrrrarcryrrrrr7rbr%r8r:r.r;r;sN++%+ +  + 0 + $ +$+#+r-c .\RRRRV/VVVVVR7#)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-beforerdno-inforordrorrrcrrr{rorrrcrr&&$$$$r.!no_info_before_validator_functionrjs0F  )Z: !9# r-rZcs8V^8dQhRRRRRRRRRR R R R R RR/#)r6roWithInfoValidatorFunctionrrrrZrarrcryrrrrr7rbr%r8r:r.r;r;"sX77'7 7 7  7 0 7$7$7#7r-c ~Ve\P!R\^R7\R\RWR7VVVVVR7#)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.Z stacklevelre with-infordrorZrgwarningswarnDeprecationWarningr|)rorrZrrcrr&&$$$$$r.#with_info_before_validator_functionru"sNP  e   [8[ !9# r-crb)AfterValidatorFunctionSchemai\z#Required[Literal['function-after']]rdr%Nrer%r-r.rvrv\s --r-rvcr=)r6ror]rrrrrarcryrrrrr7rvr%r8r:r.r;r;`sN))%) )  ) 0 ) $ )$)")r-c rd)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-afterrdrfrorgr{rhrir. no_info_after_validator_functionrx`s0B  )Z: !9# r-cs4V^8dQhRRRRRRRRRR R R R R /#)r6rorkrrrrZrarrrrrr7rvr%r8r:r.r;r;sN44'4 4 4  4 $ 4$4"4r-c s|Ve\P!R\^R7\R\RWR7VVVVR7#)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.rmrwrnro)rdrorrrrrp)rorrZrrrrir."with_info_after_validator_functionrysKL  d   [8[ #  r-cr)ValidatorFunctionWrapHandleriNcr)r6rr outer_locationzstr | int | Noner7r%r8r:r.r;Z)ValidatorFunctionWrapHandler.__annotate__s#  C 9I X[ r-c rRrSr%)r@rr{rr.rZ%ValidatorFunctionWrapHandler.__call__s r-r%rSrr%r-r.rzrzs   r-rzcr)!NoInfoWrapValidatorFunctionSchemair\rdNoInfoWrapValidatorFunctionror%Nrer%r-r.r|r|s ))r-r|cr) #WithInfoWrapValidatorFunctionSchemair_rdz'Required[WithInfoWrapValidatorFunction]rorrZr%Nrer%r-r.r~r~s ((55Or-r~cs^]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R]R&RtR#)WrapValidatorFunctionSchemairrdzRequired[WrapValidatorFunction]rorrrrrrrcr_rrrr%Nrer%r-r.rrs+ ,,--  H((r-rcr=)r6ror}rrrrrarcryrrrrr7rr%r8r:r.r;r;sN..). .  . 0 . $ .$.!.r-c s.\RRRRV/VVVVVR7#)az Returns a schema which calls a function with a `validator` callable argument which can optionally be used to call inner validation with the function logic, this is much like the "onion" implementation of middleware in many popular web frameworks, no `info` argument is passed, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn( v: str, validator: core_schema.ValidatorFunctionWrapHandler, ) -> str: return validator(input_value=v) + 'world' schema = core_schema.no_info_wrap_validator_function( function=fn, schema=core_schema.str_schema() ) v = SchemaValidator(schema) assert v.validate_python('hello ') == 'hello world' ``` Args: function: The validator function to call schema: The schema to validate the output of the validator function ref: optional unique identifier of the schema, used to reference the schema in other places json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema rrdrfrordrorrcrrrr{rhrir.no_info_wrap_validator_functionrs0L  )Z:!9 # r-c8V^8dQhRRRRRRRRR RR R R R RR/#)r6roWithInfoWrapValidatorFunctionrrrrZrarcryrrrrrr7rr%r8r:r.r;r; sX88+8 8 8 0 8  8$8$8!8r-c rl)a Returns a schema which calls a function with a `validator` callable argument which can optionally be used to call inner validation with the function logic, this is much like the "onion" implementation of middleware in many popular web frameworks, an `info` argument is also passed, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn( v: str, validator: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo, ) -> str: return validator(input_value=v) + 'world' schema = core_schema.with_info_wrap_validator_function( function=fn, schema=core_schema.str_schema() ) v = SchemaValidator(schema) assert v.validate_python('hello ') == 'hello world' ``` Args: function: The validator function to call schema: The schema to validate the output of the validator function field_name: The name of the field this validator is applied to, if any (deprecated) json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema zThe `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.rmrrnrorrp)rorrZrcrrrrtr.!with_info_wrap_validator_functionr sNR  c   [8[!9 # r-cr")PlainValidatorFunctionSchemaiT rnrdrarorrrrrcr_rrrr%Nrer%r-r.rrT s% --** H((r-rc r%) r6ror]rrarcryrrrrr7rr%r8r:r.r;r;] sF%%%% %0 % $ % $ %"%r-c s,\RRRRV/VVVVR7#)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 rzrdrfrordrorrcrrr{)rorrcrrr}r. no_info_plain_validator_functionr] s,<  )Z: !9#  r-crP)r6rorkrZrarrcryrrrrr7rr%r8r:r.r;r; sP..'..  . 0 . $ .$.".r-c s|Ve\P!R\^R7\R\RWR7VVVVR7#)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.rmrzrnrorrp)rorZrrcrrrr."with_info_plain_validator_functionr sK@  d   [8[ !9#  r-cs]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R ]R&R ]R&R]R&R]R&R]R&RtR#)WithDefaultSchemai zRequired[Literal['default']]rdrrr r2z9Union[Callable[[], Any], Callable[[dict[str, Any]], Any]]default_factoryrdefault_factory_takes_dataz#Literal['raise', 'omit', 'default']on_errorrrrrr_rrrr%Nrer%r-r.rr sA &&  LNN $$11 L Hr-rr2rrrrcsDV^8dQhRRRRRRRRR R R RR RR RRRRRRR/ #)r6rrrr2r rz?Union[Callable[[], Any], Callable[[dict[str, Any]], Any], None]rrxrz*Literal['raise', 'omit', 'default'] | Nonerrrrarrrrr7rr%r8r:r.r;r; sy5 5 5 5 U 5 !, 5 9 5 "5  5  5 $5 $5 5 r-c sL\RVVVVVVVVV R7 p V\JdWR&V #)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 r2) rdrrrrrrrrr)r|r) rr2rrrrrrrrrs &$$$$$$$$$ r.with_default_schemar sDN  '#=) # A'') Hr-cr")NullableSchemai zRequired[Literal['nullable']]rdrrrrrrr_rrrr%Nrer%r-r.rr s$ ''  L Hr-rc r%) r6rrrrrxrrarrrrr7rr%r8r:r.r;r; sF     $  $ r-c r)ac Returns a schema that matches a nullable value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.nullable_schema(core_schema.str_schema()) v = SchemaValidator(schema) assert v.validate_python(None) is None ``` Args: schema: The schema to wrap strict: Whether the underlying schema should be validated with strict mode ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema nullable)rdrrrrrr{)rrrrrr}r.nullable_schemar s4  3an r-cs]tRtRt$R]R&R]R&R]R&R]R &R]R &R ]R &R ]R&R]R&R]R&R]R&R]R&RtR#) UnionSchemai$ zRequired[Literal['union']]rdz9Required[list[Union[CoreSchema, tuple[CoreSchema, str]]]]choicesr auto_collapsercustom_error_typecustom_error_message!dict[str, Union[str, int, float]]custom_error_contextz!Literal['smart', 'left_to_right']rHrrr_rrrr%Nrer%r-r.rr$ sB $$ FF;; ++ L Hr-rrrrrrHcs@V^8dQhRRRRRRRRRR R R R RR RRRRR/ #)r6rz)list[CoreSchema | tuple[CoreSchema, str]]rrxrrarrzdict[str, str | int] | NonerHz(Literal['smart', 'left_to_right'] | Nonerrrrrr7rr%r8r:r.r;r;3 sn00 600" 0 % 0 6 0 30 0$0$00r-c r)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) rdrrrrrrHrrrr{) rrrrrrHrrrrHr. union_schemar3 s0J  #+11  #  r-cs]tRtRt$R]R&R]R&R]R&R]R &R]R &R ]R &R ]R&R ]R&R]R&R]R&R]R&RtR#)TaggedUnionSchemaif z!Required[Literal['tagged-union']]rdz$Required[dict[Hashable, CoreSchema]]rzcRequired[Union[str, list[Union[str, int]], list[list[Union[str, int]]], Callable[[Any], Hashable]]] discriminatorrrrrrrrrrr_rrrr%Nrer%r-r.rrf sB ++ 11vv;; L Hr-rrcsDV^8dQhRRRRRRRRRR R R R R R RRRRRRR/ #)r6rzdict[Any, CoreSchema]rzDstr | list[str | int] | list[list[str | int]] | Callable[[Any], Any]rrarrz#dict[str, int | str | float] | Nonerrxrrrrrrr7rr%r8r:r.r;r;t sPP "PWP" P % P > P P!P P$P$PPr-cr)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) rdrrrrrrrrrrr{) rrrrrrrrrrs &&$$$$$$$$r.tagged_union_schemart s3H  #+11' #  r-cr) ChainSchemai zRequired[Literal['chain']]rdrFstepsrrr_rrrr%Nrer%r-r.rr s $$ %% Hr-rc r) r6rr>rrarrrrr7rr%r8r:r.r;r; sCnn n n$ n $ n  nr-cr)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)rdrrrrr{)rrrrrr. chain_schemar s> wex mmr-cr)LaxOrStrictSchemai z"Required[Literal['lax-or-strict']]rdr lax_schema strict_schemarrrrr_rrrr%Nrer%r-r.rr s* ,,$$'' L Hr-rcr)r6rrrrrrxrrarrrrr7rr%r8r:r.r;r; sN3333  3  3 $ 3$33r-c r)a8 Returns a schema that uses the lax or strict schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema def fn(v: str, info: core_schema.ValidationInfo) -> str: assert 'hello' in v return v + ' world' lax_schema = core_schema.int_schema(strict=False) strict_schema = core_schema.int_schema(strict=True) schema = core_schema.lax_or_strict_schema( lax_schema=lax_schema, strict_schema=strict_schema, strict=True ) v = SchemaValidator(schema) assert v.validate_python(123) == 123 schema = core_schema.lax_or_strict_schema( lax_schema=lax_schema, strict_schema=strict_schema, strict=False ) v = SchemaValidator(schema) assert v.validate_python('123') == 123 ``` Args: lax_schema: The lax schema to use strict_schema: The strict schema to use strict: Whether the strict schema should be used ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema lax-or-strict)rdrrrrrrr{)rrrrrrrir.lax_or_strict_schemar s'V  # # r-csT]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R tR#)JsonOrPythonSchemai1 z#Required[Literal['json-or-python']]rdr json_schema python_schemarrr_rrrr%Nrer%r-r.rr1 s% --%%'' Hr-rc s0V^8dQhRRRRRRRRRR R R /#) r6rrrrrrarrrrr7rr%r8r:r.r;r;: sD----  - $ - $ --r-c s$\RVVVVVR7#)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)rdrrrrrr{)rrrrrs&&$$$r.json_or_python_schemar: s$L  # #  r-csh]tRtRt$R]R&R]R&R]R&R]R &R ]R &R]R &R ]R&R]R&RtR#)TypedDictFieldij z%Required[Literal['typed-dict-field']]rdrrrrequired>Union[str, list[Union[str, int]], list[list[Union[str, int]]]]validation_aliasrserialization_aliasserialization_excluder_rCallable[[Any], bool]serialization_exclude_ifr%Nrer%r-r.rrj s1 //  NTT33r-rrrrrrcs8V^8dQhRRRRRRRRR RR R R R RR/#)r6rrrrrxr4str | list[str | int] | list[list[str | int]] | NonerrarrrrCallable[[Any], bool] | Noner7rr%r8r:r.r;r;u s[%% %%K % $ % ' %$%;%%r-c s(\RVVVVVVVR7#)a Returns a schema that matches a typed dict field, e.g.: ```py from pydantic_core import core_schema field = core_schema.typed_dict_field(schema=core_schema.int_schema(), required=True) ``` Args: schema: The schema to use for the field required: Whether the field is required, otherwise uses the value from `total` on the typed dict validation_alias: The alias(es) to use to find the field in the validation data serialization_alias: The alias to use as a key when serializing serialization_exclude: Whether to exclude the field when serializing serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value. metadata: Any other information you want to include with the schema, not used by pydantic-core typed-dict-field)rdrrrrrrrr{)rrrrrrrrDr.typed_dict_fieldru s)8  )/3!9  r-cs]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R]R&R]R&R ]R&R]R&R]R&R]R&R]R&RtR#)TypedDictSchemai zRequired[Literal['typed-dict']]rdz#Required[dict[str, TypedDictField]]fieldsrrrcls_namelist[ComputedField]computed_fieldsrrrrr<rextra_behaviorr/rr_rrrrr^r%Nrer%r-r.rr sK )) // NM(( L!! K H r-rrrrrr/r^csLV^8dQhRRRRRRRRR R R R R RRR RRRRRRRRRR/ #)r6rzdict[str, TypedDictField]rtype[Any] | Nonerrarlist[ComputedField] | Nonerrxr<ryrExtraBehavior | Noner/rrrrrr^r]r7rr%r8r:r.r;r; s== %= = = 0 =  =%=)= = =$=$= ==r-c r)a Returns a schema that matches a typed dict, e.g.: ```py from typing_extensions import TypedDict from pydantic_core import SchemaValidator, core_schema class MyTypedDict(TypedDict): a: str wrapper_schema = core_schema.typed_dict_schema( {'a': core_schema.typed_dict_field(core_schema.str_schema())}, cls=MyTypedDict ) v = SchemaValidator(wrapper_schema) assert v.validate_python({'a': 'hello'}) == {'a': 'hello'} ``` Args: fields: The fields to use for the typed dict cls: The class to use for the typed dict cls_name: The name to use in error locations. Falls back to `cls.__name__`, or the validator name if no class is provided. computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model strict: Whether the typed dict is strict extras_schema: The extra validator to use for the typed dict ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core extra_behavior: The extra behavior to use for the typed dict total: Whether the typed dict is total, otherwise uses `typed_dict_total` from config serialization: Custom serialization schema typed-dict) rdrrrrrr<rr/rrrr^r{) rrrrrr<rr/rrrr^s &$$$$$$$$$$$r.typed_dict_schemar s9^   '#% # r-csh]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R ]R&R]R&RtR#) ModelFieldi z Required[Literal['model-field']]rdrrrrrrrrrrfrozenr_rr%Nrer%r-r.rr s1 **  TT33 Lr-rrcs8V^8dQhRRRRRRRRR R R RR R RR/#)r6rrrrrrrarrxrrrrrr7rr%r8r:r.r;r; s[%% %K%$ % ' % ; % %$%%r-c (\RVVVVVVVR7#)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)rdrrrrrrrr{)rrrrrrrrDr. model_fieldr s)8  )/3!9  r-cs]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R ]R&R]R&R ]R&R]R&R]R&R]R&RtR#)ModelFieldsSchemai! z!Required[Literal['model-fields']]rdzRequired[dict[str, ModelField]]rr model_namerrrrrrr<extras_keys_schemarrrrr_rrrr%Nrer%r-r.rr! sG ++ ++O(( L""!! Hr-rrrcsHV^8dQhRRRRRRRRR R R R R R RRRRRRRRRR/ #)r6rzdict[str, ModelField]rrarrrrxr<ryrrrrrrrrrr7rr%r8r:r.r;r;0 s66 !660 6  6 % 6*6)6!6 6$6$66r-c 0\RVVVVVVVVVV V R7 #)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) rdrrrrr<rrrrrrr{) rrrrr<rrrrrrs &$$$$$$$$$$r.model_fields_schemar0 s6R  '#-%' #  r-cs]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R ]R&R]R&R ]R&R ]R&R]R&R]R&R ]R&R]R&R]R&RtR#) ModelSchemaii rrdrrrgeneric_originrrr custom_init root_modelr post_initrrrrrrrr^rr_rrrr%Nrer%r-r.rri sX $$   NJJ L L!!  Hr-rrrrrrcsTV^8dQhRRRRRRRRR RR R R R RRRRRRRRRR RRRRRR/#)r6rrrrrrrrrxrrrar7Literal['always', 'never', 'subclass-instances'] | Nonerrrrr^r]rrrrrr7rr%r8r:r.r;r;{ sRR R R% R  R  RRRR R R)R R R$R$R !Rr-c s6\RVVVVVVVVVV V V V V R7#)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)rdrrrrrrrrrrr^rrrr{)rrrrrrrrrrr^rrrs&&$$$$$$$$$$$$r. model_schemar{ s?D   %1% # r-cs]tRtRt$R]R&R]R&R]R&R]R &R]R &R]R &R]R &R ]R&R]R&R]R&R]R&R]R&RtR#)DataclassFieldi z$Required[Literal['dataclass-field']]rdrnamerrrkw_onlyinit init_onlyrrrrrrr_rrrr%Nrer%r-r.rr sF ..   M JO LTT33r-rrrrcsHV^8dQhRRRRRRRRRRR R R R R RRRRRRRRR/ #)r6rrrrrrrxrrrrrrarrrrrrr7rr%r8r:r.r;r; s66 6 6 6  6  6K6$6'6$6;6 66r-c s0\RVVVVVVVVV VV R7 #)a Returns a schema for a dataclass field, e.g.: ```py from pydantic_core import SchemaValidator, core_schema field = core_schema.dataclass_field( name='a', schema=core_schema.str_schema(), kw_only=False ) schema = core_schema.dataclass_args_schema('Foobar', [field]) v = SchemaValidator(schema) assert v.validate_python({'a': 'hello'}) == ({'a': 'hello'}, None) ``` Args: name: The name to use for the argument parameter schema: The schema to use for the argument parameter kw_only: Whether the field can be set with a positional argument as well as a keyword argument init: Whether the field should be validated during initialization init_only: Whether the field should be omitted from `__dict__` and passed to `__post_init__` validation_alias: The alias(es) to use to find the field in the validation data serialization_alias: The alias to use as a key when serializing serialization_exclude: Whether to exclude the field when serializing serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value. metadata: Any other information you want to include with the schema, not used by pydantic-core frozen: Whether the field is frozen dataclass-field) rdrrrrrrrrrrrr{) rrrrrrrrrrrs &&$$$$$$$$$r.dataclass_fieldr s6R    )/3!9  r-cr)DataclassArgsSchemai z#Required[Literal['dataclass-args']]rdrdataclass_namezRequired[list[DataclassField]]rrrrcollect_init_onlyrrr_rrrrrr%Nrer%r-r.rr s7 --!! **(( H!!r-rrcr )r6rrrzlist[DataclassField]rrrrxrrarrrrrrr7rr%r8r:r.r;r;$ sb000 00 0 # 0  0$0$0)00r-c r)aM Returns a schema for validating dataclass arguments, e.g.: ```py from pydantic_core import SchemaValidator, core_schema field_a = core_schema.dataclass_field( name='a', schema=core_schema.str_schema(), kw_only=False ) field_b = core_schema.dataclass_field( name='b', schema=core_schema.bool_schema(), kw_only=False ) schema = core_schema.dataclass_args_schema('Foobar', [field_a, field_b]) v = SchemaValidator(schema) assert v.validate_python({'a': 'hello', 'b': True}) == ({'a': 'hello', 'b': True}, None) ``` Args: dataclass_name: The name of the dataclass being validated fields: The fields to use for the dataclass computed_fields: Computed fields to use when serializing the dataclass collect_init_only: Whether to collect init only fields into a dict to pass to `__post_init__` ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema extra_behavior: How to handle extra fields dataclass-args) rdrrrrrrrrr{)rrrrrrrrrr.dataclass_args_schemar$ s-L  %'+ #%  r-cs]tRtRt$R]R&R]R&R]R&R]R &R ]R &R ]R &R]R&R]R&R]R&R]R&R ]R&R]R&R]R&R]R&R]R&RtR#)DataclassSchemaiW zRequired[Literal['dataclass']]rdrrrrrrzRequired[list[str]]rrrrrrrrrrr_rrrslotsrr^r%Nrer%r-r.rrW sV ((   MOJJ L L H K r-rrcsTV^8dQhRRRRRRRRR R R R R RRR RR RRRRRR RR RRRR/#)r6rrrrrr list[str]rrrrarrxrrrrrrrrrrr^r]r7rr%r8r:r.r;r;i s88 8 8 8 % 8  88R8 8 8$8$8 8 8 8 !8r-c s6\RVVVVVVVVVV V V V V R7#)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)rdrrrrrrrrrrrrrr^r{)rrrrrrrrrrrrrr^s&&&$$$$$$$$$$$r.dataclass_schemari s?P   %1 # r-cr) ArgumentsParameteri rrrrzCLiteral['positional_only', 'positional_or_keyword', 'keyword_only']rHrrr%Nrer%r-r.rr s   MM IIr-rc r) r6rrrrrrHzJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Nonerrr7rr%r8r:r.r;r; sCLL L L U L @ L  Lr-c\WW#R7#)aU Returns a schema that matches an argument parameter, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param = core_schema.arguments_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) schema = core_schema.arguments_schema([param]) v = SchemaValidator(schema) assert v.validate_python(('hello',)) == (('hello',), {}) ``` Args: name: The name to use for the argument parameter schema: The schema to use for the argument parameter mode: The mode to use for the argument parameter alias: The alias to use for the argument parameter rrrHrr{rrr.arguments_parameterr s6 t KKr- VarKwargsModecs|]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R ]R &R]R&R]R&R]R&RtR#)ArgumentsSchemai zRequired[Literal['arguments']]rdz"Required[list[ArgumentsParameter]]arguments_schemarr$r#rrvar_args_schemarvar_kwargs_modevar_kwargs_schemarrr_rrrr%Nrer%r-r.rr s= ((88""!! Hr-rr$r#rrrcs@V^8dQhRRRRRRRRRR R RR R R RRRRR/ #)r6 argumentszlist[ArgumentsParameter]r$rxr#rryrzVarKwargsMode | Nonerrrarrrrr7rr%r8r:r.r;r; sn55'5"5# 5 ' 5 * 5)5 5$5$55r-c r)a Returns a schema that matches an arguments schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param_a = core_schema.arguments_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) param_b = core_schema.arguments_parameter( name='b', schema=core_schema.bool_schema(), mode='positional_only' ) schema = core_schema.arguments_schema([param_a, param_b]) v = SchemaValidator(schema) assert v.validate_python(('hello', True)) == (('hello', True), {}) ``` Args: arguments: The arguments to use for the arguments schema validate_by_name: Whether to populate by the parameter names, defaults to `False`. validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`. var_args_schema: The variable args schema to use for the arguments schema var_kwargs_mode: The validation mode to use for variadic keyword arguments. If `'uniform'`, every value of the keyword arguments will be validated against the `var_kwargs_schema` schema. If `'unpacked-typed-dict'`, the `var_kwargs_schema` argument must be a [`typed_dict_schema`][pydantic_core.core_schema.typed_dict_schema] var_kwargs_schema: The variable kwargs schema to use for the arguments schema ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema r) rdrr$r#rrrrrrr{) rr$r#rrrrrrrHr.rr s0T  ")+''+ #  r-cr) ArgumentsV3ParameterirrrrzLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict']rHrrr%Nrer%r-r.rrs!     JIr-rc r) r6rrrrrrHzLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict'] | Nonerrr7rr%r8r:r.r;r;sB#L#L #L #L #L @#L#Lr-cr)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 rr{rrr.arguments_v3_parameterrsF t KKr-csh]tRtRt$R]R&R]R&R]R&R]R&R ]R &R ]R &R ]R&R]R&RtR#)ArgumentsV3SchemaiEz!Required[Literal['arguments-v3']]rdz$Required[list[ArgumentsV3Parameter]]rrr$r#zLiteral['forbid', 'ignore']rrrr_rrrr%Nrer%r-r.rrEs1 ++::// Hr-rcrC)r6rzlist[ArgumentsV3Parameter]r$rxr#rz"Literal['forbid', 'ignore'] | Nonerrarrrrr7rr%r8r:r.r;r;PsZ00)0"0# 0 7 0  0$0$00r-c r)a Returns a schema that matches an arguments schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema param_a = core_schema.arguments_v3_parameter( name='a', schema=core_schema.str_schema(), mode='positional_only' ) param_b = core_schema.arguments_v3_parameter( name='kwargs', schema=core_schema.bool_schema(), mode='var_kwargs_uniform' ) schema = core_schema.arguments_v3_schema([param_a, param_b]) v = SchemaValidator(schema) assert v.validate_python({'a': 'hi', 'kwargs': {'b': True}}) == (('hi',), {'b': True}) ``` This schema is currently not used by other Pydantic components. In V3, it will most likely become the default arguments schema for the `'call'` schema. Args: arguments: The arguments to use for the arguments schema. validate_by_name: Whether to populate by the parameter names, defaults to `False`. validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`. extra_behavior: The extra behavior to use. ref: optional unique identifier of the schema, used to reference the schema in other places. metadata: Any other information you want to include with the schema, not used by pydantic-core. serialization: Custom serialization schema. arguments-v3)rdrr$r#rrrrr{)rr$r#rrrrrDr.arguments_v3_schemarPs*N  ")+% #  r-ch]tRtRt$R]R&R]R&R]R&R]R &R ]R &R]R &R ]R&R]R&RtR#) CallSchemaizRequired[Literal['call']]rdrrzRequired[Callable[..., Any]]ror function_namerrrsrr_rrrr%Nrer%r-r.rrs1 ##**** Hr-rrcr)r6rrrrozCallable[..., Any]rrarsryrrrrrr7rr%r8r:r.r;r;sX333 3 3 % 3  3$3$33r-c r)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)rdrrorrsrrrr{)rrorrsrrrrtr. call_schemars*T  "## #  r-cr)CustomErrorSchemaiz!Required[Literal['custom-error']]rdrrrrrrrrrr_rrrr%Nrer%r-r.rrs1 ++  $$;; Hr-rcs8V^8dQhRRRRRRRRR RR RR R R R/#)r6rrrrrrrarrrrrrr7rr%r8r:r.r;r;sX++ ++% + 0 +  +$+$++r-c r)av Returns a schema that matches a custom error value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.custom_error_schema( schema=core_schema.int_schema(), custom_error_type='MyError', custom_error_message='Error msg', ) v = SchemaValidator(schema) v.validate_python(1) ``` Args: schema: The schema to use for the custom error schema custom_error_type: The custom error type to use for the custom error schema custom_error_message: The custom error message to use for the custom error schema custom_error_context: The custom error context to use for the custom error schema ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema custom-error)rdrrrrrrrr{)rrrrrrrrtr.custom_error_schemars*D  +11 #  r-cr) JsonSchemaizRequired[Literal['json']]rdrrrrrr_rrrr%Nrer%r-r.rrs ##  Hr-rc r) r6rryrrarrrrr7rr%r8r:r.r;r;sC+o+o +o +o$ +o $ +o  +or-cr)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 json)rdrrrrr{)rrrrrr.rrsV vf nnr-c]tRtRt$R]R&R]R&R]R&R]R &R ]R &R]R &R ]R &R]R&R ]R&R]R&R]R&RtR#) UrlSchemai3zRequired[Literal['url']]rdrrrallowed_schemesr host_requiredr default_host default_port default_pathrrr_rrrr%Nrer%r-r.rr3sA ""O L Hr-rrrrrrpreserve_empty_pathcHV^8dQhRRRRRRRRR RR RR RR RR RRRRRRR/ #)r6rrrlist[str] | Nonerrxrrarrrrrrrrrr7rr%r8r:r.r;r;As444&4 4  4  44%4 4 4$4$44r-c r)a Returns a schema that matches a URL value, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.url_schema() v = SchemaValidator(schema) print(v.validate_python('https://example.com')) #> https://example.com/ ``` Args: max_length: The maximum length of the URL allowed_schemes: The allowed URL schemes host_required: Whether the URL must have a host default_host: The default host to use if the URL does not have a host default_port: The default port to use if the URL does not have a port default_path: The default path to use if the URL does not have a path preserve_empty_path: Whether to preserve an empty path or convert it to '/', default False strict: Whether to use strict URL parsing ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema url rdrrrrrrrrrrrr{ rrrrrrrrrrr $$$$$$$$$$$r. url_schemarAs6N  '#!!!/ #  r-cr)MultiHostUrlSchemaixz#Required[Literal['multi-host-url']]rdrrrrrrrrrrrrr_rrrr%Nrer%r-r.rrxsA --O L Hr-rcr)r6rrrr rrxrrarrrrrrrrrr7rr%r8r:r.r;r;s444&4 4  4  44%4 4 4$4$44r-c r)a5 Returns a schema that matches a URL value with possibly multiple hosts, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.multi_host_url_schema() v = SchemaValidator(schema) print(v.validate_python('redis://localhost,0.0.0.0,127.0.0.1')) #> redis://localhost,0.0.0.0,127.0.0.1 ``` Args: max_length: The maximum length of the URL allowed_schemes: The allowed URL schemes host_required: Whether the URL must have a host default_host: The default host to use if the URL does not have a host default_port: The default port to use if the URL does not have a port default_path: The default path to use if the URL does not have a path preserve_empty_path: Whether to preserve an empty path or convert it to '/', default False strict: Whether to use strict URL parsing ref: optional unique identifier of the schema, used to reference the schema in other places metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema multi-host-urlr r{r r r.multi_host_url_schemars6N  '#!!!/ #  r-cr)DefinitionsSchemaiz Required[Literal['definitions']]rdrrrF definitionsr_rrrr%Nrer%r-r.rrs **  ++r-rcr)r6rrrrr>r7rr%r8r:r.r;r;s(YYzY8HYM^Yr-cr)a& Build a schema that contains both an inner schema and a list of definitions which can be used within the inner schema. ```py from pydantic_core import SchemaValidator, core_schema schema = core_schema.definitions_schema( core_schema.list_schema(core_schema.definition_reference_schema('foobar')), [core_schema.int_schema(ref='foobar')], ) v = SchemaValidator(schema) assert v.validate_python([1, 2, '3']) == [1, 2, 3] ``` Args: schema: The inner schema definitions: List of definitions which can be referenced within inner schema r)rdrr)r)rrrr.definitions_schemars( - XXr-cr)DefinitionReferenceSchemaiz#Required[Literal['definition-ref']]rdr schema_refrrr_rrrr%Nrer%r-r.rrs -- Hr-rc r) r6rrrrarrrrr7rr%r8r:r.r;r;s: $$   r-cr)a+ Returns a schema that points to a schema stored in "definitions", this is useful for nested recursive models and also when you want to define validators separately from the main schema, e.g.: ```py from pydantic_core import SchemaValidator, core_schema schema_definition = core_schema.definition_reference_schema('list-schema') schema = core_schema.definitions_schema( schema=schema_definition, definitions=[ core_schema.list_schema(items_schema=schema_definition, ref='list-schema'), ], ) v = SchemaValidator(schema) assert v.validate_python([()]) == [[]] ``` Args: schema_ref: The schema ref to use for the definition reference schema metadata: Any other information you want to include with the schema, not used by pydantic-core serialization: Custom serialization schema definition-ref)rdrrrrr{)rrrrrr.definition_reference_schemars:  * r-cs V^8dQhRRRR/#)r6kwargsr r7r%r8r:r.r;r;s>>S>S>r-c sbVP4UUu/uF wrVfK WbK upp#uuppirS)Zitems)rZkZvs, r.r|r|s(#\\^ =^TQqDAD^ == =s++c`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.crr6rorkrZrrrrr%r8r:r.r;r;s)bb.GbUXbblbr-c T\P!R\4\W3RV/VB#)rrZrqrrrsrurorZrr&&&,r.field_before_validator_functionr s, MMm /x aJ aZ` aar-e`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.cN\P!R\4\V/VB#)r!rZargsr*,r.!general_before_validator_functionr%s& MMo / ? ??r-a`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.crrr%r8r:r.r;r;s)aa-FaTWaakar-c r)r&rZrqrrrsryrrr.field_after_validator_functionr(s, MMk .h `: `Y_ ``r-c`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.cr")r)r'r#r$r. general_after_validator_functionr*& MMm .t >v >>r-_`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.cr)r6rorrZrrrrr%r8r:r.r;r;s)``+`9<`FP`r-c r)r,rZrqrrrsrrrr.field_wrap_validator_functionr.s. MMi -X _* _X^ __r-a`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.cr")r/r-r#r$r.general_wrap_validator_functionr0$s& MMk -d =f ==r-a`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.crf)r6rorkrZrr%r8r:r.r;r;.s YY-FYTWYr-c sT\P!R\4\V3RV/VB#)r1rZrqrrrsr)rorZrs&&,r.field_plain_validator_functionr3-s, MMk .h X: XQW XXr-c`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.cr")r4r2r#r$r. general_plain_validator_functionr56r+r-FieldValidationInfoZFieldValidatorFunctionZGeneralValidatorFunctionZFieldWrapValidatorFunctioncrf)r6 attr_namerr7objectr%r8r:r.r;r;Js  3 6 r-cs\PV4pVf\RV R24h^RIpRV RVP R2pVP !V\ ^R7V#)Nz)module 'pydantic_core' has no attribute 'Z'Z`z` is deprecated, use `z ` instead.rm)_deprecated_import_lookupZgetZAttributeErrorrqr&rrrs)r7Znew_attrrqZmsgs& r. __getattr__r:Jsc(,,Y7HH STUVV)283D3D2EZP c-!<r-)i )r;i )ZallowZforbidZignore)rrrrrrZ bytearrayr7rGrJrMrQrrrrrr rrr&r)rjz unless-nonerrk)NN)NNNN)Znullrrrrr7rrS)Zuniformzunpacked-typed-dict)NNN)4rrrrrrrrrrrrrrrrrrr r7rGrJrMrQrrwrerrzr2rrrrrrrrrrrrrrrrr rrrr&r)rrrr)gZno_such_attributeZ json_invalidZ json_typeZneeds_python_objectZrecursion_loopr Z frozen_fieldZfrozen_instanceZextra_forbiddenZ invalid_keyZget_attribute_errorZ model_typeZmodel_attributes_typeZdataclass_typeZdataclass_exact_typeZdefault_factory_not_calledZ none_requiredZ greater_thanZgreater_than_equalZ less_thanZless_than_equalrZ finite_numberZ too_shortZtoo_longZ iterable_typeZiteration_errorZ string_typeZstring_sub_typeZstring_unicodeZstring_too_shortZstring_too_longZstring_pattern_mismatchrZ dict_typeZ mapping_typeZ list_typeZ tuple_typeZset_typeZset_item_not_hashableZ bool_typeZ bool_parsingZint_typeZ int_parsingZint_parsing_sizeZint_from_floatZ float_typeZ float_parsingZ bytes_typeZbytes_too_shortZbytes_too_longZbytes_invalid_encodingZ value_errorZassertion_errorZ literal_errorZmissing_sentinel_errorZ date_typeZ date_parsingZdate_from_datetime_parsingZdate_from_datetime_inexactZ date_pastZ date_futureZ time_typeZ time_parsingZ datetime_typeZdatetime_parsingZdatetime_object_invalidZdatetime_from_date_parsingZ datetime_pastZdatetime_futureZtimezone_naiveZtimezone_awareZtimezone_offsetZtime_delta_typeZtime_delta_parsingZfrozen_set_typeZis_instance_ofZis_subclass_ofZ callable_typeZunion_tag_invalidZunion_tag_not_foundZarguments_typeZmissing_argumentZunexpected_keyword_argumentZmissing_keyword_only_argumentZunexpected_positional_argumentZ missing_positional_only_argumentZmultiple_argument_valuesZurl_typeZ url_parsingZurl_syntax_violationZ url_too_longZ url_schemeZ uuid_typeZ uuid_parsingZ uuid_versionZ decimal_typeZdecimal_parsingZdecimal_max_digitsZdecimal_max_placesZdecimal_whole_digitsZ complex_typeZcomplex_str_parsing)__conditional_annotations__r*Z __future__rZ _annotationsZsysrqZcollections.abcrrrrrrrrZrerZtypingr r r r r Ztyping_extensionsrrZ version_inforrrrZ pydantic_corerZ ImportErrorr8rrr0r+r1r3rYr[rgrcriZ$GeneralPlainNoInfoSerializerFunctionZ"GeneralPlainInfoSerializerFunctionZ"FieldPlainNoInfoSerializerFunctionZ FieldPlainInfoSerializerFunctionrwrtrmr~rZ#GeneralWrapNoInfoSerializerFunctionZ!GeneralWrapInfoSerializerFunctionZ!FieldWrapNoInfoSerializerFunctionZFieldWrapInfoSerializerFunctionrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrZJsonTyperrrrrr!r#r'r)r/r4r1r;rBrEr?rArIrKrLrNrOrRrJrrrTrSrUrYrVrZr]r[rkr^ZValidationFunctionr`rbrjrurvrxryrzr}r|rr~ZWrapValidatorFunctionrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrZMYPYrrZCoreSchemaTypeZCoreSchemaFieldTypeZ ErrorTyper|r r%r(r*r.r0r3r5r9r6r:)r<s@r.r=s 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 cGY c   2D  !Ye! @ $#   IU F FIUJNrv" __AE_im_,%``AE`im`,%oo4   -"-- -  -  ---'+-'+-` )5 0!%0!%0 0  0  0000'+0'+0f IU  7!%7#'7 7  7  77"7"&777'+7'+7tIU'+  '+ D 9E  ;)-;";" ; %) ; ! ;!;?C;;*.;;'+;'+;|)5$!$"$ $  $ '+ $'+$N %  111 1  1  1041"&11'+1'+1h % 111 1  1  1=A1? ,% ,/" / " / " ///'+/'+//f#C5#:.&I& %c>#+>%?%DEiu 8:YYZy)$ )5 0"&0%) 0 (, 0 9= 06:00'+0'+00f   P%) P (, P AE PP$(PP'+P'+PPf)5nn'+ n '+ nnD 3 3  3 '+ 3'+33l%- - '+ - '+ --`4Ye4%!%NR % '+ % *. %'+%>B%%Piu"=!= = 37 =  =(,=,0==='+='+=!%==@%%NR%'+ % *. % >B %%'+%%P   6"637 6  6 (, 6-16,06$(66'+6'+66r)5$R(, R $ R # R!RUYRRR,0R!%RR'+R'+RRj 4Ye 46 6  6 " 6NR6'+6*.6'+6>B666r ")5 "037 0 &* 0  0'+0'+0,000fiu$8 (, 8  8"8UY888'+8'+888!%88vJ%JLX\ L CG LL<##CD yD iu 5%)5&* 5 *. 5 -1 5,055'+5'+55p J9E J#L#LCG#L#LL 0%)0&* 0 :> 0  0'+0'+00f%3!% 3 (, 3  3'+3'+33l +(, + 37 +  +'++'+++\%+o+o'+ +o '+ +o+o\   4!4)-4"& 4 $ 4 $ 4 $4(,444'+4'+44n % 4!4)-4"& 4 $ 4 $ 4 $4(,444'+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`o` op>q> opYqY qr?s?>7 9 "? (  MI %"H%s!vv v