HOME

Mini Shell 1.0
DIR:/opt/alt/python38/lib64/python3.8/__pycache__/
Current File : //opt/alt/python38/lib64/python3.8/__pycache__/typing.cpython-38.opt-2.pyc
U

��,ab
�G@s�ddlmZmZddlZddlZddlZddlZddlZddlZ	ddl
Z
ddlZddlmZm
Z
mZdddddd	d
ddd
ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJgGZd�dLdM�ZdNdO�ZdPdQ�ZdRdS�ZdTdU�ZdVdW�ZgZdXdY�ZdZd[�ZGd\d]�d]�ZGd^d_�d_�ZGd`da�daeedKdb�Zeddcdd�ZedFdedd�Zeddfdd�Zeddgdd�Zeddhdd�Z eddidd�Z!ed
djdd�Z"Gdkd�dedKdb�Z#Gdld�deedKdb�Z$d6d
d4d8d9d3d5dddm�	Z%dndo�Z&Gdpdq�dqedKdb�Z'Gdrds�dse'dKdb�Z(Gdtd	�d	�Z)Gdudv�dv�Z*Gdwdx�dx�Z+dydzd{d|d}gZ,d~dd�d�d�d�d�d�d�d�g
Z-e,e-d�gZ.d�d��Z/d�d��Z0d�d��Z1d�d��Z2dd"ddd$dd dd&d)g
d�d�gd��Z3Gd�d��d�e�Z4Gd�d�de)e4d��Z5d�dH�Z6d�d>�Z7d�d��Z8ej9ej:ej;ej<ee
efZ=d�d�dB�Z>d�dA�Z?d�d@�Z@d�dD�ZAd�dE�ZBd�d��ZCd�dG�ZDd�d?�ZEe$d��ZFe$d��ZGe$d��ZHe$d�dKd��ZIe$d�dKd��ZJe$d�dKd��ZKe$d�dKd��ZLe$d�dKeMd��ZNe$d=eOeP�ZQd�d�d��ZReRejjSd��ZSeRejjTeI�ZTeRejjUeIeLeJf�ZUeRejjVeI�ZVeRejjWeI�ZWeRejjXeI�ZXeRejjYeI�ZYeRejjZeI�ZZeRejj[d��Z[eRejj\eI�Z\eRejj]eI�Z]e(ejj^d�dKd��Z^d�e^__eRejj`eI�ZaeRejjbeF�ZbeRejjceGeKf�ZceRejjdeGeHf�ZdeRejjeeI�ZeeRejjfeF�ZfeRejjgd��Zge(ehd�d�dKd��Zid�ei__eRejeFd�d��ZkeRejleF�ZmeReneFd�d��Z`eReoeId�d��ZpeRejjqeI�ZqeRejjreG�ZreRejjseGeKf�ZseRejjteK�ZteRejueI�ZveRejweI�ZxeReyeGeHfd�d��ZzeRej{eGeHf�Z|eRej}eGeHf�Z}eRej~eF�Z~eRejeGeHf�ZeRejj�eIeLeJf�Z�eRejj�eIeLf�Z�eReMeNd�d��Z�d�e�__e6Gd�d/�d/e5��Z�e6Gd�d-�d-e5��Z�e6Gd�d,�d,e5��Z�e6Gd�d+�d+e5��Z�e6Gd�d.�d.e5��Z�e6Gd�d*�d*e5eI��Z�e6Gd�d0�d0e5eI��Z�d�dZ�d�Z�d�Z�Gd�dƄd�eM�Z�Gd�d:�d:e�d��Z�d�dɄZ�d�dKdʜd�d̄Z�d�d΄Z�Gd�dЄd�eM�Z�Gd�d;�d;eye�d��Z�d�dC�Z�ePZ�d�Z�Gd�dԄd�e)eQ�Z�Gd�dքd�e�eO�Z�Gd�d؄d�e�eP�Z�Gd�dڄdڃZ�e�d�e�_�e�e
j�e�j�<eRe	j�eQ�Z�eRe	j�eQ�Z�Gd�d݄d݃Ze�d�e_�ee
j�ej�<dS)��)�abstractmethod�ABCMetaN)�WrapperDescriptorType�MethodWrapperType�MethodDescriptorType�Any�Callable�ClassVar�Final�
ForwardRef�Generic�Literal�Optional�Protocol�Tuple�Type�TypeVar�Union�AbstractSet�
ByteString�	Container�ContextManager�Hashable�	ItemsView�Iterable�Iterator�KeysView�Mapping�MappingView�MutableMapping�MutableSequence�
MutableSet�Sequence�Sized�
ValuesView�	Awaitable�
AsyncIterator�
AsyncIterable�	Coroutine�
Collection�AsyncGenerator�AsyncContextManager�
Reversible�SupportsAbs�
SupportsBytes�SupportsComplex�
SupportsFloat�
SupportsIndex�SupportsInt�
SupportsRound�ChainMap�Counter�Deque�Dict�DefaultDict�List�OrderedDict�Set�	FrozenSet�
NamedTuple�	TypedDict�	Generator�AnyStr�cast�final�get_args�
get_origin�get_type_hints�NewType�
no_type_check�no_type_check_decorator�NoReturn�overload�runtime_checkable�Text�
TYPE_CHECKINGTcCs�ttf}|r|ttf}|dkr(td�St|t�r:t|�St|t�r\|j	|kr\t
|�d���t|t�rr|tt
fks~|ttfkr�t
d|�d���t|tttf�r�|St|�s�t
|�d|d�d���|S)Nz is not valid as type argumentzPlain z Got z.100�.)rrr	r
�type�
isinstance�strr�
_GenericAlias�
__origin__�	TypeError�_SpecialFormrrIr�callable)�arg�msg�is_argumentZinvalid_generic_forms�rZ�+/opt/alt/python38/lib64/python3.8/typing.py�_type_checkxs(

�
�r\cCsRt|t�r,|jdkr|jS|j�d|j��S|dkr8dSt|tj�rJ|jSt|�S)N�builtinsrN.z...)rPrO�
__module__�__qualname__�types�FunctionType�__name__�repr)�objrZrZr[�
_type_repr�s

recs\g�|D]J}t|t�r(|�kr(��|�t|t�r|js���fdd�|jD��qt��S)Ncsg|]}|�kr|�qSrZrZ��.0�t��tvarsrZr[�
<listcomp>�sz&_collect_type_vars.<locals>.<listcomp>)rPr�appendrR�_special�extend�__parameters__�tuple)r`rhrZrir[�_collect_type_vars�s
rqcCs�t|t�s|St|j�}t|j�D]J\}}t|t�r\t|�D]\}}||kr<||||<q<q"t|||�||<q"|jtkr�tt	|�S|�
t	|��S�N)rPrR�list�__args__�	enumerater�_subs_tvarsrSrrp�	copy_with)�tprjZsubsZnew_args�arW�iZtvarrZrZr[rv�s



rvc	Cs^|jst|�d���t|�}t|j�}||krZtd||kr>dnd�d|�d|�d|����dS)Nz is not a generic classzToo ZmanyZfewz parameters for z	; actual z, expected )rorT�len)�cls�
parametersZalenZelenrZrZr[�_check_generic�s
r~cCs�g}|D]f}t|t�r.|jtkr.|�|j�qt|t�rdt|�dkrd|dtkrd|�|dd��q|�|�qt	|�}t|�t|�kr�g}|D] }||kr�|�|�|�
|�q�|}t|�S)Nr�)rPrRrSrrnrtrpr{rl�set�remove)r}�params�pZ
all_paramsZ
new_paramsrhrZrZr[�_remove_dups_flatten�s "
r�cs4t�����t��j�t�����fdd��}|S)Ncs,z�||�WStk
r YnX�||�Srr�rT��args�kwds��cached�funcrZr[�inner�s
z_tp_cache.<locals>.inner)�	functools�	lru_cache�	_cleanupsrl�cache_clear�wraps)r�r�rZr�r[�	_tp_cache�s
r�csbt|t�r|����St|t�r^t��fdd�|jD��}||jkrH|S|�|�}|j|_|S|S)Nc3s|]}t|���VqdSrr)�
_eval_type�rgry��globalns�localnsrZr[�	<genexpr>sz_eval_type.<locals>.<genexpr>)rPr�	_evaluaterRrprtrwrm)rhr�r�Zev_args�resrZr�r[r�	s



r�c@seZdZdZdd�ZdS)�_Final)�__weakref__cOsd|krtd��dS)N�_rootz&Cannot subclass special typing classesr���selfr�r�rZrZr[�__init_subclass__sz_Final.__init_subclass__N)rbr^r_�	__slots__r�rZrZrZr[r�sr�c@seZdZdd�Zdd�ZdS)�
_ImmutablecCs|SrrrZ�r�rZrZr[�__copy__%sz_Immutable.__copy__cCs|SrrrZ)r�ZmemorZrZr[�__deepcopy__(sz_Immutable.__deepcopy__N)rbr^r_r�r�rZrZrZr[r�"sr�csleZdZdZ�fdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Ze
dd��Z�ZS)rU��_nameZ_doccsBt|�dkr6t|dt�r6t|dt�r6td|����t��|�S)N�rrzCannot subclass )r{rPrQrprT�super�__new__)r|r�r���	__class__rZr[r�3s��z_SpecialForm.__new__cCs||_||_dSrrr�)r��name�docrZrZr[�__init__@sz_SpecialForm.__init__cCst|t�stS|j|jkSrr)rPrU�NotImplementedr��r��otherrZrZr[�__eq__Ds
z_SpecialForm.__eq__cCst|jf�Srr)�hashr�r�rZrZr[�__hash__Isz_SpecialForm.__hash__cCs
d|jS)N�typing.�r�r�rZrZr[�__repr__Lsz_SpecialForm.__repr__cCs|jSrrr�r�rZrZr[�
__reduce__Osz_SpecialForm.__reduce__cOstd|����dS)NzCannot instantiate r�r�rZrZr[�__call__Rsz_SpecialForm.__call__cCst|�d���dS)Nz! cannot be used with isinstance()r��r�rdrZrZr[�__instancecheck__Usz_SpecialForm.__instancecheck__cCst|�d���dS)Nz! cannot be used with issubclass()r��r�r|rZrZr[�__subclasscheck__Xsz_SpecialForm.__subclasscheck__cs�|jdkr(t||j�d��}t||f�S|jdkr�|dkrBtd��t|t�sR|f}d�t�fdd�|D��}t|�}t|�d	kr�|d
St||�S|jdkr�t|d�}t|t	d�fS|jd
kr�t||�St|�d���dS)N)r	r
z accepts only single type.rrZz Cannot take a Union of no types.z)Union[arg, ...]: each arg must be a type.c3s|]}t|��VqdSrr�r\�rgr��rXrZr[r�fsz+_SpecialForm.__getitem__.<locals>.<genexpr>rrrz#Optional[t] requires a single type.r
z is not subscriptable)
r�r\rRrTrPrpr�r{rrO)r�r}�itemrWrZr�r[�__getitem__[s(







z_SpecialForm.__getitem__)rbr^r_r�r�r�r�r�r�r�r�r�r�r�r��
__classcell__rZrZr�r[rU,s
rU)r�a`Special 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
    or class checks.
    )r�aSpecial type indicating functions that never return.
    Example::

      from typing import NoReturn

      def stop() -> NoReturn:
          raise Exception('no way')

    This type is invalid in other positions, e.g., ``List[NoReturn]``
    will fail in static type checkers.
    a3Special type construct to mark class variables.

    An annotation wrapped in ClassVar indicates that a given
    attribute is intended to be used as a class variable and
    should not be set on instances of that class. Usage::

      class Starship:
          stats: ClassVar[Dict[str, int]] = {} # class variable
          damage: int = 10                     # instance variable

    ClassVar accepts only types and cannot be further subscribed.

    Note that ClassVar is not a class itself, and should not
    be used with isinstance() or issubclass().
    a�Special typing construct to indicate final names to type checkers.

    A final name cannot be re-assigned or overridden in a subclass.
    For example:

      MAX_SIZE: Final = 9000
      MAX_SIZE += 1  # Error reported by type checker

      class Connection:
          TIMEOUT: Final[int] = 10

      class FastConnector(Connection):
          TIMEOUT = 1  # Error reported by type checker

    There is no runtime checking of these properties.
    a'Union type; Union[X, Y] means either X or Y.

    To define a union, use e.g. Union[int, str].  Details:
    - The arguments must be types and there must be at least one.
    - None as an argument is a special case and is replaced by
      type(None).
    - Unions of unions are flattened, e.g.::

        Union[Union[int, str], float] == Union[int, str, float]

    - Unions of a single argument vanish, e.g.::

        Union[int] == int  # The constructor actually returns int

    - Redundant arguments are skipped, e.g.::

        Union[int, str, int] == Union[int, str]

    - When comparing unions, the argument order is ignored, e.g.::

        Union[int, str] == Union[str, int]

    - You cannot subclass or instantiate a union.
    - You can use Optional[X] as a shorthand for Union[X, None].
    zEOptional type.

    Optional[X] is equivalent to Union[X, None].
    a�Special typing form to define literal types (a.k.a. value types).

    This form can be used to indicate to type checkers that the corresponding
    variable or function parameter has a value equivalent to the provided
    literal (or one of several literals):

      def validate_simple(data: Any) -> Literal[True]:  # always returns True
          ...

      MODE = Literal['r', 'rb', 'w', 'wb']
      def open_helper(file: str, mode: MODE) -> str:
          ...

      open_helper('/some/path', 'r')  # Passes type check
      open_helper('/other/path', 'typo')  # Error in type checker

   Literal[...] cannot be subclassed. At runtime, an arbitrary value
   is allowed as type argument to Literal[...], but type checkers may
   impose restrictions.
    c@s:eZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)r)�__forward_arg__�__forward_code__�__forward_evaluated__�__forward_value__�__forward_is_argument__TcCsnt|t�std|����zt|dd�}Wn"tk
rJtd|����YnX||_||_d|_d|_||_	dS)Nz*Forward reference must be a string -- got z<string>�evalz/Forward reference must be an expression -- got F)
rPrQrT�compile�SyntaxErrorr�r�r�r�r�)r�rWrY�coderZrZr[r��s
zForwardRef.__init__cCsj|jr||k	rd|dkr(|dkr(i}}n|dkr6|}n|dkrB|}tt|j||�d|jd�|_d|_|jS)Nz*Forward references must evaluate to types.�rYT)r�r\r�r�r�r�)r�r�r�rZrZr[r��s
�zForwardRef._evaluatecCs>t|t�stS|jr2|jr2|j|jko0|j|jkS|j|jkSrr)rPrr�r�r�r�r�rZrZr[r�s

�zForwardRef.__eq__cCs
t|j�Srr)r�r�r�rZrZr[r�szForwardRef.__hash__cCsd|j�d�S)NzForwardRef(�))r�r�rZrZr[r�szForwardRef.__repr__N)T)	rbr^r_r�r�r�r�r�r�rZrZrZr[r�s

c@s2eZdZdZdddd�dd�Zdd�Zd	d
�ZdS)r)rb�	__bound__�__constraints__�
__covariant__�__contravariant__NF)�bound�	covariant�
contravariantc	s�||_|r|rtd��t|�|_t|�|_|r>|dk	r>td��|rVt|�dkrVtd��d�t�fdd�|D��|_|r�t	|d�|_
nd|_
zt�d�j
�d	d
�}Wnttfk
r�d}YnX|dkr�||_dS)Nz"Bivariant types are not supported.z-Constraints cannot be combined with bound=...rz"A single constraint is not allowedz:TypeVar(name, constraint, ...): constraints must be types.c3s|]}t|��VqdSrrr�rfr�rZr[r�Vsz#TypeVar.__init__.<locals>.<genexpr>zBound must be a type.rb�__main__�typing)rb�
ValueError�boolr�r�rTr{rpr�r\r��sys�	_getframe�	f_globals�get�AttributeErrorr^)r�r�r�r�r�ZconstraintsZdef_modrZr�r[r�Js(


zTypeVar.__init__cCs&|jrd}n|jrd}nd}||jS)N�+�-�~)r�r�rb)r��prefixrZrZr[r�bszTypeVar.__repr__cCs|jSrr)rbr�rZrZr[r�kszTypeVar.__reduce__)rbr^r_r�r�r�r�rZrZrZr[rs,�	)	rsrp�dictr��	frozenset�deque�defaultdictrOr;cCs|�d�o|�d�S)N�__)�
startswith�endswith)�attrrZrZr[�
_is_dunder�sr�cs�eZdZdddd�dd�Zedd��Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
dd�Zdd�Z�fdd�Z
dd�Zdd�Zdd�Z�ZS)rRTFN)�inst�specialr�cCsz||_||_|r*|dkr*|j}t�||�}||_t|t�s@|f}||_tdd�|D��|_	t
|�|_d|_|sv|j
|_
dS)Ncss*|]"}|tkrdn|tkrdn|VqdS).rZN)�_TypingEllipsis�_TypingEmptyr�rZrZr[r��s�z)_GenericAlias.__init__.<locals>.<genexpr>)�_instrmrb�_normalize_aliasr�r�rPrprSrtrqror�r^)r��originr�r�r�r�Z	orig_namerZrZr[r��s 
�

z_GenericAlias.__init__cs^|jttfkrtd|����t|t�s,|f}d�t�fdd�|D��}t||�t||j|�S)Nz%Cannot subscript already-subscripted �*Parameters to generic types must be types.c3s|]}t|��VqdSrrr�r�r�rZr[r��sz,_GenericAlias.__getitem__.<locals>.<genexpr>)	rSrrrTrPrpr~rvro�r�r�rZr�r[r��s

z_GenericAlias.__getitem__cCst|j||j|jd�S)N)r�r�)rRrSr�r�r�rZrZr[rw�sz_GenericAlias.copy_withcCs�|jdks&t|j�dkrx|jdtkrx|jr8d|j}n
t|j�}|jshdd�dd�|jD���d	�}nd
}|�|��S|jr�dSdd�d
d�|jdd�D���dt|jd��d	�S)Nr�rr��[�, cSsg|]}t|��qSrZ�rer�rZrZr[rk�sz*_GenericAlias.__repr__.<locals>.<listcomp>�]�ztyping.Callableztyping.Callable[[cSsg|]}t|��qSrZr�r�rZrZr[rk�s���z], )r�r{rt�EllipsisrerSrm�join)r�r�r�rZrZr[r��s
��
 z_GenericAlias.__repr__cCsRt|t�stS|j|jkrdS|jtkrF|jtkrFt|j�t|j�kS|j|jkS)NF)rPrRr�rSrr�rtr�rZrZr[r��s
z_GenericAlias.__eq__cCs,|jtkrttt|j�f�St|j|jf�Srr)rSrr�r�rtr�rZrZr[r��s
z_GenericAlias.__hash__cOsT|js$td|j�d|j���d���|j||�}z
||_Wntk
rNYnX|S)N�Type z cannot be instantiated; use z
() instead)r�rTr��lowerrS�__orig_class__r�)r�r��kwargs�resultrZrZr[r��s
z_GenericAlias.__call__cCs�|jrZg}|j|kr |�|j�|�|�}tdd�||dd�D��sR|�t�t|�S|jtkr�t|krpdS|�|�}||dd�D]}t|t	�r�||k	r�dSq�|jfS)Ncss"|]}t|t�pt|t�VqdSrr)rPrR�
issubclassr�rg�brZrZr[r��s�z0_GenericAlias.__mro_entries__.<locals>.<genexpr>rrZ)
r�rSrl�index�anyrrprrPrR)r��basesr�rzrrZrZr[�__mro_entries__�s$

�


z_GenericAlias.__mro_entries__cCs*d|jkrt|�st|j|�St|��dS)NrS)�__dict__r��getattrrSr�)r�r�rZrZr[�__getattr__�sz_GenericAlias.__getattr__cs2t|�s|dkr t��||�nt|j||�dS)N)r�r�rm)r�r��__setattr__�setattrrS)r�r��valr�rZr[r�sz_GenericAlias.__setattr__cCs|�t|��Srr)r�rOr�rZrZr[r�sz_GenericAlias.__instancecheck__cCs<|jr0t|t�st||j�S|jr0t|j|j�Std��dS)NzBSubscripted generics cannot be used with class and instance checks)rmrPrRrrSrTr�rZrZr[r�s
z_GenericAlias.__subclasscheck__cCs�|jr|jS|jr t�|j}n|j}|tkrht|j�dkrJ|jdtksht|jdd��|jdf}n*t	|j�}t|�dkr�t
|dt	�s�|\}tj||ffS)Nr�rr�r)
rmr��globalsrSrr{rtr�rsrprP�operator�getitem)r�r�r�rZrZr[r�s��
z_GenericAlias.__reduce__)rbr^r_r�r�r�rwr�r�r�r�r
r
rr�r�r�r�rZrZr�r[rR�s	
		rRcs(eZdZdd�Ze�fdd��Z�ZS)�_VariadicGenericAliascCs�|jdks|js|�|�St|t�r0t|�dkr8td��|\}}|tkrRt|f}n$t|t�sjtd|����t|�|f}|�|�S)Nrr�z6Callable must be used as Callable[[arg, ...], result].z1Callable[args, result]: args must be a list. Got )	r�rm�__getitem_inner__rPrpr{rTr�rs)r�r�r�rrZrZr[r�"s


z!_VariadicGenericAlias.__getitem__cs
|jtkr�|jr�|dkr$|�tf�St|t�s4|f}t|�dkrl|ddkrld�t|d��}|�|tf�Sd�t�fdd	�|D��}|�|�S|jt	j
jkr�|jr�|\}}d
�t|��}|tkr�|�t|f�Sd�t�fdd	�|D��}||f}|�|�St
��|�S)
NrZr�r.z Tuple[t, ...]: t must be a type.rz*Tuple[t0, t1, ...]: each t must be a type.c3s|]}t|��VqdSrrr�r�r�rZr[r�>sz:_VariadicGenericAlias.__getitem_inner__.<locals>.<genexpr>z.Callable[args, result]: result must be a type.z6Callable[[arg, ...], result]: each arg must be a type.c3s|]}t|��VqdSrrr�)rgrWr�rZr[r�Gs)rSrprmrwr�rPr{r\r��collections�abcrr�r�r�)r�r�r�r�rr�r�r[r2s.




z'_VariadicGenericAlias.__getitem_inner__)rbr^r_r�r�rr�rZrZr�r[rsrcs<eZdZdZdZ�fdd�Zedd��Z�fdd�Z�Z	S)	rrZFcs^|ttfkrtd|j�d���t�jtjkrF|jtjk	rFt��|�}nt�j|f|�|�}|S)Nr�z< cannot be instantiated; it can be used only as a base class)rrrTrbr�r��objectr�)r|r�r�rdr�rZr[r�dszGeneric.__new__cs�t|t�s|f}|s.|tk	r.td|j�d���d�t�fdd�|D��}|ttfkr�tdd�|D��sxtd|j�d���t	t
|��t	|�kr�td|j�d	���n
t||�t||�S)
NzParameter list to z[...] cannot be emptyr�c3s|]}t|��VqdSrrr�r�r�rZr[r�vsz,Generic.__class_getitem__.<locals>.<genexpr>css|]}t|t�VqdSrr)rPrr�rZrZr[r�yszParameters to z [...] must all be type variablesz[...] must all be unique)
rPrprrTr_rr�allrbr{r�r~rR)r|r�rZr�r[�__class_getitem__ns&
���
zGeneric.__class_getitem__c
s
t�j||�g}d|jkr(t|jk}nt|jko:|jdk}|rHtd��d|jkr�t|j�}d}|jD].}t	|t
�rf|jtkrf|dk	r�td��|j}qf|dk	r�t
|�}t
|��|�ks�d��fdd�|D��}d�dd�|D��}	td	|�d
|	�d���|}t|�|_dS)N�__orig_bases__rz!Cannot inherit from plain Genericz0Cannot inherit from Generic[...] multiple types.r�c3s|]}|�krt|�VqdSrr�rQrf�ZgvarsetrZr[r��sz,Generic.__init_subclass__.<locals>.<genexpr>css|]}t|�VqdSrrr)rg�grZrZr[r��szSome type variables (z) are not listed in Generic[r�)r�r�rrr�	__bases__rbrTrqrPrRrSror�r�rp)
r|r�rrj�errorZgvars�baseZtvarsetZs_varsZs_argsr�rr[r��s8




��zGeneric.__init_subclass__)
rbr^r_r��_is_protocolr�r�rr�r�rZrZr�r[rMs

c@seZdZdS)r�N�rbr^r_rZrZrZr[r��sr�c@seZdZdS)r�Nr#rZrZrZr[r��sr�rorrr"�_is_runtime_protocol�__abstractmethods__�__annotations__r�__doc__r�r^r�r��__subclasshook__r��_MutableMapping__markercCsrt�}|jdd�D]X}|jdkr$qt|di�}t|j���t|���D] }|�d�sJ|tkrJ|�	|�qJq|S)Nr�)rrr&Z_abc_)
r��__mro__rbrrsr�keysr��EXCLUDED_ATTRIBUTES�add)r|Zattrsr!�annotationsr�rZrZr[�_get_protocol_attrs�s
r/cst�fdd�t��D��S)Nc3s|]}tt�|d��VqdSrr)rVr�rgr��r|rZr[r��sz,_is_callable_members_only.<locals>.<genexpr>)rr/r1rZr1r[�_is_callable_members_only�sr2cOst|�jrtd��dS)Nz Protocols cannot be instantiated)rOr"rT)r�r�rrZrZr[�_no_init�s
r3c	Cs6zt�d�jddkWSttfk
r0YdSXdS)Nr�rb)rr�T)r�r�r�r�r�rZrZrZr[�_allow_reckless_class_cheks�sr4�AbstractContextManager�AbstractAsyncContextManager)zcollections.abc�
contextlibcseZdZ�fdd�Z�ZS)�
_ProtocolMetacsVt�dd�rt��r$t�j��r$dS�jrJt��fdd�t��D��rJdSt����S)Nr"FTc3s8|]0}t�|�o.tt�|d��p.t�|�dk	VqdSrr)�hasattrrVrr0�r|�instancerZr[r��s�
z2_ProtocolMeta.__instancecheck__.<locals>.<genexpr>)	rr2rr�r"rr/r�r�r:r�r:r[r��s�
��z_ProtocolMeta.__instancecheck__)rbr^r_r�r�rZrZr�r[r8�sr8cs(eZdZdZdZdZ�fdd�Z�ZS)rrZTFcs�t�j||��j�dd�s2tdd��jD���_�fdd�}d�jkrN|�_�jsXdS�jD]F}|tt	fks^|j
tkr�|jt|j
ks^t
|t	�r�|js^td|��q^t�_dS)	Nr"Fcss|]}|tkVqdSrr)rrrZrZr[r�)sz-Protocol.__init_subclass__.<locals>.<genexpr>cs��j�dd�stSt�dd�s0t�r(tStd��t��sJt�rBtStd��t|t�s\td��t	��D]v}|j
D]b}||jkr�|j|dkr�tSqdt|di�}t|tjj
�rn||krnt|t�rn|jrnqdqntSqddS)	Nr"Fr$zLInstance and class checks can only be used with @runtime_checkable protocolsz<Protocols with non-method members don't support issubclass()z"issubclass() arg 1 must be a classr&T)rr�r�rr4rTr2rPrOr/r*rrrrrr")r�r�r!r.r1rZr[�_proto_hook,s:


���
z/Protocol.__init_subclass__.<locals>._proto_hookr(z7Protocols can only inherit from other protocols, got %r)r�r�rr�rrr"r(rrr^�_PROTO_WHITELISTrbrrTr3r�)r|r�rr<r!r�r1r[r�$s,&

�����zProtocol.__init_subclass__)rbr^r_r�r"r$r�r�rZrZr�r[rs)�	metaclasscCs&t|t�r|jstd|��d|_|S)NzB@runtime_checkable can be only applied to protocol classes, got %rT)rrr"rTr$r1rZrZr[rKds�cCs|SrrrZ)�typrrZrZr[rA}sc
Cs�z
|j}Wntk
r"iYSX|j}|j}|d|�}|jpDd}|j}|rXt|�ni}|t|�}t||d�|�D]\}}	|	||<qz|S)NrZ)	�__code__r��co_argcount�co_varnames�__defaults__�__kwdefaults__r�r{�zip)
r�r�Z	pos_countZ	arg_names�defaultsZ
kwdefaultsr�Z
pos_offsetr��valuerZrZr[�
_get_defaults�s



rHcCs�t|dd�riSt|t�r�i}t|j�D]z}|dkrDtj|jj}n|}|j�	di�}|�
�D]B\}}|dkrvtd�}t|t�r�t|dd�}t
|||�}|||<q^q(|S|dkr�t|tj�r�|j}n"|}	t|	d�r�|	j}	q�t|	di�}|dkr�|}n|dk�r|}t|dd�}|dk�r6t|t��r(iStd�|���t|�}
t|�}|�
�D]d\}}|dk�rhtd�}t|t��r|t|�}t
|||�}||
k�r�|
|dk�r�t|}|||<�qN|S)N�__no_type_check__r&Fr��__wrapped__�__globals__z1{!r} is not a module, class, method, or function.)rrPrO�reversedr*r��modulesr^rr��itemsrQrr�r`�
ModuleTyper9rJ�_allowed_typesrT�formatrHr�r)rdr�r�Zhintsr!Zbase_globals�annr�rGZnsobjrFrZrZr[rE�s^




�
cCs t|t�r|jS|tkrtSdSrr)rPrRrSr)rxrZrZr[rD�s

cCsRt|t�rN|jsN|j}t|�tjjkrJ|dtk	rJt	|dd��|df}|SdS)Nrr�rZ)
rPrRrmrtrDrrrr�rs)rxr�rZrZr[rCscCs�t|t�rt|j��}|j��D]"\}}||j|fkr|�|�q|��D](}t|tj	�r`d|_
t|t�rJt|�qJz
d|_
Wntk
r�YnX|S)NT)
rPrOr�copyrNr�pop�valuesr`rarIrGrT)rWZ	arg_attrsr�rrdrZrZr[rGs	




cst����fdd��}|S)Ncs�||�}t|�}|Srr)rG)r�r�r���	decoratorrZr[�wrapped_decorator@s
z2no_type_check_decorator.<locals>.wrapped_decorator)r�r�)rWrXrZrVr[rH9scOstd��dS)Nz�You should not call an overloaded function. A series of @overload-decorated functions outside a stub module should always be followed by an implementation that is not @overload-ed.)�NotImplementedErrorr�rZrZr[�_overload_dummyIs�rZcCstSrr)rZ)r�rZrZr[rJRscCs|SrrrZ)�frZrZr[rBos�T�KT�VT�T_co)r��V_co�VT_co�T_contra)r��CT_co)r�r�cCst||d|d�S)NT)r�r�)rR)r�r�r�rZrZr[�_alias�srdrZ)r�a�Callable type; Callable[[int], str] is a function of (int) -> str.

    The subscription syntax must always be used with exactly two
    values: the argument list and the return type.  The argument list
    must be a list of types or ellipsis; the return type must be a single type.

    There is no syntax to indicate optional or keyword arguments,
    such function types are rarely used as callback types.
    F)r�r�a@Tuple type; Tuple[X, Y] is the cross-product type of X and Y.

    Example: Tuple[T1, T2] is a tuple of two elements corresponding
    to type variables T1 and T2.  Tuple[int, float, str] is a tuple
    of an int, a float and a string.

    To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
    )r�a�A special construct usable to annotate class objects.

    For example, suppose we have the following classes::

      class User: ...  # Abstract base for User classes
      class BasicUser(User): ...
      class ProUser(User): ...
      class TeamUser(User): ...

    And a function that takes a class argument that's a subclass of
    User and returns an instance of the corresponding class::

      U = TypeVar('U', bound=User)
      def new_user(user_class: Type[U]) -> U:
          user = user_class()
          # (Here we could write the user object to a database)
          return user

      joe = new_user(BasicUser)

    At this point the type checker knows that joe has type BasicUser.
    c@s"eZdZdZeed�dd��ZdS)r2rZ��returncCsdSrrrZr�rZrZr[�__int__�szSupportsInt.__int__N)rbr^r_r�r�intrgrZrZrZr[r2�sc@s"eZdZdZeed�dd��ZdS)r0rZrecCsdSrrrZr�rZrZr[�	__float__szSupportsFloat.__float__N)rbr^r_r�r�floatrirZrZrZr[r0�sc@s"eZdZdZeed�dd��ZdS)r/rZrecCsdSrrrZr�rZrZr[�__complex__
szSupportsComplex.__complex__N)rbr^r_r�r�complexrkrZrZrZr[r/sc@s"eZdZdZeed�dd��ZdS)r.rZrecCsdSrrrZr�rZrZr[�	__bytes__szSupportsBytes.__bytes__N)rbr^r_r�r�bytesrmrZrZrZr[r.sc@s"eZdZdZeed�dd��ZdS)r1rZrecCsdSrrrZr�rZrZr[�	__index__szSupportsIndex.__index__N)rbr^r_r�rrhrorZrZrZr[r1sc@s"eZdZdZeed�dd��ZdS)r-rZrecCsdSrrrZr�rZrZr[�__abs__(szSupportsAbs.__abs__N)rbr^r_r�rr_rprZrZrZr[r-#sc@s&eZdZdZedeed�dd��ZdS)r3rZr)�ndigitsrfcCsdSrrrZ)r�rqrZrZr[�	__round__2szSupportsRound.__round__N)r)rbr^r_r�rrhr_rrrZrZrZr[r3-sc	std��fdd�|D�}t�|dd�|D��}t|�|_|_zt�d�j�dd�|_	Wnt
tfk
rnYnX|S)NzDNamedTuple('Name', [(f0, t0), (f1, t1), ...]); each t must be a typecsg|]\}}|t|��f�qSrZr��rg�nrhr�rZr[rk9sz!_make_nmtuple.<locals>.<listcomp>cSsg|]\}}|�qSrZrZrsrZrZr[rk:sr�rbr�)r�
namedtupler�r&�_field_typesr�r�r�r�r^r�r�)r�r`�nm_tplrZr�r[�
_make_nmtuple7srx)r�r�r��__getnewargs__�_fields�_field_defaultsrv�_make�_replace�_asdictZ_source)r^rbr&cseZdZ�fdd�Z�ZS)�NamedTupleMetacs�|�dd�rt��||||�S|�di�}t||���}g}i}|D]H}||krl||}	|�|	�|	||<qD|rDtdj|d�|�	��d���qDt
|�|j_t|�|j_
||_|D]<}
|
tkr�td|
��q�|
tkr�|
|jkr�t||
||
�q�|S)Nr�Fr&zXNon-default namedtuple field {field_name} cannot follow default field(s) {default_names}r�)�
field_nameZ
default_namesz&Cannot overwrite NamedTuple attribute )r�r�r�rxrNrlrTrQr�r+r�r&rprCr{�_prohibitedr�rmrzr)r|�typenamer	�nsr`rwrFZ
defaults_dictr�Z
default_value�keyr�rZr[r�Os2

�
zNamedTupleMeta.__new__)rbr^r_r�r�rZrZr�r[rMsrc@seZdZdZdd�Zde_dS)r=TcOs�|std��|^}}|r"|^}}n4d|krN|�d�}ddl}|jdtdd�ntd��|r�z
|\}Wq�tk
r�tdt|�d�d	��d�Yq�Xn<d
|kr�t|�dkr�|�d
�}ddl}|jdtdd�nd}|dkr�|��}n|r�td
��t||�S)Nz*NamedTuple.__new__(): not enough argumentsr�rz4Passing 'typename' as keyword argument is deprecatedr�)�
stacklevelzGNamedTuple.__new__() missing 1 required positional argument: 'typename'z@NamedTuple.__new__() takes from 2 to 3 positional arguments but z were given�fieldsrz2Passing 'fields' as keyword argument is deprecatedzIEither list of fields or keywords can be provided to NamedTuple, not both)	rTrT�warnings�warn�DeprecationWarningr�r{rNrx)r�rr|r�r�r�rZrZr[r��sB

�
�

�
zNamedTuple.__new__z*($cls, typename, fields=None, /, **kwargs)N)rbr^r_r�r��__text_signature__rZrZrZr[r=ls#cOs
t||�Srr)r�)r|r�rrZrZr[�	_dict_new�sr�)�totalc	Ksj|dkr|}n|rtd��t|�|d�}zt�d�j�dd�|d<Wnttfk
r\YnXt|d|�S)Nz@TypedDict takes either a dict or keyword arguments, but not both)r&�	__total__rrbr�r^rZ)	rTr�r�r�r�r�r�r��_TypedDictMeta)r|r�r�r�rr�rZrZr[�_typeddict_new�sr�cCstd��dS)Nz4TypedDict does not support instance and class checksr�)r|r�rZrZr[�_check_fails�sr�cs&eZdZd�fdd�	ZeZZ�ZS)r�Tcs�|dkrtnt|d<tt|��||tf|�}|�di�}d��fdd�|��D�}|D]}|�|j	�di��qV||_
t|d�s�||_|S)Nr>r�r&z?TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a typecsi|]\}}|t|���qSrZr�)rgrtrxr�rZr[�
<dictcomp>�sz*_TypedDictMeta.__new__.<locals>.<dictcomp>r�)
r�r�r�r�r�r�r�rN�updaterr&r9r�)r|r�r	r�r�Ztp_dictZannsr!r�r�r[r��s	
z_TypedDictMeta.__new__)T)rbr^r_r�r�r�r�r�rZrZr�r[r��sr�c@seZdZdS)r>Nr#rZrZrZr[r>�scCsdd�}||_||_|S)NcSs|SrrrZ)�xrZrZr[�new_typeszNewType.<locals>.new_type)rbZ
__supertype__)r�rxr�rZrZr[rFsc@s�eZdZdZeeed�dd���Zeeed�dd���Zedd�dd	��Z	eee
d�d
d���Zeed�dd
��Z
edd�dd��Zee
d�dd��Zed6eed�dd��Zee
d�dd��Zed7eed�dd��Zed8eeed�dd��Zed9eeed�d d!��Zee
d�d"d#��Zeed�d$d%��Zed:eed&�d'd(��Zee
d�d)d*��Zeeed+�d,d-��Zeeedd.�d/d0��Zed1d�d2d3��Zedd�d4d5��ZdS);�IOrZrecCsdSrrrZr�rZrZr[�mode=szIO.modecCsdSrrrZr�rZrZr[r�BszIO.nameNcCsdSrrrZr�rZrZr[�closeGszIO.closecCsdSrrrZr�rZrZr[�closedKsz	IO.closedcCsdSrrrZr�rZrZr[�filenoPsz	IO.filenocCsdSrrrZr�rZrZr[�flushTszIO.flushcCsdSrrrZr�rZrZr[�isattyXsz	IO.isattyr�)rtrfcCsdSrrrZ)r�rtrZrZr[�read\szIO.readcCsdSrrrZr�rZrZr[�readable`szIO.readable)�limitrfcCsdSrrrZ)r�r�rZrZr[�readlinedszIO.readline)�hintrfcCsdSrrrZ)r�r�rZrZr[�	readlineshszIO.readlinesr)�offset�whencerfcCsdSrrrZ)r�r�r�rZrZr[�seeklszIO.seekcCsdSrrrZr�rZrZr[�seekablepszIO.seekablecCsdSrrrZr�rZrZr[�telltszIO.tell)�sizerfcCsdSrrrZ)r�r�rZrZr[�truncatexszIO.truncatecCsdSrrrZr�rZrZr[�writable|szIO.writable��srfcCsdSrrrZ�r�r�rZrZr[�write�szIO.write)�linesrfcCsdSrrrZ)r�r�rZrZr[�
writelines�sz
IO.writelinesz
IO[AnyStr]cCsdSrrrZr�rZrZr[�	__enter__�szIO.__enter__cCsdSrrrZ)r�rOrG�	tracebackrZrZr[�__exit__�szIO.__exit__)r�)r�)r�)r)N)rbr^r_r��propertyrrQr�r�r�r�r�rhr�r�r�r@r�r�r�r9r�r�r�r�r�r�r�r�r�r�rZrZrZr[r�.sX
r�c@s>eZdZdZeeeefed�dd��Z	edd�dd��Z
dS)	�BinaryIOrZr�cCsdSrrrZr�rZrZr[r��szBinaryIO.writerecCsdSrrrZr�rZrZr[r��szBinaryIO.__enter__N)rbr^r_r�rrrn�	bytearrayrhr�r�rZrZrZr[r��s
r�c@s�eZdZdZeeed�dd���Zeeed�dd���Z	eee
ed�dd���Zeeed�d	d
���Z
eeed�dd���Zedd�d
d��ZdS)�TextIOrZrecCsdSrrrZr�rZrZr[�buffer�sz
TextIO.buffercCsdSrrrZr�rZrZr[�encoding�szTextIO.encodingcCsdSrrrZr�rZrZr[�errors�sz
TextIO.errorscCsdSrrrZr�rZrZr[�line_buffering�szTextIO.line_bufferingcCsdSrrrZr�rZrZr[�newlines�szTextIO.newlinescCsdSrrrZr�rZrZr[r��szTextIO.__enter__N)rbr^r_r�r�rr�r�rQr�rr�r�r�rr�r�rZrZrZr[r��s$r�c@s"eZdZdddgZeZeZeZdS)�ior�r�r�N)rbr^r_�__all__r�r�r�rZrZrZr[r��s
r�z.ioc@seZdZddgZeZeZdS)�re�Pattern�MatchN)rbr^r_r�r�r�rZrZrZr[r��sr�z.re)T)NN)T)N)�rrrrZcollections.abcr7r�rr�Z	stdlib_rer�r`rrrr�r\rerqrvr~r�r�r�r�r�r�rUrrIr	r
rrr
rrr�r�rRrrr�r�Z_TYPING_INTERNALSZ_SPECIAL_NAMESr,r/r2r3r4r=r8rrKrArHra�BuiltinFunctionType�
MethodTyperOrPrErDrCrGrHrZrJrBr\r]r^r_r`rarbrOrcrnrQr@rdrr%r(r'r&rrr,r#rr)rr'r;rr!rrr"r rrprrsr9r�r6r�r�r<rrrr$r5rr6r+r�r7r�r8r:r5r4r?r*rr2r0r/r.r1r-r3rxr�rmrr=r�r�r�r�r>rFrLrMr�r�r�r�rbrMr�r�rZrZrZr[�<module>s&�X
!
	
I��
�����2a�
/[����	b�
V	
�
�	�							@+c#