
    bMhE              
       t   U d dl Z d dlZd dl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mZmZmZmZ d dlmZmZ d dlmZmZ d dlmZ d dlmZ d dlmZmZ d dl m!Z! d d	l"m#Z#m$Z$m%Z%m&Z&m'Z' d d
l(m)Z)m*Z* e j+        dk    rd dlm,Z, e j+        dk    rd dlmZ  edd          Z-eZ.eee         eeedf         f         Z/ee.ee         f         Z0e j+        dk    r!ee/ee         f         Z1eee         e0f         Z2neZ1eZ2 e1            Z3 e2            Z4 G d de          Z5dedeeef         defdZ6dee5         deedf         ddfdZ7i 8                                j9        Z:ee         e;d<   dede	e.         fdZ<deee=         e>f         fdZ?d ee5         d!ee=ef         d"ee=e@f         d#eee@f         ddf
d$ZAdS )%    N)TYPE_CHECKINGAnyClassVarDict
ForwardRefGenericIteratorListMappingOptionalTupleTypeTypeVarUnioncast)WeakKeyDictionaryWeakValueDictionary)	AnnotatedLiteral)gather_all_validators)DeferredType)	BaseModelcreate_model)JsonWrapper)display_as_typeget_all_type_hintsget_args
get_origintyping_base)all_identicallenient_issubclass   
   )_UnionGenericAliasr#      )r   GenericModelTGenericModel)bound.)r#   	   c                   @   e Zd ZU dZdZee         ed<   eree	e
df                  ed<   dee         deee         e	ee         df         f         dee         fd	Zedee         de	ee         df         defd
            Zededeee                  fd            ZdS )r)    F__concrete__.__parameters__clsparamsreturnc                     dt           dt          f fd}t                               ||                    }||S  j        rt
           j        vrt          d          t          |t                    s|f} t          u r(t          d |D                       rt          d          t           d          st          d	 j         d
          t           |           t          t!           j        |                    }t%          |                                |                                          r|r S                      |          }t-                     }t/                                                     }d |D             } fd|D             }	t3                      \  }
}t5          t6          t                   t9          |f|
p j         ft                               |                    z   d|dd|	          }|t>          |<   |rCd}|}t@          j!        |j                 j"        }||ur|#                    ||          }|dz  }||u j$        |_$        t          d tK          |                                          D                       }| |_        |r||_        |t           ||          <   tM          |          dk    r|t           ||d                   <   tO          ||	||           |S )a  Instantiates a new class from a generic class `cls` and type variables `params`.

        :param params: Tuple of types the class . Given a generic class
            `Model` with 2 type variables and a concrete model `Model[str, int]`,
            the value `(str, int)` would be passed to `params`.
        :return: New model class inheriting from `cls` with instantiated
            types described by `params`. If no parameters are given, `cls` is
            returned as is.

        _paramsr2   c                     t          |           }t          |          dk    r8t          |d         t                    rt	          |d                   |d         f}| |fS )N   r      )r   len
