xjE UdZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z m Z ddlmZmZddlZddlmZmZmZmZdZejddd kZd ed ed e fd Zd ed ed e fdZeddZde_eddZde_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%_d3ed e&fd4Z'ed5d6Z(d7e(_ed8d9Z)d:e)_ed;d<Z*d=e*_ed>d?Z+d@e+_edAdBZ,dCe,_edDdEZ-dFe-_edGdHZ.dIe._edJdKZ/dLe/_edMdNZ0dOe0_edPdQZ1dRe1_edSdTZ2dUe2_edVdWZ3dXe3_edYdZZ4d[e4_ed\d]Z5d^e5_ed_d`Z6dae6_edbdcZ7er d3ed ddfdeZ8n edbdfZ8dge8_edhdiZ9dje9_ejdkkrejejfZ:d3ed dlfdmZ;nejZj=ej?ej>j?ej@ej>j@ejAej>jAejBej>jBejCej>jCejDej>jDejEej>jEejFej>jFejGej>jGejHej>jHejIej>jIejJej>jKejLej>jLejMej>jMejNej>jNejOej>jOiejPej>jPejQeRejSeTejUejVejKeWejXeYejZej>jZej[ej>j[ej\ej>j\ej]ej>j]ej^e_ej`ejaejbejbejcejcejdejdejeej>jeejfej>jfejgehejiejiejjejjejkejlejmejniZoee_eehefepdp< dqeoqDZree_esehefepdr< eTeoqD]\ZtZueveetjwdxZxeueoex<dS)szLow-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 GenericAliasNoneType)AnyFinal) LiteralString TypeAliasTypeTypeIs deprecated)"DEPRECATED_ALIASESDEPRECATED_ALIASES_IDSr is_annotatedis_any is_classvaris_concatenate is_deprecatedis_final is_forwardref is_generic is_literalis_literalstring is_namedtupleis_never is_newtype is_nodefaultis_noextraitems 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_namereturnctt|}tt|}dti}|rE|rCt t|}t t|}||ur||d<d}nM||d<||d<d}n@|r|st t||d<d}n!|s|rt t||d<d}nd}t d|d |d }i} t ||| | |S) asCreate a function checking that the function argument is the (unparameterized) 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. 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 ``` 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 r1r2 in_typingin_typing_extensionsglobals_t_objte_obj check_code func_codelocals_s QC:\Projects\Historical\venv\Lib\site-packages\typing_inspection/typing_objects.py _compile_identity_check_functionrK=sF&''I"#4f== %s|H)''*F33 F??$HV &JJ!&HX "(HY :JJ /"6622" /"#4f=="     I !GHg&&& = !!c tt|}tt|}dti}|rB|r@t t|}t t|}||ur||d<d}nJ||f|d<d}n@|r|st t||d<d}n!|s|rt t||d<d}nd}t d|d|d |d }i} 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. rr5zisinstance(obj, _obj)_objszisinstance(obj, _objs)r8r9z(obj: Any, /) -> 'TypeIs[z]': return r:r;rAs rJ"_compile_isinstance_check_functionrOtsM ''I"#4f== %s|H)''*F33 F??$HV 0JJ!&HW 1JJ /"6622, /"#4f==,   17  I !GHg&&& = !!rL Annotatedrz 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 ``` ForwardRefrz Return whether the argument is an instance of [`ForwardRef`][typing.ForwardRef]. ```pycon >>> is_forwardref(ForwardRef('T')) True ``` 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 ``` 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`). objcvt|to$t|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 issubclasstupler<rZs rJrr9s2& c4 WZU%;%; WY@W@WWrLr rz 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 ``` NewTyperz 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 ``` NoExtraItemsrzy Return whether the argument is the `NoExtraItems` sentinel object. ```pycon >>> is_noextraitems(NoExtraItems) 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 ``` 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_innerzTypeIs[TypeAliasType]cLt|tuot|SN)r^rroras rJr'r's!Cyy ,M1H1M1MMrLr'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]c,t|tSrq)r]_deprecated_typesras rJrrs#0111rLc,t|tSrq)r]_deprecated_typeras rJrr#s#/000rLa+ 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 c4i|]\}}t||S)id).0kvs rJ r~es$6g6g6gDAqr!uua6g6g6grLr)y__doc__collections.abc collections contextlibresysr=warningstextwraprtypesrrrrrr>r r r r __all__ version_info _IS_PY310rKrOrrrrrrrrr r*r+r,boolrrrrrrrrr!r"r#r$r%r&r(r)ror'r-rurrwHashableabc Awaitable Coroutine AsyncIterable AsyncIteratorIterableIterator ReversibleSized Container CollectionCallable AbstractSetSet MutableSetMappingMutableMappingSequenceMutableSequenceTupler`ListlistDequedequeset FrozenSet frozenset MappingViewKeysView ItemsView ValuesViewDictdict DefaultDict defaultdict OrderedDictCounterChainMap GeneratorAsyncGeneratorTyper^PatternMatchContextManagerAbstractContextManagerAsyncContextManagerAbstractAsyncContextManagerr __annotations__itemsrintaliastargetr?__name__te_aliasryrLrJrsG  6666666666NNNNNNNNNNNN# J  RaR G + 4"]4"=4"]i4"4"4"4"n&"}&"]&"_k&"&"&"&"V0/ ^LL    * )% : :/.z=II   21-AQRR  , +GZ @ @ 32<QQ  . -i F F   . -i F F   21+~NN  0 / < H H  54^EVWW , +GZ @ @$XsX$XXXX443OEWXX , +GZ @ @0 / < H H  0/ ^LL  32>CTUU/.z=II   21-AQRR65oGYZZ878IK_``/.z=II  /.z=II   + *69 = =0/ ^LL  0/ ^LL   - ,X{ C C  =<_Nghh _ NcN)@NNNNN:9/K]^^ - ,X{ C C   w!,.?.JK232&:22222)3131&:1111  +3 O[_-+3 ko/+3 ko/+3 +/7 +3  +/7 +3  O[_- +3 O[_-+3 {1+3 L+/'+3 ko/+3 {1+3 O[_-+3  ++3 {1+3  NKO+!+3" ;?9#+3$ O[_-%+3+3& KO;'+3( L%)+3* K++3, L+#-+3. J/+30 i1+32  33+34 O[_-5+36 ko/7+38 {19+3: K;+3<  /=+3>  /?+3@ NK'A+3B O[)C+3D ko/E+3F ;?9G+3+3H K NBJ L"( :<  FS+3+3E$sDI~./+++XA7h6gL^LdLdLfLf6g6g6gd3S >23gggWT,224455..ME6G-u~tDDDQ'-8$..rL