HEX

File: //var/opt/nydus/ops/__pycache__/typing_extensions.cpython-39.pyc
a

�,�h�r�@sddlZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZ
ddlZddlZejdkr�ddlZgd�ZdZeZejdkZdejjvZGdd�d�Ze�Zejd	kr�d
d�Zndd�ZejZe�d
�Ze�d�Z e�d�Z!ejddd�Z"ejddd�Z#ejdk�r:ddlm$Z$n"Gdd�de�Z%Gdd�de%d�Z$ej&Z&Gdd�dej'dd�Z(Gdd�dej(dd�Z)ej*Z*ejdk�r�ej+Z+nd d!�Z+e,ed"��r�ej-Z-nd#d"�Z-d$d%�Z.ejd&k�r�ej/Z/nDd'd(�Z0d)d*�Z1Gd+d,�d,ej2dd�Z3Gd-d.�d.e)dd�Z4e4d/d0�Z/ej5Z5e,ed1��rRej6Z6ej7Z7ej8Z8n,e�9e�:ej9e;��Z<d2d3�Z6d4d1�Z7d5d6�Z8ej=Z=ej>Z>ej?Z?ej@Z@ejAZAejBZBejCZCejDZDejEZEejFZFejGZGejHZHejdk�r�dd7lmIZImJZJmKZKmLZLn�d8d9�ZMGd:d;�d;ejNdd�ZNed�ZOeNejjLd<eOeOfd=�ZLeNejjJd>eOfd=�ZJeNejPd>d?ejQeRfd@�ZKeNejSd>dAejQeRfd@�ZIgdB�dCdDgdEgdF�ZTeUejV�hdG�BZWdHdI�ZX�d5dLdM�ZYejdNk�r�ejZZZnT�d6dOdP�Z[dQdR�Z\dSdT�Z]GdUdV�dVeejZ��Z^e_dWdX��Z`GdYdZ�dZejae^d�ZZejdNk�r(ejbZbnd[d\�ZbebZcejd]k�rlejdZdejeZeejfZfejgZgejhZhejiZiejjZjn�ebGd^d_�d_eZ��ZdebGd`da�daeZ��ZeebGdbdc�dceZ��ZfebGddde�deeZ��ZgebGdfdg�dgeZ��ZhebGdhdi�dieZe"��ZiebGdjdk�dkeZe"��Zje,edl��r&e,edm��r&ejkZkejlZln0ebGdndl�dleZe"��ZkebGdodm�dmeZe#��Zle,edp��pne,edq�Zmem�r�Gdrds�dse�Zne,edp��r�ejoZonGdtdu�duend�Zpep�Zo[pe,edq��r�ejqZqnGdvdw�dwend�Zrer�Zq[rem�r�[ndxZses�rejtZtejuZuejvZvntdye�wejx�jyvZzdzd{�Z{Gd|d}�d}e�Zue�|eud~di�Z}d�d��Z~Gd�d��d�e(dd�Zed�d~��ZtejueufZ�d�d��Zve,ed���r�ej�Z�nd�d��Z�e,ed���r�ej�Z�n0d�d��Z��d7d�d��Z�ed�ZOd�d��Z��d8d�d��Z�ejd	k�r�ej�Z�ej�Z�nd�d��Z�d�d��Z�e,ed���rej�Z�ne)d�d���Z�d�d��Z�d�d��Z�Gd�d��d��Z�Gd�d��d�e�Z�e�rhdd�lmZnGd�d��d�e�d�Ze,ed���r�ej�Z�ej�Z�n.Gd�d��d��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�e�r�dd�lm�Z�n2e,ed���r�Gd�d��d�e�d�Z�nGd�d��d�e�e��Z�e,ed���sLe,ed���s4�d9dxd��d�d��Z�nej�Z�Gd�d��d�e��Z�n(ej�Z�ejdk�rtGd�d��d�ej�dd�Z�Gd�d��d��Z�d�d��Z�ej�d�d���Z�ejdk�r�ej�Z�ne)d�d���Z�e,ed���r�ej�Z�ne)d�d���Z�e,ed���r�ej�Z�ne)d�d���Z�e,ed���	rej�Z�n Gd�d��d�e)dd�Z�e�d�d���Z�e,edÃ�	r@ej�Z�ne(d�dÄ�Z�e,edŃ�	r`ej�Z�ne(d�dń�Z�e,edǃ�	r�ej�Z�ne(d�dǄ�Z�e,edɃ�	r�ej�Z�ej�Z�ne)d�dɄ�Z�e)d�d̄�Z�e,ed���	r�ej�Z�ne)d�d���Z�d�Z�ejd]k�	r�ej�Z�d�dЄZ�n>Gd�d҄d�e)dd�Z�Gd�dԄd�ej2dd�Z�e�d�dք�Z�d�dЄZ�d�dلZ�e�
rXdd�lm�Z�n0e,edۃ�
rxGd�dۄd�e�d�Z�nGd�dۄd�e��Z�e,edރ�
r�ej�Z�needߜd�dބZ�e,ed��
r�ej�Z�nd�Z�e,ed��
r�ej�Z�ne�e�d�d�d�Z�ejd]k�
r�ej�Z�n^ddxdxdxdd�eReReReRej�ej�ej=ej$ej�d�ej$ffd�fej$ej�egefd�d�d�Z�e,ed��rnej�Z�n*ejd�ej�d�ej$fd�Z�e�e�d�d�d�Z�ejd�k�r�ej�Z�ne�d�Z�Gd�d�d�Z�ejd	k�r�d�d�Z�nd�d�Z�e,edۃ�s�efd�d��Z�nd�d��Z�e�se�e_�eRd��d�d��Z�e�e�ed�d�hZ�eRd��d�d��Z�e,ed���r\�d:d�d��Z�e�e_�n�d�d�Z�e�ste�e_�ejdNk�r�ej�Z�nn�d;�d�d�Z�ej�Z�eUh�d��Z�G�d�d��de�Z�e�|eddi�ZÐd�d	�Z�ef�d
�d�Z�e�e�_�e,ejdE��
rejj�Z�n2G�ddE�dEejǃZ�eƠ�eɡeƠ�eʡeƠ�eˡe,e
�d��
rVe
j�Z�n�d
�d�Z�ejdk�
rvej�Z�nG�d�d��d�Z�ejdk�
r�ej�Z�npejd]k�
r��d�d�Z�n�d�d�Z�ejd	k�
r�eUh�d��Z�G�d�d��dej2dd�Z�G�d�d��d�Z�e,e�d��r*ej�Z�ej�Z�n2eeR�d��d�d�Z�eej�e��d��d�d�Z�e,e�d��rrej�Z�nG�d�d��d�Z�e�e
�dd�Z�e�du�r�zddl�Z�Wneِy�Yn"0e�eؐd d�Z�e�du�r�eeڃZ�e�du�r�e�Z�e�ܐd�ejdk�rd�d!lm�Z�m�Z�n4G�d"�d#��d#ej߃Z�dddxe�j�d$��d%�d&�Z�e,e�d'��rdej�Z�n:dddd�d(��d)�d*�Z�dddddeU��d+��d,�d'�Z�G�d-�d.��d.�Z�ej�d/k�r�ej�Z�n�d0�d1�Z�g�d2�Z�e���d3�d4�e�D��ejaZaejZej�Z�dS(<�N���)w�Any�ClassVar�Concatenate�Final�
LiteralString�	ParamSpec�
ParamSpecArgs�ParamSpecKwargs�Self�Type�TypeVar�TypeVarTuple�Unpack�	Awaitable�
AsyncIterator�
AsyncIterable�	Coroutine�AsyncGenerator�AsyncContextManager�Buffer�ChainMap�ContextManager�Counter�Deque�DefaultDict�
NamedTuple�OrderedDict�	TypedDict�SupportsAbs�
SupportsBytes�SupportsComplex�
SupportsFloat�
SupportsIndex�SupportsInt�
SupportsRound�Reader�Writer�	Annotated�assert_never�assert_type�clear_overloads�dataclass_transform�
deprecated�
disjoint_base�Doc�evaluate_forward_ref�
get_overloads�final�Format�get_annotations�get_args�
get_origin�get_original_bases�get_protocol_members�get_type_hints�IntVar�is_protocol�is_typeddict�Literal�NewType�overload�override�Protocol�Sentinel�reveal_type�runtime�runtime_checkable�Text�	TypeAlias�
TypeAliasType�TypeForm�	TypeGuard�TypeIs�
TYPE_CHECKING�	type_repr�Never�NoReturn�ReadOnly�Required�NotRequired�	NoDefault�NoExtraItems�AbstractSet�AnyStr�BinaryIO�Callable�
Collection�	Container�Dict�
ForwardRef�	FrozenSet�	Generator�Generic�Hashable�IO�	ItemsView�Iterable�Iterator�KeysView�List�Mapping�MappingView�Match�MutableMapping�MutableSequence�
MutableSet�Optional�Pattern�
Reversible�Sequence�Set�Sized�TextIO�Tuple�Union�
ValuesView�cast�
no_type_check�no_type_check_decoratorT)r�
r�beta�__forward_is_class__c@seZdZdd�ZdS)�	_SentinelcCsdS)Nz
<sentinel>���selfr�r��B/opt/nydus/tmp/pip-target-wkfpz8uv/lib/python/typing_extensions.py�__repr__�sz_Sentinel.__repr__N��__name__�
__module__�__qualname__r�r�r�r�r�r�sr�r�
cCst|tjtjtjf�S�N)�
isinstance�typing�
_GenericAlias�_types�GenericAlias�	UnionType��tr�r�r��_should_collect_from_parameters�s�r�cCst|tjtjf�Sr�)r�r�r�r�r�r�r�r�r�r��s�T�KT�VT�T_co)�	covariant�T_contra)�
contravariant�r�)rcs(eZdZ�fdd�Z�fdd�Z�ZS)�_AnyMetacs|turtd��t��|�S)Nz6typing_extensions.Any cannot be used with isinstance())r�	TypeError�super�__instancecheck__�r��obj��	__class__r�r�r��sz_AnyMeta.__instancecheck__cs|turdSt���S)Nztyping_extensions.Any)rr�r�r�r�r�r�r��sz_AnyMeta.__repr__)r�r�r�r�r��
__classcell__r�r�r�r�r��sr�cs eZdZdZ�fdd�Z�ZS)raqSpecial type indicating an unconstrained type.
        - Any is compatible with every type.
        - Any assumed to have all methods.
        - All values assumed to be instances of Any.
        Note that all the above statements are true from the point of view of
        static type checkers. At runtime, Any should not be used with instance
        checks.
        cs*|turtd��t�j|g|�Ri|��S)NzAny cannot be instantiated)rr�r��__new__��cls�args�kwargsr�r�r�r��szAny.__new__)r�r�r��__doc__r�r�r�r�r�r�r�sr)�	metaclassc@sneZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
ejdd��ZdS)�_SpecialForm)�_namer��_getitemcCs||_|j|_|j|_dSr�)r�r�r�r��r��getitemr�r�r��__init__�sz_SpecialForm.__init__cCs|dvr|jSt|��dS)N>r�r�)r��AttributeError)r��itemr�r�r��__getattr__�sz_SpecialForm.__getattr__cCstd|����dS)NzCannot subclass �r��r��basesr�r�r��__mro_entries__�sz_SpecialForm.__mro_entries__cCsd|j��S�Nztyping_extensions.�r�r�r�r�r�r��sz_SpecialForm.__repr__cCs|jSr�r�r�r�r�r��
__reduce__�sz_SpecialForm.__reduce__cOstd|����dS)NzCannot instantiate r��r�r��kwdsr�r�r��__call__sz_SpecialForm.__call__cCstj||fSr��r�rw�r��otherr�r�r��__or__sz_SpecialForm.__or__cCstj||fSr�r�r�r�r�r��__ror__sz_SpecialForm.__ror__cCst|�d���dS)Nz! cannot be used with isinstance()r�r�r�r�r�r�	sz_SpecialForm.__instancecheck__cCst|�d���dS)Nz! cannot be used with issubclass()r�)r�r�r�r�r��__subclasscheck__sz_SpecialForm.__subclasscheck__cCs|�||�Sr�)r��r��
parametersr�r�r��__getitem__sz_SpecialForm.__getitem__N)r�r�r��	__slots__r�r�r�r�r�r�r�r�r�r�r��	_tp_cacher�r�r�r�r�r��sr�)�_rootc@seZdZdd�ZdS)�_ExtensionsSpecialFormcCs
d|jSr�r�r�r�r�r�r�sz_ExtensionsSpecialForm.__repr__Nr�r�r�r�r�r�sr�c	Cs&z
d|_Wnttfy Yn0|S)a�This decorator can be used to indicate to type checkers that
        the decorated method cannot be overridden, and decorated class
        cannot be subclassed. For example:

            class Base:
                @final
                def done(self) -> None:
                    ...
            class Sub(Base):
                def done(self) -> None:  # Error reported by type checker
                    ...
            @final
            class Leaf:
                ...
            class Other(Leaf):  # Error reported by type checker
                ...

        There is no runtime checking of these properties. The decorator
        sets the ``__final__`` attribute to ``True`` on the decorated object
        to allow runtime introspection.
        T)�	__final__r�r�)�fr�r�r�r4%s