isinstancelisttuple)r4   argsr0   s     T/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/pydantic/v1/generics.py
_cache_keyz2GenericModel.__class_getitem__.<locals>._cache_keyW   sV    G$$D4yyA~~*T!Wd";";~d1gQ0%%    Nz?Cannot parameterize a concrete instantiation of a generic modelc              3   @   K   | ]}t          |t                    V  d S N)r9   r   .0params     r=   	<genexpr>z1GenericModel.__class_getitem__.<locals>.<genexpr>e   s,      &V&Vez%'A'A&V&V&V&V&V&Vr?   zDType parameters should be placed on typing.Generic, not GenericModelr/   zType z< must inherit from typing.Generic before being parameterizedc                 F    i | ]\  }}t          |          t          u||S r-   )r   r   )rC   kvs      r=   
<dictcomp>z2GenericModel.__class_getitem__.<locals>.<dictcomp>u   s/    \\\1jmmS[>[>[q!>[>[>[r?   c                 d    i | ],}|j         v |t                      j         |         j        f-S r-   )
__fields__r   
field_info)rC   rG   r0   s     r=   rI   z2GenericModel.__class_getitem__.<locals>.<dictcomp>w   s=    xxxdeiliwdwdw!lnncnQ&7&BCdwdwdwr?   )
__module____base__
__config____validators____cls_kwargs___c                     i | ]}|d S rA   r-   rB   s     r=   rI   z2GenericModel.__class_getitem__.<locals>.<dictcomp>   s    UUUUUDUUUr?   r7   r   )(r   CacheKey_generic_types_cachegetr.   r   	__bases__	TypeErrorr9   r;   r)   anyhasattr__name__check_parameters_countdictzipr/   r    keysvalues__concrete_name__r   r   itemsget_caller_frame_infor   r   r   rM   __parameterized_bases___assigned_parameterssysmodules__dict__
setdefaultConfigiter_contained_typevarsr8   _prepare_model_fields)r0   r1   r>   cachedtypevars_map
model_name
validators
type_hintsinstance_type_hintsfieldsmodel_modulecalled_globallycreated_modelobject_by_referencereference_namereference_module_globals
new_paramss   `                r=   __class_getitem__zGenericModel.__class_getitem__K   sq   	& 	& 	& 	& 	& 	& 	& 	& &))**V*<*<==M 	_s} < <]^^^&%(( 	YF,3&V&Vv&V&V&V#V#Vbcccs,-- 	pnCLnnnooosF+++59#c>PRX:Y:Y5Z5Z**,,l.A.A.C.CDD 	 	J **622
*3//
',,2244
\\
\\\xxxxM`xxx(=(?(?%o'93>%(C(CL(Q(Q"R"RR)#   
 
 /;]+ 	&"&'N'*{=3K'L'U$%]::&>&I&I.Zg&h&h##% &]::  #z UU&=l>Q>Q>S>S&T&TUUU
 

 *4^" 	6+5M( 4AZZ//0v;;!:G F1I!6!67 	mV5H,WWWr?   c                 ^    d |D             }d                     |          }| j         d| dS )a  Compute class name for child classes.

        :param params: Tuple of types the class . Given a generic class
            `Model` with 2 type variables and a concrete model `Model[str, int]`,
            the value `(str, int)` would be passed to `params`.
        :return: String representing a the new class where `params` are
            passed to `cls` as type variables.

        This method can be overridden to achieve a custom naming scheme for GenericModels.
        c                 ,    g | ]}t          |          S r-   )r   rB   s     r=   
