B xbe @sZdZddlZddlZddlmZdejddkr>dkrPnnddlmZn4ejdddkrpddl mZnddl m Z e e ZejdddkZ e rddl Zd Zd Zd Zd Ze r(dd l mZmZmZmZmZmZmZmZdd lmZmZejddd krddl mZeeejfZnefZn ddl mZm Z mZmZm!Z!mZm"Z"m#Z#yddl m$Z$m%Z%Wn&e&k re eZ$d Zd ZYnXyddlm'Z'WnBe&k ryddl m'Z'Wne&k rd ZYnXYnXyddlm(Z(WnBe&k r2yddl m(Z(Wne&k r,d ZYnXYnXddZ)ddZ*ddZ+ddZ,ddZ-ddZ.dd Z/d!d"Z0d#d$Z1d%d&Z2d'd(Z3d)d*Z4d+d,Z5d-d.Z6d/d0Z7d1d2Z8d3d4Z9dYd5d6Z:d7d8Z;d9d:ZZ>d?d@Z?dAdBZ@dCdDZAdEdFZBdZdGdHZCd[dIdJZDd\dKdLZEd]dMdNZFdOdPZGdQdRZHdSdTZIdUdVZJdWdXZKdS)^zDefines experimental API for runtime inspection of types defined in the standard "typing" module. Example usage:: from typing_inspect import is_generic_type N)_TypedDictMeta)rr)r ) TypedDict)rrTF)GenericCallableUnionTypeVarClassVarTuple _GenericAlias ForwardRef)FinalLiteral)rrr)_SpecialGenericAlias)r CallableMetar r TupleMetar GenericMeta _ForwardRef)_Union _ClassVar)_Final)_LiteralcCs8t|tstt|dr|jSx|jdk r2|j}q W|S)z@This function exists for compatibility with old typing versions._gorgN) isinstancerAssertionErrorhasattrr __origin__)clsr"Q/home/ankuromar296_gmail_com/.local/lib/python3.7/site-packages/typing_inspect.pyrJs    rcCsRtr8t|trt|tp6t|to6|jttt t j j fkSt|t oPt|ttf S)aTest if the given type is a generic type. This includes Generic itself, but excludes special typing constructs such as Union, Tuple, Callable, ClassVar. Examples:: is_generic_type(int) == False is_generic_type(Union[int, str]) == False is_generic_type(Union[int, T]) == False is_generic_type(ClassVar[List[int]]) == False is_generic_type(Callable[..., T]) == False is_generic_type(Generic) == True is_generic_type(Generic[T]) == True is_generic_type(Iterable[int]) == True is_generic_type(Mapping) == True is_generic_type(MutableMapping[T, List[int]]) == True is_generic_type(Sequence[Union[str, bytes]]) == True ) NEW_TYPINGrtype issubclassr typingGenericAliasr r tupler collectionsabcr rrr)tpr"r"r#is_generic_typeTs   r,cCsRtrF|tkpDt|tr$|jtjjkpDt|toDt|t oDt|tjjSt|t kS)aTest if the type is a generic callable type, including subclasses excluding non-generic types and callables. Examples:: is_callable_type(int) == False is_callable_type(type) == False is_callable_type(Callable) == True is_callable_type(Callable[..., int]) == True is_callable_type(Callable[[int, int], Iterable[str]]) == True class MyClass(Callable[[int], int]): ... is_callable_type(MyClass) == True For more general tests use callable(), for more precise test (excluding subclasses) use:: get_origin(tp) is collections.abc.Callable # Callable prior to Python 3.7 ) r$r rr'r r)r*r%r&r r)r+r"r"r#is_callable_typens r-cCsJtr>|tkpsz#is_optional_type..)evaluateF)r% is_union_typeanyget_args)r+r"r"r#r/s r/cCs0tr |tkpt|to|jtkSto.t|tkS)zTest if the type is a final type. Examples:: is_final_type(int) == False is_final_type(Final) == True is_final_type(Final[int]) == True )r$rrr'r WITH_FINALr%r)r+r"r"r# is_final_typesr8cCs,tr |tkpt|to|jtkSt|tkS)zTest if the type is a union type. Examples:: is_union_type(int) == False is_union_type(Union) == True is_union_type(Union[int, int]) == False is_union_type(Union[T, int]) == True )r$r rr'r r%r)r+r"r"r#r4sr4cCs0tr |tkpt|to|jtkSto.t|tkS)N)r$rrr'r WITH_LITERALr%r)r+r"r"r#is_literal_typesr:cCs t|tkS)zTest if the type represents a type variable. Examples:: is_typevar(int) == False is_typevar(T) == True is_typevar(Union[T, int]) == False )r%r )r+r"r"r# is_typevarsr;cCs8tr |tkpt|to|jtkStr0t|tkSdSdS)zTest if the type represents a class variable. Examples:: is_classvar(int) == False is_classvar(ClassVar) == True is_classvar(ClassVar[int]) == True is_classvar(ClassVar[List[T]]) == True FN)r$r rr'r WITH_CLASSVARr%r)r+r"r"r# is_classvars  r=cCst|dddk S)zTests if the type represents a distinct type. Examples:: is_new_type(int) == False is_new_type(NewType('Age', int)) == True is_new_type(NewType('Scores', List[Dict[str, float]])) == True __supertype__N)getattr)r+r"r"r# is_new_typesr@cCstst|tSt|tS)zTests if the type is a :class:`typing.ForwardRef`. Examples:: u = Union["Milk", Way] args = get_args(u) is_forward_ref(args[0]) == True is_forward_ref(args[1]) == False )r$rrr)r+r"r"r#is_forward_refs rAcCs:tr tdt}t|d|}||kr*dS|dkr6|S|S)aGet the last base of (multiply) subscripted type. Supports generic types, Union, Callable, and Tuple. Returns None for unsupported types. Examples:: get_last_origin(int) == None get_last_origin(ClassVar[int]) == None get_last_origin(Generic[T]) == Generic get_last_origin(Union[T, int][str]) == Union[T, int] get_last_origin(List[Tuple[T, T]][int]) == List[Tuple[T, T]] get_last_origin(List) == List zEThis function is only supported in Python 3.6, use get_origin insteadr N)r$ ValueErrorobjectr?)r+sentineloriginr"r"r#get_last_origin s  rFcCs`tr2t|tr"|jtk r|jSdS|tkr.tSdSt|trDt|St|rPt St |r\t SdS)aGet the unsubscripted version of a type. Supports generic types, Union, Callable, and Tuple. Returns None for unsupported types. Examples:: get_origin(int) == None get_origin(ClassVar[int]) == None get_origin(Generic) == Generic get_origin(Generic[T]) == Generic get_origin(Union[T, int]) == Union get_origin(List[Tuple[T, T]][int]) == list # List prior to Python 3.7 N) r$rr'r r r rrr4r r.r)r+r"r"r# get_origin%s   rGcCstr*t|rDg}x(|jdk r$|jndD]}|t|7}q(Wt|St|rg}x(|jdk rb|jndD]}|t|7}qfWt|St|r$g}|j}|dkrdSxh|D]`}xZt|rt |n|fD]@}t |rt |t st d||dkrg}||kr||qWqW|dk rt|SdSndSntrjt |ts^t |trdt|trd|tk rd|jSdSnBt|st|st|st|r|jdk r|jSdSdSdS)a>Return type parameters of a parameterizable type as a tuple in lexicographic order. Parameterizable types are generic types, unions, tuple types and callable types. Examples:: get_parameters(int) == () get_parameters(Generic) == () get_parameters(Union) == () get_parameters(List[int]) == () get_parameters(Generic[T]) == (T,) get_parameters(Tuple[List[T], List[S_co]]) == (T, S_co) get_parameters(Union[S_co, Tuple[T, T]][int, U]) == (U,) get_parameters(Mapping[T, Tuple[S_co, T]]) == (T, S_co) Nr"zKCannot inherit from a generic class parameterized with non-type-variable %s) LEGACY_TYPINGr4__union_params__get_parametersr(r.__tuple_params__r,__parameters__r6 _has_type_varrr TypeErrorappendr$r'r%r&r r-)r+paramsargZ base_paramsZbp_bpr"r"r#rJ@sP     rJcCs6trtdn"t|r.|jdk r*|jfSdSt|ry"|jdk rVt|jdkrV|jSWntk rlYnX|jdk r~|jSdSt |ry|jdk r|jSdStk r|j dk r|j SdSXnlt |r|jdk r|jSdSt |r.y|jdk r|jSdStk r*|j dk r&|j SdSXndSdS)aGet last arguments of (multiply) subscripted type. Parameters for Callable are flattened. Examples:: get_last_args(int) == () get_last_args(Union) == () get_last_args(ClassVar[int]) == (int,) get_last_args(Union[T, int]) == (T, int) get_last_args(Iterable[Tuple[T, S]][int, T]) == (int, T) get_last_args(Callable[[T], int]) == (T, int) get_last_args(Callable[[], int]) == (int,) zCThis function is only supported in Python 3.6, use get_args insteadNr"r)r$rBr=__type__r,__args__lenAttributeErrorrLr4rIr-r.rK)r+r"r"r# get_last_argss0    rWc Csg}x|D]}t|ts$||q t|drt|dd}t|dkrd|tg|dfq|dtkr|td|dfq|tt|dd|dfq |t |d |dt|ddq Wt|S)zInternal helper for get_args.rNr.) rr(rOr- _eval_argsrUr Ellipsislistr% __getitem__)argsresrQZ callable_argsr"r"r#rZs      $.rZcCstrn|dk r|stdt|trjt|drj|j}t|tjj krf|dt k rft |dd|df}|SdSt |s~t |r|jdk r|jfSdSt|r|jpdSt|st|st|st|ry |}WnTtk r(t|rt|}n,t|r t|}nt|r t|}ndSYnXt|trt|dkr|sV|ddSt|dd}t|t kr|dt k rt |dd|df}|SdS)aGet type arguments with all substitutions performed. For unions, basic simplifications used by Union constructor are performed. On versions prior to 3.7 if `evaluate` is False (default), report result as nested tuple, this matches the internal representation of types. If `evaluate` is True (or if Python version is 3.7 or greater), then all type parameters are applied (this could be time and memory expensive). Examples:: get_args(int) == () get_args(Union[int, Union[T, int], str][int]) == (int, str) get_args(Union[int, Tuple[T, int]][str]) == (int, (Tuple, str, int)) get_args(Union[int, Tuple[T, int]][str], evaluate=True) == (int, Tuple[str, int]) get_args(Dict[int, Tuple[T, T]][Optional[int]], evaluate=True) == (int, Tuple[Optional[int], Optional[int]]) get_args(Callable[[], T][int], evaluate=True) == ([], int,) Nz*evaluate can only be True in Python >= 3.7rTrrYr"rX)r$rBrr'rrTrGr)r*r r[r\r=r8rSr:Z __values__r,r4r-r. _subs_treerV_union_subs_tree_generic_subs_tree_tuple_subs_treer(rUrZ)r+r3r_treer"r"r#r6sB          r6cCs(t|rt|ddStdt|dS)zReturn the type bound to a `TypeVar` if any. It the type is not a `TypeVar`, a `TypeError` is raised. Examples:: get_bound(TypeVar('T')) == None get_bound(TypeVar('T', bound=int)) == int __bound__Nztype is not a `TypeVar`: )r;r?rNstr)r+r"r"r# get_bounds  rgcCs(t|rt|ddStdt|dS)zReturns the constraints of a `TypeVar` if any. It the type is not a `TypeVar`, a `TypeError` is raised Examples:: get_constraints(TypeVar('T')) == () get_constraints(TypeVar('T', int, str)) == (int, str) __constraints__r"ztype is not a `TypeVar`: N)r;r?rNrf)r+r"r"r#get_constraintss  ricCs t|dd}|dk r|St|S)a6Get the generic type of an object if possible, or runtime class otherwise. Examples:: class Node(Generic[T]): ... type(Node[int]()) == Node get_generic_type(Node[int]()) == Node[int] get_generic_type(Node[T]()) == Node[T] get_generic_type(1) == int __orig_class__N)r?r%)objZgen_typer"r"r#get_generic_type!s rlcCs(trtdd|jDSt|ddSdS)aGet generic base types of a type or empty tuple if not possible. Example:: class MyClass(List[int], Mapping[str, List[int]]): ... MyClass.__bases__ == (List, Mapping) get_generic_bases(MyClass) == (List[int], Mapping[str, List[int]]) css|]}t|tr|VqdS)N)rr)r0tr"r"r#r2;sz$get_generic_bases..__orig_bases__r"N)rHr( __bases__r?)r+r"r"r#get_generic_bases1s rpcCst|ttfr|jSdS)aIf td is a TypedDict class, return a dictionary mapping the typed keys to types. Otherwise, return None. Examples:: class TD(TypedDict): x: int y: int class Other(dict): x: int y: int typed_dict_keys(TD) == {'x': int, 'y': int} typed_dict_keys(dict) == None typed_dict_keys(Other) == None N)r_TypedDictMeta_Mypy_TypedDictMeta_TE__annotations__copy)tdr"r"r#typed_dict_keys@s rvcCst|r|jSdS)a If fr is a ForwardRef, return the string representation of the forward reference. Otherwise return None. Examples:: tp = List["FRef"] fr = get_args(tp)[0] get_forward_arg(fr) == "FRef" get_forward_arg(tp) == None N)rA__forward_arg__)frr"r"r#get_forward_argTs rycCs||dkr g}t|r t|||St|r4t|||St|rHt|||St|trxx$t|D]\}}||kr\||Sq\W|S)zbackport of _replace_argN) r4rar.rcr,rbrr enumerate)rQtvarsr^itvarr"r"r# _replace_argcs     r~csg}xd|D]\}t|tr&||jq t|tr\t|dkr\|dtkr\||ddq ||q Wt|tt|krg}x(|D] }|kr|| |qW|}rt t|x>|D]6tt sqt fddhDrΈ qWtfdd|DS)z backport of _remove_dups_flattenrrXNc3sB|]:}t|trt|dk st|tst|to8t|VqdS)N)rrrGr r%r&)r0t2)t1r"r#r2s  z'_remove_dups_flatten..c3s|]}|kr|VqdS)Nr")r0rm) all_paramsr"r#r2s) rrextendrIr(rUr rOsetremoverr%r5) parametersrPp new_paramsrmr")rrr#_remove_dups_flattenvs0  "      rc Csdd}||}|dkr,t|s,t|s,|Sg}x"||dk rR||||}q2Wg}dd}x"||D]}|t|||qjWx<|D]4} g} x&|| D]}| t|t| |qW| }qW|S)z;backport of typing._subs_tree, adapted for legacy versions cSs y|jStk rdSXdS)N)r rV)r!r"r"r# _get_originsz_subs_tree.._get_originNcSsTt|r|j}n4t|r |j}n$y |j}Wntk rBd}YnX|dk rP|SdS)Nr")r4rIr.rKrTrV)r!Zcls_argsr"r"r# _get_argss  z_subs_tree.._get_args)r4r.rOr~rJ) r!r{r^rcurrentZ orig_chain tree_argsrrQZoclsZ new_tree_argsr"r"r#r`s&    r`cCs>|tkr tSt|||}t|}t|dkr4|dStf|S)z backport of Union._subs_tree rXr)r r`rrU)r+r{r^rr"r"r#ras  racCs,|jdkr|St|||}t|ft|S)z$ backport of GenericMeta._subs_tree N)r r`rr()r+r{r^rr"r"r#rbs  rbcCs&|tkr tSt|||}tft|S)z7 ad-hoc function (inspired by union) for legacy typing )rr`r()r+r{r^rr"r"r#rcs rccCsT|dkr dSt|rt|St|r,t|St|rs " (  (      A+ B( -