Viewing File: /opt/hc_python/lib/python3.12/site-packages/pydantic_core/__pycache__/core_schema.cpython-312.pyc

�

c��g�
��UdZddlmZddlZddlZddlmZddlm	Z	mZm
Z
mZddlm
Z
ddlmZmZmZmZmZmZmZmZmZmZmZddlmZej8d	krdd
lmZndd
lmZej8dkrddlmZmZm Z n
ddlmZmZm Z ej8d
krddlm!Z!nddlm!Z!erddl"m#Z#n	ddl"m#Z#e!dZ&Gd�ded��Z'dZ(de)d<Gd�de�Z*Gd�de*e�Z+Gd�de�Z,e!dZ-Gd�d ed��Z.�d.d!�Z/eegefZ0eee*gefZ1eeegefZ2eeee+gefZ3ee0e1e2e3fZ4e!d"Z5	Gd#�d$ed��Z6dddd%d&�											�d/d'�Z7Gd(�d)e�Z8eee8gefZ9eee8e*gefZ:eeee8gefZ;eeee8e+gefZ<ee9e:e;e<fZ=Gd*�d+ed��Z>ddddd%d,�													�d0d-�Z?Gd.�d/ed��Z@d0d1��d1d2�ZAGd3�d4ed��ZBd0d1��d2d5�ZCGd6�d7ed��ZD�d3d8�ZEee.e6e>e@eBeDfZFGd9�d:ed��ZGddd;�									�d4d<�ZHGd=�d>ed��ZIdddd?��d5d@�ZJGdA�dBed��ZKdddd?��d6dC�ZLGdD�dEed��ZM	�d7									�d8dF�ZNGdG�dHed��ZOddddddddddI�																				�d9dJ�ZPGdK�dLed��ZQdddddddddddM�
																					�d:dN�ZRGdO�dPed��ZSdddddddddddddQ�																									�d;dR�ZTGdS�dTed��ZUdddddddddddddU�																									�d<dV�ZVGdW�dXed��ZWdddddddY�													�d=dZ�ZXGd[�d\ed��ZYddddddddddd]�
																					�d>d^�ZZGd_�d`ed��Z[dddddddaddddb�
																					�d?dc�Z\Gdd�deed��Z]dddddddddaddddf�																									�d@dg�Z^Gdh�died��Z_ddddddaddddj�																				�dAdk�Z`Gdl�dmed��Zadddd?�									�dBdn�ZbGdo�dped��Zcdddddddq�																	�dCdr�Zde!dsZeGdt�dued��Zfdddddv�											�dDdw�ZgGdx�dyed��Zhdddddv�											�dEdz�ZiGd{�d|ed��Zjdddd?�							�dFd}�ZkGd~�ded��Zldddddd��											�dGd��ZmGd��d�ed��Znddd���dHd��ZoeeneFfZpGd��d�ed��Zq	�dIdddddddd��																	�dJd��Zrdddddd��													�dKd��Zs	�dIddddddd��															�dLd��ZtGd��d�ed��Zuddddddddd��																			�dMd��ZvGd��d�ed��Zw	�dIdddddddd��																	�dNd��ZxGd��d�ed��Zy	�dIdddddddd��																	�dOd��ZzGd��d�ed��Z{	�dIdddddd��													�dPd��Z|eee}e~fZGd��d�ed��Z�ddd���dQd��Z�ee�eFfZ�Gd��d�ed��Z�		�dRddddddd��																	�dSd��Z�eegefZ�Gd��d�e�Z�eee,gefZ�Gd��d�ed��Z�ee�e�fZ�Gd��d�ed��Z�Gd��d�e�d��Z�dddd?�											�dTd��Z�ddddd��													�dUd��Z�Gd��d�e�d��Z�dddd?�											�dVd��Z�ddddd��													�dWd��Z�Gd��d�e�Z�eee�gefZ�Gd��d�e�Z�eee�e,gefZ�Gd��d�ed��Z�ee�e�fZ�Gd��d�ed��Z�dddd?�											�dXd��Z�ddddd��													�dYd��Z�Gd��d�ed��Z�dddd?�									�dZd��Z�ddddd��											�d[d��Z�Gd��d�ed��Z�e#dddddddd��																			�d\d„Z�GdÄd�ed��Z�dddddŜ											�d]dƄZ�GdDŽd�ed��Z�ddddddddddɜ																						�d^dʄZ�Gd˄d�ed��Z�ddddddddd͜																					�d_d΄Z�Gdτd�ed��Z�dddd?�									�d`dфZ�Gd҄d�ed��Z�dddddŜ													�dadԄZ�GdՄd�ed��Z�dddd?�											�dbdׄZ�Gd؄d�ed��Z�ddddddڜ													�dcdۄZ�Gd܄d�ed��Z�dddddddddddޜ
																							�ddd߄Z�Gd�d�ed��Z�dddddd�													�ded�Z�Gd�d�ed��Z�ddddddddddd�
																							�dfd�Z�Gd�d�ed��Z�dddddddddddd�																											�dgd�Z�Gd�d�ed��Z�ddddddddd�																					�dhd�Z�Gd�d�ed��Z�dddddddd�																			�did�Z�Gd�d�ed��Z�ddddddddddd��
																											�djd��Z�Gd��d�ed��Z�ddd��									�dkd��Z�Gd��d�ed��Z�ddddddd��															�dld��Z�G�d��ded��Z�ddddd�d�															�dm�d�Z�G�d��ded��Z�ddddd�d�															�dn�d�Z�G�d��d	ed��Z�	�dIdddd?�									�do�d
�Z�G�d��ded��Z�dddddddddd�d
�
																					�dp�d�Z�G�d��ded��Z�dddddddddd�d
�
																					�dq�d�Z�G�d��ded��Zɐdr�d�Z�G�d��ded��Z�	�ds									�dt�d�Z�dZ�e�sgegeI�eK�eM�eO�eQ�eS�eU�eW�eY�e[�e]�e_�ea�ec�ef�eh�ej�eq�eu�ew�ey�e{�e��e��e��e��e��e��e��e��e��e��e��e��e��e��e��e��e��e��e��e��eÑeőeǑeɑeˑel��Z�n	e!�dZ�e!�dZ�e!�dZѐdu�d�Z�e�d��dv�d��Z�e�d��d��Z�e�d ��dv�d!��Z�e�d"��d#��Z�e�d$�						�dw�d%��Z�e�d&��d'��Z�e�d(��dx�d)��Z�e�d*��d+��Z�e,e�e�e��d,�Z�ere,Zܐdy�d-�Z�y#e$$re%�Z#Y���wxYw(zze
This module contains definitions to build schemas which `pydantic_core` can
validate and serialize.
�)�annotationsN)�Mapping)�date�datetime�time�	timedelta)�Decimal)�
TYPE_CHECKING�Any�Callable�Dict�Hashable�List�Pattern�Set�Tuple�Type�Union)�
deprecated)��)�	TypedDict)r�)�Protocol�Required�	TypeAlias)r�	)�Literal)�PydanticUndefined)�allow�forbid�ignorec��eZdZUdZded<ded<ded<ded<ded	<ded
<ded<ded
<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded <d!ed"<y#)$�
CoreConfiga

    Base class for schema configuration options.

    Attributes:
        title: The name of the configuration.
        strict: Whether the configuration should strictly adhere to specified rules.
        extra_fields_behavior: The behavior for handling extra fields.
        typed_dict_total: Whether the TypedDict should be considered total. Default is `True`.
        from_attributes: Whether to use attributes for models, dataclasses, and tagged union keys.
        loc_by_alias: Whether to use the used alias (or first alias for "field required" errors) instead of
            `field_names` to construct error `loc`s. Default is `True`.
        revalidate_instances: Whether instances of models and dataclasses should re-validate. Default is 'never'.
        validate_default: Whether to validate default values during validation. Default is `False`.
        populate_by_name: Whether an aliased field may be populated by its name as given by the model attribute,
            as well as the alias. (Replaces 'allow_population_by_field_name' in Pydantic v1.) Default is `False`.
        str_max_length: The maximum length for string fields.
        str_min_length: The minimum length for string fields.
        str_strip_whitespace: Whether to strip whitespace from string fields.
        str_to_lower: Whether to convert string fields to lowercase.
        str_to_upper: Whether to convert string fields to uppercase.
        allow_inf_nan: Whether to allow infinity and NaN values for float fields. Default is `True`.
        ser_json_timedelta: The serialization option for `timedelta` values. Default is 'iso8601'.
        ser_json_bytes: The serialization option for `bytes` values. Default is 'utf8'.
        ser_json_inf_nan: The serialization option for infinity and NaN values
            in float fields. Default is 'null'.
        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.
    �str�title�bool�strict�
