fields.cpython-312.pyc•62.8 kB
�
�MMg/� � $ �� � U d Z ddlmZ ddlZddlZddlZddlZddlmZ ddlm Z
ddl m Z ddlm
Z
mZmZmZmZmZ ddlmZ ddlZddlZdd lmZ dd
lmZmZmZm Z d d l m Z d d
l m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& d dl'm(Z(m)Z) d dl*m+Z+m,Z, d dl-m.Z. d dl/m0Z0 d dl1m2Z2 d dlm3Z3 ejh rd dl5m6Z6 ne3Z7dZ8eZ9de:d< ejv dk\ rddlZej8 e z Z<de:d< ne Z<de:d< G d� d ejz d � � Z> G d � d e>d � � Z? G d!� d"e$j� � ZA G d#� d$ejz � ZBi d%d&�d'd�d(d�d)d�d*d�d+d�d,d�d-d�d.d�d/d�d0d�d1d�d2d�d3d�d4d5�d6d�d7d�ddddddddddddddd8��ZC ed9� ZDee9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9d:�! dRd<�� Z ee9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9d:�! dSd=�� Z ee9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9d:�! dTd>�� Z ee9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9d:�! dUd?�� Z efe9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9d@�" dVdA�Z eE ej� e � j� � ZHeHj� d;� G dB� dCe$j� � ZJed dD� dWdE�� ZKed dD� dXdF�� ZKed dD� dYdG�� ZKefdd dH� dZdI�ZK ej� d[i e#j� �� G dJ� dK� � ZNd\dL�ZO ej dM� ZPej$ ddddddddd5edN�
d]dO�� ZQej$ d^dP�� ZQ d_dddddddddedN�
d`dQ�ZQy)azDefining fields on models.� )� annotationsN)�copy)�Field)�cached_property)�Any�Callable�ClassVar�TypeVar�cast�overload)�warn)�PydanticUndefined)�Literal� TypeAlias�Unpack�
deprecated� )�types)� _decorators�_fields� _generics�_internal_dataclass�_repr�
_typing_extra�_utils)�GlobalsNamespace�MappingNamespace)� AliasChoices� AliasPath)�JsonDict)�PydanticUserError)�PydanticJsonSchemaWarning)�PydanticDeprecatedSince20)�ReprArgs)r � PrivateAttr�computed_fieldr �_Unset)� �
r �
Deprecatedc �p � e Zd ZU dZded< ded< ded< ded < d
ed < ded < ded
< ded< ded< ded< ded< ded< ded< ded< ded < d ed < ded < ded < ded!< d"ed#< ded$< ded%< ded&< d'ed(< d)ed*< d+ed,< d-ed.< ded/< ded0< d1ed2< ded3< ded4< ded5< ded6< ded7< y8)9�_FromFieldInfoInputsz[This class exists solely to add type checking for the `**kwargs` in `FieldInfo.from_field`.�type[Any] | None�
annotation�:Callable[[], Any] | Callable[[dict[str, Any]], Any] | None�default_factory�
str | None�alias�
int | None�alias_priority�%str | AliasPath | AliasChoices | None�validation_alias�serialization_alias�title�&Callable[[str, FieldInfo], str] | None�field_title_generator� description�list[Any] | None�examples� bool | None�exclude�!annotated_types.SupportsGt | None�gt�!annotated_types.SupportsGe | None�ge�!annotated_types.SupportsLt | None�lt�!annotated_types.SupportsLe | None�le� float | None� multiple_of�strict�
min_length�
max_length� str | typing.Pattern[str] | None�pattern�
allow_inf_nan�
max_digits�decimal_placesz(Literal['smart', 'left_to_right'] | None�
union_mode� str | types.Discriminator | None�
discriminator� Deprecated | str | bool | Noner �,JsonDict | Callable[[JsonDict], None] | None�json_schema_extra�frozen�validate_default�bool�repr�init�init_var�kw_only�coerce_numbers_to_str� fail_fastN��__name__�
__module__� __qualname__�__doc__�__annotations__� � �[C:\Users\noahv\Documents\GitHub\clickup-operator\.venv\Lib\site-packages\pydantic/fields.pyr, r, 1 s� � �e� � �O�O� �� � �;�;�#�#� ��A�A��� � �
��)�)�)�)�)�)�)�)� � � ������
-�-� � ��� � �8�8�3�3�.�.�C�C� ��!�!�
�J�
����
��&�&��rh r, F)�totalc � � e Zd ZU dZded< y)�_FieldInfoInputszYThis class exists solely to add type checking for the `**kwargs` in `FieldInfo.__init__`.r �defaultNra rg rh ri rl rl Y s
� �c�
�Lrh rl c �� � e Zd ZU dZded< ded< ded< ded < d
ed < d ed
< ded< ded< ded< ded< ded< ded< ded< ded< ded < ded < ded < d ed < ded!< ded"< ded#< d$ed%< d&Zej ej ej ej ej ej ej ej d'd'd'd'd'd'ej d(�Zd)ed*< d@d+�ZeefdAd,�� ZedBd-�� ZedCd.�� ZedDd/�� ZedEd0�� ZedFd1�� ZedGd2�� Ze dHd3�� Z e d'd4� dId5�� Z e d6d7�dJd8�� Z d9d'd:�dKd;�Z dLd<�Z dMd=�Z! dN dOd>�Z"dPd?�Z#y')Q� FieldInfoa� This class holds information about a field.
`FieldInfo` is used for any field definition regardless of whether the [`Field()`][pydantic.fields.Field]
function is explicitly used.
!!! warning
You generally shouldn't be creating `FieldInfo` directly, you'll only need to use it when accessing
[`BaseModel`][pydantic.main.BaseModel] `.model_fields` internals.
Attributes:
annotation: The type annotation of the field.
default: The default value of the field.
default_factory: A callable to generate the default value. The callable can either take 0 arguments
(in which case it is called as is) or a single argument containing the already validated data.
alias: The alias name of the field.
alias_priority: The priority of the field's alias.
validation_alias: The validation alias of the field.
serialization_alias: The serialization alias of the field.
title: The title of the field.
field_title_generator: A callable that takes a field name and returns title for it.
description: The description of the field.
examples: List of examples of the field.
exclude: Whether to exclude the field from the model serialization.
discriminator: Field name or Discriminator for discriminating the type in a tagged union.
deprecated: A deprecation message, an instance of `warnings.deprecated` or the `typing_extensions.deprecated` backport,
or a boolean. If `True`, a default deprecation message will be emitted when accessing the field.
json_schema_extra: A dict or callable to provide extra JSON schema properties.
frozen: Whether the field is frozen.
validate_default: Whether to validate the default value of the field.
repr: Whether to include the field in representation of the model.
init: Whether the field should be included in the constructor of the dataclass.
init_var: Whether the field should _only_ be included in the constructor of the dataclass, and not stored.
kw_only: Whether the field should be a keyword-only argument in the constructor of the dataclass.
metadata: List of metadata constraints.
r- r. r rm r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> r? rS rT rU r rV rW rX rY rZ r[ r\ r] r^ � list[Any]�metadata)r. � evaluatedrm r0 r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rY r[ r\ r] r^ rq �_attributes_setN)rJ rA rC rE rG rI rK rL rN rO rP rQ rR r_ r` z7ClassVar[dict[str, typing.Callable[[Any], Any] | None]]�metadata_lookupc �r � |j � D ��ci c] \ }}|t us�||�� c}}| _ |j � D ��ci c]% \ }}||t u rt j |� n|��' }}}| j |j d� � \ | _ }d| _ |j dt � }|t u r(t | _ | j j dd� n|| _ |j dd� | _ | j t ur| j � t d� �|j dd� | _ |j dd� | _ |j d d� | _ t# d
� | j | j | j fD � � }|r|j d d� xs d nd| _ |j d
d� | _ |j dd� | _ |j dd� | _ |j dd� | _ |j dd� | _ |j dd� | _ |j dt3 | dd� � | _ |j dd� | _ |j dd� | _ |j dd� | _ |j dd� | _ |j dd� | _ |j dd� | _ |j dd� | _! | jE |� |z | _# yc c}}w c c}}w ) a This class should generally not be initialized directly; instead, use the `pydantic.fields.Field` function
or one of the constructor classmethods.
See the signature of `pydantic.fields.Field` for more details about the expected arguments.
r. Frm Nr0 �/cannot specify both default and default_factoryr2 r6 r7 c 3 �$ K � | ] }|d u�� �
y �w�Nrg )�.0r2 s ri � <genexpr>z%FieldInfo.__init__.<locals>.<genexpr>� s � �� �x�:w��5��,�:w�s �r4 � r8 r: r; r= r? rT r r[ TrW rY rX r\ r] r^ )$�itemsr' rs �_DefaultValues�get�_extract_metadatar. rr �popr �Ellipsisrm r0 � TypeErrorr2 r6 r7 �anyr4 r8 r: r; r= r? rT �getattrr r[ rW rY rX r\ r] r^ �_collect_metadatarq )�self�kwargs�k�v�annotation_metadatarm � alias_is_sets ri �__init__zFieldInfo.__init__� s� � � 28� � � � S� ���A�1�F�?��1�� � S�� �MS�\�\�^�\�^�T�Q��!�a�6�k�^�'�'��*�q�@�^��\�/3�/E�/E�f�j�j�Q]�F^�/_�,���,� ����*�*�Y�(9�:�� �h� �,�D�L�
� � � $� $�Y�� 5�"�D�L� %�z�z�*;�T� B�� � �<�<� 0� 0�T�5I�5I�5U�� M�N� N��Z�Z���.��
� &�
�
�+=�t� D�� �#)�:�:�.C�T�#J�� ��x�4�:�:�t�G\�G\�^b�^v�^v�:w�x�x� �IU�f�j�j�)9�4� @� E�A�[_����Z�Z���.��
�%+�Z�Z�0G��%N��"�!�:�:�m�T�:��� �
�
�:�t�4��
� �z�z�)�T�2�� � #�Z�Z��� >��� �*�*�\�7�4� �t�3T�U����J�J�v�t�,�� �!'���,?��!F�� � &�
�
�+=�t� D�� � �j�j��4�0�� ��J�J�v�t�,�� � �
�
�:�t�4��
� �z�z�)�T�2�� � �.�.�v�6�9L�L��
��U T��\s �L-�L-�*L3c �: � d|v r t d� �t dd| i|��S )a~ Create a new `FieldInfo` object with the `Field` function.
Args:
default: The default value for the field. Defaults to Undefined.
**kwargs: Additional arguments dictionary.
Raises:
TypeError: If 'annotation' is passed as a keyword argument.
Returns:
A new FieldInfo object with the given parameters.
Example:
This is how you can create a field with default value like this:
```python
import pydantic
class MyModel(pydantic.BaseModel):
foo: int = pydantic.Field(4)
```
r. z9"annotation" is not permitted as a Field keyword argumentrm rg )r� ro )rm r� s ri �
from_fieldzFieldInfo.from_field� s+ � �0 �6� !�� W�X� X��3��3�F�3�3rh c �� � d}t j | � r,d}| t j urt j | � d } t j
| � �rt j | � ^}}t j |� rd}|D �cg c] }t
|t � s�|�� }}t j |d|i�}|r�t |� }||_
|xs |j |_ g }|D ]f }t j |� r|j |_ �*t
|t � s|j |� �L|j! |j" � �h ||_ |S t | |xs d�� S c c}w )a� Creates a `FieldInfo` instance from a bare annotation.
This function is used internally to create a `FieldInfo` from a bare annotation like this:
```python
import pydantic
class MyModel(pydantic.BaseModel):
foo: int # <-- like this
```
We also account for the case where the annotation can be an instance of `Annotated` and where
one of the (not first) arguments in `Annotated` is an instance of `FieldInfo`, e.g.:
```python
import annotated_types
from typing_extensions import Annotated
import pydantic
class MyModel(pydantic.BaseModel):
foo: Annotated[int, annotated_types.Gt(42)]
bar: Annotated[int, pydantic.Field(gt=42)]
```
Args:
annotation: An annotation object.
Returns:
An instance of the field metadata.
FTr r. N)r. rX )r � is_finalvar�typing_extensions�Final�get_args� is_annotated�
isinstancero �merge_field_infosr r. rX �is_deprecated_instance�messager �append�extendrq ) r. �final� first_arg�
extra_args�a�field_info_annotations�
field_info�new_field_inforq s ri �from_annotationzFieldInfo.from_annotation sJ � �B �� � $� $�Z� 0��E��!2�!8�!8�8� .� 7� 7�
� C�A� F�
� � %� %�j� 1�%6�%?�%?�
�%K� "�I�
� �(�(��3� ��1;�%X��A�z�!�Y�?W�a�� "�%X�"�4�4�6L�c�Yb�c�J��!%�j�!1��,5��)�(-�(B��1B�1B��%�&(��#�A�$�;�;�A�>�45�I�I��1� '��9� 5� ����*� ����
�
�3�
$� +3��'�%�%��J�u�}��E�E��# &Ys � E-�"E-c
�L � | |u r
t dd�� �t j | � }|r*| t j urt j
| � d } t
|t � r�t j | � \ |_ }|xj |z
c_
|j g |D �cg c] }t
|t � s�|�� c}�|��d|j i�}|xs |j |_ |S t
|t j � �r&d}| t j u r!d}t! j" t$ t$ � } n(t
| t j � rd}| j& } t j) |� }t j | � \ |_ }|xj |z
c_
|j g |D �cg c] }t
|t � s�|�� c}�|��d|j i�}|xs |j |_ ||_ t- |dd � |_ t- |d
d � |_ |S t j2 | � r�t j
| � ^}}|D � cg c] } t
| t � s�| �� }
} t j |
||d ��} g } |D ]f } t j4 | � r| j6 | _ �*t
| t � s| j; | � �L| j= | j � �h | | _
| S t | ||xs d � � S c c}w c c}w c c} w )
a� Create `FieldInfo` from an annotation with a default value.
This is used in cases like the following:
```python
import annotated_types
from typing_extensions import Annotated
import pydantic
class MyModel(pydantic.BaseModel):
foo: int = 4 # <-- like this
bar: Annotated[int, annotated_types.Gt(4)] = 4 # <-- or this
spam: Annotated[int, pydantic.Field(gt=4)] = 4 # <-- or this
```
Args:
annotation: The type annotation of the field.
default: The default value of the field.
Returns:
A field object with the passed values.
z�Error when building FieldInfo from annotated attribute. Make sure you don't have any field name clashing with a type annotation zunevaluable-type-annotation��coder r. FTr\ Nr^ )r. rm )r. rm rX ) r! r r� r� r� r� r� ro r r. rq r� rX � dataclassesr �InitVar�typingr r �type�_from_dataclass_fieldr] r� r\ r^ r� r� r� r r� r� )
r. rm r� r� �xr] �pydantic_fieldr� r� r� � field_infosr� rq s
ri �from_annotated_attributez"FieldInfo.from_annotated_attributeV s� � �2 �� �#�[�2��
� �)�)�*�5�� �Z�'8�'>�'>�>�*�3�3�J�?��B�J� �g�y� )�6?�6Q�6Q�R\�6]� 3�G� � 3� � � � 3� 3� �/�g�/�/� � 0�M� 0��J�q�)�4L�!� 0�M��OV��cj�cu�cu��G� #� 4�g�n�n�G�N��N� �g�{� 0� 0� 1� �H��[� 0� 0�0� �� #�[�[��c� 2�
��J� �(;�(;�<� �� '�_�_�
� &� <� <�W� E�N�=F�=X�=X�Yc�=d� :�N� %�':� � #� #�':� :� #� =�^� =� =� � 0�M� 0��J�q�)�4L�!� 0�M� � � � *�4�4� �N�
%*�$B�^�-B�-B�N� !�&.�N� #�")�'�6�4�"@�N� �%,�W�i��%F�N� "�!� !� � %� %�j� 1�%6�%?�%?�
�%K� "�I�
�&0�M�j��J�q�)�4L�1�j�K�M�"�4�4�k�i�ah�i�J�"$�H� �� �7�7��:�,-�I�I�J�)�#�A�y�1� �O�O�A�&� �O�O�A�J�J�/�
� #+�J� � � ��J���
�QU�V�V��W N��$ N�� Ns$ �&L
�<L
�<L
�L
� L!�3L!c � � t | � dk( r�t | d � }|j j |� |j dt
� }|t u rt
}|t
ur||_ |j � D ] \ }}t |||� � |S i }i }| D ]� }|j j � } |j d� } |j d� }
|
�| |d< t |
t � r5t | t � r i |
�| �|d< t | � r!t dt � nt | � r| |d< |j |� |j" D ]! } t | t$ � r�| |t' | � < �# �� |j |� t% di |��}t) |j+ � � |_ |S # t $ r Y ��w xY w)z�Merge `FieldInfo` instances keeping only explicitly set attributes.
Later `FieldInfo` instances override earlier ones.
Returns:
FieldInfo: A merged FieldInfo instance.
r r rm rW z�Composing `dict` and `callable` type `json_schema_extra` is not supported.The `callable` type is being ignored.If you'd like support for this behavior, please open an issue on pydantic.rg )�lenr rs �updater� r r� rm r| �setattrr~ r� �dict�callabler
r" �KeyErrorrq ro r� �list�values) r� � overridesr� �default_overrider� r� �merged_field_info_kwargsrq �attributes_setrW �existing_json_schema_extrar� s ri r� zFieldInfo.merge_field_infos� s� � � �{� �q� � �k�!�n�-�J� � &� &� -� -�i� 8� (�}�}�Y�8I� J� � �8�+�#4� � �'8�8�%5�
�"�!���)���1��
�A�q�)� *� � �35� ���%�J� '� 7� 7� <� <� >�N�
�$2�$6�$6�7J�$K�!�-E�-I�-I�J]�-^�*�-�5�DU�,�-@�A� � 8�$�?�!�"3�T�:�I� 8�I� /�I�0�1D�E� � 1�2� � i� 6� � � /�0�DU�,�-@�A�
%� +� +�N� ;� �(�(��!�!�Y�/�()�H�T�!�W�%� )�? &�F !�'�'� �2� �:�!9�:�
� "�8�?�?�#4� 5�
����� �
��
�s �6A>F3�3 F?�>F?c �R � | j }|t j u rt }| j t j u rt }n | j }| j
j
� D ��ci c] \ }}|t v s�||�� }}}t d||| j d�|��S c c}}w )a] Return a new `FieldInfo` instance from a `dataclasses.Field` instance.
Args:
dc_field: The `dataclasses.Field` instance to convert.
Returns:
The corresponding `FieldInfo` instance.
Raises:
TypeError: If any of the `FieldInfo` kwargs does not match the `dataclass.Field` kwargs.
)rm r0 r[ rg )
rm r� �MISSINGr' r0 rq r| �_FIELD_ARG_NAMESr r[ )�dc_fieldrm r0 r� r� �dc_field_metadatas ri r� z FieldInfo._from_dataclass_field� s� � � �"�"�� �k�)�)� )� �G� � #� #�{�':�':� :� $�O� &� 6� 6�O� /7�.?�.?�.E�.E�.G� a�.G�d�a��1�P`�K`�Q��T�.G�� a��o�W�o�H�M�M�o�]n�o�o�� bs �1B#�B#c � � | �9t j | � r$t j | � ^}}|t |� fS | g fS )a/ Tries to extract metadata/constraints from an annotation if it uses `Annotated`.
Args:
annotation: The type hint annotation for which metadata has to be extracted.
Returns:
A tuple containing the extracted metadata type and the list of extra arguments.
)r r� r� r� r� )r. r� r� s ri r zFieldInfo._extract_metadata sG � � � !� �)�)�*�5�):�)C�)C�J�)O�&� �J� �$�z�"2�2�2��2�~� rh c �, � g }i }t | j � � D ]> \ }} t j | }| |= |�� |�|||< �(|j ||� � �@ |r$|j t
j di |��� |S # t $ r Y �tw xY w)a Collect annotations from kwargs.
Args:
kwargs: Keyword arguments passed to the function.
Returns:
A list of metadata objects - a combination of `annotated_types.BaseMetadata` and
`PydanticMetadata`.
rg )r� r| ro rt r� r� r �pydantic_general_metadata)r� rq �general_metadata�key�value�markers ri r� zFieldInfo._collect_metadata s� � � !�� �� �v�|�|�~�.�J�C��
�"�2�2�3�7�� �s� �� ��>�,1�$�S�)� �O�O�F�5�M�2� /� � �O�O�G� =� =� Q�@P� Q� R���� �
��
�s �B� B�Bc �� � | j �yt | j t � r| j rdS dS t | j t � r | j S | j j S �z<The deprecation message to be emitted, or `None` if not set.Nr �r r� rZ �strr� �r� s ri �deprecation_messagez FieldInfo.deprecation_message5 �V � � �?�?� "�� �d�o�o�t� ,�#'�?�?�<� <�� <�",�T�_�_�c�"B�t���_����H_�H_�_rh )�validated_datac � � y rx rg )r� �call_default_factoryr� s ri � get_defaultzFieldInfo.get_default> s � � rh .)r� c � � y rx rg )r� r� s ri r� zFieldInfo.get_defaultC s � �QTrh F)r� r� c �, � | j � t j | j � S |rgt j
| j � r |� t
d� �| j |� S t t g t f | j � } |� S y)a` Get the default value.
We expose an option for whether to call the default_factory (if present), as calling it may
result in side effects that we want to avoid. However, there are times when it really should
be called (namely, when instantiating a model via `model_construct`).
Args:
call_default_factory: Whether to call the default factory or not.
validated_data: The already validated data to be passed to the default factory.
Returns:
The default value, calling the default factory if requested or `None` if not set.
NznThe default factory requires the 'validated_data' argument, which was not provided when calling 'get_default'.)
r0 r �smart_deepcopyrm r � takes_validated_data_argument�
ValueErrorr r r )r� r� r� �facs ri r� zFieldInfo.get_defaultF s� � � � � � '��(�(�� � �6� 6�
!��4�4�T�5I�5I�J�!�)�$� I�� � �+�+�N�;�;��8�B��G�,�d�.B�.B�C���u� �rh c �F � | j t u xr | j du S )z�Check if the field is required (i.e., does not have a default value or factory).
Returns:
`True` if the field is required, `False` otherwise.
N)rm r r0 r� s ri � is_requiredzFieldInfo.is_requiredc s$ � � �|�|� 0�0�Q�T�5I�5I�T�5Q�Qrh c � � | j s | j S t j | j g| j �� S )a( Attempts to rebuild the original annotation for use in function signatures.
If metadata is present, it adds it to the original annotation using
`Annotated`. Otherwise, it returns the original annotation as-is.
Note that because the metadata has been flattened, the original annotation
may not be reconstructed exactly as originally provided, e.g. if the original
type had unrecognized annotations, or was annotated with a call to `pydantic.Field`.
Returns:
The rebuilt annotation.
)rq r. r� � Annotatedr� s ri �rebuild_annotationz FieldInfo.rebuild_annotationk s8 � � �}�}��?�?� "� %�.�.����/P�$�-�-�/P�Q� Qrh c � � t j | j ||� \ }}t j ||� | _ y)a� Apply a `typevars_map` to the annotation.
This method is used when analyzing parametrized generic types to replace typevars with their concrete types.
This method applies the `typevars_map` to the annotation in place.
Args:
typevars_map: A dictionary mapping type variables to their concrete types.
globalns: The globals namespace to use during type annotation evaluation.
localns: The locals namespace to use during type annotation evaluation.
See Also:
pydantic._internal._generics.replace_types is used for replacing the typevars with
their concrete types.
N)r �
try_eval_typer. r �
replace_types)r� � typevars_map�globalns�localnsr. �_s ri �apply_typevars_mapz FieldInfo.apply_typevars_map~ s4 � �* &�3�3�D�O�O�X�w�W�
�
�A�#�1�1�*�l�K��rh c # �� K � dt j t j | j � � f�� d| j � f�� | j
D �] }|dv r� |dk( r
| j s�|dk( r| j du r�/|dk( r| j du r�C|d k( r| j | j k( r�b|d
k( r| j | j k( r��|d k( r#| j t urd | j f�� ��|d k( rC| j �7d t j t j | j � � f�� ��t | |� }|���|t us�� ||f�� �� y �w)
Nr. �required)rs r. rr rq r[ TrX Fr6 r7 rm r0 )r � PlainRepr�display_as_typer. r� � __slots__rq r[ rX r6 r2 r7 rm r r0 r� )r� �sr� s ri �
__repr_args__zFieldInfo.__repr_args__� sK � �� ��E�O�O�E�,A�,A�$�/�/�,R� S�S�S��$�*�*�,�,�,�� � �A� �B�B���j� �� � ���f�����d�!2���H�}�����!5���&�&�4�+@�+@�D�J�J�+N���)�)�d�.F�.F�$�*�*�.T���I�~�$�,�,�6G�"G� �� � �-�-��'�'�D�,@�,@�,L�'�� � ��9N�9N�t�Oc�Oc�9d�)e�e�e� ��a�(���$��6G�)G��U�(�N�- �s �EE.�E.�$
E.)r� zUnpack[_FieldInfoInputs]�return�None)rm r r� z Unpack[_FromFieldInfoInputs]r� ro )r. � type[Any]r� ro )r. r� rm r r� ro )r� ro r� r r� ro )r� zDataclassField[Any]r� ro )r. r- r� z"tuple[type[Any] | None, list[Any]])r� zdict[str, Any]r� rp �r� r1 )r� z
Literal[True]r� �dict[str, Any] | Noner� r )r� �Literal[False]r� r )r� rZ r� r� r� r )r� rZ �r� r )NN)r� zdict[Any, Any] | Noner� zGlobalsNamespace | Noner� zMappingNamespace | Noner� r� )r� r$ )$rb rc rd re rf r� r �Strict�annotated_types�Gt�Ge�Lt�Le�
MultipleOf�MinLen�MaxLen�FailFastrt r� � staticmethodr r� r� r� r� r� r r� �propertyr� r r� r� r� r� r� rg rh ri ro ro _ sQ � �"�H !� �
�L�O�O� �� � �;�;�#�#� ��A�A��� � �
��3�3�.�.�C�C� ��!�!�
�J�
����
�����I�< �,�,� � � � � � � � � � � � �&�1�1�%�,�,�%�,�,�� �� ��!%��^�^� P�O�L� �$0M�d �"3� 4� �4�6 �;F� �;F�z �RW� �RW�h �?� �?�B �p� �p�2 � � � � �� ��8 �`� �`� �^b��'4��F[�� �� �� �DG�T� �T�:?�im� �:R�R�, -1�+/� L�+�L� *�L� )� L�
� L�0#rh ro c � � e Zd ZdZy)� _EmptyKwargsz_This class exists solely to ensure that type checking warns about passing `**extra` in `Field`.N)rb rc rd re rg rh ri r r � s � �irh r rm .r0 r2 r4 r6 r7 r8 r; r= r? rT rW rX rY r[ Tr\ r] )r^ rN rJ rA rC rE rG rI rO rP rQ rK rL r_ �_T)!r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rY r[ r\ r] r^ rN rJ r_ rA rC rE rG rI rO rP rQ rK rL rR r` �extrac ! � � y rx rg �#rm r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rY r[ r\ r] r^ rN rJ r_ rA rC rE rG rI rO rP rQ rK rL rR r` r s# ri r r � s � �L rh c ! � � y rx rg r s# ri r r � � �L
rh c " � � y rx rg )#r0 r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rY r[ r\ r] r^ rN rJ r_ rA rC rE rG rI rO rP rQ rK rL rR r` r s# ri r r - r rh c ! � � y rx rg )"r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rY r[ r\ r] r^ rN rJ r_ rA rC rE rG rI rO rP rQ rK rL rR r` r s" ri r r T s � �J rh )"r0 r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rY r[ r\ r] r^ rN rJ r_ rA rC rE rG rI rO rP rQ rK rL rR r` c " �T � |#j dd� }$|$�
t dd�� �|#j dd� }%|%� t dt � | dt fv r|%} |#j dd� }&|&� t d t � | dt fv r|&} |#j d
d� }'|'�
t d d�� �|#j d d� }(|(�t d
t � |(du rd}|#j dd� })|)�
t dd�� �|#rDt ddj d� |#j
� D � � � d�t � |
r|
t u r|#}
|r.|t ur&t |t t t f� s t d� �|t dfv rt |t � r|}|t dfv r|}|#j dd� }*|*�t dt � t j | fi d|�d|�d|�d |�d |�d |�d |�d |�d!| �d"|
�d#| �d$| �d%|
�d&|�d'|�d(|�d)|�d*|�d+|�d,|�d-|�d.|�d/|�d0|�d1|�d2|�d3|�d4| �d5| �d6| �d7| �d8| �d9|!�d:|"��S );a� Usage docs: https://docs.pydantic.dev/2.10/concepts/fields
Create a field for objects that can be configured.
Used to provide extra information about a field, either for the model schema or complex validation. Some arguments
apply only to number fields (`int`, `float`, `Decimal`) and some apply only to `str`.
Note:
- Any `_Unset` objects will be replaced by the corresponding value defined in the `_DefaultValues` dictionary. If a key for the `_Unset` object is not found in the `_DefaultValues` dictionary, it will default to `None`
Args:
default: Default value if the field is not set.
default_factory: A callable to generate the default value. The callable can either take 0 arguments
(in which case it is called as is) or a single argument containing the already validated data.
alias: The name to use for the attribute when validating or serializing by alias.
This is often used for things like converting between snake and camel case.
alias_priority: Priority of the alias. This affects whether an alias generator is used.
validation_alias: Like `alias`, but only affects validation, not serialization.
serialization_alias: Like `alias`, but only affects serialization, not validation.
title: Human-readable title.
field_title_generator: A callable that takes a field name and returns title for it.
description: Human-readable description.
examples: Example values for this field.
exclude: Whether to exclude the field from the model serialization.
discriminator: Field name or Discriminator for discriminating the type in a tagged union.
deprecated: A deprecation message, an instance of `warnings.deprecated` or the `typing_extensions.deprecated` backport,
or a boolean. If `True`, a default deprecation message will be emitted when accessing the field.
json_schema_extra: A dict or callable to provide extra JSON schema properties.
frozen: Whether the field is frozen. If true, attempts to change the value on an instance will raise an error.
validate_default: If `True`, apply validation to the default value every time you create an instance.
Otherwise, for performance reasons, the default value of the field is trusted and not validated.
repr: A boolean indicating whether to include the field in the `__repr__` output.
init: Whether the field should be included in the constructor of the dataclass.
(Only applies to dataclasses.)
init_var: Whether the field should _only_ be included in the constructor of the dataclass.
(Only applies to dataclasses.)
kw_only: Whether the field should be a keyword-only argument in the constructor of the dataclass.
(Only applies to dataclasses.)
coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).
strict: If `True`, strict validation is applied to the field.
See [Strict Mode](../concepts/strict_mode.md) for details.
gt: Greater than. If set, value must be greater than this. Only applicable to numbers.
ge: Greater than or equal. If set, value must be greater than or equal to this. Only applicable to numbers.
lt: Less than. If set, value must be less than this. Only applicable to numbers.
le: Less than or equal. If set, value must be less than or equal to this. Only applicable to numbers.
multiple_of: Value must be a multiple of this. Only applicable to numbers.
min_length: Minimum length for iterables.
max_length: Maximum length for iterables.
pattern: Pattern for strings (a regular expression).
allow_inf_nan: Allow `inf`, `-inf`, `nan`. Only applicable to numbers.
max_digits: Maximum number of allow digits for strings.
decimal_places: Maximum number of decimal places allowed for numbers.
union_mode: The strategy to apply when validating a union. Can be `smart` (the default), or `left_to_right`.
See [Union Mode](../concepts/unions.md#union-modes) for details.
fail_fast: If `True`, validation will stop on the first error. If `False`, all validation errors will be collected.
This option can be applied only to iterable types (list, tuple, set, and frozenset).
extra: (Deprecated) Extra fields that will be included in the JSON schema.
!!! warning Deprecated
The `extra` kwargs is deprecated. Use `json_schema_extra` instead.
Returns:
A new [`FieldInfo`][pydantic.fields.FieldInfo]. The return annotation is `Any` so `Field` can be used on
type-annotated fields without causing a type error.
�constNz)`const` is removed, use `Literal` insteadzremoved-kwargsr� � min_itemszG`min_items` is deprecated and will be removed, use `min_length` instead� max_itemszG`max_items` is deprecated and will be removed, use `max_length` instead� unique_itemsz`unique_items` is removed, use `Set` instead(this feature is discussed in https://github.com/pydantic/pydantic-core/issues/296)�allow_mutationzH`allow_mutation` is deprecated and will be removed. use `frozen` insteadFT�regexz)`regex` is removed. use `pattern` insteadzzUsing extra keyword arguments on `Field` is deprecated and will be removed. Use `json_schema_extra` instead. (Extra keys: z, c 3 �< K � | ] }|j � �� � y �wrx )�__repr__)ry r� s ri rz zField.<locals>.<genexpr> s � �� �&J�\��q�z�z�|�\�s � �)zSInvalid `validation_alias` type. it should be `str`, `AliasChoices`, or `AliasPath`�includezS`include` is deprecated and does nothing. It will be removed, use `exclude` insteadr0 r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rN rY r[ r\ r] r^ r_ rJ rA rC rE rG rI rK rL rO rP rQ rR r` )r� r! r
�DeprecationWarningr' �join�keysr� r� r r r� ro r� )+rm r0 r2 r4 r6 r7 r8 r: r; r= r? rT r rW rX rY r[ r\ r] r^ rN rJ r_ rA rC rE rG rI rO rP rQ rK rL rR r` r r r
r r r r r s+ ri r r z sJ � �R
�I�I�g�t� $�E� �� � K�Rb�c�c�� � �+�t�,�I�� � �
V�Xj�k� �$�� � '�"�J�� � �+�t�,�I�� � �
V�Xj�k� �$�� � '�"�J��9�9�^�T�2�L�� � �f� "�
�
� �Y�Y� /��6�N��!� �
W�Yk�l� �U� "��F� �I�I�g�t� $�E� �� � K�Rb�c�c� � �
� !�Y�Y�&J�U�Z�Z�\�&J� J� K�1�
N�
�
� !�$5��$?� %� � � �F� *��+�c�<��-K�L��m�n�n��v�t�n�,��E�3�1G� #���F�D�>�)� ���i�i� �4�(�G��� �
b�dv�w� � � ��$ �'�$ � �$ � &� $ �
*� $ � 0�
$ � �$ � 4�$ � �$ � �$ � �$ � $�$ � �$ � ,� $ � � $ � �!$ �" *�#$ �$ �%$ �& �'$ �( �)$ �* �+$ �, 4�-$ �. �/$ �0 �1$ �2 �3$ �4 �5$ �6 �7$ �8 �9$ �: �;$ �< �=$ �> $�?$ �@ �A$ �B &�C$ �D �E$ �F �G$ � $rh c �h � e Zd ZdZdZefdd� d
d�Zej sd d�Z d d�Z
d
d�Z dd �Z y)�ModelPrivateAttra� A descriptor for private attributes in class models.
!!! warning
You generally shouldn't be creating `ModelPrivateAttr` instances directly, instead use
`pydantic.fields.PrivateAttr`. (This is similar to `FieldInfo` vs. `Field`.)
Attributes:
default: The default value of the attribute if not provided.
default_factory: A callable function that generates the default value of the
attribute if not provided.
)rm r0 N�r0 c �V � |t u rt | _ || _ y || _ || _ y rx )r� r rm r0 )r� rm r0 s ri r� zModelPrivateAttr.__init__\ s. � � �h� �,�D�L� /�� � #�D�L� .�� rh c � � |dv r,t | j |� rt | j |� S t t | � j
�d|��� �)z�This function improves compatibility with custom descriptors by ensuring delegation happens
as expected when the default value of a private attribute is a descriptor.
> �__get__�__set__�
__delete__z object has no attribute )�hasattrrm r� �AttributeErrorr� rb )r� �items ri � __getattr__z ModelPrivateAttr.__getattr__h sP � � �;�;��4�<�<��.�"�4�<�<��6�6� �D��J�$7�$7�#:�:S�TX�S[�!\�]� ]rh c �r � | j }|t u ryt |dd� }t |� r
|||� yy)zMPreserve `__set_name__` protocol defined in https://peps.python.org/pep-0487.N� __set_name__)rm r r� r� )r� �cls�namerm �set_names ri r& z ModelPrivateAttr.__set_name__q s< � ��,�,�� �'� '� ��7�N�D�9�� �H� � �S�$� � rh c �x � | j � t j | j � S | j � S )aU Retrieve the default value of the object.
If `self.default_factory` is `None`, the method will return a deep copy of the `self.default` object.
If `self.default_factory` is not `None`, it will call `self.default_factory` and return the value returned.
Returns:
The default value of the object.
)r0 r r� rm r� s ri r� z ModelPrivateAttr.get_defaultz s3 � � 7;�6J�6J�6R�v�$�$�T�\�\�2�n�X\�Xl�Xl�Xn�nrh c � � t || j � xr1 | j | j f|j |j fk( S rx )r� � __class__rm r0 )r� �others ri �__eq__zModelPrivateAttr.__eq__� sF � ��%�� � �0�
�d�l�l�D�DX�DX�5Y� �M�M� � !� !�^
� 6
�
rh )rm r r0 z typing.Callable[[], Any] | Noner� r� )r# r� r� r )r' r� r( r� r� r� r� )r- r r� rZ )
rb rc rd re r� r r� r� �
TYPE_CHECKINGr$ r& r� r. rg rh ri r r M sY � �
� /�I� /�/�fj�/��/�Dc�/�
�/� � � � ^� �
o�
rh r �r\ c � � y rx rg )rm r\ s ri r% r% � � � �
rh c � � y rx rg �r0 r\ s ri r% r% � r2 rh c � � y rx rg r0 s ri r% r% � s � � rh r4 c �F � | t ur
|� t d� �t | |�� S )a� Usage docs: https://docs.pydantic.dev/2.10/concepts/models/#private-model-attributes
Indicates that an attribute is intended for private use and not handled during normal validation/serialization.
Private attributes are not validated by Pydantic, so it's up to you to ensure they are used in a type-safe manner.
Private attributes are stored in `__private_attributes__` on the model.
Args:
default: The attribute's default value. Defaults to Undefined.
default_factory: Callable that will be
called when a default value is needed for this attribute.
If both `default` and `default_factory` are set, an error will be raised.
init: Whether the attribute should be included in the constructor of the dataclass. Always `False`.
Returns:
An instance of [`ModelPrivateAttr`][pydantic.fields.ModelPrivateAttr] class.
Raises:
ValueError: If both `default` and `default_factory` are set.
rv r )r r� r )rm r0 r\ s ri r% r% � s1 � �6 �'�'�O�,G��I�J�J� ��'� � rh c � � e Zd ZU dZdZded< ded< ded< d ed
< d ed < d ed
< ded< d ed< ded< ded< ded< ded< edd�� Zy) �ComputedFieldInfoa4 A container for data from `@computed_field` so that we can access it while building the pydantic-core schema.
Attributes:
decorator_repr: A class variable representing the decorator string, '@computed_field'.
wrapped_property: The wrapped computed field property.
return_type: The type of the computed field property's return value.
alias: The alias of the property to be used during serialization.
alias_priority: The priority of the alias. This affects whether an alias generator is used.
title: Title of the computed field to include in the serialization JSON schema.
field_title_generator: A callable that takes a field name and returns title for it.
description: Description of the computed field to include in the serialization JSON schema.
deprecated: A deprecation message, an instance of `warnings.deprecated` or the `typing_extensions.deprecated` backport,
or a boolean. If `True`, a default deprecation message will be emitted when accessing the field.
examples: Example values of the computed field to include in the serialization JSON schema.
json_schema_extra: A dict or callable to provide extra JSON schema properties.
repr: A boolean indicating whether to include the field in the __repr__ output.
z@computed_fieldz
ClassVar[str]�decorator_reprr �wrapped_propertyr � return_typer1 r2 r3 r4 r8 �5typing.Callable[[str, ComputedFieldInfo], str] | Noner: r; rU r r< r= �3JsonDict | typing.Callable[[JsonDict], None] | NonerW rZ r[ c �� � | j �yt | j t � r| j rdS dS t | j t � r | j S | j j S r� r� r� s ri r� z%ComputedFieldInfo.deprecation_message� r� rh Nr� )rb rc rd re r9 rf r r� rg rh ri r8 r8 � sh � ��$ %6�N�M�5� � ��� �� � � ��P�P���.�.� � �J�J�
�J�
�`� �`rh r8 c �� � d}t | t � rt | j dd� }n't | t � rt | j
dd� }|j
d� xr |j
d� S )z>Returns true if provided property is private, False otherwise.� rb r� �__)r� r r� �fgetr �func�
startswith)� property_� wrapped_names ri � _wrapped_property_is_privaterG � sc � ��L��)�X�&� �y�~�~�z�2�>� � �I�� /� �y�~�~�z�2�>� � � "� "�3� '� M� �0G�0G��0M�,M�Mrh � PropertyT�
r2 r4 r8 r: r; r r= rW r[ r; c
� � y rx rg rI s
ri r& r& s � � /2rh c � � y rx rg )�__funcs ri r& r& s � �47rh c
�L ��������� �
� d�������� �
�f
d� } | �| S | | � S )a# Usage docs: https://docs.pydantic.dev/2.10/concepts/fields#the-computed_field-decorator
Decorator to include `property` and `cached_property` when serializing models or dataclasses.
This is useful for fields that are computed from other fields, or for fields that are expensive to compute and should be cached.
```python
from pydantic import BaseModel, computed_field
class Rectangle(BaseModel):
width: int
length: int
@computed_field
@property
def area(self) -> int:
return self.width * self.length
print(Rectangle(width=3, length=2).model_dump())
#> {'width': 3, 'length': 2, 'area': 6}
```
If applied to functions not yet decorated with `@property` or `@cached_property`, the function is
automatically wrapped with `property`. Although this is more concise, you will lose IntelliSense in your IDE,
and confuse static type checkers, thus explicit use of `@property` is recommended.
!!! warning "Mypy Warning"
Even with the `@property` or `@cached_property` applied to your function before `@computed_field`,
mypy may throw a `Decorated property not supported` error.
See [mypy issue #1362](https://github.com/python/mypy/issues/1362), for more information.
To avoid this error message, add `# type: ignore[misc]` to the `@computed_field` line.
[pyright](https://github.com/microsoft/pyright) supports `@computed_field` without error.
```python
import random
from pydantic import BaseModel, computed_field
class Square(BaseModel):
width: float
@computed_field
def area(self) -> float: # converted to a `property` by `computed_field`
return round(self.width**2, 2)
@area.setter
def area(self, new_area: float) -> None:
self.width = new_area**0.5
@computed_field(alias='the magic number', repr=False)
def random_number(self) -> int:
return random.randint(0, 1_000)
square = Square(width=1.3)
# `random_number` does not appear in representation
print(repr(square))
#> Square(width=1.3, area=1.69)
print(square.random_number)
#> 3
square.area = 4
print(square.model_dump_json(by_alias=True))
#> {"width":2.0,"area":4.0,"the magic number":3}
```
!!! warning "Overriding with `computed_field`"
You can't override a field from a parent class with a `computed_field` in the child class.
`mypy` complains about this behavior if allowed, and `dataclasses` doesn't allow this pattern either.
See the example below:
```python
from pydantic import BaseModel, computed_field
class Parent(BaseModel):
a: str
try:
class Child(Parent):
@computed_field
@property
def a(self) -> str:
return 'new a'
except ValueError as e:
print(repr(e))
#> ValueError("you can't override a field with a computed field")
```
Private properties decorated with `@computed_field` have `repr=False` by default.
```python
from functools import cached_property
from pydantic import BaseModel, computed_field
class Model(BaseModel):
foo: int
@computed_field
@cached_property
def _private_cached_property(self) -> int:
return -self.foo
@computed_field
@property
def _private_property(self) -> int:
return -self.foo
m = Model(foo=1)
print(repr(m))
#> Model(foo=1)
```
Args:
func: the function to wrap.
alias: alias to use when serializing this computed field, only used when `by_alias=True`
alias_priority: priority of the alias. This affects whether an alias generator is used
title: Title to use when including this computed field in JSON Schema
field_title_generator: A callable that takes a field name and returns title for it.
description: Description to use when including this computed field in JSON Schema, defaults to the function's
docstring
deprecated: A deprecation message (or an instance of `warnings.deprecated` or the `typing_extensions.deprecated` backport).
to be emitted when accessing the field. Or a boolean. This will automatically be set if the property is decorated with the
`deprecated` decorator.
examples: Example values to use when including this computed field in JSON Schema
json_schema_extra: A dict or callable to provide extra JSON schema properties.
repr: whether to include this computed field in model repr.
Default is `False` for private properties and `True` for public properties.
return_type: optional return for serialization logic to expect when serializing to JSON, if included
this must be correct, otherwise a `TypeError` is raised.
If you don't include a return type Any is used, which does runtime introspection to handle arbitrary
objects.
Returns:
A proxy wrapper for the property.
c
�t �
� t j | � }��+|j r t j |j � ���t |d� r |j �t j | � } ���xs dnd �� �t | �� }n� }t | � ���
� ����
|� }t j | |� S )N�__deprecated__r{ )rE ) r �unwrap_wrapped_functionre �inspect�cleandocr! rO �ensure_propertyrG r8 �PydanticDescriptorProxy)�f� unwrapped�repr_�dec_infor2 r4 r r; r= r: rW r[ r; r8 s ����������ri �deczcomputed_field.<locals>.dec� s� �� � �7�7��:� � � �9�#4�#4�!�*�*�9�+<�+<�=�K� � �'�)�5E�"F�"�1�1�J�
� '� '�� *��27�2C�.�-�A��� �<� :�Q� G�G�E��E�$�
� � � � � !� � � � � �
�� �2�2�1�h�?�?rh )rU r r� r rg ) rC r2 r4 r8 r: r; r r= rW r[ r; rY s `````````` ri r& r& s( ��� �z @� @�D �|��
��4�y�rh )Hrm �ellipsisr2 r1 r4 r3 r6 r5 r7 r1 r8 r1 r: r9 r; r1 r= r< r? r> rT rS r rU rW rV rX r> rY r> r[ rZ r\ r> r] r> r^ r> rN rM rJ r> r_ r> rA r@ rC rB rE rD rG rF rI rH rO r> rP r3 rQ r3 rK r3 rL r3 rR �!Literal['smart', 'left_to_right']r` r> r �Unpack[_EmptyKwargs]r� r )Hrm r r2 r1 r4 r3 r6 r5 r7 r1 r8 r1 r: r9 r; r1 r= r< r? r> rT rS r rU rW rV rX r> rY r> r[ rZ r\ r> r] r> r^ r> rN rM rJ r> r_ r> rA r@ rC rB rE rD rG rF rI rH rO r> rP r3 rQ r3 rK r3 rL r3 rR r[ r` r> r r\ r� r )Hr0 z1Callable[[], _T] | Callable[[dict[str, Any]], _T]r2 r1 r4 r3 r6 r5 r7 r1 r8 r1 r: r9 r; r1 r= r< r? r> rT rS r rU rW rV rX r> rY r> r[ rZ r\ r> r] r> r^ r> rN rM rJ r> r_ r> rA r@ rC rB rE rD rG rF rI rH rO r> rP r3 rQ r3 rK r3 rL r3 rR r[ r` r> r r\ r� r )Fr2 r1 r4 r3 r6 r5 r7 r1 r8 r1 r: r9 r; r1 r= r< r? r> rT rS r rU rW rV rX r> rY r> r[ rZ r\ r> r] r> r^ r> rN rM rJ r> r_ r> rA r@ rC rB rE rD rG rF rI rH rO r> rP r3 rQ r3 rK r3 rL r3 rR r[ r` r> r r\ r� r )Jrm r r0 r/ r2 r1 r4 r3 r6 r5 r7 r1 r8 r1 r: r9 r; r1 r= r< r? r> rT rS r rU rW rV rX r> rY r> r[ rZ r\ r> r] r> r^ r> rN rM rJ r> r_ r> rA r@ rC rB rE rD rG rF rI rH rO r> rP r3 rQ r3 rK r3 rL r3 rR r[ r` r> r r\ r� r )rm r r\ r� r� r )r0 zCallable[[], _T]r\ r� r� r )r\ r� r� r )rm r r0 zCallable[[], Any] | Noner\ r� r� r rg )rE zcached_property | propertyr� rZ )r2 r1 r4 r3 r8 r1 r: r< r; r1 r rU r= r< rW r= r[ rZ r; r r� z'typing.Callable[[PropertyT], PropertyT])rL rH r� rH rx )rC zPropertyT | Noner2 r1 r4 r3 r8 r1 r: r< r; r1 r rU r= r< rW r= r[ r> r; r r� z3PropertyT | typing.Callable[[PropertyT], PropertyT])Rre �
__future__r � _annotationsr� rQ �sysr� r r �DataclassField� functoolsr r r r r
r r �warningsr
r� r� �
pydantic_corer r r r r r@ r � _internalr r r r r r r �_internal._namespace_utilsr r �aliasesr r �configr �errorsr! � json_schemar" r# r/ �_internal._reprr$ r �__all__r' rf � version_infor* � TypedDictr, rl �Representationro r r} r �set� signature�
parametersr� �remover r% � dataclass�
slots_truer8 rG rH r& rg rh ri �<module>ru s� �� � 2� � �
�
� � /� %� C� C� � � � +� D� D� � i� i� i� J� ,� � %� 2� /� ���)� 3��
2�� ��� ����w� �� $� /� /�*� <�J� �<� &�J� �&�%�,�6�6�e� %�P�+�5� � Q #��$�$� Q #�hj�$�.�.� j� �
�s� ��t� � �T� � �d� �
�� � �4�
� �T� � �4� � �� � �t� � �T� � �� �
�d� � �� � �D� � �D�! �" ��# �$ ���
�
�
�
������� !�? ��F
�T�]��
� �!'�>D�&,� �DJ� $�!'�!�6<�17�FL� �$*�� � "�!�06� �)/�,2�,2�,2�,2� &�!'� #�!'� #� #�4:� #�G%�
�%� �%� � %�
<� %� $�
%� �%� B�%� �%� �%� �%� 4�%� /�%� D� %�
� %� "�!%�" �#%�$ �%%�& �'%�( �)%�* .�+%�,
�-%�. '�/%�0 *�1%�2 *�3%�4 *�5%�6 *�7%�8 �9%�: �;%�< �=%�> �?%�@ �A%�B �C%�D 2�E%�F �G%�H "�I%�J �K%�
�%�L
� �!'�>D�&,� �DJ� $�!'�!�6<�17�FL� �$*�� � "�!�06� �)/�,2�,2�,2�,2� &�!'� #�!'� #� #�4:� #�G%
�
�%
� �%
� � %
�
<� %
� $�
%
� �%
� B�%
� �%
� �%
� �%
� 4�%
� /�%
� D� %
�
� %
� "�!%
�" �#%
�$ �%%
�& �'%
�( �)%
�* .�+%
�,
�-%
�. '�/%
�0 *�1%
�2 *�3%
�4 *�5%
�6 *�7%
�8 �9%
�: �;%
�< �=%
�> �?%
�@ �A%
�B �C%
�D 2�E%
�F �G%
�H "�I%
�J �K%
�
�%
�L
� �!'�>D�&,� �DJ� $�!'�!�6<�17�FL� �$*�� � "�!�06� �)/�,2�,2�,2�,2� &�!'� #�!'� #� #�4:� #�G%
�F�%
� �%
� � %
�
<� %
� $�
%
� �%
� B�%
� �%
� �%
� �%
� 4�%
� /�%
� D� %
�
� %
� "�!%
�" �#%
�$ �%%
�& �'%
�( �)%
�* .�+%
�,
�-%
�. '�/%
�0 *�1%
�2 *�3%
�4 *�5%
�6 *�7%
�8 �9%
�: �;%
�< �=%
�> �?%
�@ �A%
�B �C%
�D 2�E%
�F �G%
�H "�I%
�J �K%
�
�%
�L
� �!'�>D�&,� �DJ� $�!'�!�6<�17�FL� �$*�� � "�!�06� �)/�,2�,2�,2�,2� &�!'� #�!'� #� #�4:� #�E$� �$� �$� <� $�
$� $� �
$� B�$� �$� �$� �$� 4�$� /�$� D�$�
� $� "� $� �!$�" �#$�$ �%$�& �'$�( .�)$�*
�+$�, '�-$�. *�/$�0 *�1$�2 *�3$�4 *�5$�6 �7$�8 �9$�: �;$�< �=$�> �?$�@ �A$�B 2�C$�D �E$�F "�G$�H �I$�
�$�L %�L� SY� �!'�>D�&,� �DJ� $�!'�!�6<�17�FL� �$*�� � "�!�06� �)/�,2�,2�,2�,2� &�!'� #�!'� #� #�4:� #�IL�
�L� P�L� � L�
� L� <�
L� $�L� �L� B�L� �L� �L� �L� 4�L� /� L� D� L�
�!L�" "�#L�$ �%L�& �'L�( �)L�* �+L�, .�-L�.
�/L�0 '�1L�2 *�3L�4 *�5L�6 *�7L�8 *�9L�: �;L�< �=L�> �?L�@ �AL�B �CL�D �EL�F 2�GL�H �IL�J "�KL�L �ML�^ �(�w�(�(��/�:�:�;� � � � �� �=
�u�+�+� =
�D
� !�
�
�
� �
� �
�
�
�
� !�
�%�
� �
� �
�
�
�
� !��
�� ��
��
%�!� 15� � !�
�!� .�!� � !�
� !�H ����8�,�7�7�8�'`� '`� 9�'`�T N�
�F�N�N�;� '� � � � � �!%� �SW� "�15�!%�MQ��(� 2� � 2� � 2� � 2�
Q� 2� �
2� /� 2� � 2� K� 2� � 2� � 2� -� 2� � 2� � � � 7� � 7� "�B� �!%� �SW� "�15�!%�MQ� �(�B�
�B� � B�
� B� �
B� Q�B� �B� /�B� �B� K�B� �B� �B� 9� Brh