a
    !f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rd 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rTe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Z0ee
eef edddZ1ee0 eedf ddddZ2i 3 j4Z5ee e6d< eee) dddZ7eee8 e9f ddd Z:ee0 e
e8ef e
e8e;f e
ee;f dd!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r6ee	e
df  ed< ee eee e	ee df f ee dddZeee e	ee df edd	d
Zeeeee  dddZdS )r%    F__concrete__.__parameters__)clsparamsreturnc              
      s  t td fdd}t||}|dur.|S  jrFt jvrFtdt|t	sV|f} t
u rxtdd |D rxtdt d	std
 j dt | tt j|}t| | r|rȈ 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 }qr 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r6t|d tr6t|d |d f} | |fS )N   r   r   )r   len
isinstancelisttuple)r.   argsr+   r(   R/var/www/html/python-backend/venv/lib/python3.9/site-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   r=   z2GenericModel.__class_getitem__.<locals>.<dictcomp>c                    s*   i | ]"}| j v r|t  j | jfqS r(   )
__fields__r   Z
field_info)r:   r>   r5   r(   r6   r@   t   r=   )
__module____base__Z
__config__Z__validators__Z__cls_kwargs___c                 S   s   i | ]
}|d qS r8   r(   r9   r(   r(   r6   r@      r=   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   rB   __parameterized_bases___assigned_parameterssysmodules__dict__
setdefaultZConfigiter_contained_typevarsr0   _prepare_model_fields)r+   r,   r7   cachedtypevars_mapZ
model_nameZ
validatorsZ
type_hintsinstance_type_hintsfieldsZmodel_moduleZcalled_globallycreated_modelZobject_by_referenceZreference_nameZreference_module_globals
new_paramsr(   r5   r6   __class_getitem__H   sp    






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>   r=   z2GenericModel.__concrete_name__.<locals>.<listcomp>z, [])joinrL   )r+   r,   Zparam_namesZparams_componentr(   r(   r6   rR      s    
zGenericModel.__concrete_name__)r^   r-   c                 #   s   t t ttt t  d fdd} jD ]r}t|ts:q(q(t|ddsJq(q( tv r|tv r^q(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   s@   t  fdd| jD }| |}|| u s2|u r6d S |V  d S )Nc                 3   s   | ]} | V  qd S r8   r(   r9   ri   r(   r6   r<      r=   zQGenericModel.__parameterized_bases__.<locals>.build_base_model.<locals>.<genexpr>)r3   r*   rc   )rh   ri   Zbase_parametersZparameterized_baser5   rj   r6   build_base_model   s
    
z>GenericModel.__parameterized_bases__.<locals>.build_base_modelr*   Nc                    s   i | ]\}}|  ||qS r(   )rG   )r:   keyvalue)r^   r(   r6   r@      s   z8GenericModel.__parameterized_bases__.<locals>.<dictcomp>)	r   r%   Parametrizationr   rH   
issubclassgetattrrV   rS   )r+   r^   rk   rh   ri   r(   )r+   r^   r6   rU      s     





z$GenericModel.__parameterized_bases__N)rL   rB   __qualname__	__slots__r)   r   bool__annotations__r   r   TypeVarTyper   r$   r   r   rc   classmethodstrrR   rn   r   rU   r(   r(   r(   r6   r%   =   s   
2_$)type_type_mapr-   c                    s   s| S t | }t| }|tu r>|^}}tt| t|f S |rt fdd|D }t||rf| S |durt| trt|tst| dddurtt	| j
}|dusJ tjdkr|tju rt||S || S |st| tr| js| j}t fdd|D }t||r| S | | S t| ttfrXt fdd| D }t| |rT| S |S |s|t| tr|t| 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   s   | ]}t | V  qd S r8   replace_types)r:   argry   r(   r6   r<     r=   z replace_types.<locals>.<genexpr>N_namer    c                 3   s   | ]}t | V  qd S r8   rz   )r:   tr}   r(   r6   r<   +  r=   c                 3   s   | ]}t | V  qd S r8   rz   )r:   elementr}   r(   r6   r<   3  r=   )r   r   r   r{   r3   r   r1   r   rp   typingr~   rW   version_infotypesZ	UnionTyper#   r   r%   r)   r*   r   r2   r   Z
inner_typerG   )rx   ry   Z	type_argsZorigin_typeannotated_typeannotationsZresolved_type_argsZresolved_listr(   r}   r6   r{      sN    
	
r{   )r+   
parametersr-   c              	   C   sP   t |}t | j}||krL||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*   rI   rL   )r+   r   actualexpecteddescriptionr(   r(   r6   rM   C  s
    
rM   
DictValues)r?   r-   c                 c   s   t | tr| V  nrt| dr<t| s<t| tr<| jE dH  nHt | ttfrd| D ]}t	|E dH  qNn t
| }|D ]}t	|E dH  qpdS )zdRecursively iterate through all subtypes and type args of `v` and yield any typevars that are found.r*   N)r1   r   rK   r   r   r%   r*   r   r2   r[   r   )r?   varr4   r|   r(   r(   r6   r[   N  s    
r[   )r-   c               
   C   sj   zt d} W n@ ty< } ztd|W Y d}~nd}~0  tyN   Y dS 0 | 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)NFrL   )rW   	_getframe
ValueErrorRuntimeErrorAttributeError	f_globalsrG   f_locals)Zprevious_caller_frameeZframe_globalsr(   r(   r6   rT   ]  s    rT   )ra   r`   r_   r^   r-   c                 C   sz   | j  D ]j\}}||vr,|jjtus
J q
|jjtu sDJ |jj|| }t||}||_||_|  || j|< q
dS )zP
    Replace DeferredType fields with concrete type hints and prepare them.
    N)	rA   rS   rx   	__class__r   r{   Zouter_type_preparert   )ra   r`   r_   r^   rl   fieldZfield_type_hintZconcrete_typer(   r(   r6   r\   o  s    

r\   )=rW   r   r   r   r   r   r   r   r   r   r	   r
   r   r   r   r   r   weakrefr   r   Ztyping_extensionsr   Zclass_validatorsr   r`   r   mainr   r   r   r   r   r   r   r   utilsr   r   r   r#   r$   ru   rE   rn   ZGenericTypesCacheZAssignedParametersrF   rV   r%   r{   rM   rQ   r   r   rt   r[   rw   rs   rT   typer\   r(   r(   r(   r6   <module>   sJ   
@
 <K


