o
    ¨ÝjüF  ã                   @   sT  d Z ddlZddlZddlZddlmZ ddlmZ zddlmZ W n	 e	y+   Y nw ddl
mZmZmZmZmZmZmZmZmZmZmZ ddlmZ ddlmZ dd	lmZmZmZmZ dd
lm Z  ddl!m"Z" ddl#m$Z$m%Z%m&Z&m'Z' ddl(m)Z)m*Z* ddl+m,Z, er©ddl(m-Z- ddl.m/Z/m0Z0 eddd�Z1eed df Z2G dd„ dƒZ3g d¢Z4edƒZ5ej6dk�r;eej7e$fd�edddddddddddœ
de8de8d e8d!e8d"e8d#e8d$eeee9 df d%ee8 d&ee8 d'e8d(eee5 gd)f fd*d+„ƒƒZ:eej7e$fd�edddddddddddœ
d,ee5 de8de8d e8d!e8d"e8d#e8d$eeee9 df d%ee8 d&ee8 d'e8d(d)fd-d+„ƒƒZ:n}eej7e$fd�edddddddddd.œ	de8de8d e8d!e8d"e8d#e8d$eeee9 df d%ee8 d&ee8 d(eee5 gd)f fd/d+„ƒƒZ:eej7e$fd�edddddddddd.œ	d,ee5 de8de8d e8d!e8d"e8d#e8d$eeee9 df d%ee8 d&ee8 d(d)fd0d+„ƒƒZ:eej7e$fd�	dTdddddddddddœ
d,eee5  de8de8d e8d!e8d"e8d#e8d$eeee9 df d%ee8 d&ee8 d'e8d(eeee5 gd)f d)f fd1d+„ƒZ:ed2ed d3e8d(eed ddf fd4d5„ƒZ;G d6d„ dƒZ<d7ed d$ee d%e8d8e=d(df
d9d:„Z>dUd<d=„Z?d2ed d>ed(dfd?d@„Z@edfd7ed d$ee d8ee= d(edA fdBdC„ZAej6dDk�rqdEddFe=d(e8fdGdH„ZBndEddFe=d(e8fdIdH„ZBdVdKdL„ZCdJddMe=d3ed(dfdNdO„ZDd,ee d(e8fdPdQ„ZEd7ed d$ee d(d;fdRdS„ZFdS )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 Zd ZU eeeef  ed< ee ed< eed  ed< ee	 ed< eed  ed< ee	 ed< ee
e  ed< eed gd	f  ed
< ee	 ed< dededd	fdd„Zede
d  ddfdd„ƒZede
d deddfdd„ƒZd	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   úR/var/www/html/chatgpt/venv/lib/python3.10/site-packages/pydantic/v1/dataclasses.pyÚ__init__P   ó   zDataclass.__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=   zDataclass.__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©é   é
   )Zfield_specifiersTF.©
ÚinitÚreprÚeqÚorderÚunsafe_hashÚfrozenÚconfigÚvalidate_on_initÚ	use_proxyÚkw_onlyrS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r1   ÚDataclassClassOrWrapperc        
   
      C   r2   r3   r4   rR   r4   r4   r7   rI   h   ó   rI   Ú_clsc       
         C   r2   r3   r4   )r_   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r4   r4   r7   rI   y   s   ©	rS   rT   rU   rV   rW   rX   rY   rZ   r[   c        	   	      C   r2   r3   r4   r`   r4   r4   r7   rI   �   s   c       	   
      C   r2   r3   r4   )
r_   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r4   r4   r7   rI   �   r^   c       
            sH   t |ƒ‰dtt ddf‡ ‡‡‡‡‡‡‡‡‡	f
dd„}| du 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 urˆnt | ƒo| jd tu ptt| ƒƒtt| jd ƒƒk}|r+d}t| ƒ}d}n&| jp/d}tjdkrCt	j
| ˆˆˆ ˆˆˆˆd�}nt	j
| ˆˆˆ ˆˆˆd�}d}ˆ	d u rW|nˆ	}t| ˆ||ƒ |jjdi | j| i¤Ž |S )	Nr   Ú FrO   )rS   rT   rU   rV   rW   rX   r\   )rS   rT   rU   rV   rW   rX   Tr4   )rL   Ú	__bases__rG   ÚsetÚdirr%   Ú__doc__ÚsysÚversion_infoÚdataclassesrI   Ú#_add_pydantic_validation_attributesr,   Z__try_update_forward_refs__rA   )r:   Zshould_use_proxyÚ
dc_cls_docÚdc_clsZdefault_validate_on_initZshould_validate_on_init©
rU   rX   rS   r\   rV   rT   Z
the_configrW   r[   rZ   r4   r7   ÚwrapÆ   s:   ÿ*û

øÿzdataclass.<locals>.wrapN)r   r   r   )r_   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   rm   r4   rl   r7   rI   ¯   s
   ,%r:   Úvaluec                 c   s*   � | j }z|| _ | V  W || _ d S || _ w r3   )r)   )r:   rn   Zoriginal_run_validationr4   r4   r7   rJ   ñ   s   €rJ   c                   @   s’   e Zd ZdZded ddfdd„Zded	edefd
d„Zdedefdd„Z	dededdfdd„Z
dedefdd„Zddd„Zdedd fdd„ZdS )r%   Ú__dataclass__rk   r#   r1   Nc                 C   s   t  | d|¡ d S )Nro   )rG   Ú__setattr__)r6   rk   r4   r4   r7   r8   þ   ó   zDataclassProxy.__init__r/   r0   c                 O   s@   t | jdƒ� | j|i |¤ŽW  d   ƒ S 1 sw   Y  d S )NT)rJ   ro   r5   r4   r4   r7   Ú__call__  s   $ÿzDataclassProxy.__call__Únamec                 C   s   t | j|ƒS r3   )Úgetattrro   )r6   rs   r4   r4   r7   Ú__getattr__  ó   zDataclassProxy.__getattr__Ú_DataclassProxy__nameÚ_DataclassProxy__valuec                 C   s   t | j||ƒS r3   )Úsetattrro   )r6   rw   rx   r4   r4   r7   rp     s   zDataclassProxy.__setattr__Úinstancec                 C   s   t || jƒS r3   )Ú
isinstancero   )r6   rz   r4   r4   r7   Ú__instancecheck__  rv   z DataclassProxy.__instancecheck__c                 C   s   t t | j¡ƒS r3   )r%   Úcopyro   ©r6   r4   r4   r7   Ú__copy__  s   zDataclassProxy.__copy__Úmemoc                 C   s   t t | j|¡ƒS r3   )r%   r}   Údeepcopyro   )r6   r€   r4   r4   r7   Ú__deepcopy__  rq   zDataclassProxy.__deepcopy__)r1   r%   )rA   rB   rC   Ú	__slots__r   r8   r   rr   rD   ru   rp   rF   r|   r   r‚   r4   r4   r4   r7   r%   û   s    
rk   rj   c              	      sZ  | j ‰tˆƒdddtdtddf‡ ‡fdd„ƒ‰t| d	ƒrPz| jj‰W n ty.   | j‰Y nw tˆƒdddtdtddf‡ ‡fd
d„ƒ}t| dˆƒ t| d	|ƒ ntˆƒdddtdtddf‡fdd„ƒ}t| d|ƒ t| dtd|ƒƒ t| ddƒ t| dt	| ˆ |ƒƒ t| dt
ƒ t| dttƒƒ t| dttƒƒ | jjjr©| jjs«t| dtƒ dS dS dS )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 tjkrˆˆ g|¢R i ‡ fdd„| ¡ D ƒ¤Ž d S ˆj tjkrH| ¡ D ]\}}ˆ j ||¡ q&ˆˆ g|¢R i ‡ fdd„| ¡ D ƒ¤Ž d S ˆˆ g|¢R i |¤Ž d S )Nc                    ó    i | ]\}}|ˆ j v r||“qS 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ÚitemsZallowÚ__dict__Ú
setdefault)r6   r/   r0   rˆ   r>   )rY   rS   r~   r7   Úhandle_extra_init"  s   ,,z>_add_pydantic_validation_attributes.<locals>.handle_extra_initr(   c                    sr   ˆ j dkrˆ| g|¢R i |¤Ž | jjr%|  ¡  t| dƒr%| j|i |¤Ž ˆ j dkr7ˆ| g|¢R i |¤Ž d S d S )NZbefore_validationr*   Zafter_validation)Zpost_init_callÚ	__class__r)   r-   Úhasattrr*   r5   )rY   Ú	post_initr4   r7   Únew_post_init5  s   


ÿz:_add_pydantic_validation_attributes.<locals>.new_post_initr8   c              	      s®   ˆ | g|¢R i |¤Ž | j jr|  ¡  t| dƒrUi }t| j j ¡ ƒD ](\}}|jtj	u rJz	|| ||j
< W q" tyI   | |j
|j¡||j
< Y q"w q"| jdi |¤Ž d S d S )Nr*   r4   )r‘   r)   r-   r’   Ú	enumerater&   ÚvaluesÚ_field_typerh   Ú_FIELD_INITVARrs   Ú
IndexErrorÚgetÚdefaultr*   )r6   r/   r0   Zinitvars_and_valuesÚiÚf)r�   r4   r7   Únew_initG  s   
ÿüòz5_add_pydantic_validation_attributes.<locals>.new_initr)   r+   Fr,   r-   r@   r<   rp   )r8   r   r   r’   r(   Ú__wrapped__ÚAttributeErrorry   r   rK   Ú_dataclass_validate_valuesrH   Ú_validate_dataclassÚ_get_validatorsr,   Ú
__config__Zvalidate_assignmentr'   rX   Ú&_dataclass_validate_assignment_setattr)rk   rY   rZ   rj   r”   rž   r4   )rY   r�   rS   r“   r7   ri     s2   "

ÿ" ÿri   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|ttfƒr*| |Ž W  d   ƒ S t|tƒr=| di |¤ŽW  d   ƒ S t| jd�‚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 }|jt jur|j}n|jt jur!|j}nt}t|tƒr.|}d| _	nt
d||dœ|j¤Ž}|j|f||j< qt| ƒ}t| jf|| j|ddidœ|¤Ž}	|d ur`||	_|	S | jpdd|	_|	S )NT)r›   Údefault_factoryZ__resolve_forward_refs__F)r¤   rB   Z__validators__Z__cls_kwargs__ra   r4   )rh   Úfieldsr   r›   ÚMISSINGrª   r   r{   r   r.   r   ÚmetadataÚtypers   r   r   rA   rB   re   )
rk   rY   rj   Zfield_definitionsÚfieldr›   rª   Z
field_infoZ
validatorsÚmodelr4   r4   r7   rK   |  s:   
ÿûúÿrK   )rP   é   Úobjrˆ   c                 C   s   t tt| ƒ|d ƒtƒS r3   )r{   rt   r®   r   ©r²   rˆ   r4   r4   r7   Ú_is_field_cached_property¥  s   r´   c                 C   s   dS )NFr4   r³   r4   r4   r7   r´   ª  r9   r6   c                    sŠ   t ˆ dƒrd S t ˆ ddƒr‡ fdd„ˆ j ¡ D ƒ}n‡ fdd„ˆ j ¡ D ƒ}tˆ j|ˆ jd�\}}}|r6|‚ˆ j |¡ t ˆ dd¡ d S )	Nr+   r.   Fc                    s*   i | ]\}}t |tƒstˆ |ƒs||“qS r4   )r{   r   r´   r†   r~   r4   r7   r‰   ¶  s    ýýÿz._dataclass_validate_values.<locals>.<dictcomp>c                    s    i | ]\}}t ˆ |ƒs||“qS r4   )r´   r†   r~   r4   r7   r‰   ¼  rŠ   r;   T)	rt   rŽ   r�   r   r,   r‘   ÚupdaterG   rp   )r6   Z
input_dataÚdÚ_Zvalidation_errorr4   r~   r7   r¡   ®  s   

