+
    iw]                    t   R t ^ RIHt ^ RIt^ RIHtHtHt ^ RIH	t	H
t
Ht ^ RIHtHtHt ^ RIHtHtHt ^ RIHtHtHt ^ RIHtHt ^ R	IHt ^ R
IHt ^ RIH t  ]'       dW   ^ RI!H"t" ]] ] R,          ]PF                  ]PH                  ,          ] ] R,          ]].]%]]] ,          ,          ,          3,          t& ! R R]4      t' ! R R]4      t( ! R R]4      t) ! R R]4      t* ! R R]*4      t+ ! R R])](]'4      t, ! R R]4      t- ! R R]-4      t. ! R R]4      t/R R  lt0R! R" lt1R#R$R%R&R'R(R)R*R+R,R-R.R/R0R1R2R3R4R5R6R7R8R9R:R;R</t2]2Pg                  4        U Uu/ uF  w  rV ]0! V4      bK  	  upp t4]2Pg                  4        U Uu/ uF  w  rV R=,           ]1! V4      bK  	  upp t5 ! R> R?]4      t6R# u upp i u upp i )@zThis module contains some base nodes that can be inherited for the different nodes.

Previously these were called Mixin nodes.
)annotationsN)Callable	GeneratorIterator)cached_property	lru_cachepartial)TYPE_CHECKINGAnyClassVar)basesnodesutil)CallContextInferenceContextbind_context_to_node)AttributeInferenceErrorInferenceError)dunder_lookup)NodeNG)InferenceResult)LocalsDictNodeNGc                  ,    ] tR t^0tRtRt R tR tRtR# )	StatementzhStatement node adding a few attributes.

NOTE: This class is part of the public API of 'astroid.nodes'.
Tc                    V P                   P                  V 4      pVP                  V 4      p W^,           ,          #   \         d     R# i ; i)zdThe next sibling statement node.

:returns: The next sibling statement node.
:rtype: NodeNG or None
N)parentchild_sequenceindex
IndexErrorselfstmtsr   s   &  ;/usr/lib/python3/dist-packages/astroid/nodes/_base_nodes.pynext_siblingStatement.next_sibling9   sJ     **40D!	## 		s   = AAc                    V P                   P                  V 4      pVP                  V 4      pV^8  d   W^,
          ,          # R# )zgThe previous sibling statement.

:returns: The previous sibling statement node.
:rtype: NodeNG or None
N)r   r   r   r   s   &  r"   previous_siblingStatement.previous_siblingF   s=     **40D!A:##     N)	__name__
__module____qualname____firstlineno____doc__is_statementr#   r&   __static_attributes__r)   r(   r"   r   r   0   s    
 L2
