
    KiE              
          U d dl Z d dlZ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jZ                  dk\  rd dlmZ  edd      Z.eZ/eee   eeedf   f   Z0ee/ee   f   Z1ejZ                  dk\  ree0ee    f   Z2eee    e1f   Z3neZ2eZ3 e2       Z4 e3       Z5 G d de       Z6dedeeef   defdZ7dee6   deedf   ddfdZ8i js                         jt                  Z;ee   e<d<   dedee/   fdZ=deee>   e?f   fdZ@dee6   dee>ef   d ee>eAf   d!eeeAf   ddf
d"ZBy)#    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      )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y)r&    F__concrete__.__parameters__clsparamsreturnc                     dt         dt        f fd}t        j                   ||            }||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%        |j'                         |j)                               r|r S  j+                  |      }t-               }t/               j1                         }|D 	ci c]  \  }}	t3        |	      t4        us||	 }
}}	|
D ci c]5  }| j6                  v s|t9                j6                  |   j:                  f7 }}t=               \  }}t?        t@        t           tC        |f|xs  jD                   ft         jG                  |            z   d|dd|      }|tH        |<   |rKd}|}tJ        jL                  |jD                     jN                  }||ur|jQ                  ||      }|dz  }||ur jR                  |_)        t        tU        |j)                               D ci c]  }|d c}      }| |_        |r||_        |t         ||      <   tW        |      dk(  r|t         ||d         <   tY        |||
|       |S c c}	}w c c}w c c}w )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.

        _paramsr/   c                     t        |       }t        |      dk(  r&t        |d   t              rt	        |d         |d   f}| |fS )N   r      )r   len