ExtraBehavior�extra_fields_behavior�typed_dict_total�from_attributes�loc_by_alias�0Literal['always', 'never', 'subclass-instances']�revalidate_instances�validate_default�populate_by_name�int�str_max_length�str_min_length�str_strip_whitespace�str_to_lower�str_to_upper�
allow_inf_nanzLiteral['iso8601', 'float']�ser_json_timedeltaz Literal['utf8', 'base64', 'hex']�ser_json_bytesz'Literal['null', 'constants', 'strings']�ser_json_inf_nan�hide_input_in_errors�validation_error_cause�coerce_numbers_to_str�"Literal['rust-regex', 'python-re']�regex_enginez+Union[bool, Literal['all', 'keys', 'none']]�
cache_stringsN)�__name__�
__module__�__qualname__�__doc__�__annotations__���J/opt/hc_python/lib64/python3.12/site-packages/pydantic_core/core_schema.pyr$r$/s��� �D�J��L�(�(�������J�J�����������������3�3�4�4�=�=��� � ���4�4�>�>rHr$F)�totalz2set[int | str] | dict[int | str, IncExCall] | Noner�	IncExCallc���eZdZedd��Zedd��Zedd��Zedd��Zedd��Zedd��Z	edd��Z
edd��Zedd	��Zdd
�Z
dd�Zdd�Zdd
�Zy)�SerializationInfoc��y�NrG��selfs rI�includezSerializationInfo.includez���$'rHc��yrOrGrPs rI�excludezSerializationInfo.exclude}rSrHc��y)zCurrent serialization context.NrGrPs rI�contextzSerializationInfo.context�s�rHc��yrOrGrPs rI�modezSerializationInfo.mode�s��rHc��yrOrGrPs rI�by_aliaszSerializationInfo.by_alias�s�� #rHc��yrOrGrPs rI�
exclude_unsetzSerializationInfo.exclude_unset�s��%(rHc��yrOrGrPs rI�exclude_defaultsz"SerializationInfo.exclude_defaults����(+rHc��yrOrGrPs rI�exclude_nonezSerializationInfo.exclude_none�rSrHc��yrOrGrPs rI�serialize_as_anyz"SerializationInfo.serialize_as_any�r`rHc��yrOrGrPs rI�
round_tripzSerializationInfo.round_trip�s��#rHc��yrOrGrPs rI�mode_is_jsonzSerializationInfo.mode_is_json�s��CrHc��yrOrGrPs rI�__str__zSerializationInfo.__str__�s��crHc��yrOrGrPs rI�__repr__zSerializationInfo.__repr__�s��srHN)�returnrK�rmz
Any | None�rmr%)rmr')rBrCrD�propertyrRrUrWrYr[r]r_rbrdrfrhrjrlrGrHrIrMrMys���
�'��'�
�'��'�
�-��-�����
�#��#�
�(��(�
�+��+�
�'��'�
�+��+�%�'�!�"rHrMc��eZdZedd��Zy)�FieldSerializationInfoc��yrOrGrPs rI�
field_namez!FieldSerializationInfo.field_name�s��!$rHNro)rBrCrDrprtrGrHrIrrrr�s��
�$��$rHrrc�j�eZdZdZedd��Zed	d��Zed
d��Zedd��Zedd��Z	y)
�ValidationInfoz2
    Argument passed to validation functions.
    c��y)zCurrent validation context.NrGrPs rIrWzValidationInfo.context����	rHc��y)z/The CoreConfig that applies to this validation.NrGrPs rI�configzValidationInfo.config�rxrHc��y)z2The type of input data we are currently validatingNrGrPs rIrYzValidationInfo.mode�rxrHc��y)z(The data being validated for this model.NrGrPs rI�datazValidationInfo.data�rxrHc��y)zw
        The name of the current field being validated if this validator is
        attached to a model field.
        NrGrPs rIrtzValidationInfo.field_name�s��	rHNrn)rm�CoreConfig | None)rmzLiteral['python', 'json'])rmzDict[str, Any])rm�
str | None)
rBrCrDrErprWrzrYr}rtrGrHrIrvrv�sk����������������������rHrv)�noner2r'�floatr%�bytes�	bytearray�list�tuple�set�	frozenset�	generator�dictrrrr�url�multi-host-url�json�uuidc��eZdZUded<y)�SimpleSerSchemaz$Required[ExpectedSerializationTypes]�typeN�rBrCrDrFrGrHrIr�r�����
.�.rHr�c��t|��S)z{
    Returns a schema for serialization with a custom type.

    Args:
        type: The type to use for serialization
    �r�)r�r�s rI�simple_ser_schemar��s����%�%rH)�alwayszunless-noner��json-unless-nonec�J�eZdZUded<ded<ded<ded<ded	<d
ed<y)
� PlainSerializerFunctionSerSchema�#Required[Literal['function-plain']]r�zRequired[SerializerFunction]�functionr'�is_field_serializer�info_arg�
CoreSchema�
return_schema�WhenUsed�	when_usedNr�rGrHrIr�r�s%��
-�-�*�*����N����rHr�r�)r�r�r�r�c�2�|dk(rd}td|||||��S)a
    Returns a schema for serialization with a function, can be either a "general" or "field" function.

    Args:
        function: The function to use for serialization
        is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,
            and `info` includes `field_name`
        info_arg: Whether the function takes an `info` argument
        return_schema: Schema to use for serializing return value
        when_used: When the function should be called
    r�N�function-plain)r�r�r�r�r�r���_dict_not_none)r�r�r�r�r�s     rI�$plain_serializer_function_ser_schemar�s0��&�H���	��
��/��#��
�rHc��eZdZddd�Zy)�SerializerFunctionWrapHandlerNc��yrOrG)rQ�input_value�	index_keys   rI�__call__z&SerializerFunctionWrapHandler.__call__1s��X[rHrO)r�rr�zint | str | Nonermr�rBrCrDr�rGrHrIr�r�0s��[rHr�c�T�eZdZUded<ded<ded<ded<ded	<ded
<ded<y
)�WrapSerializerFunctionSerSchema�"Required[Literal['function-wrap']]r�z Required[WrapSerializerFunction]r�r'r�r�r��schemar�r�r�Nr�rGrHrIr�r�Ds+��
,�,�.�.����N������rHr�)r�r�r�r�r�c	�4�|dk(rd}td||||||��S)aE
    Returns a schema for serialization with a wrap function, can be either a "general" or "field" function.

    Args:
        function: The function to use for serialization
        is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,
            and `info` includes `field_name`
        info_arg: Whether the function takes an `info` argument
        schema: The schema to use for the inner serialization
        return_schema: Schema to use for serializing return value
        when_used: When the function should be called
    r�N�
function-wrap)r�r�r�r�r�r�r�r�)r�r�r�r�r�r�s      rI�#wrap_serializer_function_ser_schemar�Ns3��*�H���	��
��/���#���rHc�,�eZdZUded<ded<ded<y)�FormatSerSchemazRequired[Literal['format']]r��
Required[str]�formatting_stringr�r�Nr�rGrHrIr�r�qs��
%�%�$�$��rHr�r�)r�c�,�|dk(rd}td||��S)z�
    Returns a schema for serialization using python's `format` method.

    Args:
        formatting_string: String defining the format to use
        when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default
    r�N�format)r�r�r�r�)r�r�s  rI�format_ser_schemar�ws#���&�&��	��x�;L�Xa�b�brHc�"�eZdZUded<ded<y)�ToStringSerSchemazRequired[Literal['to-string']]r�r�r�Nr�rGrHrIr�r��s��
(�(��rHr�c�2�td��}|dk7r||d<|S)z�
    Returns a schema for serialization using python's `str()` / `__str__` method.

    Args:
        when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default
    z	to-stringr�r�r�)r�)r��ss  rI�to_string_ser_schemar��s%��	
�+��A��&�&�"��+���HrHc�,�eZdZUded<ded<ded<y)�ModelSerSchema�Required[Literal['model']]r��Required[Type[Any]]�cls�Required[CoreSchema]r�Nr�rGrHrIr�r��s��
$�$�	�� � rHr�c��td||��S)z�
    Returns a schema for serialization using a model.

    Args:
        cls: The expected class type, used to generate warnings if the wrong type is passed
        schema: Internal schema to use to serialize the model dict
    �model)r�r�r�)r�)r�r�s  rI�model_ser_schemar��s���w�C��?�?rHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�
ComputedFieldz#Required[Literal['computed-field']]r�r��
property_namer�r�r%�aliasr�metadataNr�rGrHrIr�r��s��
-�-� � �'�'��J��MrHr�)r�r�c�"�td||||��S)a�
    ComputedFields are properties of a model or dataclass that are included in serialization.

    Args:
        property_name: The name of the property on the model or dataclass
        return_schema: The schema used for the type returned by the computed field
        alias: The name to use in the serialized output
        metadata: Any other information you want to include with the schema, not used by pydantic-core
    �computed-field)r�r�r�r�r�r�)r�r�r�r�s    rI�computed_fieldr��s���
�]�-�_d�ow��rHc�6�eZdZUded<ded<ded<ded<y	)
�	AnySchemazRequired[Literal['any']]r�r%�refrr��	SerSchema�
serializationNr�rGrHrIr�r��s��
"�"�	�H��M��rHr��r�r�r�c� �td|||��S)a�
    Returns a schema that matches any value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.any_schema()
    v = SchemaValidator(schema)
    assert v.validate_python(1) == 1
    ```

    Args:
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �any�r�r�r�r�r�r�s   rI�
any_schemar��s��"�u�#��P]�^�^rHc�6�eZdZUded<ded<ded<ded<y	)
�
NoneSchemazRequired[Literal['none']]r�r%r�rr�r�r�Nr�rGrHrIr�r��s��
#�#�	�H��M��rHr�c� �td|||��S)a
    Returns a schema that matches a None value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.none_schema()
    v = SchemaValidator(schema)
    assert v.validate_python(None) is None
    ```

    Args:
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�r�r�r�s   rI�none_schemar��s��"�v�3��Q^�_�_rHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�
BoolSchemazRequired[Literal['bool']]r�r'r(r%r�rr�r�r�Nr�rGrHrIr�r�s��
#�#��L�	�H��M��rHr�c�"�td||||��S)ae
    Returns a schema that matches a bool value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.bool_schema()
    v = SchemaValidator(schema)
    assert v.validate_python('True') is True
    ```

    Args:
        strict: Whether the value should be a bool or a value that can be converted to a bool
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r')r�r(r�r�r�r��r(r�r�r�s    rI�bool_schemar�
s��(�v�f�#��`m�n�nrHc�r�eZdZUded<ded<ded<ded<ded<ded<d	ed
<ded<d
ed<ded<y)�	IntSchemazRequired[Literal['int']]r�r2�multiple_of�le�ge�lt�gtr'r(r%r�rr�r�r�Nr�rGrHrIr�r�!s7��
"�"����G��G��G��G��L�	�H��M��rHr��	r�r�r�r�r�r(r�r�r�c	�,�td|||||||||��
S)a�
    Returns a schema that matches a int value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.int_schema(multiple_of=2, le=6, ge=2)
    v = SchemaValidator(schema)
    assert v.validate_python('4') == 4
    ```

    Args:
        multiple_of: The value must be a multiple of this number
        le: The value must be less than or equal to this number
        ge: The value must be greater than or equal to this number
        lt: The value must be strictly less than this number
        gt: The value must be strictly greater than this number
        strict: Whether the value should be a int or a value that can be converted to a int
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r2)
r�r�r�r�r�r�r(r�r�r�r�r�s	         rI�
int_schemar�.s0��D�
��
�
�
�
����#��rHc�|�eZdZUded<ded<ded<ded<ded<ded	<ded
<ded<ded
<ded<ded<y)�FloatSchemazRequired[Literal['float']]r�r'r8r�r�r�r�r�r�r(r%r�rr�r�r�Nr�rGrHrIr�r�^s=��
$�$�����
�I�
�I�
�I�
�I��L�	�H��M��rHr��
r8r�r�r�r�r�r(r�r�r�c

�.�td||||||||||	��S)a�
    Returns a schema that matches a float value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.float_schema(le=0.8, ge=0.2)
    v = SchemaValidator(schema)
    assert v.validate_python('0.5') == 0.5
    ```

    Args:
        allow_inf_nan: Whether to allow inf and nan values
        multiple_of: The value must be a multiple of this number
        le: The value must be less than or equal to this number
        ge: The value must be greater than or equal to this number
        lt: The value must be strictly less than this number
        gt: The value must be strictly greater than this number
        strict: Whether the value should be a float or a value that can be converted to a float
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�)r�r8r�r�r�r�r�r(r�r�r�r�r�s
          rI�float_schemar�ls3��H�
�#��
�
�
�
����#��rHc��eZdZUded<ded<ded<ded<ded<ded	<ded
<ded<ded
<ded<ded<ded<ded<y)�
DecimalSchemazRequired[Literal['decimal']]r�r'r8r	r�r�r�r�r�r2�
max_digits�decimal_placesr(r%r�rr�r�r�Nr�rGrHrIr�r��sH��
&�&������K��K��K��K��O����L�	�H��M��rHr��r8r�r�r�r�r�r�r�r(r�r�r�c�2�td||||||||||	|
|��
S)a�
    Returns a schema that matches a decimal value, e.g.:

    ```py
    from decimal import Decimal
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.decimal_schema(le=0.8, ge=0.2)
    v = SchemaValidator(schema)
    assert v.validate_python('0.5') == Decimal('0.5')
    ```

    Args:
        allow_inf_nan: Whether to allow inf and nan values
        multiple_of: The value must be a multiple of this number
        le: The value must be less than or equal to this number
        ge: The value must be greater than or equal to this number
        lt: The value must be strictly less than this number
        gt: The value must be strictly greater than this number
        max_digits: The maximum number of decimal digits allowed
        decimal_places: The maximum number of decimal places allowed
        strict: Whether the value should be a float or a value that can be converted to a float
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �decimal)
r�r�r�r�r�r�r�r�r8r(r�r�r�r�r�s            rI�decimal_schemar��s9��R�
�
�
�
�
��%��#����#��rHc��eZdZUded<ded<ded<ded<ded	<ded
<ded<ded
<ded<ded<ded<ded<ded<y)�StringSchemazRequired[Literal['str']]r�zUnion[str, Pattern[str]]�patternr2�
max_length�
min_lengthr'�strip_whitespace�to_lower�to_upperr?r@r(r>r%r�rr�r�r�Nr�rGrHrIr�r��sI��
"�"�
%�%��O��O����N��N�4�4��L���	�H��M��rHr��r�rrrrrr@r(r>r�r�r�c�2�td||||||||||	|
|��
S)aC
    Returns a schema that matches a string value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.str_schema(max_length=10, min_length=2)
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello'
    ```

    Args:
        pattern: A regex pattern that the value must match
        max_length: The value must be at most this length
        min_length: The value must be at least this length
        strip_whitespace: Whether to strip whitespace from the value
        to_lower: Whether to convert the value to lowercase
        to_upper: Whether to convert the value to uppercase
        regex_engine: The regex engine to use for pattern validation. Default is 'rust-regex'.
            - `rust-regex` uses the [`regex`](https://docs.rs/regex) Rust
              crate, which is non-backtracking and therefore more DDoS
              resistant, but does not support all regex features.
            - `python-re` use the [`re`](https://docs.python.org/3/library/re.html) module,
              which supports all regex features, but may be slower.
        strict: Whether the value should be a string or a value that can be converted to a string
        coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r%)
r�r�rrrrrr@r(r>r�r�r�r�rs            rI�
str_schemar�s9��Z�
����)���!��3���#��rHc�T�eZdZUded<ded<ded<ded<ded	<d
ed<ded
<y)�BytesSchemazRequired[Literal['bytes']]r�r2rrr'r(r%r�rr�r�r�Nr�rGrHrIr	r	7s'��
$�$��O��O��L�	�H��M��rHr	�rrr(r�r�r�c	�&�td||||||��S)a�
    Returns a schema that matches a bytes value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.bytes_schema(max_length=10, min_length=2)
    v = SchemaValidator(schema)
    assert v.validate_python(b'hello') == b'hello'
    ```

    Args:
        max_length: The value must be at most this length
        min_length: The value must be at least this length
        strict: Whether the value should be a bytes or a value that can be converted to a bytes
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�)r�rrr(r�r�r�r�r
s      rI�bytes_schemarAs&��8�
������#��rHc�|�eZdZUded<ded<ded<ded<ded<ded	<d
ed<ded
<ded<ded<ded<y)�
DateSchemazRequired[Literal['date']]r�r'r(rr�r�r�r��Literal['past', 'future']�now_opr2�now_utc_offsetr%r�rr�r�r�Nr�rGrHrIrrhs?��
#�#��L��H��H��H��H�%�%���	�H��M��rHr�
r(r�r�r�r�rrr�r�r�c

�.�td||||||||||	��S)a�
    Returns a schema that matches a date value, e.g.:

    ```py
    from datetime import date
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.date_schema(le=date(2020, 1, 1), ge=date(2019, 1, 1))
    v = SchemaValidator(schema)
    assert v.validate_python(date(2019, 6, 1)) == date(2019, 6, 1)
    ```

    Args:
        strict: Whether the value should be a date or a value that can be converted to a date
        le: The value must be less than or equal to this date
        ge: The value must be greater than or equal to this date
        lt: The value must be strictly less than this date
        gt: The value must be strictly greater than this date
        now_op: The value must be in the past or future relative to the current date
        now_utc_offset: The value must be in the past or future relative to the current date with this utc offset
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r)r�r(r�r�r�r�rrr�r�r�r�rs
          rI�date_schemarxs3��J�
��
�
�
�
��%���#��rHc�|�eZdZUded<ded<ded<ded<ded<ded	<d
ed<ded
<ded<ded<ded<y)�
TimeSchemazRequired[Literal['time']]r�r'r(rr�r�r�r��%Union[Literal['aware', 'naive'], int]�
tz_constraint�Literal['truncate', 'error']�microseconds_precisionr%r�rr�r�r�Nr�rGrHrIrr�s=��
#�#��L��H��H��H��H�8�8�8�8�	�H��M��rHr�truncate�
r(r�r�r�r�rrr�r�r�c

�.�td||||||||||	��S)a�
    Returns a schema that matches a time value, e.g.:

    ```py
    from datetime import time
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.time_schema(le=time(12, 0, 0), ge=time(6, 0, 0))
    v = SchemaValidator(schema)
    assert v.validate_python(time(9, 0, 0)) == time(9, 0, 0)
    ```

    Args:
        strict: Whether the value should be a time or a value that can be converted to a time
        le: The value must be less than or equal to this time
        ge: The value must be greater than or equal to this time
        lt: The value must be strictly less than this time
        gt: The value must be strictly greater than this time
        tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset
        microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r)r�r(r�r�r�r�rrr�r�r�r�rs
          rI�time_schemar�s3��J�
��
�
�
�
�#�5���#��rHc��eZdZUded<ded<ded<ded<ded<ded	<d
ed<ded
<ded<ded<ded<ded<ded<y)�DatetimeSchemazRequired[Literal['datetime']]r�r'r(rr�r�r�r�rrrrr2rrrr%r�rr�r�r�Nr�rGrHrIr r �sK��
'�'��L��L��L��L��L�%�%�8�8���8�8�	�H��M��rHr �r(r�r�r�r�rrrrr�r�r�c�2�td||||||||||	|
|��
S)a�
    Returns a schema that matches a datetime value, e.g.:

    ```py
    from datetime import datetime
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.datetime_schema()
    v = SchemaValidator(schema)
    now = datetime.now()
    assert v.validate_python(str(now)) == now
    ```

    Args:
        strict: Whether the value should be a datetime or a value that can be converted to a datetime
        le: The value must be less than or equal to this datetime
        ge: The value must be greater than or equal to this datetime
        lt: The value must be strictly less than this datetime
        gt: The value must be strictly greater than this datetime
        now_op: The value must be in the past or future relative to the current datetime
        tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset
            TODO: use of a tzinfo where offset changes based on the datetime is not yet supported
        now_utc_offset: The value must be in the past or future relative to the current datetime with this utc offset
        microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r)
