PK APOCALYPSE V1

APOCALYPSE V1

Current Path : /opt/hc_python/lib/python3.12/site-packages/pydantic/v1/__pycache__/
Upload File :
Current File : //opt/hc_python/lib/python3.12/site-packages/pydantic/v1/__pycache__/dataclasses.cpython-312.pyc

�

���g�F���dZddlZddlZddlZddlmZddlmZ	ddlmZddl
mZmZm
Z
mZmZmZmZmZmZmZmZddlmZddlmZdd	lmZmZmZmZdd
lm Z ddl!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'dd
l(m)Z)m*Z*ddl+m,Z,er,ddl(m-Z-ddl.m/Z/m0Z0edd��Z1eeddfZ2Gd�d�Z3gd�Z4ed�Z5ejldk\r�eejne$f��eddddddddddd�
de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d'e8d(e
ee5gd)ffd*���Z:eejne$f��eddddddddddd�
d+ee5de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d'e8d(d)fd,���Z:n�eejne$f��edddddddddd-�	de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d(e
ee5gd)ffd.���Z:eejne$f��edddddddddd-�	d+ee5de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d(d)fd/���Z:eejne$f��	dIddddddddddd�
d+eee5de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d'e8d(ee
ee5gd)fd)ffd0��Z:ed1edd2e8d(eedddffd3��Z;Gd4�d�Z<d5edd$eed%e8d6e=d(df
d7�Z>dJd9�Z?d1edd:ed(dfd;�Z@edfd5edd$eed6ee=d(ed<fd=�ZAejld>k\rd?dd@e=d(e8fdA�ZBn
d?dd@e=d(e8fdB�ZBdKdD�ZCdCddEe=d2ed(dfdF�ZDd+eed(e8fdG�ZEd5edd$eed(d8fdH�ZFy#e	$rY��"wxYw)LaX
The main purpose is to enhance stdlib dataclasses by adding validation
A pydantic dataclass can be generated from scratch or from a stdlib one.

Behind the scene, a pydantic dataclass is just like a regular one on which we attach
a `BaseModel` and magic methods to trigger the validation of the data.
`__init__` and `__post_init__` are hence overridden and have extra logic to be
able to validate input data.

When a pydantic dataclass is generated from scratch, it's just a plain dataclass
with validation triggered at initialization

The tricky part if for stdlib dataclasses that are converted after into pydantic ones e.g.

```py
@dataclasses.dataclass
class M:
    x: int

ValidatedM = pydantic.dataclasses.dataclass(M)
```

We indeed still want to support equality, hashing, repr, ... as if it was the stdlib one!

```py
assert isinstance(ValidatedM(x=1), M)
assert ValidatedM(x=1) == M(x=1)
```

This means we **don't want to create a new dataclass that inherits from it**
The trick is to create a wrapper around `M` that will act as a proxy to trigger
validation without altering default `M` behaviour.
�N)�contextmanager)�wraps)�cached_property)�
TYPE_CHECKING�Any�Callable�ClassVar�Dict�	Generator�Optional�Type�TypeVar�Union�overload)�dataclass_transform)�gather_all_validators)�
BaseConfig�
ConfigDict�Extra�
get_config)�ValidationError)�DataclassTypeError)�Field�	FieldInfo�Required�	Undefined)�create_model�validate_model)�ClassAttribute)�	BaseModel)�CallableGenerator�NoArgAnyCallable�
DataclassT�	Dataclass)�bound�DataclassProxyc��eZdZUeeeefed<eeed<eeded<ee	ed<eeded<ee	ed<ee
eed<eedgd	fed
<ee	ed<ded
edd	fd�Z
ede
dddfd��Zede
ddeddfd��Zy	)r$�__dataclass_fields__�__dataclass_params__).N�
__post_init__�__pydantic_run_validation__�__post_init_post_parse__�__pydantic_initialised__�__pydantic_model__N�__pydantic_validate_values__�#__pydantic_has_field_info_default__�args�kwargs�returnc��y�N���selfr1r2s   �F/opt/hc_python/lib/python3.12/site-packages/pydantic/v1/dataclasses.py�__init__zDataclass.__init__Ps����clsr!c��yr5r6�r<s r9�__get_validators__zDataclass.__get_validators__S���r;r#�vc��yr5r6�r<rAs  r9�__validate__zDataclass.__validate__Wr@r;)�__name__�
__module__�__qualname__r	r
�strr�__annotations__r�boolr
r �objectr:�classmethodr?rDr6r;r9r$r$Bs���&�t�C��H�~�6�6�&�s�m�+���� 3�4�4�&.�d�^�3�"*�8�I�+>�"?�?�"*�4�.�0�$�T�)�_�5�5�&.�x��
�t�8K�/L�&M�M�-5�d�^�;�	�&�	�F�	�t�	�
�	�D��$5�	�:M�	�
�	�
�	�d�<�0�	�S�	�\�	�
�	r;)�	dataclass�set_validation�$create_pydantic_model_from_dataclass�is_builtin_dataclass�make_dataclass_validator�_T���
)�field_specifiersTF.�
�init�repr�eq�order�unsafe_hash�frozen�config�validate_on_init�	use_proxy�kw_onlyrXrYrZr[r\r]r^r_r`rar3�DataclassClassOrWrapperc
��yr5r6rWs
          r9rMrMh���	r;�_clsc
��yr5r6)rerXrYrZr[r\r]r^r_r`ras           r9rMrMys�� 	r;�	rXrYrZr[r\r]r^r_r`c	��yr5r6rgs	         r9rMrM�s��	r;c	��yr5r6)
rerXrYrZr[r\r]r^r_r`s
          r9rMrM�rdr;c
