c  UdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z ddlm Z mZmZmZmZddlmZmZmZmZmZmZmZddlmZddlmZmZmZm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,dd l-m.Z.dd l/m0Z0m1Z1m2Z2e rdd l3m4Z4ej5dZ6edZ7edej8Z9edej:Z;ej e1ee1eej<ej=fe1ee1eegdfZ> dddZ?e?ej@_Ae?ejB_Ae?ejC_Ae?ejD_Ae?ejE_A dddZFejG ddd ZHeHejI_AeHejJ_AeHejK_A ddd#ZLdd'ZMdd(ZNeLejO_Add+ZP ddd.ZQejGejReQejS_AeQejT_UejGejR ddd1ZVeVejW_AejGejR ddd7ZXeXejY_AejGejR ddd9ZZeZej[_A ddd;Z\ejGejRe\ej]_AejGe\ej^_UejGejR ddd=Z_e_ej`_AeaZb ddd@ZcejGejRecejd_AejGecejd_UejGejR dddBZeeeejf_AddGZg dddJZhejGejR dddKZiehejj_heiejj_AddLZkddRZlddYZm ddd^Zn ddd_ZoddcZpddZqddeZrddkZsddmZtddqZu dddsZvejwejR dddtZxevej=_vexej=_Aejyejzej{ej|ej}ej~dudvdwZdxedy<dzd{hZdd|ZddZ dddZeej_A dddZejGejR dddZeej<_eej<_AejG dddZeej_AejGejR dddZeejT_Aeej^_AejGejR dddZeej_AddZejG dddZeej_A dddZeej:_AdS)zMThis module contains a set of functions to handle inference on astroid trees.) annotationsN)Callable GeneratorIterableIterator) TYPE_CHECKINGAnyOptionalTypeVarUnion)bases constraint decoratorshelpersnodes protocolsutil) PY310_PLUS) CallContextInferenceContextbind_context_to_node copy_context) AstroidBuildingError AstroidErrorAstroidIndexErrorAstroidTypeErrorAstroidValueErrorAttributeInferenceErrorInferenceErrorNameInferenceError_NonDeducibleTypeHierarchy) dunder_lookup)AstroidManager)InferenceErrorInfoInferenceResultSuccessfulInferenceResult)Propertyobjects_T_BaseContainerT)bound _FunctionDefT?list[functools.partial[Generator[InferenceResult, None, None]]]selfcontextInferenceContext | Nonekwargsr return Iterator[_T]c+K|VdS)zInference's end for nodes that yield themselves on inference. These are objects for which inference does not have any semantic, such as Module or Consts. Nr.r/r1s 1lib/python3.11/site-packages/astroid/inference.py infer_endr8Fs JJJJJnodelist[SuccessfulInferenceResult]cg}|jD]}t|tjrqt j|j|}|st||t|dst||| t|t|tj rCt j|j|}|st||| || ||S)z.Infer all values based on _BaseContainer.elts.r:r/elts) r> isinstancerStarredr safe_infervaluerhasattrextend_infer_sequence_helper NamedExprappend)r:r/valueseltstarredrBs r7rErEZsFy c5= ) ) (G<z!infer_sequence..xsF!!<= 1u}eo677!!!!!!r9)lineno col_offsetparent)anyr>rEtyperRrSrTpostinit)r.r/r1has_starred_named_exprrHnew_seqs r7infer_sequencerZrs !!!AE!!! 'g66$t**;4?4;         r9 nodes.DictIterator[nodes.Dict]c#4Ktd|jDs|VdSt||}t||j|j|j}|t||VdS)Nc3PK|]!\}}t|tjV"dSrN)r?r DictUnpack)rOk_s r7rQzinfer_map..s3FF41az!U-..FFFFFFr9) rUitems _infer_maprVrRrSrTrWlist)r.r/rbrYs r7 infer_mapres FF4:FFF F F 4))$t**T[$/4;GGekkmm,,--- r9lhs_dict:dict[SuccessfulInferenceResult, SuccessfulInferenceResult]rhs_dictctj||}d|D}t|S)aDelete nodes that equate to duplicate keys. Since an astroid node doesn't 'equal' another node with the same value, this function uses the as_string method to make sure duplicate keys don't get through Note that both the key and the value are astroid nodes Fixes issue with DictUnpack causing duplicate keys in inferred Dict items :param lhs_dict: Dictionary to 'merge' nodes into :param rhs_dict: Dictionary with nodes to pull from :return : merged dictionary of nodes cBi|]\}}|||fSr5) as_string)rOkeyrBs r7 z,_update_with_replacement..s*PPPJC#--//C<PPPr9) itertoolschainrbdictrH)rfrh combined_dict string_maps r7_update_with_replacementrssV&OHNN$4$4hnn6F6FGGMPP-PPPJ  !!## $ $$r9ci}|jD]\}}t|tjrjt j||}|st t|tjst ||t||}t||}t j||}t j||}td||fDrt ||t|||i}|S)z%Infer all values based on Dict.items.r=r/c3K|]}| VdSrNr5)rOelems r7rQz_infer_map..s$::t8::::::r9) rbr?rr_rrArDictrcrsrU) r:r/rHnamerBdouble_starred unpack_itemsrl safe_values r7rcrcsJLFzII e dE, - - I$/w??N! %$$nej99 A$$@@@@%ng>>L-flCCFF$T7;;;C +E7CCCJ::j(9::::: A$$@@@@-fsJ6GHHFF Mr9 nodes.NodeNGnodes.FunctionDef | Nonec|}|jrLt|jtjs-|j}|jrt|jtj-|r|jr|jSdS)aSearch for the first function which encloses the given scope. This can be used for looking up in that function's scope, in case looking up in a lower scope for a particular name fails. :param node: A scope node. :returns: ``None``, if no parent function scope was found, otherwise an instance of :class:`astroid.nodes.scoped_nodes.Function`, which encloses the given node. N)rTr?r FunctionDef)r:currents r7_higher_function_scoperspG .!GNE~ 4r9nodes.Name | nodes.AssignName&Generator[InferenceResult, None, None]c ||j\}}|skt|}|r||j\}}|s)t |j||t |}|j|_tj|||j |j<tj |||S)z$Infer a Name: use name lookup rules.)ryscoper/) lookupryrrr r lookupnamerget_constraints constraintsr _infer_stmts)r.r/r1framestmtsparent_functionras r7 infer_namers ;;ty))LE5  1>>  9&--di88HAu $YdjjllG 7##GG%/%?e%L%LG "  eWe 4 44r9 nodes.Call4Generator[InferenceResult, None, InferenceErrorInfo]c+Kt|}d|_|'t|||_|j|D]t}|tjur|V t|dr>t|j |j ||_ |||Ed{Ve#t$rYqwxYwt!||S)z?Infer a Call node by trying to guess what the function returns.Ninfer_call_result)argskeywordscallee)callerr/r=)r boundnode_populate_context_lookupclone extra_contextfuncinferr UninferablerCrrr callcontextrrr$)r.r/r1rrs r7 infer_callrs w''K KT$>$''DD& F F F dG<<<# E FB&&(( BBB$888cABw''!t6TYY[[3HII!%111 " JJttW    sHA A%A  A%)A>> BBB#AC99 D)!D$$D)"nodes.Attribute | nodes.AssignAttrc+@K|j|D]}|tjur|Vt |}|j} ||_t |tjtj frFt |tjr|n|j }tj |||j|j<||j|Ed{Vn#t"t$t&f$rYnwxYw||_#||_wxYwt)||S)zBInfer an Attribute node by using getattr on the associated object.)rNr=)exprrrrrrr?rClassDefr Instance_proxiedrrrattrnameigetattrrrAttributeErrorr$)r.r/r1owner old_boundnoders r7infer_attributer`sN )).. D$ $ KKK w'')  . %G %%.%.!ABB !+E5>!B!BV5?5O666#DM2~~dmW== = = = = = = = = #       D  !.G   G  - - - - 4 9 9 99s+ BCDC85D7C88D D  nodes.Globalc &||jt|| tj||j|S#t $r+}tt|||j||d}~wwxYw)Nr=r)rrr rrrrr)r.r/r1rs r7 infer_globalrs 9',9$8888!$))++"5"5g6H"I"I7SSS " JJtw/A7    s>A B%&B  Bnodes.Subscript;Generator[InferenceResult, None, InferenceErrorInfo | None]c +,Kd}|j|D]`}|tjurtjVdS|j|D]"}|tjurtjVdSt }|jtjkr|}n0|jtjkrtj |}|r|}n|}|t urt|| | ||}n=#tttt t"f$r} t||| d} ~ wwxYw||us|tjurtjVdS||Ed{Vd}$b|rt%||SdS)zInference for subscripts. We're understanding if the index is a Const or a slice, passing the result of inference to the value's `getitem` method, which should handle each supported index type accordingly. FNr=T)rBrrrslice_SUBSCRIPT_SENTINEL __class__r rrclass_instance_as_indexrgetitemrrrrrr$) r.r/r1 found_onerBindex index_valueinstance_as_indexassignedrs r7infer_subscriptrsI!!'**(( D$ $ " " " "44Z%%g..$ $ E(( &&&&ttt.K%.0 $# EN2 $$+$CE$J$J!$4"3K# 11 A$$@@@@ J ==g>> !!'  J J J%$@@@cI Jx 8t/?#? &&&&ttt~~g.. . . . . . . .III$ L>!tW==== 4s(C??#D9"D44D9 nodes.BoolOpc+&K|j}|jdkr tj}n tj} fd|D}n#t $rt jVYdSwxYwtj |D]}td|Drt jV*d|D}td|Drt jV^t j}t||D]\}} || r|Vn|Vt|S)zInfer a boolean operation (and / or / not). The function will calculate the boolean operation for all pairs generated through inference for each component node. orc<g|]}|S)ru)r)rOrBr/s r7 z!_infer_boolop..s'LLLE5;;w;77LLLr9Nc32K|]}|tjuVdSrNrrrOitems r7rQz _infer_boolop..s*99Dtt''999999r9c6g|]}|Sr5) bool_valuers r7rz!_infer_boolop..s":::Tt((:::r9c32K|]}|tjuVdSrNrrs r7rQz _infer_boolop..s*@@Dtt''@@@@@@r9r=) rHopoperatortruthnot_rrrrnproductrUzipr$) r.r/r1rH predicateinferred_valuespair bool_valuesrBrs ` r7 _infer_booloprsy[F w$"N M LLLLVLLL tt!?3 99D999 9 9 " " " " ::T::: @@K@@@ @ @ " " " "  !$T;!7!7   E:y$$   KKK 4 9 9 99s?AAinfer_callablejCallable[[_T, InferenceContext | None], Generator[InferenceResult | util.BadOperationMessage, None, None]]rtype[util.BadOperationMessage]c#nK|||D]%}t||rtjV!|V&dSrN)r?rr)r.rr/rresults r7_filter_operation_errorsrs^!.w// fe $ $ " " " " "LLLLr9 nodes.UnaryOpFGenerator[InferenceResult | util.BadUnaryOperationMessage, None, None]c#K|j|D]^} ||jV!#t$r'}t j||j|VYd}~Md}~wt$r}tj |j}|K| }|t j urtj | Vnt j Vnt|tjtjfs#t j||j|VYd}~ t%j||}n2#t($r%t j||j|VYYd}~NwxYw|d}t+||d}|t j us|sYd}~t/|}||_t3g||_|||}t+|d} | |Vn| VnM#t($r'} t j||j| VYd} ~ n!d} ~ wt8$rt j VYnwxYwYd}~Xd}~wwxYwdS)3Infer what an UnaryOp should return when evaluated.Nrru)rr)operandrinfer_unary_opr TypeErrorrBadUnaryOperationMessagerrUNARY_OP_METHODrrr const_factoryr?r rrr"rrnextcallablerrrrrr) r.r/rrmethrmethodsinferred call_resultsr inner_excs r7_infer_unaryopr1s<%%g..3+3+2 +((11 1 1 1 1 G G G/#FF F F F F F F F F- +- +- +,TW5D+ +%//11 T%55+-*n======*****!'ENEN+KLL7#NNNNNHHHH+!"/"6w"E"E2!!!";GTWcRRRRR !#1:D#DJJwJ$?$?FFH4#33!8;L;L;N;N! *733G(/G%*52h*O*O*OG'#+#=#=dG#=#T#TL!,55F%% $ .UUU7)TTTTTTTTTT%+++******+Y- + 3+3+s~> I:A**I:8B'I5'D=<H"='E,$H"+E,,AH"AH"!I5" I,,I I5I,)I5+I,,I55I:c+vKt|t|tjEd{Vt ||S)rNr=)rrrrr$r6s r7 infer_unaryoprksY ( ngt'D 4 9 9 99r9cRt|tjo |jtuS)z0Check if the given const node is NotImplemented.)r?rConstrBNotImplemented)consts r7_is_not_implementedr{s eU[ ) ) Kek^.KKr9instance nodes.Constotherr+tuple[type[util.Uninferable] | nodes.Const]ctt|tjritj|jvr tjfSfd|jD}t d|Drtd|D}nd}nt|tjri}|j D]}tj |d}t|tj stjfcStj |d}t|tj stjfcS|j ||j <n/t|tj r|j }n tjfS tj|j |zfS#tt t"f$rtjfcYSwxYw)zInfer the result of '"string" % ...'. TODO: Instead of returning Uninferable we should rely on the call to '%' to see if the result is actually uninferable. c:g|]}tj|Sr5)rrA)rOir/s r7rz6_infer_old_style_string_formatting..s&RRR!w1!W==RRRr9c3JK|]}t|tjVdSrN)r?rrrOrs r7rQz5_infer_old_style_string_formatting..s.GGaz!U[))GGGGGGr9c3$K|] }|jV dSrN)rBrs r7rQz5_infer_old_style_string_formatting..s$@@q17@@@@@@r9Nr)r?rTuplerrr>alltuplerxrbrrArrBrrKeyError ValueError)r r r/inferred_positionalrHrrlrBs ` r7"_infer_old_style_string_formattingrs%%%#  uz ) '$& &RRRRuzRRR GG3FGGG G G @@,?@@@@@FFFF E5: & & #!#K , ,D$T!Wg66Cc5;// +(****&tAw88EeU[11 +(**** % F39   , E5; ' '# ""##HNV$;<<>> x ,### """"#s3F$F76F7r%opnodenodes.AugAssign | nodes.BinOprr method_namectj||}t||}|d}||j_t |t jr>t |jtr$|dkrtt|||S t| |}n$#t$r} t||| d} ~ wwxYw|t jurtt |t jt jt jt jt*jfst||||||S)z8Invoke binary operation inference on the given instance.r%rur=N)r"rrrrr?rrrBriterrrr StopIterationrrrrListrr rinfer_binary_op) r rrr r/rrmethodrrPs r7_invoke_binop_inferencer%sR"8[99G"7H55G QZF!'G 8U[))R x~s + +R #IR 6xPPQQQB W 5566 BBB&':::AB4## 5; UZX    # #FBw I IIs#B77 CCCFnodes.AugAssignreverse9functools.partial[Generator[InferenceResult, None, None]]c ftj|}tjt||||||S)zCreate a new UnionType instance for binary or, e.g. int | str.N)r UnionType)r4r6s r7_bin_op_or_union_typer9s& /$ & &&&&&&r9c#K||fD]7}|}t|g|_d|_|V8dS)zGet contexts for binary operations. This will return two inference contexts, the first one for x.__op__(y), the other one for y.__rop__(x), where only the arguments are inversed. )rN)rrrr)r/r4r6arg new_contexts r7_get_binop_contextsr=s^t}mmoo "-C5"9"9"9  $  r9cV||kS)z$Check if type1 is the same as type2.)qname)type1type2s r7 _same_typerBs ;;==EKKMM ))r9 left_typeInferenceResult | None binary_opnode right_typereverse_contextc |j}t||rt|||||g}ntj||rt|||||g}nftj||r)t|||||dt|||||g}n(t|||||t|||||dg}t r|dkrt|tj tj fs!t|tj r}|j vt|tj tj fs!t|tj r6|j /|tjt"||g|S)aVGet the flow for binary operations. The rules are a bit messy: * if left and right have the same type, then only one method will be called, left.__op__(right) * if left and right are unrelated typewise, then first left.__op__(right) is tried and if this does not exist or returns NotImplemented, then right.__rop__(left) is tried. * if left is a subtype of right, then only left.__op__(right) is tried. * if left is a supertype of right, then right.__rop__(left) is first tried and then left.__op__(right) Tr'|)rrBr3r is_subtype is_supertyperr?r r8rrrrBrDr,r-r9) r4rCrEr6rFr/rGrrs r7_get_binop_flowrMs.  B)Z((  4E7CCD  Iz 2 2  4E7CCD  i 4 4  E="dOT R R R D-UG < <  D-UG < < E="dOT R R R  P #IP teou~> ? ? P $ ,, P  P uu? @ @P%--P P  )*?uMMNOOO Nr9 aug_opnodec B|jd}|j}t||r't|||||t |||||g} nt j||r't|||||t |||||g} nt j||r;t|||||t |||||dt |||||g} n:t|||||t |||||t |||||dg} | S)aGet the flow for augmented binary operations. The rules are a bit messy: * if left and right have the same type, then left.__augop__(right) is first tried and then left.__op__(right). * if left and right are unrelated typewise, then left.__augop__(right) is tried, then left.__op__(right) is tried and then right.__rop__(left) is tried. * if left is a subtype of right, then left.__augop__(right) is tried and then left.__op__(right). * if left is a supertype of right, then left.__augop__(right) is tried, then right.__rop__(left) and then left.__op__(right) =TrI)rstriprBr/r3rrKrL) r4rCrNr6rFr/rGbin_opaug_oprs r7 _get_aug_flowrTMsS0]  % %F ]F)Z(( D*feW = = D*feW = =   Iz 2 2 D*feW = = D*feW = =   i 4 4  D*feW = = E:vt_d S S S D*feW = =  D*feW = = D*feW = = E:vt_d S S S  Nr9 flow_factoryGetFlowFactoryGGenerator[InferenceResult | util.BadBinaryOperationMessage, None, None]c #Kt|||\}}tj|}tj|}||||||||}|D]} t| } t d| Drt jVdSttt| rgtd| D} | r$| t| krt jVdS| Ed{VdS#t$rYt$rYt$rt jVYdSwxYwt j||j|VdS)zInfer a binary operation between a left operand and a right operand. This is used by both normal binary operations and augmented binary operations, the only difference is the flow factory used. c32K|]}|tjuVdSrNrrOrs r7rQz*_infer_binary_operation..s*DD&6T--DDDDDDr9Nc38K|]}t|dVdS)rN)rrZs r7rQz*_infer_binary_operation..sD""+>v+F+F"""""""r9)r=r object_typerdrUrrrmaprsumlenrrrBadBinaryOperationMessager) r4r6rEr/rUrGrCrFrr$resultsnot_implementeds r7_infer_binary_operationrcs 37D%HHG_#D))I$U++Jl iz7OG 6688nnGDDGDDDDD &&&&3*G4455 !"" '"""O ?c'll#B &&&&        FF/    H&    H   " " " " FFF *  (M4Dj Q QQQQQQsD D6 D6D65D6 nodes.BinOpc#K|j}|j}|p t}t|}t|}||}||}t j||D]n\}} td| |fDrtj VdS t|| ||tEd{VQ#t$rtj VYkwxYwdS)z!Binary operation inference logic.ruc32K|]}|tjuVdSrNrrOrBs r7rQz_infer_binop..*AAUu((AAAAAAr9N) r4r6rrrrnrrUrrrcrMr!) r.r/r4r6 lhs_context rhs_contextlhs_iterrhs_iterlhsrhss r7 _infer_binopros, 9D JE +)++Gw''Kw''Kzz+z..H{{;{//H%h99 # #S AAsCjAAA A A " " " " FF #.sCwXX X X X X X X X X) # # #" " " " " " # # #s2CC,+C,c Dt|t|tjSrN)rrorr`r6s r7 infer_binoprqs" $ lGT%C  r9c ||vSrNr5abs r7rvs qAvr9c ||vSrNr5rss r7rvrvs 1A:r9)z==z!=z>=inznot inz%dict[str, Callable[[Any, Any], bool]] COMPARE_OPSiszis notcNtj|SrN)ast literal_evalrk)r:s r7 _to_literalrs  DNN,, - --r9 left_iterIterable[nodes.NodeNG] right_iterbool | type[util.Uninferable]cd}|tvr tjSt|}t j||D]\}}|tjus|tjurtjcS t |t |}}n+#tttf$rtjcYcSwxYw |||}n#t$r }t|d}~wwxYw||}||krtjcS|J|S)aa If all possible combinations are either True or False, return that: >>> _do_compare([1, 2], '<=', [3, 4]) True >>> _do_compare([1, 2], '==', [3, 4]) False If any item is uninferable, or if some combinations are True and some are False, return Uninferable: >>> _do_compare([1, 3], '<=', [2, 4]) util.Uninferable N) UNINFERABLE_OPSrrr{rnrr SyntaxErrorrrrr) rrrretvalop_funcr4r6rrs r7 _do_comparersPF _ "oG (J??$$ e 4# # $u0@'@ $# # # # $%d++[-?-?%DDZ8 $ $ $# # # # # # $ ,74''DD , , ," + ,  $FF t^ $# # # # $  Ms**B  #B10B15 C C CC nodes.Compare;Generator[nodes.Const | type[util.Uninferable], None, None]c+Kd}|j}|j}t||}|D]`\}}t||} t ||| }n#t $rt j}Yn wxYw|durn| }a|t jur|VdStj |VdS)z#Chained comparison inference logic.TruN) opsr4rdrrrrrrr) r.r/r1rr left_nodermr right_noderns r7_infer_comparers-1F (C I yw// 0 0C  J:##G#4455  b#..FF   %F EE     E !!" k&!!!!!!!s!A33B  B c#K|p t}|}|j|}|j|}t j||D]o\}}td||fDrtj VdS t||||tEd{VR#t$rtj VYlwxYwdS)z0Inference logic for augmented binary operations.ruc32K|]}|tjuVdSrNrrgs r7rQz#_infer_augassign..Frhr9N)r4r6rEr/rU)rrr infer_lhsrBrrnrrUrrrcrTr!)r.r/rjrkrlrmrns r7_infer_augassignr;s9+)++G--//K{$$W$55Hz 44H%h99##S AAsCjAAA A A " " " " FF #."*         * # # #" " " " " " ###s$CCCc Dt|t|tjSrN)rrrr`r6s r7infer_augassignrWs# $ )G  r9nodes.Argumentsc l||jt||tj||j|S)Nr=)rrr_arguments_infer_argnamer6s r7infer_argumentsrgsA9',9$8888  -dG4F P PPr9#nodes.AssignName | nodes.AssignAttrc t|jtjr|j|St ||}tj||S)zXInfer a AssignName/AssignAttr: need to inspect the RHS part of the assign node. ru) r?rTr AugAssignrrdassigned_stmtsr r)r.r/r1rs r7 infer_assignrssa$+u//*{  ))) $$W$55 6 6E  eW - --r9nodes.EmptyNodec+K|stjVdS t|j|Ed{VdS#t $rtjVYdSwxYw)Nru)has_underlying_objectrrr#infer_ast_from_somethingobjectrr6s r7infer_empty_noders  % % ' '# #%''@@ WA          # # #" " " " " " " #s.AA43A4callci}||S|jD],}t|tjr |||j<'|||<-|j|jng}|D] }|||j< |SrN)rr?rr@rBr)rr/context_lookupr;rkeywords r7rrs?ANy** c5= ) ) *(/N39 % %")N3   $ At}}rH00(/w}%% r9 nodes.IfExpc+pKd}|p t}t|}t|} t|j|}|t jurX|r"|j |Ed{Vn>|j |Ed{Vnd}n#ttf$rd}YnwxYw|rD|j |Ed{V|j |Ed{VdSdS)zSupport IfExp inference. If we can't infer the truthiness of the condition, we default to inferring both branches. Otherwise, we infer either branch depending on the condition. FruNT) rrrtestrrrrrbodyorelserr!)r.r/r1 both_branchesrirjrs r7 infer_ifexprsM +)++Gw''Kw''K !DIOOGMMOOO<<== t' ' !   B9??;???????????;,,[,AAAAAAAAAA MM M * :9??;?777777777;$$[$99999999999::s:CC-,C-=Generator[Property | _FunctionDefT, None, InferenceErrorInfo]c+rK|jrtj|s|Vt||S|jd}|j|jvo(td|j|jD}t|jtj tj tj frd}t||j|j|s|jnd|j}|r |j|_|g|j|j|Vt||S)Nr=T)futurec3JK|]}t|tjVdSrN)r?r(r')rOvals r7rQz$infer_functiondef..sHQQ.1 3())QQQQQQr9)functionryrRrTrS)rrdoc_node)rr _is_propertyr$rTrrylocalsrUr?r TryExcept TryFinallyIfr(r'rRrSrWrr)r.r/r1 parent_frame!property_already_in_parent_locals prop_funcs r7infer_functiondefrs[ ?>%"4T":":> !tW====;$$D$11L(, \5H(H)SQQ5A5H5SQQQNN%$+1A58LMM1,0)   Y{"CMt{{? !I)';  BTYGGG OOO 4 9 9 99r9rN)r.r)r/r0r1r r2r3)r:r*r/r0r2r;)r.r*r/r0r1r r2rK)r.r[r/r0r2r\)rfrgrhrgr2rg)r:r[r/r0r2rg)r:r}r2r~)r.rr/r0r1r r2r)r.rr/r0r1r r2r)NT) r.rr/r0rrr1r r2r) r.rr/r0rrr1r r2r)r.rr/r0r1r r2r)r.rr/r0r1r r2r)r.rr/r0r1r r2r)r.rr/r0r1r r2r) r.r)rrr/r0rrr2r)r.rr/r0r2r)r.rr/r0r1r r2r)r2r)r r r r}r/rr2r )r r%rrrrr r%r/rrrr2r)F)r r%rr&rrr r%r/rr'rr2r()r r%rrrrr r%r/rr'rr2r()r4r5r6r5r2r)r4r%rCrDrErr6r%rFrDr/rrGrr2r-)r4r%rCrDrNr&r6r%rFrDr/rrGrr2r-) r4r%r6r%rErr/rrUrVr2rW)r.rdr/r0r2rW)r.rdr/r0r1r r2r)r:r}r2r )rrrrrrr2r)r.rr/r0r1r r2r)r.r&r/r0r2rW)r.r&r/r0r1r r2r)r.rr/r0r1r r2r)r.rr/r0r1r r2r)r.rr/r0r1r r2r)rrr/r0)r.rr/r0r1r r2r)r.r,r/r0r1r r2r)__doc__ __future__rr~r,rnrtypingcollections.abcrrrrrr r r r astroidr rrrrrr astroid.constrastroid.contextrrrrastroid.exceptionsrrrrrrrr r!astroid.interpreterr"astroid.managerr#astroid.typingr$r%r&astroid.objectsr' lazy_importr(r) BaseContainerr*rr,rBinOprVr8Module_inferrLambdarSlicerEraise_if_nothing_inferredrZr"rSetrersrcrxrr path_wrapperName AssignNamerrCallrImportr ImportFromr Attribute AssignAttrrGlobalrrr SubscriptrBoolOprrrUnaryOprrr%r/r3r9r=rBrMrTrcroyes_if_nothing_inferredrqeqneltlegtger{__annotations__rrrrComparerrr Argumentsrr EmptyNoderrIfExprr5r9r7rs  TSS""""""  CCCCCCCCCCCC??????????????RRRRRRRRRRRRRRRRRR$$$$$$                      .-----****** )(((((( $ 9 % % WT]]'+53FGGGu/@AAA ! eou{*+!F G "26  !   ?C0 %(,&%(# # ! :>     %%%%40 ,(,5555589J8JJ'' ( % 9=::::&%:0  % (,BBBB&%B*#  % (,&%B, (,:::::D>=JO,,BZA/RR % ;?    &% # fhh?C88888z>=JO,,AJ@QQ % ;?2:2:2:2:&%2:j$  (=A7+7+7+7+7+t % <@::::&%: . $ LLLL "#"#"#"#JJJJJP 6 6''''    **** 6666r0000f/R/R/R/Rf;?#####6 # :>$#(    + +  +  +  %% 6 6       ....))))Z=A"""""6& ?C#####8 % >B&%$4 (  %>BQQQQ&%Q) % (, . . . .&% .'& % >B # # # #&% #*" %:>::::&%:D! =A:::::D-r9