File: //usr/local/CyberCP/lib64/python3.10/site-packages/pydantic/v1/__pycache__/typing.cpython-310.pyc
o
�hM �
@ s@ U d dl Z d dlZd dlmZ d dlmZ d dlmZmZmZmZ m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dl m Z m Z m Z m Z!m"Z# zd dlm$Z% W n e&yj d dlm'Z% Y nw zd dlm(Z) W n e&y~ d Z)Y nw zd d
l*m+Z, W n e&y� d Z,Y nw e j-d k r�d e d
ededefdd�Z.n e j-dk r�d e d
ededefdd�Z.n
d e d
ededefdd�Z.e j-d k r�eZ/ndrded
ededefdd�Z/ed�Z0e def Z1e g ef Z2e de0f Z3ddhZ4e hZ5ee e6d < e7ed ��r e5�8ej � e j-d k �r!d ee deee fd d!�Z9nd d"lm9Z: d#ee deee fd$d!�Z9e j-d k �rRd d%lm;Z; d ee deedf fd&d'�Z<n$d d(lm<Z= d#ee deedf fd)d*�Z>d#ee deedf fd+d'�Z<e j-d k �r�d#ee dee fd,d-�Z?nd d.lm@Z@ d d/l mAZA d#ee dee fd0d-�Z?e j-d1k �r�d#eee deBfd2d3�ZCe)fZDn d dl*Z*d dlZd#eee deBfd4d3�ZCej;e*j(e*j+fZDeeEef ZFe�r=d d5lGmHZH e
eeEef ddf ZIe eEef ZJe eef ZKeeE ZLeeE ZMeeNeEf ZOeeO ZPe eOef ZQeeOef ZRe
e1ddf ZSeeeeE ef ZTd6ZUeU�r6eVe ZWneVeeef ZWd7ZXdjYZZdeZe d fZ[eeeef e6d8< e j-d k �rbd edeBfd9d:�Z\n e j-dd;� d k�rvd edeBfd<d:�Z\n d edeBfd=d:�Z\d>ee deEfd?d@�Z]dAe eEee f dBeeE de eEee f fdCdD�Z^d ee deBfdEdF�Z_d ee deBfdGdH�Z`d ee deedf fdIdJ�Zad ee deedf fdKdL�Zbd ee deBfdMdN�Zcd ee deBfdOdP�Zdd edeBfdQdR�Zed edeBfdSdT�ZfedUeE�Zgd ee deBfdVdW�Zhd ee dee fdXdY�Zid>eee deBfdZd[�Zjd>eee deBfd\d]�Zkd^ee deBfd_d`�Zld^ee deBfdadb�Zmdcddd
ededdfdedf�Zn dsdgee dhedd die eee eEe f e1f ddjdkeeeo df ddf dldm�Zpd ee dedeBee f fdndo�Zqd#edee fdpdq�ZrdS )t� N)�Callable)�PathLike)�
TYPE_CHECKING� AbstractSet�Anyr �ClassVar�Dict�
ForwardRef� Generator�Iterable�List�Mapping�NewType�Optional�Sequence�Set�Tuple�Type�TypeVar�Union�
_eval_type�cast�get_type_hints)� Annotated�Final�Literal� NotRequired�Required)� _TypingBase)�_Final)� GenericAlias� )� UnionType�� � �type_�globalns�localns�returnc C s | � ||�S �N)� _evaluate�r& r' r( r! r! �E/usr/local/CyberCP/lib/python3.10/site-packages/pydantic/v1/typing.py�evaluate_forwardref: s r. )r$ � � c C s t t| �j||t� d�S )N)�recursive_guard�r r r+ �setr, r! r! r- r. ? s c C s t t| �j||dt� d�S )Nr! )� type_paramsr1 r2 r, r! r! r- r. H s �objc C s t | ||dd�S )NT)�include_extras)r )r5 r' r( r! r! r- �get_all_type_hintsV � r7 �_T.�
AnnotatedMeta�_AnnotatedAlias�
LITERAL_TYPESr �r$ � �tc C s( t | �jtv rttt t�S t| dd �S )N�
__origin__)�type�__name__�AnnotatedTypeNamesr r r r �getattr)r? r! r! r- �
get_origino s rE )rE �tpc C s0 t | �jtv rttt t�S t| �pt| dd�S )a4
We can't directly use `typing.get_origin` since we need a fallback to support
custom generic classes like `ConstrainedList`
It should be useless once https://github.com/cython/cython/issues/3537 is
solved and https://github.com/pydantic/pydantic/pull/1753 is merged.
r@ N) rA rB rC r r r r �_typing_get_originrD �rF r! r! r- rE x s )�
_GenericAliasc C sl t | �jtv r
| j| j S t| t�r0| j}| jtu r.|r.|d t ur.t
|dd� �|d f}|S t | dd�S )z�Compatibility version of get_args for python 3.7.
Mostly compatible with the python 3.8 `typing` module version
and able to handle almost all use cases.
r N����__args__r! ) rA rB rC rK � __metadata__�
isinstancerI r@ r �Ellipsis�listrD )r? �resr! r! r- �get_args� s
rQ �rQ c C s` t | d�r tf| j S z| td ks tjdkr | td kr#W dS W dS W dS ty/ Y dS w )aI
In python 3.9, `typing.Dict`, `typing.List`, ...
do have an empty `__args__` by default (instead of the generic ~T for example).
In order to still support `Dict` for example and consider it as `Dict[Any, Any]`,
we retrieve the `_nparams` value that tells us how many parameters it needs.
�_nparamsr! r# �r! )�hasattrr rS r �sys� version_info�tuple� TypeErrorrH r! r! r- �_generic_get_args� s
"�� ��rZ c C s6 t | �jtv r
| j| j S t| �pt| dd�pt| �S )a� Get type arguments with all substitutions performed.
For unions, basic simplifications used by Union constructor are performed.
Examples::
get_args(Dict[str, int]) == (str, int)
get_args(int) == ()
get_args(Union[int, Union[T, int], str][int]) == (int, str)
get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
get_args(Callable[[], T][int]) == ([], int)
rK r! )rA rB rC rK rL �_typing_get_argsrD rZ rH r! r! r- rQ � s c C s | S )z�Python 3.9 and older only supports generics from `typing` module.
They convert strings to ForwardRef automatically.
Examples::
typing.List['Hero'] == typing.List[ForwardRef('Hero')]
r! rH r! r! r- �convert_generics� s r\ )�_UnionGenericAlias)r; c s� t � �}|r t� d�s
� S t� �}|tu r"tt|d �|dd� �S t� fdd�|D ��}||kr3� S t� t�r=t||�S t� t �rGt
||�S z t � d|� W � S t yZ Y � S w )a�
Recursively searches for `str` type hints and replaces them with ForwardRef.
Examples::
convert_generics(list['Hero']) == list[ForwardRef('Hero')]
convert_generics(dict['Hero', 'Team']) == dict[ForwardRef('Hero'), ForwardRef('Team')]
convert_generics(typing.Dict['Hero', 'Team']) == typing.Dict[ForwardRef('Hero'), ForwardRef('Team')]
convert_generics(list[str | 'Hero'] | int) == list[str | ForwardRef('Hero')] | int
rK r � Nc 3 s4 � | ]}t |t�rt � t�rt|�nt|�V qd S r* )rM �str�TypingGenericAliasr r\ )�.0�argrH r! r- � <genexpr>� s
� "�
�z#convert_generics.<locals>.<genexpr>)
rE rU rQ r r; r\ rX rM r` �TypesUnionTyper] �setattr�AttributeError)rF �origin�args� convertedr! rH r- r\ � s,
�
���r$ �
c C s | t u S r* )r rH r! r! r- �is_union� � rl c C s | t u p| tju S r* )r �typesr" rH r! r! r- rl s )�
ModelFieldF)'� AnyCallable�NoArgAnyCallable�NoneType� is_none_type�display_as_type�resolve_annotations�is_callable_type�is_literal_type�all_literal_values�
is_namedtuple� is_typeddict�is_typeddict_special� is_new_type�new_type_supertype� is_classvar� is_finalvar�update_field_forward_refs�update_model_forward_refs�TupleGenerator�
DictStrAny�DictAny�SetStr�ListStr�IntStr�AbstractSetIntStr�
DictIntStrAny�CallableGenerator�ReprArgs�AnyClassMethodr� �
WithArgsTypesrQ rE �
get_sub_types� typing_baser7 rl �StrPath�MappingIntStrAny�
NONE_TYPESc C � | t v S r* �r� �r& r! r! r- rs Y rm rs � c C s0 t D ] }| |u r dS qt| �rt| �dkS dS )NTr* F)r� rw rx )r& � none_typer! r! r- rs ^ s � c C r� r* r� r� r! r! r- rs k rm �vc C s� t | t�st | t�st | t�s| j} tt| ��r&dd�tt t
| ���� d�S t | t�r3t | �� dd�S z| j
W S tyH t | �� dd� Y S w )NzUnion[z, �]ztyping.� )rM r� r� rA � __class__rl rE �join�maprt rQ r_ �replacerB rf �r� r! r! r- rt o s
�rt �raw_annotations� module_namec C s� d}|rzt j| }W n ty Y nw |j}i }| �� D ]L\}}t|t�rFdt j kr2dks8n t jdkr@t|ddd�}nt|dd�}zt jd krUt ||dd
d �}nt ||d�}W n t
ye Y nw |||< q |S ) z�
Partially taken from typing.get_type_hints.
Resolve string or ForwardRef annotations into type objects if possible.
Nrj )r$ r% r> )r$ rk r^ FT)� is_argument�is_class)r� )r$ �
r! )r4 ) rV �modules�KeyError�__dict__�itemsrM r_ rW r r � NameError)r� r� � base_globals�module� annotations�name�valuer! r! r- ru � s0 �
"
� �
ru c C s | t u p t| �t u S r* )r rE r� r! r! r- rv � � rv c C s t d uo t| �tv S r* )r rE r< r� r! r! r- rw � r� rw c C s t | �S r* rR r� r! r! r- �literal_values� rm r� c C s( t | �s| fS t| �}tdd� |D ��S )z�
This method is used to retrieve all Literal values as
Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586)
e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]`
c s s" � | ] }t |�D ]}|V qqd S r* )rx )ra r� �xr! r! r- rc � s � z%all_literal_values.<locals>.<genexpr>)rw r� rX )r& �valuesr! r! r- rx � s rx c C � ddl m} || t�ot| d�S )zy
Check if a given class is a named tuple.
It can be either a `typing.NamedTuple` or `collections.namedtuple`
r ��lenient_issubclass�_fields)�pydantic.v1.utilsr� rX rU �r& r� r! r! r- ry � � ry c C r� )z�
Check if a given class is a typed dict (from `typing` or `typing_extensions`)
In 3.10, there will be a public method (https://docs.python.org/3.10/library/typing.html#typing.is_typeddict)
r r� � __total__)r� r� �dictrU r� r! r! r- rz � r� rz c C s | t u p| tu S r* )�TypedDictRequired�TypedDictNotRequiredr� r! r! r- �_check_typeddict_special� r8 r� c C � t | �p t t| ��S )zN
Check if type is a TypedDict special form (Required or NotRequired).
)r� rE r� r! r! r- r{ � s r{ � test_typec C s t | tj�o
t| d�S )z>
Check whether type_ was created using typing.NewType
�
__supertype__)rM r� r� rU r� r! r! r- r| � s r| c C s t | d�r
| j} t | d�s| S )Nr� )rU r� r� r! r! r- r} � s
�r} c C s( | d u rdS | j tj kot| dd �dkS )NF�_namer )r� r rD r� r! r! r- �_check_classvar� s r� c C s2 | du rdS | j tj kotjdk pt| dd�dkS )z9
Check if a given type is a `typing.Final` type.
NFr= r� r )r� r rV rW rD r� r! r! r- �_check_finalvar� s &r� �ann_typec C s6 t | �s
t t| ��r dS | jtkr| j�d�rdS dS )NTz ClassVar[F)r� rE r� r �__forward_arg__�
startswith�r� r! r! r- r~ � s
r~ c C r� r* )r� rE r� r! r! r- r r� r �fieldro c C s� d}| j jtkrd}t| j ||pd�| _ | jjtkr&d}t| j||p#d�| _|r,| �� | jr<| jD ] }t|||d� q2| jdurG| � � dS dS )z]
Try to update ForwardRefs on fields based on this ModelField, globalns and localns.
FTN�r' r( )
r& r� r r. � outer_type_�prepare�
sub_fieldsr� �discriminator_key�&prepare_discriminated_union_sub_fields)r� r' r( r� �sub_fr! r! r- r�
s
�r� �model�fields�
json_encodersr� �exc_to_suppressc
C s� | j tjv rtj| j j�� }ni }|�| j| � |D ]}z t|||d� W q |y/ Y qw t|� � �D ]0}t
|t �rBt |�}n t
|t �rJ|}nq6z
t
|||pRd�} W n |y^ Y q6w |�|�|| < q6dS )zL
Try to update model fields ForwardRefs based on model and localns.
r� N)�
__module__rV r� r� �copy�
setdefaultrB r� r3 �keysrM r_ r r. �pop)
r� r� r� r( r� r' �f�key�fr�new_keyr! r! r- r� # s.
�
��r� c C sB | t u rdS t| �du rdS t| �}|rt|d t �s dS |d S )z�
Tries to get the class of a Type[T] annotation. Returns True if Type is used
without brackets. Otherwise returns None.
TNr )rA rE rQ rM )r& rh r! r! r- � get_classJ s r� c C s@ t | �}|tu rtt| �d �S t|�r dd� t| �D �S | gS )z~
Return all the types that are allowed by type `tp`
`tp` can be a `Union` of allowed types or an `Annotated` type
r c S s g | ] }t |�D ]}|�qqS r! )r� )ra r? r� r! r! r- �
<listcomp>e s z!get_sub_types.<locals>.<listcomp>)rE r r� rQ rl )rF rg r! r! r- r� \ s r� )NNrT )srV �typing�collections.abcr �osr r r r �TypingCallabler r r r
r r r
r r r r r r r r r r r �typing_extensionsr r r r r� r r� r r� � ImportErrorr r r` rn r" rd rW r. r7 r9 rp rq �AnyArgTCallablerC r< �__annotations__rU �addrE rG rI rQ r[ rZ r\ r] r; �boolrl r� r_ r� �pydantic.v1.fieldsro r� r� r� r� r� �intr� r� r� r� r� r� �MYPY� classmethodr� �__all__r� rr r� rs rt ru rv rw r� rx ry rz r� r{ r� r| r} r� r� r~ r r� �
BaseExceptionr� r� r� r! r! r! r- �<module> s�
` � � �
)
+
2#
������
�$'