B S\z@sdZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd l mZdd lmZdd lmZe ZdYd dZee j_ee j_ee j_ee j_ee j_ee j_dZddZe jd[ddZee j_ee j_ee j _d\ddZ!ddZ"ddZ#e!e j$_ddZ%d]ddZ&e e 'e&e j(_e&e j)_*e je j'd^ddZ+e+e j,_e je j'd_d d!Z-e-e j._e je j'd`d"d#Z/e/e j0_dad$d%Z1e e 'e1e j2_e e1e j3_*e je j'dbd&d'Z4e4e j5_e6Z7e jdcd(d)Z8e 'e8e j9_e8e j9_*e je j'ddd*d+Z:e:e j;_d,d-Ze=e j?_=e>e j?_d2d3Z@d4d5ZAdgd7d8ZBdhd9d:ZCd;d<ZDd=d>ZEd?d@ZFdAdBZGdCdDZHdEdFZIe jJe j'didGdHZKeIe jL_IeKe jL_djdIdJZMe je j'dkdKdLZNeMe jO_MeNe jO_e jdldMdNZPePe jQ_e je j'dmdOdPZReRe j)_eRe j3_e je j'dndQdRZSeSe jT_e jdodSdTZUeUe jV_dpdUdVZWeWejX_YdWdXZZdS)qzMthis module contains a set of functions to handle inference on astroid trees N)bases)context) exceptions) decorators)helpers)manager)nodes) dunder_lookup) protocols)utilccs |VdS)zRinference's end for node such as Module, ClassDef, FunctionDef, Const... N)selfrr r 0lib/python3.7/site-packages/astroid/inference.py infer_end.srcCsvg}xl|jD]b}t|tjrdt|j|}|ss   rccsRtdd|jDs|Vn2t||}t||j|j|jd}|||VdS)Ncss|]}t|tjVqdS)N)rrr).0er r r Qsz!infer_sequence..)lineno col_offsetparent)anyrrtyperr r!postinit)r rrnew_seqr r rinfer_sequenceOs  r&ccsXtdd|jDs|Vn8t||}t||j|j|j}|t||VdS)Ncss|]\}}t|tjVqdS)N)rr DictUnpack)rk_r r rrcszinfer_map..) r"items _infer_mapr#rr r!r$list)r rr*r%r r r infer_mapbs  r-cCs.t||}dd|D}t|S)abDelete 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 duplicte keys in inferred Dict items :param dict(nodes.NodeNG, nodes.NodeNG) lhs_dict: Dictionary to 'merge' nodes into :param dict(nodes.NodeNG, nodes.NodeNG) rhs_dict: Dictionary with nodes to pull from :return dict(nodes.NodeNG, nodes.NodeNG): merged dictionary of nodes cSsi|]\}}||f|qSr )Z as_string)rkeyrr r r ~sz,_update_with_replacement..) itertoolschainr*dictr)Zlhs_dictZrhs_dictZ combined_dictZ string_mapr r r_update_with_replacementlsr3cCsi}x|jD]\}}t|tjrft||}|s6tjt|tjsPtj||dt ||}t ||}q tj||d}tj||d}t dd||fDrtj||dt |||i}q W|S)z$Infer all values based on Dict.items)rr)rcss|] }| VqdS)Nr )relemr r rrsz_infer_map..) r*rrr'rrrrDictr+r3r")rrrnamerZdouble_starredZ unpack_itemsr.r r rr+s      r+cCs8|}x|jr"t|jtjs"|j}qW|r4|jr4|jSdS)a Search 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.scoped_nodes.Function`, which encloses the given node. N)r!rr FunctionDef)rZcurrentr r r_higher_function_scopes   r8cCsn||j\}}|sNt|}|r4||j\}}|sNtj|j||dt|}|j|_t |||S)z#infer a Name: use name lookup rules)r6scoper) lookupr6r8r9rZNameInferenceError contextmod copy_context lookupnamer _infer_stmts)r rframestmtsZparent_functionr)r r r infer_names  rAc cst|}tj|j|jd|_d|_|dk rinfer a Call node by trying to guess what the function returns)argskeywordsNinfer_call_result)Zcallerr)rr)r;r< CallContextrBrC callcontext boundnode_populate_context_lookupcloneZ extra_contextfuncinferr UninferablerrDrrr2)r rrFZcalleer r r infer_calls     rMTc cs~|j}|dkrtj||dy(|r6|||Vn ||VWn4tjk rx}ztj||d|Wdd}~XYnXdS)z7infer an Import node: return the imported module/objectN)rr)r=rrdo_import_module real_nameAstroidBuildingError)r rasnamer6excr r r infer_importsrSc Cs|j}|dkrtj||d|r*||}y |}Wn4tjk rj}ztj||d|Wdd}~XYnXy2t|}||_|j||| kd}t ||Stj k r}ztj|j |||d|Wdd}~XYnXdS)z:infer a ImportFrom node: return the imported module/objectN)rr)Z ignore_locals)target attributer)r=rrrOrNrPr;r<getattrrootrr>AttributeInferenceErrormessage)r rrQr6modulerRr@errorr r rinfer_import_froms$  "  r\c csx|j|D]}|tjkr$|Vq|r|jrt|tjrt|jtjry$t t |jt |rj|j}Wnt j k rYnXy$||_| |j|EdHd|_Wqt jt jfk rd|_Yqtk rd|_YqXqWt||dS)zAinfer an Attribute node by using getattr on the associated objectN)rr)exprrKr rLrGrrInstancer is_subtype object_typer_NonDeducibleTypeHierarchyigetattrZattrnamerXrAttributeErrorr2)r rownerr r rinfer_attributes.        rec Csr|jdkrtj||dyt||j|Stjk rl}ztj|j||j|d|Wdd}~XYnXdS)N)rr)rTrUr) r=rrrr>rWrVrXrY)r rr[r r r infer_global@s rfc csPd}x2|j|D] }|tjkr0tjVdSx|j|D]}|tjkrZtjVdSt}|jtjkrp|}n$|jtjkrt |}|r|}n|}|tkrt j ||dy| ||}Wn@t jt jt jtfk r}zt j ||d|Wdd}~XYnX||ks|tjkrtjVdS||EdHd}q@WqW|rLt||dSdS)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. FN)rrT)rrKr rLslice_SUBSCRIPT_SENTINEL __class__rr^rZclass_instance_as_indexrrgetitemZAstroidTypeErrorZAstroidIndexErrorrXrcr2) r rZ found_onerindexZ index_valueZinstance_as_indexassignedrRr r rinfer_subscriptSsF      "  rmc#s|j}|jdkrtj}ntj}yfdd|D}Wntjk rRtjVdSXxt j |D]~}t dd|DrtjVq`dd|D}t dd|DrtjVq`tj}x,t ||D]\}}||r|VPqW|Vq`Wt |d 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. orcsg|]}|jdqS))r)rK)rr)rr r sz!_infer_boolop..Ncss|]}|tjkVqdS)N)r rL)ritemr r rrsz _infer_boolop..cSsg|] }|qSr ) bool_value)rrpr r rroscss|]}|tjkVqdS)N)r rL)rrpr r rrs)rr)ropoperatortruthnot_rrr rLr0productr"zipr2)r rrZ predicateZpairZ bool_valuesrrqr )rr _infer_boolops0    rxccs2x,|||D]}t||r$tjVq |Vq WdS)N)rr rL)r Zinfer_callablerr[resultr r r_filter_operation_errorss  rzc csx|j|D]}y||jVWqtk r\}zt||j|VWdd}~XYqtk r}ztj |j}|dkr| }|tj k rt | Vntj Vn:t|tjt jfst||j|Vwyyt||}Wn,tjk rt||j|VwYnX|d}t|j|d}|tj ksF|sHwt|}tj|gd|_|j||d}t|d} | dkr|Vn| VWnVtjk r}zt||j|VWdd}~XYn tjk rtj VYnXWdd}~XYqXqWdS)z3Infer what an UnaryOp should return when evaluated.Nr)r)rB)operandrKZinfer_unary_oprr TypeErrorr BadUnaryOperationMessagercr ZUNARY_OP_METHODrqrLrZ const_factoryrrr^ClassDefr r:rrXnextcallabler;r<rErFrDr) r rr{rRmethrqmethodsinferredZ call_resultsryr r r_infer_unaryopsH"       "rccs"t|t|tjEdHt||dS)z3Infer what an UnaryOp should return when evaluated.N)rr)rzrr r}r2)r rr r r infer_unaryop srcCst|tjo|jtkS)z0Check if the given const node is NotImplemented.)rrConstrNotImplemented)Zconstr r r_is_not_implementedsrc CsRt||}t||}|d}t|j|d}|tjkr@tj | |||||S)z8Invoke binary operation inference on the given instance.r)r) r r:r;bind_context_to_noderrKr rLrrZinfer_binary_op) instanceopnoderrotherr method_namermethodrr r r_invoke_binop_inferences   rFc Cs"tj|}tjt||||||dS)zt|||||t|||||g} nt||rlt|||||t|||||g} nrt||rt|||||t|||||ddt|||||g} n2t|||||t|||||t|||||ddg} | 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) =T)r)rrstriprrrrr_r) rrZ aug_opnoderrrrZbin_opZaug_oprr r r _get_aug_flows     rc cst|||\}}t|}t|}||||||||}x|D]} yt| } WnHtk rfw>Yq>tjk r|w>Yq>tjk rtj VdSXt dd| Drtj VdSt t t | rq>tdd| D} | r| t| krtj VdS| EdHdSq>Wt||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. Ncss|]}|tjkVqdS)N)r rL)rryr r rrsz*_infer_binary_operation..css|]}t|rdVqdS)N)r)rryr r rrs)rrr`r,rcrrXrr rLr"allmaprsumlenBadBinaryOperationMessagerr) rrrr flow_factoryrrrrrZresultsZnot_implementedr r r_infer_binary_operations8    rc cs|j}|j}|pt}t|}t|}|j|d}|j|d}xtt||D]d\}} tdd| |fDr|t j VdSyt || ||t EdHWqRt jk rt j VYqRXqRWdS)z!Binary operation inference logic.)rcss|]}|tjkVqdS)N)r rL)rrr r rrsz_infer_binop..N)rrr;InferenceContextr<rKr0rvr"r rLrrrra) r rrrZ lhs_context rhs_contextlhs_iterrhs_iterlhsrhsr r r _infer_binops     rcCst|t|tjS)N)rzrr r)r rr r r infer_binopsrc cs|dkrt}|}|jj|d}|jj|d}xvt||D]f\}}t dd||fDrlt j VdSyt ||||t dEdHWqBtjk rt j VYqBXqBWdS)z0Inference logic for augmented binary operations.N)rcss|]}|tjkVqdS)N)r rL)rrr r rr sz#_infer_augassign..)rrrrr)r;rrIrT infer_lhsrrKr0rvr"r rLrrrra)r rrrrrrr r r_infer_augassigns$rcCst|t|tjS)N)rzrr r)r rr r rinfer_augassignsrcCs*|j}|dkrtj||dt|||S)N)rr)r=rrr Z_arguments_infer_argname)r rr6r r rinfer_arguments+srcCs:|}t|tjr||St|j|d}t||S)zWinfer a AssignName/AssignAttr: need to inspect the RHS part of the assign node )r) Z statementrr AugAssignrKr,Zassigned_stmtsrr>)r rZstmtr@r r r infer_assign6s   rccsP|stjVn:ytj|j|dEdHWntjk rJtjVYnXdS)N)r)Zhas_underlying_objectr rLMANAGERZinfer_ast_from_somethingobjectrZ AstroidError)r rr r rinfer_empty_nodeHs  rcCs |j|S)N)rrK)r rr r r infer_indexWsrcCsdt||}|s|}tj|gd|_t|jd|dd}t|tjsTt j d||dt| ||S)N)rB __getitem__)rz(Could not find __getitem__ for {node!r}.)rr) r;rrErFrrbrrZ BoundMethodrrrD)r rkrrrr r rinstance_getitem`s   rcCspi}|dkr|Sx.|jD]$}t|tjr4|||j<q|||<qW|jdk rP|jng}x|D]}|||j<qZW|S)N)rBrrrrrC)ZcallrZcontext_lookuprrCkeywordr r rrHus     rH)N)N)N)N)N)N)NT)NT)N)N)N)N)N)N)F)F)N)N)N)N)N)N)N)N)[__doc__rr0rsZastroidrrr;rrrrrZastroid.interpreterr r r ZAstroidManagerrrZModuleZ_inferr~r7ZLambdarZSlicerZraise_if_nothing_inferredr&ZListZTupleSetr-r3r+r5r8rAZ path_wrapperNameZ AssignNamerrMZCallrSZImportr\Z ImportFromreZ AttributeZ AssignAttrrfZGlobalrrhrmZ SubscriptrxZBoolOprzrrZUnaryOprrrrrrrrrrZyes_if_nothing_inferredrZBinOprrrrZ ArgumentsrrZ EmptyNoderZIndexrr^rjrHr r r rs                $  83 6  #-,