
    +DCfF                        d Z ddlZddlZddlZddlmZ ddlmZ 	 ddlmZ 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.m/Z/  edd      Z0eed   df   Z1 G d d      Z2g dZ3 ed      Z4ejj                  dk\  r eejl                  e$f      eddddddddddd
de7d e7d!e7d"e7d#e7d$e7d%eeee8   df   d&ee7   d'ee7   d(e7d)eee4   gd*f   fd+              Z9 eejl                  e$f      eddddddddddd
d,ee4   de7d e7d!e7d"e7d#e7d$e7d%eeee8   df   d&ee7   d'ee7   d(e7d)d*fd-              Z9n eejl                  e$f      edddddddddd.	de7d e7d!e7d"e7d#e7d$e7d%eeee8   df   d&ee7   d'ee7   d)eee4   gd*f   fd/              Z9 eejl                  e$f      edddddddddd.	d,ee4   de7d e7d!e7d"e7d#e7d$e7d%eeee8   df   d&ee7   d'ee7   d)d*fd0              Z9 eejl                  e$f      	 dJddddddddddd
d,eee4      de7d e7d!e7d"e7d#e7d$e7d%eeee8   df   d&ee7   d'ee7   d(e7d)eeee4   gd*f   d*f   fd1       Z9ed2ed   d3e7d)eed   ddf   fd4       Z: G d5 d      Z;d6ed   d%ee   d&e7d7e<d)df
d8Z=dKd:Z>d2ed   d;ed)dfd<Z?edfd6ed   d%ee   d7ee<   d)ed=   fd>Z@ejj                  d?k\  rd@ddAe<d)e7fdBZAn
d@ddAe<d)e7fdCZAdLdEZBdDddFe<d3ed)dfdGZCd,ee   d)e7fdHZDd6ed   d%ee   d)d9fdIZEy# e	$ r Y "w xY w)MaX  
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                      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Zede
d    ddfd       Zede
d   deddfd       Zy	)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 selfr2   r3   s      W/var/www/highfloat_scraper/venv/lib/python3.12/site-packages/pydantic/v1/dataclasses.py__init__zDataclass.__init__P   s        clsr"   c                      y r6   r7   r=   s    r:   __get_validators__zDataclass.__get_validators__S       r<   r$   vc                      y r6   r7   r=   rB   s     r:   __validate__zDataclass.__validate__W   rA   r<   )__name__
__module____qualname__r	   r
   strr   __annotations__r   boolr   r!   objectr;   classmethodr@   rE   r7   r<   r:   r%   r%   B   s    &tCH~66&sm+ 344 &.d^3"*8I+>"??"*4.0$T)_55&.xt8K/L&MM-5d^;	& 	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_onlyrY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   r4   DataclassClassOrWrapperc        
              y r6   r7   rX   s
             r:   rN   rN   h        	r<   _clsc       
              y r6   r7   )rf   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   s              r:   rN   rN   y   s      	r<   	rY   rZ   r[   r\   r]   r^   r_   r`   ra   c        	              y r6   r7   rh   s	            r:   rN   rN      s     	r<   c       	              y r6   r7   )
rf   rY   rZ   r[   r\   r]   r^   r_   r`   ra   s
             r:   rN   rN      re   r<   c       
            	
 t        |      dt        t           ddf
	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=   r4   rc   c           
        
 nYt        |       xrM | j                  d   t        u xs6 t        t	        |             t        t	        | j                  d               k(  }|rd}t        |       }d}n_| j                  xs d}t        j                  dk\  rt        j                  | 
	      }nt        j                  | 
      }d}|n}t        | ||        |j                  j                  di | j                  | i |S )	Nr    FrT   )rY   rZ   r[   r\   r]   r^   rb   )rY   rZ   r[   r\   r]   r^   Tr7   )rQ   	__bases__rL   setdirr'   __doc__sysversion_infodataclassesrN   #_add_pydantic_validation_attributesr/   __try_update_forward_refs__rF   )r=   should_use_proxy
