PATH:
opt
/
hc_python
/
lib
/
python3.12
/
site-packages
/
pydantic_core
/
__pycache__
� ���g � � � U d Z ddlmZ ddlZddlZddlmZ ddlm Z mZm Z m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZmZmZ ddlmZ ej8 d k rdd lm Z ndd lm Z ej8 d k r dd lm Z m Z m Z n dd lm Z m Z m Z ej8 d k rddlm!Z! nddlm!Z! erddl"m#Z# n ddl"m#Z# e!d Z& G d� de d�� Z'dZ(de)d< G d� de � Z* G d� de*e � Z+ G d � d e � Z,e!d Z- G d � d e d�� Z.�d.d!�Z/eegef Z0eee*gef Z1eeegef Z2eeee+gef Z3ee0e1e2e3f Z4e!d" Z5 G d#� d$e d�� Z6dddd%d&� �d/d'�Z7 G d(� d)e � Z8eee8gef Z9eee8e*gef Z:eeee8gef Z;eeee8e+gef Z<ee9e:e;e<f Z= G d*� d+e d�� Z>ddddd%d,� �d0d-�Z? G d.� d/e d�� Z@d0d1��d1d2�ZA G d3� d4e d�� ZBd0d1��d2d5�ZC G d6� d7e d�� ZD�d3d8�ZEee.e6e>e@eBeDf ZF G d9� d:e d�� ZGddd;� �d4d<�ZH G d=� d>e d�� ZIdddd?��d5d@�ZJ G dA� dBe d�� ZKdddd?��d6dC�ZL G dD� dEe d�� ZM �d7 �d8dF�ZN G dG� dHe d�� ZOddddddddddI� �d9dJ�ZP G dK� dLe d�� ZQdddddddddddM� �d:dN�ZR G dO� dPe d�� ZSdddddddddddddQ� �d;dR�ZT G dS� dTe d�� ZUdddddddddddddU� �d<dV�ZV G dW� dXe d�� ZWdddddddY� �d=dZ�ZX G d[� d\e d�� ZYddddddddddd]� �d>d^�ZZ G d_� d`e d�� Z[dddddddaddddb� �d?dc�Z\ G dd� dee d�� Z]dddddddddaddddf� �d@dg�Z^ G dh� die d�� Z_ddddddaddddj� �dAdk�Z` G dl� dme d�� Zadddd?� �dBdn�Zb G do� dpe d�� Zcdddddddq� �dCdr�Zde!ds Ze G dt� due d�� Zfdddddv� �dDdw�Zg G dx� dye d�� Zhdddddv� �dEdz�Zi G d{� d|e d�� Zjdddd?� �dFd}�Zk G d~� de d�� Zldddddd�� �dGd��Zm G d�� d�e d�� Znddd���dHd��ZoeeneFf Zp G d�� d�e d�� Zq �dIdddddddd�� �dJd��Zrdddddd�� �dKd��Zs �dIddddddd�� �dLd��Zt G d�� d�e d�� Zuddddddddd�� �dMd��Zv G d�� d�e d�� Zw �dIdddddddd�� �dNd��Zx G d�� d�e d�� Zy �dIdddddddd�� �dOd��Zz G d�� d�e d�� Z{ �dIdddddd�� �dPd��Z|eee}e~f Z G d�� d�e d�� Z�ddd���dQd��Z�ee�eFf Z� G d�� d�e d�� Z� �dRddddddd�� �dSd��Z�eegef Z� G d�� d�e � Z�eee,gef Z� G d�� d�e d�� Z�ee�e�f Z� G d�� d�e d�� Z� G d�� d�e�d�� Z�dddd?� �dTd��Z�ddddd�� �dUd��Z� G d�� d�e�d�� Z�dddd?� �dVd��Z�ddddd�� �dWd��Z� G d�� d�e � Z�eee�gef Z� G d�� d�e � Z�eee�e,gef Z� G d�� d�e d�� Z�ee�e�f Z� G d�� d�e d�� Z�dddd?� �dXd��Z�ddddd�� �dYd��Z� G d�� d�e d�� Z�dddd?� �dZd��Z�ddddd�� �d[d��Z� G d�� d�e d�� Z�e#dddddddd�� �d\dZ� G dÄ d�e d�� Z�dddddŜ �d]dƄZ� G dDŽ d�e d�� Z�ddddddddddɜ �d^dʄZ� G d˄ d�e d�� Z�ddddddddd͜ �d_d΄Z� G dτ d�e d�� Z�dddd?� �d`dфZ� G d҄ d�e d�� Z�dddddŜ �dadԄZ� G dՄ d�e d�� Z�dddd?� �dbdׄZ� G d d�e d�� Z�ddddddڜ �dcdۄZ� G d܄ d�e d�� Z�dddddddddddޜ �ddd߄Z� G d� d�e d�� Z�dddddd� �ded�Z� G d� d�e d�� Z�ddddddddddd� �dfd�Z� G d� d�e d�� Z�dddddddddddd� �dgd�Z� G d� d�e d�� Z�ddddddddd� �dhd�Z� G d� d�e d�� Z�dddddddd� �did�Z� G d� d�e d�� Z�ddddddddddd�� �djd��Z� G d�� d�e d�� Z�ddd�� �dkd��Z� G d�� d�e d�� Z�ddddddd�� �dld��Z� G �d � �de d�� Z�ddddd�d� �dm�d�Z� G �d� �de d�� Z�ddddd�d� �dn�d�Z� G �d� �d e d�� Z� �dIdddd?� �do�d �Z� G �d � �d e d�� Z�dddddddddd�d � �dp�d�Z� G �d� �de d�� Z�dddddddddd�d � �dq�d�Z� G �d� �de d�� Zɐdr�d�Z� G �d� �de d�� Z� �ds �dt�d�Z�dZ�e�sgeg eI�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!�d Z�e!�d Z�e!�d Zѐ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$$ r e%� Z#Y � ��w xY w(z ze 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 � � e Zd ZU dZded< ded< ded< ded< ded < ded < d ed < ded < ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded < ded < ded < d ed < 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�>�>rH r$ F)�totalz2set[int | str] | dict[int | str, IncExCall] | Noner � IncExCallc �� � e Zd Zedd�� Zedd�� Zedd�� Zedd�� Zedd�� Zedd�� Z edd�� Z edd�� Z edd �� Z dd �Z dd �Zdd �Zdd �Zy)�SerializationInfoc � � y �NrG ��selfs rI �includezSerializationInfo.includez � � �$'rH c � � y rO rG rP s rI �excludezSerializationInfo.exclude} rS rH c � � y)z Current serialization context.NrG rP s rI �contextzSerializationInfo.context� s � rH c � � y rO rG rP s rI �modezSerializationInfo.mode� s � � rH c � � y rO rG rP s rI �by_aliaszSerializationInfo.by_alias� s � � #rH c � � y rO rG rP s rI � exclude_unsetz SerializationInfo.exclude_unset� s � �%(rH c � � y rO rG rP s rI �exclude_defaultsz"SerializationInfo.exclude_defaults� � � �(+rH c � � y rO rG rP s rI � exclude_nonez SerializationInfo.exclude_none� rS rH c � � y rO rG rP s rI �serialize_as_anyz"SerializationInfo.serialize_as_any� r` rH c � � y rO rG rP s rI � round_tripz SerializationInfo.round_trip� s � �#rH c � � y rO rG rP s rI � mode_is_jsonz SerializationInfo.mode_is_json� s � �CrH c � � y rO rG rP s rI �__str__zSerializationInfo.__str__� s � �crH c � � y rO rG rP s rI �__repr__zSerializationInfo.__repr__� s � �srH N)�returnrK �rm z Any | None�rm r% )rm r' )rB rC rD �propertyrR rU rW rY r[ r] r_ rb rd rf rh rj rl rG rH rI rM rM y s� � � �'� �'� �'� �'� �-� �-� � � � � �#� �#� �(� �(� �+� �+� �'� �'� �+� �+�%�'�!�"rH rM c � � e Zd Zedd�� Zy)�FieldSerializationInfoc � � y rO rG rP s rI � field_namez!FieldSerializationInfo.field_name� s � �!$rH Nro )rB rC rD rp rt rG rH rI rr rr � s � � �$� �$rH rr c �j � e Zd ZdZedd�� Zed d�� Zed d�� Zed d�� Zed d�� Z y) �ValidationInfoz2 Argument passed to validation functions. c � � y)zCurrent validation context.NrG rP s rI rW zValidationInfo.context� � � � rH c � � y)z/The CoreConfig that applies to this validation.NrG rP s rI �configzValidationInfo.config� rx rH c � � y)z2The type of input data we are currently validatingNrG rP s rI rY zValidationInfo.mode� rx rH c � � y)z(The data being validated for this model.NrG rP s rI �datazValidationInfo.data� rx rH c � � y)zw The name of the current field being validated if this validator is attached to a model field. NrG rP s rI rt zValidationInfo.field_name� s � � rH Nrn )rm �CoreConfig | None)rm zLiteral['python', 'json'])rm zDict[str, Any])rm � str | None) rB rC rD rE rp rW rz rY r} rt rG rH rI rv rv � sk � �� � � � � � � � � � � � � � � � � � � � rH rv )�noner2 r' �floatr% �bytes� bytearray�list�tuple�set� frozenset� generator�dictr r r r �url�multi-host-url�json�uuidc � � e Zd ZU ded< y)�SimpleSerSchemaz$Required[ExpectedSerializationTypes]�typeN�rB rC rD rF rG rH rI r� r� � � � � .�.rH r� 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 )�alwaysz unless-noner� �json-unless-nonec �J � e Zd ZU ded< ded< ded< ded< ded < d ed < y ) � PlainSerializerFunctionSerSchema�#Required[Literal['function-plain']]r� z Required[SerializerFunction]�functionr' �is_field_serializer�info_arg� CoreSchema� return_schema�WhenUsed� when_usedNr� rG rH rI r� r� s% � � -�-�*�*� � ��N� � ��rH r� r� )r� r� r� r� c �2 � |dk( rd}t d| ||||�� 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� �� � � �� /��#�� � rH c � � e Zd Zddd�Zy)� SerializerFunctionWrapHandlerNc � � y rO rG )rQ � input_value� index_keys rI �__call__z&SerializerFunctionWrapHandler.__call__1 s � �X[rH rO )r� r r� zint | str | Nonerm r �rB rC rD r� rG rH rI r� r� 0 s � �[rH r� c �T � e Zd ZU ded< ded< ded< ded< ded < ded < d ed < y )� WrapSerializerFunctionSerSchema�"Required[Literal['function-wrap']]r� z Required[WrapSerializerFunction]r� r' r� r� r� �schemar� r� r� Nr� rG rH rI r� r� D s+ � � ,�,�.�.� � ��N� �� � ��rH r� )r� r� r� r� r� c �4 � |dk( rd}t d| |||||�� 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� N s3 � �* �H� �� � � �� /���#�� � rH c �, � e Zd ZU ded< ded< ded< y)�FormatSerSchemazRequired[Literal['format']]r� � Required[str]�formatting_stringr� r� Nr� rG rH rI r� r� q s � � %�%�$�$��rH r� r� )r� c �, � |dk( rd}t d| |�� 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� w s# � � �&�&�� � �x�;L�Xa� b�brH c �" � e Zd ZU ded< ded< y)�ToStringSerSchemaz Required[Literal['to-string']]r� r� r� Nr� rG rH rI r� r� � s � � (�(��rH r� c �2 � t d�� }| dk7 r| |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��&�&�"��+�� �HrH c �, � e Zd ZU ded< ded< ded< y)�ModelSerSchema�Required[Literal['model']]r� �Required[Type[Any]]�cls�Required[CoreSchema]r� Nr� rG rH rI r� r� � s � � $�$� � � � rH r� c � � t d| |�� 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�� ?�?rH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) � ComputedFieldz#Required[Literal['computed-field']]r� r� � property_namer� r� r% �aliasr �metadataNr� rG rH rI r� r� � s � � -�-� � �'�'� �J��MrH r� )r� r� c �" � t d| |||�� 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� � rH c �6 � e Zd ZU ded< ded< ded< ded< y ) � AnySchemazRequired[Literal['any']]r� r% �refr r� � SerSchema� serializationNr� rG rH rI r� r� � s � � "�"� �H��M� � rH r� �r� r� r� c � � t d| ||�� 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]� ^�^rH c �6 � e Zd ZU ded< ded< ded< ded< y ) � NoneSchemazRequired[Literal['none']]r� r% r� r r� r� r� Nr� rG rH rI r� r� � s � � #�#� �H��M� � rH r� c � � t d| ||�� 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^� _�_rH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) � BoolSchemazRequired[Literal['bool']]r� r' r( r% r� r r� r� r� Nr� rG rH rI r� r� s � � #�#� �L� �H��M� � rH r� c �" � t d| |||�� 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�nrH c �r � e Zd ZU ded< ded< ded< ded< ded< ded< d ed < d ed < d ed< ded< y)� IntSchemazRequired[Literal['int']]r� r2 � multiple_of�le�ge�lt�gtr' r( r% r� r r� r� r� Nr� rG rH rI r� r� ! s7 � � "�"��� �G� �G� �G� �G� �L� �H��M� � rH r� � r� r� r� r� r� r( r� r� r� c �, � t d| ||||||||�� 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 � � � � � � �� ��#� � rH c �| � e Zd ZU ded< ded< ded< ded< ded< ded < ded < ded < d ed < ded< ded< y)� FloatSchemazRequired[Literal['float']]r� r' r8 r� r� r� r� r� r� r( r% r� r r� r� r� Nr� rG rH rI r� r� ^ s= � � $�$����� �I� �I� �I� �I� �L� �H��M� � rH r� � r8 r� r� r� r� r� r( r� r� r� c �. � t d| ||||||||| �� 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� r8 r� r� r� r� r� r( r� r� r� r� r� s rI � float_schemar� l s3 � �H � �#� � � � � �� ��#� � rH c � � e Zd ZU ded< ded< ded< ded< ded< ded < ded < d ed < d ed < ded< ded< ded< ded< y)� DecimalSchemaz Required[Literal['decimal']]r� r' r8 r r� r� r� r� r� r2 � max_digits�decimal_placesr( r% r� r r� r� r� Nr� rG rH rI r� r� � sH � � &�&������K��K��K��K��O��� �L� �H��M� � rH r� � r8 r� r� r� r� r� r� r� r( r� r� r� c �2 � t d|||||||| || | | �� 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� r8 r( r� r� r� r� r� s rI �decimal_schemar� � s9 � �R � � � � � � �%� �#�� ��#� � rH c � � e Zd ZU ded< 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� r r� r� r� Nr� rG rH rI r� r� � sI � � "�"� %�%��O��O����N��N�4�4� �L� � � �H��M� � rH r� � r� r r r r r r@ r( r> r� r� r� c �2 � t d| ||||||||| | | �� 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� r r r r r r@ r( r> r� r� r� r� r s rI � str_schemar � s9 � �Z � �� � �)���!�� 3� ��#� � rH c �T � e Zd ZU ded< ded< ded< ded< ded < d ed < d ed < y)� BytesSchemazRequired[Literal['bytes']]r� r2 r r r' r( r% r� r r� r� r� Nr� rG rH rI r r 7 s' � � $�$��O��O� �L� �H��M� � rH r �r r r( r� r� r� c �& � t d| |||||�� 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� r r r( r� r� r� r� r s rI � bytes_schemar A s& � �8 � � � �� ��#� � rH c �| � e Zd ZU ded< ded< ded< ded< ded< ded < d ed < d ed < ded< ded< ded< y)� DateSchemazRequired[Literal['date']]r� r' r( r r� r� r� r� �Literal['past', 'future']�now_opr2 �now_utc_offsetr% r� r r� r� r� Nr� rG rH rI r r h s? � � #�#� �L� �H� �H� �H� �H� %�%� �� �H��M� � rH r � r( r� r� r� r� r r r� r� r� c �. � t d| ||||||||| �� 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� r r r� r� r� r� r s rI � date_schemar x s3 � �J � �� � � � ��%� ��#� � rH c �| � e Zd ZU ded< ded< ded< ded< ded< ded < d ed < d ed < ded< ded< ded< y)� TimeSchemazRequired[Literal['time']]r� r' r( r r� r� r� r� �%Union[Literal['aware', 'naive'], int]� tz_constraint� Literal['truncate', 'error']�microseconds_precisionr% r� r r� r� r� Nr� rG rH rI r r � s= � � #�#� �L� �H� �H� �H� �H�8�8� 8�8� �H��M� � rH r �truncate� r( r� r� r� r� r r r� r� r� c �. � t d| ||||||||| �� 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� r r r� r� r� r� r s rI � time_schemar � s3 � �J � �� � � � �#� 5� ��#� � rH c � � e Zd ZU ded< ded< ded< ded< ded< ded < d ed < d ed < ded< ded< ded< ded< ded< y)�DatetimeSchemaz Required[Literal['datetime']]r� r' r( r r� r� r� r� r r r r r2 r r r r% r� r r� r� r� Nr� rG rH rI r r � sK � � '�'� �L��L��L��L��L� %�%�8�8� �� 8�8� �H��M� � rH r � r( r� r� r� r� r r r r r� r� r� c �2 � t d| ||||||||| | | �� 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� r r r r r� r� r� r� r! s rI �datetime_schemar# s9 � �V � �� � � � ��#�%� 5� ��#� � rH c �r � e Zd ZU ded< ded< ded< ded< ded< ded < d ed < d ed < ded< ded< y)�TimedeltaSchemaz Required[Literal['timedelta']]r� r' r( r r� r� r� r� r r r% r� r r� r� r� Nr� rG rH rI r% r% < s7 � � (�(� �L��M��M��M��M� 8�8� �H��M� � rH r% � r( r� r� r� r� r r� r� r� c �, � t d| ||||||||�� 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� r r� r� r� r� r& s rI �timedelta_schemar( I s0 � �F � �� � � � � 5� ��#� � rH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) � LiteralSchemaz Required[Literal['literal']]r� �Required[List[Any]]�expectedr% r� r r� r� r� Nr� rG rH rI r* r* z s � � &�&�!�!� �H��M� � rH r* c �" � t d| |||�� 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�urH c �h � e Zd ZU ded< ded< ded< ded< d ed < d ed < d ed< ded< ded< y)� EnumSchemazRequired[Literal['enum']]r� � Required[Any]r� r+ �membersz Literal['str', 'int', 'float']�sub_typezCallable[[Any], Any]�missingr' r( r% r� r r� r� r� Nr� rG rH rI r1 r1 � s5 � � #�#� �� � �,�,� !�!� �L� �H��M� � rH r1 )r4 r5 r( r� r� r� c �* � t d| |||||||�� 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� r3 r4 r5 r( r� r� r� r� )r� r3 r4 r5 r( r� r� r� s rI � enum_schemar8 � s- � �L � � ����� ��#� � rH )�nullr' r2 r� r% r� r� c �J � e Zd ZU ded< ded< ded< ded< ded < d ed < y ) �IsInstanceSchemaz Required[Literal['is-instance']]r� r2 r� r% �cls_reprr� r r� r� r� Nr� rG rH rI r; r; � s# � � *�*� ���M� �H��M� � rH r; )r< r� r� r� c �$ � t d| ||||�� 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� � rH c �J � e Zd ZU ded< ded< ded< ded< ded < d ed < y ) �IsSubclassSchemaz Required[Literal['is-subclass']]r� r� r� r% r< r� r r� r� r� Nr� rG rH rI rC rC s# � � *�*� � ��M� �H��M� � rH rC c �$ � t d| ||||�� 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_schemarF s � �@ � ��h�C�(�bo� � rH c �6 � e Zd ZU ded< ded< ded< ded< y ) �CallableSchemaz Required[Literal['callable']]r� r% r� r r� r� r� Nr� rG rH rI rH rH 5 s � � '�'� �H��M� � rH rH c � � t d| ||�� 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�crH c �J � e Zd ZU ded< ded< ded< ded< d ed < d ed < y )� UuidSchemazRequired[Literal['uuid']]r� zLiteral[1, 3, 4, 5]�versionr' r( r% r� r r� r� r� Nr� rG rH rI rM rM R s# � � #�#� � � �L� �H��M� � rH rM �rN r( r� r� r� c �$ � t d| ||||�� S )Nr� )r� rN r( r� r� r� r� rO s rI � uuid_schemarQ [ s � � � �W�V��x�_l� � rH c �, � e Zd ZU ded< ded< ded< y)�IncExSeqSerSchemaz-Required[Literal['include-exclude-sequence']]r� zSet[int]rR rU Nr� rG rH rI rS rS h s � � 7�7� �� �rH rS �rR rU c � � t d| |�� S )Nzinclude-exclude-sequence�r� rR rU r� rT s rI �filter_seq_schemarW n s � � � 9�7�T[� \�\rH c �h � e Zd ZU ded< ded< ded< ded< ded < ded < d ed < d ed< ded< y)� ListSchemazRequired[Literal['list']]r� r� � items_schemar2 r r r' � fail_fastr( r% r� r r� �IncExSeqOrElseSerSchemar� Nr� rG rH rI rY rY u s2 � � #�#� � ��O��O��O� �L� �H��M�*�*rH rY )r r r[ r( r� r� r� c �* � t d| |||||||�� 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� rZ r r r[ r( r� r� r� r� �rZ r r r[ 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)rZ ra r( r� r� r� rd s rI �tuple_positional_schemarg � sG � �B � � !�,� /��#�}�o�5� � "�� �!� /�� ��#� � rH )r r r( 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 )rZ rd r r r( r� r� r� )rf r� )rZ r r r( r� r� r� s rI �tuple_variable_schemari � s4 � �@ �"�2�j�l�3� � � �� ��#� � rH c �r � e Zd ZU ded< ded< ded< ded< ded< d ed < d ed < d ed < ded< ded< y)rb zRequired[Literal['tuple']]r� �Required[List[CoreSchema]]rZ r2 rd r r r' r[ r( r% r� r r� r\ r� Nr� rG rH rI rb rb s8 � � $�$�,�,� � ��O��O��O� �L� �H��M�*�*rH )rd r r r[ r( r� r� r� c �, � t d| ||||||||�� 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� rZ rd r r r[ r( r� r� r� r� ) rZ rd r r r[ r( r� r� r� s rI rf rf s0 � �J � �!� /� � ��� ��#� � rH c �h � e Zd ZU ded< ded< ded< ded< ded < ded < d ed < d ed< ded< y)� SetSchemazRequired[Literal['set']]r� r� rZ r2 r r r' r[ r( r% r� r r� r� r� Nr� rG rH rI rn rn L s2 � � "�"� � ��O��O��O� �L� �H��M� � rH rn c �* � t d| |||||||�� 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_schemarp X s- � �D � �!� � ��� ��#� � rH c �h � e Zd ZU ded< ded< ded< ded< ded < ded < d ed < d ed< ded< y)�FrozenSetSchemaz Required[Literal['frozenset']]r� r� rZ r2 r r r' r[ r( r% r� r r� r� r� Nr� rG rH rI rr rr � s2 � � (�(� � ��O��O��O� �L� �H��M� � rH rr c �* � t d| |||||||�� 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 � �!� � ��� ��#� � rH c �T � e Zd ZU ded< ded< ded< ded< ded < d ed < d ed < y)�GeneratorSchemaz Required[Literal['generator']]r� r� rZ r2 r r r% r� r r� r\ r� Nr� rG rH rI rv rv � s( � � (�(� � ��O��O� �H��M�*�*rH rv )r r r� r� r� c �& � t d| |||||�� 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� rZ r r r� r� r� r� )rZ r r r� r� r� s rI �generator_schemarx � s' � �H � �!� � � ��#� � rH c �, � e Zd ZU ded< ded< ded< y)�IncExDictSerSchemaz)Required[Literal['include-exclude-dict']]r� � IncExDictrR rU Nr� rG rH rI rz rz � s � � 3�3� �� �rH rz c � � t d| |�� S )Nzinclude-exclude-dictrV r� rT s rI �filter_dict_schemar} s � � � 5�w�PW� X�XrH c �h � e Zd ZU ded< ded< ded< ded< ded< d ed < d ed < d ed< ded< y)� DictSchemazRequired[Literal['dict']]r� r� � keys_schema� values_schemar2 r r r' r( r% r� r r� �IncExDictOrElseSerSchemar� Nr� rG rH rI r r s3 � � #�#��� � ��O��O� �L� �H��M�+�+rH r c �* � t d| |||||||�� 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� r r r( r� r� r� r� )r� r� r r r( r� r� r� s rI � dict_schemar� s- � �D � � �#� � �� ��#� � rH c �" � e Zd ZU ded< ded< y)� NoInfoValidatorFunctionSchema�Literal['no-info']r� �NoInfoValidatorFunctionr� Nr� rG rH rI r� r� J s � � � �%�%rH r� c �, � e Zd ZU ded< ded< ded< y)� WithInfoValidatorFunctionSchema� Required[Literal['with-info']]r� z#Required[WithInfoValidatorFunction]r� r% rt Nr� rG rH rI r� r� S s � � (�(�1�1��OrH r� c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) �_ValidatorFunctionSchema� Required[ValidationFunction]r� r� r� r% r� r r� r� r� Nr� rG rH rI r� r� \ s � �*�*� � � �H��M� � rH r� c � � e Zd ZU ded< y)� BeforeValidatorFunctionSchemaz$Required[Literal['function-before']]r� Nr� rG rH rI r� r� d r� rH r� c �* � t dd| 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� h s) � �B � �#��:�� ��#� � rH )rt r� r� r� c �< � t dt d| |�� ||||�� 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� rt r� r� �r� r� rt r� r� r� s rI �#with_info_before_validator_functionr� � s. � �L � � �[�8�PZ�[�� ��#� � rH c � � e Zd ZU ded< y)� AfterValidatorFunctionSchemaz#Required[Literal['function-after']]r� Nr� rG rH rI r� r� � s � � -�-rH r� c �* � t dd| 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( � �> � �#��:�� ��#� � rH c �< � t dt d| |�� ||||�� 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�[�� ��#� � rH c � � e Zd Zddd�Zy)� ValidatorFunctionWrapHandlerNc � � y rO rG )rQ r� �outer_locations rI r� z%ValidatorFunctionWrapHandler.__call__! s � � rH rO )r� r r� zstr | int | Nonerm r r� rG rH rI r� r� s � � rH r� c �" � e Zd ZU ded< ded< y)�!NoInfoWrapValidatorFunctionSchemar� r� �NoInfoWrapValidatorFunctionr� Nr� rG rH rI r� r� ) s � � � �)�)rH r� c �, � e Zd ZU ded< ded< ded< y)�#WithInfoWrapValidatorFunctionSchemar� r� z'Required[WithInfoWrapValidatorFunction]r� r% rt Nr� rG rH rI r� r� 2 s � � (�(�5�5��OrH r� c �J � e Zd ZU ded< ded< ded< ded< d ed < d ed < y )�WrapValidatorFunctionSchemar� r� z Required[WrapValidatorFunction]r� r� r� r% r� r r� r� r� Nr� rG rH rI r� r� ; s$ � � ,�,�-�-� � � �H��M� � rH r� c �* � t dd| 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� D s) � �H � �#��:�� ��#� � rH c �< � t dt d| |�� ||||�� S )a� Returns a schema which calls a function with a `validator` callable argument which can optionally be used to call inner validation with the function logic, this is much like the "onion" implementation of middleware in many popular web frameworks, 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� r s. � �N � � �[�8�PZ�[�� ��#� � rH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) � PlainValidatorFunctionSchemar� r� r� r� r% r� r r� r� r� Nr� rG rH rI r� r� � s � � -�-�*�*� �H��M� � rH r� c �( � t dd| 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 � �#��:� ��#� � rH c �: � t dt d| |�� |||�� 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� rt r� r� r� s rI �"with_info_plain_validator_functionr� � s* � �< � � �[�8�PZ�[� ��#� � rH c �r � e Zd ZU ded< ded< ded< ded< d ed < d ed < d ed < ded< ded< ded< y)�WithDefaultSchemaz Required[Literal['default']]r� r� r� r �defaultzCallable[[], Any]�default_factoryz#Literal['raise', 'omit', 'default']�on_errorr' r0 r( r% r� r� r� r� Nr� rG rH rI r� r� � s: � � &�&� � � �L�&�&�1�1��� �L� �H��M� � rH r� )r� r� r� r0 r( r� r� r� c �H � t d| |||||||�� } |t ur|| 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� r0 r( r� r� r� )r� r ) r� r� r� r� r0 r( r� r� r� r� s rI �with_default_schemar� sC � �J � ��'��)�� ��#� �A� �'�'� ��)� � �HrH c �J � e Zd ZU ded< ded< ded< ded< d ed < d ed < y )�NullableSchemaz Required[Literal['nullable']]r� r� r� r' r( r% r� r r� r� r� Nr� rG rH rI r� r� 9 s# � � '�'� � � �L� �H��M� � rH r� r� c �$ � t d| ||||�� 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� � rH c �| � e Zd ZU ded< 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']rY r( r� r r� r� r� Nr� rG rH rI r� r� a sA � � $�$� F�F����� � �;�;� +�+� �L� �H��M� � rH r� ) r� r� r� r� rY r( r� r� r� c �. � t d| ||||||||| �� 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� rY r( r� r� r� r� ) r� r� r� r� r� rY r( r� r� r� s rI � union_schemar� p s3 � �N � ��#�+� 1� 1� �� ��#� � rH c �| � e Zd ZU ded< 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� r r� r� r� Nr� rG rH rI r� r� � sA � � +�+� 1�1�v�v��� � �;�;� �L��� �H��M� � rH r� )r� r� r� r( r, r� r� r� c �. � t d| ||||||||| �� 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��'� ��#� � rH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) � ChainSchemazRequired[Literal['chain']]r� rk �stepsr% r� r r� r� r� Nr� rG rH rI r� r� s � � $�$� %�%� �H��M� � rH r� c �" � t d| |||�� 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�mrH c �T � e Zd ZU ded< ded< ded< ded< ded < d ed < d ed < y)�LaxOrStrictSchemaz"Required[Literal['lax-or-strict']]r� r� � lax_schema� strict_schemar' r( r% r� r r� r� r� Nr� rG rH rI r� r� - s) � � ,�,�$�$�'�'� �L� �H��M� � rH r� c �& � t d| |||||�� 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 � � �#�� ��#� � rH c �J � e Zd ZU ded< ded< ded< ded< ded < d ed < y ) �JsonOrPythonSchemaz#Required[Literal['json-or-python']]r� r� � json_schema� python_schemar% r� r r� r� r� Nr� rG rH rI r� r� m s$ � � -�-�%�%�'�'� �H��M� � rH r� c �$ � t d| ||||�� 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 � � �#� ��#� � rH c �T � e Zd ZU ded< 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_excluder r� Nr� rG rH rI r� r� � s* � � /�/� � ��N�T�T� � � � ��MrH r� )r� r� r� r� r� c �& � t d| |||||�� 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�� � rH c � � e Zd ZU ded< ded< ded< ded< d ed < d ed < ded < ded< ded< ded< ded< ded< y)�TypedDictSchemaz Required[Literal['typed-dict']]r� z#Required[Dict[str, TypedDictField]]�fields�List[ComputedField]�computed_fieldsr' r( r� ra r) �extra_behaviorrJ r1 r% r� r r� r� r� r$ rz Nr� rG rH rI r� r� � sF � � )�)� /�/�(�(� �L� � �!�!� �K��� �H��M� � � �rH r� ) r� r( ra r� rJ r1 r� r� r� rz c �0 � t d| ||||||||| | �� 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( ra r� rJ r1 r� r� r� rz r� ) r� r� r( ra r� rJ r1 r� r� r� rz s rI �typed_dict_schemar� � s6 � �N � ��'��#�%��)� ��#�� � rH c �T � e Zd ZU ded< ded< ded< ded< d ed < d ed < d ed < y)� ModelFieldz Required[Literal['model-field']]r� r� r� r� r� r% r� r' r� �frozenr r� Nr� rG rH rI r� r� s* � � *�*� � �T�T� � � � � �L��MrH r� )r� r� r� r r� c �& � t d| |||||�� 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� r r� r� )r� r� r� r� r r� s rI � model_fieldr & s& � �4 � ��)� /� 3��� � rH c � � e Zd ZU ded< ded< ded< ded< d ed < d ed < d ed< d ed< d ed< ded< ded< ded< y)�ModelFieldsSchemaz!Required[Literal['model-fields']]r� z Required[Dict[str, ModelField]]r� r% � model_namer� r� r' r( r� ra r) r� r1 r, r� r r� r� r� Nr� rG rH rI r r K sF � � +�+� +�+��O�(�(� �L� � �!�!����� �H��M� � rH r ) r r� r( ra r� r1 r, r� r� r� c �0 � t d| ||||||||| | �� 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� r r� r( ra r� r1 r, r� r� r� r� ) r� r r� r( ra r� r1 r, r� r� r� s rI �model_fields_schemar [ s6 � �R � �� �'��#�%�)�'� ��#� � rH c � � e Zd ZU ded< 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( r r) r� r$ rz r� r r� r� r� Nr� rG rH rI r r � sQ � � $�$� � � � ������N�J�J� �L� �L�!�!� �� �H��M� � rH r ) r r r r/ r( r r� rz r� r� r� c �4 � t d| ||||||||| | | | �� 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 r r/ r( r r� rz r� r� r� r� ) r� r� r r r r/ r( r r� rz r� r� r� s rI � model_schemar � s< � �~ � � �� � �� 1���%�� ��#� � rH c �| � e Zd ZU ded< 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_onlyr r� r� r% r� r� r r� Nr� rG rH rI r r � s? � � .�.� �� � � �M� �J��O� �L�T�T� � � � ��MrH r )r r r r� r� r� r� r c �. � t d| ||||||||| �� 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� r r� r r r r� r� r� r� r r� ) r r� r r r r� r� r� r� r s rI �dataclass_fieldr s3 � �N � � ��� ��)� /� 3��� � rH c �r � e Zd ZU ded< ded< ded< ded< d ed < d ed < d ed < ded< ded< ded< y)�DataclassArgsSchemaz#Required[Literal['dataclass-args']]r� r� �dataclass_namez Required[List[DataclassField]]r� r� r� r' r1 �collect_init_onlyr% r� r r� r� r� r) r� Nr� rG rH rI r r : s< � � -�-�!�!� *�*�(�(����� �H��M� � �!�!rH r )r� r1 r r� r� r� r� c �, � t d| ||||||||�� 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� r r� r� r1 r r� r� r� r� r� ) r r� r� r1 r r� r� r� r� s rI �dataclass_args_schemar G s0 � �P � �%��'�)�+� ��#�%� � rH c � � e Zd ZU ded< ded< ded< ded< d ed < d ed < d ed< d ed< d ed< d ed< ded< ded< d ed< ded< y)�DataclassSchemaz Required[Literal['dataclass']]r� r� r� r� r� zRequired[List[str]]r� r% �cls_namer' r r. r/ r( r r� r r� r� r� �slotsr$ rz Nr� rG rH rI r" r" } sO � � (�(� � � � � � ��M��O�J�J� �L� �L� �H��M� � � �K� �rH r" ) r# r r/ r( r� r� r� r r$ rz c �4 � t d| ||||||||| | | | �� 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� r r/ r( r� r� r� r r$ rz r� ) r� r� r� r# r r/ r( r� r� r� r r$ rz s rI �dataclass_schemar' � s< � �J � � ����� 1�� ��#���� � rH c �6 � e Zd ZU ded< ded< ded< ded< y ) �ArgumentsParameterr� r r� r� zCLiteral['positional_only', 'positional_or_keyword', 'keyword_only']rY r� r� Nr� rG rH rI r) r) � s � � �� � � M�M� I�IrH r) )rY r� 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 �r r� rY r� r� r+ s rI �arguments_parameterr, � s � �6 �t�F��U� K�KrH c �^ � e Zd ZU ded< ded< ded< ded< ded < d ed < d ed < ded< y)�ArgumentsSchemaz Required[Literal['arguments']]r� z"Required[List[ArgumentsParameter]]�arguments_schemar' r1 r� �var_args_schema�var_kwargs_schemar% r� r r� r� r� Nr� rG rH rI r. r. � s0 � � (�(�8�8��� � �!�!� �H��M� � rH r. )r1 r0 r1 r� r� r� c �( � t d| ||||||�� 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/ r1 r0 r1 r� r� r� r� )r3 r1 r0 r1 r� r� r� s rI r/ r/ � s* � �H � �"�)�'�+� ��#� � rH c �^ � e Zd ZU ded< ded< ded< ded< d ed < ded < d ed < ded< y)� CallSchemazRequired[Literal['call']]r� r� r/ z Required[Callable[..., Any]]r� r% � function_namer� r� r� r r� r� r� Nr� rG rH rI r5 r5 % s0 � � #�#�*�*�*�*��� � � �H��M� � rH r5 )r6 r� r� r� r� c �( � t d| ||||||�� 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� r6 r� r� r� r� r� )r3 r� r6 r� r� r� r� s rI � call_schemar9 0 s* � �T � �"��#�#� ��#� � rH c �^ � e Zd ZU ded< 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� r r� r� r� Nr� rG rH rI r; r; f s0 � � +�+� � �$�$� � �;�;� �H��M� � rH r; )r� r� r� r� r� c �( � t d| ||||||�� 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� ��#� � rH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) � JsonSchemazRequired[Literal['json']]r� r� r� r% r� r r� r� r� Nr� rG rH rI r@ r@ � s � � #�#� �� �H��M� � rH r@ c �" � t d| |||�� 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 rI r� r� � s � �V �v�f�#��`m� n�nrH c �| � e Zd ZU ded< ded< ded< ded< d ed < ded < d ed < ded < d ed< ded< ded< y)� UrlSchemazRequired[Literal['url']]r� r2 r � List[str]�allowed_schemesr' � host_requiredr% � default_host� default_port� default_pathr( r� r r� r� r� Nr� rG rH rI rC rC � s@ � � "�"��O� � ��������� �L� �H��M� � rH rC � r rE rF rG rH rI r( r� r� r� c �. � t d| ||||||||| �� 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� r rE rF rG rH rI r( r� r� r� r� rJ s rI � url_schemarM � s3 � �J � � �'�#�!�!�!�� ��#� � rH c �| � e Zd ZU ded< ded< ded< ded< d ed < ded < d ed < ded < d ed< ded< ded< y)�MultiHostUrlSchemaz#Required[Literal['multi-host-url']]r� r2 r rD rE r' rF r% rG rH rI r( r� r r� r� r� Nr� rG rH rI rO rO s@ � � -�-��O� � ��������� �L� �H��M� � rH rO c �. � t d| ||||||||| �� 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� rL r� rJ s rI �multi_host_url_schemarQ % s3 � �J � � �'�#�!�!�!�� ��#� � rH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) �DefinitionsSchemaz Required[Literal['definitions']]r� r� r� rk � definitionsr r� r� r� Nr� rG rH rI rS rS Y s � � *�*� � �+�+��M� � rH rS c � � t d| |�� 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� rT s rI �definitions_schemarV a s � �( �-��K� X�XrH c �@ � e Zd ZU ded< ded< ded< ded< d ed < y ) �DefinitionReferenceSchemaz#Required[Literal['definition-ref']]r� r� � schema_refr% r� r r� r� r� Nr� rG rH rI rX rX x s � � -�-� � � �H��M� � rH rX c �" � t d| |||�� 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� rY r� r� r� r� )rY r� r� r� s rI �definition_reference_schemar\ � s � �4 � �*�#��`m� � rH )0r� r� r' r2 r� r� r% r� r r r r r. r7 r> rE rJ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r r& r3 r8 r= r� r� r� rT r[ r� )r r r� 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 ��ci c] \ }}|�� ||�� c}}S c c}}w rO )�items)�kwargs�k�vs rI r� r� v s, � � #�\�\�^� =�^�T�Q��q�}�A�q�D�^� =�=�� =s � (�(�c`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.c �T � t j dt � t | |fd|i|��S )Nr� rt ��warnings�warn�DeprecationWarningr� �r� rt r� 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 � t j dt � 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 � t j dt � 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 � t j dt � 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 � t j dt � 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 � t j dt � 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 � t j dt � t | fd|i|��S )Nr� rt �r� r� r� r� )r� rt r� 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 � t j dt � t | i |��S )Nr� r� r� s rI � general_plain_validator_functionr� � r� rH )�FieldValidationInfo�FieldValidatorFunction�GeneralValidatorFunction�FieldWrapValidatorFunctionc � � t j | � }|�t d| � d�� �dd l}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� rB r� 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� �ExpectedSerializationTypesrm r� ) r� �SerializerFunctionr� � bool | Noner� r� r� �CoreSchema | Noner� r� rm r� )r� �WrapSerializerFunctionr� r� r� r� r� r� r� r� r� r� rm r� )r� r% r� r� rm r� )r� r� rm r� )r� � Type[Any]r� r� rm r� ) r� r% r� r� r� r� r� r rm r� )r� r� r� r r� �SerSchema | Nonerm r� )r� r� r� r r� r� rm r� )NNNN) r( r� r� r� r� r r� r� rm r� )r� � int | Noner� r� r� r� r� r� r� r� r( r� r� r� r� r r� r� rm r� )r8 r� r� � float | Noner� r� r� r� r� r� r� r� r( r� r� r� r� r r� r� rm r� )r8 r' r� �Decimal | Noner� r� r� r� r� r� r� r� r� r� r� r� r( r� r� r� r� r r� r� rm r� )r� zstr | Pattern[str] | Noner r� r r� r r� r r� r r� r@ z)Literal['rust-regex', 'python-re'] | Noner( r� r> r� r� r� r� r r� r� rm r� )r r� r r� r( r� r� r� r� r r� r� rm r )r( r� r� � date | Noner� r� r� r� r� r� r � Literal['past', 'future'] | Noner r� r� r� r� r r� r� rm r )r( r� r� � time | Noner� r� r� r� r� r� r �&Literal['aware', 'naive'] | int | Noner r r� r� r� r r� r� rm r )r( r� r� �datetime | Noner� r r� r r� r r r� r r� r r� r r r� r� r� r r� r� rm r )r( r� r� �timedelta | Noner� r r� r r� r r r r� r� r� r r� r� rm r% ) r, � list[Any]r� r� r� r r� r� rm r* )r� r r3 r r4 z%Literal['str', 'int', 'float'] | Noner5 zCallable[[Any], Any] | Noner( r� r� r� r� r r� r� rm r1 ) r� r r< r� r� r� r� r r� r� rm r; ) r� r� r< r� r� r� r� r r� r� rm r; )r� r� r� r r� r� rm rH ) rN zLiteral[1, 3, 4, 5] | Noner( r� r� r� r� r r� r� rm rM )rR �Set[int] | NonerU r rm rS rO )rZ r� r r� r r� r[ r� r( r� r� r� r� r r� � IncExSeqOrElseSerSchema | Nonerm rY )rZ �list[CoreSchema]ra r� r( r� r� r� r� r r� r rm rb )rZ r� r r� r r� r( r� r� r� r� r r� r rm rb )rZ r rd r� r r� r r� r[ r� r( r� r� r� r� r r� r rm rb )rZ r� r r� r r� r[ r� r( r� r� r� r� r r� r� rm rn )rZ r� r r� r r� r[ r� r( r� r� r� r� r r� r� rm rr )rZ r� r r� r r� r� r� r� r r� r rm rv )rR �IncExDict | NonerU r rm rz )NN)r� r� r� r� r r� r r� r( r� r� r� r� r r� r� rm r ) r� r� r� r� r� r� r� r r� r� rm r� )r� �WithInfoValidatorFunctionr� r� rt r� r� r� r� r r� r� rm r� ) r� r� r� r� r� r� r� r r� r� rm r� )r� r r� r� rt r� r� r� r� r r� r� rm r� ) r� r� r� r� r� r� r� r r� r� rm r� )r� � WithInfoWrapValidatorFunctionr� r� rt r� r� r� r� r r� r� rm r� ) r� r� r� r� r� r r� r� rm r� ) r� r rt r� r� r� r� r r� r� rm r� )r� r� r� r r� zCallable[[], Any] | Noner� z*Literal['raise', 'omit', 'default'] | Noner0 r� r( r� r� r� r� r r� r� rm r� ) r� r� r( r� r� r� r� r r� r� rm r� )r� z)list[CoreSchema | tuple[CoreSchema, str]]r� r� r� r� r� r� r� zdict[str, str | int] | NonerY z(Literal['smart', 'left_to_right'] | Noner( r� r� r� r� r r� r� rm r� )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� r r� r� rm r� ) r� r r� r� r� r r� r� rm r� )r� r� r� r� r( r� r� r� r� r r� r� rm r� ) r� r� r� r� r� r� r� r r� r� rm r� )r� r� r� r� r� �4str | list[str | int] | list[list[str | int]] | Noner� r� r� r� r� r rm r� )r� zDict[str, TypedDictField]r� �list[ComputedField] | Noner( r� ra r� r� �ExtraBehavior | NonerJ r� r1 r� r� r� r� r r� r� rz r rm r� )r� r� r� r r� r� r� r� r r� r� r rm r� )r� zDict[str, ModelField]r r� r� r r( r� ra r� r� r r1 r� r, r� r� r� r� r r� r� rm r ) r� r� r� r� r r� r r� r r� r/ �7Literal['always', 'never', 'subclass-instances'] | Noner( r� r r� r� r rz r r� r� r� r r� r� rm r )r r% r� r� r r� r r� r r� r� r r� r� r� r� r� r r r� rm r )r r% r� zlist[DataclassField]r� zList[ComputedField] | Noner1 r� r r� r� r� r� r r� r� r� r rm r ) r� r� r� r� r� rD r# r� r r� r/ r r( r� r� r� r� r r� r� r r� r$ r� rz r rm r" ) r r% r� r� rY zJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Noner� r rm r) )r3 zlist[ArgumentsParameter]r1 r� r0 r� r1 r� r� r� r� r r� r� rm r. )r3 r� r� zCallable[..., Any]r6 r� r� r� r� r� r� r r� r� rm r5 )r� r� r� r% r� r� r� zdict[str, Any] | Noner� r� r� r r� r� rm r; ) r� r� r� r� r� r r� r� rm r@ )r r� rE �list[str] | NonerF r� rG r� rH r� rI r� r( r� r� r� r� r r� r� rm rC )r r� rE r rF r� rG r� rH r� rI r� r( r� r� r� r� r r� r� rm rO )r� r� rT r rm rS )NNN) rY r% r� r� r� r r� r� rm rX )r� r rm r )r� r rt r% r� r� )r� r rt r% r� r� )r� r rt r% )r� r% rm �object)�rE � __future__r � _annotations�sysr� �collections.abcr r r r r r� r �typingr r r r r r r r r r r �typing_extensionsr � version_infor r r r r � pydantic_corer � ImportErrorr r) r$ rK rF rM rr rv r� 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� r r r r r r r r r# r% r( r* r/ r1 r8 �JsonTyper; rA rC rF rH rK rM rQ rS rW r\ rY r` rg ri rb rf rn rp rr rt rv rx r2 r% r{ rz r} r� r r� r� r� r r� �ValidationFunctionr� r� r� r� r� r� r� r� r� r� r r� �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� r r r r r r r r r r" r' r) r, r. r/ r5 r9 r; r> r@ r� rC rM rO rQ rS rV rX r\ �MYPYr� �CoreSchemaType�CoreSchemaFieldType� ErrorTyper� r� r� r� r� r� r� r� r� r� r� r� rG rH rI �<module>r' s# ��� 3� � � #� 4� 4� � g� g� g� g� (����g� �+� ����g� �?�?�4�4����f� �)� ��/� %�3� �3�4� �D?��%� D?�N L� �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
[+]
..
[-] core_schema.cpython-312.pyc
[edit]
[-] __init__.cpython-312.pyc
[edit]