
    $O=dIF                     p   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	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,m-Z-  edd          Z.eed         df         Z/ G d d          Z0g dZ1 ed          Z2ej3        dk    r eej4        e"f          eddddddddddd
de5de5d e5d!e5d"e5d#e5d$eeee6         df         d%ee5         d&ee5         d'e5d(eee2         gd)f         fd*                        Z7 eej4        e"f          eddddddddddd
d+ee2         de5de5d e5d!e5d"e5d#e5d$eeee6         df         d%ee5         d&ee5         d'e5d(d)fd,                        Z7n eej4        e"f          edddddddddd-	de5de5d e5d!e5d"e5d#e5d$eeee6         df         d%ee5         d&ee5         d(eee2         gd)f         fd.                        Z7 eej4        e"f          edddddddddd-	d+ee2         de5de5d e5d!e5d"e5d#e5d$eeee6         df         d%ee5         d&ee5         d(d)fd/                        Z7 eej4        e"f          	 dDddddddddddd
d+eee2                  de5de5d e5d!e5d"e5d#e5d$eeee6         df         d%ee5         d&ee5         d'e5d(eeee2         gd)f         d)f         fd0            Z7ed1ed         d2e5d(eed         ddf         fd3            Z8 G d4 d          Z9d5ed         d$ee         d%e5d6e:d(df
d7Z;dEd9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=Z>dFd?Z?d>dd@e:d2e
d(dfdAZ@d+ee
         d(e5fdBZAd5ed         d$ee         d(d8fdCZBdS )GaX  
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)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      >D:\Sites\api_v1\venv\Lib\site-packages\pydantic/dataclasses.py__init__zDataclass.__init__I   s    D    clsr!   c                     d S r5   r6   r<   s    r9   __get_validators__zDataclass.__get_validators__L       Dr;   r#   vc                     d S r5   r6   r<   rA   s     r9   __validate__zDataclass.__validate__P   r@   r;   )__name__
__module____qualname__r   r	   strr   __annotations__r   boolr   r    objectr:   classmethodr?   rD   r6   r;   r9   r$   r$   ;   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   a   	     	r;   _clsc       
             d S r5   r6   )re   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   s              r9   rM   rM   r   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_init.  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_init@  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   d  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   h  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   u  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;   r8   c                 V   t          | d          rd S t          | dd          r$d | j                                        D             }n| j        }t          | j        || j                  \  }}}|r|| j                            |           t                              | dd           d S )Nr-   r0   Fc                 D    i | ]\  }}t          |t                    ||S r6   )r   r   )r   r   rA   s      r9   r   z._dataclass_validate_values.<locals>.<dictcomp>  s.    ]]]tq!JqR[D\D\]a]]]r;   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 # ^]t}':':'<'<]]]

]
+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)Crp   r   rs   rq   
contextlibr   	functoolsr   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#   rb   r$   __all__rR   rr   r   rJ   rK   rM   rN   r&   rH   rt   r   r   rO   r   r   rP   rQ   r6   r;   r9   <module>r      sC	     B      



 % % % % % %       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 t 1 1 1 1 1 1 3 3 3 3 3 3 = = = = = = = = = = = = + + + + + + & & & & & & 9 9 9 9 9 9 9 9 9 9 9 9 . . . . . . . . ! ! ! ! ! ! ;;;;;;;;[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? ? ? ?$
* 
*C 
*PS 
*X\ 
* 
* 
* 
*tCy T    :QT+%6 QZ@P QUh Q Q Q Q Q Qr;   