o
     dD                  
   @   s:  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 d dlmZmZ d dl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rvd dlm'Z' edddZ(eZ)eee eeedf f Z*e
e)ee f Z+e j&dkree*ee f Z,eee e+f Z-neZ,eZ-e, Z.e- Z/G dd deZ0dede
eef defddZ1dee0 deedf ddfddZ2i 3 j4Z5ee e6d< dedee) fdd Z7deee8 e9f fd!d"Z:d#ee0 d$e
e8ef d%e
e8e;f d&e
ee;f ddf
d'd(Z<dS ))    N)TYPE_CHECKINGAnyClassVarDictGenericIteratorListMappingOptionalTupleTypeTypeVarUnioncast)WeakKeyDictionaryWeakValueDictionary)	Annotated   )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GenericModelTGenericModel)bound.)r!   	   c                   @   s   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	d
Zedee de	ee df defddZededeee  fddZdS )r%    F__concrete__.__parameters__clsparamsreturnc              
      s  dt dtf fdd}t||}|dur|S  jr$t jvr$tdt|t	s,|f} t
u r=tdd |D r=td	t d
sKtd j dt | tt j|}t| | re|re S  |}t }t  }dd |D } fdd|D }	t \}
}ttt
 t|f|
p j ft	 | d|dd|	}|t|< |rd}|}t j!|j j"}||ur|#||}|d7 }||us j$|_$t	dd t%| D }| |_|r||_|t||< t&|dkr|t||d < t'||	|| |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.

        _paramsr-   c                    s@   t | }t|dkrt|d trt|d |d f} | |fS )N   r   r   )r   len
isinstancelisttuple)r.   argsr+   r(   </usr/local/lib/python3.10/dist-packages/pydantic/generics.py
_cache_keyT   s   
z2GenericModel.__class_getitem__.<locals>._cache_keyNz?Cannot parameterize a concrete instantiation of a generic modelc                 s   s    | ]}t |tV  qd S N)r1   r   .0paramr(   r(   r6   	<genexpr>b       z1GenericModel.__class_getitem__.<locals>.<genexpr>zDType parameters should be placed on typing.Generic, not GenericModelr*   zType z< must inherit from typing.Generic before being parameterizedc                 S   s"   i | ]\}}t |tur||qS r(   )r   r   )r:   kvr(   r(   r6   
<dictcomp>r   s   " z2GenericModel.__class_getitem__.<locals>.<dictcomp>c                    s*   i | ]}| j v r|t  j | jfqS r(   )
__fields__r   
field_info)r:   r>   r5   r(   r6   r@   t   s   * )
__module____base__
__config____validators____cls_kwargs___c                 S   s   i | ]}|d qS r8   r(   r9   r(   r(   r6   r@      s    r   r   )(r   CacheKey_generic_types_cachegetr)   r   	__bases__	TypeErrorr1   r3   r%   anyhasattr__name__check_parameters_countdictzipr*   r   keysvalues__concrete_name__r   r   itemsget_caller_frame_infor   r   r   rC   __parameterized_bases___assigned_parameterssysmodules__dict__
setdefaultConfigiter_contained_typevarsr0   _prepare_model_fields)r+   r,   r7   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_paramsr(   r5   r6   __class_getitem__H   sr   




zGenericModel.__class_getitem__c                 C   s*   d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                 S   s   g | ]}t |qS r(   )r   r9   r(   r(   r6   
<listcomp>   s    z2GenericModel.__concrete_name__.<locals>.<listcomp>z, [])joinrP   )r+   r,   param_namesparams_componentr(   r(   r6   rV      s   
zGenericModel.__concrete_name__rc   c                 #   s    dt t dtdtt t  f fdd} jD ]6}t|tsqt|dds&q tv rE|tv r/qfdd	t   D }|||E dH  q||E dH  q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_typesr-   c                 3   sB    t  fdd| jD }| |}|| u s|u rd S |V  d S )Nc                 3   s    | ]} | V  qd S r8   r(   r9   rx   r(   r6   r<      s    zQGenericModel.__parameterized_bases__.<locals>.build_base_model.<locals>.<genexpr>)r3   r*   rp   )rw   rx   base_parametersparameterized_baser5   ry   r6   build_base_model   s   

z>GenericModel.__parameterized_bases__.<locals>.build_base_modelr*   Nc                    s   i | ]\}}|  ||qS r(   )rK   )r:   keyvalue)rc   r(   r6   r@      s    z8GenericModel.__parameterized_bases__.<locals>.<dictcomp>)	r   r%   Parametrizationr   rL   
issubclassgetattrrZ   rW   )r+   rc   r|   rw   rx   r(   )r+   rc   r6   rY      s,   