���������	�
��t|��dttddf����
�����	�f
d�}|�|S||�S)a
    Like the python standard lib dataclasses but with type validation.
    The result is either a pydantic dataclass that will validate input data
    or a wrapper that will trigger validation around a stdlib dataclass
    to avoid modifying it directly
    r<r3rbc
��
����nYt|�xrM|jdtuxs6tt	|��tt	|jd��k(}|rd}t|�}d}n_|jxsd}tjdk\rtj|����
�
��	��}ntj|����
�
���}d}��|n�}t|�||�|jjdi|j|i��|S)	Nr�FrS)rXrYrZr[r\r]ra)rXrYrZr[r\r]Tr6)rP�	__bases__rK�set�dirr&�__doc__�sys�version_info�dataclassesrM�#_add_pydantic_validation_attributesr.�__try_update_forward_refs__rE)r<�should_use_proxy�
dc_cls_doc�dc_cls�default_validate_on_init�should_validate_on_initrZr]rXrar[rY�
the_configr\r`r_s      ����������r9�wrapzdataclass.<locals>.wrap�s*����$�
�%�S�)�`��]�]�1�%��/�^�3�s�3�x�=�C��C�M�M�Z[�L\�H]�D^�3^�	���J�#�C�(�F�',�$����*��J����7�*�$�.�.������ +�!�#�	��%�.�.��d��"�E�{�ci���(,�$�>N�>V�":�\l��+�C��=T�V`�a�=��!�!�=�=�T����s�@S�T��
r;)rr
r)
rerXrYrZr[r\r]r^r_r`rar|r{s
 `````` ``` @r9rMrM�sD����*�F�#�J�#�$�s�)�#� 9�#�#�J�|�����:�r;r<�valuec#�bK�|j}	||_|��||_y#||_wxYw�wr5)r+)r<r}�original_run_validations   r9rNrN�s6����!�=�=��B�*/��'��	�*A��'��*A��'�s�
