o /Zh@ @s"UdZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z ddlm Z mZddlZddlmZmZmZmZdZejddd kZd ed ed e fd dZd ed ed e fddZejd krnddl mZnedZeddZde_eddZde_eddZde_eddZde_eddZd e_ed!d"Z d#e _ed$d%Z!d&e!_ed'd(Z"d)e"_ed*d+Z#d,e#_ed-d.Z$d/e$_ed0d1Z%d2e%_d3e d e&fd4d5Z'ed6d7Z(d8e(_ed9d:Z)d;e)_ejd kredd=Z*d?e*_ed@dAZ+dBe+_edCdDZ,dEe,_edFdGZ-dHe-_edIdJZ.dKe._edLdMZ/dNe/_edOdPZ0dQe0_edRdSZ1dTe1_edUdVZ2dWe2_edXdYZ3dZe3_ed[d\Z4d]e4_ed^d_Z5d`e5_edadbZ6erdd3e d dcfdddeZ7nedadeZ7dfe7_edgdhZ8die8_ejdjkrd3e d dkfdldmZ9n d3e d dkfdndmZ9doe9_iej:ej;j:ejej;j>ej?ej;j?ej@ej;j@ejAej;jAejBej;jBejCej;jCejDej;jDejEej;jEejFej;jFejGej;jHejIej;jIejJej;jJejKej;jKejLej;jLiejMej;jMejNeOejPeQejRejSejHeTejUeVejWej;jWejXej;jXejYej;jYejZej;jZej[e\ej]ej^ej_ej_ej`ej`ejaejaejbej;jbejcej;jcejdeejeejeejfejfejgejhejiejjiZkee\e ee feldp< eQekmD]\ZnZoepeenjqdZrdureoeker<qydS)qzLow-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)AnyFinal) LiteralString TypeAliasTypeTypeIs deprecated)DEPRECATED_ALIASESNoneType is_annotatedis_any is_classvaris_concatenate is_deprecatedis_final is_generic is_literalis_literalstring is_namedtupleis_never is_newtype is_nodefault is_noreturnis_notrequired is_paramspecis_paramspecargsis_paramspeckwargs is_readonly is_requiredis_self is_typealiasis_typealiastype is_typeguard is_typeis is_typevaris_typevartupleis_union is_unpack) member function_namereturncCstt|}tt|}|r'|r'tt|tt|urd|}nd|d|}n|r1|s1d|}n |s;|r;d|}nd}td|d|d}i}tttd}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 ``` zobj is typing.z or obj is typing_extensions.zobj is typing_extensions.False def z&(obj: Any, /) -> bool: return  rtypingtyping_extensionshasattrr4r5getattrrrexecr-r.Z in_typingZin_typing_extensionsZ check_code func_codeZlocals_globals_r=W/var/www/html/lang_env/lib/python3.10/site-packages/typing_inspection/typing_objects.py _compile_identity_check_function:s(        r?cCstt|}tt|}|r)|r)tt|tt|urd|d}n"d|d|d}n|r4|s4d|d}n |s?|r?d|d}nd}td|d |d |d }i}tttd }t|||||S) aCreate 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. zisinstance(obj, typing.)zisinstance(obj, (typing.z, typing_extensions.z))z"isinstance(obj, typing_extensions.r0r1z(obj: Any, /) -> 'TypeIs[z]': return r2r3r6r:r=r=r>"_compile_isinstance_check_functiongs,     rA)r Annotatedr z Return whether the argument is the [`Annotated`][typing.Annotated] [special form][]. ```pycon >>> is_annotated(Annotated) True >>> is_annotated(Annotated[int, ...]) False ``` rrzm Return whether the argument is the [`Any`][typing.Any] [special form][]. ```pycon >>> is_any(Any) True ``` ClassVarrz Return whether the argument is the [`ClassVar`][typing.ClassVar] [type qualifier][]. ```pycon >>> is_classvar(ClassVar) True >>> is_classvar(ClassVar[int]) >>> False ``` Concatenaterz Return whether the argument is the [`Concatenate`][typing.Concatenate] [special form][]. ```pycon >>> is_concatenate(Concatenate) True >>> is_concatenate(Concatenate[int, P]) False ``` rrz Return whether the argument is the [`Final`][typing.Final] [type qualifier][]. ```pycon >>> is_final(Final) True >>> is_final(Final[int]) False ``` Genericrz Return whether the argument is the [`Generic`][typing.Generic] [special form][]. ```pycon >>> is_generic(Generic) True >>> is_generic(Generic[T]) False ``` Literalrz Return whether the argument is the [`Literal`][typing.Literal] [special form][]. ```pycon >>> is_literal(Literal) True >>> is_literal(Literal["a"]) False ``` ParamSpecrz 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`). objcCst|tot|tot|dS)aReturn 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) isinstancetype issubclasstupler7rKr=r=r>rsrrrz Return whether the argument is the [`LiteralString`][typing.LiteralString] [special form][]. ```pycon >>> is_literalstring(LiteralString) True ``` Neverrzu Return whether the argument is the [`Never`][typing.Never] [special form][]. ```pycon >>> is_never(Never) True ``` NewTypercCs t|dS)N __supertype__)r7rQr=r=r>rMs z Return whether the argument is a [`NewType`][typing.NewType]. ```pycon >>> UserId = NewType("UserId", int) >>> is_newtype(UserId) True ``` NoDefaultrz Return whether the argument is the [`NoDefault`][typing.NoDefault] sentinel object. ```pycon >>> is_nodefault(NoDefault) True ``` NoReturnrz Return whether the argument is the [`NoReturn`][typing.NoReturn] [special form][]. ```pycon >>> is_noreturn(NoReturn) True >>> is_noreturn(Never) False ``` NotRequiredrz Return whether the argument is the [`NotRequired`][typing.NotRequired] [special form][]. ```pycon >>> is_notrequired(NotRequired) True ``` ParamSpecArgsrz Return whether the argument is an instance of [`ParamSpecArgs`][typing.ParamSpecArgs]. ```pycon >>> P = ParamSpec('P') >>> is_paramspecargs(P.args) True ``` ParamSpecKwargsrz Return whether the argument is an instance of [`ParamSpecKwargs`][typing.ParamSpecKwargs]. ```pycon >>> P = ParamSpec('P') >>> is_paramspeckwargs(P.kwargs) True ``` ReadOnlyrz 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_innerzTypeIs[TypeAliasType]cCst|tuo t|SN)rNrr_rQr=r=r>r#sr#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+ zTypeIs[deprecated]cCst|tjtjfSr`)rMwarningsr r5rQr=r=r>rsrcCs t|tjSr`)rMr5r rQr=r=r>rs 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')) True ``` r )s__doc__collections.abc collections contextlibresysr4rctextwraprtypesrrrrr5rrr r __all__ version_infoZ _IS_PY310r?rAr rNr rrrrrrrr&r'r(boolrrrrrrrrrrr r!r"r$r%r_r#r)rHashableabc Awaitable Coroutine AsyncIterable AsyncIteratorIterableIterator ReversibleSized Container CollectionCallable AbstractSetSet MutableSetMappingMutableMappingSequenceMutableSequenceTuplerPListlistDequedequeset FrozenSet frozenset MappingViewKeysView ItemsView ValuesViewDictdict DefaultDict defaultdict OrderedDictCounterChainMap GeneratorAsyncGeneratorTypePatternMatchContextManagerAbstractContextManagerAsyncContextManagerAbstractAsyncContextManagerr __annotations__itemsaliastargetr8_nameZte_aliasr=r=r=r>sH "-                                                     ! " #$,