z$GenericModel.__parameterized_bases__N)rP   rC   __qualname__	__slots__r)   r   bool__annotations__r   r   TypeVarTyper   r$   r   r   rp   classmethodstrrV   r   r   rY   r(   r(   r(   r6   r%   =   s   
 6_( type_type_mapr-   c                    sx   s| S t | }t| }|tu r|^}}tt| t|f S |rht fdd|D }t||r3| S |durOt| trOt|tsOt| dddurOtt	| j
}|dusUJ tjdkrd|tju rdt||S || S |st| tr| js| j}t fdd|D }t||r| S | | S t| ttfrt fdd| D }t| |r| S |S |st| trt| j | _| 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]]

    c                 3       | ]}t | V  qd S r8   replace_types)r:   argr   r(   r6   r<     r=   z replace_types.<locals>.<genexpr>N_namer    c                 3   r   r8   r   )r:   tr   r(   r6   r<   +  r=   c                 3   r   r8   r   )r:   elementr   r(   r6   r<   3  r=   )r   r   r   r   r3   r   r1   r   r   typingr   r[   version_infotypes	UnionTyper#   r   r%   r)   r*   r   r2   r   
inner_typerK   )r   r   	type_argsorigin_typeannotated_typeannotationsresolved_type_argsresolved_listr(   r   r6   r      sN   
	


r   r+   
parametersc              	   C   sP   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 )r0   r*   rM   rP   )r+   r   actualexpecteddescriptionr(   r(   r6   rQ   C  s   
"rQ   
DictValuesr?   c                 c   s    t | tr| V  dS t| dr!t| s!t| tr!| jE dH  dS t | ttfr6| D ]	}t	|E dH  q*dS t
| }|D ]	}t	|E dH  q<dS )zdRecursively iterate through all subtypes and type args of `v` and yield any typevars that are found.r*   N)r1   r   rO   r   r   r%   r*   r   r2   r`   r   )r?   varr4   r   r(   r(   r6   r`   N  s   

r`   c               
   C   s^   zt d} W n ty } ztd|d}~w ty!   Y dS 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]
    r/   z2This function must be used inside another functionN)NFrP   )r[   	_getframe
ValueErrorRuntimeErrorAttributeError	f_globalsrK   f_locals)previous_caller_frameeframe_globalsr(   r(   r6   rX   ]  s   
rX   rk   rh   rg   rc   c                 C   sz   | j  D ]5\}}||vr|jjtusJ q|jjtu s"J |jj|| }t||}||_||_|  || j|< qdS )zP
    Replace DeferredType fields with concrete type hints and prepare them.
    N)	rA   rW   r   	__class__r   r   outer_type_preparer   )rk   rh   rg   rc   r}   fieldfield_type_hintconcrete_typer(   r(   r6   ra   o  s   

ra   )=r[   r   r   r   r   r   r   r   r   r   r	   r
   r   r   r   r   r   weakrefr   r   typing_extensionsr   class_validatorsr   rh   r   mainr   r   r   r   r   r   r   r   utilsr   r   r   r#   r$   r   rI   r   GenericTypesCacheAssignedParametersrJ   rZ   r%   r   rQ   rU   r   r   r   r`   r   r   rX   typera   r(   r(   r(   r6   <module>   sV   
 @

 <"K