r(   r   c                  &    ] tR t^StRtR R ltRtR# )NoChildrenNodez1Base nodes for nodes with no children, e.g. Pass.c                   V ^8  d   QhRR/# )   returnzIterator[NodeNG]r)   )formats   "r"   __annotate__NoChildrenNode.__annotate__V   s      . r(   c              #  	&   "   R R j  xL
  R #  L5i)Nr)   r)   r    s   &r"   get_childrenNoChildrenNode.get_childrenV   s     s   r)   N)r*   r+   r,   r-   r.   r;   r0   r)   r(   r"   r2   r2   S   s    ; r(   r2   c                  ,    ] tR t^ZtRtR R ltR tRtR# )FilterStmtsBaseNodez6Base node for statement filtering and assignment type.c                   V ^8  d   QhRR/# r4   mystmtzStatement | Noner)   )r6   s   "r"   r7    FilterStmtsBaseNode.__annotate__]   s      ;K r(   c                <    V P                  4       VJ d   V.R3# VR3# )zAMethod used in _filter_stmts to get statements and trigger break.TF	statement)r    _node_stmtsrA   s   &&&&&r"   _get_filtered_stmts'FilterStmtsBaseNode._get_filtered_stmts]   s)    >>v% 64<u}r(   c                	    V # Nr)   r:   s   &r"   assign_typeFilterStmtsBaseNode.assign_typee       r(   r)   N)r*   r+   r,   r-   r.   rI   rM   r0   r)   r(   r"   r>   r>   Z   s    @r(   r>   c                  ,    ] tR t^itRtR tR R ltRtR# )AssignTypeNodez8Base node for nodes that can 'assign' such as AnnAssign.c                	    V # rL   r)   r:   s   &r"   rM   AssignTypeNode.assign_typel   rO   r(   c                   V ^8  d   QhRR/# r@   r)   )r6   s   "r"   r7   AssignTypeNode.__annotate__o   s      EU r(   c                N    WJ d   VR3# V P                  4       VJ d   V.R3# VR3# )zMethod used in filter_stmts.TFrD   )r    lookup_noderG   rH   rA   s   &&&&&r"   rI   "AssignTypeNode._get_filtered_stmtso   s8    >4<>>v% 64<u}r(   r)   N)r*   r+   r,   r-   r.   rM   rI   r0   r)   r(   r"   rQ   rQ   i   s    B r(   rQ   c                       ] tR t^ztRtR tRtR# )ParentAssignNodezGBase node for nodes whose assign_type is determined by the parent node.c                	6    V P                   P                  4       # rL   )r   rM   r:   s   &r"   rM   ParentAssignNode.assign_type}   s    {{&&((r(   r)   N)r*   r+   r,   r-   r.   rM   r0   r)   r(   r"   rZ   rZ   z   s
    Q)r(   rZ   c                  V    ] tR t^t$ RtR]R&    R]R&    R tRR R	 lltR
 R ltRt	R# )
ImportNodez$Base node for From and Import Nodes.
str | Nonemodnamezlist[tuple[str, str | None]]namesc                	    V# rL   r)   )r    framenames   &&&r"   _infer_nameImportNode._infer_name   rO   r(   Nc                    V ^8  d   QhRRRR/# )r4   r`   r_   r5   znodes.Moduler)   )r6   s   "r"   r7   ImportNode.__annotate__   s     
 

 
l 
r(   c                   V P                  4       p\        V RR4      pVf   V P                  pV'       d$   VP                  W4      VP                  8X  d   RpMRpTP                  TT\        T;'       d    V^8  4      VR7      # )zGReturn the ast for a module whose name is <modname> imported by <self>.levelNFT)rj   relative_only	use_cache)rootgetattrr`   relative_to_absolute_namerd   import_modulebool)r    r`   mymodulerj   rl   s   &&   r"   do_import_moduleImportNode.do_import_module   s    99;#D'48?llG
 227BhmmSII %%u33!4	 & 
 	
r(   c                    V ^8  d   QhRRRR/# )r4   asnamestrr5   r)   )r6   s   "r"   r7   rh      s     
 
 
 
r(   c                    V P                    F=  w  r#VR8X  d   Vu # V'       g   VP                  R^4      ^ ,          pTpW8X  g   K;  Vu # 	  \        RV VR7      h)zGet name from 'as' name.*.z:Could not find original name for {attribute} in {target!r})target	attribute)ra   splitr   )r    rv   rd   _asnames   &&  r"   	real_nameImportNode.real_name   s^    !ZZMDs{zz#q)!,  ( &H
 	
r(   r)   rL   )
r*   r+   r,   r-   r.   __annotations__re   rs   r   r0   r)   r(   r"   r^   r^      s1    .
 ('
4
 
r(   r^   c                  b    ] tR t^t$ RtR
tR]R&   ]R 4       tR t	R t
R t]R R	 l4       tR
tR# )MultiLineBlockNodea  Base node for multi-line blocks, e.g. For and FunctionDef.