r4r0cCs
d|_|S)a<This decorator marks a class as a disjoint base.

        Child classes of a disjoint base cannot inherit from other disjoint bases that are
        not parent classes of the disjoint base.

        For example:

            @disjoint_base
            class Disjoint1: pass

            @disjoint_base
            class Disjoint2: pass

            class Disjoint3(Disjoint1, Disjoint2): pass  # Type checker error

        Type checkers can use knowledge of disjoint bases to detect unreachable code
        and determine when two types can overlap.

        See PEP 800.T)Z__disjoint_base__�r�r�r�r�r0HscCs
t�|�Sr�)r�r��namer�r�r�r<`sr<)rr��cCs8g}|D]&}t|t�r$|�|j�q|�|�qt|�S)zJAn internal helper for Literal creation: flatten Literals among parameters)r��_LiteralGenericAlias�extend�__args__�append�tuple)r��params�pr�r�r��_flatten_literal_paramsis
r�ccs|D]}|t|�fVqdSr�)�type)r�r�r�r�r��_value_and_type_iterssr�c@seZdZdd�Zdd�ZdS)r�cCs2t|t�stStt|j��}tt|j��}||kSr�)r�r��NotImplemented�setr�r�)r�r�Zthese_args_dedupedZother_args_dedupedr�r�r��__eq__xs

z_LiteralGenericAlias.__eq__cCsttt|j���Sr�)�hash�	frozensetr�r�r�r�r�r��__hash__sz_LiteralGenericAlias.__hash__N)r�r�r�r�r�r�r�r�r�r�wsr�c@s"eZdZed�dd�Zdd�ZdS)�_LiteralForm��doccCsd|_||_|_dS)Nr?)r�Z_docr�)r�r�r�r�r�r��sz_LiteralForm.__init__cCs�t|t�s|f}t|�}tt|��}zt|�}WntyBYnT0t|�t|�kr�g}|D]$}||vr\|�|d�|�	|�q\|r�J|��t|�}t
||�S�Nr)r�r�r��listr�r�r��lenr��remover�)r�r�Zval_type_pairsZ
deduped_pairsZnew_parameters�pairr�r�r�r��s"
z_LiteralForm.__getitem__N)r�r�r��strr�r�r�r�r�r�r��sr�a�                           A type that can be used to indicate to type checkers
                           that the corresponding value has a value literally equivalent
                           to the provided parameter. For example:

                               var: Literal[4] = 4

                           The type checker understands that 'var' is literally equal to
                           the value 4 and no other value.

                           Literal[...] cannot be subclassed. There is no runtime
                           checking verifying that the parameter is actually a value
                           instead of a type.r�r3cCs@t|d|�}z|t|j|j|jj<Wnty:Yn0tS)a�Decorator for overloaded functions/methods.

        In a stub file, place two or more stub definitions for the same
        function in a row, each decorated with @overload.  For example:

        @overload
        def utf8(value: None) -> None: ...
        @overload
        def utf8(value: bytes) -> bytes: ...
        @overload
        def utf8(value: str) -> bytes: ...

        In a non-stub file (i.e. a regular .py file), do the same but
        follow it with an implementation.  The implementation should *not*
        be decorated with @overload.  For example:

        @overload
        def utf8(value: None) -> None: ...
        @overload
        def utf8(value: bytes) -> bytes: ...
        @overload
        def utf8(value: str) -> bytes: ...
        def utf8(value):
            # implementation goes here

        The overloads for a function can be retrieved at runtime using the
        get_overloads() function.
        �__func__)�getattr�_overload_registryr�r��__code__�co_firstlinenor��_overload_dummy)�funcr�r�r�r�rA�s��rAcCsDt|d|�}|jtvrgSt|j}|j|vr2gSt||j���S)z6Return all defined overloads for *func* as a sequence.r�)r�r�r�r�r��values)r�r��mod_dictr�r�r�r3�s


cCst��dS)z$Clear all overloads in the registry.N)r��clearr�r�r�r�r-�sr-)rrrr`cCs|�d�o|�d�S)N�__)�
startswith�endswith)�attrr�r�r��
_is_dunder
sr�cs<eZdZdddd��fdd�
Zdd�Zejd	d
��Z�ZS)�_SpecialGenericAliasTNr�)�instr��defaultscst�j||||d�||_dS)N)r�r�)r�r��	_defaults)r��origin�nparamsr�r�r�r�r�r�r�sz_SpecialGenericAlias.__init__cCs:hd�}t|�s||vr(t�|||�nt|j||�dS)N>r�r��_nparams�_inst)r��object�__setattr__�setattr�
__origin__)r�r��valZ
allowed_attrsr�r�r�rsz _SpecialGenericAlias.__setattr__c	s�t|t�s|f}d�t�fdd�|D��}|jrxt|�|jkrxt|�t|j�|jkrxg|�|jt|�|jd��R}t|�}||jkr�|jr�d|jt|j���}n
t|j�}|js�t|�d���td||jkr�dnd�d	|�d
|�d|����|�|�S)Nz*Parameters to generic types must be types.c3s|]}t�|��VqdSr��r��_type_check��.0r���msgr�r��	<genexpr>�z3_SpecialGenericAlias.__getitem__.<locals>.<genexpr>�	at least � is not a generic class�Too �many�few� arguments for �	; actual �, expected )r�r�r�r�rr�r��	copy_with)r�r�Z
actual_len�expectedr�r
r�r�s8
���"

����z _SpecialGenericAlias.__getitem__)	r�r�r�r�rr�r�r�r�r�r�r�r�r�sr�r)r��r)r�r�r)rZrrerfrrbrtr\r[rqr�AbstractContextManager�AbstractAsyncContextManagerr)zcollections.abc�
contextlib�typing_extensions>�__non_callable_proto_members__Z__match_args__r��__protocol_attrs__cCsht�}|jdd�D]N}|jdvr$qt|di�}g|j�|�RD] }|�d�s@|tvr@|�|�q@q|S)N���>rarC�__annotations__�_abc_)r��__mro__r�r��__dict__r��_EXCLUDED_ATTRS�add)r��attrs�base�annotationsr�r�r�r��_get_protocol_attrs[s
r,r��__main__c	Cs^zt�|d�p|WSty&Yn0zt�|d�j�d|�WSttfyXYn0dS)Nr�r�)�sysZ_getframemodulenamer��	_getframe�	f_globals�get�
ValueError)�depth�defaultr�r�r��_callergsr5�rr|cCst|�dvS)z�Allow instance and class checks for special stdlib modules.
        The abc and functools modules indiscriminately call isinstance() and
        issubclass() on the whole MRO of a user class, which may contain protocols.
        >�abc�	functoolsN)r5�r3r�r�r��_allow_reckless_class_checksysr:cOst|�jrtd��dS)Nz Protocols cannot be instantiated)r��_is_protocolr��r�r�r�r�r�r��_no_init�s
r=cCst|t�std��dS)a�Raise TypeError if `arg` is not an instance of `type`
        in `issubclass(arg, <protocol>)`.

        In most cases, this is verified by type.__subclasscheck__.
        Checking it again unnecessarily would slow down issubclass() checks,
        so, we don't perform this check unless we absolutely have to.

        For various error paths, however,
        we want to ensure that *this* error message is shown to the user
        where relevant, rather than a typing.py-specific error message.
        z"issubclass() arg 1 must be a classN)r�r�r���argr�r�r��_type_check_issubclass_arg_1�s
r@c@sBeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zed�dd
�Z	dS)�
_ProtocolMetacKs�|dkrt|�dkrnZttjht|�@rp|D]B}|ttjttjhvs,|jt�|j	g�vs,t
|�s,td|����q,tj
j||||fi|��S)NrCrz5Protocols can only inherit from other protocols, got )r�rCr�r�rrar��_PROTO_ALLOWLISTr1r�r=r�r7�ABCMetar�)�mclsr�r��	namespacer�r*r�r�r�r��s �����z_ProtocolMeta.__new__cOs4tjj|g|�Ri|��t|dd�r0t|�|_dS)Nr;F)r7rCr�r�r,r!r�r�r�r�r��sz_ProtocolMeta.__init__cCs�|turt�||�St|dd�r�t�s�t|dd�sBt|�td��|jr�|j�	d�t
ur�t|�t|j�}tdt|�dd��d	���t
j�||�S)
Nr;F�_is_runtime_protocol�LInstance and class checks can only be used with @runtime_checkable protocols�__subclasshook__zRProtocols with non-method members don't support issubclass(). Non-method members: r�r"�.)rCr�r�r�r:r@r�r r&r1�_proto_hook�sortedr�r7rC)r�r�Znon_method_attrsr�r�r�r��s.
�����
��z_ProtocolMeta.__subclasscheck__c	Cs�|turt�||�St|dd�s.tj�||�St|dd�sHt�sHtd��tj�||�rZdS|jD]D}zt	�
||�}Wnty�Yq�Yn0|dur`||jvr`q�q`dSdS)Nr;FrFrGT)
rCr�r�r�r7rCr:r�r!�inspect�getattr_staticr�r )r��instancer�rr�r�r�r��s(
��
z_ProtocolMeta.__instancecheck__cCs(tj�||�durdS|tuo&|tjuS)NT)r7rCr�rCr��r�r�r�r�r�r��sz_ProtocolMeta.__eq__��returncCs
t�|�Sr�)r�r�r�r�r�r�r��sz_ProtocolMeta.__hash__N)
r�r�r�r�r�r�r�r��intr�r�r�r�r�rA�s rAcCs�|j�dd�stS|jD]n}|jD]Z}||jvrN|j|durJtSqt|di�}t|tjj	�r"||vr"t
|�r"qq"tSqdS)Nr;Fr#T)r&r1r�r!r%r�r��collectionsr7rir=)r�r�r�r*r+r�r�r�rJ�s$


���
rJcs0eZdZejjZdZdZdZ�fdd�Z	�Z
S)rCr�TFcsbt�j|i|��|j�dd�s6tdd�|jD��|_d|jvrFt|_|jr^|j	t
j	ur^t|_	dS)Nr;Fcss|]}|tuVqdSr�)rC�r�br�r�r�rrz-Protocol.__init_subclass__.<locals>.<genexpr>rH)r��__init_subclass__r&r1�any�	__bases__r;rJrHr�rCr=r�r�r�r�rVs
zProtocol.__init_subclass__)r�r�r�r�rCr�r�r;rFrVr�r�r�r�r�rCs
rCcCs�t|tj�rt|dd�s&td|����d|_t|t�s@tj	dkr�t
�|_|jD]`}zt
t||d��}Wn6ty�}ztd|�d��|�WYd}~qNd}~00|sN|j�|�qN|S)	ajMark a protocol class as a runtime protocol.

        Such protocol can be used with isinstance() and issubclass().
        Raise TypeError if applied to a non-protocol class.
        This allows a simple-minded structural check very similar to
        one trick ponies in collections.abc such as Iterable.

        For example::

            @runtime_checkable
            class Closable(Protocol):
                def close(self): ...

            assert isinstance(open('/some/file'), Closable)

        Warning: this will check only the presence of the required methods,
        not their type signatures!
        r;Fz@@runtime_checkable can be only applied to protocol classes, got T)r�rNz,Failed to determine whether protocol member z is a method member)�
issubclassr�rar�r�rFr�rAr.�version_infor�r r!�callable�	Exceptionr()r�r�Zis_callable�er�r�r�rG.s&�	