<listcomp>z2GenericModel.__concrete_name__.<locals>.<listcomp>   s     BBB%u--BBBr?   z, [])joinr[   )r0   r1   param_namesparams_components       r=   ra   zGenericModel.__concrete_name__   sD     CB6BBB99[11,44!14444r?   rn   c              #      K   dt           t                   dt          dt          t           t                            f fd} j        D ]}t          |t                    st          |dd          s* t          v rH|t          v r=fdt                                                    D             } |||          E d{V  { ||          E d{V  dS )a  
        Returns unbound bases of cls parameterised to given type variables

        :param typevars_map: Dictionary of type applications for binding subclasses.
            Given a generic class `Model` with 2 type variables [S, T]
            and a concrete model `Model[str, int]`,
            the value `{S: str, T: int}` would be passed to `typevars_map`.
        :return: an iterator of generic sub classes, parameterised by `typevars_map`
            and other assigned parameters of `cls`

        e.g.:
        ```
        class A(GenericModel, Generic[T]):
            ...

        class B(A[V], Generic[V]):
            ...

        assert A[int] in B.__parameterized_bases__({V: int})
        ```
        
base_modelmapped_typesr2   c              3      K   t          fd| j        D                       }|                     |          }|| u s|u rd S |V  d S )Nc              3   (   K   | ]}|         V  d S rA   r-   )rC   rD   r   s     r=   rE   zQGenericModel.__parameterized_bases__.<locals>.build_base_model.<locals>.<genexpr>   s(      #_#_EL$7#_#_#_#_#_#_r?   )r;   r/   r{   )r   r   base_parametersparameterized_baser0   s    `  r=   build_base_modelz>GenericModel.__parameterized_bases__.<locals>.build_base_model   sp       $#_#_#_#_ZE^#_#_#___O!+!=!=o!N!N!Z//3E3L3L$$$$$$r?   r/   Nc                 D    i | ]\  }}|                     ||          S r-   )rV   )rC   keyvaluern   s      r=   rI   z8GenericModel.__parameterized_bases__.<locals>.<dictcomp>   s<     5 5 5@JU\--eU;;5 5 5r?   )	r   r)   Parametrizationr	   rW   
issubclassgetattrre   rb   )r0   rn   r   r   r   s   ``   r=   rd   z$GenericModel.__parameterized_bases__   sJ     0	%\*	%:I	%d<()	% 	% 	% 	% 	% 	% - 	F 	FJj,77 FZ)94@@ F ,,,!555 
5 5 5 5NbcfNgNmNmNoNo5 5 5L  0/
LIIIIIIIIII ,+JEEEEEEEEEE9	F 	Fr?   N)r[   rM   __qualname__	__slots__r.   r   bool__annotations__r   r   TypeVarTyper   r(   r   r   r{   classmethodstrra   r   r	   rd   r-   r?   r=   r)   r)   @   s9        I#(L(4.((( : !{C'7!89999]tM2 ]E$s)USWX[S\^aSaMbBb<c ]hlmphq ] ] ] ]~ 5tCy 5%S	32G 5C 5 5 5 [5 =F? =FxPTUXPYGZ =F =F =F [=F =F =Fr?   type_type_mapr2   c                    s| S t          |           }t          |           }|t          u r.|^}}t          t          |          t	          |          f         S |t
          u st          j        dk    r|t          u r	                    | |           S |rt	          fd|D                       }t          ||          r| S |Ut          | t                    r@t          |t                    s+t          | dd          t          t          | j                  }|J t          j        dk    r|t           j        u rt%          ||          S ||         S |sXt'          | t(                    rC| j        s<| j        }t	          fd|D                       }t          ||          r| S | |         S t          | t.          t0          f          r/t1          fd| D                       }t          | |          r| S |S |s1t'          | t2                    rt          | j                  | _        | S 	                    | |           }t          |t6                    rt9          |          S |S )a  Return type with all occurrences of `type_map` keys recursively replaced with their values.

    :param type_: Any type, class or generic alias
    :param type_map: Mapping from `TypeVar` instance to concrete types.
    :return: New type representing the basic structure of `type_` with all
        `typevar_map` keys recursively replaced.

    >>> replace_types(Tuple[str, Union[List[str], float]], {str: int})
    Tuple[int, Union[List[int], float]]

    r&   c              3   8   K   | ]}t          |          V  d S rA   replace_types)rC   argr   s     r=   rE   z replace_types.<locals>.<genexpr>  s-      "U"UC=h#?#?"U"U"U"U"U"Ur?   N_namer"   c              3   8   K   | ]}t          |          V  d S rA   r   )rC   tr   s     r=   rE   z replace_types.<locals>.<genexpr>0  s-      "Q"Q!=H#=#="Q"Q"Q"Q"Q"Qr?   c              3   8   K   | ]}t          |          V  d S rA   r   )rC   elementr   s     r=   rE   z replace_types.<locals>.<genexpr>8  s-      SS']7H==SSSSSSr?   )r   r   r   r   r;   
ExtLiteralrf   version_infor   rV   r    r9   r   r   typingr   types	UnionTyper%   r!   r)   r.   r/   r
   r:   r   
