
    ,hE              
          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 jV                  dk\  rd dlm,Z, e jV                  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 jV                  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 jq                         jr                  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$ZAy)%    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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.

        _paramsr2   c                     t        |       }t        |      dk(  r&t        |d   t              rt	        |d         |d   f}| |fS )N   r      )r   len
isinstancelisttuple)r4   argsr0   s     V/var/www/html/Resume-Scraper/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)r9   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___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   itemsr   r   
__fields__r   
field_infoget_caller_frame_infor   r   r   rE   __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kvinstance_type_hintsfieldsmodel_modulecalled_globallycreated_modelobject_by_referencereference_namereference_module_globalsrC   
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   joinrR   )r0   r1   rC   param_namesparams_components        r=   rX   zGenericModel.__concrete_name__   sK     <BB%u-BB99[1,,q!1 2!44 Cs   <rg   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_typesr2   c              3      K   t        fd| j                  D              }| j                  |      }|| u s|u ry | y w)Nc              3   (   K   | ]	  }|     y wrA   r-   )rB   rC   r   s     r=   rD   zQGenericModel.__parameterized_bases__.<locals>.build_base_model.<locals>.<genexpr>   s     #_EL$7#_s   )r;   r/   rv   )r~   r   base_parametersparameterized_baser0   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	   rN   
issubclassgetattrr^   rY   rM   )r0   rg   r   r~   keyvaluer   s   `      r=   r]   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)rR   rE   __qualname__	__slots__r.   r   bool__annotations__r   r   TypeVarTyper   r(   r   r   rv   classmethodstrrX   r   r	   r]   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_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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\  r|t         j"                  u rt%        ||      S ||   S |sOt'        | t(              r?| j*                  s3| j,                  }t	        fd|D              }t        ||      r| S | |   S t        | t.        t0        f      r$t1        fd| D              }t        | |      r| S |S |s-t'        | t2              rt        | j4                        | _        | S j                  | |       }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   6   K   | ]  }t        |        y wrA   replace_types)rB   argr   s     r=   rD   z replace_types.<locals>.<genexpr>  s     "UC=h#?"U   N_namer"   c              3   6   K   | ]  }t        |        y wrA   r   )rB   tr   s     r=   rD   z replace_types.<locals>.<genexpr>0  s     "Q!=H#="Qr   c              3   6   K   | ]  }t        |        y wrA   r   )rB   elementr   s     r=   rD   z replace_types.<locals>.<genexpr>8  s     S']7H=Sr   )r   r   r   r   r;   
ExtLiteralr_   version_infor   rM   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@%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%k3EFF-.. -e\B5K]K]((	""Qy"QQ$67L'(( %$&SUSS.L -e[A()9)98D ||E5)H(C (##r?   r0   
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 )r8   r/   rO   rR   )r0   r   actualexpecteddescriptions        r=   rS   rS   M  sd    _F3%%&H & 1fu${m+;CLL>SYRZZefneopqq r?   
DictValuesrl   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)r9   r   rQ   r   r!   r)   r/   r   r:   rd   r   )rl   varr<   r   s       r=   rd   rd   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]
    r6   z2This function must be used inside another functionN)NFrR   )r_   	_getframe
ValueErrorRuntimeErrorAttributeError	f_globalsrM   f_locals)previous_caller_frameeframe_globalss      r=   r\   r\   g  sr     #a 0
 *33MZ(*?*H*HM*YYY  XOPVWW s   A 	A&AA&%A&rq   rn   rm   rg   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)	rZ   rY   r   	__class__r   r   outer_type_preparer   )rq   rn   rm   rg   r   fieldfield_type_hintconcrete_types           r=   re   re   y  s     $..446 ;
Uf;;((<<{{$$4Kekk6K6KK-c2%o|D#)-:%%c*;r?   )Br_   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   rK   r   GenericTypesCacheAssignedParametersrL   r^   r)   r   rS   rW   r   r   r   rd   r   r   r\   typere   r-   r?   r=   <module>r      s	   
      " ; > > + 4 ) e e ?w)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?   