isinstancelisttuple)r1   argsr-   s     `/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/pydantic/v1/generics.py
_cache_keyz2GenericModel.__class_getitem__.<locals>._cache_keyW   sH    G$D4yA~*T!Wd";d1gQ0%%    Nz?Cannot parameterize a concrete instantiation of a generic modelc              3   <   K   | ]  }t        |t                y wN)r6   r   ).0params     r:   	<genexpr>z1GenericModel.__class_getitem__.<locals>.<genexpr>e   s     &Vez%'A&Vs   zDType parameters should be placed on typing.Generic, not GenericModelr,   zType z< must inherit from typing.Generic before being parameterized)
__module____base__
__config____validators____cls_kwargs___r4   r   )-r   CacheKey_generic_types_cachegetr+   r   	__bases__	TypeErrorr6   r8   r&   anyhasattr__name__check_parameters_countdictzipr,   r    keysvalues__concrete_name__r   r   itemsr   r   
__fields__r   
field_infoget_caller_frame_infor   r   r   rB   __parameterized_bases___assigned_parameterssysmodules__dict__
setdefaultConfigiter_contained_typevarsr5   _prepare_model_fields)r-   r.   r;   cachedtypevars_map
model_name
validators
type_hintskvinstance_type_hintsfieldsmodel_modulecalled_globallycreated_modelobject_by_referencereference_namereference_module_globalsr@   
new_paramss   `                   r:   __class_getitem__zGenericModel.__class_getitem__K   s   	& 	& 	& &))*V*<=Ms}} <]^^&%(YF,3&Vv&V#Vbccs,-eCLL>1mnoosF+59#c>P>PRX:Y5Z**,l.A.A.CDJ **62
*3/
',224
0:\1jmS[>[q!t\\M`xdeiliwiwdw!lncnnQ&7&B&BCCxx(=(?%o'93>>%(C(CL(Q"RR)# 
 /;]+"&'N'*{{=3K3K'L'U'U$%]:&>&I&I.Zg&h##% &]:  #zz &=l>Q>Q>S&TUUUD[U

 *4^"+5M( 4AZ/0v;!:G F1I!67 	mV5H,Wg ]xB Vs   
K2$K20K8&K8
K=c                     |D cg c]  }t        |       }}dj                  |      }| j                   d| dS c c}w )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.
        z, [])r   joinrO   )r-   r.   r@   param_namesparams_components        r:   rU   zGenericModel.__concrete_name__   sK     <BB%u-BB99[1,,q!1 2!44 Cs   <rd   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 rU|t        v r3t            j                         D ci c]  \  }}||j                  ||       }}} |||      E d{     |||      E d{     yc c}}w 7 7 w)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_typesr/   c              3      K   t        fd| j                  D              }| j                  |      }|| u s|u ry | y w)Nc              3   (   K   | ]	  }|     y wr>   r*   )r?   r@   r|   s     r:   rA   zQGenericModel.__parameterized_bases__.<locals>.build_base_model.<locals>.<genexpr>   s     #_EL$7#_s   )r8   r,   rs   )r{   r|   base_parametersparameterized_baser-   s    `  r:   build_base_modelz>GenericModel.__parameterized_bases__.<locals>.build_base_model   sI      $#_ZE^E^#__O!+!=!=o!N!Z/3E3L$$s   >Ar,   N)
r   r&   Parametrizationr	   rK   
issubclassgetattrr[   rV   rJ   )r-   rd   r   r{   keyvaluer|   s   `      r:   rZ   z$GenericModel.__parameterized_bases__   s     0	%\*	%:I	%d<()	% -- 	FJj,7Z)94@ ,,!55  OccfNgNmNmNo5@JU\--eU;;5L 5  0
LIII ,JEEE9	F*5 J Fs0   BC
C'C6C7CC	CCN)rO   rB   __qualname__	__slots__r+   r   bool__annotations__r   r   TypeVarTyper   r%   r   r   rs   classmethodstrrU   r   r	   rZ   r*   r<   r:   r&   r&   @   s    I#(L(4.( !{C'7!899]tM2 ]E$s)USWX[S\^aSaMbBb<c ]hlmphq ]~ 5tCy 5%S	32G 5C 5 5 =F? =FxPTUXPYGZ =F =Fr<   type_type_mapr/   c                 F   s| S t        |       }t        |       }|t        u r"|^}}t        t        |      t	        |      f   S |t
        u st        j                  dk\  r|t        u rj                  | |       S |rt	        fd|D              }t        ||      r| S |Gt        | t              r7t        |t              s't        | dd      t        t        | j                        }|J t        j                  dk\  r6|t         j"                  u r$t%        j&                  t(        j*                  |      S ||   S |sOt-        | t.              r?| j0                  s3| j2                  }t	        fd|D              }t        ||      r| S | |   S t        | t4        t6        f      r$t7        fd| D              }t        | |      r| S |S |s-t-        | t8              rt        | j:                        | _        | S j                  | |       }t        |t<              rt?        |      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   6   K   | ]  }t        |        y wr>   replace_types)r?   argr   s     r:   rA   z replace_types.<locals>.<genexpr>  s     "UC=h#?"U   N_name)r#   
   c              3   6   K   | ]  }t        |        y wr>   r   )r?   tr   s     r:   rA   z replace_types.<locals>.<genexpr>0  s     "Q!=H#="Qr   c              3   6   K   | ]  }t        |        y wr>   r   )r?   elementr   s     r:   rA   z replace_types.<locals>.<genexpr>8  s     S']7H=Sr   ) r   r   r   r   r8   
ExtLiteralr\   version_infor   rJ   r    r6   r   r   typingr   types	UnionType	functoolsreduceoperatoror_r!   r&   r+   r,   r
   r7   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@%BTTUUz!s'7'76'AkU\F\||E5)) ""U9"UU$67 L#5+.{K8w-9
 "&%++6K&&& w&;%//+I##HLL2DEE-.. -e\B5K]K]((	""Qy"QQ$67L'(( %$&SUSS.L -e[A()9)98D ||E5)H(C (##r<   r-   
parametersc           
          t        |      }t        | j                        }||k7  r*||kD  rdnd}t        d| d| j                   d| d|       y )NmanyfewzToo z parameters for z	; actual z, expected )r5   r,   rL   rO   )r-   r   actualexpecteddescriptions        r:   rP   rP   M  sd    _F3%%&H & 1fu${m+;CLL>SYRZZefneopqq r<   
DictValuesri   c              #   f  K   t        | t              r|  yt        | d      r0t        |       s%t	        | t
              r| j                  E d{    yt        | t        t        f      r| D ]  }t        |      E d{     yt        |       }|D ]  }t        |      E d{     y7 \7 /7 w)zdRecursively iterate through all subtypes and type args of `v` and yield any typevars that are found.r,   N)r6   r   rN   r   r!   r&   r,   r   r7   ra   r   )ri   varr9   r   s       r:   ra   ra   X  s     !W	$	%jm@RSTVb@c####	A
D)	* 	4C.s333	4 { 	4C.s333	4 	$ 4 4s6   AB1B+.B1=B->%B1#B/$B1-B1/B1c                      	 t        j                  d      } | j
                  }|j                  d      | j                  |u fS # t        $ r}t        d      |d}~wt        $ r Y yw xY w)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]
    r3   z2This function must be used inside another functionN)NFrO   )r\   	_getframe
ValueErrorRuntimeErrorAttributeError	f_globalsrJ   f_locals)previous_caller_frameeframe_globalss      r:   rY   rY   g  sr     #a 0
 *33MZ(*?*H*HM*YYY  XOPVWW s   A 	A&AA&%A&rn   rk   rj   rd   c                 x   | j                   j                         D ]  \  }}||vr|j                  j                  t        usJ )|j                  j                  t        u sJ |j                  j                         ||   }t        ||      }||_        ||_        |j                          || j                  |<    y)zP
    Replace DeferredType fields with concrete type hints and prepare them.
    N)	rW   rV   r   	__class__r   r   outer_type_preparer   )rn   rk   rj   rd   r   fieldfield_type_hintconcrete_types           r:   rb   rb   y  s     $..446 ;
Uf;;((<<<{{$$4Kekk6K6KK4-c2%o|D#)-:%%c*;r<   )Cr   r   r\   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   rH   r   GenericTypesCacheAssignedParametersrI   r[   r&   r   rP   rT   r   r   r   ra   r   r   rY   typerb   r*   r<   r:   <module>r      s     
      " ; > > + 4 ) e e ?v~>cCsCx01+tCy01 v+Hd9o,EF*4	?O+KL+* )*  *+ xF9 xFvO OS(9 Oc Odr\ 2 rc3h rTX r 		--
DI -4s 4x'< 4ZuXc]D%89 Z$;%;CH; !d+; #t)$	;
 
;r<   