관리-도구
편집 파일: _generics.cpython-38.pyc
U /?�f�V � @ s& U d dl mZ d dlZd dlZd dlZd dlmZ d dlmZ d dl m Z d dlm Z d dlm Z m Z mZmZmZmZmZmZ d dlmZ d dlZd d lmZ d d lmZ d d lm Z m Z d d l m Z m Z ej!dkr�d dlm"Z" e r�ddl#m$Z$ ee e ee df f Z%ed�Z&ed�Z'dZ(e �r<G dd� de)ee&e'f �Z*nG dd� de)�Z*ej!dk�rfee%df Z+neZ+e �r�G dd � d ee&e'f �Z,nG d d � d e�Z,e+� Z-G d d � d ej.�Z/d dd!d!dd"�d#d$�Z0dgd%d&d'�d(d)�Z1i �2� j3Z4d*e5d+< d,d-d.�d/d0�Z6d,d,d.�d1d2�Z7d,d,d.�d3d4�Z8d*d5d6�d7d8�Z9dd5d6�d9d:�Z:d,d;d,d<�d=d>�Z;d,d,d?d@�dAdB�Z<dd!dCdD�dEdF�Z=e dGddH�Z>dIe5dG< edd!dJdK�dLdM��Z?dNdO�dPdQ�Z@dd,dRdS�dTdU�ZAdd,dd!dRdV�dWdX�ZBdhdd!ddRdYdCdZ�d[d\�ZCd,d,d]�d^d_�ZDdd,d`da�dbdc�ZEdd!d,d`dd�dedf�ZFdS )i� )� annotationsN)�ChainMap)�contextmanager)� ContextVar)� prepare_class)� TYPE_CHECKING�Any�Iterator�List�Mapping�MutableMapping�Tuple�TypeVar)�WeakValueDictionary� )� get_type_ref)�PydanticRecursiveRef)� TypeVarType� typing_base)� all_identical�is_model_class�� � )�_UnionGenericAlias� )� BaseModel.�KT�VT�d c @ s e Zd Zefdd�dd�ZdS )� LimitedDict�int�� size_limitc C s d S �N� ��selfr# r% r% �J/opt/hc_python/lib/python3.8/site-packages/pydantic/_internal/_generics.py�__init__( � �LimitedDict.__init__N)�__name__� __module__� __qualname__�_LIMITED_DICT_SIZEr) r% r% r% r( r ' s r c s@ e Zd ZdZefdd�� fdd� Zdddd�� fd d � Z� ZS ) r z�Limit the size/length of a dict used for caching to avoid unlimited increase in memory usage. Since the dict is ordered, and we always remove elements from the beginning, this is effectively a FIFO cache. r! r" c s || _ t� �� d S r$ )r# �superr) r& �� __class__r% r( r) 2 s r+ r �None��key�value�returnc s\ t � �||� t| �| jkrXt| �| j | jd }t| �� �d |� }|D ] }| |= qLd S )Nr )r0 � __setitem__�lenr# �list�keys)r' r5 r6 �excessZ to_remove�kr1 r% r( r8 6 s zLimitedDict.__setitem__)r, r- r. �__doc__r/ r) r8 � __classcell__r% r% r1 r( r , s )r � ztype[BaseModel]c @ s e Zd ZdS )� DeepChainMapN)r, r- r. r% r% r% r( rA H s rA c @ s@ e Zd ZdZdd�dd�Zdddd�d d �Zddd �d d �ZdS )rA z�Variant of ChainMap that allows direct updates to inner scopes. Taken from https://docs.python.org/3/library/collections.html#collections.ChainMap, with some light modifications for this use case. r3 �r7 c C s | j D ] }|�� qd S r$ )�maps�clear)r' �mappingr% r% r( rD T s zDeepChainMap.clearr r r4 c C s | j D ] }|||< qd S r$ )rC )r' r5 r6 rE r% r% r( r8 X s zDeepChainMap.__setitem__)r5 r7 c C s2 d}| j D ]}||kr ||= d}q |s.t|��d S )NFT)rC �KeyError)r' r5 �hitrE r% r% r( � __delitem__\ s zDeepChainMap.__delitem__N)r, r- r. r> rD r8 rH r% r% r% r( rA M s c @ s& e Zd ZU ded< ded< ded< dS )�PydanticGenericMetadata�type[BaseModel] | None�origin�tuple[Any, ...]�argsztuple[type[Any], ...]� parametersN)r, r- r. �__annotations__r% r% r% r( rI m s rI �strrL )� model_namerK rM �paramsr7 c C s� d|j i}|f}t| |�\}}}|�|� || ||f|||d�dd�|��} tdd�\} } | r�d} | } tj| j j}| | k r�|�| | �} | d7 } qt| S ) aN Dynamically create a submodel of a provided (generic) BaseModel. This is used when producing concrete parametrizations of generic models. This function only *creates* the new subclass; the schema/validators/serialization must be updated to reflect a concrete parametrization elsewhere. Args: model_name: The name of the newly created model. origin: The base class for the new model to inherit from. args: A tuple of generic metadata arguments. params: A tuple of generic metadata parameters. Returns: The created submodel. r- )rK rM rN F)� __pydantic_generic_metadata__Z#__pydantic_reset_parent_namespace__r )�depthN�_)r- r �update�_get_caller_frame_info�sys�modules�__dict__� setdefault)rQ rK rM rR � namespace�bases�meta�ns�kwdsZ created_modelZ model_moduleZcalled_globallyZobject_by_referenceZreference_nameZreference_module_globalsr% r% r( �create_generic_submodels s4 ��� � ra r! ztuple[str | None, bool])rT r7 c C sj zt �| �}W n@ tk r: } ztd�|�W 5 d}~X Y n tk rN Y dS X |j}|�d�|j|kfS )a Used inside a function to check whether it was called globally. Args: depth: The depth to get the frame. Returns: A tuple contains `module_name` and `called_globally`. Raises: RuntimeError: If the function is not called inside a function. z2This function must be used inside another functionN)NFr, )rX � _getframe� ValueError� RuntimeError�AttributeError� f_globals�get�f_locals)rT Zprevious_caller_frame�eZ frame_globalsr% r% r( rW � s rW z type[Any]� DictValuesr zIterator[TypeVarType])�vr7 c c sx t | t�r| V nbt| �r,| jd E dH nHt | ttf�rT| D ]}t|�E dH q>n t| �}|D ]}t|�E dH q`dS )a7 Recursively iterate through all subtypes and type args of `v` and yield any typevars that are found. This is inspired as an alternative to directly accessing the `__parameters__` attribute of a GenericAlias, since __parameters__ of (nested) generic BaseModel subclasses won't show up in that list. rN N)� isinstancer r rS rj r: �iter_contained_typevars�get_args)rk �varrM �argr% r% r( rm � s rm c C s$ t | dd �}|r|�d�S t�| �S )NrS rM )�getattrrg �typing_extensionsrn �rk Zpydantic_generic_metadatar% r% r( rn � s rn c C s$ t | dd �}|r|�d�S t�| �S )NrS rK )rq rg rr � get_originrs r% r% r( rt � s rt z dict[TypeVarType, Any] | None)�clsr7 c C s< t | �}|dkrdS t|d�s"dS | j}|j}tt||��S )z�Package a generic type's typevars and parametrization (if present) into a dictionary compatible with the `replace_types` function. Specifically, this works with standard typing generics and typing._GenericAlias. N�__parameters__)rt �hasattr�__args__rv �dict�zip)ru rK rM rN r% r% r( �get_standard_typevars_map� s r{ c C s( | j }|d }|d }ttt|�|��S )ae Package a generic BaseModel's typevars and concrete parametrization (if present) into a dictionary compatible with the `replace_types` function. Since BaseModel.__class_getitem__ does not produce a typing._GenericAlias, and the BaseModel generic info is stored in the __pydantic_generic_metadata__ attribute, we need special handling here. rK rM )rS ry rz rm )ru Zgeneric_metadatarK rM r% r% r( �get_model_typevars_map� s r| zMapping[Any, Any] | None)�type_�type_mapr7 c s� � s| S t | �}t| �}|tjkrP|^}}t|� �}|D ]}tj||f }q8|S |r�t� fdd�|D ��}t||�rx| S |dk r�t| t�r�t|t�s�t | dd�dk r�t t | j �}|dk s�t �t jdkr�|tjkr�t||�S |t|�dkr�|d n| S |�sHt| ��rH| jd } | �s| S t� fd d�| D ��}t| |��r@| S | | S t| ttf��r�t� fd d�| D ��} t| | ��r~| S | S � �| | �S ) ao Return type with all occurrences of `type_map` keys recursively replaced with their values. Args: type_: The class or generic alias. type_map: Mapping from `TypeVar` instance to concrete types. Returns: A new type representing the basic structure of `type_` with all `typevar_map` keys recursively replaced. Example: ```py from typing import List, Tuple, Union from pydantic._internal._generics import replace_types replace_types(Tuple[str, Union[List[str], float]], {str: int}) #> Tuple[int, Union[List[int], float]] ``` c 3 s | ]}t |� �V qd S r$ �� replace_types)�.0rp �r~ r% r( � <genexpr>! s z replace_types.<locals>.<genexpr>N�_namer r r rN c 3 s | ]}t |� �V qd S r$ r )r� �tr� r% r( r� ? s c 3 s | ]}t |� �V qd S r$ r �r� �elementr� r% r( r� G s )rn rt rr � Annotatedr� �tupler rl r rq �typingr� �AssertionErrorrX � version_info�types� UnionTyper r9 r rS r r: rg ) r} r~ � type_args� origin_type�annotated_typer Z annotated� annotationZresolved_type_argsrN Z resolved_listr% r� r( r� � sR ���� r� �bool)r} �isinstance_targetr7 c s� t | � �rdS t| �}t| �}|tjkr:|^}}t|� �S t� fdd�|D ��rTdS t | ttf�r�t | tj �s�t� fdd�| D ��r�dS dS )zrChecks if the type, or any of its arbitrary nested args, satisfy `isinstance(<type>, isinstance_target)`. Tc 3 s | ]}t |� �V qd S r$ ��has_instance_in_type)r� �a�r� r% r( r� a s z'has_instance_in_type.<locals>.<genexpr>c 3 s | ]}t |� �V qd S r$ r� r� r� r% r( r� g s F) rl rn rt rr r� r� �anyr r: � ParamSpec)r} r� r� r� r� r r% r� r( r� Q s r� r3 )ru rN r7 c C sR t |�}t | jd �}||krN||kr*dnd}td|� d| � d|� d|� ���dS ) a Check the generic model parameters count is equal. Args: cls: The generic model. parameters: A tuple of passed parameters to the generic model. Raises: TypeError: If the passed parameters count is not equal to generic model parameters count. rN �many�fewzToo z parameters for z ; actual z , expected N)r9 rS � TypeError)ru rN �actual�expected� descriptionr% r% r( �check_parameters_countm s r� �_generic_recursion_cache)�defaultzContextVar[set[str] | None]z%Iterator[PydanticRecursiveRef | None])rK rM r7 c c sv t �� }|dkr"t� }t �|�}nd}z:t| |d�}||krNt|d�}|V n|�|� dV W 5 |rpt �|� X dS )a� This contextmanager should be placed around the recursive calls used to build a generic type, and accept as arguments the generic origin type and the type arguments being passed to it. If the same origin and arguments are observed twice, it implies that a self-reference placeholder can be used while building the core schema, and will produce a schema_ref that will be valid in the final parent schema. N)Z args_override)�type_ref)r� rg �set�resetr r �add)rK rM Zpreviously_seen_type_refs�tokenr� Z self_typer% r% r( �generic_recursion_self_type� s r� zset[str]rB c C s t �� } | st� S | �� S r$ )r� rg r� �copy)�visitedr% r% r( � recursively_defined_type_refs� s r� rJ )�parent�typevar_valuesr7 c C s t �t| |��S )a The use of a two-stage cache lookup approach was necessary to have the highest performance possible for repeated calls to `__class_getitem__` on generic types (which may happen in tighter loops during runtime), while still ensuring that certain alternative parametrizations ultimately resolve to the same type. As a concrete example, this approach was necessary to make Model[List[T]][int] equal to Model[List[int]]. The approach could be modified to not use two different cache keys at different points, but the _early_cache_key is optimized to be as quick to compute as possible (for repeated-access speed), and the _late_cache_key is optimized to be as "correct" as possible, so that two types that will ultimately be the same after resolving the type arguments will always produce cache hits. If we wanted to move to only using a single cache key per type, we would either need to always use the slower/more computationally intensive logic associated with _late_cache_key, or would need to accept that Model[List[T]][int] is a different type than Model[List[T]][int]. Because we rely on subclass relationships during validation, I think it is worthwhile to ensure that types that are functionally equivalent are actually equal. )�_GENERIC_TYPES_CACHErg �_early_cache_key)r� r� r% r% r( � get_cached_generic_type_early� s r� )r� r� rK rM r7 c C s. t �t|||��}|dk r*t| ||||� |S )zkSee the docstring of `get_cached_generic_type_early` for more information about the two-stage cache lookup.N)r� rg �_late_cache_key�set_cached_generic_type)r� r� rK rM �cachedr% r% r( � get_cached_generic_type_late� s r� ztuple[Any, ...] | None)r� r� r} rK rM r7 c C sH |t t| |�< t|�dkr,|t t| |d �< |rD|rD|t t|||�< dS )z�See the docstring of `get_cached_generic_type_early` for more information about why items are cached with two different keys. r r N)r� r� r9 r� )r� r� r} rK rM r% r% r( r� � s r� )r� r7 c C sN t | t�r.g }| D ]}|�t|�� qt|�S t�| �tjkrFt| �S dS dS )a� This is intended to help differentiate between Union types with the same arguments in different order. Thanks to caching internal to the `typing` module, it is not possible to distinguish between List[Union[int, float]] and List[Union[float, int]] (and similarly for other "parent" origins besides List) because `typing` considers Union[int, float] to be equal to Union[float, int]. However, you _can_ distinguish between (top-level) Union[int, float] vs. Union[float, int]. Because we parse items as the first Union type that is successful, we get slightly more consistent behavior if we make an effort to distinguish the ordering of items in a union. It would be best if we could _always_ get the exact-correct order of items in the union, but that would require a change to the `typing` module itself. (See https://github.com/python/cpython/issues/86483 for reference.) r% N) rl r� �append�_union_orderings_keyrr rt r� �Unionrn )r� Z args_datar6 r% r% r( r� � s r� �GenericTypesCacheKey)ru r� r7 c C s | |t |�fS )a This is intended for minimal computational overhead during lookups of cached types. Note that this is overly simplistic, and it's possible that two different cls/typevar_values inputs would ultimately result in the same type being created in BaseModel.__class_getitem__. To handle this, we have a fallback _late_cache_key that is checked later if the _early_cache_key lookup fails, and should result in a cache hit _precisely_ when the inputs to __class_getitem__ would result in the same type. �r� )ru r� r% r% r( r� � s r� )rK rM r� r7 c C s t |�| |fS )a� This is intended for use later in the process of creating a new type, when we have more information about the exact args that will be passed. If it turns out that a different set of inputs to __class_getitem__ resulted in the same inputs to the generic type creation process, we can still return the cached type, and update the cache with the _early_cache_key as well. r� )rK rM r� r% r% r( r� � s r� )r )NN)G� __future__r rX r� r� � collectionsr � contextlibr Z contextvarsr r r r r r r r r r �weakrefr rr Z _core_utilsr Z _forward_refr Z _typing_extrar r Z_utilsr r r� r �mainr r� r r r/ ry r ZGenericTypesCacherA r� � TypedDictrI ra rW �valuesr2 rj rO rm rn rt r{ r| r� r� r� r� r� r� r� r� r� r� r� r� r% r% r% r( �<module> sr ( /U �