��rG�rrYc@s(eZdZdZdZejed�dd��ZdS)r&z(An ABC with one abstract method __int__.r�rPcCsdSr�r�r�r�r�r��__int__vszSupportsInt.__int__N)	r�r�r�r�r�r7�abstractmethodrRr`r�r�r�r�r&qsr&c@s(eZdZdZdZejed�dd��ZdS)r$z*An ABC with one abstract method __float__.r�rPcCsdSr�r�r�r�r�r��	__float__szSupportsFloat.__float__N)	r�r�r�r�r�r7ra�floatrbr�r�r�r�r$zsr$c@s(eZdZdZdZejed�dd��ZdS)r#z,An ABC with one abstract method __complex__.r�rPcCsdSr�r�r�r�r�r��__complex__�szSupportsComplex.__complex__N)	r�r�r�r�r�r7ra�complexrdr�r�r�r�r#�sr#c@s(eZdZdZdZejed�dd��ZdS)r"z*An ABC with one abstract method __bytes__.r�rPcCsdSr�r�r�r�r�r��	__bytes__�szSupportsBytes.__bytes__N)	r�r�r�r�r�r7ra�bytesrfr�r�r�r�r"�sr"c@s$eZdZdZejed�dd��ZdS)r%r�rPcCsdSr�r�r�r�r�r��	__index__�szSupportsIndex.__index__N)r�r�r�r�r7rarRrhr�r�r�r�r%�sr%c@s(eZdZdZdZejed�dd��ZdS)r!z_
        An ABC with one abstract method __abs__ that is covariant in its return type.
        r�rPcCsdSr�r�r�r�r�r��__abs__�szSupportsAbs.__abs__N)	r�r�r�r�r�r7rar�rir�r�r�r�r!�sr!c@s,eZdZdZdZejdeed�dd��Z	dS)	r'za
        An ABC with one abstract method __round__ that is covariant in its return type.
        r�r)�ndigitsrQcCsdSr�r�)r�rjr�r�r��	__round__�szSupportsRound.__round__N)r)
r�r�r�r�r�r7rarRr�rkr�r�r�r�r'�sr'r(r)c@s,eZdZdZdZejdeed�dd��Z	dS)	r(zeProtocol for simple I/O reader instances.

        This protocol only supports blocking I/O.
        r�.)�sizerQcCsdS)z�Read data from the input stream and return it.

            If *size* is specified, at most *size* items (bytes/characters) will be
            read.
            Nr�)r�rlr�r�r��read�szReader.readN).)
r�r�r�r�r�r7rarRr�rmr�r�r�r�r(�sc@s*eZdZdZdZejeed�dd��Z	dS)r)zeProtocol for simple I/O writer instances.

        This protocol only supports blocking I/O.
        r�)�datarQcCsdS)zIWrite *data* to the output stream and return the number of items written.Nr�)r�rnr�r�r��write�szWriter.writeN)
r�r�r�r�r�r7rar�rRror�r�r�r�r)�srUrVc@seZdZdd�ZdS)�
SingletonMetacCstd|�d|j����dS)Nzcannot set z attribute of immutable type �r�r�)r�r��valuer�r�r�r�s�zSingletonMeta.__setattr__N)r�r�r�rr�r�r�r�rp�srpc@s,eZdZdZdZdd�Zdd�Zdd�Zd	S)
�
NoDefaultTypez$The type of the NoDefault singleton.r�cCst��d�pt�|�S�NrU��globalsr1rr�r�r�r�r�r��szNoDefaultType.__new__cCsdS)Nztyping_extensions.NoDefaultr�r�r�r�r�r��szNoDefaultType.__repr__cCsdSrtr�r�r�r�r�r��szNoDefaultType.__reduce__N�r�r�r�r�r�r�r�r�r�r�r�r�rs�s
rsc@s,eZdZdZdZdd�Zdd�Zdd�Zd	S)
�NoExtraItemsTypez'The type of the NoExtraItems singleton.r�cCst��d�pt�|�S�NrVrur�r�r�r�r�szNoExtraItemsType.__new__cCsdS)Nztyping_extensions.NoExtraItemsr�r�r�r�r�r�szNoExtraItemsType.__repr__cCsdSryr�r�r�r�r�r�szNoExtraItemsType.__reduce__Nrwr�r�r�r�rx�s
rxF�moduleccs�t|�}|tur*t|�}|r||d}qzq|q|turDtVt|�\}q|tur^tVt|�\}q|tur|tVt|�\}qq|qdSr�)r8r*r7rSrTrR)�annotation_typeZannotation_originZannotation_argsr�r�r��_get_typeddict_qualifiers&s 
r|c@s.eZdZdded�dd�ZeZdd�ZeZdS)�_TypedDictMetaTN��total�closed�extra_itemscsZ�D]"}t|�tur|tjurtd��q|durH|turHtd|�d���tdd��D��rdtjf}nd}|�dd�}	t�td	g|�t	�R|��|�_
�jd	kr�|�_t�d
�s���_
i}
d�|	dur�|	�nTtjdk�rttd�r�t�|��n
|�d
���du�rtj�tj�d��ni�ni�d�t�rB��fdd����D��n�fdd����D��t�}t�}t�}
t�}|}�D]r}|j}tjdk�r�|
�|�di��|�|�dd��|�|�dd��|
�|�dd��|�|�dd���qx|�rFtjdk�rFd�v�rF��d�}tt|��}t|v�r0td��t|v�rBtd��|}|
������D]�\}}tt|��}t|v�r�|�|�n2t|v�r�|�|�n|�r�|�|�n
|�|�t|v�r�|� |�|
�|�n|�|�|
� |��qXtjdk�r������fdd�}|�_!n|
�_"t#|��_$t#|��_%t#|
��_&t#|��_'|�_(|�_)|�_*�S)aICreate new typed dict class object.

            This method is called when TypedDict is subclassed,
            or when TypedDict is instantiated. This way
            TypedDict supports all three syntax forms described in its docstring.
            Subclasses and instances of TypedDict return actual dictionaries.
            zHcannot inherit from both a TypedDict type and a non-TypedDict base classNzCannot combine closed=z and extra_itemscss|]}t|tj�VqdSr�)rZr�rarTr�r�r�rMrz)_TypedDictMeta.__new__.<locals>.<genexpr>r�r#rC�__orig_bases__r�!get_annotate_from_class_namespace�__annotate__��ownerz?TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a typecs$i|]\}}|tj|��jd��qS��rz�r�r
r��r�n�tp�r�tp_dictr�r��
<dictcomp>rs�z*_TypedDictMeta.__new__.<locals>.<dictcomp>csi|]\}}|t�|���qSr�r	r�r
r�r�r�ws��__required_keys__�__optional_keys__�__readonly_keys__�__mutable_keys__�__extra_items__z5Special key __extra_items__ does not support Requiredz8Special key __extra_items__ does not support NotRequiredcs�i}�D]8}|turq|j}|dur&qtj|||d�}|�|�q�dur~tj�|�d�}|tjkr���fdd�|��D�}n4|tjkr�t���}n|tj	tj
fvr��}nt|��|�|�|S)Nr�cs$i|]\}}|tj|��jd��qSr�r�r�r�r�r�r��s�z@_TypedDictMeta.__new__.<locals>.__annotate__.<locals>.<dictcomp>)rar��
annotationlib�call_annotate_function�updater5�STRING�itemsZannotations_to_string�
FORWARDREF�VALUE�NotImplementedError)�formatZannosr*Z
base_annotateZ
base_annosZown�r�rZown_annotate�own_annotationsZown_checked_annotationsr�r�r�r��s4��
�

z,_TypedDictMeta.__new__.<locals>.__annotate__)+r�r}r�rar�rVrW�popr��dictr�r��hasattrr�r.r[r�r�r1r�r5r��
_TAKES_MODULEr�r�r&r�r|rSrTr(rR�discardr�r#r�r�r�r�r��	__total__Z
__closed__r�)r�r�r��nsrr�r�r*Zgeneric_baseZns_annotationsr+�
required_keys�
optional_keysZ
readonly_keysZmutable_keysZextra_items_typeZ	base_dictr{Z
qualifiersZannotation_keyr�r�r�r�r�=s�	






��
��

�
�










z_TypedDictMeta.__new__cCstd��dS)Nz4TypedDict does not support instance and class checksr�rOr�r�r�r��sz _TypedDictMeta.__subclasscheck__)	r�r�r�rVr�r�r�r�r�r�r�r�r�r};s�r}r r�c
Ks|tus|dur�|turd}nd}d|�d|�d�}|�d�|d}	tj|	tdd	�|d
urz|durz|durz||d<d}|tur�||d
<t}|}n|r�td��|r�tjdkr�td��tjdtdd	�dt|�i}
t	|r�dndd�}|dur�||
d<t
|d|
|||d�}tf|_|S)N�2Failing to pass a value for the 'fields' parameter�(Passing `None` as the 'fields' parameter�`z
 = TypedDict(z, {})`z� is deprecated and will be disallowed in Python 3.15. To create a TypedDict class with 0 fields using the functional syntax, pass an empty dictionary, e.g. rIr��
stacklevelFTr�r�z@TypedDict takes either a dict or keyword arguments, but not bothr6z$TypedDict takes no keyword argumentsz�The kwargs-based syntax for TypedDict definitions is deprecated in Python 3.11, will be removed in Python 3.13, and may not be understood by third-party type checkers.r#�r9r�r�r~)
�_marker�warnings�warn�DeprecationWarningrVr�r.r[r�r5r}r r�)
�typename�fields�typing_is_inlinerr�r�r��deprecated_thing�example�deprecation_msgr�rz�tdr�r�r��_create_typeddict�sL���
��r�c@s*eZdZefdded�dd�Zdd�ZdS)�_TypedDictSpecialFormTNr~cKst||fd|||d�|��S)NF�r�rr�r�)r�)r�r�r�rr�r�r�r�r�r�r�$s���z_TypedDictSpecialForm.__call__cCstfSr�)�
_TypedDictr�r�r�r�r�9sz%_TypedDictSpecialForm.__mro_entries__)r�r�r�r�rVr�r�r�r�r�r�r�#s��r�cCs&t|t�std��td|dddtd�S)aqA simple typed namespace. At runtime it is equivalent to a plain dict.

        TypedDict creates a dictionary type such that a type checker will expect all
        instances to have a certain set of keys, where each key is
        associated with a value of a consistent type. This expectation
        is not checked at runtime.

        Usage::

            class Point2D(TypedDict):
                x: int
                y: int
                label: str

            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check

            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')

        The type info can be accessed via the Point2D.__annotations__ dict, and
        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
        TypedDict supports an additional equivalent form::

            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})

        By default, all keys must be present in a TypedDict. It is possible
        to override this by specifying totality::

            class Point2D(TypedDict, total=False):
                x: int
                y: int

        This means that a Point2D TypedDict can have any of the keys omitted. A type
        checker is only expected to support a literal False or True as the value of
        the total argument. True is the default, and makes all items defined in the
        class body be required.

        The Required and NotRequired special forms can also be used to mark
        individual keys as being required or not required::

            class Point2D(TypedDict):
                x: int  # the "x" key must always be present (Required is the default)
                y: NotRequired[int]  # the "y" key can be omitted

        See PEP 655 for more details on Required and NotRequired.
        z9TypedDict[...] should be used with a single dict argumentz<inline TypedDict>Tr�)r�r�r�r�rV�r�r�r�r�r�r <s1
��cCs
t|t�S)aCheck if an annotation is a TypedDict class

        For example::
            class Film(TypedDict):
                title: str
                year: int

            is_typeddict(Film)  # => True
            is_typeddict(Union[list, str])  # => False
        )r��_TYPEDDICT_TYPES�r�r�r�r�r>}sr>r,cCs|S)a�Assert (to the type checker) that the value is of the given type.

        When the type checker encounters a call to assert_type(), it
        emits an error if the value is not of the specified type::

            def greet(name: str) -> None:
                assert_type(name, str)  # ok
                assert_type(name, int)  # type checker error

        At runtime this returns the first argument unchanged and otherwise
        does nothing.
        r�)r�typr�r�r�r,�s
rRcCs
t|tj�rt|j�St|d�r>|jtttfvr>t|j	d�St|tj
�rvtdd�|j	D��}||j	krl|S|�|�Stt
d�r�t|t
j�r�tdd�|j	D��}||j	kr�|St
�|j|�Stt
d��rt|t
j��rtdd�|j	D��}||j	kr�|St�tj|�S|S)	z=Strips Annotated, Required and NotRequired from a given type.rrcss|]}t|�VqdSr���
_strip_extras�r�ar�r�r�r�rz _strip_extras.<locals>.<genexpr>r�css|]}t|�VqdSr�r�r�r�r�r�r�rr�css|]}t|�VqdSr�r�r�r�r�r�r�r)r�r��_AnnotatedAliasr�rr�rSrTrRr�r�r�rr�r�r�r8�reduce�operator�or_)r��
stripped_argsr�r�r�r��s(




r�cCsDtj|||dd�}tjdkr*t||||�|r2|Sdd�|��D�S)a�Return type hints for an object.

        This is often the same as obj.__annotations__, but it handles
        forward references encoded as string literals, adds Optional[t] if a
        default value equal to None is set and recursively replaces all
        'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
        (unless 'include_extras=True').

        The argument may be a module, class, method, or function. The annotations
        are returned as a dictionary. For classes, annotations include also
        inherited members.

        TypeError is raised if the argument is not of a type that can contain
        annotations, and an empty dictionary is returned if no annotations are
        present.

        BEWARE -- the behavior of globalns and localns is counterintuitive
        (unless you are familiar with how eval() and exec() work).  The
        search order is locals first, then globals.

        - If no dict arguments are passed, an attempt is made to use the
          globals from obj (or the respective module's globals for classes),
          and these are also used as the locals.  If the object does not appear
          to have globals, an empty dictionary is used.

        - If one dict argument is passed, it is used for both globals and
          locals.

        - If two dict arguments are passed, they specify globals and
          locals, respectively.
        T)�globalns�localns�include_extrasr�cSsi|]\}}|t|��qSr�r�)r�kr�r�r�r�r��rz"get_type_hints.<locals>.<dictcomp>)r�r;r.r[�_clean_optionalr�)r�r�r�r��hintr�r�r�r;�s �
r;cCs&t|tj�sdS|jdtur"dSdS)z detects Union[..., None] patternFr"T)r�r��_UnionGenericAliasr��	_NoneTyper�r�r�r��_could_be_inserted_optional�s
r�cCs,|rt|t�rdSt�|�}|s$dS|j}|��D]�\}}t|�r2||vs2||durXq2||}|durlt}t|t�r�|dur�t|t	j
�r�|j}n"|}	t|	d�r�|	j
}	q�t|	di�}|dur�|}n|dur�|}t|t|t	j
�d�}t�|||�}
|
|k�stt	d�r2t|
t	j�r2t|t	j�s2|
||<q2dS)N�__wrapped__�__globals__)�is_argumentr�)r�r�r��
_get_defaultsr#r�r�r�r�r��
ModuleTyper&r�r�r�r^�
_eval_typer�)r��hintsr�r�r�Zoriginal_hintsr�rr�original_value�nsobjZoriginal_evaluatedr�r�r�r��sR
�
�

�
�
�
�r�cCs@t|tj�rtSt|tjtjttf�r,|j	S|tj
ur<tj
SdS)a6Get the unsubscripted version of a type.

        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
        and Annotated. Return None for unsupported types. Examples::

            get_origin(Literal[42]) is Literal
            get_origin(int) is None
            get_origin(ClassVar[int]) is ClassVar
            get_origin(Generic) is Generic
            get_origin(Generic[T]) is Generic
            get_origin(Union[T, int]) is Union
            get_origin(List[Tuple[T, T]][int]) == list
            get_origin(P.args) is P
        N)r�r�r�r*�_BaseGenericAliasr�r�rrrrar�r�r�r�r8-s�
r8cCspt|tj�r|jg|j�RSt|tjtjf�rl|j}t	|�t
jjurh|dt
urht|dd��|df}|SdS)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)
        rNr"r�)r�r�r�r�__metadata__r�r�r�r�r8rSr7rZ�Ellipsisr�)r��resr�r�r�r7Esr7rIcCst|�d���dS)a&Special marker indicating that an assignment should
        be recognized as a proper type alias definition by type
        checkers.

        For example::

            Predicate: TypeAlias = Callable[..., bool]

        It's invalid when used anywhere except as in the example above.
        � is not subscriptableNr�r�r�r�r�rI_scs�fdd�|_�|_dS)Ncs�tuSr�)rUr��r4r�r��<lambda>orz_set_default.<locals>.<lambda>)�has_default�__default__)�
type_paramr4r�r�r��_set_defaultnsr�cCstdd�}|dkr||_dS)Nrr9r)r5r�)Ztypevarlike�def_modr�r�r��_set_moduless
r�c@seZdZdZdZeZdS)�
_DefaultMixinzMixin for TypeVarLike defaults.r�N)r�r�r�r�r�r�r�r�r�r�r�r�zsr�c@seZdZeed�dd�ZdS)�_TypeVarLikeMeta)�_TypeVarLikeMeta__instancerQcCst||j�Sr�)r��_backported_typevarlike)r�r�r�r�r�r��sz"_TypeVarLikeMeta.__instancecheck__N)r�r�r�r�boolr�r�r�r�r�r��sr�)rc@s:eZdZdZejZdddedd�dd�Zdd�dd	�Z	dS)
rzType variable.NF)�boundr�r�r4�infer_variancec	s�ttd�r*tj|g|�R||||d���n6tj|g|�R|||d���|rZ|sR|rZtd��|�_t�|�t���fdd�}|�_�S)NrJ�r�r�r�r��r�r�r�z1Variance cannot be specified with infer_variance.cs,���r(|j���t|�kr(|�jf7}|Sr�)r��__parameters__�indexr�r�)�aliasr��Ztypevarr�r��_tvar_prepare_subst�s��z,TypeVar.__new__.<locals>._tvar_prepare_subst)r�r�rr2�__infer_variance__r�r��__typing_prepare_subst__)	r�r�r�r�r�r4r��constraintsr�r�r�r�r��s 
�
�
zTypeVar.__new__rPcCstdt�d���dS)N�type 'z(.TypeVar' is not an acceptable base typerqr�r�r�r�rV�szTypeVar.__init_subclass__)
r�r�r�r�r�rr�rUr�rVr�r�r�r�r�s�rrc@s$eZdZdZdZdd�Zdd�ZdS)�
_Immutablez3Mixin to indicate that object should not be copied.r�cCs|Sr�r�r�r�r�r��__copy__�sz_Immutable.__copy__cCs|Sr�r�)r��memor�r�r��__deepcopy__�sz_Immutable.__deepcopy__N)r�r�r�r�r�r�r�r�r�r�r�r��sr�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	raQThe args for a ParamSpec object.

        Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.

        ParamSpecArgs objects have a reference back to their ParamSpec:

        P.args.__origin__ is P

        This type is meant for runtime introspection and has no special meaning to
        static type checkers.
        cCs
||_dSr��r�r�rr�r�r�r��szParamSpecArgs.__init__cCs|jj�d�S)Nz.args�rr�r�r�r�r�r��szParamSpecArgs.__repr__cCst|t�stS|j|jkSr�)r�rr�rr�r�r�r�r��s
zParamSpecArgs.__eq__N�r�r�r�r�r�r�r�r�r�r�r�r�sc@s(eZdZdZdd�Zdd�Zdd�ZdS)	ra[The kwargs for a ParamSpec object.

        Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.

        ParamSpecKwargs objects have a reference back to their ParamSpec:

        P.kwargs.__origin__ is P

        This type is meant for runtime introspection and has no special meaning to
        static type checkers.
        cCs
||_dSr�rrr�r�r�r��szParamSpecKwargs.__init__cCs|jj�d�S)Nz.kwargsrr�r�r�r�r��szParamSpecKwargs.__repr__cCst|t�stS|j|jkSr�)r�rr�rr�r�r�r�r��s
zParamSpecKwargs.__eq__Nrr�r�r�r�r�sr)r
r
c@s:eZdZdZejZdddded�dd�Zdd�dd	�Z	dS)
r
zParameter specification.NF�r�r�r�r�r4cs`ttd�r tj|||||d��ntj||||d��|�_t�|�t���fdd�}|�_�S)NrJr�r�cs�|j}|���}|t|�kr2���r2g|��j�}|t|�krLtd|����t|�dkrzt�|d�sz|dksrJ�|f}n<t||t	�r�g|d|��t
||��||dd��R}|S)N�Too few arguments for r�r)r�r�r�r�r�r�r��_is_param_exprr�r�r�)r�r�r��i�Z	paramspecr�r��_paramspec_prepare_substs
.z3ParamSpec.__new__.<locals>._paramspec_prepare_subst)r�r�r
r�r�r�r�)r�r�r�r�r�r�r4r	r�rr�r��s 
��
zParamSpec.__new__rPcCstdt�d���dS)Nr�z*.ParamSpec' is not an acceptable base typerqr�r�r�r�rV!szParamSpec.__init_subclass__)
r�r�r�r�r�r
r�rUr�rVr�r�r�r�r
�s�%c@sleZdZdZejZedd��Zedd��Z	dddde
d�d	d
�Zdd�Zd
d�Z
dd�Zdd�Zdd�ZdS)r
a'Parameter specification variable.

        Usage::

           P = ParamSpec('P')

        Parameter specification variables exist primarily for the benefit of static
        type checkers.  They are used to forward the parameter types of one
        callable to another callable, a pattern commonly found in higher order
        functions and decorators.  They are only valid when used in ``Concatenate``,
        or s the first argument to ``Callable``. In Python 3.10 and higher,
        they are also supported in user-defined Generics at runtime.
        See class Generic for more information on generic types.  An
        example for annotating a decorator::

           T = TypeVar('T')
           P = ParamSpec('P')

           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
               '''A type-safe decorator to add logging to a function.'''
               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
                   logging.info(f'{f.__name__} was called')
                   return f(*args, **kwargs)
               return inner

           @add_logging
           def add_two(x: float, y: float) -> float:
               '''Add two numbers together.'''
               return x + y

        Parameter specification variables defined with covariant=True or
        contravariant=True can be used to declare covariant or contravariant
        generic types.  These keyword arguments are valid, but their actual semantics
        are yet to be decided.  See PEP 612 for details.

        Parameter specification variables can be introspected. e.g.:

           P.__name__ == 'T'
           P.__bound__ == None
           P.__covariant__ == False
           P.__contravariant__ == False

        Note that only parameter specification variables defined in global scope can
        be pickled.
        cCst|�Sr�)rr�r�r�r�r�ZszParamSpec.argscCst|�Sr�)rr�r�r�r�r�^szParamSpec.kwargsNFrcCspt�||g�||_t|�|_t|�|_t|�|_|rFt�|d�|_	nd|_	t
