
    |;3hB                     J   U d Z ddlZddlZddlZddlZddlZddlZddlm	Z	 ddl
mZmZ ddlmZmZ ddlZddlmZmZmZmZ dZej*                  dd d	k(  Zd
ededefdZd
ededefdZej*                  d	k\  rddl
mZ n ed      Z edd      Zde_          edd      Zde_          edd      Zde_          edd      Zde_          edd      Zde_          edd       Z d!e _          ed"d#      Z!d$e!_          ed%d&      Z"d'e"_          ed(d)      Z#d*e#_          ed+d,      Z$d-e$_          ed.d/      Z%d0e%_          ed1d2      Z&d3e&_         d4ede'fd5Z( ed6d7      Z)d8e)_          ed9d:      Z*d;e*_         ej*                  d	k\  r
 ed<d=      Z+nd4ede'fd>Z+d?e+_          ed@dA      Z,dBe,_          edCdD      Z-dEe-_          edFdG      Z.dHe._          edIdJ      Z/dKe/_          edLdM      Z0dNe0_          edOdP      Z1dQe1_          edRdS      Z2dTe2_          edUdV      Z3dWe3_          edXdY      Z4dZe4_          ed[d\      Z5d]e5_          ed^d_      Z6d`e6_          edadb      Z7er	d4eddcfddZ8n	 edade      Z8dfe8_          edgdh      Z9die9_         ej*                  djk\  r	d4eddkfdlZ:nd4eddkfdmZ:dne:_         i ejv                  ejx                  jv                  ejz                  ejx                  jz                  ej|                  ejx                  j|                  ej~                  ejx                  j~                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  i ej                  ejx                  j                  ej                  ePej                  eRej                  ej                  ej                  eUej                  eWej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  e]ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ejx                  j                  ej                  ejx                  j                  ej                  eej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  iZlee]eee   f      emdo<   	  eRelj                               D ]!  \  ZoZp eqeeoj                  d      xZsepeles<   # y)pzLow-level introspection utilities for [`typing`][] members.

The provided functions in this module check against both the [`typing`][] and [`typing_extensions`][]
variants, if they exists and are different.
    N)dedent)FunctionTypeGenericAlias)AnyFinal)LiteralStringTypeAliasTypeTypeIs
deprecated) DEPRECATED_ALIASESNoneTypeis_annotatedis_anyis_classvaris_concatenateis_deprecatedis_finalis_forwardref
is_generic
is_literalis_literalstringis_namedtupleis_never
is_newtypeis_nodefaultis_noreturnis_notrequiredis_paramspecis_paramspecargsis_paramspeckwargsis_readonlyis_requiredis_selfis_typealiasis_typealiastypeis_typeguard	is_typeis
is_typevaris_typevartupleis_union	is_unpack   )   
   memberfunction_namereturnc                 D   t        t        |       }t        t        |       }|r1|r/t        t        |       t        t        |       u rd|  }nd|  d|  }n|r|sd|  }n|s|rd|  }nd}t	        d| d| d      }i }t
        t        t        d}t        |||       ||   S )	a}  Create a function checking that the function argument is the (unparameterized) typing :paramref:`member`.

    The function will make sure to check against both the `typing` and `typing_extensions`
    variants as depending on the Python version, the `typing_extensions` variant might be different.
    For instance, on Python 3.9:

    ```pycon
    >>> from typing import Literal as t_Literal
    >>> from typing_extensions import Literal as te_Literal, get_origin

    >>> t_Literal is te_Literal
    False
    >>> get_origin(t_Literal[1])
    typing.Literal
    >>> get_origin(te_Literal[1])
    typing_extensions.Literal
    ```
    zobj is typing.z or obj is typing_extensions.zobj is typing_extensions.False	
    def z&(obj: Any, /) -> bool:
        return 
    r   typingtyping_extensionshasattrr7   r8   getattrr   r   execr/   r0   	in_typingin_typing_extensions
