관리-도구
편집 파일: _utils.cpython-38.pyc
U /?�fu1 � @ sV U d Z ddlmZ ddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZ ddlmZmZmZmZmZmZ ddlmZmZmZ dd lmZm Z d d l m Z m Z ej r�d Z!d e"d< dZ#d e"d< ddl$m%Z% e&e'e(e)e*e+e,e j-eeeej.eee/j0e1j0hZ2de"d< e3e4e5e6e7e e e hZ8de"d< ddd�dd�Z9dddd �d d �Z:dddd �d d!�Z;dd"d#�d$d%�Z<d&dd'�d(d)�Z=ed*�Z>d+d+d+d,�d-d.�Z?d/dd0d1�d2d3�Z@ed4�ZAe)d5�d6d7d8d9�d:d;�ZBG d<d=� d=e jC�ZDej �r�d&d4d4d>�d?d@�ZEnG dAd@� d@�ZEedB�ZFdBdBdC�dDdE�ZGeH� ZIdFdFddG�dHdI�ZJejKdJdK�G dLdM� dM��ZLdS )Nz�Bucket of reusable internal utilities. This should be reduced as much as possible with functions only used in one place, moved to that place. � )� annotationsN)� OrderedDict� defaultdict�deque)�deepcopy)� zip_longest)�BuiltinFunctionType�CodeType� FunctionType� GeneratorType� LambdaType� ModuleType)�Any�Mapping�TypeVar)� TypeAlias� TypeGuard� )�_repr� _typing_extraz3typing.Mapping[int, Any] | typing.Mapping[str, Any]r �MappingIntStrAnyz1typing.AbstractSet[int] | typing.AbstractSet[str]�AbstractSetIntStr� �� BaseModelzset[type[Any]]� IMMUTABLE_NON_COLLECTIONS_TYPES�BUILTIN_COLLECTIONSr �bool��v�returnc C s t | ttttttf�S �N)� isinstance�list�tuple�set� frozensetr r �r � r( �G/opt/hc_python/lib/python3.8/site-packages/pydantic/_internal/_utils.py� sequence_like@ s r* z(type[Any] | tuple[type[Any], ...] | None)�o�class_or_tupler c C s( z t | |�W S tk r" Y dS X d S �NF)r" � TypeError)r+ r, r( r( r) �lenient_isinstanceD s r/ )�clsr, r c C sD zt | t�ot| |�W S tk r> t | tj�r8Y dS � Y nX d S r- )r" �type� issubclassr. r Z WithArgsTypes)r0 r, r( r( r) �lenient_issubclassK s r3 zTypeGuard[type[BaseModel]])r0 r c C s ddl m} t| |�o | |k S )z�Returns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, unlike raw calls to lenient_issubclass. r r )�mainr r3 )r0 r r( r( r) �is_model_classT s r5 �str)� identifierr c C s | � � ot�| � S )z�Checks that a string is a valid identifier and not a Python keyword. :param identifier: The identifier to test. :return: True if the identifier is valid. )� isidentifier�keyword� iskeyword)r7 r( r( r) �is_valid_identifier] s r; �KeyTypezdict[KeyType, Any])�mapping�updating_mappingsr c G sd | � � }|D ]R}|�� D ]D\}}||krTt|| t�rTt|t�rTt|| |�||< q|||< qq |S r! )�copy�itemsr" �dict� deep_update)r= r> Zupdated_mappingZupdating_mapping�kr r( r( r) rB h s rB zdict[Any, Any]�None)r= �updater c K s | � dd� |�� D �� d S )Nc S s i | ]\}}|d k r||�qS r! r( )�.0rC r r( r( r) � <dictcomp>t s z#update_not_none.<locals>.<dictcomp>)rE r@ )r= rE r( r( r) �update_not_nones s rH �T)� name_factoryzlist[T] | tuple[T, ...]ztyping.Callable[[T], str]zlist[T])� input_listrJ r c C sJ g }g }| D ]8}||�}||kr6|� |� |� |� q |||�|�< q |S )z�Make a list unique while maintaining order. We update the list if another one with the same name is set (e.g. model validator overridden in subclass). )�append�index)rK rJ �resultZ result_namesr Zv_namer( r( r) � unique_listz s rO c @ s� e Zd ZdZdZdddd�dd�Zdd d �d d �Zdd d �d d�Zddd�dd�Zdddd�dd�Z e d,ddd dd�d d ��Z e ddd �d d ��Z e ddd!�d"d#��Ze dd d$�d%d&��Zd'd(�d)d*�Zd+S )-� ValueItemszOClass for more convenient calculation of excluded or included fields on values.)�_items�_typer z$AbstractSetIntStr | MappingIntStrAnyrD )�valuer@ r c C s2 | � |�}t|ttf�r(| �|t|��}|| _d S r! )� _coerce_itemsr" r# r$ �_normalize_indexes�lenrQ )�selfrS r@ r( r( r) �__init__� s zValueItems.__init__r )�itemr c C s | � | j�|��S )zWCheck if item is fully excluded. :param item: key or index of a value )�is_truerQ �get�rW rY r( r( r) � is_excluded� s zValueItems.is_excludedc C s || j kS )z`Check if value is contained in self._items. :param item: key or index of value �rQ r\ r( r( r) � is_included� s zValueItems.is_includedz int | strz+AbstractSetIntStr | MappingIntStrAny | None)�er c C s | j �|�}| �|�s|S dS )z�:param e: key or index of element on value :return: raw values for element if self._items is dict and contain needed element N)rQ r[ rZ )rW r` rY r( r( r) � for_element� s zValueItems.for_elementr �intzdict[int | str, Any])r@ �v_lengthr c C s i }d}|� � D ]�\}}t|tj�sPt|tj�sP| �|�sPtd|� d|j� ���|dkrd| �|�}qt|t �svtd��|dk r�|| n|}| � ||� |��||< q|s�|S | �|�r�t |�D ]}|� |d� q�|S t |�D ]*}|� |i �}| �|�s�| � ||�||< q�|S )a] :param items: dict or set of indexes which will be normalized :param v_length: length of sequence indexes of which will be >>> self._normalize_indexes({0: True, -2: True, -1: True}, 4) {0: True, 2: True, 3: True} >>> self._normalize_indexes({'__all__': True}, 4) {0: True, 1: True, 2: True, 3: True} Nz,Unexpected type of exclude value for index "z" �__all__z�Excluding fields from a sequence of sub-models or dicts must be performed index-wise: expected integer keys or keyword "__all__"r .)r@ r" �typingr � AbstractSetrZ r. � __class__� _coerce_valuerb �merger[ �range� setdefault) rW r@ rc Znormalized_itemsZ all_items�ir Z normalized_i�normalized_itemr( r( r) rU � s2 " � z ValueItems._normalize_indexesF)�base�override� intersectr c s� | � ���| � � �� �dkr � S | �� �s2� dkr6�S | ���rL|rH� S �S |rv�fdd�� D �� fdd��D � }nt� �� fdd��D � }i }|D ]0}| j� �|���|�|d�}|dk r�|||< q�|S )aH Merge a `base` item with an `override` item. Both `base` and `override` are converted to dictionaries if possible. Sets are converted to dictionaries with the sets entries as keys and Ellipsis as values. Each key-value pair existing in `base` is merged with `override`, while the rest of the key-value pairs are updated recursively with this function. Merging takes place based on the "union" of keys if `intersect` is set to `False` (default) and on the intersection of keys if `intersect` is set to `True`. Nc s g | ]}|� kr|�qS r( r( �rF rC )ro r( r) � <listcomp>� s z$ValueItems.merge.<locals>.<listcomp>c s g | ]}|� kr|�qS r( r( rq �rn r( r) rr � s c s g | ]}|� kr|�qS r( r( rq rs r( r) rr � s )rp )rh rZ r# ri r[ )r0 rn ro rp Z merge_keysZmergedrC Z merged_itemr( )rn ro r) ri � s" & zValueItems.merge)r@ r c C sF t | tj�rn4t | tj�r(t�| d�} nt| dd�}td|� ���| S )N.rg z???z!Unexpected type of exclude value )r" re r rf rA �fromkeys�getattrr. )r@ � class_namer( r( r) rT � s zValueItems._coerce_items)rS r c C s |d ks| � |�r|S | �|�S r! )rZ rT )r0 rS r( r( r) rh s zValueItems._coerce_valuer c C s | dkp| dkS )NT.r( r' r( r( r) rZ s zValueItems.is_truez_repr.ReprArgs)r c C s d | j fgS r! r^ )rW r( r( r) � __repr_args__ s zValueItems.__repr_args__N)F)�__name__� __module__� __qualname__�__doc__� __slots__rX r] r_ ra rU � classmethodri � staticmethodrT rh rZ rw r( r( r( r) rP � s %% rP ��namerS r c C s d S r! r( �r� rS r( r( r) �ClassAttribute � r� c @ s8 e Zd ZdZdZdddd�dd�Zdd dd �d d �Zd S )r� z(Hide class attribute from its instances.r� r6 r rD r c C s || _ || _d S r! r� )rW r� rS r( r( r) rX ! s zClassAttribute.__init__z type[Any])�instance�ownerr c C s* |d kr| j S t| j�d|j�d���d S )Nz attribute of z is class-only)rS �AttributeErrorr� rx )rW r� r� r( r( r) �__get__% s zClassAttribute.__get__N)rx ry rz r{ r| rX r� r( r( r( r) r� s �Obj)�objr c C s\ | j }|tkr| S z&| s6|tkr6|tkr,| n| �� W S W n tttfk rR Y nX t| �S )z�Return type as is for immutable built-in types Use obj.copy() for built-in empty collections Use copy.deepcopy() for non-empty collections and unknown objects. ) rg r r r$ r? r. � ValueError� RuntimeErrorr )r� �obj_typer( r( r) �smart_deepcopy. s r� ztyping.Iterable[Any])�left�rightr c C s* t | |td�D ]\}}||k r dS qdS )a Check that the items of `left` are the same objects as those in `right`. >>> a, b = object(), object() >>> all_identical([a, b, a], [a, b, a]) True >>> all_identical([a, b, [a]], [a, b, [a]]) # new list object, while "equal" is not "identical" False )� fillvalueFT)r � _SENTINEL)r� r� Z left_itemZ right_itemr( r( r) � all_identicalD s r� T)�frozenc @ sD e Zd ZU dZdZded< ddd�dd �Zejr@dd d�d d �Z d S )�SafeGetItemProxyz�Wrapper redirecting `__getitem__` to `get` with a sentinel value as default This makes is safe to use in `operator.itemgetter` when some keys may be missing )�wrappedzMapping[str, Any]r� r6 r )�keyr c C s | j �|t�S r! )r� r[ r� �rW r� r( r( r) � __getitem__` s z SafeGetItemProxy.__getitem__r c C s | j �|�S r! )r� � __contains__r� r( r( r) r� i s z SafeGetItemProxy.__contains__N) rx ry rz r{ r| �__annotations__r� re � TYPE_CHECKINGr� r( r( r( r) r� S s r� )Mr{ � __future__r Z _annotations� dataclassesr9 re �weakref� collectionsr r r r? r � itertoolsr �typesr r r r r r r r r �typing_extensionsr r � r r r� r r� r r4 r rb �float�complexr6 r �bytesr1 ZNoneType�ref�NotImplementedrg �Ellipsisr r# r% r$ r& rA r r* r/ r3 r5 r; r< rB rH rI rO ZRepresentationrP r� r� r� �objectr� r� � dataclassr� r( r( r( r) �<module> s� � � �