[ӟ3
U d Z ddlmZ ddlZddlZddlZddlZddlZddlm Z m
Z
m Z m Z ddlm
Z
mZmZmZmZ ddlmZmZmZmZmZmZmZ ddlmZ ddl m Z m Z m Z m 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/m0Z0m1Z1m2Z2 e
rdd
l3m4Z4 ej5 d Z6 ed Z7 edej8 Z9 edej: Z;ej e1ee1 eej< ej= f e1ee1 e e gdf Z> dddZ?e?ej@ _A e?ejB _A e?ejC _A e?ejD _A e?ejE _A ddd ZFejG ddd ZHeHejI _A eHejJ _A eHejK _A ddd#ZLdd'ZMdd(ZNeLejO _A dd+ZP ddd.ZQ ejG ejR eQ ejS _A eQejT _U ejG ejR ddd1 ZVeVejW _A ejG ejR ddd7 ZXeXejY _A ejG ejR ddd9 ZZeZej[ _A ddd;Z\ ejG ejR e\ ej] _A ejG e\ ej^ _U ejG ejR ddd= Z_e_ej` _A ea Zb ddd@Zc ejG ejR ec ejd _A ejG ec ejd _U ejG ejR dddB Zeeeejf _A ddGZg dddJZhejG ejR dddK Ziehejj _h eiejj _A ddLZkddRZlddYZm ddd^Zn ddd_ZoddcZpdd ZqddeZrddkZsddmZtddqZu dddsZvejw ejR dddt Zxevej= _v exej= _A ejy ejz ej{ ej| ej} ej~ du dv dwZdxedy< dzd{hZdd|ZddZ dddZeej _A dddZejG ejR ddd Zeej< _ eej< _A ejG ddd Zeej _A ejG ejR ddd ZeejT _A eej^ _A ejG ejR ddd Zeej _A ddZejG ddd Zeej _A dddZeej: _A dS )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 | V dS )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.
N r. r/ r1 s c/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/astroid/inference.py infer_endr8 F s JJJJJ node list[SuccessfulInferenceResult]c g }| j D ] }t |t j rqt j |j | }|st | | t |d st | | | t | t |t j rCt j |j | }|st | | | | | | |S )z.Infer all values based on _BaseContainer.elts.r: r/ elts)
r>
isinstancer Starredr
safe_infervaluer hasattrextend_infer_sequence_helper NamedExprappend)r: r/ valueseltstarredrB s r7 rE rE Z s Fy c5= ) )
(G<z!infer_sequence..x sF ! !<=
1u}eo677! ! ! ! ! !r9 )lineno
col_offsetparent)anyr> rE typerR rS rT postinit)r. r/ r1 has_starred_named_exprrH new_seqs r7 infer_sequencerZ r s ! ! !AE! ! ! 'g66 $t**;4?4;
r9
nodes.DictIterator[nodes.Dict]c # 4 K t d | j D s| V d S t | | } t | | j | j | j }| t | |V d S )Nc 3 P K | ]!\ }}t |t j V "d S rN )r? r
DictUnpack)rO k_s r7 rQ z infer_map.. s3 FF41az!U -..FFFFFFr9 ) rU items
_infer_maprV rR rS rT rW list)r. r/ rb rY s r7 infer_mapre s FF4:FFF F F
4)) $t**T[$/4;GGekkmm,,---
r9 lhs_dict:dict[SuccessfulInferenceResult, SuccessfulInferenceResult]rhs_dictc t j | | }d |D }t | S )a Delete 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
c B i | ] \ }}| ||f S r5 ) as_string)rO keyrB s r7
z,_update_with_replacement.. s* PPPJC#--//C<PPPr9 ) itertoolschainrb dictrH )rf rh
combined_dict
string_maps r7 _update_with_replacementrs sV & OHNN$4$4hnn6F6FGGMPP-PPPJ
!!## $ $$r9 c i }| j D ]\ }}t |t j rjt j || }|st t |t j st
| | t || }t || }t j || }t j || }t d ||fD rt
| | t |||i }|S )z%Infer all values based on Dict.items.r= r/ c 3 K | ]}| V d S rN r5 )rO elems r7 rQ z _infer_map.. s$ ::t8::::::r9 ) rb r? r r_ r rA r Dictrc rs rU ) r: r/ rH namerB double_starred unpack_itemsrl
safe_values r7 rc rc s JLFz I I e dE , - - I $ /w ? ?N!
%$$ nej99
A$$@@@@%ng>>L-flCCFF$T7;;;C +E7CCCJ::j(9:::::
A$$@@@@-fsJ6GHHFF Mr9 nodes.NodeNGnodes.FunctionDef | Nonec | }|j rLt |j t j s-|j }|j r t |j t j -|r|j r|j S dS )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.nodes.scoped_nodes.Function`,
which encloses the given node.
N)rT r? r FunctionDef)r: currents r7 _higher_function_scoper sp G
. !GNE ~ 4r9 nodes.Name | nodes.AssignName&Generator[InferenceResult, None, None]c | | j \ }}|skt | }|r | | j \ }}|s)t | j | | t | }| j |_ t j | | |j | j < t j ||| S )z$Infer a Name: use name lookup rules.)ry scoper/ ) lookupry r r r r
lookupnamer get_constraints constraintsr
_infer_stmts)r. r/ r1 framestmtsparent_functionra s r7
infer_namer s ;;ty))LE5
1 >> 9&--di88HAu $YdjjllG
7##G G%/%?e%L%LG " eWe 4 44r9
nodes.Call4Generator[InferenceResult, None, InferenceErrorInfo]c + K t | }d|_ |'t | | |_ | j | D ]}t |t j r|V ! t |d r>t | j | j
| |_ | | | E d{V q# t $ r Y }w xY wt# | | 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? r UninferableBaserC r r r callcontextr r r$ )r. r/ r1 r r s r7
infer_callr s w''K K$AC
CCT nodes.Importasnamebool#Generator[nodes.Module, None, None]c + 2 K |p
t }|j }|t | | |r,| | | V dS | | V dS # t
$ r}t | | |d}~ww xY w)z8Infer an Import node: return the imported module/object.Nr= )r r r do_import_module real_namer )r. r/ r r1 ry excs r7 infer_importr s +)++G D | $8888B .''t(<(<== = = = = =''-- - - - - - B B B $888cABs ,A5 A5 5
B?BBnodes.ImportFromc X |p
t }|j }|t | | |r; | | }n$# t $ r}t | | |d}~ww xY w | }n$# t $ r}t | | |d}~ww xY w t | }||_ | ||| u }t j || S # t $ r&}t t | | || |d}~ww xY w)z;Infer a ImportFrom node: return the imported module/object.Nr= )
ignore_localstarget attributer/ )
r r r r r r r r getattrrootr
r str) r. r/ r r1 ry r moduler errors r7 infer_import_fromr : sw +)++G D | $8888
F F>>$''DD& F F F dG<<<# E FB&&(( B B B $888cAB w'' !t6TYY[[3HII!%111 " JJttW
sH A
A%A A%)A> >
B BB #AC9 9
D)!D$$D)"nodes.Attribute | nodes.AssignAttrc + X K | j | D ]}t |t j r|V !t | }|j } ||_ t |t j t j
f rFt |t j r|n|j }t j
| | |j | j < | | j | E d{V n # t" t$ t& f$ r Y nw xY w||_ # ||_ w xY wt) | | S )zBInfer an Attribute node by using getattr on the associated object.)r Nr= )exprr r? r r r r r ClassDefr
Instance_proxiedr r r attrnameigetattrr r AttributeErrorr$ )r. r/ r1 owner
old_boundnoder s r7 infer_attributer ` sS )) . . eT 1 2 2 KKK w'' )
. %G %%.%.!ABB
!+E5>!B!BV5?5O6 6 6#DM2 ~~dmW== = = = = = = = = #
D !.G
G - - - - 4 9 9 99s+ BC*)D*DDDD D nodes.Globalc & ||j t | | t j | |j | S # t $ r+}t t | | |j | |d }~ww xY w)Nr= r )r r r
r r r r r )r. r/ r1 r s r7 infer_globalr s
',4 $8888!$))++"5"5g6H"I"I7SSS " JJtw/A7
s >A
B%&B Bnodes.Subscript;Generator[InferenceResult, None, InferenceErrorInfo | None]c + t K d}| j | D ]}t |t j rt j V dS | j | D ]:}t |t j rt j V dS t }|j t j
k r|}n0|j t j
k rt j | }|r|}n|}|t u rt | | | || }n=# t t t" t$ t& f$ r} t | | | d} ~ ww xY w| |u st |t j rt j V dS | | E d{V d}<|rt) | | S dS )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)rB r r? r r Uninferableslice_SUBSCRIPT_SENTINEL __class__r
r r class_instance_as_indexr getitemr r r r r r$ )
r. r/ r1 found_onerB index index_valueinstance_as_indexassignedr s
r7 infer_subscriptr s I!!'** ( ( eT 1 2 2 " " " "44Z%%g.. $ $ E%!566
&&&&ttt .K%.00 # EN22$+$CE$J$J!$ 4"3K # 111$$@@@@
J ==g>> !!'
J
J
J %$@@@cI
J x :h8L#M#M &&&&ttt ~~g.. . . . . . . . III$ L >!tW==== 4s D#E:E E nodes.BoolOpc + & K | j }| j dk r
t j }n t j } fd|D }n # t
$ r t j V Y dS w xY wt j | D ]}t d |D rt j V *d |D }t d |D rt j V ^t j }t || D ]\ }} || r|V n|V t | 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 )rO rB r/ s r7
z!_infer_boolop.. s' LLLE5;;w;77LLLr9 Nc 3 J K | ] }t |t j V d S rN r? r r rO items r7 rQ z _infer_boolop.. s/ GG$z$ 455GGGGGGr9 c 6 g | ]}| S r5 )
bool_valuer s r7 r z!_infer_boolop.. s" :::Tt((:::r9 c 3 J K | ] }t |t j V d S rN r r s r7 rQ z _infer_boolop.. s/ NN$z$ 455NNNNNNr9 r= )
rH opoperatortruthnot_r r r rn productrU zipr$ )
r. r/ r1 rH predicateinferred_valuespair bool_valuesrB r s
` r7
_infer_boolopr sv [F w$ N M LLLLVLLL tt !?3 GG$GGG G G " " " " ::T::: NN+NNN N N " " " " !$T;!7!7 E:y$$
KKK 4 9 9 99s ? AAinfer_callablejCallable[[_T, InferenceContext | None], Generator[InferenceResult | util.BadOperationMessage, None, None]]r type[util.BadOperationMessage]c # n K || | D ]%}t || rt j V !|V &d S rN )r? r r )r. r r/ r results r7 _filter_operation_errorsr s^ !.w// fe $ $ " " " " "LLLL r9
nodes.UnaryOpFGenerator[InferenceResult | util.BadUnaryOperationMessage, None, None]c # . K | j | D ]v} | | j V !# t $ r'}t j || j | V Y d}~Md}~wt $ r}t j | j }|W|
}t |t
j st j | V nt
j V nt |t j t j f s#t j || j | V Y d}~ t' j || }n2# t* $ r% t j || j | V Y Y d}~Zw xY w|d }t- | | d }t |t
j s| sY d}~t1 | }||_ t5 g | |_ | | | }t- |d } | |V n| V nM# t* $ r'}
t j || j |
V Y d}
~
n!d}
~
wt: $ r t
j V Y nw xY wY d}~pd}~ww xY wdS )3Infer what an UnaryOp should return when evaluated.Nr ru )r r ) operandr infer_unary_opr TypeErrorr BadUnaryOperationMessager r UNARY_OP_METHODr r? r r
const_factoryr r
r r r" r r nextcallabler r r r r r ) r. r/ r r methr methodsinferred call_resultsr inner_excs r7 _infer_unaryopr 1 s <%%g.. 6+ 6+5 +((11 1 1 1 1 G G G/#FF F F F F F F F F 0 + 0 + 0 + ,TW5D| % / / 1 1
!*d.BCC + -*n====== *****!'ENEN+KLL 7#NNNNN HHHH +!"/"6w"E"E2 ! ! ! " ;GTWc R RRRR ! #1:D #DJJwJ$?$? F FH"8T-ABB! ' 0 0 2 2! ! *7 3 3G(/G%*52h*O*O*OG'#+#=#=dG#=#T#TL !, 5 5F ~ %
$ . U U U 7)TTTTTTTTTT% + + + ******+_0 +
6+ 6+s~ >
J A**J8B3J
3E H: 'E80H:7E88A H:A H:9J
:
J I&!J
&JJ
JJ
Jc + v K t | t |t j E d{V t | | S )r Nr= )r r r r r$ r6 s r7
infer_unaryopr n sY ( ngt'D 4 9 9 99r9 c R t | t j o
| j t u S )z0Check if the given const node is NotImplemented.)r? r ConstrB NotImplemented)consts r7 _is_not_implementedr ~ s eU[ ) ) Kek^.KKr9 instance nodes.Constotherr )tuple[util.UninferableBase | nodes.Const]c t t |t j rit j |j v r
t j fS fd|j D }t
d |D rt d |D }nd}nt |t j ri }|j D ]}t j |d }t |t j st j fc S t j |d }t |t j st j fc S |j
||j
< n/t |t j r|j
}n
t j fS t j | j
|z fS # t t t" f$ r t j fcY S w xY w)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 | ]}t j | S r5 )r rA )rO ir/ s r7 r z6_infer_old_style_string_formatting.. s& R R R!w 1!W = = R R Rr9 c 3 J K | ] }t |t j V d S rN )r? r r rO r s r7 rQ z5_infer_old_style_string_formatting.. s. GGaz!U[))GGGGGGr9 c 3 $ K | ] }|j V d S rN )rB r s r7 rQ z5_infer_old_style_string_formatting.. s$ @@q17@@@@@@r9 Nr )r? r Tupler r r> alltuplerx rb r rA r rB r r KeyError
ValueError)r
r r/ inferred_positionalrH r rl rB s ` r7 "_infer_old_style_string_formattingr s %%% # uz ) )$& & R R R Ruz R R R GG3FGGG G G @@,?@@@@@FFFF E5: & &
#!#K , ,D$T!Wg66C c5;//
+ (****&tAw88E eU[11
+ (**** % F39 ,
E5; ' ' # ""##HNV$;<<>> x , # # # """"#s 3 F $F76F7r% opnode nodes.AugAssign | nodes.BinOpr r method_namec t j | | }t || }|d }||j _ t | t j r>t | j t r$|dk r t t | || S t |
| }n$# t $ r} t || | d} ~ ww xY wt |t j rt t | t j t j t j t j t* j f st | ||||| S )z8Invoke binary operation inference on the given instance.r %ru r= N)r" r r r r r? r r rB r iterr r r
StopIterationr r r r Listr r
r infer_binary_op)
r
r r r r/ r r methodr rP s
r7 _invoke_binop_inferencer& sQ "8[99G"7H55G
QZF!'G 8U[))R x~s + +R
#II6xPPQQQB W 5566 B B B &':::AB(D 011 5; UZ X # #FBw I IIs #B7 7
CCCFnodes.AugAssignreverse9functools.partial[Generator[InferenceResult, None, None]]c f t j | }t j t | ||||| S )zCreate a new UnionType instance for binary or, e.g. int | str.N)r
UnionType)r5 r7 s r7 _bin_op_or_union_typer: s&
/$
&
&&&&&&r9 c # K ||fD ]7}| }t |g |_ d|_ |V 8dS )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.
)r N)r r r r )r/ r5 r7 arg new_contexts r7 _get_binop_contextsr> s^ t} mmoo "-C5"9"9"9 $ r9 c V | | k S )z$Check if type1 is the same as type2.)qname)type1type2s r7
_same_typerC s ;;==EKKMM ))r9 left_typeInferenceResult | None
binary_opnode
right_typereverse_contextc |j }t || rt | |||| g}nt j || rt | |||| g}nft j || r)t |||| |d t | |||| g}n(t | |||| t |||| |d g}t r|dk rt | t j t j f s!t | t j r}| j
vt |t j t j f s!t |t j r6|j
/| t j t" | | g |S )aV Get 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( |)r rC r4 r
is_subtype is_supertyper r? r
r9 r r r rB rD r- r. r: ) r5 rD rF r7 rG r/ rH r r s r7 _get_binop_flowrN s .
B)Z((
4 E7CCD Iz 2 2
4 E7CCD i 4 4
E="dOT R R R D-UG < <
D-UG < < E="dOT R R R
P #II teou~ > ? ?
$ ,,
"
uu ? @ @ # %-- #
# )*?uMMNOOO Nr9
aug_opnodec
B |j d }|j }t || r't | |||| t | |||| g} nt j || r't | |||| t | |||| g} nt j || r;t | |||| t |||| |d t | |||| g} n:t | |||| t | |||| t |||| |d g} | S )a Get 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)
=TrJ )r striprC r0 r4 r rL rM )
r5 rD rO r7 rG r/ rH bin_opaug_opr s
r7
_get_aug_flowrU P sS 0 ]
%
%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 # K t || | \ }}t j | }t j | } || |||||| }|D ]} t | }
t d |
D rt
j V dS t t t |
rgt d |
D } | r$| t |
k rt
j V dS |
E d{V dS # t $ r Y t $ r Y t $ r t
j V Y dS w xY wt j ||j | V dS )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.
c 3 J K | ] }t |t j V d S rN r rO r s r7 rQ z*_infer_binary_operation.. s/ RR:fd&:;;RRRRRRr9 Nc 3 8 K | ]}t | d V dS )r N)r r[ s r7 rQ z*_infer_binary_operation.. sD " " +>v+F+F"" " " " " "r9 )r> r object_typerd rU r r r mapr sumlenr r r BadBinaryOperationMessager ) r5 r7 rF r/ rV rH rD rG r r% resultsnot_implementeds r7 _infer_binary_operationrd s 37D% H H G_#D))I$U++Jl i z7O G 6688nnG RR'RRRRR
&&&&3*G4455
! " " '" " " O
?c'll#B#B&&&& FF/ H& H " " " " FFF *
(M4Dj
Q
QQQQQQs D
D6 D6D65D6 nodes.BinOpc # K | j }| j }|p
t }t | }t | }| | }| | }t j || D ]n\ }} t d | |fD rt j V dS t || | |t E d{V Q# t $ r t j V Y kw xY wdS )z!Binary operation inference logic.ru c 3 J K | ] }t |t j V d S rN r rO rB s r7 rQ z _infer_binop.. / OO5z%!566OOOOOOr9 N)
r5 r7 r r r rn r rU r r rd rN r! )
r. r/ r5 r7 lhs_context rhs_contextlhs_iterrhs_iterlhsrhss
r7 _infer_binoprp s, 9D JE
+)++G w''K w''Kzz+z..H{{;{//H %h99 # #S OOS#JOOO O O " " " " FF #.sCwXX X X X X X X X X) # # #" " " " " " # # #s 2 CC,+C,c D t | t |t j S rN )r rp r ra r6 s r7 infer_binoprr s"
$ lGT%C r9 c
| |v S rN r5 abs r7 rw s
qAv r9 c
| |vS rN r5 rt s r7 rw rw s
1A: r9 )z==z!=z>=inznot inz%dict[str, Callable[[Any, Any], bool]] COMPARE_OPSiszis notc N t j | S rN )ast literal_evalrk )r: s r7 _to_literalr s DNN , , - --r9 left_iterIterable[nodes.NodeNG]
right_iterbool | util.UninferableBasec ( d}|t v r t j S t | }t j | | D ]\ }}t
|t j st
|t j rt j c S t | t | }}n+# t t t f$ r t j cY c S w xY w ||| }n# t $ r
}t |d}~ww xY w||}||k rt j c S |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_OPSr r r| rn r r? r r SyntaxErrorr r r r ) r r r retvalop_funcr5 r7 r r s r7 _do_comparer sY F _ "oG (J?? $ $ e dD 0 1 1 $Z 4'6
6
$ # # # # $%d++[-?-?%DDZ 8 $ $ $# # # # # # $ ,74''DD , , ," + , >FF
t^^# # # # Ms* B!!#C C
C
C1$C,,C1
nodes.Compare9Generator[nodes.Const | util.UninferableBase, None, None]c + K d}| j }| j }t | | }|D ]`\ }}t | | } t ||| }n # t
$ r t j }Y n
w xY w|dur n| }a|t j u r|V dS t j | V dS )z#Chained comparison inference logic.Tru N)
opsr5 rd r r r r r r r )
r. r/ r1 r r left_nodern r
right_nodero s
r7 _infer_comparer " s +/F
(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\ }}t d ||fD rt j
V dS t ||| |t E d{V R# t $ r t j
V Y lw xY wdS )z0Inference logic for augmented binary operations.ru c 3 J K | ] }t |t j V d S rN r rh s r7 rQ z#_infer_augassign..K ri r9 N)r5 r7 rF r/ rV )r r r infer_lhsrB r rn r rU r r rd rU r! )r. r/ rk rl rm rn ro s r7 _infer_augassignr @ s9 +)++G--//K{$$W$55Hz 44H %h99 # #S OOS#JOOO O O " " " " FF #. " *
* # # #" " " " " " # # #s $ CC C c D t | t |t j S rN )r r r ra r6 s r7 infer_augassignr \ s#
$ )G r9 nodes.Argumentsc l ||j t | | t j | |j | S )Nr= )r r r _arguments_infer_argnamer6 s r7 infer_argumentsr l s< ',4 $8888 -dG4F P PPr9 #nodes.AssignName | nodes.AssignAttrc t | j t j r| j | S t | | }t j || S )zXInfer a AssignName/AssignAttr: need to inspect the RHS part of the
assign node.
ru ) r? rT r AugAssignr rd assigned_stmtsr
r )r. r/ r1 r s r7 infer_assignr x sa $+u// *{ ))) $$W$55 6 6E eW - --r9 nodes.EmptyNodec + K | st j V d S t | j | E d {V d S # t $ r t j V Y d S w xY w)Nru )has_underlying_objectr r r# infer_ast_from_somethingobjectr r6 s r7 infer_empty_noder s
% % ' ' # #%''@@ W A
# # #" " " " " " " #s .A A43A4callc i }||S | j D ],}t |t j r |||j < '|||< -| j | j ng }|D ] }|||j <
|S rN )r r? r r@ rB r )r r/ context_lookupr< r keywords r7 r r s ?AN y * * c5= ) ) *(/N39 % %")N3 $
9t}}rH 0 0(/w}%% r9 nodes.IfExpc + K d}|p
t }t | }t | } t | j | }t
|t j sX| r"| j
| E d{V n>| j | E d{V n d}n# t t f$ r d}Y nw xY w|rD| j
| E d{V | j | E d{V dS dS )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.
Fru NT)r r r testr r r? r r r bodyorelser r" )r. r/ r1
both_branchesrj rk r s r7 infer_ifexpr s M
+)++G w''K w''K !DIOOGMMOOO<<== $ 455 !
B 9??;??????????? ;,,[,AAAAAAAAAA MM
M *
:9??;?777777777;$$[$99999999999: :s :C# #C98C9=Generator[Property | _FunctionDefT, None, InferenceErrorInfo]c + r K | j rt j | s| V t | | S | j d }| j |j v o(t d |j | j D }t | j t j t j t j
f rd}t | | j | j |s| j nd | j }|r | j |_ | g | j | j |V t | | S )Nr= T)futurec 3 J K | ] }t |t j V d S rN )r? r( r' )rO vals r7 rQ z$infer_functiondef.. sH Q Q.1
3())Q Q Q Q Q Qr9 )functionry rR rT rS )r r doc_node)r r
_is_propertyr$ rT r ry localsrU r? r TryExcept
TryFinallyIfr( r' rR rS rW r r )r. r/ r1 parent_frame!property_already_in_parent_locals prop_funcs r7 infer_functiondefr s[ ? >%"4T":": >
!tW==== ;$$D$11L(, \5H(H )S Q Q5A5H5SQ Q Q N N% $+1A58 LMM 1,0)
Y{"CMt{{? ! I ) ' ;
BTY GGG
OOO 4 9 9 99r9 rN )r. r) r/ r0 r1 r r2 r3 )r: r* r/ r0 r2 r; )r. r* r/ r0 r1 r r2 rK )r. r[ r/ r0 r2 r\ )rf rg rh rg r2 rg )r: r[ r/ r0 r2 rg )r: r} r2 r~ )r. r r/ r0 r1 r r2 r )r. r r/ r0 r1 r r2 r )NT)
r. r r/ r0 r r r1 r r2 r )
r. r r/ r0 r r r1 r r2 r )r. r r/ r0 r1 r r2 r )r. r r/ r0 r1 r r2 r )r. r r/ r0 r1 r r2 r )r. r r/ r0 r1 r r2 r )
r. r) r r r/ r0 r r r2 r )r. r r/ r0 r2 r )r. r r/ r0 r1 r r2 r )r2 r )r
r r r} r/ r r2 r
)r
r% r r r r r r% r/ r r r r2 r )F)r
r% r r' r r r r% r/ r r( r r2 r) )r
r% r r r r r r% r/ r r( r r2 r) )r5 r6 r7 r6 r2 r )r5 r% rD rE rF r r7 r% rG rE r/ r rH r r2 r- )r5 r% rD rE rO r' r7 r% rG rE r/ r rH r r2 r- ) r5 r% r7 r% rF r r/ r rV rW r2 rX )r. re r/ r0 r2 rX )r. re r/ r0 r1 r r2 r )r: r} r2 r )r r r r r r r2 r )r. r r/ r0 r1 r r2 r )r. r' r/ r0 r2 rX )r. r' r/ r0 r1 r r2 r )r. r r/ r0 r1 r r2 r )r. r r/ r0 r1 r r2 r )r. r r/ r0 r1 r r2 r )r r r/ r0 )r. r r/ r0 r1 r r2 r )r. r, r/ r0 r1 r r2 r )__doc__
__future__r r r- rn r typingcollections.abcr r r r r r r
r r astroidr
r r r r r r
astroid.constr astroid.contextr r r r astroid.exceptionsr r r r r r r r r! astroid.interpreterr" astroid.managerr# astroid.typingr$ r% r& astroid.objectsr' lazy_importr( r)
BaseContainerr* r r, r BinOprW r8 Module_inferr Lambdar SlicerE raise_if_nothing_inferredrZ r# r Setre rs rc rx r r path_wrapperName
AssignNamer r Callr Importr
ImportFromr Attribute
AssignAttrr Globalr r r Subscriptr BoolOpr r r UnaryOpr r r& r0 r4 r: r> rC rN rU rd rp yes_if_nothing_inferredrr eqneltlegtger| __annotations__r r r r Comparer r r Argumentsr r EmptyNoder r IfExpr r5 r9 r7 r s
T S S " " " " " "
C C C C C C C C C C C C ? ? ? ? ? ? ? ? ? ? ? ? ? ? R R R R R R R R R R R R R R R R R R $ $ $ $ $ $
. - - - - - * * * * * * )(((((( $
9
%
% WT]]'+53FGGGu/@AAA
!
eou{*+ ! F G " 26 ! ?C 0 % (, &%( #
# ! :> % % % %4 0
, (,5 5 5 5 58 9J8JJ''
( % 9=: : : : &%:0
% (,B B B B &%B* # % (, &% B ,
(, : : : : :D >=JO,, BZ A/ R R % ;?
&%
# fhh ?C8 8 8 8 8z >=JO,, AJ @ Q Q % ;?2: 2: 2: 2: &%2:j $ ( =A:+ :+ :+ :+ :+z % <@: : : : &%: .
$
L L L L
"# "# "# "#J J J J JP
6
6' ' ' '
* * * *
6 6 6 6r0 0 0 0f/R /R /R /Rf ;?# # # # #6 # :> $# ( +
+
+
+
%% 6 6 . . . .+ + + +^ =A" " " " "6 &
?C# # # # #8 % >B &% $4 (
%>BQ Q Q Q &%Q ) % (, . . . . &% . ' & % >B # # # # &% # * " %:> : : : : &% :D ! =A : : : : :D - r9