Mh>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_utilscH||}t|dkrtjd|d||St |d}t |r9t ||}|||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) zInferred typing index z should lead to 1 object, not r) infer_nodelenrwarninglistr _get_forward_reference_nodeget_safe_value)context annotation value_setinferred_valueresults a/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/jedi/inference/gradual/annotation.pyinfer_annotationr s"":..I 9~~ #-::yy: ; ; ;)__Q'N  .,Wn6S6S6U6UVV  %%f-- - ct||}|tS||}+|fd}|S)Nc~|jdko1tt|kS)Ntuple) array_typerr py__iter__)valueindexs rz*_infer_annotation_string..8s< G+;U--//0011U:r!)rrrfilterpy__simple_getitem__)rstringr(noders ` r_infer_annotation_stringr.0sz &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 rrr@s *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_declarationrIQsYu555>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*->rz&Comments length != Params length %s %sr)rr9r@rget_following_comment_same_linerrematchrIgroupr(rrris_bound_methodr.get_default_param_contextr ) rPrQr all_paramsr-commentr^params_commentsr( param_commentrs rrNrNsv!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')funcdefrUfunction_paramparam_annotationreturn_annotations rpy__annotations__rmsa 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|]\}}||Srt)rZr=r-rrs r z.resolve_forward_references..s' J J JJD$D''$-- J J Jr!)items)rall_annotationsrrs` @rresolve_forward_referencesrxsF, 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. rgNz%^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)rc3K|]E}t|ttfr|nt |hVFdSN isinstancer r define_genericsr)rZann type_var_dicts r z%infer_return_types..sm  c2G< = = SM***CKSE??r!)rarxrmr5getrr\rr]r^r.r_rCexecute_annotationfind_unknown_type_varsr infer_type_vars_for_executionr from_sets) function argumentsrrwrr-rcr^unknown_type_varsannotation_valuesrs @rinfer_return_typesrsl 0022G0(,--O!$$Xt44J!>tDD ? A7KK  '  KKNN " "        /w CC(*== 6 335551(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)rar 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 rrr s60022G"$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|DS)Nrc3K|]E}t|ttfr|nt |hVFdSr{r|)rZv all_type_varss rrz,infer_return_for_callable..9sl  a0': ; ; -((( qc]]r!)r%_infer_type_vars_for_callabler&updaterrr)r param_values result_valuespvrrs @rinfer_return_for_callabler2sM00 =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 rrrAs #%03I4D4D4F4F 0T0T  ,J, 3 9 9 ; ;%++-- ' ! 1 12B C C     '&r!c|D].\}}|r' ||xx|zcc<#t$r|||<Y*wxYw/dSr{)rvr) base_dictnew_dict type_var_namerSs rrrSs!)!1!122 v  2 2-(((F2(((( 2 2 2+1 -((( 2 222s.AAci}t|ts|S|}|}t||D]:\}}t |||;|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}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 34F4Y4Y4[4[ \ \    r!c<t|||jd|S)Nr_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)Nrz1Can only be here when children[1] is 'foo() as f'rK)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!cXd}|jdvr'd}|jD]}||krn|jdkr|dz }gStj|}|gSt jd|}|gSt ||d| S)N)testlist_star_exprexprlisttestlistroperatorrz^#\s*type:\s*([^#]*)) rAr@rr\r]r^r.r_rCr)rr-rr=r(rHrcr^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[r)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,,,,,,555555999999.     "> 0.1.1.1b   KKK4'' 'T#'#'#'L   '''$222111hOOOFFFOOO2        r!