+ VjE aRltx0tRt^RIt^RIt^RIt^RIt^RIt^RIt^RI H t ^RI H t H t Ht^RIHtHt^RIt^RIHtHtHtHtRmt]P.R#,Rn8HtR$R%ltR&R'lt]!R(R4tR)]n]!R*R4tR+]n]!R,R4tR-]n]!R.R 4tR/]n]!R0R 4tR1]n]!R2R 4t R3] n]!R4R 4t!R5]!n]!R6R 4t"R7]"n]!R8R4t#R9]#n]!R:R4t$R;]$n]!RR!4t&R?]&nR@RAlt']!RBR4t(RC](n]!RDR4t)RE])n]!RFR4t*RG]*n]!RHR4t+RI]+n]!RJR4t,RK],n]!RLR4t-RM]-n]!RNR4t.RO].n]!RPR4t/RQ]/n]!RRR4t0RS]0n]!RTR4t1RU]1n]!RVR4t2RW]2n]!RXR4t3RY]3n]!RZR4t4R[]4n]!R\R4t5R]]5n]!R^R4t6R_]6n]!R`Ra4t7]'dRbRclt8M ]!R`R4t8Rd]8n]!ReR"4t9Rf]9n]P.Ro8d ]P*]P*3t:RgRhlt;M]P*t>> 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 ``` r_objz obj is _obj_t_obj_te_objzobj is _t_obj or obj is _te_objFalse def z&(obj: Any, /) -> bool: return  hasattrtypingtyping_extensionsrgetattrrexec r,r- in_typingin_typing_extensionsglobals_t_objte_obj check_code func_codelocals_s && r1 _compile_identity_check_functionrJ=s&'I"#4f= %s|H)'*F3 ?$V &J!&X "(Y :J /"662" /"#4f="   | I !Gg&  !!r3c<V^8dQhR\R\R\/#r+r/)r0s"r1r2r2ts"&"&"}&"]&"_k&"r3c \\V4p\\V4pR\/pV'd>V'd6\ \V4p\ \V4pWVJdWTR&RpMWWV3VR&RpMNV'dV'g\ \V4VR&RpM(V'gV'd\ \V4VR&RpMRp\ RV RV R V R 24p/p \ WV 4W,#) 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. rr5zisinstance(obj, _obj)_objszisinstance(obj, _objs)r8r9z(obj: Any, /) -> 'TypeIs[z]': return r:r;rAs && r1"_compile_isinstance_check_functionrNts 'I"#4f= %s|H)'*F3 ?$V 0J!&HW 1J /"662, /"#4f=,   09| I !Gg&  !!r3 Annotatedz Return whether the argument is the [`Annotated`][typing.Annotated] [special form][]. ```pycon >>> is_annotated(Annotated) True >>> is_annotated(Annotated[int, ...]) False ``` rzm Return whether the argument is the [`Any`][typing.Any] [special form][]. ```pycon >>> is_any(Any) True ``` ClassVarz Return whether the argument is the [`ClassVar`][typing.ClassVar] [type qualifier][]. ```pycon >>> is_classvar(ClassVar) True >>> is_classvar(ClassVar[int]) >>> False ``` Concatenatez Return whether the argument is the [`Concatenate`][typing.Concatenate] [special form][]. ```pycon >>> is_concatenate(Concatenate) True >>> is_concatenate(Concatenate[int, P]) False ``` rz Return whether the argument is the [`Final`][typing.Final] [type qualifier][]. ```pycon >>> is_final(Final) True >>> is_final(Final[int]) False ``` ForwardRefz Return whether the argument is an instance of [`ForwardRef`][typing.ForwardRef]. ```pycon >>> is_forwardref(ForwardRef('T')) True ``` Genericz Return whether the argument is the [`Generic`][typing.Generic] [special form][]. ```pycon >>> is_generic(Generic) True >>> is_generic(Generic[T]) False ``` Literalz Return whether the argument is the [`Literal`][typing.Literal] [special form][]. ```pycon >>> is_literal(Literal) True >>> is_literal(Literal["a"]) False ``` ParamSpecz Return whether the argument is an instance of [`ParamSpec`][typing.ParamSpec]. ```pycon >>> P = ParamSpec('P') >>> is_paramspec(P) True ``` TypeVarz Return whether the argument is an instance of [`TypeVar`][typing.TypeVar]. ```pycon >>> T = TypeVar('T') >>> is_typevar(T) True ``` TypeVarTuplez Return whether the argument is an instance of [`TypeVarTuple`][typing.TypeVarTuple]. ```pycon >>> Ts = TypeVarTuple('Ts') >>> is_typevartuple(Ts) True ``` Uniona 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`). c0V^8dQhR\R\/#)r)objr.)rbool)r0s"r1r2r29sXXsX$Xr3cz\V\4;'d%\V\4;'d \ VR4#)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 issubclasstupler<rZs"r1 is_namedtuplerc9s/& c4 W WZU%; W WY@WWr3rz Return whether the argument is the [`LiteralString`][typing.LiteralString] [special form][]. ```pycon >>> is_literalstring(LiteralString) True ``` Neverzu Return whether the argument is the [`Never`][typing.Never] [special form][]. ```pycon >>> is_never(Never) True ``` NewTypez Return whether the argument is a [`NewType`][typing.NewType]. ```pycon >>> UserId = NewType("UserId", int) >>> is_newtype(UserId) True ``` NoDefaultz Return whether the argument is the [`NoDefault`][typing.NoDefault] sentinel object. ```pycon >>> is_nodefault(NoDefault) True ``` NoExtraItemszy Return whether the argument is the `NoExtraItems` sentinel object. ```pycon >>> is_noextraitems(NoExtraItems) True ``` NoReturnz Return whether the argument is the [`NoReturn`][typing.NoReturn] [special form][]. ```pycon >>> is_noreturn(NoReturn) True >>> is_noreturn(Never) False ``` NotRequiredz Return whether the argument is the [`NotRequired`][typing.NotRequired] [special form][]. ```pycon >>> is_notrequired(NotRequired) True ``` ParamSpecArgsz Return whether the argument is an instance of [`ParamSpecArgs`][typing.ParamSpecArgs]. ```pycon >>> P = ParamSpec('P') >>> is_paramspecargs(P.args) True ``` ParamSpecKwargsz Return whether the argument is an instance of [`ParamSpecKwargs`][typing.ParamSpecKwargs]. ```pycon >>> P = ParamSpec('P') >>> is_paramspeckwargs(P.kwargs) True ``` ReadOnlyz Return whether the argument is the [`ReadOnly`][typing.ReadOnly] [special form][]. ```pycon >>> is_readonly(ReadOnly) True ``` Requiredz Return whether the argument is the [`Required`][typing.Required] [special form][]. ```pycon >>> is_required(Required) True ``` Selfzq Return whether the argument is the [`Self`][typing.Self] [special form][]. ```pycon >>> is_self(Self) True ``` TypeAliasz Return whether the argument is the [`TypeAlias`][typing.TypeAlias] [special form][]. ```pycon >>> is_typealias(TypeAlias) True ``` TypeGuardz Return whether the argument is the [`TypeGuard`][typing.TypeGuard] [special form][]. ```pycon >>> is_typeguard(TypeGuard) True ``` r zy Return whether the argument is the [`TypeIs`][typing.TypeIs] [special form][]. ```pycon >>> is_typeis(TypeIs) True ``` r _is_typealiastype_innerc(V^8dQhR\RR/#)r)rZr.zTypeIs[TypeAliasType]r)r0s"r1r2r2sNNcN)@Nr3cJ\V4\J;'d \V4#N)r_rrqrbs"r1r"r"sCy ,MM1H1MMr3a' 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 ``` Unpackz Return whether the argument is the [`Unpack`][typing.Unpack] [special form][]. ```pycon >>> is_unpack(Unpack) True >>> is_unpack(Unpack[Ts]) False ``` c(V^8dQhR\RR/#r)rZr.zTypeIs[deprecated]rs)r0s"r1r2r2s2232&:2r3c"\V\4#ru)r^_deprecated_typesrbs"r1 is_deprecatedr{s#011r3c(V^8dQhR\RR/#rxrs)r0s"r1r2r2#s1131&:1r3c"\V\4#ru)r^_deprecated_typerbs"r1r{r{#s#/00r3a+ 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 ``` cV^8dQh/^\9d1\\\\\,3,,;R&^\9d1\\\ \\,3,,;R&#)r)DEPRECATED_ALIASESDEPRECATED_ALIASES_IDS)__conditional_annotations__rdictrr_int)r0s"r1r2r2s]j++E$sDI~./+kHhgd3S >23gIr3)"rrrr r rrr{rrrrrrcrrrrrrrrrrrr r!r"r#r$r%r&r'r() )r )yr__doc__collections.abc collections contextlibresysr=warningstextwraprtypesrrrrrr>rr r r __all__ version_info _IS_PY310rJrNr r rrrrrrrr%r&r'rcrrrrrrrrrrrr r!r#r$rqr"r(rzr{r~Hashableabc Awaitable Coroutine AsyncIterable AsyncIteratorIterableIterator ReversibleSized Container CollectionCallable AbstractSetSet MutableSetMappingMutableMappingSequenceMutableSequenceTupleraListlistDequedequeset FrozenSet frozenset MappingViewKeysView ItemsView ValuesViewDictr DefaultDict defaultdict OrderedDictCounterChainMap GeneratorAsyncGeneratorTyper_PatternMatchContextManagerAbstractContextManagerAsyncContextManagerAbstractAsyncContextManagerritemsidraliastargetr?__name__te_aliasr2)kvrs00@r1rs 66NN# J   R G + 4"n&"V0 ^L    *% :/z=I   2-AQR  ,GZ @ 3<Q  .i F   .i F   2+~N  0 < H  5^EVW ,GZ @$X44OEWX ,GZ @0 < H  0 ^L  3>CTU/z=I   2-AQR6oGYZ88IK_`/z=I  /z=I   +69 =0 ^L  0 ^L   -X{ C  =_Ngh N:/K]^ -X{ C   w!,,.?.J.JK2)331  +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+3+XAM_LdLdLf6gLfDAr!uaxLf6ggW,2245ME6-u~~tDDQ'-8$6 7hs2]