dc_cls_docdc_clsdefault_validate_on_initshould_validate_on_initr[   r^   rY   rb   r\   rZ   
the_configr]   ra   r`   s         r:   wrapzdataclass.<locals>.wrap   s*    $  %S) `]]1%/^3s3x=CCMMZ[L\H]D^3^ 	 J#C(F',$*J7*$.. +!#	 %..d"E{ci (,$>N>V":\l+C=TV`a=!!==Ts@STr<   )r   r   r   )rf   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   r}   r|   s    `````` ``` @r:   rN   rN      sD    * F#J#$s) # 9 # #J |:r<   r=   valuec              #   b   K   | j                   }	 || _         |  || _         y # || _         w xY wwr6   )r,   )r=   r~   original_run_validations      r:   rO   rO      s6     !==B*/'	*A'*A's   /# /	,/c                       e Zd ZdZded   ddfdZdededefd	Zd
edefdZ	dededdfdZ
dedefdZddZdedd fdZy)r'   __dataclass__ry   r%   r4   Nc                 2    t         j                  | d|       y )Nr   )rL   __setattr__)r9   ry   s     r:   r;   zDataclassProxy.__init__   s    4&9r<   r2   r3   c                 ~    t        | j                  d      5   | j                  |i |cd d d        S # 1 sw Y   y xY w)NT)rO   r   r8   s      r:   __call__zDataclassProxy.__call__  s<    D..5 	7%4%%t6v6	7 	7 	7s   3<namec                 .    t        | j                  |      S r6   )getattrr   )r9   r   s     r:   __getattr__zDataclassProxy.__getattr__  s    t))400r<   _DataclassProxy__name_DataclassProxy__valuec                 0    t        | j                  ||      S r6   )setattrr   )r9   r   r   s      r:   r   zDataclassProxy.__setattr__  s    t))67;;r<   instancec                 .    t        || j                        S r6   )
isinstancer   )r9   r   s     r:   __instancecheck__z DataclassProxy.__instancecheck__  s    (D$6$677r<   c                 R    t        t        j                  | j                              S r6   )r'   copyr   )r9   s    r:   __copy__zDataclassProxy.__copy__  s    dii(:(:;<<r<   memoc                 T    t        t        j                  | j                  |            S r6   )r'   r   deepcopyr   )r9   r   s     r:   __deepcopy__zDataclassProxy.__deepcopy__  s    dmmD,>,>EFFr<   )r4   r'   )rF   rG   rH   	__slots__r   r;   r   r   rI   r   r   rK   r   r   r   r7   r<   r:   r'   r'      s    I:tK0 :T :7c 7S 7S 71 1 1<# < < <8# 8$ 8=G G)9 Gr<   ry   rx   c           	      b   | j                   t              dddt        dt        ddffd       t        | d      rW	 | j                  j
                  t              dddt        dt        ddffd	       }t        | d
       t        | d|       n1t              dddt        dt        ddff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&               yyy# t        $ r | j                  Y Tw xY w)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
    r9   r%   r2   r3   r4   Nc           
      
   j                   t        j                  k(  r> | g|i |j                         D ci c]  \  }}|| j                  v s|| c}} y j                   t        j
                  k(  rr|j                         D ]!  \  }}| j                  j                  ||       #  | g|i |j                         D ci c]  \  }}|| j                  v s|| c}} y  | g|i | y c c}}w c c}}w r6   )extrar   ignoreitemsr)   allow__dict__
setdefault)r9   r2   r3   krB   r_   rY   s        r:   handle_extra_initz>_add_pydantic_validation_attributes.<locals>.handle_extra_init"  s    <<5<<'dd&,,. c$!QAIbIbDbA cd\\U[[( /1((A./dd&,,. c$!QAIbIbDbA cd ''' !d
 !ds   C9C9	C? C?r+   c                     j                   dk(  r | g|i | | j                  j                  r.| j                          t	        | d      r | j
                  |i | j                   dk(  r | g|i | y y )Nbefore_validationr-   after_validation)post_init_call	__class__r,   r0   hasattrr-   )r9   r2   r3   r_   	post_inits      r:   new_post_initz:_add_pydantic_validation_attributes.<locals>.new_post_init5  s    $$(;;$000~~991134!;<1D114B6B$$(::$000 ;r<   r;   c                     | g|i | | j                   j                  r| j                          t        | d      rzi }t	        | j                   j
                  j                               D ]5  \  }}|j                  t        j                  u s#	 ||   ||j                  <   7  | j                  di | y y # t        $ r6 |j                  |j                  |j                        ||j                  <   Y w xY w)Nr-   r7   )r   r,   r0   r   	enumerater)   values_field_typert   _FIELD_INITVARr   
IndexErrorgetdefaultr-   )r9   r2   r3   initvars_and_valuesifr   s         r:   new_initz5_add_pydantic_validation_attributes.<locals>.new_initG  s    d4T4V4~~99113t78
 79#%dnn&I&I&P&P&RS XDAq}}(B(BBX:>q'/7	X .--D0CD 9  * X:@**QVVQYY:W/7Xs   B;;<C:9C:r,   r.   Fr/   r0   rE   r@   r   )r;   r   r   r   r+   __wrapped__AttributeErrorr   r    rP   _dataclass_validate_valuesrM   _validate_dataclass_get_validatorsr/   
