�
c��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