
    hF                        S r SSKrSSKrSSKrSSKJr  SSKJr   SSKJr  SSK
JrJrJrJrJrJrJrJrJrJrJr  SSKJr  SSKJr  SS	KJrJrJrJr  SS
KJ r   SSK!J"r"  SSK#J$r$J%r%J&r&J'r'  SSK(J)r)J*r*  SSK+J,r,  \(       a)  SSK(J-r-  SSK.J/r/J0r0  \" SSS9r1\\S   S4   r2 " S S5      r3/ SQr4\" S5      r5\Rl                  S:  a  \" \Rn                  \$4S9\SSSSSSSSSSS.
S\8S\8S \8S!\8S"\8S#\8S$\\\\9   S4   S%\\8   S&\\8   S'\8S(\\\5   /S)4   4S* jj5       5       r:\" \Rn                  \$4S9\SSSSSSSSSSS.
S+\\5   S\8S\8S \8S!\8S"\8S#\8S$\\\\9   S4   S%\\8   S&\\8   S'\8S(S)4S, jj5       5       r:O\" \Rn                  \$4S9\SSSSSSSSSS-.	S\8S\8S \8S!\8S"\8S#\8S$\\\\9   S4   S%\\8   S&\\8   S(\\\5   /S)4   4S. jj5       5       r:\" \Rn                  \$4S9\SSSSSSSSSS-.	S+\\5   S\8S\8S \8S!\8S"\8S#\8S$\\\\9   S4   S%\\8   S&\\8   S(S)4S/ jj5       5       r:\" \Rn                  \$4S9 SISSSSSSSSSSS.
S+\\\5      S\8S\8S \8S!\8S"\8S#\8S$\\\\9   S4   S%\\8   S&\\8   S'\8S(\\\\5   /S)4   S)4   4S0 jjj5       r:\S1\S   S2\8S(\\S   SS4   4S3 j5       r; " S4 S5      r<S5\S   S$\\   S%\8S6\=S(S4
S7 jr>SJS9 jr?S1\S   S:\S(S4S; jr@\S4S5\S   S$\\   S6\\=   S(\S<   4S= jjrA\Rl                  S>:  a  S?SS@\=S(\84SA jrBOS?SS@\=S(\84SB jrBSKSD jrCSCSSE\=S2\S(S4SF jrDS+\\   S(\84SG jrES5\S   S$\\   S(S84SH jrFg! \	 a     GN/f = f)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                   ,   \ rS rSr% \\\\4      \S'   \\   \S'   \\	S      \S'   \\
   \S'   \\	S      \S'   \\
   \S'   \\\      \S	'   \\	S /S
4      \S'   \\
   \S'   S\S\SS
4S jr\S\S    SS4S j5       r\S\S   S\SS4S j5       rSrg
)r$   B   __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                     g N selfr2   r3   s      I/var/www/html/env/lib/python3.13/site-packages/pydantic/v1/dataclasses.py__init__Dataclass.__init__P   s        clsr!   c                     g r6   r7   r>   s    r:   __get_validators__Dataclass.__get_validators__S       r=   r#   vc                     g r6   r7   r>   rD   s     r:   __validate__Dataclass.__validate__W   rC   r=   r7   )__name__
__module____qualname____firstlineno__r	   r
   strr   __annotations__r   boolr   r    objectr;   classmethodrA   rG   __static_attributes__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_onlyr^   r_   r`   ra   rb   rc   rd   re   rf   rg   r4   DataclassClassOrWrapperc        
             g r6   r7   r]   s
             r:   rS   rS   h        	r=   _clsc       
             g r6   r7   )rk   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   s              r:   rS   rS   y   s      	r=   	r^   r_   r`   ra   rb   rc   rd   re   rf   c        	             g r6   r7   rm   s	            r:   rS   rS      s     	r=   c       	             g r6   r7   )
rk   r^   r_   r`   ra   rb   rc   rd   re   rf   s
             r:   rS   rS      rj   r=   c       
            ^^^^^^^^	^
^ [        U5      mS[        [           SS4UUUU
UUUUU	U4
S jjnU c  U$ U" U 5      $ )z
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   rh   c                 B  >
 Tb  TOc[        U 5      =(       aR    U R                  S   [        L =(       d6    [        [	        U 5      5      [        [	        U R                  S   5      5      :H  nU(       a  Sn[        U 5      nSnOaU R                  =(       d    Sn[        R                  S:  a  [        R                  " U TTTT
TTT	S9nO[        R                  " U TTTT
TTS9nSnTc  UOTn[        U TXR5        UR                  R                  " S0 U R                  U 0D6  U$ )	Nr    FrY   )r^   r_   r`   ra   rb   rc   rg   )r^   r_   r`   ra   rb   rc   Tr7   )rV   	__bases__rP   setdirr&   __doc__sysversion_infodataclassesrS   #_add_pydantic_validation_attributesr/   __try_update_forward_refs__rI   )r>   should_use_proxy
dc_cls_docdc_clsdefault_validate_on_initshould_validate_on_initr`   rc   r^   rg   ra   r_   
the_configrb   rf   re   s         r:   wrap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=Ta!!==Ts@STr=   )r   r   r   )rk   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   r   r   s    `````` ``` @r:   rS   rS      sI    * F#J#$s) # 9 # # #J |:r=   r>   valuec              #   \   #    U R                   n Xl         U v   X l         g ! X l         f = f7fr6   )r,   )r>   r   original_run_validations      r:   rT   rT      s/     !==B*/'	*A'*A's   ,
! ,),c                       \ rS rSrSrS\S   SS4S jrS\S	\S\4S
 jrS\	S\4S jr
S\	S\SS4S jrS\S\4S jrSS jrS\SS 4S jrSrg)r&      __dataclass__r~   r$   r4   Nc                 2    [         R                  U SU5        g )Nr   )rP   __setattr__)r9   r~   s     r:   r;   DataclassProxy.__init__   s    4&9r=   r2   r3   c                     [        U R                  S5         U R                  " U0 UD6sS S S 5        $ ! , (       d  f       g = f)NT)rT   r   r8   s      r:   __call__DataclassProxy.__call__  s1    D..5%%t6v6 655s	   3
Anamec                 .    [        U R                  U5      $ r6   )getattrr   )r9   r   s     r:   __getattr__DataclassProxy.__getattr__  s    t))400r=   _DataclassProxy__name_DataclassProxy__valuec                 .    [        U R                  X5      $ r6   )setattrr   )r9   r   r   s      r:   r   DataclassProxy.__setattr__  s    t))6;;r=   instancec                 ,    [        XR                  5      $ r6   )
isinstancer   )r9   r   s     r:   __instancecheck__ DataclassProxy.__instancecheck__  s    ($6$677r=   c                 T    [        [        R                  " U R                  5      5      $ r6   )r&   copyr   )r9   s    r:   __copy__DataclassProxy.__copy__  s    dii(:(:;<<r=   memoc                 V    [        [        R                  " U R                  U5      5      $ r6   )r&   r   deepcopyr   )r9   r   s     r:   __deepcopy__DataclassProxy.__deepcopy__  s    dmmD,>,>EFFr=   r7   )r4   r&   )rI   rJ   rK   rL   	__slots__r   r;   r   r   rM   r   r   rO   r   r   r   rR   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=   r~   r}   c           	        ^^^^ U R                   m[        T5      SSS[        S[        SS4UU4S jj5       m[        U S5      (       aY   U R                  R
                  m[        T5      SSS[        S[        SS4UU4S	 jj5       n[        U S
T5        [        U SU5        O3[        T5      SSS[        S[        SS4U4S jj5       n[        U S
U5        [        U S[        SU5      5        [        U SS5        [        U S[        U TU5      5        [        U S[        5        [        U S[        [        5      5        [        U S[        [        5      5        U R                  R                  R                   (       a.  U R"                  R$                  (       d  [        U S[&        5        ggg! [         a    U R                  m GNcf = f)z
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           
        > TR                   [        R                  :X  aA  T" U /UQ70 UR                  5        VVs0 s H  u  p4X0R                  ;   d  M  X4_M     snnD6  g TR                   [        R
                  :X  au  UR                  5        H   u  p4U R                  R                  X45        M"     T" U /UQ70 UR                  5        VVs0 s H  u  p4X0R                  ;   d  M  X4_M     snnD6  g T" U /UQ70 UD6  g s  snnf s  snnf r6   )extrar   ignoreitemsr)   allow__dict__
setdefault)r9   r2   r3   krD   rd   r^   s        r:   handle_extra_init>_add_pydantic_validation_attributes.<locals>.handle_extra_init"  s    <<5<<'dd&,,. c.$!AIbIbDb. cd\\U[[(((. 'dd&,,. c.$!AIbIbDb. cd ''' !d
 !ds   DDD'Dr+   c                   > TR                   S:X  a  T" U /UQ70 UD6  U R                  R                  (       a3  U R                  5         [	        U S5      (       a  U R
                  " U0 UD6  TR                   S:X  a  T" U /UQ70 UD6  g g )Nbefore_validationr-   after_validation)post_init_call	__class__r,   r0   hasattrr-   )r9   r2   r3   rd   	post_inits      r:   new_post_init:_add_pydantic_validation_attributes.<locals>.new_post_init5  s    $$(;;$000~~991134!;<<114B6B$$(::$000 ;r=   r;   c                   > T" U /UQ70 UD6  U R                   R                  (       a  U R                  5         [        U S5      (       a{  0 n[	        U R                   R
                  R                  5       5       H5  u  pEUR                  [        R                  L d  M$   X   X5R                  '   M7     U R                  " S0 UD6  g g ! [         a6    UR                  UR                  UR                  5      X5R                  '    M  f = f)Nr-   r7   )r   r,   r0   r   	enumerater)   values_field_typery   _FIELD_INITVARr   
IndexErrorgetdefaultr-   )r9   r2   r3   initvars_and_valuesifr   s         r:   new_init5_add_pydantic_validation_attributes.<locals>.new_initG  s    d4T4V4~~99113t788
 79#%dnn&I&I&P&P&RSDA}}(B(BBX:>'/7	 T --D0CD 9  * X:@**QVVQYY:W/7Xs   C<DDr,   r.   Fr/   r0   rG   rA   r   )r;   r   r   r   r+   __wrapped__AttributeErrorr   r   rU   _dataclass_validate_valuesrQ   _validate_dataclass_get_validatorsr/   
__config__validate_assignmentr*   rc   &_dataclass_validate_assignment_setattr)	r~   rd   re   r}   r   r   r   r^   r   s	    `    @@@r:   rz   rz     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* *GGr!   c              #   (   #    U R                   v   g 7fr6   )rG   r@   s    r:   r   r   k  s     


s   rD   c                 X   [        U S5         [        X5      (       a  UR                  5         UsS S S 5        $ [        U[        [        45      (       a  U " U6 sS S S 5        $ [        U[
        5      (       a  U " S0 UD6sS S S 5        $ [        U R                  S9e! , (       d  f       g = f)NT)
class_namer7   )rT   r   r0   listtupledictr   rI   rF   s     r:   r   r   o  s    	T	"a**, 
#	" D%=))7 
#	" 4  88 
#	" %== 
#	"s   "BB"BB
B)r    c                 V   0 n[         R                  " U 5       H  n[        nS nUR                  [         R                  La  UR                  nO0UR
                  [         R                  La  UR
                  nO[        n[        U[        5      (       a
  UnSU l	        O[        SXVS.UR                  D6nUR                  U4X4R                  '   M     [        U 5      n[        U R                   4UU R"                  USS0S.UD6n	Ub  X)l        U	$ U R$                  =(       d    SU	l        U	$ )NT)r   default_factory__resolve_forward_refs__F)r   rJ   __validators____cls_kwargs__rr   r7   )ry   fieldsr   r   MISSINGr   r   r   r   r1   r   metadatatyper   r   r   rI   rJ   rv   )
r~   rd   r}   field_definitionsfieldr   r   
field_info
validatorsmodels
             r:   rU   rU   |  s    
 )+##F+ 8< == 3 33mmG""+*=*==#33OGgy)) J9=F6bwbSXSaSabJ).Z(@**%% ,( 'v.J+ $$!2E:   E #-"8JML ?Enn>RPREMLr=   )rZ      objr   c                 J    [        [        [        U 5      US 5      [        5      $ r6   )r   r   r   r   r   r   s     r:   _is_field_cached_propertyr     s    '$s)Q5GGr=   c                     g)NFr7   r   s     r:   r   r     s    r=   r9   c                 L   [        U S5      (       a  g [        U SS5      (       aX  U R                  R                  5        VVs0 s H0  u  p[        U[        5      (       a  M  [        X5      (       a  M.  X_M2     nnnO@U R                  R                  5        VVs0 s H  u  p[        X5      (       a  M  X_M     nnn[        U R                  X0R                  S9u  pEnU(       a  UeU R                  R                  U5        [        R                  U SS5        g s  snnf s  snnf )Nr.   r1   Fr@   T)r   r   r   r   r   r   r   r/   r   updaterP   r   )r9   r   rD   
input_datad_validation_errors          r:   r   r     s     t/00t:EBB
 ++-
-q), 0I$0R AD- 	 

 (,}}':':'<g'<tqD]^bDfdad'<
g+D,C,CZUcUcdA
MM
t7>
 hs   D!D3DD 4D r   c                 n   U R                   (       a  [        U R                  5      nUR                  US 5        U R                  R
                  R                  US 5      nU(       a:  UR                  X#XR                  S9u  p%U(       a  [        U/U R                  5      e[        R                  XU5        g )N)locr>   )r.   r   r   popr/   
__fields__r   validater   r   rP   r   )r9   r   r   r   known_fielderror_s         r:   r   r     s    $$	dD--88<<T4H'00t0XME%vh??
t5)r=   c           	          [         R                  " U 5      =(       aP    [        U S5      (       + =(       a8    [        U R                  5      R                  [        [        U S0 5      5      5      $ )aw  
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/   rN   )ry   is_dataclassr   rt   r)   
issupersetr   )rk   s    r:   rV   rV     sZ    . 	  & 	a233	a))*55c'$HY[]:^6_`r=   c              #   F   #    [        [        XSS95       Sh  vN   g N7f)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)rd   rf   N)r   rS   )r~   rd   s     r:   rW   rW     s      y$OPPPs   !!r6   )r>   rh   r4   r!   )r9   r$   r4   N)Grv   r   ry   rw   
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#   rh   r$   __all__rX   rx   r   rO   rP   rS   rT   r&   rM   rz   r   r   rU   r   r   r   rV   rW   r7   r=   r:   <module>r     s   B   
 % 	)
 u t t t 1 > H H 6 1 D D 9 ,*F[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   M MM