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   úT/var/www/html/CropPilot/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©é   é
   )Ú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 |ƒ‰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   )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:   ÿ*û

øÿzdataclass.<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 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__rn   r#   r1   Nc                 C   s   t  | d|¡ d S )Nrv   )rG   Ú__setattr__)r6   rn   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   rv   r5   r4   r4   r7   Ú__call__  s   $ÿzDataclassProxy.__call__Únamec                 C   s   t | j|ƒS r3   )Úgetattrrv   )r6   rz   r4   r4   r7   Ú__getattr__  ó   zDataclassProxy.__getattr__Ú_DataclassProxy__nameÚ_DataclassProxy__valuec                 C   s   t | j||ƒS r3   )Úsetattrrv   )r6   r~   r   r4   r4   r7   rw     s   zDataclassProxy.__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   zDataclassProxy.__copy__Úmemoc                 C   s   t t | j|¡ƒS r3   )r%   r„   Údeepcopyrv   )r6   r‡   r4   r4   r7   Ú__deepcopy__  rx   zDataclassProxy.__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ˆƒ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Ú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 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 )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 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_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|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_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 tt| ƒ|d ƒtƒS r3   )r‚   r{   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)	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 ¡ | jj |d ¡}|r-|j|||| jd�\}}|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  | ¡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   )ri   Úis_dataclassr�   rd   r&   Ú
issupersetr{   )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)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ýÿþý
ü'
"