�||�t�}|dkrl||_dS)NzBound must be a type.r)
r�r�r�r��
__covariant__�__contravariant__r�r�r
�	__bound__r�r5r�)r�r�r�r�r�r�r4r�r�r�r�r�bs


zParamSpec.__init__cCs2|jrd}n|jrd}n|jr$d}nd}||jS)N��+�-�~)r�r
rr�)r��prefixr�r�r�r�tszParamSpec.__repr__cCs
t�|�Sr��rr�r�r�r�r�r�szParamSpec.__hash__cCs||uSr�r�r�r�r�r�r��szParamSpec.__eq__cCs|jSr��r�r�r�r�r�r��szParamSpec.__reduce__cOsdSr�r�r<r�r�r�r��szParamSpec.__call__)r�r�r�r�r�rr��propertyr�r�rUr�r�r�r�r�r�r�r�r�r�r
(s/

�r�
_type_convert)�allow_special_formscCsT|durtd�St|t�rPtjdkr,t|�StjdkrBt||d�St|||d�S|S)z=For converting None to type(None), and strings to ForwardRef.N)r�	�)rr�r�)rz�is_class)r�r�r�r.r[r^)r?rzrr�r�r�r�s


csVeZdZejZ�fdd�Zdd�Zdd�Zdd�Z	e
d	d
��Zdd�Zd
d�Z
�ZS)�_ConcatenateGenericAliascst��|�||_||_dSr�)r�r�rr�)r�rr�r�r�r�r��sz!_ConcatenateGenericAlias.__init__cs2tj��|j��dd��fdd�|jD���d�S)N�[�, c3s|]}�|�VqdSr�r��rr?��
_type_reprr�r�r�rz4_ConcatenateGenericAlias.__repr__.<locals>.<genexpr>�])r�r r�joinr�r�r�rr�r��s�z!_ConcatenateGenericAlias.__repr__cCst|j|jf�Sr�)r�rr�r�r�r�r�r��sz!_ConcatenateGenericAlias.__hash__cOsdSr�r�r<r�r�r�r��sz!_ConcatenateGenericAlias.__call__cCstdd�|jD��S)Ncss"|]}t|tjtf�r|VqdSr�)r�r�rr
)rr�r�r�r�r�sz:_ConcatenateGenericAlias.__parameters__.<locals>.<genexpr>)r�r�r�r�r�r�r��s�z'_ConcatenateGenericAlias.__parameters__cCs�t|dt�r,g|dd��|dj�R}nNt|dttf�rXg|dd��|d�RS|dduszt|dt�sztd��|�|j|�S�Nr".�MThe last parameter to Concatenate should be a ParamSpec variable or ellipsis.)	r�rr�r�r�r
r�r�r�r�r�r�r�r�r�s�"_ConcatenateGenericAlias.copy_withc	s�|jttfvrtd|����|js0t|�d���t|t�s@|f}tdd�|D��}|j}|D]�}t|dd�}|dur�|||�}q\t|t	�r\|�
|�}|t|�kr�t|dt�tur�g|�|j
�}|t|�kr�td|����t|�dk�r
t|d	��s
|d	k�sJ�|f}q\t||t�r\t||t�s\g|d|��t||��||dd��R}q\t|�}t|�}||k�r�td
||k�r�dnd�d
|�d|�d|����tt|j|���g}|jD]�}	t|	t��r�|�|	��q�t|	t��r:�|	}	t|	tj��rt|	��s*ttd��r�t|	tj��r�t|	dd��r�t|	�d���nPt|	ttd��sPtjn
tjtjf��r�|	j}
|
�r�t�fdd�|
D��}|	|}	|�|	��q�|�t|��S)Nz%Cannot subscript already-subscripted rcss|]}t|�VqdSr�)rrr�r�r�r�r�7_ConcatenateGenericAlias.__getitem__.<locals>.<genexpr>r�r�rr�rrrrrrrr��__unpacked__Fz is not valid as type argumentc3s|]}�|VqdSr�r�)r�x��substr�r�rr)rrarCr�r�r�r��_unpack_argsr�r
r�r�rUr�rr�rr��zipr�r�r�rr�r��
_is_unpackr�r�r�r)r�r�r��param�preparer�alen�plen�new_argsr?�	subparams�subargsr�r*r�r��s�



