File: //usr/local/lib/python3.10/dist-packages/pydantic/v1/__pycache__/dataclasses.cpython-310.pyc
o
|��g�F � @ sT d Z ddlZddlZddlZddlmZ ddlmZ zddlmZ W n e y+ Y nw ddl
m Z m Z m
Z
mZmZmZmZmZmZmZmZ ddlmZ ddlmZ dd lmZm Z m Z m Z dd
l m Z dd l!m"Z" dd l#m$Z$m%Z%m&Z&m'Z' dd
l(m)Z)m*Z* ddl+m,Z, e r�ddl(m-Z- ddl.m/Z/m0Z0 eddd�Z1eed df Z2G dd� d�Z3g d�Z4ed�Z5ej6dk�r;eej7e$fd�edddddddddd d �
d e8d e8d e8d!e8d"e8d#e8d$ee ee9 df d%ee8 d&ee8 d'e8d(e
ee5 gd)f fd*d+���Z:eej7e$fd�edddddddddd d �
d,ee5 d e8d e8d e8d!e8d"e8d#e8d$ee ee9 df d%ee8 d&ee8 d'e8d(d)fd-d+���Z:n}eej7e$fd�edddddddddd.� d e8d e8d e8d!e8d"e8d#e8d$ee ee9 df d%ee8 d&ee8 d(e
ee5 gd)f fd/d+���Z:eej7e$fd�edddddddddd.� d,ee5 d e8d e8d e8d!e8d"e8d#e8d$ee ee9 df d%ee8 d&ee8 d(d)fd0d+���Z:eej7e$fd� dTddddddddddd �
d,eee5 d e8d e8d e8d!e8d"e8d#e8d$ee ee9 df d%ee8 d&ee8 d'e8d(ee
ee5 gd)f d)f fd1d+��Z:ed2ed d3e8d(eed ddf fd4d5��Z;G d6d� d�Z<d7ed d$ee d%e8d8e=d(df
d9d:�Z>dUd<d=�Z?d2ed d>e d(dfd?d@�Z@edfd7ed d$ee d8ee= d(edA fdBdC�ZAej6dDk�rqdEddFe=d(e8fdGdH�ZBn dEddFe=d(e8fdIdH�ZBdVdKdL�ZCdJddMe=d3e d(dfdNdO�ZDd,ee d(e8fdPdQ�ZEd7ed d$ee d(d;fdRdS�ZFdS )WaX
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 @ s� e Zd ZU eeeef ed< ee ed< eed ed< ee ed< eed ed< ee ed< ee
e ed< eed gd f ed
< ee ed < d e d
e dd fdd�Z
ede
d ddfdd��Zede
d deddfdd��Zd S )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 O � d S �N� ��selfr/ r0 r4 r4 �B/usr/local/lib/python3.10/dist-packages/pydantic/v1/dataclasses.py�__init__P � zDataclass.__init__�clsr c C r2 r3 r4 �r: r4 r4 r7 �__get_validators__S � z Dataclass.__get_validators__r" �vc C r2 r3 r4 �r: r> r4 r4 r7 � __validate__W r= zDataclass.__validate__)�__name__�
__module__� __qualname__r r �strr �__annotations__r �boolr r �objectr8 � classmethodr< r@ r4 r4 r4 r7 r# B s
)� 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_onlyrT rU rV rW rX rY rZ r[ r\ r] r1 �DataclassClassOrWrapperc
C r2 r3 r4 rS r4 r4 r7 rI h � rI �_clsc
C r2 r3 r4 ) r` rT rU rV rW rX rY rZ r[ r\ r] r4 r4 r7 rI y s � rT rU rV rW rX rY rZ r[ r\ c C r2 r3 r4 ra r4 r4 r7 rI � s c
C r2 r3 r4 )
r` rT rU rV rW rX rY rZ r[ r\ r4 r4 r7 rI � r_ c
sH t |��dtt ddf� ��������� f
dd� } | du r | 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: r1 r^ c
s� �d ur�nt | �o | jd tu p tt| ��tt| jd ��k}|r+d}t| �}d}n&| jp/d}tjdkrCt j
| ��� ����d�}n t j
| ��� ���d�}d}� d u rW|n� }t | �||� |j j
di | j| i�� |S ) Nr � FrO )rT rU rV rW rX rY r] )rT rU rV rW rX rY Tr4 )rL � __bases__rG �set�dirr% �__doc__�sys� version_info� dataclassesrI �#_add_pydantic_validation_attributesr, �__try_update_forward_refs__rA )r: �should_use_proxy�
dc_cls_doc�dc_cls�default_validate_on_init�should_validate_on_init�
rV rY rT r] rW rU �
the_configrX r\ r[ r4 r7 �wrap� s: �*�
� �zdataclass.<locals>.wrapN)r r r ) r` rT rU rV rW rX rY rZ r[ r\ r] rs r4 rq r7 rI � s
,%r: �valuec c s* � | j }z || _ | V W || _ d S || _ w r3 )r) )r: rt �original_run_validationr4 r4 r7 rJ � s �rJ c @ s� e Zd ZdZded ddfdd�Zded edefd
d �Zd edefd
d�Z dededdfdd�Z
dede fdd�Z ddd�Z
dedd fdd�ZdS ) r% �
__dataclass__rn r# r1 Nc C s t �| d|� d S )Nrv )rG � __setattr__)r6 rn r4 r4 r7 r8 � � zDataclassProxy.__init__r/ r0 c O s@ t | jd�� | j|i |��W d � S 1 sw Y d S )NT)rJ rv r5 r4 r4 r7 �__call__ s $�zDataclassProxy.__call__�namec C s t | j|�S r3 )�getattrrv )r6 rz r4 r4 r7 � __getattr__ � zDataclassProxy.__getattr__�_DataclassProxy__name�_DataclassProxy__valuec C s t | j||�S r3 )�setattrrv )r6 r~ r r4 r4 r7 rw s zDataclassProxy.__setattr__�instancec C s t || j�S r3 )�
isinstancerv )r6 r� r4 r4 r7 �__instancecheck__ r} z DataclassProxy.__instancecheck__c C s t t�| j��S r3 )r% �copyrv �r6 r4 r4 r7 �__copy__ s zDataclassProxy.__copy__�memoc C s t t�| j|��S r3 )r% r� �deepcopyrv )r6 r� r4 r4 r7 � __deepcopy__ rx zDataclassProxy.__deepcopy__)r1 r% )rA rB rC � __slots__r r8 r ry rD r| rw rF r� r� r� r4 r4 r4 r7 r% � s
rn rm c sZ | j �t��dddtdtddf� �fdd� ��t| d �rPz| jj�W n ty. | j�Y nw t��dddtdtddf� �fd
d � �}t| d �� t| d |� nt��dddtdtddf�fd
d� �}t| d |� t| dtd|�� t| dd� t| dt | � |�� t| dt
� t| dt t �� t| dt t
�� | jjjr�| jjs�t| dt� dS dS dS )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
r6 r# r/ r0 r1 Nc s� �j tjkr �� g|�R i � fdd�|�� D ��� d S �j tjkrH|�� D ] \}}� j�||� q&�� g|�R i � fdd�|�� D ��� d S �� g|�R i |�� d S )Nc � i | ] \}}|� j v r||�qS r4 �r& ��.0�kr> r� r4 r7 �
<dictcomp>% � zR_add_pydantic_validation_attributes.<locals>.handle_extra_init.<locals>.<dictcomp>c r� r4 r� r� r� r4 r7 r� * r� )�extrar �ignore�items�allow�__dict__�
setdefault)r6 r/ r0 r� r> )rZ rT r� r7 �handle_extra_init" s , ,z>_add_pydantic_validation_attributes.<locals>.handle_extra_initr( c sr � j dkr�| g|�R i |�� | jjr%| �� t| d�r%| j|i |�� � j dkr7�| g|�R i |�� d S d S )N�before_validationr* �after_validation)�post_init_call� __class__r) r- �hasattrr* r5 )rZ � post_initr4 r7 �
new_post_init5 s
�z:_add_pydantic_validation_attributes.<locals>.new_post_initr8 c s� � | g|�R i |�� | j jr| �� t| d�rUi }t| j j�� �D ](\}}|jtj u rJz || ||j
< W q" t yI |� |j
|j
�||j
< Y q"w q"| jdi |�� d S d S )Nr* r4 )r� r) r- r� � enumerater& �values� _field_typeri �_FIELD_INITVARrz �
IndexError�get�defaultr* )r6 r/ r0 �initvars_and_values�i�f)r� r4 r7 �new_initG s
���z5_add_pydantic_validation_attributes.<locals>.new_initr) r+ Fr, r- r@ r< rw )r8 r r r� r( � __wrapped__�AttributeErrorr� r rK �_dataclass_validate_valuesrH �_validate_dataclass�_get_validatorsr, �
__config__�validate_assignmentr' rY �&_dataclass_validate_assignment_setattr)rn rZ r[ rm r� r� r4 )rZ r� rT r� r7 rj s2 "
�" �rj r c c s � | j V d S r3 )r@ r; r4 r4 r7 r� k s � r� r> c C s� t | d��> t|| �r|�� |W d � S t|ttf�r*| |� W d � S t|t�r=| di |��W d � S t| jd��1 sFw Y d S )NT)�
class_namer4 )rJ r� r- �list�tuple�dictr rA r? r4 r4 r7 r� o s
��
� �r� r c
C s� i }t �| �D ]:}t}d }|jt jur|j}n |jt jur!|j}nt}t|t�r.|}d| _ n t
d||d�|j ��}|j |f||j
< qt| �}t| jf|| j|ddid�|��} |d ur`|| _| S | jpdd| _| S )NT)r� �default_factory�__resolve_forward_refs__F)r� rB �__validators__�__cls_kwargs__rb r4 )ri �fieldsr r� �MISSINGr� r r� r r. r �metadata�typerz r r rA rB rf )
rn rZ rm �field_definitions�fieldr� r� �
field_info�
validators�modelr4 r4 r7 rK | s:
��� �rK )rP � �objr� c C s t tt| �|d �t�S r3 )r� r{ r� r �r� r� r4 r4 r7 �_is_field_cached_property� s r� c C s dS )NFr4 r� r4 r4 r7 r� � r9 r6 c s� t � d�rd S t � dd�r� fdd�� j�� D �}n � fdd�� j�� D �}t� j|� jd�\}}}|r6|�� j�|� t�� dd� d S ) Nr+ r. Fc s* i | ]\}}t |t�st� |�s||�qS r4 )r� r r� r� r� r4 r7 r� � s ���z._dataclass_validate_values.<locals>.<dictcomp>c s i | ] \}}t � |�s||�qS r4 )r� r� r� r4 r7 r� � r� r; T) r{ r� r� r r, r� �updaterG rw )r6 �
input_data�d�_�validation_errorr4 r� r7 r� � s
� r� rz c C sl | j r-t| j�}|�|d � | jj�|d �}|r-|j|||| jd�\}}|r-t |g| j��t
� | ||� d S )N)�locr: ) r+ r� r� �popr, �
__fields__r� �validater� r rG rw )r6 rz rt r� � known_field�error_r4 r4 r7 r� � s
r� c C s2 t �| �ot| d� ot| j��tt| 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, rE )ri � is_dataclassr� rd r& �
issupersetr{ )r` r4 r4 r7 rL � s
��rL c c s � t t| |dd��E dH dS )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)rZ r\ N)r� rI )rn rZ r4 r4 r7 rM � s � rM r3 )r: r^ r1 r )r6 r# r1 N)Grf r� ri rg �
contextlibr � functoolsr r � ImportError�typingr r r r r r
r r r
r r �typing_extensionsr � pydantic.v1.class_validatorsr �pydantic.v1.configr r r r �pydantic.v1.error_wrappersr �pydantic.v1.errorsr �pydantic.v1.fieldsr r r r �pydantic.v1.mainr r �pydantic.v1.utilsr r �pydantic.v1.typingr r! r" r^ r# �__all__rN rh r� rF rG rI rJ r% rD rj r� r� rK r� r� r� rL rM r4 r4 r4 r7 �<module> s� ! �4 �������� �
� � ��������� �
� � �
��������� �
� ��������� �
� � ���
������� �
� � �
�A* ����
�
V����
� '
"