þr¡   rs   c                 C   sl   | j r-t| jƒ}| |d ¡ | jj |d ¡}|r-|j|||| jd�\}}|r-t	|g| jƒ‚t
 | ||¡ d S )N)Úlocr:   )r+   r©   rŽ   Úpopr,   Z
__fields__rš   Úvalidater‘   r   rG   rp   )r6   rs   rn   r¶   Zknown_fieldZerror_r4   r4   r7   r¥   Ä  s   
r¥   c                 C   s2   t  | ¡ot| dƒ ot| jƒ tt| di ƒƒ¡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   )rh   Úis_dataclassr’   rc   r&   Ú
issupersetrt   )r_   r4   r4   r7   rL   Ñ  s
   

ÿýrL   c                 c   s   � t t| |dd�ƒE dH  dS )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)rY   r[   N)r£   rI   )rk   rY   r4   r4   r7   rM   î  s   €rM   r3   )r:   r]   r1   r    )r6   r#   r1   N)Gre   r}   rh   rf   Ú
contextlibr   Ú	functoolsr   r   ÚImportErrorÚtypingr   r   r   r   r	   r
   r   r   r   r   r   Ztyping_extensionsr   Zpydantic.v1.class_validatorsr   Zpydantic.v1.configr   r   r   r   Zpydantic.v1.error_wrappersr   Zpydantic.v1.errorsr   Zpydantic.v1.fieldsr   r   r   r   Zpydantic.v1.mainr   r   Zpydantic.v1.utilsr   r   Zpydantic.v1.typingr    r!   r"   r]   r#   Ú__all__rN   rg   r¯   rF   rG   rI   rJ   r%   rD   ri   r£   r¢   rK   r´   r¡   r¥   rL   rM   r4   r4   r4   r7   Ú<module>   sÞ   !þ4õþýüûúùø	÷
öõôôÿýüûúùø	÷
öõôóöþýüûúùø	÷
öõõÿýüûúùø	÷
öõôÿô
ÿýüûúùø	÷
öõôóA*	ÿþýü
û
Výÿþý
ü'
"