r�r(r�r�r�r�rrrrr�r�r�r�r!s            rI�datetime_schemar#s9��V�
��
�
�
�
��#�%�5���#��rHc�r�eZdZUded<ded<ded<ded<ded<ded	<d
ed<ded
<ded<ded<y)�TimedeltaSchemazRequired[Literal['timedelta']]r�r'r(rr�r�r�r�rrr%r�rr�r�r�Nr�rGrHrIr%r%<s7��
(�(��L��M��M��M��M�8�8�	�H��M��rHr%�	r(r�r�r�r�rr�r�r�c	�,�td|||||||||��
S)a]
    Returns a schema that matches a timedelta value, e.g.:

    ```py
    from datetime import timedelta
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.timedelta_schema(le=timedelta(days=1), ge=timedelta(days=0))
    v = SchemaValidator(schema)
    assert v.validate_python(timedelta(hours=12)) == timedelta(hours=12)
    ```

    Args:
        strict: Whether the value should be a timedelta or a value that can be converted to a timedelta
        le: The value must be less than or equal to this timedelta
        ge: The value must be greater than or equal to this timedelta
        lt: The value must be strictly less than this timedelta
        gt: The value must be strictly greater than this timedelta
        microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r)
r�r(r�r�r�r�rr�r�r�r�r&s	         rI�timedelta_schemar(Is0��F�
��
�
�
�
�5���#��rHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�
LiteralSchemazRequired[Literal['literal']]r��Required[List[Any]]�expectedr%r�rr�r�r�Nr�rGrHrIr*r*zs��
&�&�!�!�	�H��M��rHr*c�"�td||||��S)a[
    Returns a schema that matches a literal value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.literal_schema(['hello', 'world'])
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello'
    ```

    Args:
        expected: The value must be one of these values
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �literal)r�r,r�r�r�r�)r,r�r�r�s    rI�literal_schemar/�s��(�y�8��x�gt�u�urHc�h�eZdZUded<ded<ded<ded<d	ed
<ded<d
ed<ded<ded<y)�
EnumSchemazRequired[Literal['enum']]r��
Required[Any]r�r+�memberszLiteral['str', 'int', 'float']�sub_typezCallable[[Any], Any]�missingr'r(r%r�rr�r�r�Nr�rGrHrIr1r1�s5��
#�#�	��
 � �,�,�
!�!��L�	�H��M��rHr1)r4r5r(r�r�r�c�*�td||||||||��	S)a�
    Returns a schema that matches an enum value, e.g.:

    ```py
    from enum import Enum
    from pydantic_core import SchemaValidator, core_schema

    class Color(Enum):
        RED = 1
        GREEN = 2
        BLUE = 3

    schema = core_schema.enum_schema(Color, list(Color.__members__.values()))
    v = SchemaValidator(schema)
    assert v.validate_python(2) is Color.GREEN
    ```

    Args:
        cls: The enum class
        members: The members of the enum, generally `list(MyEnum.__members__.values())`
        sub_type: The type of the enum, either 'str' or 'int' or None for plain enums
        missing: A function to use when the value is not found in the enum, from `_missing_`
        strict: Whether to use strict mode, defaults to False
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �enum)	r�r�r3r4r5r(r�r�r�r�)r�r3r4r5r(r�r�r�s        rI�enum_schemar8�s-��L�
��������#�
�
rH)�nullr'r2r�r%r�r�c�J�eZdZUded<ded<ded<ded<ded	<d
ed<y)
�IsInstanceSchemaz Required[Literal['is-instance']]r�r2r�r%�cls_reprr�rr�r�r�Nr�rGrHrIr;r;�s#��
*�*�	���M�	�H��M��rHr;)r<r�r�r�c�$�td|||||��S)a�
    Returns a schema that checks if a value is an instance of a class, equivalent to python's `isinstance` method, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    class A:
        pass

    schema = core_schema.is_instance_schema(cls=A)
    v = SchemaValidator(schema)
    v.validate_python(A())
    ```

    Args:
        cls: The value must be an instance of this class
        cls_repr: If provided this string is used in the validator name instead of `repr(cls)`
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �is-instance�r�r�r<r�r�r�r��r�r<r�r�r�s     rI�is_instance_schemarA�s��:�
��h�C�(�bo��rHc�J�eZdZUded<ded<ded<ded<ded	<d
ed<y)
�IsSubclassSchemaz Required[Literal['is-subclass']]r�r�r�r%r<r�rr�r�r�Nr�rGrHrIrCrCs#��
*�*�	���M�	�H��M��rHrCc�$�td|||||��S)a
    Returns a schema that checks if a value is a subtype of a class, equivalent to python's `issubclass` method, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    class A:
        pass

    class B(A):
        pass

    schema = core_schema.is_subclass_schema(cls=A)
    v = SchemaValidator(schema)
    v.validate_python(B)
    ```

    Args:
        cls: The value must be a subclass of this class
        cls_repr: If provided this string is used in the validator name instead of `repr(cls)`
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �is-subclassr?r�r@s     rI�is_subclass_schemarFs ��@�
��h�C�(�bo��rHc�6�eZdZUded<ded<ded<ded<y	)
�CallableSchemazRequired[Literal['callable']]r�r%r�rr�r�r�Nr�rGrHrIrHrH5s��
'�'�	�H��M��rHrHc� �td|||��S)a,
    Returns a schema that checks if a value is callable, equivalent to python's `callable` method, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.callable_schema()
    v = SchemaValidator(schema)
    v.validate_python(min)
    ```

    Args:
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �callabler�r�r�s   rI�callable_schemarK<s��&�z�s�X�Ub�c�crHc�J�eZdZUded<ded<ded<ded<d	ed
<ded<y
)�
UuidSchemazRequired[Literal['uuid']]r�zLiteral[1, 3, 4, 5]�versionr'r(r%r�rr�r�r�Nr�rGrHrIrMrMRs#��
#�#�
 � ��L�	�H��M��rHrM�rNr(r�r�r�c�$�td|||||��S)Nr�)r�rNr(r�r�r�r�rOs     rI�uuid_schemarQ[s���
�W�V��x�_l��rHc�,�eZdZUded<ded<ded<y)�IncExSeqSerSchemaz-Required[Literal['include-exclude-sequence']]r�zSet[int]rRrUNr�rGrHrIrSrShs��
7�7�
��
�rHrS�rRrUc��td||��S)Nzinclude-exclude-sequence�r�rRrUr�rTs  rI�filter_seq_schemarWns���9�7�T[�\�\rHc�h�eZdZUded<ded<ded<ded<ded	<ded
<ded<d
ed<ded<y)�
ListSchemazRequired[Literal['list']]r�r��items_schemar2rrr'�	fail_fastr(r%r�rr��IncExSeqOrElseSerSchemar�Nr�rGrHrIrYrYus2��
#�#����O��O��O��L�	�H��M�*�*rHrY)rrr[r(r�r�r�c�*�td||||||||��	S)a�
    Returns a schema that matches a list value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.list_schema(core_schema.int_schema(), min_length=0, max_length=10)
    v = SchemaValidator(schema)
    assert v.validate_python(['4']) == [4]
    ```

    Args:
        items_schema: The value must be a list of items that match this schema
        min_length: The value must be a list with at least this many items
        max_length: The value must be a list with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a list with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r��	r�rZrrr[r(r�r�r�r��rZrrr[r(r�r�r�s        rI�list_schemar`�s-��@�
�!�������#�
�
rH)�
extras_schemar(r�r�r��TupleSchemac�P�|�t|�}||gz}nd}t||||||��S)a�
    Returns a schema that matches a tuple of schemas, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.tuple_positional_schema(
        [core_schema.int_schema(), core_schema.str_schema()]
    )
    v = SchemaValidator(schema)
    assert v.validate_python((1, 'hello')) == (1, 'hello')
    ```

    Args:
        items_schema: The value must be a tuple with items that match these schemas
        extras_schema: The value must be a tuple with items that match this schema
            This was inspired by JSON schema's `prefixItems` and `items` fields.
            In python's `typing.Tuple`, you can't specify a type for "extra" items -- they must all be the same type
            if the length is variable. So this field won't be set from a `typing.Tuple` annotation on a pydantic model.
        strict: The value must be a tuple with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    N)rZ�variadic_item_indexr(r�r�r�)�len�tuple_schema)rZrar(r�r�r�rds       rI�tuple_positional_schemarg�sG��B� �!�,�/��#�}�o�5��"���!�/����#�
�rH)rrr(r�r�r�c
�B�t|xs
t�gd||||||��S)a�
    Returns a schema that matches a tuple of a given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.tuple_variable_schema(
        items_schema=core_schema.int_schema(), min_length=0, max_length=10
    )
    v = SchemaValidator(schema)
    assert v.validate_python(('1', 2, 3)) == (1, 2, 3)
    ```

    Args:
        items_schema: The value must be a tuple with items that match this schema
        min_length: The value must be a tuple with at least this many items
        max_length: The value must be a tuple with at most this many items
        strict: The value must be a tuple with exactly this many items
        ref: Optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r)rZrdrrr(r�r�r�)rfr�)rZrrr(r�r�r�s       rI�tuple_variable_schemari�s4��@�"�2�j�l�3�������#�	�	rHc�r�eZdZUded<ded<ded<ded<ded<d	ed
<d	ed<ded
<ded<ded<y)rbzRequired[Literal['tuple']]r��Required[List[CoreSchema]]rZr2rdrrr'r[r(r%r�rr�r\r�Nr�rGrHrIrbrbs8��
$�$�,�,����O��O��O��L�	�H��M�*�*rH)rdrrr[r(r�r�r�c�,�td|||||||||��
S)a�
    Returns a schema that matches a tuple of schemas, with an optional variadic item, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.tuple_schema(
        [core_schema.int_schema(), core_schema.str_schema(), core_schema.float_schema()],
        variadic_item_index=1,
    )
    v = SchemaValidator(schema)
    assert v.validate_python((1, 'hello', 'world', 1.5)) == (1, 'hello', 'world', 1.5)
    ```

    Args:
        items_schema: The value must be a tuple with items that match these schemas
        variadic_item_index: The index of the schema in `items_schema` to be treated as variadic (following PEP 646)
        min_length: The value must be a tuple with at least this many items
        max_length: The value must be a tuple with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a tuple with exactly this many items
        ref: Optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�)
r�rZrdrrr[r(r�r�r�r�)	rZrdrrr[r(r�r�r�s	         rIrfrfs0��J�
�!�/�������#��rHc�h�eZdZUded<ded<ded<ded<ded	<ded
<ded<d
ed<ded<y)�	SetSchemazRequired[Literal['set']]r�r�rZr2rrr'r[r(r%r�rr�r�r�Nr�rGrHrIrnrnLs2��
"�"����O��O��O��L�	�H��M��rHrnc�*�td||||||||��	S)a�
    Returns a schema that matches a set of a given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.set_schema(
        items_schema=core_schema.int_schema(), min_length=0, max_length=10
    )
    v = SchemaValidator(schema)
    assert v.validate_python({1, '2', 3}) == {1, 2, 3}
    ```

    Args:
        items_schema: The value must be a set with items that match this schema
        min_length: The value must be a set with at least this many items
        max_length: The value must be a set with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a set with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�r^r�r_s        rI�
set_schemarpXs-��D�
�!�������#�
�
rHc�h�eZdZUded<ded<ded<ded<ded	<ded
<ded<d
ed<ded<y)�FrozenSetSchemazRequired[Literal['frozenset']]r�r�rZr2rrr'r[r(r%r�rr�r�r�Nr�rGrHrIrrrr�s2��
(�(����O��O��O��L�	�H��M��rHrrc�*�td||||||||��	S)a
    Returns a schema that matches a frozenset of a given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.frozenset_schema(
        items_schema=core_schema.int_schema(), min_length=0, max_length=10
    )
    v = SchemaValidator(schema)
    assert v.validate_python(frozenset(range(3))) == frozenset({0, 1, 2})
    ```

    Args:
        items_schema: The value must be a frozenset with items that match this schema
        min_length: The value must be a frozenset with at least this many items
        max_length: The value must be a frozenset with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a frozenset with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�r^r�r_s        rI�frozenset_schemart�s-��D�
�!�������#�
�
rHc�T�eZdZUded<ded<ded<ded<ded	<d
ed<ded
<y)�GeneratorSchemazRequired[Literal['generator']]r�r�rZr2rrr%r�rr�r\r�Nr�rGrHrIrvrv�s(��
(�(����O��O�	�H��M�*�*rHrv)rrr�r�r�c	�&�td||||||��S)a�
    Returns a schema that matches a generator value, e.g.:

    ```py
    from typing import Iterator
    from pydantic_core import SchemaValidator, core_schema

    def gen() -> Iterator[int]:
        yield 1

    schema = core_schema.generator_schema(items_schema=core_schema.int_schema())
    v = SchemaValidator(schema)
    v.validate_python(gen())
    ```

    Unlike other types, validated generators do not raise ValidationErrors eagerly,
    but instead will raise a ValidationError when a violating value is actually read from the generator.
    This is to ensure that "validated" generators retain the benefit of lazy evaluation.

    Args:
        items_schema: The value must be a generator with items that match this schema
        min_length: The value must be a generator that yields at least this many items
        max_length: The value must be a generator that yields at most this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�)r�rZrrr�r�r�r�)rZrrr�r�r�s      rI�generator_schemarx�s'��H�
�!�����#��rHc�,�eZdZUded<ded<ded<y)�IncExDictSerSchemaz)Required[Literal['include-exclude-dict']]r��	IncExDictrRrUNr�rGrHrIrzrz�s��
3�3�
��
�rHrzc��td||��S)Nzinclude-exclude-dictrVr�rTs  rI�filter_dict_schemar}s���5�w�PW�X�XrHc�h�eZdZUded<ded<ded<ded<ded<d	ed
<ded<d
ed<ded<y)�
DictSchemazRequired[Literal['dict']]r�r��keys_schema�
values_schemar2rrr'r(r%r�rr��IncExDictOrElseSerSchemar�Nr�rGrHrIrrs3��
#�#������O��O��L�	�H��M�+�+rHrc�*�td||||||||��	S)a
    Returns a schema that matches a dict value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.dict_schema(
        keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()
    )
    v = SchemaValidator(schema)
    assert v.validate_python({'a': '1', 'b': 2}) == {'a': 1, 'b': 2}
    ```

    Args:
        keys_schema: The value must be a dict with keys that match this schema
        values_schema: The value must be a dict with values that match this schema
        min_length: The value must be a dict with at least this many items
        max_length: The value must be a dict with at most this many items
        strict: Whether the keys and values should be validated with strict mode
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�)	r�r�r�rrr(r�r�r�r�)r�r�rrr(r�r�r�s        rI�dict_schemar�s-��D�
��#������#�
�
rHc�"�eZdZUded<ded<y)�NoInfoValidatorFunctionSchema�Literal['no-info']r��NoInfoValidatorFunctionr�Nr�rGrHrIr�r�Js��
��%�%rHr�c�,�eZdZUded<ded<ded<y)�WithInfoValidatorFunctionSchema�Required[Literal['with-info']]r�z#Required[WithInfoValidatorFunction]r�r%rtNr�rGrHrIr�r�Ss��
(�(�1�1��OrHr�c�@�eZdZUded<ded<ded<ded<d	ed
<y)�_ValidatorFunctionSchema�Required[ValidationFunction]r�r�r�r%r�rr�r�r�Nr�rGrHrIr�r�\s��*�*� � �	�H��M��rHr�c��eZdZUded<y)�BeforeValidatorFunctionSchemaz$Required[Literal['function-before']]r�Nr�rGrHrIr�r�dr�rHr�c�*�tdd|d�||||��S)a�
    Returns a schema that calls a validator function before validating, no `info` argument is provided, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: bytes) -> str:
        return v.decode() + 'world'

    func_schema = core_schema.no_info_before_validator_function(
        function=fn, schema=core_schema.str_schema()
    )
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call
        schema: The schema to validate the output of the validator function
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �function-before�no-info�r�r��r�r�r�r�r�r�r��r�r�r�r�r�s     rI�!no_info_before_validator_functionr�hs)��B�
�#��:����#�
�rH)rtr�r�r�c�<�tdtd||��||||��S)a�
    Returns a schema that calls a validator function before validation, the function is called with
    an `info` argument, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
        assert info.data is not None
        assert info.field_name is not None
        return v.decode() + 'world'

    func_schema = core_schema.with_info_before_validator_function(
        function=fn, schema=core_schema.str_schema(), field_name='a'
    )
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call
        field_name: The name of the field
        schema: The schema to validate the output of the validator function
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r��	with-info�r�r�rtr�r��r�r�rtr�r�r�s      rI�#with_info_before_validator_functionr��s.��L�
��[�8�PZ�[����#�
�rHc��eZdZUded<y)�AfterValidatorFunctionSchemaz#Required[Literal['function-after']]r�Nr�rGrHrIr�r��s��
-�-rHr�c�*�tdd|d�||||��S)a�
    Returns a schema that calls a validator function after validating, no `info` argument is provided, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str) -> str:
        return v + 'world'

    func_schema = core_schema.no_info_after_validator_function(fn, core_schema.str_schema())
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call after the schema is validated
        schema: The schema to validate before the validator function
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �function-afterr�r�r�r�r�s     rI� no_info_after_validator_functionr��s(��>�
�#��:����#�
�rHc�<�tdtd||��||||��S)a�
    Returns a schema that calls a validator function after validation, the function is called with
    an `info` argument, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert info.data is not None
        assert info.field_name is not None
        return v + 'world'

    func_schema = core_schema.with_info_after_validator_function(
        function=fn, schema=core_schema.str_schema(), field_name='a'
    )
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call after the schema is validated
        schema: The schema to validate before the validator function
        field_name: The name of the field this validators is applied to, if any
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�r�r�r�r�r�s      rI�"with_info_after_validator_functionr��s.��L�
��[�8�PZ�[����#�
�rHc��eZdZddd�Zy)�ValidatorFunctionWrapHandlerNc��yrOrG)rQr��outer_locations   rIr�z%ValidatorFunctionWrapHandler.__call__!s��rHrO)r�rr�zstr | int | Nonermrr�rGrHrIr�r� s��rHr�c�"�eZdZUded<ded<y)�!NoInfoWrapValidatorFunctionSchemar�r��NoInfoWrapValidatorFunctionr�Nr�rGrHrIr�r�)s��
��)�)rHr�c�,�eZdZUded<ded<ded<y)�#WithInfoWrapValidatorFunctionSchemar�r�z'Required[WithInfoWrapValidatorFunction]r�r%rtNr�rGrHrIr�r�2s��
(�(�5�5��OrHr�c�J�eZdZUded<ded<ded<ded<d	ed
<ded<y
)�WrapValidatorFunctionSchemar�r�zRequired[WrapValidatorFunction]r�r�r�r%r�rr�r�r�Nr�rGrHrIr�r�;s$��
,�,�-�-� � �	�H��M��rHr�c�*�tdd|d�||||��S)ah
    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
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�r�r�r�r�r�s     rI�no_info_wrap_validator_functionr�Ds)��H�
�#��:����#�
�rHc�<�tdtd||��||||��S)a�
    Returns a schema which calls a function with a `validator` callable argument which can
    optionally be used to call inner validation with the function logic, this is much like the
    "onion" implementation of middleware in many popular web frameworks, an `info` argument is also passed, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(
        v: str,
        validator: core_schema.ValidatorFunctionWrapHandler,
        info: core_schema.ValidationInfo,
    ) -> str:
        return validator(input_value=v) + 'world'

    schema = core_schema.with_info_wrap_validator_function(
        function=fn, schema=core_schema.str_schema()
    )
    v = SchemaValidator(schema)
    assert v.validate_python('hello ') == 'hello world'
    ```

    Args:
        function: The validator function to call
        schema: The schema to validate the output of the validator function
        field_name: The name of the field this validators is applied to, if any
        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�r�r�r�r�r�s      rI�!with_info_wrap_validator_functionr�rs.��N�
��[�8�PZ�[����#�
�rHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�PlainValidatorFunctionSchemar�r�r�r�r%r�rr�r�r�Nr�rGrHrIr�r��s��
-�-�*�*�	�H��M��rHr�c�(�tdd|d�|||��S)a�
    Returns a schema that uses the provided function for validation, no `info` argument is passed, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str) -> str:
        assert 'hello' in v
        return v + 'world'

    schema = core_schema.no_info_plain_validator_function(function=fn)
    v = SchemaValidator(schema)
    assert v.validate_python('hello ') == 'hello world'
    ```

    Args:
        function: The validator function to call
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�r�r��r�r�r�r�r�r�)r�r�r�r�s    rI� no_info_plain_validator_functionr��s%��8�
�#��:���#��rHc�:�tdtd||��|||��S)a]
    Returns a schema that uses the provided function for validation, an `info` argument is passed, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert 'hello' in v
        return v + 'world'

    schema = core_schema.with_info_plain_validator_function(function=fn)
    v = SchemaValidator(schema)
    assert v.validate_python('hello ') == 'hello world'
    ```

    Args:
        function: The validator function to call
        field_name: The name of the field this validators is applied to, if any
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�r�r�r�r�)r�rtr�r�r�s     rI�"with_info_plain_validator_functionr��s*��<�
��[�8�PZ�[���#��rHc�r�eZdZUded<ded<ded<ded<d	ed
<ded<ded
<ded<ded<ded<y)�WithDefaultSchemazRequired[Literal['default']]r�r�r�r�defaultzCallable[[], Any]�default_factoryz#Literal['raise', 'omit', 'default']�on_errorr'r0r(r%r�r�r�r�Nr�rGrHrIr�r��s:��
&�&� � �
�L�&�&�1�1����L�	�H��M��rHr�)r�r�r�r0r(r�r�r�c�H�td||||||||��	}	|tur||	d<|	S)a~
    Returns a schema that adds a default value to the given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.with_default_schema(core_schema.str_schema(), default='hello')
    wrapper_schema = core_schema.typed_dict_schema(
        {'a': core_schema.typed_dict_field(schema)}
    )
    v = SchemaValidator(wrapper_schema)
    assert v.validate_python({}) == v.validate_python({'a': 'hello'})
    ```

    Args:
        schema: The schema to add a default value to
        default: The default value to use
        default_factory: A function that returns the default value to use
        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
    r�)	r�r�r�r�r0r(r�r�r�)r�r)