����0
���


���
�
��

��$_ConcatenateGenericAlias.__getitem__)r�r�r�r�r�r�r�r�r�r�rr�rr�r�r�r�r�r�r�s
rcs,eZdZdZ�fdd�Z�fdd�Z�ZS)rr�cs�t|dttf�r,g|dd��|d�RSt|dtj�rZg|dd��|dj�R}n"|ddus|t|dt�s|td��ttj|��	|�Sr#)
r�r�r�r�rr�r
r�r�rr%r�r�r�r sr&csBt��|�}t|t�r>tdd�|D��r>ttdd�|D���S|S)Ncss|]}t|�VqdSr��r.�rr�r�r�r�r,rr'css|]
}|VqdSr�r��rr�r�r�r�r-r)r�r�r�r�rWr,)r�r�rrr�r�r�r�*sr6)r�r�r�rr�r�r�r�r�r�rs
c@seZdZdS)�_EllipsisDummyN)r�r�r�r�r�r�r�r:2rr:cCs�|ddur,tjdkr,g|dd��t�R}tjdkrLt||ttfdd�}n
t||�}|dturf|Stdd�|jD��|_tjd	kr�|Std
d�|jD��|_|S)Nr".)rrr)rr�rT)Z_typevar_typesZ_paramspec_tvarscss|]}|tur|ndVqdS).N�r:rr�r�r�rCs�z,_create_concatenate_alias.<locals>.<genexpr>r�css|]}|tur|VqdSr�r;rr�r�r�rHs�)	r.r[r:rrr
r�r�r�)rr�Zconcatenater�r�r��_create_concatenate_alias6s"
�
�

r<csx|dkrtd��t|t�s |f}|ddusBt|dt�sBtd��d�g�fdd�|dd�D��|d�R}t||�S)	Nr�z&Cannot take a Concatenate of no types.r".r$z/Concatenate[arg, ...]: each arg must be a type.c3s|]}t�|��VqdSr�r	rr
r�r�rXrz'_concatenate_getitem.<locals>.<genexpr>)r�r�r�r
r<r�r�r
r��_concatenate_getitemNs
�r=cCs
t||�S)a&Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
        higher order function which adds, removes or transforms parameters of a
        callable.

        For example::

           Callable[Concatenate[int, P], int]

        See PEP 612 for detailed information.
        )r=r�r�r�r�rcsrLcCs t�||�d��}t�||f�S)a	Special typing form used to annotate the return type of a user-defined
        type guard function.  ``TypeGuard`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.

        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".

        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
        return type to alert static type checkers to this intention.

        Using  ``-> TypeGuard`` tells the static type checker that for a given
        function:

        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the type inside ``TypeGuard``.

        For example::

            def is_str(val: Union[str, float]):
                # "isinstance" type guard
                if isinstance(val, str):
                    # Type of ``val`` is narrowed to ``str``
                    ...
                else:
                    # Else, type of ``val`` is narrowed to ``float``.
                    ...

        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
        form of ``TypeA`` (it can even be a wider form) and this may lead to
        type-unsafe results.  The main reason is to allow for things like
        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
        a subtype of the former, since ``List`` is invariant.  The responsibility of
        writing type-safe type guards is left to the user.

        ``TypeGuard`` also works with type variables.  For more information, see
        PEP 647 (User-Defined Type Guards).
        � accepts only a single type.�r�r
r��r�r�r�r�r�r�rLws,rMcCs t�||�d��}t�||f�S)awSpecial typing form used to annotate the return type of a user-defined
        type narrower function.  ``TypeIs`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.

        ``TypeIs`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".

        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeIs[...]`` as its
        return type to alert static type checkers to this intention.

        Using  ``-> TypeIs`` tells the static type checker that for a given
        function:

        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the intersection of the type inside ``TypeIs`` and the argument's
        previously known type.

        For example::

            def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]:
                return hasattr(val, '__await__')

            def f(val: Union[int, Awaitable[int]]) -> int:
                if is_awaitable(val):
                    assert_type(val, Awaitable[int])
                else:
                    assert_type(val, int)

        ``TypeIs`` also works with type variables.  For more information, see
        PEP 742 (Narrowing types with TypeIs).
        r>r?r@r�r�r�rM�s&rKc@seZdZdd�ZdS)�
_TypeFormFormcCs|Sr�r�r�r�r�r�r��sz_TypeFormForm.__call__N)r�r�r�r�r�r�r�r�rA�srAcCs t�||�d��}t�||f�S)a�A special form representing the value that results from the evaluation
        of a type expression. This value encodes the information supplied in the
        type expression, and it represents the type described by that type expression.

        When used in a type expression, TypeForm describes a set of type form objects.
        It accepts a single type argument, which must be a valid type expression.
        ``TypeForm[T]`` describes the set of all type form objects that represent
        the type T or types that are assignable to T.

        Usage:

            def cast[T](typ: TypeForm[T], value: Any) -> T: ...

            reveal_type(cast(int, "x"))  # int

        See PEP 747 for more information.
        r>r?r@r�r�r�rK�sr	cCst|�d���dS)aDRepresents an arbitrary literal string.

        Example::

          from typing_extensions import LiteralString

          def query(sql: LiteralString) -> ...:
              ...

          query("SELECT * FROM table")  # ok
          query(f"SELECT * FROM {input()}")  # not ok

        See PEP 675 for details.

        r�Nr�r%r�r�r�r	�sr
cCst|�d���dS)z�Used to spell the type of "self" in classes.

        Example::

          from typing import Self

          class ReturnsSelf:
              def parse(self, data: bytes) -> Self:
                  ...
                  return self

        r�Nr�r%r�r�r�r
	srPcCst|�d���dS)a�The bottom type, a type that has no members.

        This can be used to define a function that should never be
        called, or a function that never returns::

            from typing_extensions import Never

            def never_call_me(arg: Never) -> None:
                pass

            def int_or_str(arg: int | str) -> None:
                never_call_me(arg)  # type checker error
                match arg:
                    case int():
                        print("It's an int")
                    case str():
                        print("It's a str")
                    case _:
                        never_call_me(arg)  # ok, arg is of type Never

        r�Nr�r%r�r�r�rP)	srScCs"t�||j�d��}t�||f�S)a�A special typing construct to mark a key of a total=False TypedDict
        as required. For example:

            class Movie(TypedDict, total=False):
                title: Required[str]
                year: int

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )

        There is no runtime checking that a required key is actually provided
        when instantiating a related TypedDict.
        r>�r�r
r�r�r@r�r�r�rSH	scCs"t�||j�d��}t�||f�S)a`A special typing construct to mark a key of a TypedDict as
        potentially missing. For example:

            class Movie(TypedDict):
                title: str
                year: NotRequired[int]

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
        r>rBr@r�r�r�rT\	srTcCs"t�||j�d��}t�||f�S)a�A special typing construct to mark an item of a TypedDict as read-only.

        For example:

            class Movie(TypedDict):
                title: ReadOnly[str]
                year: int

            def mutate_movie(m: Movie) -> None:
                m["year"] = 1992  # allowed
                m["title"] = "The Matrix"  # typechecker error

        There is no runtime checking for this property.
        r>rBr@r�r�r�rRq	sa�Type unpack operator.

The type unpack operator takes the child types from some container type,
such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'. For
example:

  # For some generic class `Foo`:
  Foo[Unpack[tuple[int, str]]]  # Equivalent to Foo[int, str]

  Ts = TypeVarTuple('Ts')
  # Specifies that `Bar` is generic in an arbitrary number of types.
  # (Think of `Ts` as a tuple of an arbitrary number of individual
  #  `TypeVar`s, which the `Unpack` is 'pulling out' directly into the
  #  `Generic[]`.)
  class Bar(Generic[Unpack[Ts]]): ...
  Bar[int]  # Valid
  Bar[int, str]  # Also valid

From Python 3.11, this can also be done using the `*` operator:

    Foo[*tuple[int, str]]
    class Bar(Generic[*Ts]): ...

The operator can also be used along with a `TypedDict` to annotate
`**kwargs` in a function signature. For instance:

  class Movie(TypedDict):
    name: str
    year: int

  # This function expects two keyword arguments - *name* of type `str` and
  # *year* of type `int`.
  def foo(**kwargs: Unpack[Movie]): ...

Note that there is only some runtime checking of this operator. Not
everything the runtime allows may be accepted by static type checkers.

For more information, see PEP 646 and PEP 692.
cCst|�tuSr�)r8r�r�r�r�r�r.�	sr.cseZdZ�fdd�Z�ZS)�_UnpackSpecialFormcst��|�t|_dSr�)r�r��_UNPACK_DOCr�r�r�r�r�r��	sz_UnpackSpecialForm.__init__)r�r�r�r�r�r�r�r�r�rD�	srDcsDeZdZejdkrejZedd��Z	edd��Z
�fdd�Z�ZS)�_UnpackAliasr�cCsV|jtusJ�t|j�dks J�|j\}t|tjtjf�rR|jt	urLt
d��|jSdS)Nr�z*Unpack[...] must be used with a tuple type)rrr�r�r�r�r�r�r�r�r�)r�r?r�r�r��__typing_unpacked_tuple_args__�	s
z+_UnpackAlias.__typing_unpacked_tuple_args__cCs0|jtusJ�t|j�dks J�t|jdt�S)Nr�r)rrr�r�r�rr�r�r�r��#__typing_is_unpacked_typevartuple__�	sz0_UnpackAlias.__typing_is_unpacked_typevartuple__cs|jr
|St��|�Sr�)rHr�r�r�r�r�r�r��	sz_UnpackAlias.__getitem__)
r�r�r�r.r[r�rr�rrGrHr�r�r�r�r�r�rF�	s



rFcCs t�||j�d��}t||f�S)Nr>)r�r
r�rFr@r�r�r�r�	srcCs
t|t�Sr�)r�rFrCr�r�r�r.�	scGsLg}|D]>}t|dd�}|dur<|r0|ddus<|�|�q|�|�q|S)NrGr".)r�r�r�)r�Znewargsr?r5r�r�r�r,�	sr,)rrc@s,eZdZdZejZed�dd�Zdd�Z	dS)rzType variable tuple.r�cs2t�|��t�|�t���fdd�}|�_�S)Ncs�|j}|���}||dd�D]}t|t�r td|����q t|�}t|�}|}||d}d}	d}
t|�D]V\}}t|t�snt|dd�}
|
rnt|
�dkrn|
ddurn|	dur�td��|}	|
d}
qn|	dur�t	||	�}t	|||	d�}n,|||k�rtd	|�d
|�d|d����|||k�r<��
��r<t�j�}n||||�}g|d|��|
g||�|�|
g||||d�|||d��RS)Nr�z(More than one TypeVarTuple parameter in rGrr".z6More than one unpacked arbitrary-length tuple argumentrrrz, expected at least )
r�r�r�rr�r��	enumerater�r��minr�r,r�)r�r�r�Ztypevartuple_indexr/r1r2�left�rightZvar_tuple_indexZfillargr�r?r5�replacement�Ztvtr�r��_typevartuple_prepare_subst�	s\

�
�


��
�����z9TypeVarTuple.__new__.<locals>._typevartuple_prepare_subst)r�rr�r�r�)r�r�r4rOr�rNr�r��	s

