]jV?^SrSSKrSSKJr SSKJrJr SSKJr SSK J r J r SSK J r Jr SSKJr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SrS$SjrSrSr\"5S%Sj5r Sr!Sr"Sr#\"5S5r$Sr%Sr&Sr'Sr(Sr)Sr*Sr+Sr,S r-S!r.S&S"jr/S#r0g)'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_utilscDURU5n[U5S:Xa [R"SU<SU<35 U$[nUHSn[ U5(a1[ XR55nUbX0RU5-nMDU[U/5-nMU U$)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 ^/home/mande/repo/quber/.venv/lib/python3.13/site-packages/jedi/inference/gradual/annotation.pyinfer_annotationrs"":.I 9~ JTV_ ` bO T??0:M:M:OPF!#5#5f#==8TF++  c^[X5nUc[$URU5nTb$URU4Sj5R T5nU$)Ncz>URS:H=(a% [[UR555T:$)Ntuple) array_typerlist py__iter__)valueindexs r*_infer_annotation_string..;s6  G+;U--/01U:;r )rrrfilterpy__simple_getitem__)rstringr(noders ` r_infer_annotation_stringr/3s[ &w 7D |""4(I $$   u %  r c@URRRUSSS9nURR 5n[ R "X#RS5 URUlU$![a [R"SU-5 gf=f)N eval_inputF) start_symbolerror_recoveryrzAnnotation not parsed: %s) inference_stategrammarr tree_node get_root_nodermoveend_posparentrrr)rr-new_nodemodules rrrCs **2288 % 9 ""002(NN1$56!++  1F:;s%A77#BBc[USS9RSnUR S;aUR 5R5/$/nURnUHBnUR S;dMURUR 5R55 MD U$![a [R"SU-5 /s$f=f![a /s$f=f)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)r3rz*Comment annotation is not valid Python: %s)name atom_exprpower) rchildrenrrrtypeget_codestripappendAttributeError) decl_textr.paramsrAchilds r _split_comment_param_declarationrJTsYu5>>qA  yy22 %%'(( F8==Ezz;; enn.4467 M#  BYNO   s#B! C !%C C  CCcr[X5nU(dU(dU$URnURS:Xa,[US5n[ [ U[ U455/5$URS:XaC[US5n[ [US5/5U4n[ [ U[ U55/5$U$)Nr#dictstr) _infer_paramr4 star_countrrr r )function_valueparam ignore_starsvaluesr4tuple_dctgenericss r infer_paramrYss . 0F6 $44O 1"?G<   *       Q 8 '?@ A     )     Mr cURnUGcDURRVs/sHnURS:XdMUPM nnURRn[R "U5nUc[ $[R"SU5nU(d[ $[URS55nURU5n [U5[U5:wa[R"SX5 UR5(aU S:Xa[ $U S-n U [U5:a[ $Xn [!UR#5U 5$UR#5n [%X5$s snf)zB Infers the type of a function parameter, using type annotations. rSz^#\s*type:\s*\(([^#]*)\)\s*->rLz&Comments length != Params length %s %sr)rr:rArBrget_following_comment_same_linerrematchrJgroupr(rrris_bound_methodr/get_default_param_contextr) rRrSrrI all_paramsr.commentr]params_commentsr( param_commentrs rrPrPsX!!J*/)>)>0)>w.)> 0||"">>tD ? 97C :5;;q>J  '  3z? 2 MM8   ) ) + +z  QJE C( ( '. '  4 4 6   668G G 00K0s E0E0c0nUR5H,nURnUcMX1URR'M. URnU(aXAS'U$)Nreturn) get_paramsrr>r')funcdefrWfunction_paramparam_annotationreturn_annotations rpy__annotations__rls] C!,,.)44  '-=##)) */  **)H Jr cr^U4SjnUR5VVs0sH up4X2"U5_M snn$s snnf)Nc>UbURS:waU$[TTRRR UR 55nUcgUR SnU$)Nr-r)rBrr4compiled_subprocesssafe_literal_evalr'rA)r.rs rresolve+resolve_forward_references..resolvese <4990K*   # # 7 7 I I    < }}Q r )items)rall_annotationsrqr>r.s` rresolve_forward_referencesrus9,3B2G2G2I J2IJDD'$- 2I JJ Js3cl^ UR5n[U[UR55nUR SS5nUcURn[ R "U5nUc[$[R"SU5nU(d[$[UURS5R55RU5$[X$5n[X$5n U(dU RU5$[!XU5m ["R$"U 4SjU 55RU5$)zN Infers the type of a function's return value, according to type annotations. rfNz%^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)rLc3># UH=n[U[[45(aURT5O [ U15v M? g7fN isinstancer r define_genericsr).0ann type_var_dicts r %infer_return_types..sI%C c2G< = = M*CKSE? S$AA)r`rurlr6getrr[rr\r]r/r^rDexecute_annotationfind_unknown_type_varsrinfer_type_vars_for_executionr from_sets) function argumentsrrtrr.rbr]unknown_type_varsannotation_valuesr~s @rinfer_return_typesrs" 002G0(,,-O!$$Xt4J!!>>tD ? A7K '  KKN "   W % & /wC(=  33G<<1(WM   % ! "r cUR5n0n[X5nUHnX&Rn[ X75nU(dM&UR U5n UR 5n UR5n U [RLaU R5n O$U [RLaU RS5n [UU RU 55 M U$![a Mf=f)a1 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)r`r 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 rrrs002G"$3HH3 -.M.MNO 6gO  #*#5#5o#F &//1D288: y///#3#J#J#L ...#3#=#=n#M +$445EF # 4* '&%   sC  C.-C.c^0mUH?nURS:XdM[XR55nTRU5 MA [R "U4SjU55R UR5$)Nr%c3># UH=n[U[[45(aURT5O [ U15v M? g7frxry)r|v all_type_varss rr,infer_return_for_callable..<sJA a0': ; ; -( qc] r)r$_infer_type_vars_for_callabler&updaterrrr)r param_values result_valuespvr~rs @rinfer_return_for_callabler5ssM ==F "9)]]_UM   /      **+ ,r c0n[UR5U5HCuup4nUR5nUR5n[UUR U55 ME U$)zb Infers type vars for the Calllable class: def x() -> Callable[[Callable[..., _T]], _T]: ... )zipunpackrrr)r lazy_paramsr_ lazy_valuelazy_callable_paramcallable_param_valuesrs rrrDsm #%03I4D4D4F 0T,, 3 9 9 ;%++- ' ! 1 12B C 1U '&r cUR5Hup#U(dMX==U-ss'M g![a X0U'M1f=frx)rsr) base_dictnew_dict type_var_namerUs rrrVsG!)!1 6 2(F2("2 2+1-( 2s 1AAc 0n[U[5(dU$UR5nUR5n[X45H/upV[ UUR UR S555 M1 U$)a 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)rzr get_genericsrrrr)annotation_valueannotated_argument_classr~annotation_genericsactual_genericsannotation_generics_setactual_generic_sets rmerge_pairwise_genericsr_sFM .0F G G*779.;;=O7:;N7`3  # 3 34F4Y4YZ^4_ ` 8a r c6[XURSU5$)NrL_find_type_from_comment_hintrArr.r>s rfind_type_from_comment_hint_forr 't}}Q7G NNr c[UR5S:a/$[URSR5S:XdS5eURSRSn[XX25$)NrLz1Can only be here when children[1] is 'foo() as f'rM)rrAr)rr.r>varlists r find_type_from_comment_hint_withrsl 4==A t}}Q(( )Q .<;< .mmA''*G 'w EEr c6[XURSU5$)Nrrrs r"find_type_from_comment_hint_assignrrr cnSnURS;a5SnURH!nXS:Xa OURS:XaMUS- nM# /$[R"U5nUc/$[R "SU5nUc/$[ XRS5R5U5RU5$)N)testlist_star_exprexprlisttestlistroperatorrLz^#\s*type:\s*([^#]*)) rBrArr[r\r]r/r^rDr)rr.rr>r(rIrbr]s rrrs E||EE%%E}zzZ' QJE &I::4@G HH,g 6E } #Q%%' !"r c0^^^UUU4Sjm/mT"U5 T$)Nc>URS;a\URSnURS:Xa<URSS:Xa([URS5H nT"U5 M ggg[TR U5T5TSS&g)N)r?r@trailerr[rL)rBrA_unpack_subscriptlist_filter_type_varsr)r.rsubscript_node check_noderfounds rr*find_unknown_type_vars..check_nodes 99. .mmB'G||y(W-=-=a-@C-G&;Grs *=9L?3,594  "> 0.1b K4'" '"T#'L ,'$21hOFO"2  r