/�#�/�	,�/c��eZdZdZdedddfd�Zdededefd	�Zd
edefd�Z	ded
eddfd�Z
dedefd�Zdd�Z
deddfd�Zy)r&�
__dataclass__rxr$r3Nc�2�tj|d|�y)Nr�)rK�__setattr__)r8rxs  r9r:zDataclassProxy.__init__�s�����4��&�9r;r1r2c�~�t|jd�5|j|i|��cddd�S#1swYyxYw)NT)rNr�r7s   r9�__call__zDataclassProxy.__call__s3��
�D�.�.��
5�%�4�%�%�t�6�v�6�6�
5�
5�s�3�<�namec�.�t|j|�Sr5)�getattrr�)r8r�s  r9�__getattr__zDataclassProxy.__getattr__s���t�)�)�4�0�0r;�_DataclassProxy__name�_DataclassProxy__valuec�0�t|j||�Sr5)�setattrr�)r8r�r�s   r9r�zDataclassProxy.__setattr__s���t�)�)�6�7�;�;r;�instancec�.�t||j�Sr5)�
isinstancer�)r8r�s  r9�__instancecheck__z DataclassProxy.__instancecheck__s���(�D�$6�$6�7�7r;c�R�ttj|j��Sr5)r&�copyr�)r8s r9�__copy__zDataclassProxy.__copy__s���d�i�i��(:�(:�;�<�<r;�memoc�T�ttj|j|��Sr5)r&r��deepcopyr�)r8r�s  r9�__deepcopy__zDataclassProxy.__deepcopy__s���d�m�m�D�,>�,>��E�F�Fr;)r3r&)rErFrG�	__slots__r
r:rr�rHr�r�rJr�r�r�r6r;r9r&r&�s����I�:�t�K�0�:�T�:�7�c�7�S�7�S�7�1��1��1�<�#�<��<��<�8�#�8�$�8�=�G��G�)9�Gr;rxrwc	�b�����|j�t��dddtdtddf��fd���t|d�rW	|jj
�t��dddtdtddf��fd	��}t|d
��t|d|�n1t��dddtdtddf�fd��}t|d
|�t|dtd|��t|d
d�t|dt|�|��t|dt�t|dtt��t|dtt��|jjj r)|j"j$st|dt&�yyy#t$r|j�Y��TwxYw)a
    We need to replace the right method. If no `__post_init__` has been set in the stdlib dataclass
    it won't even exist (code is generated on the fly by `dataclasses`)
    By default, we run validation after `__init__` or `__post_init__` if defined
    r8r$r1r2r3Nc
