jV?rdZddlZddlmZddlmZmZddlmZddl m Z m Z ddl m Z mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZdZd&dZdZdZed'dZ dZ!dZ"dZ#edZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+d Z,d!Z-d"Z.d(d$Z/d%Z0dS))a  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_utilscd||}t|dkrtjd|d||St}|D]a}t |r=t ||}||||z}N|t|gz}b|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) rzInferred typing index z should lead to 1 object, not ) infer_nodelenrwarningrr _get_forward_reference_nodeget_safe_valuer)context annotation value_setstrings_removedpartresults n/var/www/finuniver-perm.ru/html/student/venv/lib/python3.11/site-packages/jedi/inference/gradual/annotation.pyinfer_annotationrs"":..I 9~~ JT**V_V_ ` b b bO,, T?? 0$:M:M:O:OPPF!7#5#5f#=#==8TF+++ ct||}|tS||}+|fd}|S)Nc~|jdko1tt|kS)Ntuple) array_typerlist py__iter__)valueindexs rz*_infer_annotation_string..;s< G+;U--//0011U:r )rrrfilterpy__simple_getitem__)rstringr(noders ` r_infer_annotation_stringr.3sz &w 7 7D |""4((I $$       u % %  r c& |jj|dd}|j}t j||jd|j|_|S#t$rtj d|zYdSwxYw)N eval_inputF) start_symbolerror_recoveryrzAnnotation not parsed: %s) inference_stategrammarr tree_node get_root_nodermoveend_posparentrrr)rr,new_nodemodules rrrCs *288 % 9  "0022(FN1$5666!+  1F:;;;tts"A++!BBc t|djd}n)#t$rtjd|zgcYSwxYw|jdvr'|gSg} |j}|D]D}|jdvr9||En#t$rgcYSwxYw|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)r2rz*Comment annotation is not valid Python: %s)name atom_exprpower) rchildrenrrrtypeget_codestripappendAttributeError) decl_textr-paramsr@childs r _split_comment_param_declarationrITsYu555>qA  BYNOOO  y222 %%''(( F8= 8 8Ez;;; enn..4466777 8   Ms!#AA;C CCFct||}|s|s|S|j}|jdkrz _infer_param..s.000w.....r z^#\s*type:\s*\(([^#]*)\)\s*->rKz&Comments length != Params length %s %sr)rr9r@rget_following_comment_same_linerrematchrIgroupr(rrris_bound_methodr.get_default_param_contextr) rQrRr all_paramsr-commentr_params_commentsr( param_commentrs rrOrOsv!J00)>000 |">tDD ? 97CC  :5;;q>>JJ  ''   3z?? 2 2 M8     ) ) + + zz  QJE C(( ( ( '. '  4 4 6 6    6688G GZ 0 00r ci}|D]}|j}||||jj<|j}|r||d<|S)Nreturn) get_paramsrr=r')funcdefrVfunction_paramparam_annotationreturn_annotations rpy__annotations__rnsa C!,,..>>)4  '-=C#) ***)H Jr cPfdfd|DS)Nc| |jdkr|Stjj|j}|dS|jd}|S)Nr,r)rArr3compiled_subprocesssafe_literal_evalr'r@)r-rs rresolvez+resolve_forward_references..resolvesh <4900K*   # 7 I I      <4 }Q r c.i|]\}}||Sru)r[r=r-rss r z.resolve_forward_references..s' J J JJD$D''$-- J J Jr )items)rall_annotationsrss` @rresolve_forward_referencesrysF, K J J J/2G2G2I2I J J JJr c |}t|t|j}|dd}||j}t j|}|tStj d|}|stSt|| d  |St||}t||} |s| |St!||| t#j fd| D |S)zZ Infers the type of a function's return value, according to type annotations. rhNz%^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)rKc3K|]E}t|ttfr|nt |hVFdSN isinstancer r define_genericsr)r[ann type_var_dicts r z%infer_return_types..sm  c2G< = = SM***CKSE??r )rbryrnr5getrr]rr^r_r.r`rCexecute_annotationfind_unknown_type_varsrinfer_type_vars_for_executionr from_sets) function argumentsrrxrr-rdr_unknown_type_varsannotation_valuesrs @rinfer_return_typesrsr 0022G0(,--O!$$Xt44J!>tDD ? A7KK  '  KKNN " "    W % % & /w CC(*== = 33G<<<1(IWWM  %  !! "r c |}i}t||}|D]} ||j}n#t$rYwxYwt ||}|r||} |} |} | tj ur| } n#| tj ur| d} t|| | |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. _dict_values)rbr string_nameKeyErrorrrget_kindinferrVAR_POSITIONALmerge_types_of_iterate VAR_KEYWORD try_mergemerge_type_var_dictsinfer_type_vars) rrannotation_dictrannotation_variable_resultsexecuted_param_namesexecuted_param_nameannotation_nodeannotation_variablesannotation_value_setkindactual_value_sets rrrs60022G"$3HiHH3 -.A.MNOO    H  6gOO  #*#5#5o#F#F &//11D288:: y///#3#J#J#L#L  ...#3#=#=n#M#M +$445EFF    '&s : AAci|D]D}|jdkr7t||}|Et jfd|D|jS)Nr%c3K|]E}t|ttfr|nt |hVFdSr|r})r[v all_type_varss rrz,infer_return_for_callable..<sl  a0': ; ; -((( qc]]r )r$_infer_type_vars_for_callabler&updaterrrr)r param_values result_valuespvrrs @rinfer_return_for_callabler5sM00 =F " "9)R]]__UUM   / / /      *++ ,r ci}t||D]S\\}}}|}|}t|||T|S)zn Infers type vars for the Calllable class: def x() -> Callable[[Callable[..., _T]], _T]: ... )zipunpackrrr)r lazy_paramsr_ lazy_valuelazy_callable_paramcallable_param_valuesrs rrrDs #%03I4D4D4F4F 0T0T  ,J, 3 9 9 ; ;%++-- ' ! 1 12B C C     '&r c|D].\}}|r' ||xx|zcc<#t$r|||<Y*wxYw/dSr|)rwr) base_dictnew_dict type_var_namerTs rrrVs!)!1!122 v  2 2-(((F2(((( 2 2 2+1 -((( 2 222s.AAc  i}t|ts|S|}|}t||D];\}}t |||d<|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`. N)r~r get_genericsrrrr)annotation_valueannotated_argument_classrannotation_genericsactual_genericsannotation_generics_setactual_generic_sets rmerge_pairwise_genericsr_sFM .0F G G*7799.;;==O7:;NP_7`7`  3!3  # 3 34F4Y4YZ^4_4_ ` `    r c<t|||jd|S)NrK_find_type_from_comment_hintr@rr-r=s rfind_type_from_comment_hint_forr 't}Q7G N NNr ct|jdkrgSt|jdjdks Jd|jdjd}t||||S)NrKz1Can only be here when children[1] is 'foo() as f'rL)rr@r)rr-r=varlists r find_type_from_comment_hint_withrst 4=A t}Q( ) )Q . . .; / . .mA'*G 'w E EEr c<t|||jd|S)Nrrrs r"find_type_from_comment_hint_assignrrr cZd}|jdvr'd}|jD]}||krn|jdkr|dz }gStj|}|gSt jd|}|gSt ||d| |S)N)testlist_star_exprexprlisttestlistroperatorrKz^#\s*type:\s*([^#]*)) rAr@rr]r^r_r.r`rCr)rr-rr=r(rHrdr_s rrrs E|EEE%  E}}zZ'' QJEEI:4@@G H,g 6 6E } #Q%%''  !!"r c4fdg|S)Nc|jdvrW|jd}|jdkr9|jddkr*t|jdD]}|dSdSdSt|dd<dS)N)r>r?trailerr[rK)rAr@_unpack_subscriptlist_filter_type_varsr)r-rsubscript_node check_noderfounds rrz*find_unknown_type_vars..check_nodes 9. . .mB'G|y((W-=a-@C-G-G&;Grs ********======99999999LLLLLLLL??????333333,,,,,,5555559999994     "> 0.1.1.1b   KKK4'"'" '"T#'#'#'L , , ,'''$222111hOOOFFFOOO"""2        r