X-Ph XdZddlmZddlZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZddlmZddlmZmZdd lmZdd lmZmZdd lmZdd lmZdd lmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ddl0m1Z1ddl2m3Z3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRmSZSddlTmUZUGdde ZVGdde ZWGdde5ZXGdde;ZYdXd&ZZGd'd(e;Z[dYd*Z\Gd+d,e]Z^dZd0Z_d[d2Z`Gd3d4Zad\d8Zbd]d=Zcd^d>ZdGd?d@eKZeedAeGBZfd_dCZgGdDdEeLZhd`dGZidadKZjdbdNZkdcdRZldddSZmedTZndedWZodS)faMechanisms for inferring function types based on callsites. Currently works by collecting all argument types at callsites, synthesizing a list of possible function types from that, trying them all, and picking the one with the fewest errors that we think is the "best". Can return JSON that pyannotate can use to apply the annotations to code. There are a bunch of TODOs here: * Maybe want a way to surface the choices not selected?? * We can generate an exponential number of type suggestions, and probably want a way to not always need to check them all. * Our heuristics for what types to try are primitive and not yet supported by real practice. * More! Other things: * This is super brute force. Could we integrate with the typechecker more to understand more about what is going on? * Like something with tracking constraints/unification variables? * No understanding of type variables at *all* ) annotationsN)Iterator)contextmanager)Callable NamedTuple TypedDictTypeVarcast)map_actuals_to_formals)GraphState has_any_type)InvalidSourceList SourceFinder)join_type_list)meet_type_list)PYTHON_EXTENSIONS)ARG_STAR ARG_STAR2ArgKindCallExpr Decorator ExpressionFuncDefMypyFileRefExpr ReturnStmt SymbolNode SymbolTableTypeInfoVarreverse_builtin_aliases)Options)FunctionContext MethodContextPlugin)FineGrainedBuildManager)state)TraverserVisitor) bind_selfmake_simplified_union)AnyType CallableType FunctionLikeInstanceNoneType ProperType TupleTypeType TypeAliasType TypedDictType TypeOfAnyTypeStrVisitorTypeTranslator TypeVarTypeUninhabitedType UnionTypeget_proper_type)is_overlapping_noneremove_optional) split_targetc$eZdZUded<ded<dS)PyAnnotateSignaturestr return_type list[str] arg_typesN__name__ __module__ __qualname____annotations__P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/suggestions.pyrBrBWs*rMrBcLeZdZUded<ded<ded<ded<d ed <d ed <d S)CallsiterCpathintlinelist[list[ArgKind]] arg_kindszlist[str | None]callee_arg_nameslist[list[str | None]] arg_nameslist[list[Type]]rFNrGrLrMrNrPrP\sT III III""""&&&&%%%%rMrPc2eZdZdZddZdd Zdd ZddZdS)SuggestionPluginz0Plugin that records all calls to a given target.targetrCreturnNonec|dr|ddd}||_g|_dS)N)z.__new__z .__init__.r)endswithrsplitr\ mystery_hits)selfr\s rN__init__zSuggestionPlugin.__init__hsF ??4 5 5 .]]3**1-F -/rMfullname(Callable[[FunctionContext], Type] | Nonec*||jkr|jSdSNr\logrergs rNget_function_hookz"SuggestionPlugin.get_function_hookq t{ " "8O4rM&Callable[[MethodContext], Type] | Nonec*||jkr|jSdSrjrkrms rNget_method_hookz SuggestionPlugin.get_method_hookwrorMctxFunctionContext | MethodContextr4c |jt|jj|jj|j|j|j |j |j Srj) rdappendrPapirQcontextrSrUrVrXrFdefault_return_type)rerss rNrlzSuggestionPlugin.log}sY       $     &&rMN)r\rCr]r^)rgrCr]rh)rgrCr]rp)rsrtr]r4)rHrIrJ__doc__rfrnrrrlrLrMrNr[r[esj::////  ' ' ' ' ' 'rMr[c*eZdZdZd dZdd Zdd Zd S) ReturnFinderz7Visitor for finding all types returned from a function.typemapdict[Expression, Type]r]r^c"||_g|_dSrj)r} return_types)rer}s rNrfzReturnFinder.__init__s (*rMorc|j:|j|jvr.|j|j|jdSdSdSrj)exprr}rrvrers rNvisit_return_stmtzReturnFinder.visit_return_stmtsL 6 !&DL"8"8   $ $T\!&%9 : : : : :  "8"8rMrcdSrjrLrs rNvisit_func_defzReturnFinder.visit_func_defs rMN)r}r~r]r^)rrr]r^)rrr]r^)rHrIrJrzrfrrrLrMrNr|r|sVAA++++;;;;      rMr|r}r~funcrr] list[Type]cbt|}|j||jS)z9Find all the types returned by return statements in func.)r|bodyacceptrr}rfinders rNget_return_typesrs. ' " "FIV  rMc"eZdZdZd dZdd Zd S) ArgUseFinderzVisitor for finding all the types of arguments that each arg is passed to. This is extremely simple minded but might be effective anyways. rrr}r~r]r^c@||_d|jD|_dS)Nci|] }|jg SrL)variable).0args rN z)ArgUseFinder.__init__..s7c7c7cS b7c7c7crM)r} argumentsrF)rerr}s rNrfzArgUseFinder.__init__s& 7c7cTXTb7c7c7crMrrctfd|jDsdStj|j}t |tsdSt|j |j |j |j d}t|D]j\}}|D]b}|j|}t |tr>|j jvr0j|j |j|ckdS)Nc3^K|]'}t|to |jjvV(dSrj) isinstancernoderF)reres rN z/ArgUseFinder.visit_call_expr..s;WW1:a))Faf.FWWWWWWrMc4ttjSrj)r-r7 special_form)ns rNz.ArgUseFinder.visit_call_expr..sgi455rM)anyargsr=r}getcalleerr.r rUrX enumeraterrrFrv)rertypformal_to_actualirarg_idxrs` rNvisit_call_exprzArgUseFinder.visit_call_exprs%WWWWPQPVWWWWW  Fdl..qx8899#|,,  F1 K K M M 5 5   !!122 F FGAt F FfWoc7++FDN0J0JN38,33CM!4DEEE F F FrMN)rrr}r~r]r^)rrr]r^)rHrIrJrzrfrrLrMrNrrsP ddddFFFFFFrMrrYc~t|||jfd|jDS)zFind all the types of arguments that each arg is passed to. For example, given def foo(x: int) -> None: ... def bar(x: str) -> None: ... def test(x, y): foo(x) bar(y) this will return [[int], [str]]. c4g|]}j|jSrL)rFr)rrrs rN z get_arg_uses..s# E E EsF S\ * E E ErM)rrrrrs @rN get_arg_usesrsF$ ( (FIV E E E Edn E E EErMceZdZdS)SuggestionFailureN)rHrIrJrLrMrNrrsDrMrrr-boolc,|jtjkSrj) type_of_anyr7explicitrs rNis_explicit_anyrs ?i0 00rMr4cjt|}t|tot| Srj)r=rr-rrs rNis_implicit_anyrs/ #  C c7 # # @OC,@,@(@@rMc2eZdZdZdddddddidZdjdZdjdZedkdZedldZ dmdZ dmd Z dnd)Z dod*Z dpd,Zdqd/Zdrd2Zdsd4Zdtd6Zdud9Zdvd?ZdwdBZdxdFZdydKZdzdNZd{dRZd|dUZd}d~dXZdd[Zdd^Zdd`ZddbZdddZ ddgZ!ddhZ"dS)SuggestionEnginez8Engine for finding call sites and suggesting signatures.FN) no_errorsno_anyflex_any use_fixme max_guesses fgmanagerr(jsonrrrr float | Noner str | Noner int | Noner]r^c||_|j|_|jj|_|j|_t |jj|jj|_||_||_ ||_ |rd|_ |pd|_ ||_ dS)N?@) rmanagerplugingraphrfscacheoptionsr give_jsonrrrr)rerrrrrrrs rNrfzSuggestionEngine.__init__s# ( l) _ "4<#79MNN "   DM&,""rMfunctionrCcz||\}}}||5|5|||}dddn #1swxYwYdddn #1swxYwY|jr|||||S||S)z&Suggest an inferred type for function.N) find_node restore_afterwith_export_typesget_suggestionrjson_suggestionformat_signature)rermod func_namer suggestions rNsuggestzSuggestionEngine.suggests9#~~h77Y    $ $ < <'')) < <!00d;;  < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < > 5''YjII I((44 4s5A>A' A>'A+ +A>.A+ /A>>BBc|\}}}|5|\}}dddn #1swxYwYdt fd|DS)z&Find a list of call sites of function.N c \g|](\}}}}}}|d|d|||)S):z: ) format_args)rrQrSrU_rXrFres rNrz6SuggestionEngine.suggest_callsites..s]FdIq)YYYdYYd&6&6y)Y&W&WYYrM)rr get_callsitesjoindedup)rerrrr callsitess` rNsuggest_callsitesz"SuggestionEngine.suggest_callsitess~~h// Q    $ $ 4 4--d33LIq 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4yy JS     sAAAmoduleIterator[None]c#K dV||j|dS#||j|wxYw)zContext manager that reloads a module after executing the body. This should undo any damage done to the module state while mucking around. N)reloadr)rers rNrzSuggestionEngine.restore_after"sR  , EEE KK 6* + + + + +DKK 6* + + + +s *"A c#K|jjj}d|jj_ dV||jj_dS#||jj_wxYw)zContext manager that enables the export_types flag in the body. This causes type information to be exported into the manager's all_types variable. TN)rr export_types)reolds rNrz"SuggestionEngine.with_export_types-s\ l"/,0 ) 4 EEE03DL - - -DL - 3 3 3 3s =Afdefrr.c td|jD|j|jttj|dS)z?Generate a trivial callable type from a func def, with all Anysc@g|]}ttjSrL)r-r7suggestion_engine)rrs rNrz5SuggestionEngine.get_trivial_type..@s# J J JaWY0 1 1 J J JrMzbuiltins.function)r.rUrXr-r7r named_typerers rNget_trivial_typez!SuggestionEngine.get_trivial_type:sQ  J J4> J J J N N I/ 0 0 OO/ 0 0    rMct|jtrt|jS||Srj)rtyper.make_suggestion_anysrrs rNget_starting_typez"SuggestionEngine.get_starting_typeGs: di . . /' 22 2((.. .rM is_methodbasedefaultslist[Type | None]rlist[Callsite]usesrYc g}tt|jD]}|dkr0|r.|t t jg9g}|D]9} | j||z D]&} t| s|| ':g} ||D]&} t| s| | '||} | r,|| | r| | g} |r`td|DrG| tj |dt t j gnQ|r#| t|n,| t t j | r"| t| || |S)z:Produce a list of type suggestions for each argument type.rc3ZK|]&}tt|tV'dSrj)rr=r1)rtps rNrz,SuggestionEngine.get_args..qsE%%>@ ?2..99%%%%%%rM)rangelenrUrvr-r7rrFrallr< make_unionrextendgenerate_type_combinationsr)rerrrrrtypesr all_arg_typescallr all_use_typesdefaultrFs rNget_argszSuggestionEngine.get_argsMs6#%s4>**++) $) $AAvv)v gi&ABBCDDDM! 2 2>!i-822C*3//2%,,S1112MAw . .&s++.!((---qkG 2$$W--- 2!((111I >%%DQ%%%"" >  (-*:GIDV  !;M!J!JKKKK  );!!>??? LL # # # # rMc*fd|jDS)NcPg|]"}|jrjj|jnd#Srj) initializerr all_types)rrres rNrz:SuggestionEngine.get_default_arg_types..sA   8; PDL "3? 3 3D   rM)rrs` rNget_default_arg_typesz&SuggestionEngine.get_default_arg_typess0    ~    rMlist[CallableType]c|||||}tjtj|d|j}fd|DS)zCompute a list of guesses for a function's type. This focuses just on the argument types, and doesn't change the provided return type. rc rg|]3}tt|4S))rF)refine_callable copy_modifiedlist)rxrs rNrz0SuggestionEngine.get_guesses..s;^^^QRd&8&8477&8&K&KLL^^^rM)r  itertoolsisliceproductr)rerrrrrrrs ` rN get_guesseszSuggestionEngine.get_guessessZ-- 49dKK"9#4g#>4CSTT^^^^V]^^^^rMr tuple[list[Callsite], list[str]]c\||}t|j}|jjd| |||}|jjdn$#|jjdwxYw|j|fS)z"Find all call sites of a function.r) rr[rgr_pluginsinserttry_typepoprd)rernew_typecollector_pluginerrorss rNrzSuggestionEngine.get_callsitess))$//+DM:: ##A'7888 (]]422F K $ $Q ' ' ' 'DK $ $Q ' ' ' ',f44s B!B"guesses ignore_returnc(fd|DS)z~Apply any configured filters to the possible guesses. Currently the only option is filtering based on Any prevalance.cVg|]%}jt|jk#|&Srj)rany_score_callable)rtr(rres rNrz3SuggestionEngine.filter_options..sG   }$!!Y >>$-OO POOrMrL)rer'rr(s` ``rNfilter_optionszSuggestionEngine.filter_optionss:           rMtuple[CallableType, int]c|stdfd|Dt|fd}|t|fS)zFrom a list of possible function types, find the best one. For best, we want the fewest errors, then the best "score" from score_callable. zNo guesses that match criteria!c>i|]}||SrL)r")rguessrres rNrz.SuggestionEngine.find_best..s)III%tU33IIIrMcXt||fSrj) count_errorsscore_callable)sr&res rNrz,SuggestionEngine.find_best..s'<q +B+BDDWDWXYDZDZ*[rM)key)rminr3)rerr'bestr&s`` @rN find_bestzSuggestionEngine.find_bestsq  G#$EFF FIIIIIIII7 [ [ [ [ [\\\\&,////rMrc|jsgS|jjddD]}|j|j}|r~t |jttfr]t|jj }t |tr/t|j t|jkr|gcSgS)z8Try to get a guess of a method type from a parent class.raN)infomronamesrnamerrrrr=rr.rrFr)rerparentpnoders rNget_guesses_from_parentz(SuggestionEngine.get_guesses_from_parentsy IimABB' ! !FL$$TY//E !EJ)0DEE !%ejo66c<00!S5G5G3t~K^K^5^5^ 5LLL rMrrBc\ |j}||\}}t|jj|}|jr|rt dt|jo|j }tj ||j j 5||||||||}dddn #1swxYwY|||z }|||d}|||\ } || t+|jj|} tj ||j j 5| rt-| } nt/g} dddn #1swxYwY fd| D}|||d}|||\ } |jr| rt d||| S)zxCompute a suggestion for a function. Return the type and whether the first argument should be ignored. zFunction does not typecheck.NT)r(cbg|]+}tj|,S)ret_type)r refine_typerE)rr,r8s rNrz3SuggestionEngine.get_suggestion..s7aaaRS4%%{4=!/L/L%MMaaarMFzNo annotation without errors)rrrrrrrrr; is_staticr)strict_optional_setrstrict_optionalrrrrAr-r9r"rrr1pyannotate_signature)rerrrr orig_errorsrrr'rreturns ret_typesr&r8s @rNrzSuggestionEngine.get_suggestions  !%!3!3D!9!9 ;DL2D99 > Dk D#$BCC COO:DN(:  &uSz'9'I J J  &&&&t,,**400 G                4//555%%gy%MM..w//a dD!!!"4<#94@@  &uSz'9'I J J ) ) )6w?? %ZZL  ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) baaaW`aaa%%gy%NN~~dG44 f > Df D#$BCC C((i>>>s%ACC#&C#"F55F9<F9rUrTrXrWrFcg}tt|D]}t||||||D][\}}}|d|} |tkrd| z} -|t krd| z} >|r |r|d| } \|| dd|dS)N*z**=(, )) rrzip format_typerris_namedrvr) rerUrXrFrrkindr>rrs rNrzSuggestionEngine.format_argss s9~~&&  A#&y|Yq\9Q<#P#P . .dC&&tS118##)CCY&&*CC]]__..!%oooo KK    %499T??%%%%rMr6tuple[str, str, FuncDef]cd}d|vr|ddkr"td||d\}}|std|t |}|||\}}|jt|dzd}nIt|j j |}|std||\}}| ||}t|tr*||}|std|dt|t std|d |||fS) a4From a target name, return module/target names and the func def. The 'key' argument can be in one of two formats: * As the function full name, e.g., package.module.Cls.method * As the function location as file and line separated by column, e.g., path/to/file.py:42 NrrazgMalformed location for function: {}. Must be either package.module.Class.method or path/to/file.py:linez"Line number must be a number. Got zCannot find module for zObject z is a decorator we can't handlez is not a function)countrformatsplitisdigitrRfind_node_by_file_and_linergrr@rrfind_node_by_module_and_namerrextract_from_decoratorr) rer6rfilerS line_numbermodnametailr\s rNrzSuggestionEngine.find_nodes#' #::yy~~!!'KKQ6RU;;3JD$<<>> U'(ST(S(STTTd))K ;;D+NNMGT=W!1!3!34DD!$."6< 5 C-$&C#&&3z??Q3F3FxxJX[\\ X##rMrarSrRtuple[str, SymbolNode]ctfdtDstd |jt j\}}n%#t$r}tdz|d}~wwxYw||j vrtd|z| |j j |d}d}d}| D]L\}} }t| jtt fr | jj} n5| |kr|| |kr | }| j}M|std|||fS) zFind symbol node by path to file and line number. Find the first function declared *before or on* the line number. Return module id and the node found. Raise SuggestionFailure if can't find one. c3BK|]}|VdSrj)rb)rextras rNrz>SuggestionEngine.find_node_by_file_and_line..cs/CC#4==%%CCCCCCrMz Source file is not a Python filezInvalid source file name: NzUnknown module: T)forcezCannot find a function at line )rrrrcrawl_uposrQnormpathrrrirlocal_definitionsrrrrrS) rerarSrcrrrjr closest_linesymsym_lines ` rNr^z+SuggestionEngine.find_node_by_file_and_line\sCCCC1BCCCCC H#$FGG G P--bg.>.>t.D.DEEJGQQ  P P P#$@4$GHHa O P $* $ $#$6$@AA A!!$."6w"?t!LL"&#' //11 IAsA#(Wi$899 8=4\%9X =T=T' x N#$Ld$L$LMM M}s:A-- B7B  BrFuncDef | Nonec|jD]}d}t|tr;t|jtt frt |jj}nt|trt|j trst|j jtt tfrGtt |j jjx}trt |j }t|tr^|jd}t|t r/t|jtrt!|jd}t|tsdS|jD]T}t%|jdkr6t|jdt(r|jd|j ksdSU|jS)N__call__rar) decoratorsrrrr"rr=rrrrr.rEr0 get_methodr/r+itemsrrFr:r)rerdecrcall_tp call_methodcts rNr`z'SuggestionEngine.extract_from_decorators?  CC#w'' 8Jsx#w,P,P 8%chm443)) 8sz733 8szGS0IJJ 8?3:?;O+P+P PS_``  8 &g&677#x(( <!h11*== k733< ;CSUa8b8b<#K$4d;;Cc<00 tti   %%**"2<?K@@+ Q2;664447  yrMrr2rEc|j}d|_||_ |j|j}|||_S#||_wxYw)z_Recheck a function while assuming it has type typ. Return all error messages. N)unanalyzed_typerrtriggerrg)rerrrress rNr"zSuggestionEngine.try_types] " " '.((77C#&D 3D & & & &s ? Ar)r c|jJ|j|j|j|jfggS)z"Recheck the module given by state.)rQr flush_cacheupdateid)rer)s rNrzSuggestionEngine.reloadsHz%%% ""$$$~$$ux&<%=rBBBrMrrrcv|jr|jjs|r|||jJ|jS)z?Make sure that the module represented by state is fully loaded.)rjis_cache_skeletonr)rer)rrs rNrizSuggestionEngine.ensure_loadedsGz UZ9 U  KK   z%%%zrMr5r0c@|jj|Srj)rsemantic_analyzerr)rer5s rNrzSuggestionEngine.named_types|-88;;;rMrrc|js|jr|ddd}tj|j|j}||j||dd}tj |gdS)zLProduce a json blob for a suggestion suitable for application by pyannotate.r`rargr) signaturerSrQrsamplesT) sort_keys) is_classrGr\rtrQabspathrxpathrSrdumps)rerrrrrQobjs rNrz SuggestionEngine.json_suggestions = 4DN 4!Q//3I wtz#455$I"   z3%40000rM cur_modulect|}fd|j|dD|jdS)z+Format a callable type as a pyannotate dictc<g|]}|SrL)rU)rr,rres rNrz9SuggestionEngine.pyannotate_signature..s)YYYa$**:q99YYYrMN)rFrD)rRrFrUrE)rerrrstarts`` rNrJz%SuggestionEngine.pyannotate_signatures]IYYYYY3=QVQWQWCXYYY++J EE   rMsigcPdd|dd|dS)zDFormat a callable type in a way suitable as an annotation... kind ofrQrRrFz) -> rD)r)rers rNrz!SuggestionEngine.format_signatures.I499S-..IIS5GIIIrMr4c|jr)tt|tr|jS|t ||j|jjSrj) rrr=r-r TypeFormatterrrr)rerrs rNrUzSuggestionEngine.format_typesR > "j)=)=wGG "> !zz- DJ @TUUVVVrMr,arg_posct|}t|trdS|rt|trdSt|trQt d|jDrdSt d|jDrdSt|sdSt|tr t|st|rdSdS)zGenerate a score for a type that we use to pick which type to use. Lower is better, prefer non-union/non-any types. Don't penalize optionals. c3ZK|]&}tt|tV'dSrjrr=r-rrs rNrz.SuggestionEngine.score_type..s4LLq:oa00'::LLLLLLrMc34K|]}t|VdSrjrrs rNrz.SuggestionEngine.score_type..s(44q<??444444rM r) r=rr-r1r<rrr>r.ris_tricky_callable)rer,rs rN score_typezSuggestionEngine.score_types A   a ! ! 2  z!X.. 2 a # # LLAGLLLLL r44AG44444 r&q)) r a & & LOO ?QRS?T?T 2qrMc~tfd|jD|jdzS)Nc3FK|]}|dVdS)TrN)r)rrres rNrz2SuggestionEngine.score_callable..s3II4??1d?33IIIIIIrMFr)sumrFrrErer,s` rNr4zSuggestionEngine.score_callablesOIIIIQ[IIIIIDOO JM\M M   rM)rr(rrrrrrrrrrrrr]r^)rrCr]rC)rrCr]r)r]r)rrr]r.) rrrr.rrrrrrYr]rY)rrr]r) rrrr.rrrrrrYr]r)rrr]r)r'rrrr(rr]r)rrr'rr]r.)rrr]r)rrCrrr]rB)rUrTrXrWrFrYr]rC)r6rCr]rX)rcrCrdrCr]re)rarCrSrRr]rn)rrr]rz)rrrr2r]rE)r)r r]rE)F)r)r rrrr]r)r5rCr]r0) rrCrrCrrrrBr]rC)rrrrrr.r]rB)rrBr]rC)rrrr4r]rC)r,r4rrr]rR)r,r.r]rR)#rHrIrJrzrfrrrrrrrr rrrr-r9rArrrr_r^r`r"rrirrrJrrUrr4rLrMrNrrsBB !% $"&######4 5 5 5 5     ,,,^, 4 4 4^ 4     //// 4444l    ____$ 5 5 5 5      0 0 0 0"*?*?*?*?X&&&&(%#%#%#%#N!$!$!$!$F!!!!F<''''(CCCC <<<<1111,    JJJJWWWW *      rMrutrfloatct|}t|tr|jtjkrdSt|t r|rdSt|tr@td|j DrdStd|j DrdSt|trt|rdSt|rdSdS)ziGenerate a very made up number representing the Anyness of a type. Higher is better, 1.0 is max rg?c3ZK|]&}tt|tV'dSrjrrs rNrz!any_score_type..s4HH1z/!,,g66HHHHHHrMc34K|]}t|VdSrjrrs rNrz!any_score_type..s(001|A000000rMg?r) r=rr-rr7rr1r<rrr.rr)rrr,s rNany_score_typers A!W!-93N"N"Nq!X7s!Y HHHHH H H 3 00000 0 0 4!\""'9!'<'<sAs 3rMr,r.rr(c d|jt|dD}tt|jt r|s!|rdnt |jd}|||gz }t|t|z S)Nc0g|]}t|dS)Tr)rrs rNrz&any_score_callable..s% U U U!nQ--- U U UrMrFr) rFrRrr=rEr1rrr)r,rr(scoresrets rNr+r+s U Uq{3y>>CSCS7T U U UF oaj118 < <F"Qccqz5(Q(Q(Q3* v;;V $$rMcL|jptd|jDS)z@Is t a callable that we need to put a ... in for syntax reasons?c3fK|],}|p|V-dSrj)is_starrV)rks rNrz%is_tricky_callable..+s7$V$VQQYY[[%@AJJLL$V$V$V$V$V$VrM)is_ellipsis_argsrrUr,s rNrr)s)  V$V$V!+$V$V$V!V!VVrMc`eZdZdZdfd ZddZddZddZddZd dZ d!fd Z d"dZ xZ S)#rzVisitor used to format typesrrrr rr$r]r^cht|||_||_dS)N)r)superrfrr)rerrr __class__s rNrfzTypeFormatter.__init__2s0 )))  rMr,r-rCc"|jr|jSdSNAny)missing_import_namers rN visit_anyzTypeFormatter.visit_any7s  ( (5rMr0c.|jjp |jjpd}|dS|tvr t|}t |j|}|sJ|\}}|jrD|d}|j|jj}|r|d|j vr|j}||fdkr)dd|j d |zdz}}n(|j r!|d| |j d z }|d krd S|d kr|Sd|vrdnd }||z|zS)Nzr`r)builtinstupletypingTuple[z, ...][])runicodeTextrr) rrgr>r#r@rrr\rjr=rrlist_str) rer,r5mod_objrrpartsrjdelims rNvisit_instancezTypeFormatter.visit_instance=sO FO 2qv{ 2d 97 ' ' ''*Atz1--S ; "IIcNNE:dk*/D "aDJ..k :. . .AF1I,<,>CCsE;$ $rMr3c|jr=|jjr1|jjj}|dkr|j|S||j}d|dS)Nzbuiltins.tuplerr)partial_fallbackrrgrrr)rer, fallback_namer5s rNvisit_tuple_typezTypeFormatter.visit_tuple_type^sl  7!"4"9 7.3r?rrvisit_union_type)rer,rs rNrzTypeFormatter.visit_union_typelsc qw<<1  !4Q!7!7 Aq1188>>AAA A77++A.. .rMr.ct|rd}n,fd|jD}dd|d}d|d|jdS)Nz...c:g|]}|SrLr)rrres rNrz5TypeFormatter.visit_callable_type..{s%<<<CJJt$$<<.s#$D$D$DQXXd^^$D$D$DrMr)rrrs` rNvisit_type_alias_typez'MakeSuggestionAny.visit_type_alias_types.$D$D$D$DQV$D$D$DEEErMN)r,r-r]r4)r,r5r]r4)rHrIrJrrrLrMrNrrsB FFFFFFrMrrcXt|}t|}||kr|gS||gS)zGenerate possible combinations of a list of types. mypy essentially supports two different ways to do this: joining the types and unioning the types. We try both. )rr,)r joined_type union_types rNrrs< !''K&u--Jj  }Z((rMmsgsrErRc4td|DS)Ncg|]}d|v| S)z error: rLrs rNrz count_errors..s333a:?????rM)r)rs rNr3r3s 334333 4 44rMtisict|}t|}t|tr t|tr |jr|n|St|tr]t|trH|j|jkr8|dt|j|jDSt|trt|trr|j |j krbt|j t|j kr8|dt|j |j DSt|tr%t|trt||St|trt!||S|S)aRefine `ti` by replacing Anys in it with information taken from `si` This basically works by, when the types have the same structure, traversing both of them in parallel and replacing Any on the left with whatever the type on the right is. If the types don't have the same structure (or aren't supported), the left type is chosen. For example: refine(Any, T) = T, for all T refine(float, int) = float refine(List[Any], List[int]) = List[int] refine(Dict[int, Any], Dict[Any, int]) = Dict[int, int] refine(Tuple[int, Any], Tuple[Any, int]) = Tuple[int, int] refine(Callable[[Any], Any], Callable[[int], int]) = Callable[[int], int] refine(Callable[..., int], Callable[[int, float], Any]) = Callable[[int, float], int] refine(Optional[Any], int) = Optional[int] refine(Optional[Any], Optional[int]) = Optional[int] refine(Optional[Any], Union[int, str]) = Optional[Union[int, str]] refine(Optional[List[Any]], List[int]) = List[int] c4g|]\}}t||SrLrFrtasas rNrzrefine_type..s&$[$[$[VR[R%8%8$[$[$[rMrc4g|]\}}t||SrLrrs rNrzrefine_type..s&%^%^%^fb"k"b&9&9%^%^%^rM)r)r=rr-rr0rrrTrr3rrrr.rr< refine_union)rrr,r5s rNrFrFs0 AA!WLq'**Kq/DKqq!K!X]:a#:#:]qv?O?O$[$[s16STSYGZGZ$[$[$[\\\ 1i  ` q) $ $`  !"4 4 4 LLCLL ( (%^%^AGUVU\H]H]%^%^%^___!\""%z!\'B'B%q!$$$!Y"Aq!!! HrMr<r5r2cx||kr|St|tr|jn|g}g}|jD]M}d}|D]/}t||}||kr||d}0|s||Nt jd5t|cdddS#1swxYwYdS)a7Refine a union type based on another type. This is done by refining every component of the union against the right hand side type (or every component of its union if it is one). If an element of the union is successfully refined, we drop it from the union in favor of the refined versions. FTN)rr<rrFrvr)rHr,)r,r5 rhs_items new_itemslhsrefinedrhsnews rNrrs) Avv%a33<!IIw""  Cc3''Cczz  %%% "   S ! ! !  "4 ( (00$Y//000000000000000000sB//B36B3c|j|jkr|S|jr=t|s.|t |j|jSt|s|j|jkr|S|dt|j|jDt |j|jS)zKRefine a callable based on another. See comments for refine_type. rDc4g|]\}}t||SrLrrs rNrz#refine_callable..s&SSS62r;r2&&SSSrM)rFrE) rrrrrFrErUrTrF)r,r5s rNrrs  zQZM"4Q"7"7M AJ (K(KLLL! q{ : : ??SSSak5R5RSSSQZ44   rMTrlist[T]cFg}|D]}||vr|||Srj)rv)rr rs rNrrs4C  C<< JJqMMM JrM)r}r~rrr]r)r}r~rrr]rY)rr-r]r)rr4r]r)rr4rrr]r)r,r.rrr(rr]r)r,r.r]r)r,rr]r)rrr]r)rrEr]rR)rr4rr4r]r4)r,r<r5r2r]r4)r,r.r5r.r]r.)rrr]r)prz __future__rrrrtcollections.abcr contextlibrrrrrr r mypy.argmapr mypy.buildr r mypy.checkexprrmypy.find_sourcesrr mypy.joinr mypy.meetrmypy.modulefinderr mypy.nodesrrrrrrrrrrrr r!r"r# mypy.optionsr$ mypy.pluginr%r&r'mypy.server.updater( mypy.stater)mypy.traverserr* mypy.typeopsr+r, mypy.typesr-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=mypy.types_utilsr>r? mypy.utilr@rBrPr[r|rrr Exceptionrrrrrr+rrrrrrr3rFrrrrrLrMrNr&s)0#""""" $$$$$$%%%%%%AAAAAAAAAAAAAA......########''''''========$$$$$$$$$$$$//////"! >>>>>>>>>>666666++++++99999999&BAAAAAAA"""""")      z   #'#'#'#'#'v#'#'#'P      #    FFFFF#FFFBFFFF"        1111AAAA Y Y Y Y Y Y Y Y x. % % % %WWWW PAPAPAPAPANPAPAPAf t$$$6666FFFFFFFF ) ) ) )55552 2 2 2 j0000B( GCLLrM