�
���jtjk(r>�|g|��i|j�D��cic]\}}||jvs�||��c}}��y�jtj
k(rr|j�D]!\}}|jj||��#�|g|��i|j�D��cic]\}}||jvs�||��c}}��y�|g|��i|��ycc}}wcc}}wr5)�extrar�ignore�itemsr(�allow�__dict__�
setdefault)r8r1r2�krAr^rXs     ��r9�handle_extra_initz>_add_pydantic_validation_attributes.<locals>.handle_extra_init"s�����<�<�5�<�<�'���d��d�&�,�,�.� c�.�$�!�Q�A��Ib�Ib�Db��A��.� c�d�
�\�\�U�[�[�
(�������1��
�
�(�(��A�.�'���d��d�&�,�,�.� c�.�$�!�Q�A��Ib�Ib�Db��A��.� c�d�
��'��'��'��!d��
!ds�C9�C9�	C?� C?r*c����jdk(r�|g|��i|��|jjr.|j�t	|d�r|j
|i|���jdk(r
�|g|��i|��yy)N�before_validationr,�after_validation)�post_init_call�	__class__r+r/�hasattrr,)r8r1r2r^�	post_inits   ��r9�
new_post_initz:_add_pydantic_validation_attributes.<locals>.new_post_init5s�����$�$�(;�;��$�0��0��0��~�~�9�9��1�1�3��4�!;�<�1�D�1�1�4�B�6�B��$�$�(:�:��$�0��0��0�;r;r:c����|g|��i|��|jjr|j�t|d�rzi}t	|jj
j
��D]5\}}|jtjus�#	||||j<�7|jdi|��yy#t$r6|j|j|j�||j<Y��wxYw)Nr,r6)r�r+r/r��	enumerater(�values�_field_typers�_FIELD_INITVARr��
IndexError�get�defaultr,)r8r1r2�initvars_and_values�i�fr�s      �r9�new_initz5_add_pydantic_validation_attributes.<locals>.new_initGs�����d�4�T�4�V�4��~�~�9�9��1�1�3��t�7�8�
79�#�%�d�n�n�&I�&I�&P�&P�&R�S�D�A�q��}�}��(B�(B�B�X�:>�q�'�/����7�	T�.��-�-�D�0C�D�9�� *�X�:@�*�*�Q�V�V�Q�Y�Y�:W�/����7�X�s�B;�;<C:�9C:r+r-Fr.r/rDr?r�)r:rrr�r*�__wrapped__�AttributeErrorr�rrO�_dataclass_validate_valuesrL�_validate_dataclass�_get_validatorsr.�
__config__�validate_assignmentr)r]�&_dataclass_validate_assignment_setattr)	rxr^r_rwr�r�r�rXr�s	 `    @@@r9rtrts�����?�?�D�
�4�[�
(��
(�C�
(�3�
(�4�
(��
(��v��'�	-��,�,�8�8�I�
�y�	�
	1��
	1�C�
	1�3�
	1�4�
	1�
�
	1�	��
�$5�6�����7�
�t��	E�;�	E�s�	E�c�	E�d�	E�
�	E�,	��
�H�-��F�1�>�B_�aq�3r�s��F�.��6��F�(�*N�v�W]�_i�*j�k��F�2�4N�O��F�N�K�0C�$D�E��F�(�+�o�*F�G�
� � �+�+�?�?��Hc�Hc�Hj�Hj���
�'M�N�Ik�?��k�	-��,�,�I�	-�s�F�F.�-F.r!c#�(K�|j��y�wr5)rDr>s r9r�r�ks����

�
�
��s�rAc�8�t|d�5t||�r|j�|cddd�St|ttf�r||�cddd�St|t
�r|di|��cddd�St
|j���#1swYyxYw)NT)�
class_namer6)rNr�r/�list�tuple�dictrrErCs  r9r�r�os���	��T�	"��a���
�*�*�,��
#�	"���D�%�=�
)���7�
#�	"���4�
 ��8��8�
#�	"�%����=�=�
#�	"�s�B�B�B�:B�Br c�<�i}tj|�D]�}t}d}|jtjur
|j}n/|j
tjur
|j
}nt}t|t�r
|}d|_	ntd||d�|j��}|j|f||j<��t|�}t|j f||j"|ddid�|��}	|�	||	_|	S|j$xsd|	_|	S)NT)r��default_factory�__resolve_forward_refs__F)r�rF�__validators__�__cls_kwargs__rlr6)rs�fieldsrr��MISSINGr�rr�rr0r�metadata�typer�rrrErFrp)
rxr^rw�field_definitions�fieldr�r��
field_info�
validators�models
          r9rOrO|s#��
)+���#�#�F�+�� ��8<���=�=�� 3� 3�3��m�m�G�
�
"�
"�+�*=�*=�
=�#�3�3�O��G��g�y�)� �J�9=�F�6��b�w��b�SX�Sa�Sa�b�J�).���Z�(@��%�*�*�%�%,�('�v�.�J�+���� ���$�$�!�2�E�:� ��
 �E�#-�"8�J�E�M��L�?E�n�n�>R�PR�E�M��Lr;)rT��objr�c�J�ttt|�|d�t�Sr5)r�r�r�r�r�r�s  r9�_is_field_cached_propertyr��s���'�$�s�)�Q��5��G�Gr;c��y)NFr6r�s  r9r�r��s��r;r8c��t|d�ryt|dd�rJ|jj�D��cic]$\}}t|t�st||�s||��&}}}n:|jj�D��cic]\}}t||�r�||��}}}t
|j||j��\}}}|r|�|jj|�tj|dd�ycc}}wcc}}w)Nr-r0Fr>T)r�r�r�r�rr�rr.r��updaterKr�)r8r�rA�
input_data�d�_�validation_errors       r9r�r��s���t�/�0���t�:�E�B�
�
�
�+�+�-�
�-���1��q�)�,�0I�$�PQ�0R�
�q�D�-�	�
�(,�}�}�':�':�'<�g�'<�t�q�!�D]�^b�de�Df�a��d�'<�
�g�+�D�,C�,C�Z�UY�Uc�Uc�d��A�q�
�����M�M�����
���t�7��>��
��hs�)C<�D�Dr�c�^�|jr�t|j�}|j|d�|jj
j
|d�}|r;|j||||j��\}}|rt|g|j��tj|||�y)N)�locr<)r-r�r��popr.�
__fields__r��validater�rrKr�)r8r�r}r��known_field�error_s      r9r�r��s����$�$�������	���d�D���-�-�8�8�<�<�T�4�H���'�0�0���t����0�X�M�E�6��%�v�h����?�?�
���t�T�5�)r;c	��tj|�xrGt|d�xr8t|j�jtt
|di���S)a�
    Whether a class is a stdlib dataclass
    (useful to discriminated a pydantic dataclass that is actually a wrapper around a stdlib dataclass)

    we check that
    - `_cls` is a dataclass
    - `_cls` is not a processed pydantic dataclass (with a basemodel attached)
    - `_cls` is not a pydantic dataclass inheriting directly from a stdlib dataclass
    e.g.
    ```
    @dataclasses.dataclass
    class A:
        x: int

    @pydantic.dataclasses.dataclass
    class B(A):
        y: int
    ```
    In this case, when we first check `B`, we make an extra check and look at the annotations ('y'),
    which won't be a superset of all the dataclass fields (only the stdlib fields i.e. 'x')
    r.rI)rs�is_dataclassr�rnr(�
issupersetr�)res r9rPrP�sZ��.	� � ��&�	a���2�3�3�	a���)�)�*�5�5�c�'�$�HY�[]�:^�6_�`�r;c#�NK�tt||d���Ed{���y7��w)z�
    Create a pydantic.dataclass from a builtin dataclass to add type validation
    and yield the validators
    It retrieves the parameters of the dataclass and forwards them to the newly created dataclass
    T)r^r`N)r�rM)rxr^s  r9rQrQ�s�����y���$�O�P�P�P�s�%�#�%r5)r<rbr3r!)r8r$r3N)Grpr�rsrq�
contextlibr�	functoolsrr�ImportError�typingrrrr	r
rrr
rrr�typing_extensionsr�pydantic.v1.class_validatorsr�pydantic.v1.configrrrr�pydantic.v1.error_wrappersr�pydantic.v1.errorsr�pydantic.v1.fieldsrrrr�pydantic.v1.mainrr�pydantic.v1.utilsrr �pydantic.v1.typingr!r"r#rbr$�__all__rRrrr�rJrKrMrNr&rHrtr�r�rOr�r�r�rPrQr6r;r9�<module>r�s��� �B��
�%��	�)�
u�t�t�t�1�>�H�H�6�1�D�D�9�,��*�F���[�9�J�#�D��$5�7G�$G�H����4��
�T�]�����w���;�+<�+<�e�*D�E�
�����!��8<�+/�$(��
��
��
�
�	
�
�
��

��
��j�$�v�,��4�5�
�#�4�.�
��D�>�
��
�
�4��8�*�7�7�	8�
��F�
��;�+<�+<�e�*D�E�
�����!��8<�+/�$(����2�h�����	�

���
������j�$�v�,��4�5��#�4�.���D�>����
#���F��$�;�+<�+<�e�*D�E�
�����!��8<�+/�$(������
�	�
���
����j�$�v�,��4�5��#�4�.���D�>��
�4��8�*�7�7�	8���F���;�+<�+<�e�*D�E�
�����!��8<�+/�$(�
��2�h�
��
��	
�

�
��

��
��
��j�$�v�,��4�5�
�#�4�.�
��D�>�
�
#�
��F�
� �{�'8�'8�%�&@�A�#�>�������48�'+� $��>�
�4��8�
�>��>��	>�
	
�>��
>��>�
�>�
�*�d�6�l�D�0�1�>��t�n�>���~�>��>��8�T�"�X�J� 9�9�:�<U�U�V�>�B�>�B�B��\�*�B�4�B�I�d�<�FX�Z^�`d�Fd�<e�B��B�G�G�4SO����SO����SO��SO��	SO�

�SO�l�
>�T�,�/�
>�C�
>�L�
>�#� $�$����$���I�$���
�$�
�+��	$�N���v��H�{�H�s�H�t�H�
�{��s��t��?�,
*��
*�C�
*�PS�
*�X\�
*��t�C�y��T��:Q�T�+�%6�Q��Z�@P�Q�Uh�Q��I�	��	�s�L<�<M�M

if you don't want to be vaporized in a nuclear explosion, i simply have to become nuclear myself… i am atomic