h@ P%SrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ r SSK J r J r SSKJ r Jr SSKrSSKJrJrJrJr Sr\R*SSS :HrS \S \S \ 4S jrS \S \S \ 4Sjr\R*S :aSSK Jr O\"S5r\"SS5rS\l\"SS5rS\l\"SS5rS\l\"SS5rS\l\"SS5rS\l\"SS 5r S!\ l\"S"S#5r!S$\!l\"S%S&5r"S'\"l\"S(S)5r#S*\#l\"S+S,5r$S-\$l\"S.S/5r%S0\%lS1\ S \&4S2jr'\"S3S45r(S5\(l\"S6S75r)S8\)l\R*S :a \"S9S:5r*O S1\ S \&4S;jr*S<\*l\"S=S>5r+S?\+l\"S@SA5r,SB\,l\"SCSD5r-SE\-l\"SFSG5r.SH\.l\"SISJ5r/SK\/l\"SLSM5r0SN\0l\"SOSP5r1SQ\1l\"SRSS5r2ST\2l\"SUSV5r3SW\3l\"SXSY5r4SZ\4l\"S[S\5r5S]\5l\"S^S_5r6\(a S1\ S S`4Sajr7O \"S^Sb5r7Sc\7l\"SdSe5r8Sf\8l\R*Sg:a S1\ S Sh4Sijr9O S1\ S Sh4Sjjr9Sk\9l0\Rt\RvRt_\Rx\RvRx_\Rz\RvRz_\R|\RvR|_\R~\RvR~_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\RvR_0\R\RvR_\R\O_\R\Q_\R\R_\R\T_\R\V_\R\RvR_\R\RvR_\R\RvR_\R\RvR_\R\\_\R\R_\R\R_\R\R_\R\R_\R\RvR_\R\RvR_E\R\\R\R\R\R\R\R\R\R0Erk\\\\ \\ 4\lSl'\Q"\kR55H$urnro\p"\\nRS5=rrcM\o\k\r'M& g)mzLow-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_namereturnc~[[U5n[[U5nU(a7U(a0[[U5[[U5LaSU3nO3SUSU3nO*U(a U(dSU3nOU(d U(aSU3nOSn[ SUSUS35n0n[ [[S.n[ XWU5 Xa$) aECreate 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_extensionshasattrr6r7getattrrrexecr.r/ in_typingin_typing_extensions check_code func_codelocals_globals_s R/var/www/html/env/lib/python3.13/site-packages/typing_inspection/typing_objects.py _compile_identity_check_functionrD:s&'I"#4f=) 66 "g.?&H H)&2J)&1NvhWJ /%fX. /09   | I !G'*fSdeHg&  !!c [[U5n[[U5nU(a9U(a2[[U5[[U5LaSUS3nO6SUSUS3nO,U(aU(dSUS3nOU(dU(aSUS3nOSn[ SUS US US 35n0n[ [[S .n[ XWU5 Xa$) 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. zisinstance(obj, typing.)zisinstance(obj, (typing.z, typing_extensions.z))z"isinstance(obj, typing_extensions.r2r3z(obj: Any, /) -> 'TypeIs[z]': return r4r5r8r<s rC"_compile_isinstance_check_functionrHgs 'I"#4f=) 66 "g.?&H H26(!>> 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`). objcv[U[5=(a# [U[5=(a [ US5$)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 issubclasstupler9rRs rCrrs)& c4 WZU%; WY@WWrErrz 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 ``` NewTyperc[US5$)N __supertype__)r9rYs rCrrMssO,,rEz 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 ``` 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_innerzTypeIs[TypeAliasType]cH[U5[L=(a [U5$N)rVrrhrYs rCr$r$sCy ,M1H1MMrEr$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]cV[U[R[R45$rj)rUwarningsr r7rYs rCrrs!# 3 35F5Q5QRSSrEc6[U[R5$rj)rUr7r rYs rCrrs#0;;<>> is_deprecated(warnings.deprecated('message')) True >>> is_deprecated(typing_extensions('deprecated')) True ``` r )s__doc__collections.abc collections contextlibresysr6rntextwraprtypesrrrrr7rr r r __all__ version_info _IS_PY310rDrHr rVrrrrrrrrr'r(r)boolrrrrrrrrrr r!r"r#r%r&rhr$r*rHashableabc Awaitable Coroutine AsyncIterable AsyncIteratorIterableIterator ReversibleSized Container CollectionCallable AbstractSetSet MutableSetMappingMutableMappingSequenceMutableSequenceTuplerXListlistDequedequeset FrozenSet frozenset MappingViewKeysView ItemsView ValuesViewDictdict DefaultDict defaultdict OrderedDictCounterChainMap GeneratorAsyncGeneratorTypePatternMatchContextManagerAbstractContextManagerAsyncContextManagerAbstractAsyncContextManagerr __annotations__itemsaliastargetr:_namete_aliasrErCrs ,NN D   Ra G + *"]*"=*"]i*"Z"}"]"_k"@wDzH0 ^L    *% :/z=I   2-AQR  ,GZ @ .i F   .i F   2+~N  0 < H  5^EVW ,GZ @$XsX$X44OEWX ,GZ @w3I|LJ--4- 0 ^L  /z=I   2-AQR6oGYZ88IK_`/z=I  /z=I   +69 =0 ^L  0 ^L   -X{ C  =_Ngh NcN)@N:/K]^ -X{ C   wT3T&:T =3=&:=  +3 OO[__--+3 koo//+3 koo//+3 +//77 +3  +//77 +3  OO[__-- +3 OO[__--+3 {11+3 LL+//''+3 koo//+3 {11+3 OO[__--+3  +++3 {11+3  NNKOO++!+3" ;??99#+3$ OO[__--%+3& KOO;;'+3( LL%)+3* KK++3, LL+##-+3. JJ/+30 i1+32  333+34 OO[__--5+36 koo//7+38 {119+3: KK;+3<  //=+3>  //?+3@ NNK''A+3B OO[))C+3D koo//E+3F ;??99G+3H KK NNBJJ LL"(( :<<  F FS+3E$sDI~./+XA,2245ME6-u{{DAAN'-8$6rE