-zTypeVarTuple.__new__cOstd��dS)N�&Cannot subclass special typing classesr�r�r�r�r�rV,
s�TypeVarTuple.__init_subclass__N)
r�r�r�r�r�rr�rUr�rVr�r�r�r�r�	s5c@sTeZdZdZejZdd�Zed�dd�Z	dd�Z
d	d
�Zdd�Zd
d�Z
dd�ZdS)ra�Type variable tuple.

        Usage::

            Ts = TypeVarTuple('Ts')

        In the same way that a normal type variable is a stand-in for a single
        type such as ``int``, a type variable *tuple* is a stand-in for a *tuple*
        type such as ``Tuple[int, str]``.

        Type variable tuples can be used in ``Generic`` declarations.
        Consider the following example::

            class Array(Generic[*Ts]): ...

        The ``Ts`` type variable tuple here behaves like ``tuple[T1, T2]``,
        where ``T1`` and ``T2`` are type variables. To use these type variables
        as type parameters of ``Array``, we must *unpack* the type variable tuple using
        the star operator: ``*Ts``. The signature of ``Array`` then behaves
        as if we had simply written ``class Array(Generic[T1, T2]): ...``.
        In contrast to ``Generic[T1, T2]``, however, ``Generic[*Shape]`` allows
        us to parameterise the class with an *arbitrary* number of type parameters.

        Type variable tuples can be used anywhere a normal ``TypeVar`` can.
        This includes class definitions, as shown above, as well as function
        signatures and variable annotations::

            class Array(Generic[*Ts]):

                def __init__(self, shape: Tuple[*Ts]):
                    self._shape: Tuple[*Ts] = shape

                def get_shape(self) -> Tuple[*Ts]:
                    return self._shape

            shape = (Height(480), Width(640))
            x: Array[Height, Width] = Array(shape)
            y = abs(x)  # Inferred type is Array[Height, Width]
            z = x + x   #        ...    is Array[Height, Width]
            x.get_shape()  #     ...    is tuple[Height, Width]

        ccs|jVdSr�)r(r�r�r�r��__iter___
szTypeVarTuple.__iter__r�cCs4||_t�||�t�}|dkr&||_t||_dS)Nr)r�r�r�r5r�rr()r�r�r4r�r�r�r�r�b
szTypeVarTuple.__init__cCs|jSr�rr�r�r�r�r�m
szTypeVarTuple.__repr__cCs
t�|�Sr�rr�r�r�r�r�p
szTypeVarTuple.__hash__cCs||uSr�r�r�r�r�r�r�s
szTypeVarTuple.__eq__cCs|jSr�rr�r�r�r�r�v
szTypeVarTuple.__reduce__cOsd|vrtd��dS)Nr�rPr�r�r�r�r�rVy
srQN)r�r�r�r�r�rr�rRrUr�r�r�r�r�rVr�r�r�r�r0
s,rE)r�rQcCstdt|�j��tjd�|S)a�Reveal the inferred type of a variable.

        When a static type checker encounters a call to ``reveal_type()``,
        it will emit the inferred type of the argument::

            x: int = 1
            reveal_type(x)

        Running a static type checker (e.g., ``mypy``) on this example
        will produce output similar to 'Revealed type is "builtins.int"'.

        At runtime, the function prints the runtime type of the
        argument and returns it unchanged.

        zRuntime type is )�file)�printr�r�r.�stderrrCr�r�r�rE�
s�_ASSERT_NEVER_REPR_MAX_LENGTH�dr+�r?rQcCs6t|�}t|�tkr$|dt�d}td|����dS)a1Assert to the type checker that a line of code is unreachable.

        Example::

            def int_or_str(arg: int | str) -> None:
                match arg:
                    case int():
                        print("It's an int")
                    case str():
                        print("It's a str")
                    case _:
                        assert_never(arg)

        If a type checker finds that a call to assert_never() is
        reachable, it will emit an error.

        At runtime, this throws an exception when called.

        N�...z*Expected code to be unreachable, but got: )�reprr�rV�AssertionError)r?rrr�r�r�r+�
s)�
eq_default�
order_default�kw_only_default�frozen_default�field_specifiers.)r\r]r^r_r`r�rQcs������fdd�}|S)a�Decorator that marks a function, class, or metaclass as providing
        dataclass-like behavior.

        Example:

            from typing_extensions import dataclass_transform

            _T = TypeVar("_T")

            # Used on a decorator function
            @dataclass_transform()
            def create_model(cls: type[_T]) -> type[_T]:
                ...
                return cls

            @create_model
            class CustomerModel:
                id: int
                name: str

            # Used on a base class
            @dataclass_transform()
            class ModelBase: ...

            class CustomerModel(ModelBase):
                id: int
                name: str

            # Used on a metaclass
            @dataclass_transform()
            class ModelMeta(type): ...

            class ModelBase(metaclass=ModelMeta): ...

            class CustomerModel(ModelBase):
                id: int
                name: str

        Each of the ``CustomerModel`` classes defined in this example will now
        behave similarly to a dataclass created with the ``@dataclasses.dataclass``
        decorator. For example, the type checker will synthesize an ``__init__``
        method.

        The arguments to this decorator can be used to customize this behavior:
        - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
          True or False if it is omitted by the caller.
        - ``order_default`` indicates whether the ``order`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``kw_only_default`` indicates whether the ``kw_only`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``frozen_default`` indicates whether the ``frozen`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``field_specifiers`` specifies a static list of supported classes
          or functions that describe fields, similar to ``dataclasses.field()``.

        At runtime, this decorator records its arguments in the
        ``__dataclass_transform__`` attribute on the decorated object.

        See PEP 681 for details.

        cs������d�|_|S)N)r\r]r^r_r`r�)Z__dataclass_transform__)Z	cls_or_fn�r\r`r_r^r�r]r�r��	decorators�z&dataclass_transform.<locals>.decoratorr�)r\r]r^r_r`r�rbr�rar�r.�
sI
r.rB�_F)r�c	Cs&z
d|_Wnttfy Yn0|S)aHIndicate that a method is intended to override a method in a base class.

        Usage:

            class Base:
                def method(self) -> None:
                    pass

            class Child(Base):
                @override
                def method(self) -> None:
                    super().method()

        When this decorator is applied to a method, the type checker will
        validate that it overrides a method with the same name on a base class.
        This helps prevent bugs that may occur when a base class is changed
        without an equivalent change to a child class.

        There is no runtime checking of these properties. The decorator
        sets the ``__override__`` attribute to ``True`` on the decorated object
        to allow runtime introspection.

        See PEP 698 for details.

        T)Z__override__r�r�r>r�r�r�rBs

)rr|r�_Tc@sHeZdZdZedd�eejeje	e
dd�dd�Zeed�d	d
�Z
dS)r/aIndicate that a class, function or overload is deprecated.

        When this decorator is applied to an object, the type checker
        will generate a diagnostic on usage of the deprecated object.

        Usage:

            @deprecated("Use B instead")
            class A:
                pass

            @deprecated("Use g instead")
            def f():
                pass

            @overload
            @deprecated("int support is deprecated")
            def g(x: int) -> int: ...
            @overload
            def g(x: str) -> int: ...

        The warning specified by *category* will be emitted at runtime
        on use of deprecated objects. For functions, that happens on calls;
        for classes, on instantiation and on creation of subclasses.
        If the *category* is ``None``, no warning is emitted at runtime.
        The *stacklevel* determines where the
        warning is emitted. If it is ``1`` (the default), the warning
        is emitted at the direct caller of the deprecated object; if it
        is higher, it is emitted further up the stack.
        Static type checker behavior is not affected by the *category*
        and *stacklevel* arguments.

        The deprecation message passed to the decorator is saved in the
        ``__deprecated__`` attribute on the decorated object.
        If applied to an overload, the decorator
        must be after the ``@overload`` decorator for the attribute to
        exist on the overload as returned by ``get_overloads()``.

        See PEP 702 for details.

        r���categoryr�N)�messagerfr�rQcCs4t|t�stdt|�j����||_||_||_dS)Nz2Expected an object of type str for 'message', not )r�r�r�r�r�rgrfr�)r�rgrfr�r�r�r�r�ms
��zdeprecated.__init__rXc	sv|j�|j�|j��dur$��_�St�t�r�ddl}ddlm}�j	�|�
�������fdd��}t|��_	�j�t�|�r��j
�|�
������fdd��}t|��_n"|�
������fdd��}|�_��_|_�|_�St���rdddl}ddl}ddl}|�
������fdd	��}|j����rTtjd
k�rJ|�|�}n
|jj|_��_|_|Std�����dS)Nr)�
MethodTypecsn|�urtj���dd��tjur<�|g|�Ri|��S|jtjurb|sP|rbt|j�d���n�|�SdS)Nr�rez() takes no arguments)r�r�rr�r�r�r�r�)r?rfr�original_newr�r�r�r��s
z$deprecated.__call__.<locals>.__new__cs"tj���dd��|i|��S�Nr�re�r�r��r�r��rfr�original_init_subclassr�r�r�rV�sz.deprecated.__call__.<locals>.__init_subclass__cs"tj���dd��|i|��Srjrkrlrmr�r�rV�scs"tj���dd��|i|��Srjrkrl)r?rfrr�r�r��wrapper�sz$deprecated.__call__.<locals>.wrapperr_zY@deprecated decorator with non-None category must be applied to a class or callable, not )rgrfr�Z__deprecated__r�r�r8�typesrhr��wraps�staticmethodrVr��classmethodr\Zasyncio.coroutinesrL�
coroutines�iscoroutinefunctionr.r[Zmarkcoroutinefunction�
_is_coroutiner�)	r�r?r8rhr�rV�asynciorLror�)r?rfrrnrir�r�r�~sT




��zdeprecated.__call__)r�r�r�r�r�r�r�ror�WarningrRr�rdr�r�r�r�r�r/Cs.��r/cCs|dupt|ttttf�S�N.)r�r�r�r
rr>r�r�r�r�s
�rcCs|dupt|tttttjf�Sry)r�r�r�r
rr�r>r�r�r�r�s
��cCszt�|�rHt|tj�rHt|j�dkrHt|jdt�rH|rHt	|d�sHdS|sZt
|�d���|tur�t|d�rr|js�t
|�d���t|j�}t|�}||k�rv|}t|d��r.dd�|jD�}t
dd	�|D��}|dkr�|||kr�dS||k�r.t||d
t�tu�r
dSt
dd	�|D��}||8}d|��}tjd
k�r>dnd}t
d||k�rTdnd�d|�d|�d|�d|��
��dS)��Check correct count for parameters of a generic cls (internal helper).

        This gives a nice error message in case of count mismatch.
        r�rNrr�cSsg|]}t|�s|�qSr�r7rr�r�r��
<listcomp>r�"_check_generic.<locals>.<listcomp>css|]}t|t�VqdSr�)r�rrr�r�r�rr�!_check_generic.<locals>.<genexpr>r�css|]}t|dt�tuVqdS�r�N�r�rUrr�r�r�rs�
�rr��	argumentsr�rrr� z for rr)rL�isclassrZr�rar�r�r�r
rr�r�r��sumr�rUr.r[)r�r��elenr1�
expect_valZ
num_tv_tuples�num_default_tvZthingsr�r�r��_check_generic�sV���
�


���
���r�c	Cs�|st|�d���t|�}||kr�|}t|d�r�dd�|jD�}||kr�t||dt�tur`dStdd�|D��}||8}d	|��}td
||kr�dnd�d
|�d|�d|����dS)rzrr�cSsg|]}t|�s|�qSr�r7rr�r�r�r{,rr|r�Ncss|]}t|dt�tuVqdSr~rrr�r�r�r9s�
�r}rrrrrrr)r�r�r�r�r�rUr�)r�r�r�r1r�r�r�r�r�r�!s2
���
���rPc	Cshzt�d�}Wnttfy&YdS0|j�d�dkr<dS|j�d�}|tjupb|t	upb|tj	uSdS)NrFr�r�r)
r.r/r�r2r0r1�f_localsr�rarC)�framerr�r�r��"_has_generic_or_protocol_as_originGsr�cCs<t|�turdSt|�}t|�o:t|�dko:t|d�tvS)NFr�r)r8rr7r�r�r��_TYPEVARTUPLE_TYPES)r)r�r�r�r��_is_unpacked_typevartuple]s
��r��_collect_type_varsc	s�|durtj}g�t�}d}d}|D]�}t|�r6d}ndt||�r�t|t�s�|�vr�|r�t|dt�tu}|r||rvtd��d}n|r�td|�d�����	|�t
|�r����fdd	�|jD��q$t|t
�r$|D]&}t|g�D]}|�vrڈ�	|�q�q�q$t
��S)
z�Collect all type variable contained in types in order of
        first appearance (lexicographic order). For example::

            _collect_type_vars((T, List[S, T])) == (T, S)
        NFTr��2Type parameter with a default follows TypeVarTuple�Type parameter �8 without a default follows type parameter with a defaultcsg|]}|�vr|�qSr�r�r8��tvarsr�r�r{�rz&_collect_type_vars.<locals>.<listcomp>)r�rr�r�r�rFr�rUr�r�r�r�r�r�r�)	rpZ
