
    bMhF                        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 n# e	$ r Y nw xY 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r8ddl(m-Z- ddl.m/Z/m0Z0  edd          Z1eed         df         Z2 G d d          Z3g dZ4 ed          Z5ej6        dk    r eej7        e$f          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*                        Z: eej7        e$f          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,                        Z:n eej7        e$f          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.                        Z: eej7        e$f          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d/                        Z: eej7        e$f          	 dId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d0            Z:ed1ed         d2e8d(eed         ddf         fd3            Z; G d4 d          Z<d5ed         d$ee         d%e8d6e=d(df
d7Z>dJd9Z?d1ed         d:ed(dfd;Z@edfd5ed         d$ee         d6ee=         d(ed<         fd=ZAej6        d>k    rd?dd@e=d(e8fdAZBn
d?dd@e=d(e8fdBZBdKdDZCdCddEe=d2ed(dfdFZDd+ee         d(e8fdGZEd5ed         d$ee         d(d8fdHZFdS )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                      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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                     d S N selfr1   r2   s      W/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/pydantic/v1/dataclasses.py__init__zDataclass.__init__P   s    D    clsr!   c                     d S r5   r6   r<   s    r9   __get_validators__zDataclass.__get_validators__S       Dr;   r#   vc                     d S r5   r6   r<   rA   s     r9   __validate__zDataclass.__validate__W   r@   r;   )__name__
__module____qualname__r	   r
   strr   __annotations__r   boolr   r    objectr:   classmethodr?   rD   r6   r;   r9   r$   r$   B   sf        &tCH~6666&sm+++ 34444 &.d^333"*8I+>"????"*4.000$T)_5555&.xt8K/L&MM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_onlyrX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   r3   DataclassClassOrWrapperc        
             d S r5   r6   rW   s
             r9   rM   rM   h   	     	r;   _clsc       
             d S r5   r6   )re   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   s              r9   rM   rM   y   s	      	r;   	rX   rY   rZ   r[   r\   r]   r^   r_   r`   c        	             d S r5   r6   rg   s	            r9   rM   rM      s	     	r;   c       	             d S r5   r6   )
re   rX   rY   rZ   r[   r\   r]   r^   r_   r`   s
             r9   rM   rM      rd   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<   r3   rb   c           
        
 ngt          |           oX| j        d         t          u pDt          t	          |                     t          t	          | j        d                             k    }|rd}t          |           }d}nS| j        pd}t          j        dk    rt          j
        | 
	          }nt          j
        | 
          }d}|n}t          | ||            |j        j        di | j        | i |S )	Nr    FrS   )rX   rY   rZ   r[   r\   r]   ra   )rX   rY   rZ   r[   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_initrZ   r]   rX   ra   r[   rY   
the_configr\   r`   r_   s         r9   wrapzdataclass.<locals>.wrap   sX    $ I %S)) `]1%/^3s3xx==CCMZ[L\H]H]D^D^3^ 	  	,J#C((F',$$*J7**$. +!#	 	 	 %.d"E{ci   (,$>N>V":":\l+C=TV`aaa=!=TTs@STTTr;   )r   r   r   )re   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   r|   r{   s    `````` ``` @r9   rM   rM      s    * F##J#$s) # 9 # # # # # # # # # # # # # # #J |4::r;   r<   valuec              #   V   K   | j         }	 || _         | V  || _         d S # || _         w xY wr5   )r+   )r<   r}   original_run_validations      r9   rN   rN      sI      !=B*/'			*A'''*A'AAAAs    	(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dS )r&   __dataclass__rx   r$   r3   Nc                 >    t                               | d|           d S )Nr   )rK   __setattr__)r8   rx   s     r9   r:   zDataclassProxy.__init__   s     4&99999r;   r1   r2   c                 z    t          | j        d          5   | j        |i |cd d d            S # 1 swxY w Y   d S )NT)rN   r   r7   s      r9   __call__zDataclassProxy.__call__  s    D.55 	7 	7%4%t6v66	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7s   044namec                 ,    t          | j        |          S r5   )getattrr   )r8   r   s     r9   __getattr__zDataclassProxy.__getattr__  s    t)4000r;   _DataclassProxy__name_DataclassProxy__valuec                 .    t          | j        ||          S r5   )setattrr   )r8   r   r   s      r9   r   zDataclassProxy.__setattr__  s    t)67;;;r;   instancec                 ,    t          || j                  S r5   )
isinstancer   )r8   r   s     r9   __instancecheck__z DataclassProxy.__instancecheck__  s    (D$6777r;   c                 N    t          t          j        | j                            S r5   )r&   copyr   )r8   s    r9   __copy__zDataclassProxy.__copy__  s    di(:;;<<<r;   memoc                 P    t          t          j        | j        |                    S r5   )r&   r   deepcopyr   )r8   r   s     r9   __deepcopy__zDataclassProxy.__deepcopy__  s    dmD,>EEFFFr;   )r3   r&   )rE   rF   rG   	__slots__r   r:   r   r   rH   r   r   rJ   r   r   r   r6   r;   r9   r&   r&      s       I:tK0 :T : : : :7c 7S 7S 7 7 7 71 1 1 1 1 1<# < < < < < <8# 8$ 8 8 8 8= = = =G G)9 G G G G G Gr;   rx   rw   c           	         | j         t                    dddt          dt          ddffd            t          | d          rv	 | j        j        n# t          $ r
 | j        Y nw xY wt                    dddt          dt          ddffd	            }t          | d
           t          | d|           n>t                    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&                     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
    r8   r$   r1   r2   r3   Nc                     j         t          j        k    r,  g|R i  fd|                                D              d S j         t          j        k    ra|                                D ] \  }} j                            ||           !  g|R i  fd|                                D              d S   g|R i | d S )Nc                 .    i | ]\  }}|j         v ||S r6   r(   .0krA   r8   s      r9   
<dictcomp>zR_add_pydantic_validation_attributes.<locals>.handle_extra_init.<locals>.<dictcomp>%  ,     c c c$!QAIbDbDbADbDbDbr;   c                 .    i | ]\  }}|j         v ||S r6   r   r   s      r9   r   zR_add_pydantic_validation_attributes.<locals>.handle_extra_init.<locals>.<dictcomp>*  r   r;   )extrar   ignoreitemsallow__dict__
setdefault)r8   r1   r2   r   rA   r^   rX   s   `    r9   handle_extra_initz>_add_pydantic_validation_attributes.<locals>.handle_extra_init"  s   <5<''Ddddd c c c c&,,.. c c cddddd\U[(( / /1((A....Ddddd c c c c&,,.. c c cddddd D'''''''''r;   r*   c                     j         dk    r | g|R i | | j        j        r1|                                  t	          | d          r | j        |i | j         dk    r | g|R i | d S d S )Nbefore_validationr,   after_validation)post_init_call	__class__r+   r/   hasattrr,   )r8   r1   r2   r^   	post_inits      r9   new_post_initz:_add_pydantic_validation_attributes.<locals>.new_post_init5  s    $(;;;	$0000000~9 C113334!;<< C1D14B6BBB$(:::	$000000000 ;:r;   r:   c                     | g|R i | | j         j        r|                                  t          | d          ri }t	          | j         j                                                  D ]b\  }}|j        t          j	        u rJ	 ||         ||j
        <   *# t          $ r+ |                    |j
        |j                  ||j
        <   Y ^w xY wc | j        di | d S d S )Nr,   r6   )r   r+   r/   r   	enumerater(   values_field_typers   _FIELD_INITVARr   
IndexErrorgetdefaultr,   )r8   r1   r2   initvars_and_valuesifr   s         r9   new_initz5_add_pydantic_validation_attributes.<locals>.new_initG  s/   d4T444V444~9 411333t788 E
 79#%dn&I&P&P&R&RSS X XDAq}(BBBX:>q'/77) X X X:@**QVQY:W:W/777X	 C .-DD0CDDDDDE Es   B2C
	C
r+   r-   Fr.   r/   rD   r?   r   )r:   r   r   r   r*   __wrapped__AttributeErrorr   r   rO   _dataclass_validate_valuesrL   _validate_dataclass_get_validatorsr.   
__config__validate_assignmentr)   r]   &_dataclass_validate_assignment_setattr)	rx   r^   r_   rw   r   r   r   rX   r   s	    `    @@@r9   rt   rt     s    ?D
4[[
( 
(C 
(3 
(4 
( 
( 
( 
( 
( 
( [
( v'' /.	-,8II 	- 	- 	-,III	- 
y		
	1 
	1C 
	13 
	14 
	1 
	1 
	1 
	1 
	1 
	1 
	
	1 	
$56667777 
t	E; 	Es 	Ec 	Ed 	E 	E 	E 	E 	E 
	E, 	
H---F1>B_aq3r3rsssF.666F(*NvW]_i*j*jkkkF24NOOOFNK0C$D$DEEEF(+o*F*FGGG +? OHcHj O'MNNNNNO O O Os   A A,+A,r!   c              #      K   | j         V  d S r5   )rD   r>   s    r9   r   r   k  s      

r;   rA   c                 x   t          | d          5  t          ||           r"|                                 |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xY w Y   d S )NT)
class_namer6   )rN   r   r/   listtupledictr   rE   rC   s     r9   r   r   o  sF   	T	"	" 	> 	>a 	>**,,,	> 	> 	> 	> 	> 	> 	> 	> D%=)) 	>37	> 	> 	> 	> 	> 	> 	> 	> 4   	>38888	> 	> 	> 	> 	> 	> 	> 	> %====	> 	> 	> 	> 	> 	> 	> 	> 	> 	>s#   &B/ B/1B/B//B36B3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|}	||n| j        pd|	_        |	S )NT)r   default_factory__resolve_forward_refs__F)r   rF   __validators____cls_kwargs__rl   r6   )rs   fieldsr   r   MISSINGr   r   r   r   r0   r   metadatatyper   r   r   rE   rF   rp   )
rx   r^   rw   field_definitionsfieldr   r   
field_info
validatorsmodels
             r9   rO   rO   |  s+   
 )+#F++ A A 8< = 333mGG"+*===#3OOGgy)) 	c J9=F66bwbbSXSabbJ).Z(@%*%%&v..J+ $!2E:       E #-"8JJfn>RPREMLr;   )rT      objr   c                 d    t          t          t          |           |d           t                    S r5   )r   r   r   r   r   r   s     r9   _is_field_cached_propertyr     s$    '$s))Q55GGGr;   c                     dS )NFr6   r   s     r9   r   r     s    ur;   r8   c                     t           d          rd S t           dd          r& fd j                                        D             }n% fd j                                        D             }t           j        | j                  \  }}}|r| j                            |           t                               dd           d S )Nr-   r0   Fc                 f    i | ]-\  }}t          |t                    t          |          *||.S r6   )r   r   r   r   s      r9   r   z._dataclass_validate_values.<locals>.<dictcomp>  sU     
 
 
1q),,
 1J$PQ0R0R
q
 
 
r;   c                 <    i | ]\  }}t          |          ||S r6   )r   r   s      r9   r   z._dataclass_validate_values.<locals>.<dictcomp>  s1    gggtq!D]^bdeDfDfgagggr;   r>   T)	r   r   r   r   r.   r   updaterK   r   )r8   
input_datad_validation_errors   `    r9   r   r     s     t/00 t:EBB 	h
 
 
 
++--
 
 


 hgggt}':':'<'<ggg
+D,CZUYUcdddAq
 M
t7>>>>>r;   r   c                 V   | j         rt          | j                  }|                    |d            | j        j                            |d           }|r9|                    |||| j                  \  }}|rt          |g| j                  t                              | ||           d S )N)locr<   )r-   r   r   popr.   
__fields__r   validater   r   rK   r   )r8   r   r}   r   known_fielderror_s         r9   r   r     s    $ @	dD-8<<T4HH 	@'00t0XXME6 @%vh???
tT5)))))r;   c           	          t          j        |           oSt          | d           oBt          | 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.   rI   )rs   is_dataclassr   rn   r(   
issupersetr   )re   s    r9   rP   rP     sf    . 	 && 	a2333	a)**55c'$HY[]:^:^6_6_``r;   c              #   T   K   t          t          | |d                    E d{V  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)r^   r`   N)r   rM   )rx   r^   s     r9   rQ   rQ     s=       y$OOOPPPPPPPPPPPr;   r5   )r<   rb   r3   r!   )r8   r$   r3   N)Grp   r   rs   rq   
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#   rb   r$   __all__rR   rr   r   rJ   rK   rM   rN   r&   rH   rt   r   r   rO   r   r   r   rP   rQ   r6   r;   r9   <module>r     s	     B      



 % % % % % %      	))))))) 	 	 	D	 u t t t t t t t t t t t t t t t t t t t t t t t t t 1 1 1 1 1 1 > > > > > > H H H H H H H H H H H H 6 6 6 6 6 6 1 1 1 1 1 1 D D D D D D D D D D D D 9 9 9 9 9 9 9 9 , , , , , , ******FFFFFFFF[999J#D$57G$GH       4   WT]]w;+<e*DEEE !8<+/$(    	
    j$v,45 #4. D>  
48*77	8   X FE ;+<e*DEEE !8<+/$(  2h  	
     j$v,45 #4. D>  
#   X FE $ ;+<e*DEEE !8<+/$(    	
    j$v,45 #4. D> 
48*77	8   X FE ;+<e*DEEE !8<+/$(  2h  	
     j$v,45 #4. D> 
#   X FE  {'8%&@AAA#> 48'+ $> > >
48
> > 	>
 	> > > > *d6lD01> tn> ~> > 8T"XJ 99:<UUV> > > BA>B B\* B4 BId<FXZ^`dFd<e B B B BG G G G G G G G4SOSOSO SO 	SO
 
SO SO SO SOl   
>T,/ 
>C 
>L 
> 
> 
> 
> # $$ $$I$ $ 
+	$ $ $ $N vH{ Hs Ht H H H H H
{ s t    ? ? ? ?,
* 
*C 
*PS 
*X\ 
* 
* 
* 
*tCy T    :QT+%6 QZ@P QUh Q Q Q Q Q Qs   # ++