File: //usr/local/lib/python3.10/dist-packages/pydantic/v1/__pycache__/typing.cpython-310.pyc
o
|��g�K �
@ 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
d e d
ededefdd�Z.e j-d k r�eZ/ndpded
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 �r>d 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 �rvd!ee dee fd*d+�Z?nd d,lm@Z@ d d-l mAZA d!ee dee fd.d+�Z?e j-d/k �r�d!eee deBfd0d1�ZCe)fZDn d dl*Z*d dlZd!eee deBfd2d1�ZCej;e*j(e*j+fZDeeEef ZFe�r)d d3lGmHZH e
eeEef ddf ZIe eEef ZJe eef ZKeeE ZLeeE ZMeeNeEf ZOeeO ZPe eOef ZQeeOef ZRe
e1ddf ZSeeeeE ef ZTd4ZUeU�r"eVe ZWneVeeef ZWd5ZXdjYZZdeZe d fZ[eeeef e6d6< e j-d k �rNd edeBfd7d8�Z\n e j-dd9� d k�rbd edeBfd:d8�Z\n d edeBfd;d8�Z\d<ee deEfd=d>�Z]d?e eEee f d@eeE de eEee f fdAdB�Z^d ee deBfdCdD�Z_d ee deBfdEdF�Z`d ee deedf fdGdH�Zad ee deedf fdIdJ�Zbd ee deBfdKdL�Zcd ee deBfdMdN�Zdd edeBfdOdP�Zed edeBfdQdR�ZfedSeE�Zgd ee deBfdTdU�Zhd ee dee fdVdW�Zid<eee deBfdXdY�Zjd<eee deBfdZd[�Zkd\ee deBfd]d^�Zld\ee deBfd_d`�Zmdadbd
ededdfdcdd�Zn dqdeee dfedb dge eee eEe f e1f ddhdieeeo df ddf djdk�Zpd ee dedeBee f fdldm�Zqd!edee fdndo�ZrdS )r� 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! �=/usr/local/lib/python3.10/dist-packages/pydantic/v1/typing.py�evaluate_forwardref: s r. c C s t t| �j||t� d�S )N)�recursive_guard)r r r+ �setr, r! r! r- r. ? s �objc C s t | ||dd�S )NT)�include_extras)r )r1 r' r( r! r! r- �get_all_type_hintsO � r3 �_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_originh s rA )rA �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) r= r> r? r r r r �_typing_get_originr@ �rB r! r! r- rA q 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! ) r= r> r? rG � __metadata__�
isinstancerE r< r �Ellipsis�listr@ )r; �resr! r! r- �get_args� s
rM �rM 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 rO r �sys� version_info�tuple� TypeErrorrD r! r! r- �_generic_get_args� s
"�� ��rV 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)
rG r! )r= r> r? rG rH �_typing_get_argsr@ rV rD r! r! r- rM � 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! rD r! r! r- �convert_generics� s rX )�_UnionGenericAlias)r7 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
rG r � Nc 3 s4 � | ]}t |t�rt � t�rt|�nt|�V qd S r* )rI �str�TypingGenericAliasr rX )�.0�argrD r! r- � <genexpr>� s
� "�
�z#convert_generics.<locals>.<genexpr>)
rA rQ rM r r7 rX rT rI r\ �TypesUnionTyperY �setattr�AttributeError)rB �origin�args� convertedr! rD r- rX � s,
�
���r$ �
c C s | t u S r* )r rD r! r! r- �is_union� � rh c C s | t u p| tju S r* )r �typesr" rD r! r! r- rh � 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� �
WithArgsTypesrM rA �
get_sub_types� typing_baser3 rh �StrPath�MappingIntStrAny�
NONE_TYPESc C � | t v S r* �r� �r& r! r! r- ro R ri ro � c C s0 t D ] }| |u r dS qt| �rt| �dkS dS )NTr* F)r� rs rt )r& � none_typer! r! r- ro W s � c C r� r* r� r� r! r! r- ro d ri �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.� )rI r� r� r= � __class__rh rA �join�maprp rM r[ �replacer> rb �r� r! r! r- rp h s
�rp �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.
Nrf )r$ r% r: )r$ rg rZ FT)� is_argument�is_class)r� )r$ �
r! )� type_params) rR �modules�KeyError�__dict__�itemsrI r[ rS r r � NameError)r� r� � base_globals�module� annotations�name�valuer! r! r- rq z s0 �
"
� �
rq c C s | t u p t| �t u S r* )r rA r� r! r! r- rr � � rr c C s t d uo t| �tv S r* )r rA r8 r� r! r! r- rs � r� rs c C s t | �S r* rN r� r! r! r- �literal_values� ri 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* )rt )r] r� �xr! r! r- r_ � s � z%all_literal_values.<locals>.<genexpr>)rs r� rT )r& �valuesr! r! r- rt � s rt 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� rT rQ �r& r� r! r! r- ru � � ru 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� �dictrQ r� r! r! r- rv � r� rv c C s | t u p| tu S r* )�TypedDictRequired�TypedDictNotRequiredr� r! r! r- �_check_typeddict_special� r4 r� c C � t | �p t t| ��S )zN
Check if type is a TypedDict special form (Required or NotRequired).
)r� rA r� r! r! r- rw � s rw � test_typec C s t | tj�o
t| d�S )z>
Check whether type_ was created using typing.NewType
�
__supertype__)rI r� r� rQ r� r! r! r- rx � s rx c C s t | d�r
| j} t | d�s| S )Nr� )rQ r� r� r! r! r- ry � s
�ry c C s( | d u rdS | j tj kot| dd �dkS )NF�_namer )r� r r@ 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.
NFr9 r� r )r� r rR rS r@ 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� rA r� r �__forward_arg__�
startswith�r� r! r! r- rz � s
rz c C r� r* )r� rA r� r! r! r- r{ r� r{ �fieldrk 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__rR r� r� �copy�
setdefaultr> r| r0 �keysrI 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 )r= rA rM rI )r& rd r! r! r- � get_classC 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� )r] r; r� r! r! r- �
<listcomp>^ s z!get_sub_types.<locals>.<listcomp>)rA r r� rM rh )rB rc r! r! r- r� U s r� )NNrP )srR �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\ rj r" r` rS r. r3 r5 rl rm �AnyArgTCallabler? r8 �__annotations__rQ �addrA rC rE rM rW rV rX rY r7 �boolrh r� r[ r� �pydantic.v1.fieldsrk r~ r r� r� r� �intr� r� r� r� r� r� �MYPY� classmethodr� �__all__r� rn r� ro rp rq rr rs r� rt ru rv r� rw r� rx ry r� r� rz r{ r| �
BaseExceptionr} r� r� r! r! r! r- �<module> s�
` � � �
)
+
2#
������
�$'