typevar_types�enforce_default_ordering�default_encountered�type_var_tuple_encounteredr�r�r)�	collectedr�r�r�r�js@���

c	Cs�g}t�}d}d}|D]�}t|t�r&qt|t�r^|D]&}t|g�D]}||vrB|�|�qBq4qt|d�r�||vr�|r�t|dt�tu}|r�|r�t	d��|r�d}n|r�t	d|�d���|�|�qt
|�r�d}t|dd	�D]}||vr�|�|�q�qt|�S)
z�Collect all type variables and parameter specifications in args
        in order of first appearance (lexicographic order).

        For example::

            assert _collect_parameters((T, Callable[P, T])) == (T, P)
        FZ__typing_subst__r�r�Tr�r�r�r�)r�r�r�r��_collect_parametersr�r�r�rUr�r�)	r�r�r�r�r�r�r)r�r�r�r�r�r��s<


�r�cCs@dd�|D�}dd�|D�}tj||||d�}||_|j_|S)NcSsg|]\}}|�qSr�r��rr�r�r�r�r�r{�rz!_make_nmtuple.<locals>.<listcomp>c	Ss&i|]\}}|t�|d|�d���qS)zfield z annotation must be a typer	r�r�r�r�r��s�z!_make_nmtuple.<locals>.<dictcomp>�r�rz)rS�
namedtupler#r�)r�rprzr�r�r+�nm_tplr�r�r��
_make_nmtuple�s��r�>r�r#r�c@seZdZdd�ZdS)�_NamedTupleMetacs0t|vsJ�|D]}|tur|tjurtd��qtdd�|D��}d�vrT�d}nd�vrj�dd�}ni}g}|D]L}|�vr�|�|�qv|rvtd|�dt|�dkr�d	nd
�dd�|�����qvt||�	��fd
d�|D��dd�}||_
tj|v�r*ttd��rttj
�|_ntjjj}	t|	�|_��	�D]�\}
}|
tv�rRtd|
��n�|
tv�r2|
|jv�rxt||
�|
�zt|�j}Wnt�y�Ynz0z||||
�Wnft�y}
zLdt|�j�d|
�d|��}tjdk�r�|
�|��n
t|�|
�WYd}
~
n
d}
~
00�q2tj|v�r,|��|S)Nz3can only inherit from a NamedTuple type and Genericcss|]}|turtn|VqdSr�)�_NamedTupler�)rr*r�r�r�r�rz*_NamedTupleMeta.__new__.<locals>.<genexpr>r#r�r�zNon-default namedtuple field z cannot follow default field�sr
r�rcsg|]}�|�qSr�r�r9�r�r�r�r{
rz+_NamedTupleMeta.__new__.<locals>.<listcomp>r�r��_generic_class_getitemz&Cannot overwrite NamedTuple attribute zError calling __set_name__ on z
 instance z in r_)r�r�rar�r�r�r�r"r�r�rXr�rsr��__class_getitem__r��_prohibited_namedtuple_fieldsr��_special_namedtuple_fields�_fieldsrr��__set_name__�
BaseExceptionr�r.r[Zadd_note�RuntimeErrorrV)r�r�r�r�r*rp�
default_names�
field_namer�Z
class_getitem�keyr�set_namer^rr�r�r�r��sv�

��
�



���

$z_NamedTupleMeta.__new__N)r�r�r�r�r�r�r�r�r��sr�rcCst|vsJ�tfSr�)rr�)r�r�r�r��_namedtuple_mro_entries5
sr�cKs�|tur:|rd}d}q�d}d|�d|�d�}d|d}nF|d	urt|rPtd
��q�d}d|�d|�d�}d|d}n|r�td��|tus�|d	ur�tj|j|d
d�tdd�|��}t||t�d�}t	f|_
|S)aoTyped version of namedtuple.

        Usage::

            class Employee(NamedTuple):
                name: str
                id: int

        This is equivalent to::

            Employee = collections.namedtuple('Employee', ['name', 'id'])

        The resulting class has an extra __annotations__ attribute, giving a
        dict that maps field names to types.  (The field names are also in
        the _fields attribute, which is part of the namedtuple API.)
        An alternative equivalent functional syntax is also accepted::

            Employee = NamedTuple('Employee', [('name', str), ('id', int)])
        z3Creating NamedTuple classes using keyword argumentszq{name} is deprecated and will be disallowed in Python {remove}. Use the class-based or functional syntax instead.r�r�z = NamedTuple(z, [])`z�{name} is deprecated and will be disallowed in Python {remove}. To create a NamedTuple class with 0 fields using the functional syntax, pass an empty list, e.g. rINz\Cannot pass `None` as the 'fields' parameter and also specify fields using keyword argumentsr�zIEither list of fields or keywords can be provided to NamedTuple, not bothz3.15)r�r�rr�r�)r�r�r�r�r�r�r�r�r5rr�)r�r�r�r�r�r��ntr�r�r�r9
sH�������c@seZdZdZdS)ra�Base class for classes that implement the buffer protocol.

        The buffer protocol allows Python objects to expose a low-level
        memory buffer interface. Before Python 3.12, it is not possible
        to implement the buffer protocol in pure Python code, or even
        to check whether a class implements the buffer protocol. In
        Python 3.12 and higher, the ``__buffer__`` method allows access
        to the buffer protocol from Python code, and the
        ``collections.abc.Buffer`` ABC allows checking whether a class
        implements the buffer protocol.

        To indicate support for the buffer protocol in earlier versions,
        inherit from this ABC, either in a stub file or at runtime,
        or use ABC registration. This ABC provides no methods, because
        there is no Python-accessible methods shared by pre-3.12 buffer
        classes. It is useful primarily for static checks.

        N)r�r�r�r�r�r�r�r�r�
sr9cCs@z|j�d|j�WSty:tdt|�j���d�Yn0dS)aReturn the class's "original" bases prior to modification by `__mro_entries__`.

        Examples::

            from typing import TypeVar, Generic
            from typing_extensions import NamedTuple, TypedDict

            T = TypeVar("T")
            class Foo(Generic[T]): ...
            class Bar(Foo[int], float): ...
            class Baz(list[str]): ...
            Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
            Spam = TypedDict("Spam", {"a": int, "b": str})

            assert get_original_bases(Bar) == (Foo[int], float)
            assert get_original_bases(Baz) == (list[str],)
            assert get_original_bases(Eggs) == (NamedTuple,)
            assert get_original_bases(Spam) == (TypedDict,)
            assert get_original_bases(int) == (object,)
        r�z"Expected an instance of type, not N)r&r1rXr�r�r�r�r�r�r�r�r9�
s��c@sReZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Ze	j
dkrNd
d�Zdd�ZdS)r@aLNewType creates simple unique types with almost zero
        runtime overhead. NewType(name, tp) is considered a subtype of tp
        by static type checkers. At runtime, NewType(name, tp) returns
        a dummy callable that simply returns its argument. Usage::
            UserId = NewType('UserId', int)
            def name_by_id(user_id: UserId) -> str:
                ...
            UserId('user')          # Fails type check
            name_by_id(42)          # Fails type check
            name_by_id(UserId(42))  # OK
            num = UserId(5) + 1     # type: int
        cCs|Sr�r�r�r�r�r�r��
szNewType.__call__cCs@||_d|vr|�d�d}||_||_t�}|dkr<||_dS)NrIr"r)r��
rpartitionr��
__supertype__r5r�)r�r�r�r�r�r�r�r��
szNewType.__init__cs|j�G�fdd�d�}|fS)NcseZdZ�fdd�ZdS)z&NewType.__mro_entries__.<locals>.Dummycs&|j}td|�d|�d��d���dS)NzGCannot subclass an instance of NewType. Perhaps you were looking for: `z = NewType(rz)`)r�r�)r�Zsubcls_name�Z
supercls_namer�r�rV�
s����z8NewType.__mro_entries__.<locals>.Dummy.__init_subclass__N)r�r�r�rVr�r�r�r��Dummy�
sr�r)r�r�r�r�r�r�r��
s	zNewType.__mro_entries__cCs|j�d|j��S)NrI)r�r�r�r�r�r�r��
szNewType.__repr__cCs|jSr�)r�r�r�r�r�r��
szNewType.__reduce__r�cCstj||fSr�r�r�r�r�r�r��
szNewType.__or__cCstj||fSr�r�r�r�r�r�r��
szNewType.__ror__N)
r�r�r�r�r�r�r�r�r�r.r[r�r�r�r�r�r�r@�
s


r@cCs"|dup t|ttjtjtjtf�S�z:Corresponds to is_unionable() in unionobject.c in CPython.N)r�r�r�r�r�r�rJrCr�r�r��
_is_unionables�r�cCs|dupt|ttjtjtf�Sr�)r�r�r�r�r�rJrCr�r�r�r�s�>rXrr��
__reduce_ex__r�rGr�r(r�r�r�r�c@seZdZdd�ZdS)�_TypeAliasGenericAliascCs |tvrt�||�St|j|�Sr�)� _ATTRIBUTE_DELEGATION_EXCLUSIONSrr�r�r)r�r�r�r�r�r�.sz"_TypeAliasGenericAlias.__getattr__N)r�r�r�r�r�r�r�r�r�-sr�cs�eZdZdZdd�ed�dd�Zeedd��fd	d
�Zeed�dd
�Z	eed�dd�Z
ed�dd�Zej
dkrxd&dd�Zdd�Zdd�Zdd�Zdd�Zdd �Zej
d!kr�d"d#�Zd$d%�Z�ZS)'rJa�Create named, parameterized type aliases.

        This provides a backport of the new `type` statement in Python 3.12:

            type ListOrSet[T] = list[T] | set[T]

        is equivalent to:

            T = TypeVar("T")
            ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,))

        The name ListOrSet can then be used as an alias for the type it refers to.

        The type_params argument should contain all the type parameters used
        in the value of the type alias. If the alias is not generic, this
        argument is omitted.

        Static type checkers should only support type aliases declared using
        TypeAliasType that follow these rules:

        - The first argument (the name) must be a string literal.
        - The TypeAliasType instance must be immediately assigned to a variable
          of the same name. (For example, 'X = TypeAliasType("Y", int)' is invalid,
          as is 'X, Y = TypeAliasType("X", int), TypeAliasType("Y", int)').

        r�)�type_paramsr�c	Cs�t|t�std��t|t�s$td��||_||_d}g}|D]z}t|tttf�rXt	|�rftd|����t
|dt�tu}|r�|s�td|�d���|r�d}t|t�r�|�|�q<|�
|�q<t|�|_t�}|d	kr�||_||_dS)
Nz#TypeAliasType name must be a stringztype_params must be a tupleFzExpected a type param, got r�znon-default type parameter 'z ' follows default type parameterTr)r�r�r�r��	__value__�__type_params__rrr
r.r�rUr�r�r�r5r�r�)	r�r�rrr�Zdefault_value_encounteredr�r�r�r�r�r�r�r�Ps8

���

zTypeAliasType.__init__N)r�rrrQcs&t|d�r|�|�t��||�dS)Nr�)r��_raise_attribute_errorr�r)r�r�rrr�r�r�rus

zTypeAliasType.__setattr__)r�rQcCs|�|�dSr�)r��r�r�r�r�r��__delattr__zszTypeAliasType.__delattr__cCs@|dkrtd��n*|dvr,td|�d���ntd|�d���dS)Nr�zreadonly attribute>r�r�r�r�zattribute 'z3' of 'typing.TypeAliasType' objects is not writablez0'typing.TypeAliasType' object has no attribute '�')r�r�r�r�r�r�}s

�
�z$TypeAliasType._raise_attribute_errorrPcCs|jSr�rr�r�r�r�r��szTypeAliasType.__repr__r�rcsT|durdS|durdSt|t�r>�dkr>��fdd�|D�St�|d�j�d��S)N.rcsg|]}��|�d��qS)r���_check_single_paramr��	recursionr�r�r�r{�s�z5TypeAliasType._check_single_param.<locals>.<listcomp>�
Subscripting � requires a type.)r�r�r�r
r�)r�r/r�r�r�r�r��s��z!TypeAliasType._check_single_paramcs6tjdkr t�fdd�|D��St�fdd�|D��S)Nr�c3s|]}��|�VqdSr�r��rr�r�r�r�r�s�z2TypeAliasType._check_parameters.<locals>.<genexpr>c3s$|]}t�|d�j�d��VqdS)r�r�N)r�r
r�r�r�r�r�r�s��)r.r[r�r�r�r�r��_check_parameters�s
��zTypeAliasType._check_parameterscCsd|jstd��t|t�s|f}tjdkr4t�||�St|�}|�	|�}t
||�}|j|kr`||_|S)Nz+Only generic type aliases are subscriptabler�)r�r�r�r�r.r[r�r�r�r�r�r�)r�r�Z	type_varsr�r�r�r�r��s