Note that this does not apply to every node with a `body` field.
For instance, an If node has a multi-line body, but the body of an
IfExpr is not multi-line, and hence cannot contain Return nodes,
Assign nodes, etc.
zClassVar[tuple[str, ...]]_multi_line_block_fieldsc                	   a  \         ;QJ d!    . V 3R  lS P                   4       F  NK  	  5# ! V 3R  lS P                   4       4      # )c              3  <   <"   T F  p\        SV4      x  K  	  R # 5irL   )rn   ).0fieldr    s   & r"   	<genexpr>8MultiLineBlockNode._multi_line_blocks.<locals>.<genexpr>   s     U7TeWT5))7Ts   )tupler   r:   s   fr"   _multi_line_blocks%MultiLineBlockNode._multi_line_blocks   s1    uUt7T7TUuUuUt7T7TUUUr(   c              #  	   "   V P                    F8  pV F/  pVP                  '       d   K  VP                  4        R j  xL
  K1  	  K:  	  R #  L5irL   )r   is_function _get_return_nodes_skip_functionsr    block
child_nodes   &  r"   r   3MultiLineBlockNode._get_return_nodes_skip_functions   sF     ,,E#
)))%FFHHH $ - I   <AAAc              #  	   "   V P                    F8  pV F/  pVP                  '       d   K  VP                  4        R j  xL
  K1  	  K:  	  R #  L5irL   )r   r   _get_yield_nodes_skip_functionsr   s   &  r"   r   2MultiLineBlockNode._get_yield_nodes_skip_functions   sF     ,,E#
)))%EEGGG $ - Hr   c              #  	   "   V P                    F8  pV F/  pVP                  '       d   K  VP                  4        R j  xL
  K1  	  K:  	  R #  L5irL   )r   	is_lambda_get_yield_nodes_skip_lambdasr   s   &  r"   r   0MultiLineBlockNode._get_yield_nodes_skip_lambdas   sF     ,,E#