inner_typer   r   )	r   r   	type_argsorigin_typeannotated_typeannotationsresolved_type_argsresolved_listnew_types	    `       r=   r   r      s     IU##Ki'0$~x@@%BTBTTUUz!!s'76'A'AkU\F\F\||E5)))  /""U"U"U"U9"U"U"UUU$677 	 L#5+.. ${K88 $ w--9
 "&%+66K&&& w&&;%/+I+I%k3EFFF-..  )-e\BB )5K] )(	""Q"Q"Q"Qy"Q"Q"QQQ$677 	L'(( %$&& SSSSUSSSSS.. 	L  -e[AA ()98DD ||E5))H(C   (###r?   r0   
parametersc           
          t          |          }t          | j                  }||k    r*||k    rdnd}t          d| d| j         d| d|           d S )NmanyfewzToo z parameters for z	; actual z, expected )r8   r/   rX   r[   )r0   r   actualexpecteddescriptions        r=   r\   r\   M  sv    __F3%&&H & 1 1ffup{ppCLppSYppfnppqqq r?   
DictValuesrH   c              #     K   t          | t                    r| V  dS t          | d          r3t          |           s$t	          | t
                    r| j        E d{V  dS t          | t          t          f          r| D ]}t          |          E d{V  dS t          |           }|D ]}t          |          E d{V  dS )zdRecursively iterate through all subtypes and type args of `v` and yield any typevars that are found.r/   N)r9   r   rZ   r   r!   r)   r/   r   r:   rk   r   )rH   varr<   r   s       r=   rk   rk   X  s     !W 
4	$	%	% 4jmm 4@RSTVb@c@c 4##########	A
D)	*	* 4 	4 	4C.s3333333333	4 	4 {{ 	4 	4C.s3333333333	4 	4r?   c                      	 t          j        d          } n.# t          $ r}t          d          |d}~wt          $ r Y dS w xY w| j        }|                    d          | j        |u fS )z
    Used inside a function to check whether it was called globally

    Will only work against non-compiled code, therefore used only in pydantic.generics

    :returns Tuple[module_name, called_globally]
    r6   z2This function must be used inside another functionN)NFr[   )rf   	_getframe
ValueErrorRuntimeErrorAttributeError	f_globalsrV   f_locals)previous_caller_frameeframe_globalss      r=   rc   rc   g  s     #a 0 0 X X XOPPVWW   {{)3MZ((*?*HM*YYYs    
A1AArv   rs   rr   rn   c                 N   | j                                         D ]\  }}||vr|j        j        t          usJ |j        j        t          u sJ |j        j                    ||         }t          ||          }||_        ||_        |                                 || j        |<   dS )zP
    Replace DeferredType fields with concrete type hints and prepare them.
    N)	rK   rb   r   	__class__r   r   outer_type_preparer   )rv   rs   rr   rn   r   fieldfield_type_hintconcrete_types           r=   rl   rl   y  s     $.4466 ; ;
Uf;(<<<<{$444ek6K444-c2%o|DD#)-:%c**; ;r?   )Brf   r   r   r   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   weakrefr   r   typing_extensionsr   r   r   pydantic.v1.class_validatorsr   pydantic.v1.fieldsr   pydantic.v1.mainr   r   pydantic.v1.typesr   pydantic.v1.typingr   r   r   r   r   pydantic.v1.utilsr    r!   r   r%   r(   r   rT   r   GenericTypesCacheAssignedParametersrU   re   r)   r   r\   r`   r   r   r   rk   r   r   rc   typerl   r-   r?   r=   <module>r      s   




                                   " ; : : : : : : : > > > > > > > > > > > > > > + + + + + + 4 4 4 4 4 4 4 4 ) ) ) ) ) ) e e e e e e e e e e e e e e ? ? ? ? ? ? ? ?w))))))v~>>>cCsCx01+tCy01 v+Hd9o,EF*4	?O+KL+* )(**  *)++ xF xF xF xF xF9 xF xF xFvO OS(9 Oc O O O Odr\ 2 rc3h rTX r r r r 		-
DI - - -4s 4x'< 4 4 4 4ZuXc]D%89 Z Z Z Z$;%;CH; !d+; #t)$	;
 
; ; ; ; ; ;r?   