check_code	func_codelocals_globals_s           `/var/www/html/audio-gradio/venv/lib/python3.12/site-packages/typing_inspection/typing_objects.py _compile_identity_check_functionrE   ;   s    & 'I"#4f=)66"g.?&HH)&2J)&1NvhWJ	/%fX.
/09

 		 |  	I
 !G'*fSdeHHg&=!!    c           	      R   t        t        |       }t        t        |       }|r3|r1t        t        |       t        t        |       u rd|  d}n"d|  d|  d}n|r	|sd|  d}n|s	|rd|  d}nd}t	        d| d	|  d
| d      }i }t
        t        t        d}t        |||       ||   S )a  Create a function checking that the function is an instance of the typing `member`.

    The function will make sure to check against both the `typing` and `typing_extensions`
    variants as depending on the Python version, the `typing_extensions` variant might be different.
    zisinstance(obj, typing.)zisinstance(obj, (typing.z, typing_extensions.z))z"isinstance(obj, typing_extensions.r3   r4   z(obj: Any, /) -> 'TypeIs[z]':
        return r5   r6   r9   r=   s           rD   "_compile_isinstance_check_functionrI   h   s     'I"#4f=)66"g.?&HH26(!<J3F8;OPVxWYZJ	/.vha8
/9&C

 		0 9|  	I
 !G'*fSdeHHg&=!!rF   )r   	Annotatedr   z
Return whether the argument is the [`Annotated`][typing.Annotated] [special form][].

```pycon
>>> is_annotated(Annotated)
True
>>> is_annotated(Annotated[int, ...])
False
```
r   r   zm
Return whether the argument is the [`Any`][typing.Any] [special form][].

```pycon
>>> is_any(Any)
True
```
ClassVarr   z
Return whether the argument is the [`ClassVar`][typing.ClassVar] [type qualifier][].

```pycon
>>> is_classvar(ClassVar)
True
>>> is_classvar(ClassVar[int])
>>> False
```
Concatenater   z
Return whether the argument is the [`Concatenate`][typing.Concatenate] [special form][].

```pycon
>>> is_concatenate(Concatenate)
True
>>> is_concatenate(Concatenate[int, P])
False
```
r   r   z
Return whether the argument is the [`Final`][typing.Final] [type qualifier][].

```pycon
>>> is_final(Final)
True
>>> is_final(Final[int])
False
```

ForwardRefr   z
Return whether the argument is an instance of [`ForwardRef`][typing.ForwardRef].

```pycon
>>> is_forwardref(ForwardRef('T'))
True
```
Genericr   z
Return whether the argument is the [`Generic`][typing.Generic] [special form][].

```pycon
>>> is_generic(Generic)
True
>>> is_generic(Generic[T])
False
```
Literalr   z
Return whether the argument is the [`Literal`][typing.Literal] [special form][].

```pycon
>>> is_literal(Literal)
True
>>> is_literal(Literal["a"])
False
```
	ParamSpecr   z
Return whether the argument is an instance of [`ParamSpec`][typing.ParamSpec].

```pycon
>>> P = ParamSpec('P')
>>> is_paramspec(P)
True
```
TypeVarr(   z
Return whether the argument is an instance of [`TypeVar`][typing.TypeVar].

```pycon
>>> T = TypeVar('T')
>>> is_typevar(T)
True
```
TypeVarTupler)   z
Return whether the argument is an instance of [`TypeVarTuple`][typing.TypeVarTuple].

```pycon
>>> Ts = TypeVarTuple('Ts')
>>> is_typevartuple(Ts)
True
```
Unionr*   a  
Return whether the argument is the [`Union`][typing.Union] [special form][].

This function can also be used to check for the [`Optional`][typing.Optional] [special form][],
as at runtime, `Optional[int]` is equivalent to `Union[int, None]`.

```pycon
>>> is_union(Union)
True
>>> is_union(Union[int, str])
False
```

!!! warning
    This does not check for unions using the [new syntax][types-union] (e.g. `int | str`).
objc                b    t        | t              xr t        | t              xr t	        | d      S )a  Return whether the argument is a named tuple type.

    This includes [`NamedTuple`][typing.NamedTuple] subclasses and classes created from the
    [`collections.namedtuple`][] factory function.

    ```pycon
    >>> class User(NamedTuple):
    ...     name: str
    ...
    >>> is_namedtuple(User)
    True
    >>> City = collections.namedtuple('City', [])
    >>> is_namedtuple(City)
    True
    >>> is_namedtuple(NamedTuple)
    False
    ```
    _fields)
isinstancetype
issubclasstupler:   rT   s    rD   r   r   )  s)    & c4 WZU%;WY@WWrF   r   r   z
Return whether the argument is the [`LiteralString`][typing.LiteralString] [special form][].

```pycon
>>> is_literalstring(LiteralString)
True
```
Neverr   zu
Return whether the argument is the [`Never`][typing.Never] [special form][].

```pycon
>>> is_never(Never)
True
```
NewTyper   c                    t        | d      S )N__supertype__)r:   r[   s    rD   r   r   [  s    sO,,rF   z
Return whether the argument is a [`NewType`][typing.NewType].

```pycon
>>> UserId = NewType("UserId", int)
>>> is_newtype(UserId)
True
```
	NoDefaultr   z
Return whether the argument is the [`NoDefault`][typing.NoDefault] sentinel object.

```pycon
>>> is_nodefault(NoDefault)
True
```
NoReturnr   z
Return whether the argument is the [`NoReturn`][typing.NoReturn] [special form][].

```pycon
>>> is_noreturn(NoReturn)
True
>>> is_noreturn(Never)
False
```
NotRequiredr   z
Return whether the argument is the [`NotRequired`][typing.NotRequired] [special form][].

```pycon
>>> is_notrequired(NotRequired)
True
```
ParamSpecArgsr   z
Return whether the argument is an instance of [`ParamSpecArgs`][typing.ParamSpecArgs].

```pycon
>>> P = ParamSpec('P')
>>> is_paramspecargs(P.args)
True
```
ParamSpecKwargsr    z
Return whether the argument is an instance of [`ParamSpecKwargs`][typing.ParamSpecKwargs].

```pycon
>>> P = ParamSpec('P')
>>> is_paramspeckwargs(P.kwargs)
True
```
ReadOnlyr!   z
Return whether the argument is the [`ReadOnly`][typing.ReadOnly] [special form][].

```pycon
>>> is_readonly(ReadOnly)
True
```
Requiredr"   z
Return whether the argument is the [`Required`][typing.Required] [special form][].

```pycon
>>> is_required(Required)
True
```
Selfr#   zq
Return whether the argument is the [`Self`][typing.Self] [special form][].

```pycon
>>> is_self(Self)
True
```
	TypeAliasr$   z
Return whether the argument is the [`TypeAlias`][typing.TypeAlias] [special form][].

```pycon
>>> is_typealias(TypeAlias)
True
```
	TypeGuardr&   z
Return whether the argument is the [`TypeGuard`][typing.TypeGuard] [special form][].

```pycon
>>> is_typeguard(TypeGuard)
True
```
r
   r'   zy
Return whether the argument is the [`TypeIs`][typing.TypeIs] [special form][].

```pycon
>>> is_typeis(TypeIs)
True
```
r	   _is_typealiastype_innerzTypeIs[TypeAliasType]c                >    t        |       t        uxr t        |       S N)rX   r   rj   r[   s    rD   r%   r%     s    Cy,M1H1MMrF   r%   a'  
Return whether the argument is a [`TypeAliasType`][typing.TypeAliasType] instance.

```pycon
>>> type MyInt = int
>>> is_typealiastype(MyInt)
True
>>> MyStr = TypeAliasType("MyStr", str)
>>> is_typealiastype(MyStr):
True
>>> type MyList[T] = list[T]
>>> is_typealiastype(MyList[int])
False
```
Unpackr+   z
Return whether the argument is the [`Unpack`][typing.Unpack] [special form][].

```pycon
>>> is_unpack(Unpack)
True
>>> is_unpack(Unpack[Ts])
False
```
)r-      zTypeIs[deprecated]c                V    t        | t        j                  t        j                  f      S rl   )rW   warningsr   r8   r[   s    rD   r   r   	  s!    # 3 35F5Q5QRSSrF   c                6    t        | t        j                        S rl   )rW   r8   r   r[   s    rD   r   r     s    #0;;<<rF   a+  
Return whether the argument is a [`deprecated`][warnings.deprecated] instance.

This also includes the [`typing_extensions` backport][typing_extensions.deprecated].

```pycon
>>> is_deprecated(warnings.deprecated('message'))
True
>>> is_deprecated(typing_extensions.deprecated('message'))
True
```
r   )t__doc__collections.abccollections
contextlibresysr7   rp   textwrapr   typesr   r   r   r   r8   r   r	   r
   r   __all__version_info	_IS_PY310rE   rI   r   rX   r   r   r   r   r   r   r   r   r   r(   r)   r*   boolr   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r&   r'   rj   r%   r+   r   Hashableabc	Awaitable	CoroutineAsyncIterableAsyncIteratorIterableIterator
ReversibleSized	Container
CollectionCallableAbstractSetSet
MutableSetMappingMutableMappingSequenceMutableSequenceTuplerZ   ListlistDequedequeset	FrozenSet	frozensetMappingViewKeysView	ItemsView
ValuesViewDictdictDefaultDictdefaultdictOrderedDictCounterChainMap	GeneratorAsyncGeneratorTypePatternMatchContextManagerAbstractContextManagerAsyncContextManagerAbstractAsyncContextManagerr   __annotations__itemsaliastargetr;   _namete_alias rF   rD   <module>r      s     	 
    ,   N N!F Ra G+	*"] *"= *"]i *"Z"} "] "_k "@ wDzH 0^L	  
*%	: /z=I	  2-AQR	  ,GZ@	  3<Q  .iF
	
  .iF
	
  2+~N  0	<H

  5^EVW  ,GZ@ $Xs X$ X4 4OEWX    ,GZ@  w3I|LJ- -4 -
  0^L  /z=I	  2-AQR  6oGYZ    88IK_`    /z=I  /z=I  +69
= 0^L  0^L  -X{C		  =_Ngh  
Nc N)@ N :/K]^    -X{C			  wT3 T&: T
=3 =&: = +3
OO[__--+3
koo//+3 koo//+3 +//77	+3
 +//77+3 OO[__--+3 OO[__--+3 {11+3 LL+//''+3 koo//+3 {11+3 OO[__--+3 +++3 {11+3  NNKOO++!+3" ;??99#+3$ OO[__--%+3& KOO;;'+3( LL%)+3* KK++3, LL+##-+3. JJ/+30 i1+32 333+34 OO[__--5+36 koo//7+38 {119+3: KK;+3< //=+3> //?+3@ NNK''A+3B OO[))C+3D koo//E+3F ;??99G+3H KK
NNBJJ
LL"((
:<<

 F FS+3 E$sDI~./ +X A ,2245 .ME6-u{{DAAN'-8$.rF   