'''%CCEEE $ - Fr   c                   V ^8  d   QhRR/# )r4   r5   zlist[nodes.Assign]r)   )r6   s   "r"   r7   MultiLineBlockNode.__annotate__   s     J J(: Jr(   c                	x    R  V P                    4       p\        \        P                  P	                  V4      4      # )c              3  L   "   T F  pV F  pVP                   x  K  	  K  	  R # 5irL   )_assign_nodes_in_scope)r   r   r   s   &  r"   r   <MultiLineBlockNode._assign_nodes_in_scope.<locals>.<genexpr>   s*      !
0#
 --# .0s   "$)r   list	itertoolschainfrom_iterable)r    children_assign_nodess   & r"   r   )MultiLineBlockNode._assign_nodes_in_scope   s5    !
00!

 IOO112GHIIr(   r)   N)r*   r+   r,   r-   r.   r   r   r   r   r   r   r   r   r0   r)   r(   r"   r   r      sQ     ;=7<V VIHF J Jr(   r   c                  :    ] tR t^tRt]R 4       tRR R lltRtR# )MultiLineWithElseBlockNodez>Base node for multi-line blocks that can have else statements.c                	    V P                   # rL   )linenor:   s   &r"   blockstart_tolineno.MultiLineWithElseBlockNode.blockstart_tolineno   s    {{r(   Nc               (    V ^8  d   QhRRRRRRRR/# )	r4   r   intorelsezlist[nodes.NodeNG]lastz
int | Noner5   ztuple[int, int]r)   )r6   s   "r"   r7   'MultiLineWithElseBlockNode.__annotate__   s,     - --#5-=G-	-r(   c                    WP                   8X  d   W3# V'       dG   W^ ,          P                   8  d   WR,          P                  3# W^ ,          P                   ^,
          3# Y;'       g    V P                  3# )zOHandle block line numbers range for try/finally, for, if and while
statements.
)
fromlinenotolineno)r    r   r   r   s   &&&&r"   _elsed_block_range-MultiLineWithElseBlockNode._elsed_block_range   si     __$>!---bz2222!9//!333,,t}},,r(   r)   rL   )	r*   r+   r,   r-   r.   r   r   r   r0   r)   r(   r"   r   r      s!    H - -r(   r   c                  6    ] tR tRtRt]R R l4       tR tRtR# )LookupMixIni  z+Mixin to look up a name in the right scope.c                    V ^8  d   QhRRRR/# )r4   rd   rw   r5   z%tuple[LocalsDictNodeNG, list[NodeNG]]r)   )r6   s   "r"   r7   LookupMixIn.__annotate__  s     5 53 5#H 5r(   c                @    V P                  4       P                  W4      # )a  Lookup where the given variable is assigned.

The lookup starts from self's scope. If self is not a frame itself
and the name is found in the inner frame locals, statements will be
filtered to remove ignorable statements according to self's location.

:param name: The name of the variable to find assignments for.

:returns: The scope node and the list of assignments associated to the
    given name according to the scope where it has been found (locals,
    globals or builtin).
)scopescope_lookup)r    rd   s   &&r"   lookupLookupMixIn.lookup  s     zz|((44r(   c                j    V P                  V4      w  r#\        4       p\        P                  ! W4V4      # )zLookup the inferred values of the given variable.

:param name: The variable name to find values for.
:type name: str

:returns: The inferred values of the statements returned from
    :meth:`lookup`.
:rtype: iterable
)r   r   r   _infer_stmts)r    rd   rc   r!   contexts   &&   r"   ilookupLookupMixIn.ilookup  s/     {{4("$!!%%88r(   r)   N)	r*   r+   r,   r-   r.   r   r   r   r0   r)   r(   r"   r   r     s    55 59r(   r   c                   V ^8  d   QhRR/# r4   r5   rw   r)   )r6   s   "r"   r7   r7   %        S r(   c                "    R V R,          ,           # )__rr4   NNr)   rd   s   &r"   _reflected_namer   %      48r(   c                   V ^8  d   QhRR/# r   r)   )r6   s   "r"   r7   r7   )  r   r(   c                "    R V R,          ,           # )__ir   r)   r   s   &r"   _augmented_namer   )  r   r(   +__add__-__sub__/__truediv__z//__floordiv__ry   __mul__z**__pow__%__mod__&__and__|__or__^__xor__z<<
__lshift__z>>
__rshift__@
__matmul__=c                      ] tR tRt]R R l4       t]R R l4       t]R R l4       t]R R	 l4       t]RR
 R ll4       t	]RR R ll4       t
]R R l4       t]R 4       t]R R l4       t]R R l4       t]R R l4       t]R R l4       tRtR# )OperatorNodeiE  c               (    V ^8  d   QhRRRRRRRR/# )	r4   infer_callablezZCallable[[InferenceContext | None], Generator[InferenceResult | util.BadOperationMessage]]r   zInferenceContext | Noneerrorztype[util.BadOperationMessage]r5   Generator[InferenceResult]r)   )r6   s   "r"   r7   OperatorNode.__annotate__G  s4      

 ) . 
$r(   c              #  	~   "   V ! V4       F,  p\        W24      '       d   \        P                  x  K(  Vx  K.  	  R # 5irL   )
isinstancer   Uninferable)r   r   r   results   &&& r"   _filter_operation_errors%OperatorNode._filter_operation_errorsF  s4      %W-F&(( &&& .s   ;=c                   V ^8  d   QhRR/# r4   r5   rq   r)   )r6   s   "r"   r7   r   Y  s     P Pd Pr(   c                j    \        V \        P                  4      ;'       d    V P                  \        J # )z0Check if the given const node is NotImplemented.)r   r   ConstvalueNotImplemented)consts   &r"   _is_not_implemented OperatorNode._is_not_implementedX  s&     %-OO%++2OOr(   c               (    V ^8  d   QhRRRRRRRR/# )	r4   instanceznodes.Constotherznodes.NodeNGr   r   r5   z)tuple[util.UninferableBase | nodes.Const]r)   )r6   s   "r"   r7   r   ^  s,     "' "'"'&2"'=M"'	2"'r(   c                   \        V\        P                  4      '       d   \        P                  VP
                  9   d   \        P                  3# VP
                   Uu. uF  p\        P                  ! W24      NK  	  pp\        ;QJ d    R V 4       F  '       d   K   RM	  RM! R V 4       4      '       d/   \        ;QJ d    . R V 4       F  NK  	  5M! R V 4       4      pEM2RpEM.\        V\        P                  4      '       d   / pVP                   F  p\        P                  ! V^ ,          V4      p\        V\        P                  4      '       g   \        P                  3u # \        P                  ! V^,          V4      p\        V\        P                  4      '       g   \        P                  3u # VP                  WWP                  &   K  	  M>\        V\        P                  4      '       d   VP                  pM\        P                  3#  \        P                  ! V P                  V,          4      3# u upi   \        \        \         3 d    \        P                  3u # i ; i)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              3  V   "   T F  p\        V\        P                  4      x  K!  	  R # 5irL   )r   r   r   r   is   & r"   r   BOperatorNode._infer_old_style_string_formatting.<locals>.<genexpr>j  s      K7J!:a--7J   ')FTc              3  8   "   T F  qP                   x  K  	  R # 5irL   )r   r  s   & r"   r   r  k  s     D0C1ww0Cs   N)r   r   Tupler   r   elts
safe_inferallr   Dictitemsr   r   const_factory	TypeErrorKeyError
ValueError)	r  r  r   r  inferred_positionalvaluespairkeyr   s	   &&&      r"   "_infer_old_style_string_formatting/OperatorNode._infer_old_style_string_formatting]  s    eU[[))5::-((**HM

"S
14??1#>
"SsK7JKsssK7JKKKD0CDD0CDDuzz**%'Food1gw7!#u{{33 ,,..Q9!%55 ,,..$)KKyy! $ u{{++[[F$$&&	'''(?@BB+ #T, 8Z0 	'$$&&	's   I'I 'I21I2c               4    V ^8  d   QhRRRRRRRRRR	R
RRR/# )r4   r  r   opnodenodes.AugAssign | nodes.BinOpoprw   r  r   r   method_namer5   r   r)   )r6   s   "r"   r7   r     sW     $N $N!$N-$N $N 	$N
 "$N $N 
$$Nr(   c                   \         P                  ! W4      p\        W@4      pV^ ,          pWtP                  n        \        V \        P                  4      '       dG   \        V P                  \        4      '       d'   VR8X  d    \        \        P                  WV4      4      #  \        VP                  VR7      4      p\        T\"        P$                  4      '       d   \         h\        T \        P                  \        P&                  \        P(                  \        P*                  \,        P.                  34      '       g   \         hT P1                  YY4T4      #   \         d   p	\!        YtR7      T	hRp	?	ii ; i)z8Invoke binary operation inference on the given instance.r   )r   )rG   r   N)r   r   r   callcontextcalleer   r   r   r   rw   iterr   r  nextinferStopIterationr   r   UninferableBaser  ListClassDefr   Instanceinfer_binary_op)
r  r  r  r  r   r  methodsmethodinferredes
   &&&&&&    r"   _invoke_binop_inference$OperatorNode._invoke_binop_inference  s$     &&x=&w9%+" x--8>>3//c	??W 	FFLLL9:H h 4 455  [[%++uzz5>>5>>R
 
 ! ''EHMM  	F f>AE	Fs   "E E6$E11E6c               4    V ^8  d   QhRRRRRRRRRR	R
RRR/# )r4   r  r   r  nodes.AugAssignr  rw   r  r   r   reverserq   r5   #partial[Generator[InferenceResult]]r)   )r6   s   "r"   r7   r     sN     
 
!

 
 	

 "
 
 
-
r(   c           
     \    \         V,          p\        \        P                  V VVVVVR7      # )z<Get an inference callable for an augmented binary operation.r  r  r  r  r   r  )AUGMENTED_OP_METHODr   r   r0  r  r  r  r  r   r4  r  s   &&&&&& r"   _aug_opOperatorNode._aug_op  s6     *"-00#
 	
r(   c               4    V ^8  d   QhRRRRRRRRRR	R
RRR/# )r4   r  r   r  r  r  rw   r  r   r   r4  rq   r5   r5  r)   )r6   s   "r"   r7   r     sN     
 
!
-
 
 	

 "
 
 
-
r(   c           
         V'       d   \         V,          pM\        V,          p\        \        P                  V VVVVVR7      # )zGet an inference callable for a normal binary operation.

If *reverse* is True, then the reflected method will be used instead.
r7  )REFLECTED_BIN_OP_METHODBIN_OP_METHODr   r   r0  r9  s   &&&&&& r"   _bin_opOperatorNode._bin_op  sC     1"5K'+K00#
 	
r(   c               $    V ^8  d   QhRRRRRR/# )r4   leftz.bases.UnionType | nodes.ClassDef | nodes.Constrightr5   r   r)   )r6   s   "r"   r7   r     s&     + +<+=+ 
$+r(   c              #  >   "   \         P                  ! W4      x  R# 5i)z>Create a new UnionType instance for binary or, e.g. int | str.N)r   	UnionType)rC  rD  s   &&r"   _bin_op_or_union_type"OperatorNode._bin_op_or_union_type  s      ood**s   c              #  |   "   W!3 F0  pV P                  4       p\        V.R7      Vn        RVn        Vx  K2  	  R# 5i)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.
)argsN)cloner   r!  	boundnode)r   rC  rD  argnew_contexts   &&&  r"   _get_binop_contexts OperatorNode._get_binop_contexts  s;      =C!--/K&1u&=K#$(K!	 !s   :<c                   V ^8  d   QhRR/# r   r)   )r6   s   "r"   r7   r     s     . .D .r(   c                D    V P                  4       VP                  4       8H  # )z$Check if type1 is the same as type2.)qname)type1type2s   &&r"   
_same_typeOperatorNode._same_type  s     {{}--r(   c               8    V ^8  d   QhRRRRRRRRRRR	R
RR
RR/# )r4   rC  r   	left_typeInferenceResult | None
aug_opnoder3  rD  
right_typer   r   reverse_contextr5   )list[partial[Generator[InferenceResult]]]r)   )r6   s   "r"   r7   r     sX     6 66)6 $6 	6
 +6 "6 *6 
36r(   c                   ^ RI Hp VP                  P                  R4      pVP                  p	\        P                  W4      '       d1   \        P                  WWV4      \        P                  WWV4      .p
V
# VP                  W4      '       d1   \        P                  WWV4      \        P                  WWV4      .p
V
# VP                  W4      '       dI   \        P                  WWV4      \        P                  W2WVRR7      \        P                  WWV4      .p
V
# \        P                  WWV4      \        P                  WWV4      \        P                  W2WVRR7      .p
V
# )aZ  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)
helpersr   Tr4  )
astroidra  r  stripr   rV  r:  r@  
is_subtypeis_supertype)rC  rY  r[  rD  r\  r   r]  ra  bin_opaug_opr,  s   &&&&&&&    r"   _get_aug_flowOperatorNode._get_aug_flow  s_   2 	$$$S)""999$$TvgN$$TvgNG2 + 	66$$TvgN$$TvgNG( ! !!)88$$TvgN$$v_d %  $$TvgNG  $$TvgN$$TvgN$$v_d % G r(   c               8    V ^8  d   QhRRRRRRRRRRR	R
RR
RR/# )r4   rC  r   rY  rZ  binary_opnoder  rD  r\  r   r   r]  r5   r^  r)   )r6   s   "r"   r7   r   0  sX     : ::): 5: 	:
 +: ": *: 
3:r(   c           
        ^ RI Hp VP                  p\        P	                  W4      '       d   \        P                  WWV4      .p	MVP                  W4      '       d   \        P                  WWV4      .p	MxVP                  W4      '       d2   \        P                  W2WVRR7      \        P                  WWV4      .p	M0\        P                  WWV4      \        P                  W2WVRR7      .p	VR8X  d   \        V \        P                  \        P                  34      '       g/   \        V \        P                  4      '       d   V P                  f   \        V\        P                  \        P                  34      '       g/   \        V\        P                  4      '       d9   VP                  f+   V	P                  \!        \        P"                  W4      .4       V	# )a   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)
r`  Trb  r   )rc  ra  r  r   rV  r@  re  rf  r   r   rF  r   r)  r   r   extendr   rG  )
rC  rY  rl  rD  r\  r   r]  ra  r  r,  s
   &&&&&&&   r"   _get_binop_flowOperatorNode._get_binop_flow/  sw   0 	$""999#++DGTUG	66#++DGTUG!!)88$$"OT %  $$T"WM	G $$T"WM$$"OT % G #I4%//5>>!BCCtU[[11djj6H 55??ENN"CDDuekk22u{{7J NNGL$F$FTUVr(   c               0    V ^8  d   QhRRRRRRRRRR	R
R/# )r4   rC  r   rD  rl  r  r   r   flow_factoryGetFlowFactoryr5   z;Generator[InferenceResult | util.BadBinaryOperationMessage]r)   )r6   s   "r"   r7   r   m  sM     3V 3V3V3V 53V "	3V
 %3V 
E3Vr(   c           	   #  ,  "   ^ RI Hp \        P                  W0V4      w  r6VP	                  V 4      pVP	                  V4      pV! WW!WV4      p	V	 F  p
 \        V
! 4       4      p\        ;QJ d    R V 4       F  '       g   K   RM	  RM! R V 4       4      '       d   \        P                  x   R# \        \        \        P                  V4      4      '       d   K  \        R V 4       4      pV'       d&   V\        V4      8w  d   \        P                  x   R# T Rj  xL
   R# 	  \        P"                  ! WrP$                  V4      x  R#  L.  \         d     EK  \         d     EK   \          d    \        P                  x    R# i ; i5i)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.
r`  c              3  V   "   T F  p\        V\        P                  4      x  K!  	  R # 5irL   )r   r   r'  r   r   s   & r"   r   7OperatorNode._infer_binary_operation.<locals>.<genexpr>  s      VgFz&$*>*>??gr	  TFNc              3  `   "   T F$  p\         P                  V4      '       g   K   ^x  K&  	  R# 5i)   N)r   r   rv  s   & r"   r   rw    s#      &$+&|/O/OPV/WAAGs   .
.)rc  ra  r   rO  object_typer   anyr   r   r  mapr   sumlenAttributeErrorr   r   BadBinaryOperationMessager  )rC  rD  rl  r   rr  ra  r]  rY  r\  r,  r-  resultsnot_implementeds   &&&&&        r"   _infer_binary_operation$OperatorNode._infer_binary_operationl  sW     	$#/#C#C5$
  ''-	((/
]:
 Fvx. 3VgV333VgVVV***s<;;WEFF"% &$+& # ##g,'F***"""5 : ,,Y8H8H*UU	 #- " * ! &&&sg   AFE$FFBF"E#/FFF"F+F,F0F9FFFFr)   N)F)r*   r+   r,   r-   staticmethodr   r   r  r0  r:  r@  rG  rO  rV  ri  ro  r  r0   r)   r(   r"   r   r   E  s     " P P "' "'H $N $NL 
 
( 
 
4 + +   . . 6 6p : :x 3V 3Vr(   r   )7r.   
__future__r   r   collections.abcr   r   r   	functoolsr   r   r   typingr	   r
   r   rc  r   r   r   astroid.contextr   r   r   astroid.exceptionsr   r   astroid.interpreterr   astroid.nodes.node_ngr   astroid.typingr   astroid.nodes.node_classesr   	AugAssignBinOpr   rs  r   r2   r>   rQ   rZ   r^   r   r   r   r   r   r?  r  r>  r8  r   )r  r   s   00r"   <module>r     s  

 #  9 9 9 9 / / & & 
 . ( *;d"OOekk)d"	
 	WY/01		3N   FV & V ")~ );
$ni ;
|+J +J\-!3 -,9& 9D
 .),," 5B4G4G4I4ILSC	4I  ;H:M:M:O:O,3C#Iu%%:O 
[V6 [Vs   F.F4