
    4gF                        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/m0Z0  edd      Z1eed   df   Z2 G d d      Z3g dZ4 ed      Z5ejl                  dk\  r eejn                  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jn                  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jn                  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jn                  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jn                  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jl                  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ZFy# e	$ r Y "w xY w)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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 selfr1   r2   s      m/var/www/python.lazyprojects.co.uk/rdoDiscordBot/venv/lib/python3.12/site-packages/pydantic/v1/dataclasses.py__init__zDataclass.__init__P   s        clsr!   c                      y r5   r6   r<   s    r9   __get_validators__zDataclass.__get_validators__S       r;   r#   vc                      y 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   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_onlyrX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   r3   DataclassClassOrWrapperc        
              y r5   r6   rW   s
             r9   rM   rM   h        	r;   _clsc       
              y 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        	              y r5   r6   rg   s	            r9   rM   rM      s     	r;   c       	              y 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           
        
 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    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   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   )re   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   r|   r{   s    `````` ``` @r9   rM   rM      sD    * F#J#$s) # 9 # #J |:r;   r<   valuec              #   b   K   | j                   }	 || _         |  || _         y # || _         w xY wwr5   )r+   )r<   r}   original_run_validations      r9   rN   rN      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__rx   r$   r3   Nc                 2    t         j                  | d|       y )Nr   )rK   __setattr__)r8   rx   s     r9   r:   zDataclassProxy.__init__   s    4&9r;   r1   r2   c                 ~    t        | j                  d      5   | j                  |i |cd d d        S # 1 sw Y   y xY w)NT)rN   r   r7   s      r9   __call__zDataclassProxy.__call__  s3    D..5%4%%t6v6 655s   3<namec                 .    t        | j                  |      S r5   )getattrr   )r8   r   s     r9   __getattr__zDataclassProxy.__getattr__  s    t))400r;   _DataclassProxy__name_DataclassProxy__valuec                 0    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$677r;   c                 R    t        t        j                  | j                              S r5   )r&   copyr   )r8   s    r9   __copy__zDataclassProxy.__copy__  s    dii(:(:;<<r;   memoc                 T    t        t        j                  | j                  |            S r5   )r&   r   deepcopyr   )r8   r   s     r9   __deepcopy__zDataclassProxy.__deepcopy__  s    dmmD,>,>E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1 1 1<# < < <8# 8$ 8=G G)9 Gr;   rx   rw   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
    r8   r$   r1   r2   r3   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 r5   )extrar   ignoreitemsr(   allow__dict__
setdefault)r8   r1   r2   krA   r^   rX   s        r9   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+   r/   hasattrr,   )r8   r1   r2   r^   	post_inits      r9   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,   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4V4~~99113t78
 79#%dnn&I&I&P&P&RSDAq}}(B(BBX:>q'/7	 T .--D0CD 9  * X:@**QVVQYY:W/7Xs   B;;<C:9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'	-,,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r5   )rD   r>   s    r9   r   r   k  s     


s   rA   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_namer6   )rN   r   r/   listtupledictr   rE   rC   s     r9   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   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+ 8< == 3 33mmG""+*=*==#33OGgy) J9=F6bwbSXSaSabJ).Z(@%**%% ,( 'v.J+ $$!2E:   E #-"8JEML ?Enn>RPREMLr;   )rT      objr   c                 J    t        t        t        |       |d       t              S r5   )r   r   r   r   r   r   s     r9   _is_field_cached_propertyr     s    '$s)Q5GGr;   c                      y)NFr6   r   s     r9   r   r     s    r;   r8   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-   r0   Fr>   T)r   r   r   r   r   r   r   r.   r   updaterK   r   )r8   r   rA   
input_datad_validation_errors          r9   r   r     s     t/0t:EB
 ++-
-1q),0I$PQ0R qD- 	 
 (,}}':':'<g'<tq!D]^bdeDfad'<
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   rK   r   )r8   r   r}   r   known_fielderror_s         r9   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.   rI   )rs   is_dataclassr   rn   r(   
issupersetr   )re   s    r9   rP   rP     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^   r`   N)r   rM   )rx   r^   s     r9   rQ   rQ     s      y$OPPPs   %#%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   
 % 	)
 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   L< <MM