r�r�r�r�r0r(r�r�r�r�s
          rI�with_default_schemar�	sC��J	�
��'��)����#�
	�A��'�'���)���HrHc�J�eZdZUded<ded<ded<ded<d	ed
<ded<y
)�NullableSchemazRequired[Literal['nullable']]r�r�r�r'r(r%r�rr�r�r�Nr�rGrHrIr�r�9	s#��
'�'� � ��L�	�H��M��rHr�r�c�$�td|||||��S)a�
    Returns a schema that matches a nullable value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.nullable_schema(core_schema.str_schema())
    v = SchemaValidator(schema)
    assert v.validate_python(None) is None
    ```

    Args:
        schema: The schema to wrap
        strict: Whether the underlying schema should be validated with strict mode
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �nullable)r�r�r(r�r�r�r�)r�r(r�r�r�s     rI�nullable_schemar�B	s��4�
��v�3��an��rHc�|�eZdZUded<ded<ded<ded<ded	<d
ed<ded
<ded<ded<ded<ded<y)�UnionSchemazRequired[Literal['union']]r�z9Required[List[Union[CoreSchema, Tuple[CoreSchema, str]]]]�choicesr'�
auto_collapser%�custom_error_type�custom_error_message�!Dict[str, Union[str, int, float]]�custom_error_contextz!Literal['smart', 'left_to_right']rYr(r�rr�r�r�Nr�rGrHrIr�r�a	sA��
$�$�
F�F�������;�;�
+�+��L�	�H��M��rHr�)	r�r�r�r�rYr(r�r�r�c	
�.�td||||||||||	��S)a�
    Returns a schema that matches a union value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()])
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello'
    assert v.validate_python(1) == 1
    ```

    Args:
        choices: The schemas to match. If a tuple, the second item is used as the label for the case.
        auto_collapse: whether to automatically collapse unions with one element to the inner validator, default true
        custom_error_type: The custom error type to use if the validation fails
        custom_error_message: The custom error message to use if the validation fails
        custom_error_context: The custom error context to use if the validation fails
        mode: How to select which choice to return
            * `smart` (default) will try to return the choice which is the closest match to the input value
            * `left_to_right` will return the first choice in `choices` which succeeds validation
        strict: Whether the underlying schemas should be validated with strict mode
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �union)r�r�r�r�r�r�rYr(r�r�r�r�)
r�r�r�r�r�rYr(r�r�r�s
          rI�union_schemar�p	s3��N�
��#�+�1�1�
����#��rHc�|�eZdZUded<ded<ded<ded<ded	<d
ed<ded
<ded<ded<ded<ded<y)�TaggedUnionSchemaz!Required[Literal['tagged-union']]r�z$Required[Dict[Hashable, CoreSchema]]r�zcRequired[Union[str, List[Union[str, int]], List[List[Union[str, int]]], Callable[[Any], Hashable]]]�
discriminatorr%r�r�r�r�r'r(r,r�rr�r�r�Nr�rGrHrIr�r��	sA��
+�+�
1�1�v�v�����;�;��L���	�H��M��rHr�)r�r�r�r(r,r�r�r�c
�.�td||||||||||	��S)a�

    Returns a schema that matches a tagged union value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    apple_schema = core_schema.typed_dict_schema(
        {
            'foo': core_schema.typed_dict_field(core_schema.str_schema()),
            'bar': core_schema.typed_dict_field(core_schema.int_schema()),
        }
    )
    banana_schema = core_schema.typed_dict_schema(
        {
            'foo': core_schema.typed_dict_field(core_schema.str_schema()),
            'spam': core_schema.typed_dict_field(
                core_schema.list_schema(items_schema=core_schema.int_schema())
            ),
        }
    )
    schema = core_schema.tagged_union_schema(
        choices={
            'apple': apple_schema,
            'banana': banana_schema,
        },
        discriminator='foo',
    )
    v = SchemaValidator(schema)
    assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123}
    assert v.validate_python({'foo': 'banana', 'spam': [1, 2, 3]}) == {
        'foo': 'banana',
        'spam': [1, 2, 3],
    }
    ```

    Args:
        choices: The schemas to match
            When retrieving a schema from `choices` using the discriminator value, if the value is a str,
            it should be fed back into the `choices` map until a schema is obtained
            (This approach is to prevent multiple ownership of a single schema in Rust)
        discriminator: The discriminator to use to determine the schema to use
            * If `discriminator` is a str, it is the name of the attribute to use as the discriminator
            * If `discriminator` is a list of int/str, it should be used as a "path" to access the discriminator
            * If `discriminator` is a list of lists, each inner list is a path, and the first path that exists is used
            * If `discriminator` is a callable, it should return the discriminator when called on the value to validate;
              the callable can return `None` to indicate that there is no matching discriminator present on the input
        custom_error_type: The custom error type to use if the validation fails
        custom_error_message: The custom error message to use if the validation fails
        custom_error_context: The custom error context to use if the validation fails
        strict: Whether the underlying schemas should be validated with strict mode
        from_attributes: Whether to use the attributes of the object to retrieve the discriminator value
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �tagged-union)r�r�r�r�r�r�r(r,r�r�r�r�)
r�r�r�r�r�r(r,r�r�r�s
          rI�tagged_union_schemar��	s3��H�
��#�+�1�1��'���#��rHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�ChainSchemazRequired[Literal['chain']]r�rk�stepsr%r�rr�r�r�Nr�rGrHrIr�r�
s��
$�$�%�%�	�H��M��rHr�c�"�td||||��S)a_
    Returns a schema that chains the provided validation schemas, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert 'hello' in v
        return v + ' world'

    fn_schema = core_schema.with_info_plain_validator_function(function=fn)
    schema = core_schema.chain_schema(
        [fn_schema, fn_schema, fn_schema, core_schema.str_schema()]
    )
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello world world world'
    ```

    Args:
        steps: The schemas to chain
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �chain)r�r�r�r�r�r�)r�r�r�r�s    rI�chain_schemar�
s��6�w�e��x�_l�m�mrHc�T�eZdZUded<ded<ded<ded<ded	<d
ed<ded
<y)�LaxOrStrictSchemaz"Required[Literal['lax-or-strict']]r�r��
lax_schema�
strict_schemar'r(r%r�rr�r�r�Nr�rGrHrIr�r�-
s)��
,�,�$�$�'�'��L�	�H��M��rHr�c	�&�td||||||��S)a�
    Returns a schema that uses the lax or strict schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert 'hello' in v
        return v + ' world'

    lax_schema = core_schema.int_schema(strict=False)
    strict_schema = core_schema.int_schema(strict=True)

    schema = core_schema.lax_or_strict_schema(
        lax_schema=lax_schema, strict_schema=strict_schema, strict=True
    )
    v = SchemaValidator(schema)
    assert v.validate_python(123) == 123

    schema = core_schema.lax_or_strict_schema(
        lax_schema=lax_schema, strict_schema=strict_schema, strict=False
    )
    v = SchemaValidator(schema)
    assert v.validate_python('123') == 123
    ```

    Args:
        lax_schema: The lax schema to use
        strict_schema: The strict schema to use
        strict: Whether the strict schema should be used
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �
lax-or-strict)r�r�r�r(r�r�r�r�)r�r�r(r�r�r�s      rI�lax_or_strict_schemar�7
s'��V�
��#����#��rHc�J�eZdZUded<ded<ded<ded<ded	<d
ed<y)
�JsonOrPythonSchemaz#Required[Literal['json-or-python']]r�r��json_schema�
python_schemar%r�rr�r�r�Nr�rGrHrIr�r�m
s$��
-�-�%�%�'�'�	�H��M��rHr�c�$�td|||||��S)a�
    Returns a schema that uses the Json or Python schema depending on the input:

    ```py
    from pydantic_core import SchemaValidator, ValidationError, core_schema

    v = SchemaValidator(
        core_schema.json_or_python_schema(
            json_schema=core_schema.int_schema(),
            python_schema=core_schema.int_schema(strict=True),
        )
    )

    assert v.validate_json('"123"') == 123

    try:
        v.validate_python('123')
    except ValidationError:
        pass
    else:
        raise AssertionError('Validation should have failed')
    ```

    Args:
        json_schema: The schema to use for Json inputs
        python_schema: The schema to use for Python inputs
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �json-or-python)r�r�r�r�r�r�r�)r�r�r�r�r�s     rI�json_or_python_schemar�v
s$��L�
��#���#�
�rHc�T�eZdZUded<ded<ded<ded<d	ed
<ded<ded
<y)�TypedDictFieldz%Required[Literal['typed-dict-field']]r�r�r�r'�required�>Union[str, List[Union[str, int]], List[List[Union[str, int]]]]�validation_aliasr%�serialization_alias�serialization_excluderr�Nr�rGrHrIr�r��
s*��
/�/� � ��N�T�T������MrHr�)r�r�r�r�r�c	�&�td||||||��S)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
        validation_alias: The alias(es) to use to find the field in the validation data
        serialization_alias: The alias to use as a key when serializing
        serialization_exclude: Whether to exclude the field when serializing
        metadata: Any other information you want to include with the schema, not used by pydantic-core
    �typed-dict-field)r�r�r�r�r�r�r�r�)r�r�r�r�r�r�s      rI�typed_dict_fieldr��
s&��4�
���)�/�3���rHc��eZdZUded<ded<ded<ded<d	ed
<ded<ded
<ded<ded<ded<ded<ded<y)�TypedDictSchemazRequired[Literal['typed-dict']]r�z#Required[Dict[str, TypedDictField]]�fields�List[ComputedField]�computed_fieldsr'r(r�rar)�extra_behaviorrJr1r%r�rr�r�r�r$rzNr�rGrHrIr�r��
sF��
)�)�/�/�(�(��L���!�!��K���	�H��M����rHr�)
r�r(rar�rJr1r�r�r�rzc
�0�td||||||||||	|
��S)aX
    Returns a schema that matches a typed dict, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    wrapper_schema = core_schema.typed_dict_schema(
        {'a': core_schema.typed_dict_field(core_schema.str_schema())}
    )
    v = SchemaValidator(wrapper_schema)
    assert v.validate_python({'a': 'hello'}) == {'a': 'hello'}
    ```

    Args:
        fields: The fields to use for the typed dict
        computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
        strict: Whether the typed dict is strict
        extras_schema: The extra validator to use for the typed dict
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        extra_behavior: The extra behavior to use for the typed dict
        total: Whether the typed dict is total
        populate_by_name: Whether the typed dict should populate by name
        serialization: Custom serialization schema
    �
typed-dict)r�r�r�r(rar�rJr1r�r�r�rzr�)r�r�r(rar�rJr1r�r�r�rzs           rI�typed_dict_schemar��
s6��N�
��'��#�%��)���#��
�
rHc�T�eZdZUded<ded<ded<ded<d	ed
<d	ed<ded
<y)�
ModelFieldz Required[Literal['model-field']]r�r�r�r�r�r%r�r'r��frozenrr�Nr�rGrHrIr�r�s*��
*�*� � �T�T������L��MrHr�)r�r�r�rr�c	�&�td||||||��S)aq
    Returns a schema for a model field, e.g.:

    ```py
    from pydantic_core import core_schema

    field = core_schema.model_field(schema=core_schema.int_schema())
    ```

    Args:
        schema: The schema to use for the field
        validation_alias: The alias(es) to use to find the field in the validation data
        serialization_alias: The alias to use as a key when serializing
        serialization_exclude: Whether to exclude the field when serializing
        frozen: Whether the field is frozen
        metadata: Any other information you want to include with the schema, not used by pydantic-core
    �model-field)r�r�r�r�r�rr�r�)r�r�r�r�rr�s      rI�model_fieldr&s&��4�
��)�/�3����rHc��eZdZUded<ded<ded<ded<d	ed
<ded<d
ed<d	ed<d	ed<ded<ded<ded<y)�ModelFieldsSchemaz!Required[Literal['model-fields']]r�zRequired[Dict[str, ModelField]]r�r%�
model_namer�r�r'r(r�rar)r�r1r,r�rr�r�r�Nr�rGrHrIrrKsF��
+�+�+�+��O�(�(��L���!�!�����	�H��M��rHr)
rr�r(rar�r1r,r�r�r�c
�0�td||||||||||	|
��S)a�
    Returns a schema that matches a typed dict, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    wrapper_schema = core_schema.model_fields_schema(
        {'a': core_schema.model_field(core_schema.str_schema())}
    )
    v = SchemaValidator(wrapper_schema)
    print(v.validate_python({'a': 'hello'}))
    #> ({'a': 'hello'}, None, {'a'})
    ```

    Args:
        fields: The fields to use for the typed dict
        model_name: The name of the model, used for error messages, defaults to "Model"
        computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
        strict: Whether the typed dict is strict
        extras_schema: The extra validator to use for the typed dict
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        extra_behavior: The extra behavior to use for the typed dict
        populate_by_name: Whether the typed dict should populate by name
        from_attributes: Whether the typed dict should be populated from attributes
        serialization: Custom serialization schema
    �model-fields)r�r�rr�r(rar�r1r,r�r�r�r�)r�rr�r(rar�r1r,r�r�r�s           rI�model_fields_schemar	[s6��R�
���'��#�%�)�'���#�
�
rHc��eZdZUded<ded<ded<ded<ded	<d
ed<ded
<ded<ded<ded<ded<d
ed<ded<ded<y)�ModelSchemar�r�r�r�r�r�r'�custom_init�
root_modelr%�	post_initr.r/r(rr)r�r$rzr�rr�r�r�Nr�rGrHrIrr�sQ��
$�$�	�� � ������N�J�J��L��L�!�!���	�H��M��rHr)rr
rr/r(rr�rzr�r�r�c�4�td||||||||||	|
||��S)ak
    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
        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�)r�r�r�rr
rr/r(rr�rzr�r�r�r�)
r�r�rr
rr/r(rr�rzr�r�r�s
             rI�model_schemar�s<��~�
������1���%����#��rHc�|�eZdZUded<ded<ded<ded<ded	<ded
<ded<ded
<ded<ded<ded<y)�DataclassFieldz$Required[Literal['dataclass-field']]r�r��namer�r�r'�kw_only�init�	init_onlyrr�r�r%r�r�rr�Nr�rGrHrIrr�s?��
.�.�
�� � �
�M�
�J��O��L�T�T������MrHr)rrrr�r�r�r�rc
�.�td||||||||||	��S)a�
    Returns a schema for a dataclass field, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    field = core_schema.dataclass_field(
        name='a', schema=core_schema.str_schema(), kw_only=False
    )
    schema = core_schema.dataclass_args_schema('Foobar', [field])
    v = SchemaValidator(schema)
    assert v.validate_python({'a': 'hello'}) == ({'a': 'hello'}, None)
    ```

    Args:
        name: The name to use for the argument parameter
        schema: The schema to use for the argument parameter
        kw_only: Whether the field can be set with a positional argument as well as a keyword argument
        init: Whether the field should be validated during initialization
        init_only: Whether the field should be omitted  from `__dict__` and passed to `__post_init__`
        validation_alias: The alias(es) to use to find the field in the validation data
        serialization_alias: The alias to use as a key when serializing
        serialization_exclude: Whether to exclude the field when serializing
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        frozen: Whether the field is frozen
    �dataclass-field)r�rr�rrrr�r�r�r�rr�)
rr�rrrr�r�r�r�rs
          rI�dataclass_fieldrs3��N�
�
���
��)�/�3����rHc�r�eZdZUded<ded<ded<ded<d	ed
<d	ed<ded
<ded<ded<ded<y)�DataclassArgsSchemaz#Required[Literal['dataclass-args']]r�r��dataclass_namezRequired[List[DataclassField]]r�r�r�r'r1�collect_init_onlyr%r�rr�r�r�r)r�Nr�rGrHrIrr:s<��
-�-�!�!�*�*�(�(�����	�H��M���!�!rHr)r�r1rr�r�r�r�c�,�td|||||||||��
S)a�
    Returns a schema for validating dataclass arguments, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    field_a = core_schema.dataclass_field(
        name='a', schema=core_schema.str_schema(), kw_only=False
    )
    field_b = core_schema.dataclass_field(
        name='b', schema=core_schema.bool_schema(), kw_only=False
    )
    schema = core_schema.dataclass_args_schema('Foobar', [field_a, field_b])
    v = SchemaValidator(schema)
    assert v.validate_python({'a': 'hello', 'b': True}) == ({'a': 'hello', 'b': True}, None)
    ```

    Args:
        dataclass_name: The name of the dataclass being validated
        fields: The fields to use for the dataclass
        computed_fields: Computed fields to use when serializing the dataclass
        populate_by_name: Whether to populate by name
        collect_init_only: Whether to collect init only fields into a dict to pass to `__post_init__`
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
        extra_behavior: How to handle extra fields
    �dataclass-args)
r�rr�r�r1rr�r�r�r�r�)	rr�r�r1rr�r�r�r�s	         rI�dataclass_args_schemar Gs0��P�
�%��'�)�+���#�%��rHc��eZdZUded<ded<ded<ded<d	ed
<ded<d
ed<ded<ded<d	ed<ded<ded<ded<ded<y)�DataclassSchemazRequired[Literal['dataclass']]r�r�r�r�r�zRequired[List[str]]r�r%�cls_namer'rr.r/r(rr�rr�r�r��slotsr$rzNr�rGrHrIr"r"}sO��
(�(�	�� � ����M��O�J�J��L��L�	�H��M����K��rHr")
r#rr/r(r�r�r�rr$rzc
�4�td||||||||||	|
||��S)a9
    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
        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)r�r�r�r#r�rr/r(r�r�r�rr$rzr�)
r�r�r�r#rr/r(r�r�r�rr$rzs
             rI�dataclass_schemar'�s<��J�
������1����#�����rHc�6�eZdZUded<ded<ded<ded<y	)
�ArgumentsParameterr�rr�r�zCLiteral['positional_only', 'positional_or_keyword', 'keyword_only']rYr�r�Nr�rGrHrIr)r)�s��
�� � �
M�M�I�IrHr))rYr�c� �t||||��S)a�
    Returns a schema that matches an argument parameter, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param = core_schema.arguments_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    schema = core_schema.arguments_schema([param])
    v = SchemaValidator(schema)
    assert v.validate_python(('hello',)) == (('hello',), {})
    ```

    Args:
        name: The name to use for the argument parameter
        schema: The schema to use for the argument parameter
        mode: The mode to use for the argument parameter
        alias: The alias to use for the argument parameter
    �rr�rYr�r�r+s    rI�arguments_parameterr,�s��6�t�F��U�K�KrHc�^�eZdZUded<ded<ded<ded<ded	<d
ed<ded
<ded<y)�ArgumentsSchemazRequired[Literal['arguments']]r�z"Required[List[ArgumentsParameter]]�arguments_schemar'r1r��var_args_schema�var_kwargs_schemar%r�rr�r�r�Nr�rGrHrIr.r.�s0��
(�(�8�8�����!�!�	�H��M��rHr.)r1r0r1r�r�r�c
�(�td|||||||��S)a]
    Returns a schema that matches an arguments schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param_a = core_schema.arguments_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    param_b = core_schema.arguments_parameter(
        name='b', schema=core_schema.bool_schema(), mode='positional_only'
    )
    schema = core_schema.arguments_schema([param_a, param_b])
    v = SchemaValidator(schema)
    assert v.validate_python(('hello', True)) == (('hello', True), {})
    ```

    Args:
        arguments: The arguments to use for the arguments schema
        populate_by_name: Whether to populate by name
        var_args_schema: The variable args schema to use for the arguments schema
        var_kwargs_schema: The variable kwargs schema to use for the arguments schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �	arguments)r�r/r1r0r1r�r�r�r�)r3r1r0r1r�r�r�s       rIr/r/�s*��H�
�"�)�'�+���#�	�	rHc�^�eZdZUded<ded<ded<ded<d	ed
<ded<ded
<ded<y)�
CallSchemazRequired[Literal['call']]r�r�r/zRequired[Callable[..., Any]]r�r%�
function_namer�r�r�rr�r�r�Nr�rGrHrIr5r5%
s0��
#�#�*�*�*�*�����	�H��M��rHr5)r6r�r�r�r�c
�(�td|||||||��S)a-
    Returns a schema that matches an arguments schema, then calls a function, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param_a = core_schema.arguments_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    param_b = core_schema.arguments_parameter(
        name='b', schema=core_schema.bool_schema(), mode='positional_only'
    )
    args_schema = core_schema.arguments_schema([param_a, param_b])

    schema = core_schema.call_schema(
        arguments=args_schema,
        function=lambda a, b: a + str(not b),
        return_schema=core_schema.str_schema(),
    )
    v = SchemaValidator(schema)
    assert v.validate_python((('hello', True))) == 'helloFalse'
    ```

    Args:
        arguments: The arguments to use for the arguments schema
        function: The function to use for the call schema
        function_name: The function name to use for the call schema, if not provided `function.__name__` is used
        return_schema: The return schema to use for the call schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �call)r�r/r�r6r�r�r�r�r�)r3r�r6r�r�r�r�s       rI�call_schemar90
s*��T�
�"��#�#���#�	�	rHc�^�eZdZUded<ded<ded<ded<d	ed
<ded<ded
<ded<y)�CustomErrorSchemaz!Required[Literal['custom-error']]r�r�r�r�r�r%r�r�r�r�rr�r�r�Nr�rGrHrIr;r;f
s0��
+�+� � �$�$���;�;�	�H��M��rHr;)r�r�r�r�r�c
�(�td|||||||��S)a�
    Returns a schema that matches a custom error value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.custom_error_schema(
        schema=core_schema.int_schema(),
        custom_error_type='MyError',
        custom_error_message='Error msg',
    )
    v = SchemaValidator(schema)
    v.validate_python(1)
    ```

    Args:
        schema: The schema to use for the custom error schema
        custom_error_type: The custom error type to use for the custom error schema
        custom_error_message: The custom error message to use for the custom error schema
        custom_error_context: The custom error context to use for the custom error schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �custom-error)r�r�r�r�r�r�r�r�r�)r�r�r�r�r�r�r�s       rI�custom_error_schemar>q
s*��D�
��+�1�1���#�	�	rHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�
JsonSchemazRequired[Literal['json']]r�r�r�r%r�rr�r�r�Nr�rGrHrIr@r@�
s��
#�#���	�H��M��rHr@c�"�td||||��S)a�
    Returns a schema that matches a JSON value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    dict_schema = core_schema.model_fields_schema(
        {
            'field_a': core_schema.model_field(core_schema.str_schema()),
            'field_b': core_schema.model_field(core_schema.bool_schema()),
        },
    )

    class MyModel:
        __slots__ = (
            '__dict__',
            '__pydantic_fields_set__',
            '__pydantic_extra__',
            '__pydantic_private__',
        )
        field_a: str
        field_b: bool

    json_schema = core_schema.json_schema(schema=dict_schema)
    schema = core_schema.model_schema(cls=MyModel, schema=json_schema)
    v = SchemaValidator(schema)
    m = v.validate_python('{"field_a": "hello", "field_b": true}')
    assert isinstance(m, MyModel)
    ```

    Args:
        schema: The schema to use for the JSON schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�)r�r�r�r�r�r�)r�r�r�r�s    rIr�r��
s��V�v�f�#��`m�n�nrHc�|�eZdZUded<ded<ded<ded<d	ed
<ded<d	ed<ded
<d	ed<ded<ded<y)�	UrlSchemazRequired[Literal['url']]r�r2r�	List[str]�allowed_schemesr'�
host_requiredr%�default_host�default_port�default_pathr(r�rr�r�r�Nr�rGrHrIrCrC�
s@��
"�"��O������������L�	�H��M��rHrC�
rrErFrGrHrIr(r�r�r�c

�.�td||||||||||	��S)a�
    Returns a schema that matches a URL value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.url_schema()
    v = SchemaValidator(schema)
    print(v.validate_python('https://example.com'))
    #> https://example.com/
    ```

    Args:
        max_length: The maximum length of the URL
        allowed_schemes: The allowed URL schemes
        host_required: Whether the URL must have a host
        default_host: The default host to use if the URL does not have a host
        default_port: The default port to use if the URL does not have a port
        default_path: The default path to use if the URL does not have a path
        strict: Whether to use strict URL parsing
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r��r�rrErFrGrHrIr(r�r�r�r�rJs
          rI�
url_schemarM�
s3��J�
��'�#�!�!�!����#��rHc�|�eZdZUded<ded<ded<ded<d	ed
<ded<d	ed<ded
<d	ed<ded<ded<y)�MultiHostUrlSchemaz#Required[Literal['multi-host-url']]r�r2rrDrEr'rFr%rGrHrIr(r�rr�r�r�Nr�rGrHrIrOrOs@��
-�-��O������������L�	�H��M��rHrOc

�.�td||||||||||	��S)a&
    Returns a schema that matches a URL value with possibly multiple hosts, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.multi_host_url_schema()
    v = SchemaValidator(schema)
    print(v.validate_python('redis://localhost,0.0.0.0,127.0.0.1'))
    #> redis://localhost,0.0.0.0,127.0.0.1
    ```

    Args:
        max_length: The maximum length of the URL
        allowed_schemes: The allowed URL schemes
        host_required: Whether the URL must have a host
        default_host: The default host to use if the URL does not have a host
        default_port: The default port to use if the URL does not have a port
        default_path: The default path to use if the URL does not have a path
        strict: Whether to use strict URL parsing
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    r�rLr�rJs
          rI�multi_host_url_schemarQ%s3��J�
��'�#�!�!�!����#��rHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�DefinitionsSchemaz Required[Literal['definitions']]r�r�r�rk�definitionsrr�r�r�Nr�rGrHrIrSrSYs��
*�*� � �+�+��M��rHrSc��td||��S)ab
    Build a schema that contains both an inner schema and a list of definitions which can be used
    within the inner schema.

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.definitions_schema(
        core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
        [core_schema.int_schema(ref='foobar')],
    )
    v = SchemaValidator(schema)
    assert v.validate_python([1, 2, '3']) == [1, 2, 3]
    ```

    Args:
        schema: The inner schema
        definitions: List of definitions which can be referenced within inner schema
    rT)r�r�rT)rS)r�rTs  rI�definitions_schemarVas��(�-��K�X�XrHc�@�eZdZUded<ded<ded<ded<d	ed
<y)�DefinitionReferenceSchemaz#Required[Literal['definition-ref']]r�r��
schema_refr%r�rr�r�r�Nr�rGrHrIrXrXxs��
-�-���	�H��M��rHrXc�"�td||||��S)aw
    Returns a schema that points to a schema stored in "definitions", this is useful for nested recursive
    models and also when you want to define validators separately from the main schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema_definition = core_schema.definition_reference_schema('list-schema')
    schema = core_schema.definitions_schema(
        schema=schema_definition,
        definitions=[
            core_schema.list_schema(items_schema=schema_definition, ref='list-schema'),
        ],
    )
    v = SchemaValidator(schema)
    assert v.validate_python([()]) == [[]]
    ```

    Args:
        schema_ref: The schema ref to use for the definition reference schema
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    �definition-ref)r�rYr�r�r�r�)rYr�r�r�s    rI�definition_reference_schemar\�s��4�
�*�#��`m��rH)0r�r�r'r2r�r�r%r�rrrrr.r7r>rErJr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�rr&r3r8r=r�r�r�rTr[r�)rrr�r�)`�no_such_attribute�json_invalid�	json_type�recursion_loopr5�frozen_field�frozen_instance�extra_forbidden�invalid_key�get_attribute_error�
model_type�model_attributes_type�dataclass_type�dataclass_exact_type�
none_required�greater_than�greater_than_equal�	less_than�less_than_equalr��
finite_number�	too_short�too_long�
iterable_type�iteration_error�string_type�string_sub_type�string_unicode�string_too_short�string_too_long�string_pattern_mismatchr7�	dict_type�mapping_type�	list_type�
tuple_type�set_type�	bool_type�bool_parsing�int_type�int_parsing�int_parsing_size�int_from_float�
float_type�
float_parsing�
bytes_type�bytes_too_short�bytes_too_long�value_error�assertion_error�
literal_error�	date_type�date_parsing�date_from_datetime_parsing�date_from_datetime_inexact�	date_past�date_future�	time_type�time_parsing�
datetime_type�datetime_parsing�datetime_object_invalid�datetime_from_date_parsing�
datetime_past�datetime_future�timezone_naive�timezone_aware�timezone_offset�time_delta_type�time_delta_parsing�frozen_set_type�is_instance_of�is_subclass_of�
callable_type�union_tag_invalid�union_tag_not_found�arguments_type�missing_argument�unexpected_keyword_argument�missing_keyword_only_argument�unexpected_positional_argument� missing_positional_only_argument�multiple_argument_values�url_type�url_parsing�url_syntax_violation�url_too_long�
url_scheme�	uuid_type�uuid_parsing�uuid_version�decimal_type�decimal_parsing�decimal_max_digits�decimal_max_places�decimal_whole_digitsc�\�|j�D��cic]\}}|��	||��
c}}Scc}}wrO)�items)�kwargs�k�vs   rIr�r�vs,��#�\�\�^�=�^�T�Q��q�}�A�q�D�^�=�=��=s�
(�(�c`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.c�T�tjdt�t||fd|i|��S)Nr�rt��warnings�warn�DeprecationWarningr��r�rtr�r�s    rI�field_before_validator_functionr�s.���M�M�m���/�x��a�J�a�Z`�a�arH�e`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.c�L�tjdt�t|i|��S)Nr�r���argsr�s  rI�!general_before_validator_functionr��s&���M�M�o���/��?��?�?rH�a`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.c�T�tjdt�t||fd|i|��S)Nr�rt�r�r�r�r�r�s    rI�field_after_validator_functionr��s.���M�M�k���.�h��`�:�`�Y_�`�`rH�c`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.c�L�tjdt�t|i|��S)Nr�r�r�s  rI� general_after_validator_functionr���&���M�M�m���.�t�>�v�>�>rH�_`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.c�T�tjdt�t||fd|i|��S)Nr�rt�r�r�r�r�r�s    rI�field_wrap_validator_functionr��s0��
�M�M�i���-�X�v�_�*�_�X^�_�_rH�a`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.c�L�tjdt�t|i|��S)Nr�r�r�s  rI�general_wrap_validator_functionr��s&���M�M�k���-�d�=�f�=�=rH�a`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.c�R�tjdt�t|fd|i|��S)Nr�rt�r�r�r�r�)r�rtr�s   rI�field_plain_validator_functionr��s,���M�M�k���.�h�X�:�X�QW�X�XrH�c`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.c�L�tjdt�t|i|��S)Nr�r�r�s  rI� general_plain_validator_functionr��r�rH)�FieldValidationInfo�FieldValidatorFunction�GeneralValidatorFunction�FieldWrapValidatorFunctionc��tj|�}|�td|�d���ddl}d|�d|j�d�}|j
|td��|S)	Nz)module 'pydantic_core' has no attribute '�'r�`z` is deprecated, use `z
` instead.�)�
stacklevel)�_deprecated_import_lookup�get�AttributeErrorr�rBr�r�)�	attr_name�new_attrr��msgs    rI�__getattr__r��se��(�,�,�Y�7�H����H���ST�U�V�V���)��2�8�3D�3D�2E�Z�P����
�
�c�-�!�<��rH)r��ExpectedSerializationTypesrmr�)r��SerializerFunctionr��bool | Noner�r�r��CoreSchema | Noner�r�rmr�)r��WrapSerializerFunctionr�r�r�r�r�r�r�r�r�r�rmr�)r�r%r�r�rmr�)r�r�rmr�)r��	Type[Any]r�r�rmr�)
r�r%r�r�r�r�r�rrmr�)r�r�r�rr��SerSchema | Nonermr�)r�r�r�rr�r�rmr�)NNNN)
r(r�r�r�r�rr�r�rmr�)r��
int | Noner�r�r�r�r�r�r�r�r(r�r�r�r�rr�r�rmr�)r8r�r��float | Noner�r�r�r�r�r�r�r�r(r�r�r�r�rr�r�rmr�)r8r'r��Decimal | Noner�r�r�r�r�r�r�r�r�r�r�r�r(r�r�r�r�rr�r�rmr�)r�zstr | Pattern[str] | Nonerr�rr�rr�rr�rr�r@z)Literal['rust-regex', 'python-re'] | Noner(r�r>r�r�r�r�rr�r�rmr�)rr�rr�r(r�r�r�r�rr�r�rmr	)r(r�r��date | Noner�r�r�r�r�r�r� Literal['past', 'future'] | Nonerr�r�r�r�rr�r�rmr)r(r�r��time | Noner�r�r�r�r�r�r�&Literal['aware', 'naive'] | int | Nonerrr�r�r�rr�r�rmr)r(r�r��datetime | Noner�rr�rr�rrr�rr�rr�rrr�r�r�rr�r�rmr )r(r�r��timedelta | Noner�rr�rr�rrrr�r�r�rr�r�rmr%)
r,�	list[Any]r�r�r�rr�r�rmr*)r�rr3rr4z%Literal['str', 'int', 'float'] | Noner5zCallable[[Any], Any] | Noner(r�r�r�r�rr�r�rmr1)r�rr<r�r�r�r�rr�r�rmr;)r�r�r<r�r�r�r�rr�r�rmr;)r�r�r�rr�r�rmrH)rNzLiteral[1, 3, 4, 5] | Noner(r�r�r�r�rr�r�rmrM)rR�Set[int] | NonerUrrmrSrO)rZr�rr�rr�r[r�r(r�r�r�r�rr��IncExSeqOrElseSerSchema | NonermrY)rZ�list[CoreSchema]rar�r(r�r�r�r�rr�rrmrb)rZr�rr�rr�r(r�r�r�r�rr�rrmrb)rZrrdr�rr�rr�r[r�r(r�r�r�r�rr�rrmrb)rZr�rr�rr�r[r�r(r�r�r�r�rr�r�rmrn)rZr�rr�rr�r[r�r(r�r�r�r�rr�r�rmrr)rZr�rr�rr�r�r�r�rr�rrmrv)rR�IncExDict | NonerUrrmrz)NN)r�r�r�r�rr�rr�r(r�r�r�r�rr�r�rmr)r�r�r�r�r�r�r�rr�r�rmr�)r��WithInfoValidatorFunctionr�r�rtr�r�r�r�rr�r�rmr�)r�r�r�r�r�r�r�rr�r�rmr�)r�rr�r�rtr�r�r�r�rr�r�rmr�)r�r�r�r�r�r�r�rr�r�rmr�)r��WithInfoWrapValidatorFunctionr�r�rtr�r�r�r�rr�r�rmr�)
r�r�r�r�r�rr�r�rmr�)r�rrtr�r�r�r�rr�r�rmr�)r�r�r�rr�zCallable[[], Any] | Noner�z*Literal['raise', 'omit', 'default'] | Noner0r�r(r�r�r�r�rr�r�rmr�)r�r�r(r�r�r�r�rr�r�rmr�)r�z)list[CoreSchema | tuple[CoreSchema, str]]r�r�r�r�r�r�r�zdict[str, str | int] | NonerYz(Literal['smart', 'left_to_right'] | Noner(r�r�r�r�rr�r�rmr�)r�zDict[Any, CoreSchema]r�zDstr | list[str | int] | list[list[str | int]] | Callable[[Any], Any]r�r�r�r�r�z#dict[str, int | str | float] | Noner(r�r,r�r�r�r�rr�r�rmr�)
r�rr�r�r�rr�r�rmr�)r�r�r�r�r(r�r�r�r�rr�r�rmr�)r�r�r�r�r�r�r�rr�r�rmr�)r�r�r�r�r��4str | list[str | int] | list[list[str | int]] | Noner�r�r�r�r�rrmr�)r�zDict[str, TypedDictField]r��list[ComputedField] | Noner(r�rar�r��ExtraBehavior | NonerJr�r1r�r�r�r�rr�r�rzrrmr�)r�r�r�r	r�r�r�r�rr�r�rrmr�)r�zDict[str, ModelField]rr�r�r
r(r�rar�r�rr1r�r,r�r�r�r�rr�r�rmr)r�r�r�r�rr�r
r�rr�r/�7Literal['always', 'never', 'subclass-instances'] | Noner(r�rr�r�rrzrr�r�r�rr�r�rmr)rr%r�r�rr�rr�rr�r�r	r�r�r�r�r�rrr�rmr)rr%r�zlist[DataclassField]r�zList[ComputedField] | Noner1r�rr�r�r�r�rr�r�r�rrmr)r�r�r�r�r�rDr#r�rr�r/rr(r�r�r�r�rr�r�rr�r$r�rzrrmr")
rr%r�r�rYzJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Noner�r	rmr))r3zlist[ArgumentsParameter]r1r�r0r�r1r�r�r�r�rr�r�rmr.)r3r�r�zCallable[..., Any]r6r�r�r�r�r�r�rr�r�rmr5)r�r�r�r%r�r�r�zdict[str, Any] | Noner�r�r�rr�r�rmr;)
r�r�r�r�r�rr�r�rmr@)rr�rE�list[str] | NonerFr�rGr�rHr�rIr�r(r�r�r�r�rr�r�rmrC)rr�rEr
rFr�rGr�rHr�rIr�r(r�r�r�r�rr�r�rmrO)r�r�rTrrmrS)NNN)
rYr%r�r�r�rr�r�rmrX)r�rrmr)r�rrtr%r�r�)r�rrtr%r�r�)r�rrtr%)r�r%rm�object)�rE�
__future__r�_annotations�sysr��collections.abcrrrrrr�r	�typingr
rrr
rrrrrrr�typing_extensionsr�version_inforrrrr�
pydantic_corer�ImportErrorrr)r$rKrFrMrrrvr�r�r��$GeneralPlainNoInfoSerializerFunction�"GeneralPlainInfoSerializerFunction�"FieldPlainNoInfoSerializerFunction� FieldPlainInfoSerializerFunctionr�r�r�r�r��#GeneralWrapNoInfoSerializerFunction�!GeneralWrapInfoSerializerFunction�!FieldWrapNoInfoSerializerFunction�FieldWrapInfoSerializerFunctionr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr	rrrrrr r#r%r(r*r/r1r8�JsonTyper;rArCrFrHrKrMrQrSrWr\rYr`rgrirbrfrnrprrrtrvrxr2r%r{rzr}r�rr�r�r�rr��ValidationFunctionr�r�r�r�r�r�r�r�r�r�rr��WrapValidatorFunctionr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrr	rrrrrr r"r'r)r,r.r/r5r9r;r>r@r�rCrMrOrQrSrVrXr\�MYPYr��CoreSchemaType�CoreSchemaFieldType�	ErrorTyper�r�r�r�r�r�r�r�r�r�r�r�rGrHrI�<module>r's#���
3�
��#�4�4��g�g�g�g�(����g��+� ����g��?�?�4�4����f��)���/�
%�3�
�3�4�
�D?��%�D?�NL�	�9�K�##��##�L%�.��%�
�X��D%����2/�i�u�/�&�(0���s�
�';�$�%-�s�4E�.F��.K�%L�"�%-�s�C�j�#�o�%>�"�#+�S�#�7M�,N�PS�,S�#T� ��(�&�&�$�&����F�G����y���(,� �'+�"�
� ��%���	�
%���
�&��@\�H�\�
'/��5R�/S�UX�/X�&Y�#�$,�c�3P�Rc�-d�fi�-i�$j�!�$,�c�3�8U�-V�X[�-[�$\�!�"*�C��6S�Uk�+l�nq�+q�"r���'�%�%�#�%����i�u��(,� � $�'+�"� �$� �%� ��	 �

� �%�
 �� �%� �F�i�u��HZ�c��	���
3E�
�!�Y�e�!�@�
��$�#�����
�	��I�U��KO�`d����'1��=G��Z]����"�	���%)�$�bf�_�(��%��&*�4�cg�`�(��%��qu�o��o�%/�o�BE�o�]m�o��o�.
�	��
�#��������&*�-��-�	�-�	�	-�
	�-�	�
-�
�-�
�-��-�$�-��-�`�)�5�� "&� $��������&*�0��0��0�	�	0�
	�0�	�
0�	�0�
�0�
�0��0�$�0��0�f
�I�U�
�$�"&�����!�!%����&*�7��7� �7�	�	7�
	�7�	�
7�	�7��7��7�
�7�
�7��7�$�7��7�t
�9�E�
�$*.�!�!�$(� � �>B��)-���&*�;�
&�;��;��	;�
"�;��
;��;�<�;�
�;�'�;�
�;��;�$�;��;�|�)�5��"�!����&*�$��$��$�
�	$�

�$��
$�$�$��$�N
��%�
�$�����/3�!%���&*�1��1�	�1�	�	1�
	�1�	�
1�
-�1��1�
�1��1�$�1��1�h��%�� �����<@�;E���&*�1��1�	�1�	�	1�
	�1�	�
1�:�1�9�1�
�1��1�$�1��1�h�Y�e��(�����/3�<@�!%�;E���&*�9��9�	�9�	�	9�
	�9�	�
9�
-�9�:�9��9�9�9�
�9��9�$�9��9�x
�i�u�
������;E���&*�.��.�	�.�	�	.�
	�.�	�
.�9�.�
�.��.�$�.��.�b�I�U��/3�D�lp�v��v�!+�v�>A�v�Yi�v��v�.	��%�	� 7;�+/����&*�0�	�0�
�0�4�	0�
)�0�
�
0�
�0��0�$�0��0�h�H�I���y��� ���&*�
�	����
�	�
��$�
���D�y��� ���&*�
"�	�"��"�
�	"�
�"�$�
"��"�J�Y�e���t�W[�d��d�),�d�DT�d��d�,��%��+/����&*�
�
'�
�
�
�
�	
�
�
�$�
��
��	���59�UY�]� � 1�9� <�=��	+��%�	+�'+�*�"�!�!����48�*�#�*��*��	*�
�*�
�
*�
�*��*�2�*��*�b(,����48�-�"�-�%�-�
�	-�

�-��
-�2�-��-�d'+�)�"�!����48�)�#�)��)��	)�

�)�
�
)��)�2�)��)�X
+�)�5�
+� '+�!�!�!����48�0�"�0�$�0��	0�
�0��
0�
�0�
�0��0�2�0��0�f	�	��	�'+�,�"�!�!����&*�,�#�,��,��	,�
�,�
�
,�
�,��,�$�,��,�^	�i�u�	�'+�,�"�!�!����&*�,�#�,��,��	,�
�,�
�
,�
�,��,�$�,��,�^+�i�u�+�'+�,�"�!���48�,�#�,��,��	,�

�,��
,�2�,��,�^
��c�3�h�� �	���%��7;�X\�Y�!�!3�Y�!>�?��	,��%�	,�&*�'+�,�"�!����&*�,�"�,�$�,��	,�
�,�
�
,�
�,��,�$�,��,�`#�C�5�#�:�.��&�I�&�%�c�>�%:�C�%?�@���i�u���8�:Y�Y�Z���y���/�$<�E�/���&*�
(�%�(��(�
�	(�
�(�$�
(�#�(�^"���&*�-�'�-��-��	-�

�-��
-�$�-�#�-�`.�#;�5�.���&*�
&�%�&��&�
�	&�
�&�$�
&�"�&�Z"���&*�-�'�-��-��	-�

�-��
-�$�-�"�-�`�8��'��-I�'J�C�'O�P��*�	�*�!)�#�/K�^�)\�^a�)a� b���)�5���?�Ad�d�e���)�5����&*�
+�)�+��+�
�	+�
�+�$�
+�!�+�d"���&*�.�+�.��.��	.�

�.��
.�$�.�!�.�b�9�E����&*�"�%�"�
�"��	"�
$�"�"�
"�P"���&*�
$�'�$��$�
�	$�
�$�$�
$�"�$�N
�	��
� %�04�;?�$(����&*�2
��2
��2
�.�	2
�
9�2
�"�
2
�
�2
�
�2
��2
�$�2
��2
�j�Y�e�����&*�
���
��
�	�
��$�
���>�)�5��$"&�$(�'+�8<�59����&*�3�
6�3��3�"�	3�
%�3�6�
3�3�3�
�3�
�3��3�$�3��3�l�	���$%)�'+�@D��#'���&*�P�
"�P�W�P�"�	P�
%�P�>�
P�
�P�!�P�
�P��P�$�P��P�f�)�5��37��pt�n��n�%/�n�BE�n�]m�n��n�<�	������&*�3��3��3�
�	3�

�3��
3�$�3��3�l��%����&*�
-��-��-�
�	-�
�-�$�
-��-�`�Y�e��!�MQ�&*�)-��"��"��"�K�	"�
$�"�'�
"��"��"�J
�i�u�
�&37��'+�+/��$(���&*� $�4�%�4�0�4�
�	4�
%�4�)�
4��4�"�4�
�4��4�$�4�
�4��4�n��%��NR�&*�)-���"��"�K�"�$�	"�
'�"�
�
"��"��"�J
�	��
�&"�26��'+�+/�$(�#'���&*�6�!�6��6�0�	6�

�6�%�
6�)�6�"�6�!�6�
�6��6�$�6��6�r�)�5��* $�"� �TX���+/� $���&*�N�	�N��N��	N�
�N��
N�R�N�
�N�
�N�)�N�
�N�
�N��N�$�N��N�b�Y�e��$ ��!�MQ�&*�)-���3�

�3��3��	3�
�3��
3�K�3�$�3�'�3��3�
�3��3�l
"�)�5�
"�"37�$(�%)���&*�+/�3��3� �3�0�	3�
"�3�#�
3�
�3��3�$�3�)�3��3�l�i�u��, �!�TX����&*��� $�4�	�4��4�
�4�
�4��
4�R�4�
�4�
�4��4�$�4�
�4��4�
�4��4�nJ��%�J�X\�BF�L�

�L��L�U�	L�
@�L��
L�<�i�u��%)�)-�+/���&*�-�'�-�"�-�'�	-�
)�-�
�
-��-�$�-��-�`��%��!%�'+���&*�3��3� �3��	3�
%�3�
�
3��3�$�3��3�l�	���(,�26���&*�+��+��+�%�	+�
0�+�
�
+��+�$�+��+�\��%��!%�+o���&*�+o��+o�
�+o��	+o�
$�+o��
+o�\�	��� "�(,�!%�#�#�#����&*�1��1�&�1��	1�
�1��
1��1�
�1�
�1��1�$�1��1�h��%�� "�(,�!%�#�#�#����&*�1��1�&�1��	1�
�1��
1��1�
�1�
�1��1�$�1��1�h�	���Y�.�	���fj����$��7:��Rb����>
����/	�	�/	��/	��/	�	�/	�	�	/	�
	�/	�	�
/	�	�/	�	�/	�	�/	�	�/	�	�/	�	�/	�	�/	�	�/	�	�/	� 	�!/	�"	�#/	�$	�%/	�&	�'/	�(	�)/	�*	�+/	�,	�-/	�.	%�//	�0	&�1/	�2	$�3/	�4	%�5/	�6	�7/	�8	�9/	�:	�;/	�<	�=/	�>	�?/	�@	�A/	�B	�C/	�D	�E/	�F	�G/	�H	�I/	�J	�K/	�L	�M/	�N	�O/	�P	�Q/	�R	�S/	�T	�U/	�V	�W/	�X	�Y/	�Z	�[/	�\	"�]/	�^	�_/	�1�J�d�
�/�1��f�d�e��

�_�a
�	�H>��q�r�b�s�b��s�t�@�u�@��o�p�a�q�a��q�r�?�s�?��m�n�`�+�`�9<�`�FP�`�o�`��o�p�>�q�>��o�p�Y�q�Y��q�r�?�s�?�*�7� 9�"?�	���(��	��Y}�%�"�H��%�s�0t6�6u�u
Back to Directory File Manager