a [gmn @sdZddlZddlZddlZddlZddlmZdejddkrNdkr`nnddlmZ nXejdddkrzddlmZ Wqe yddlmZ Yq0nddlm Z e e Z ejdddkZ e rddlZd Zd Zd Zd Zd Ze rddd lmZmZmZmZmZmZmZmZmZdd lmZmZejddd krZddlm Z ee ej!fZ"nefZ"nRddlmZm#Z#mZmZm$Z$mZm%Z%m&Z&zddlm'Z'm(Z(Wn$e ye eZ'd Zd ZYn0zddlm)Z)Wn>e yzddlm)Z)Wne yd ZYn0Yn0zddlmZWn>e ydzddlmZWne y^d ZYn0Yn0zddlmZWn>e yzddlmZWne yd ZYn0Yn0ddZ*ddZ+ddZ,ddZ-ddZ.ddZ/z ej0Z1Wne2ydZ1Yn0d d!Z3ehZ4e5ed"r0e46ejd#d$Z7d%d&Z8d'd(Z9d)d*Z:d+d,Z;d-d.Zd3d4Z?d5d6Z@d[d7d8ZAd9d:ZBd;d<ZCd=d>ZDd?d@ZEdAdBZFdCdDZGdEdFZHdGdHZId\dIdJZJd]dKdLZKd^dMdNZLd_dOdPZMdQdRZNdSdTZOdUdVZPdWdXZQdYdZZRdS)`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 ForwardRefNewType)FinalLiteral)rrr)_SpecialGenericAlias)r CallableMetar r TupleMetar GenericMeta _ForwardRef)_Union _ClassVar)_Final)r)rcCs4t|tsJt|dr|jS|jdur0|j}q|S)z@This function exists for compatibility with old typing versions._gorgN) isinstancerhasattrr __origin__clsr"\/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/typing_inspect.pyr\s   rcCsRtr8t|trt|tp6t|to6|jttt t j j fvSt|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 typingGenericAliasrr tupler collectionsabcr rrrtpr"r"r#is_generic_typefs   r-cCsRtrF|tupDt|tr$|jtjjupDt|toDt|t oDt|tjjSt|t uS)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'rr)r*r%r&r rr+r"r"r#is_callable_types  r.cCsJtr>|tupz#is_optional_type..)evaluateF)r% is_union_typeanyget_argsr+r"r"r#r1s r1cCs0tr |tupt|to|jtuSto.t|tuS)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%rr+r"r"r# is_final_types r;cCs:tr.|tup,t|tr |jtup,to,t|tSt|tuS)a)Test 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 is_union_type(int | int) == False is_union_type(T | int) == True )r$r rr'rMaybeUnionTyper%rr+r"r"r#r7s  r7rcCs4tr |tvpt|to|jtvSto2t|ttuSr0)r$LITERALSrr'r WITH_LITERALr%rr+r"r"r#is_literal_types r?cCs t|tuS)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 |tupt|to|jtuStr0t|tuSdSdS)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%rr+r"r"r# is_classvars rBcCstsdStjdddkrDtjjdkrD|ttjfvpBt|ttjfStjdddkrzt|tj}WntyxYn 0|r|S|ttjfvpt|ddduot|dd d ko|j d vS|tupt|ddduo|j d vSdS) zTests if the type represents a distinct type. Examples:: is_new_type(int) == False is_new_type(NewType) == True is_new_type(NewType('Age', int)) == True is_new_type(NewType('Scores', List[Dict[str, float]])) == True FNr)r rbeta)rrr __supertype__ __qualname__zNewType..new_type)typingtyping_extensions) WITH_NEWTYPEsys version_info releaselevelrrIr TypeErrorgetattr __module__)r,resr"r"r# is_new_types. rRcCstst|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$rrrr+r"r"r#is_forward_ref6s rScCs:tr tdt}t|d|}||ur*dS|dur6|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 insteadrN)r$ ValueErrorobjectrO)r,sentineloriginr"r"r#get_last_originCs  rXcCsztr2t|tr"|jtur|jSdS|tur.tSdSt|trDt|St|rPt St |r\t St |rvtrr|jpp|St 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'rr r rrr7r r/rr?rr+r"r"r# get_origin[s"    rYcCstrt|r@g}|jdur"|jndD]}|t|7}q&t|St|rzg}|jdur\|jndD]}|t|7}q`t|St|rg}|j}|durdS|D]\}t|rt |n|fD]@}t |rt |t st d||durg}||vr||qq|durt|SdSndSntrft |tr8t|dsZt |tr`t|tr`|tur`|jSdSnBt|st|st|st|r|jdur|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__parameters__) LEGACY_TYPINGr7__union_params__get_parametersr(r/__tuple_params__r-rZr9 _has_type_varrr rNappendr$r'rr%r&r r.)r,paramsargZ base_paramsZbp_bpr"r"r#r]zsn  r]cCs>trtdn*t|r.|jdur*|jfSdSt|rz$|jdurXt|jdkrX|jWSWntylYn0|jdur~|jSdSt |rz|jdur|jndWSty|j dur|j ndYS0npt |r|jdur|jSdSt |r6z|jdur|jndWSty2|j dur*|j ndYS0ndSdS)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$rTrB__type__r-__args__lenAttributeErrorrZr7r\r.r/r^r+r"r"r# get_last_argss0      rhc Csg}|D]}t|ts"||qt|drt|dd}t|dkrb|tg|dfq|dtur|td|dfq|tt|dd|dfq|t |d |dt|ddqt|S)zInternal helper for get_args.rNr.) rr(r`r. _eval_argsrfr Ellipsislistr% __getitem__)argsrQrbZ callable_argsr"r"r#rks     $,rkcCstr|dur|stdt|trjt|drj|j}t|tjj urf|dt urft |dd|df}|St r~t|t r~|jSdSt |st|r|jdur|jfSdSt|r|jpdSt|st|st|st|rz |}WnVty>t|r t|}n.t|r t|}nt|r4t|}nYdSYn0t|trt|dkr|sl|ddSt|dd}t|t ur|dt urt |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.7rerrjr"ri)r$rTrr'rrerYr)r*r rlrmr<rBr;rdr?Z __values__r-r7r.r/ _subs_treerg_union_subs_tree_generic_subs_tree_tuple_subs_treer(rfrk)r,r6rQtreer"r"r#r9sR           r9cCs(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__Ntype is not a `TypeVar`: r@rOrNstrr+r"r"r# get_boundAs  rycCs(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"rvNrwr+r"r"r#get_constraintsQs  r{cCs t|dd}|dur|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)rOr%)objZgen_typer"r"r#get_generic_typeas r~cCs(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|VqdSr0)rrr2tr"r"r#r4{r5z$get_generic_bases..__orig_bases__r"N)r[r( __bases__rOr+r"r"r#get_generic_basesqs rcCst|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_keyss rcCst|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)rS__forward_arg__)frr"r"r#get_forward_args rcCs||dur g}t|r t|||St|r4t|||St|rHt|||St|trxt|D]\}}||krZ||SqZ|S)zbackport of _replace_argN) r7rqr/rsr-rrrr enumerate)rbtvarsroiZtvarr"r"r# _replace_args    rcsg}|D]\}t|tr$||jqt|trZt|dkrZ|dturZ||ddq||qt|tt|krg}|D] }|vr|| |q|}rJt||D]6tt sqt fddhDrĈ qtfdd|DS)z backport of _remove_dups_flattenrriNc3sB|]:}t|trt|dust|tst|to8t|VqdSr0)rrrYr r%r&)r2t2)t1r"r#r4s    z'_remove_dups_flatten..c3s|]}|vr|VqdSr0r"r) all_paramsr"r#r4r5) rrextendr\r(rfr r`setremover%r8) parametersrap new_paramsrr")rrr#_remove_dups_flattens2 "       rc Csdd}||}|dur,t|s,t|s,|Sg}||durP||||}q0g}dd}||D]}|t|||qd|D]0} g} || D]}| t|t| |q| }q|S)z;backport of typing._subs_tree, adapted for legacy versions cSs"z|jWStyYdS0dSr0)rrgr r"r"r# _get_origins z_subs_tree.._get_originNcSsRt|r|j}n2t|r |j}n"z |j}Wnty@d}Yn0|durN|SdS)Nr")r7r\r/r^rerg)r!Zcls_argsr"r"r# _get_argss   z_subs_tree.._get_args)r7r/r`rr]) r!rrorcurrentZ orig_chain tree_argsrrbZoclsZ new_tree_argsr"r"r#rps&     rpcCs>|tur tSt|||}t|}t|dkr4|dStf|S)z backport of Union._subs_tree rir)r rprrfr,rrorr"r"r#rq s  rqcCs,|jdur|St|||}t|ft|S)z$ backport of GenericMeta._subs_tree N)rrprr(rr"r"r#rrs  rrcCs&|tur tSt|||}tft|S)z7 ad-hoc function (inspired by union) for legacy typing )rrpr(rr"r"r#rss rscCsT|dur dSt|rt|St|r,t|St|rs  rcCs*|jr |jD]}t|r dSq t|jS)NT)rer_Z __result__rr"r"r#rFs  rcCs$|jr |jD]}t|r dSq dSr)rZr_rr"r"r#rNs  r)N)NN)NN)NN)NN)S__doc__rKtypesrHrIZmypy_extensionsrrrLr ImportErrorrr%r$collections.abcr)r:r>rArJr[r r r r r rrrrrrr GenericAliasr'rrrrrrrrr-r.r/r1r;Z UnionTyper<rgr7r=raddr?r@rBrRrSrXrYr]rhrkr9ryr{r~rrrrrrprqrrrsr_rrrrr"r"r"r#s  "  ,  (          E+ D( -