zTypeAliasType.__getitem__cCs|jSr�rr�r�r�r�r��szTypeAliasType.__reduce__cOstd��dS)NzEtype 'typing_extensions.TypeAliasType' is not an acceptable base typer�r�r�r�r�rV�s�zTypeAliasType.__init_subclass__cCstd��dS)NzType alias is not callabler�r�r�r�r�r��szTypeAliasType.__call__r�cCst|�stStj||fSr��r�r�r�rw)r�rLr�r�r�r��szTypeAliasType.__or__cCst|�stStj||fSr�r�)r�rKr�r�r�r��szTypeAliasType.__ror__)r)r�r�r�r�r�r�rrrPr�r�r�r.r[r�r�r�r�rVr�r�r�r�r�r�r�r�rJ4s %


rJr=)r�rQcCs(t|t�o&t|dd�o&|tuo&|tjuS)aZReturn True if the given type is a Protocol.

        Example::

            >>> from typing_extensions import Protocol, is_protocol
            >>> class P(Protocol):
            ...     def a(self) -> str: ...
            ...     b: int
            >>> is_protocol(P)
            True
            >>> is_protocol(int)
            False
        r;F)r�r�r�rCr�r�r�r�r�r=�s

���cCs6t|�st|�d���t|d�r*t|j�Stt|��S)a�Return the set of members defined in a Protocol.

        Example::

            >>> from typing_extensions import Protocol, get_protocol_members
            >>> class P(Protocol):
            ...     def a(self) -> str: ...
            ...     b: int
            >>> get_protocol_members(P)
            frozenset({'a', 'b'})

        Raise a TypeError for arguments that are not Protocols.
        z is not a Protocolr!)r=r�r�r�r!r,r�r�r�r�r:�s


r:r1c@sLeZdZdZedd�dd�Zed�dd�Zed�d	d
�Ze	e
d�dd
�ZdS)r1afDefine the documentation of a type annotation using ``Annotated``, to be
         used in class attributes, function and method parameters, return values,
         and variables.

        The value should be a positional-only string literal to allow static tools
        like editors and documentation generators to use it.

        This complements docstrings.

        The string value passed is available in the attribute ``documentation``.

        Example::

            >>> from typing_extensions import Annotated, Doc
            >>> def hi(to: Annotated[str, Doc("Who to say hi to")]) -> None: ...
        N)�
documentationrQcCs
||_dSr��r�)r�r�r�r�r�r�szDoc.__init__rPcCsd|j�d�S)NzDoc(�)r�r�r�r�r�r�szDoc.__repr__cCs
t|j�Sr�)r�r�r�r�r�r�r�szDoc.__hash__)r�rQcCst|t�stS|j|jkSr�)r�r1r�r�r�r�r�r�r�!s
z
Doc.__eq__)r�r�r�r�r�r�r�rRr�rr�r�r�r�r�r�r1s
�CapsuleType�CAPI)r5r6c@seZdZdZdZdZdZdS)r5r�rrr�N)r�r�r�r��VALUE_WITH_FAKE_GLOBALSr�r�r�r�r�r�r5=sr5)rv�locals�eval_strr�csNt|�}|tjurtd��|r0|tjur0td��t|t�r�t|dd�}|rrt|d�rr|�dd�}t|t	j
�rvd}nd}d}t|dd�}|r�tj�|d�}	|	r�t|	dd�}t
t|��}
|}n�t|t	j�r�t|dd�}|j}d}
d}nZt|��rt|dd�}t|dd�}d}
|}n.t|d��r.|j}d}}
}nt|�d	���|du�rJiSt|t
��sdt|�d
���|�sniS|�s�|tju�r�dd�|��D�St
|�S|du�r�t|d
��r�|j}�q�t|tj��r�|j}�q��qڐq�t|d��r�|j}�du�r�|��du�r|
�pi�t|df�}�r2dd�|D��B���fdd�|��D�}
|
S)aCompute the annotations dict for an object.

        obj may be a callable, class, or module.
        Passing in an object of any other type raises TypeError.

        Returns a dict.  get_annotations() returns a new dict every time
        it's called; calling it twice on the same object will return two
        different but equivalent dicts.

        This is a backport of `inspect.get_annotations`, which has been
        in the standard library since Python 3.10. See the standard library
        documentation for more:

            https://docs.python.org/3/library/inspect.html#inspect.get_annotations

        This backport adds the *format* argument introduced by PEP 649. The
        three formats supported are:
        * VALUE: the annotations are returned as-is. This is the default and
          it is compatible with the behavior on previous Python versions.
        * FORWARDREF: return annotations as-is if possible, but replace any
          undefined names with ForwardRef objects. The implementation proposed by
          PEP 649 relies on language changes that cannot be backported; the
          typing-extensions implementation simply returns the same result as VALUE.
        * STRING: return annotations as strings, in a format close to the original
          source. Again, this behavior cannot be replicated directly in a backport.
          As an approximation, typing-extensions retrieves the annotations under
          VALUE semantics and then stringifies them.

        The purpose of this backport is to allow users who would like to use
        FORWARDREF or STRING semantics once PEP 649 is implemented, but who also
        want to support earlier Python versions, to simply write:

            typing_extensions.get_annotations(obj, format=Format.FORWARDREF)

        z;The VALUE_WITH_FAKE_GLOBALS format is for internal use onlyz8eval_str=True is only supported with format=Format.VALUEr&Nr1r#r�r�z% is not a module, class, or callable.z+.__annotations__ is neither a dict nor NonecSs*i|]"\}}|t|t�r|nt�|��qSr�)r�r�r�r �rr�rrr�r�r�r��s�z#get_annotations.<locals>.<dictcomp>r�r�cSsi|]}|j|�qSr�r)rr/r�r�r�r��rcs,i|]$\}}|t|t�s|n
t|����qSr�)r�r��evalr��rvr�r�r�r��s�)r5r�r2r�r�r�r�r�r1r��GetSetDescriptorTyper.�modulesr��varsr�r&r\r#r�r�r�r�r8�partialr�r�)r�rvr�r�r�Zobj_dict�annZobj_globals�module_namerzZ
obj_locals�unwrapr�Zreturn_valuer�r�r�r6Es�%
�


�



�r6r2�r�rvr�r�cCs|jr|jSt|dd�durLz|jj}Wnty:Yn0d|_||_|S|dur`t|dd�}|dur�t|dd�dur�ttj�|j	d�dd�}|dur�t|dd�}|du�rt
|t�r�t|dd�}|r�tj�|d�}|r�t|dd�}n2t
|tj
��rt|dd�}nt|��rt|dd�}|du�r(i}|du�rPi}t
|t��rP|�t|��|du�rp|du�rpt|dd�}|du�r�t|�}|D]}|||j<�q�|j}	|	���r�t�|	��s�|	|v�r�||	}n2|	|v�r�||	}ntt|	��r�tt|	�St|	��n|j}
t|
||�}d|_||_|S)	N�__cell__TZ	__owner__�__forward_module__r&r�r�r�)�__forward_evaluated__�__forward_value__r�r��
cell_contentsr2r.r�r1r�r�r�r�r�r\r�r�r�r��__forward_arg__�isidentifier�keyword�	iskeywordr��builtins�	NameError�__forward_code__r�)�forward_refr�rvr�r�rrr�rzr/r?�coder�r�r��_eval_with_owner�st���











r�)r�rvr�r�r��_recursive_guardc		Cs$|tjkr|jS|j|vr|Szt|||||d�}Wn&tyZ|tjkrT|YS�Yn0t|t�rnt|�}t|t�r�t	|dd�dur�d}t
|||||||d�Stjdkr�|r�|r�t
|�ni}|D]}|j|vr�|||j<q�tjdk�rtj|||||jhBd�Stj||||||jhBd�SdS)a�Evaluate a forward reference as a type hint.

        This is similar to calling the ForwardRef.evaluate() method,
        but unlike that method, evaluate_forward_ref() also:

        * Recursively evaluates forward references nested within the type hint.
        * Rejects certain objects that are not valid type hints.
        * Replaces type hints that evaluate to None with types.NoneType.
        * Supports the *FORWARDREF* and *STRING* formats.

        *forward_ref* must be an instance of ForwardRef. *owner*, if given,
        should be the object that holds the annotations that the forward reference
        derived from, such as a module, class object, or function. It is used to
        infer the namespaces to use for looking up names. *globals* and *locals*
        can also be explicitly given to provide the global and local namespaces.
        *type_params* is a tuple of type parameters that are in scope when
        evaluating the forward reference. This parameter must be provided (though
        it may be an empty tuple) if *owner* is not given and the forward reference
        does not already have an owner set. *format* specifies the format of the
        annotation and is a member of the annotationlib.Format enum.

        r�r�TN)rvr�r�r�r�r�)rrY�)�recursive_guard)r5r�r�r�r�r�r�r�r^r�r2r.r[r�r�r�r�)	r�r�rvr�r�r�r�rrZtvarr�r�r�r2s^ 

�



�

�
�c@sdeZdZdZdeejed�dd�Zdd�Ze	j
dkr>d	d
�Ze	j
dkrXdd
�Zdd�Z
dd�ZdS)rDz�Create a unique sentinel object.

    *name* should be the name of the variable to which the return value shall be assigned.

    *repr*, if supplied, will be used for the repr of the sentinel object.
    If not provided, "<name>" will be used.
    N)r�rZcCs$||_|dur|n
d|�d�|_dS)N�<�>)r��_repr)r�r�rZr�r�r�r�{szSentinel.__init__cCs|jSr�)r�r�r�r�r�r��szSentinel.__repr__r�cOstt|�j�d���dS)Nz object is not callable�r�r�r�r<r�r�r�r��szSentinel.__call__r�cCstj||fSr�r�r�r�r�r�r��szSentinel.__or__cCstj||fSr�r�r�r�r�r�r��szSentinel.__ror__cCstdt|�j�d���dS)NzCannot pickle z objectr�r�r�r�r��__getstate__�szSentinel.__getstate__)N)r�r�r�r�r�r�ror�r�r.r[r�r�r�r�r�r�r�r�rDrs��

rD)rrrr}cCsJt|ttjtjf�r6|jdkr$|jS|j�d|j��S|durBdSt|�S)a"Convert a Python value to a format suitable for use with the STRING format.

        This is intended as a helper for tools that support the STRING format but do
        not have access to the code that originally produced the annotations. It uses
        repr() for most objects.

        r�rI.rY)r�r�r��FunctionType�BuiltinFunctionTyper�r�rZ)rrr�r�r�rO�s
rO)#rWrXrYrZr[r\r]r_rbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r�cCs"i|]}tt|�r|tt|��qSr�)r�r�r�)rr�r�r�r�r��rr�)r�r-)r)NNF)NN)N)N)r�)�r7r�rS�collections.abcr�enumr8rL�ior�r�r.rpr�r�r�r[r��__all__ZPEP_560r�ZGenericMetaZ_PEP_696_IMPLEMENTEDr^r�Z_FORWARD_REF_HAS_CLASSrr�r�rQrr�r�r�r�r�rr�r�_Finalr�r�rr4r�r0r<r?r�r�r�r�r�r�rAr3r-�defaultdictr�r�r�rrrrrrrrrrrHrNrrrr`r�r�r�rror�rrBr��EXCLUDED_ATTRIBUTESr'r,r5rCr:r=r@rArsrJrarGrFr&r$r#r"r%r!r'r(r)Z_NEEDS_SINGLETONMETArprUrsrVrxZ_PEP_728_IMPLEMENTEDr r}r>�	signaturer
r�r�r|r�r�r�r�r�r,r;r�r�r�r8r7rIr�r�r�r�rrr�r
r�rrr:r<r�r=rrLrMrKrAr	r
rPrSrTrRrErr.rDrFr,rrErVr+r.rvrwrZrBrcr/rdrr�r�r�r�r�r�r�rr��_prohibitedr�r�r�r�r�r�r�ABC�register�
memoryview�	bytearrayrgr9r@rJr�r�r�r=r:r_r�r1Z_CapsuleType�_socket�ImportErrorZ_CAPIr�r�r5r6�IntEnumr�r2r�rDrOZ
_typing_namesrvr�r*r�r�r�r��<module>sL






. 

�((��
�
�	�
d
5
�)>
>
*
7
'
1fv


0
*






,

>N� ���V&

8"08	GA



 >	# 


��Q�Y&
'