a lc<>@sfdZddlZddlmZddlmZmZddlmZddl m Z m Z ddl m Z mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddZd;ddZddZddZeda  PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints through function annotations. There is a strong suggestion in this document that only the type of type hinting defined in PEP0484 should be allowed as annotations in future python versions. N) Parameter)ParserSyntaxErrorparse)inference_state_method_cache)ValueSet NO_VALUES)DefineGenericBaseClass GenericClass)TupleGenericManager)TypeVar) is_string)builtin_from_name)get_executed_param_names)debug) parser_utilscCsd||}t|dkr,td||f|St|d}t|r`t||}|dur`||S|S)z Inferes an annotation node. This means that it inferes the part of `int` here: foo: int = 3 Also checks for forward references (strings) z9Inferred typing index %s should lead to 1 object, not %srN) infer_nodelenrwarninglistr _get_forward_reference_nodeZget_safe_value)context annotation value_setZinferred_valueresultr]/var/www/html/django/DPS/env/lib/python3.9/site-packages/jedi/inference/gradual/annotation.pyinfer_annotations    rcsDt||}|durtS||}dur@|fdd}|S)Ncs|jdkott|kS)Ntuple) array_typerr py__iter__)valueindexrr8s z*_infer_annotation_string..)rrrfilterZpy__simple_getitem__)rstringr#noderrr"r_infer_annotation_string0s   r(cCshz|jjj|ddd}Wn"ty:td|YdS0|j}t ||j d|j|_ |SdS)NZ eval_inputF)Z start_symbolerror_recoveryzAnnotation not parsed: %sr) inference_stateZgrammarrrrr tree_nodeZ get_root_nodermoveend_posparent)rr&new_nodemodulerrrr@s   rcCszt|ddjd}Wn$ty:td|gYS0|jdvrT|gSg}z |j}WntyxgYS0|D] }|jdvr~| |q~|S)z Split decl_text on commas, but group generic expressions together. For example, given "foo, Bar[baz, biz]" we return ['foo', 'Bar[baz, biz]']. F)r)rz*Comment annotation is not valid Python: %s)name atom_exprpower) rchildrenrrrtypeget_codestripAttributeErrorappend)Z decl_textr'paramsr4childrrr _split_comment_param_declarationQs        r<FcCst||}|s|s|S|j}|jdkrFt|d}tt|t|fgS|jdkrt|d}tt|dg|f}tt|t|gS|S)Nrrdictstr) _infer_paramr*Z star_countr rr r )function_valueparamZ ignore_starsvaluesr*tuple_dctZgenericsrrr infer_paramps(     rFc Cs|j}|durdd|jjD}|jj}t|}|dur>tStd|}|sRtSt| d}| |}t |t |krt d|||r|dkrtS|d8}|t |krtS||} t|| S|} t| |S)zJ Infers the type of a function parameter, using type annotations. NcSsg|]}|jdkr|qS)rB)r5).0r;rrr s z _infer_param..z^#\s*type:\s*\(([^#]*)\)\s*->rz&Comments length != Params length %s %sr)rr.r4rget_following_comment_same_linerrematchr<groupr#rrrZis_bound_methodr(get_default_param_contextr) rArBr all_paramsr'commentrKZparams_commentsr#Z param_commentrrrrr@s<    r@cCsBi}|D]}|j}|dur |||jj<q |j}|r>||d<|S)Nreturn) get_paramsrr1r!)ZfuncdefrEZfunction_paramZparam_annotationreturn_annotationrrrpy__annotations__s rScs"fddfdd|DS)NcsF|dus|jdkr|Stjj|j}|dur8dS|jd}|S)Nr&r)r5rr*Zcompiled_subprocessZsafe_literal_evalr!r4)r')rrrresolves z+resolve_forward_references..resolvecsi|]\}}||qSrr)rGr1r')rTrr z.resolve_forward_references..)items)rall_annotationsr)rrTrresolve_forward_referencess rYc s|}t|t|j}|dd}|durt|j}t|}|durHtSt d|}|s\tSt || d  St||}t||} |s| St|||tfdd| D S)zZ Infers the type of a function's return value, according to type annotations. rPNz%^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)rc3s0|](}t|ttfr|nt|hVqdSN isinstancerr Zdefine_genericsr)rGann type_var_dictrr s z%infer_return_types..)rMrYrSr+getrrIrrJrKr(rLr7execute_annotationfind_unknown_type_varsrinfer_type_vars_for_executionr from_sets) function argumentsrrXrr'rOrKZunknown_type_varsZannotation_valuesrr^rinfer_return_typess4       rhc Cs|}i}t||}|D]}z||j}WntyBYqYn0t||}|r||} |} |} | tj ur| } n| tj ur| d} t || | q|S)aM Some functions use type vars that are not defined by the class, but rather only defined in the function. See for example `iter`. In those cases we want to: 1. Search for undefined type vars. 2. Infer type vars with the execution state we have. 3. Return the union of all type vars that have been found. Z _dict_values)rMrZ string_nameKeyErrorrcrZget_kindinferrVAR_POSITIONALZmerge_types_of_iterate VAR_KEYWORDZ try_mergemerge_type_var_dictsinfer_type_vars) rfrgZannotation_dictrannotation_variable_resultsZexecuted_param_namesZexecuted_param_nameZannotation_nodeZannotation_variablesZannotation_value_setkindactual_value_setrrrrd s,          rdcsLi|D]&}|jdkrt||}|qtfdd|DS)Nrc3s0|](}t|ttfr|nt|hVqdSrZr[)rGvZ all_type_varsrrr`9s z,infer_return_for_callable..)r_infer_type_vars_for_callabler updaterrerb)rgZ param_valuesZ result_valuespvr_rrsrinfer_return_for_callable2s  rwcCsDi}t||D],\\}}}|}|}t|||q|S)zn Infers type vars for the Calllable class: def x() -> Callable[[Callable[..., _T]], _T]: ... )zipunpackrjrmrn)rgZ lazy_paramsro_Z lazy_valueZlazy_callable_paramZcallable_param_valuesrqrrrrtAsrtc CsJ|D]<\}}|rz|||O<WqtyB|||<Yq0qdSrZ)rWri)Z base_dictZnew_dictZ type_var_namerCrrrrmSs  rmcCsNi}t|ts|S|}|}t||D]\}}t|||q,|S)aw Match up the generic parameters from the given argument class to the target annotation. This walks the generic parameters immediately within the annotation and argument's type, in order to determine the concrete values of the annotation's parameters for the current case. For example, given the following code: def values(mapping: Mapping[K, V]) -> List[V]: ... for val in values({1: 'a'}): val Then this function should be given representations of `Mapping[K, V]` and `Mapping[int, str]`, so that it can determine that `K` is `int and `V` is `str`. Note that it is responsibility of the caller to traverse the MRO of the argument type as needed in order to find the type matching the annotation (in this case finding `Mapping[int, str]` as a parent of `Dict[int, str]`). Parameters ---------- `annotation_value`: represents the annotation to infer the concrete parameter types of. `annotated_argument_class`: represents the annotated class of the argument being passed to the object annotated by `annotation_value`. )r\rZ get_genericsrxrmrnrb)Zannotation_valueZannotated_argument_classr_Zannotation_genericsZactual_genericsZannotation_generics_setZactual_generic_setrrrmerge_pairwise_generics\s#  r{cCst|||jd|S)Nr_find_type_from_comment_hintr4rr'r1rrrfind_type_from_comment_hint_forsrcCs:t|jdjdksJd|jdjd}t||||S)Nrz1Can only be here when children[1] is 'foo() as f'r=)rr4r})rr'r1varlistrrr find_type_from_comment_hint_withs rcCst|||jd|S)Nrr|r~rrr"find_type_from_comment_hint_assignsrcCsd}|jdvrBd}|jD]$}||kr(qB|jdkr4q|d7}qgSt|}|durXgStd|}|durpgSt||d| S)N)Ztestlist_star_exprZexprlistZtestlistroperatorrz^#\s*type:\s*([^#]*)) r5r4rrIrJrKr(rLr7rb)rr'rr1r#r;rOrKrrrr}s&      r}cs fddg|S)Ncsf|jdvrJ|jd}|jdkrb|jddkrbt|jdD] }|q:nt|dd<dS)N)r2r3trailerr[r)r5r4_unpack_subscriptlist_filter_type_varsr)r'rZsubscript_node check_noderfoundrrrs    z*find_unknown_type_vars..check_noder)rr'rrrrcs rcrcCs2t|}|D] }t|tr ||vr ||q |SrZ)rr\r r9)rrZ new_foundZtype_varrrrrs  rccsF|jdkr2|jdddD]}|jdkr|Vqn|jdkrB|VdS)N subscriptlistr= subscript)r5r4)rrrrrrs     r)N)F)r)1__doc__rJinspectrZparsorrZjedi.inference.cacherZjedi.inference.base_valuerrZjedi.inference.gradual.baserr Zjedi.inference.gradual.genericsr Zjedi.inference.gradual.type_varr Zjedi.inference.helpersr Zjedi.inference.compiledr Zjedi.inference.paramrZjedirrrr(rr<rFr@rSrYrhrdrwrtrmr{rrrr}rcrrrrrrsH           1  *& 4