File: //usr/local/lib/python3.10/dist-packages/pydantic/v1/__pycache__/generics.cpython-310.pyc
o
|��g�E �
@ sX U d dl Z d dlZd dlZd dlmZmZmZmZmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZ d dlmZmZ d dlmZmZ d dlmZ d dlm Z d dl m Z m Z d dl 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 krzd d lm,Z, e j+d
kr�d dlmZ eddd�Z-eZ.e
ee ee
edf f Z/e e.ee f Z0e j+dkr�ee/ee f Z1eee e0f Z2neZ1eZ2e1� Z3e2� Z4G dd� de �Z5dede eef defdd�Z6dee5 de
edf ddfd d �Z7i �8� j9Z:ee e;d < d ede e. fd d!�Z<de
e e= e>f fd"d#�Z?d$ee5 d%e e=ef d&e e=e@f d'e ee@f ddf
d(d)�ZAdS )*� 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 @ s� e Zd ZU dZdZee ed< eree e
df ed< de e de
e e e e e df f de e fd d
�Zede e de e e df defd d ��Zed
edee e fdd��ZdS )r( � F� __concrete__.�__parameters__�cls�params�returnc
s dt dtf� fdd� }t�||��}|dur|S � jr$t� jvr$td��t|t �s,|f}� t
u r=t dd� |D ��r=td ��t � d
�sKtd � j
� d ���t� |� tt� j|��}t|�� |�� �re|re� S � �|�}t� �}t� ��� }d
d� |D �}� fdd�|D �} t� \}
} ttt
t |f|
p�� j � ft � � |�� d|dd�| ���} |t | < | r�d}
|}t j!| j j"}|
| ur�|�#|| �}
|d7 }|
| us�� j$| _$t dd� t%|�� �D ��}| | _|r�|| _| t||�< t&|�dkr�| 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.
�_paramsr0 c s@ t | �}t|�dkrt|d t�rt|d �|d f}� | |fS )N� r � )r �len�
isinstance�list�tuple)r1 �args�r. r+ �?/usr/local/lib/python3.10/dist-packages/pydantic/v1/generics.py�
_cache_keyW s
z2GenericModel.__class_getitem__.<locals>._cache_keyNz?Cannot parameterize a concrete instantiation of a generic modelc s s � | ]}t |t�V qd S �N)r5 r ��.0�paramr+ r+ r: � <genexpr>e � � z1GenericModel.__class_getitem__.<locals>.<genexpr>zDType parameters should be placed on typing.Generic, not GenericModelr- zType z< must inherit from typing.Generic before being parameterizedc S s" i | ]
\}}t |�tur||�qS r+ )r r )r> �k�vr+ r+ r: �
<dictcomp>u s " z2GenericModel.__class_getitem__.<locals>.<dictcomp>c s* i | ]}|� j v r|t� � j | jf�qS r+ )�
__fields__r �
field_info)r> rB r9 r+ r: rD w s * )�
__module__�__base__�
__config__�__validators__�__cls_kwargs__�_c S s i | ]}|d �qS r< r+ r= r+ r+ r: rD � s r3 r )(r �CacheKey�_generic_types_cache�getr, r � __bases__� TypeErrorr5 r7 r( �any�hasattr�__name__�check_parameters_count�dict�zipr- r �keys�values�__concrete_name__r r �items�get_caller_frame_infor r
r rG �__parameterized_bases__�_assigned_parameters�sys�modules�__dict__�
setdefault�Config�iter_contained_typevarsr4 �_prepare_model_fields)r. r/ 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_paramsr+ r9 r: �__class_getitem__K sr
����
�� z GenericModel.__class_getitem__c C s* dd� |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 |��qS r+ )r r= r+ r+ r: �
<listcomp>� s z2GenericModel.__concrete_name__.<locals>.<listcomp>z, �[�])�joinrT )r. r/ � param_names�params_componentr+ r+ r: rZ � s
z GenericModel.__concrete_name__rg c # s� � dt t dtdtt t f� fdd� }� jD ]6}t|t�s qt|dd�s&q� tv rE|tv r/q�fdd �t� �� D �}|||�E dH q||��E dH qdS )
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_typesr0 c 3 sB � t � fdd�| jD ��}| �|�}|| u s|�u r d S |V d S )Nc 3 s � | ]}� | V qd S r< r+ r= �r| r+ r: r@ � s � zQGenericModel.__parameterized_bases__.<locals>.build_base_model.<locals>.<genexpr>)r7 r- rt )r{ r| �base_parameters�parameterized_baser9 r} r: �build_base_model� s �
z>GenericModel.__parameterized_bases__.<locals>.build_base_modelr- Nc s i | ] \}}|� � ||��qS r+ )rO )r> �key�value)rg r+ r: rD � s �z8GenericModel.__parameterized_bases__.<locals>.<dictcomp>) r
r( �Parametrizationr rP �
issubclass�getattrr^ r[ )r. rg r� r{ r| r+ )r. rg r: r] � s, ���
�
��z$GenericModel.__parameterized_bases__N)rT rG � __qualname__� __slots__r, r �bool�__annotations__r r � TypeVarTyper
r' r r rt � classmethod�strrZ r� r r] r+ r+ r+ r: r( @ s
6_( �type_�type_mapr0 c s� � s| S t | �}t| �}|tu r |^}}tt|� �t|�f S |tu s,tjdkr2|tu r2� � | | �S |r{t� fdd�|D ��}t
||�rF| S |durbt | t �rbt |t �sbt
| dd�durbt
t| j�}|dushJ �tjdkrw|tju rwt||�S || S |s�t| t�r�| js�| j}t� fdd�|D ��}t
||�r�| S | | S t | ttf�r�t� fdd�| D ��}t
| |�r�| S |S |s�t| t�r�t| j� �| _| S � � | | �}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 � � | ]}t |� �V qd S r< ��
replace_types)r> �arg�r� r+ r: r@ rA z replace_types.<locals>.<genexpr>N�_namer! c 3 r� r< r� )r> �tr� r+ r: r@ 0 rA c 3 r� r< r� )r> �elementr� r+ r: r@ 8 rA ) r r r r� r7 �
ExtLiteralr_ � version_infor rO r r5 r r� �typingr� �types� UnionTyper$ r r( r, r- r r6 r �
inner_typer� r ) r� r� � type_args� origin_type�annotated_type� annotations�resolved_type_args�
resolved_list�new_typer+ r� r: r� � sT
��
r� r. �
parametersc C sP t |�}t | j�}||kr&||krdnd}td|� d| j� d|� d|� ���d S )N�many�fewzToo z parameters for z ; actual z , expected )r4 r- rQ rT )r. r� �actual�expected� descriptionr+ r+ r: rU M s
"�rU �
DictValuesrC c c s� � t | t�r | V dS t| d�r!t| �s!t| t�r!| jE dH dS t | ttf�r6| D ] }t |�E dH q*dS t
| �}|D ] }t |�E dH q<dS )zdRecursively iterate through all subtypes and type args of `v` and yield any typevars that are found.r- N) r5 r rS r r r( r- r� r6 rd r )rC �varr8 r� r+ r+ r: rd X s �
��rd c
C s^ zt �d�} W n ty } ztd�|�d}~w ty! Y dS w | j}|�d�| j|u fS )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]
r2 z2This function must be used inside another functionN)NFrT )r_ � _getframe�
ValueError� RuntimeError�AttributeError� f_globalsrO �f_locals)�previous_caller_frame�e�
frame_globalsr+ r+ r: r\ g s
� �r\ ro rl rk rg c C sz | j �� D ]5\}}||vr|jjtusJ �q|jjtu s"J |jj��|| }t||�}||_||_|�� || j|< qdS )zP
Replace DeferredType fields with concrete type hints and prepare them.
N) rE r[ r� � __class__r r� � outer_type_�preparer� )ro rl rk rg r� �field�field_type_hint�
concrete_typer+ r+ r: re y s
�re )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� rM r� �GenericTypesCache�AssignedParametersrN r^ r( r� rU rY r� r� r� rd r� r� r\ �typere r+ r+ r+ r: �<module> sZ
D
<"R�
�
�
��