
    R}bgF                        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.m/Z/  edd          Z0eed         df         Z1 G d d          Z2g dZ3 ed          Z4ej5        dk    r eej6        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j6        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j6        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j6        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j6        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j5        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ZEdS )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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 selfr2   r3   s      j/home/e360mart.nyusoft.in/public_html/e360mart_env/lib/python3.11/site-packages/pydantic/v1/dataclasses.py__init__zDataclass.__init__P   s    D    clsr"   c                     d S r6   r7   r=   s    r:   __get_validators__zDataclass.__get_validators__S       Dr<   r$   vc                     d S 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   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_onlyrY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   r4   DataclassClassOrWrapperc        
             d S r6   r7   rX   s
             r:   rN   rN   h   	     	r<   _clsc       
             d S 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        	             d S r6   r7   rh   s	            r:   rN   rN      s	     	r<   c       	             d S 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           
        
 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    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   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   )rf   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   r}   r|   s    `````` ``` @r:   rN   rN      s    * F##J#$s) # 9 # # # # # # # # # # # # # # #J |4::r<   r=   valuec              #   V   K   | j         }	 || _         | V  || _         d S # || _         w xY wr6   )r,   )r=   r~   original_run_validations      r:   rO   rO      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__ry   r%   r4   Nc                 >    t                               | d|           d S )Nr   )rL   __setattr__)r9   ry   s     r:   r;   zDataclassProxy.__init__   s     4&99999r<   r2   r3   c                 z    t          | j        d          5   | j        |i |cd d d            S # 1 swxY w Y   d S )NT)rO   r   r8   s      r:   __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 r6   )getattrr   )r9   r   s     r:   __getattr__zDataclassProxy.__getattr__  s    t)4000r<   _DataclassProxy__name_DataclassProxy__valuec                 .    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777r<   c                 N    t          t          j        | j                            S r6   )r'   copyr   )r9   s    r:   __copy__zDataclassProxy.__copy__  s    di(:;;<<<r<   memoc                 P    t          t          j        | j        |                    S r6   )r'   r   deepcopyr   )r9   r   s     r:   __deepcopy__zDataclassProxy.__deepcopy__  s    dmD,>EEF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 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<   ry   rx   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
    r9   r%   r2   r3   r4   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 r7   r)   .0krB   r9   s      r:   
<dictcomp>zR_add_pydantic_validation_attributes.<locals>.handle_extra_init.<locals>.<dictcomp>%  ,     c c c$!QAIbDbDbADbDbDbr<   c                 .    i | ]\  }}|j         v ||S r7   r   r   s      r:   r   zR_add_pydantic_validation_attributes.<locals>.handle_extra_init.<locals>.<dictcomp>*  r   r<   )extrar   ignoreitemsallow__dict__
setdefault)r9   r2   r3   r   rB   r_   rY   s   `    r:   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,   r0   hasattrr-   )r9   r2   r3   r_   	post_inits      r:   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-   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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/   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'' /.	-,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 r6   )rE   r?   s    r:   r   r   k  s      

r<   rB   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_namer7   )rO   r   r0   listtupledictr   rF   rD   s     r:   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   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 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<   )rU      objr   c                 d    t          t          t          |           |d           t                    S r6   )r   r   r   r   r   r   s     r:   _is_field_cached_propertyr     s$    '$s))Q55GGGr<   c                     dS )NFr7   r   s     r:   r   r     s    ur<   r9   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.   r1   Fc                 f    i | ]-\  }}t          |t                    t          |          *||.S r7   )r   r   r   r   s      r:   r   z._dataclass_validate_values.<locals>.<dictcomp>  sU     
 
 
1q),,
 1J$PQ0R0R
q
 
 
r<   c                 <    i | ]\  }}t          |          ||S r7   )r   r   s      r:   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   updaterL   r   )r9   
input_datad_validation_errors   `    r:   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   rL   r   )r9   r   r~   r   known_fielderror_s         r:   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/   rJ   )rt   is_dataclassr   ro   r)   
issupersetr   )rf   s    r:   rQ   rQ     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_   ra   N)r   rN   )ry   r_   s     r:   rR   rR     s=       y$OOOPPPPPPPPPPPr<   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      



 % % % % % %      	))))))) 	 	 	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 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 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   # ++