__config__validate_assignmentr*   r^   &_dataclass_validate_assignment_setattr)	ry   r_   r`   rx   r   r   r   rY   r   s	    `    @@@r:   ru   ru     s    ??D
4[
( 
(C 
(3 
(4 
( 
( v'	-,,88I 
y	
	1 
	1C 
	13 
	14 
	1 

	1 	
$567 
t	E; 	Es 	Ec 	Ed 	E 
	E, 	
H-F1>B_aq3rsF.6F(*NvW]_i*jkF24NOFNK0C$DEF(+o*FG  ++??HcHcHjHj'MN Ik?k  	-,,I	-s   F F.-F.r"   c              #   (   K   | j                    y wr6   )rE   r?   s    r:   r   r   k  s     


s   rB   c                 8   t        | d      5  t        ||       r|j                          |cd d d        S t        |t        t        f      r | | cd d d        S t        |t
              r | di |cd d d        S t        | j                        # 1 sw Y   y xY w)NT)
class_namer7   )rO   r   r0   listtupledictr   rF   rD   s     r:   r   r   o  s    	T	" 	>a**,	> 	> D%=)7	> 	> 4 88	> 	> %==	> 	>s   BBB:BBr!   c                 <   i }t        j                  |       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                  <    t        |       }t        | j                   f|| j"                  |ddid|}	|	||	_        |	S | j$                  xs d|	_        |	S )NT)r   default_factory__resolve_forward_refs__F)r   rG   __validators____cls_kwargs__rm   r7   )rt   fieldsr   r   MISSINGr   r   r   r   r1   r   metadatatyper   r   r   rF   rG   rq   )
ry   r_   rx   field_definitionsfieldr   r   
field_info
validatorsmodels
             r:   rP   rP   |  s*   
 )+##F+ A 8< == 3 33mmG""+*=*==#33OGgy) J9=F6bwbSXSaSabJ).Z(@%**%%A( 'v.J+ $$!2E:   E #-"8JEML ?Enn>RPREMLr<   )rU      objr   c                 J    t        t        t        |       |d       t              S r6   )r   r   r   r   r   r   s     r:   _is_field_cached_propertyr     s    '$s)Q5GGr<   c                      y)NFr7   r   s     r:   r   r     s    r<   r9   c                    t        | d      ry t        | dd      rJ| j                  j                         D ci c]$  \  }}t        |t              st        | |      s||& }}}n:| j                  j                         D ci c]  \  }}t        | |      r|| }}}t        | j                  || j                        \  }}}|r|| j                  j                  |       t        j                  | dd       y c c}}w c c}}w )Nr.   r1   Fr?   T)r   r   r   r   r   r   r   r/   r   updaterL   r   )r9   r   rB   
input_datad_validation_errors          r:   r   r     s     t/0t:EB
 ++-
1q),0I$PQ0R qD

 
 (,}}':':'<gtq!D]^bdeDfadg
g+D,C,CZUYUcUcdAq
MM
t7>
 hs   )C<DDr   c                 ^   | j                   rt        | j                        }|j                  |d        | j                  j
                  j                  |d       }|r;|j                  |||| j                        \  }}|rt        |g| j                        t        j                  | ||       y )N)locr=   )r.   r   r   popr/   
__fields__r   validater   r   rL   r   )r9   r   r~   r   known_fielderror_s         r:   r   r     s    $$	dD--88<<T4H'00t0XME6%vh??
tT5)r<   c           	          t        j                  |       xrG t        | d       xr8 t        | j                        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/   rJ   )rt   is_dataclassr   ro   r)   
issupersetr   )rf   s    r:   rQ   rQ     sZ    . 	  & 	a233	a))*55c'$HY[]:^6_`r<   c              #   N   K   t        t        | |d            E d{    y7 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_   ra   N)r   rN   )ry   r_   s     r:   rR   rR     s      y$OPPPs   %#%r6   )r=   rc   r4   r"   )r9   r%   r4   N)Frq   r   rt   rr   
contextlibr   	functoolsr   r   ImportErrortypingr   r   r   r	   r
   r   r   r   r   r   r   typing_extensionsr   class_validatorsr   r_   r   r   r   r   error_wrappersr   errorsr   r   r   r   r   r   mainr   r   utilsr    r!   r"   r#   r$   rc   r%   __all__rS   rs   r   rK   rL   rN   rO   r'   rI   ru   r   r   rP   r   r   r   rQ   rR   r7   r<   r:   <module>r      s   B   
 % 	)
 u t t t 1 3 = = + & 9 9 . !;[9J#D$57G$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<+/$(2h  	
     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<+/$(2h  	
     j$v,45 #4. D> 
#  F  {'8'8%&@A#> 48'+ $>
48
> > 	>
 	> > > > *d6lD01> tn> ~> > 8T"XJ 99:<UUV> B>B B\* B4 BId<FXZ^`dFd<e B BG G4SOSOSO SO 	SO
 
SOl
>T,/ 
>C 
>L 
> # $$$I$ $ 
+	$N vH{ Hs Ht H
{ s t ?,
* 
*C 
*PS 
*X\ 
*tCy T :QT+%6 QZ@P QUh QI  		s   L< <MM