
    cn                       d dl mZ d dlZd dlZd dlZd dlmZmZ d dlm	Z
 d dlmZmZmZmZmZmZmZmZmZ d dlmZmZ d dlmZ d dlmZmZmZmZmZ d d	l m!Z! d d
l"m#Z# d dl$m%Z% d dl&m'Z' d dl(m)Z)m*Z*m+Z+ erd dlm,Z, ej-        dk    rd dlm.Z. nd dl/m.Z. ej-        dk    rd dlm0Z0 nd dl1m2Z0  edd          Z3 edd          Z4 edd          Z5eded         eed         df         f         Z6 G d d          Z7dS )    )annotationsN)	GeneratorIterator)singledispatch)	TYPE_CHECKINGAnyClassVarTupleTypeTypeVarUnioncastoverload)
decoratorsutil)InferenceContext)AstroidErrorInferenceErrorParentMissingErrorStatementMissingUseInferenceDefault)AstroidManagerAsStringVisitor)OP_PRECEDENCE)Position)InferenceErrorInfoInferenceResultInferFn)nodes)      )Literal)cached_property)cachedproperty_NodesTNodeNG)bound_NodesT2_NodesT3.c                     e Zd ZU dZdZded<   	 dZded<   	 dZded<   	 dZded<   dZ	d	ed
<   	 dZ
d	ed<   	 dZd	ed<   	 dZded<   	 	 	 dkddddldZ	 dmdnd Zdod"Zdod#Zdod$Zd% Zdpd'Zdqd(Zdpd)Zdrd+Zed,d-dsd0            Zedtd3            Zdd-dud5Zdd-dvd7Zdwd9Zdxd;Zd< Zd= Zd> Zd? Ze dyd@            Z!e dydA            Z"dydBZ#dC Z$dzdFZ%e	 d{d|dL            Z&e	 d{d}dO            Z&e	 d{d~dR            Z&e	 d{ddT            Z&	 dmddVZ&e'j(        dW             Z)dX Z*dY Z+dZ Z,d[ Z-	 dmdd]Z.d^ Z/d_ Z0drd`Z1drdaZ2drdbZ3dodcZ4	 	 	 	 	 	 ddodgZ5dmddhZ6di Z7ddjZ8dS )r'   zlA node of the new Abstract Syntax Tree (AST).

    This is the base class for all Astroid node classes.
    FzClassVar[bool]is_statementoptional_assignis_function	is_lambda zClassVar[tuple[str, ...]]_astroid_fields_other_fields_other_other_fieldsNzInferFn | None_explicit_inference)
end_linenoend_col_offsetlineno
int | None
col_offsetparentNodeNG | Noner5   r6   returnNonec               d    || _         	 || _        	 || _        	 || _        	 || _        	 d| _        dS )a  
        :param lineno: The line that this node appears on in the source code.

        :param col_offset: The column that this node appears on in the
            source code.

        :param parent: The parent node in the syntax tree.

        :param end_lineno: The last line this node appears on in the source code.

        :param end_col_offset: The end column this node appears on in the
            source code. Note: This is after the last symbol.
        N)r7   r9   r:   r5   r6   position)selfr7   r9   r:   r5   r6   s         5lib/python3.11/site-packages/astroid/nodes/node_ng.py__init__zNodeNG.__init__]   sL    , #)D&0F%+1&0D*8	
 *.	 	    contextInferenceContext | Nonekwargsr   &Generator[InferenceResult, None, None]c              +     K   ||j                             | |          }| j        V	 t           | j        | |fi |          }||xj        t          |          z  c_        |E d{V  dS # t          $ r Y nw xY w|s | j        dd|i|E d{V  dS | |j        |j	        |j
        f}||j        v r|j        |         E d{V  dS g }t          j        }t           | j        dd|i|          D ]s\  }}||k    s|j        |j        k    r/|                    t"          j                   t"          j        V   n*|                    |           |V  |xj        dz  c_        tt'          |          |j        |<   dS )aV  Get a generator of the inferred values.

        This is the main entry point to the inference system.

        .. seealso:: :ref:`inference`

        If the instance has some explicit inference function set, it will be
        called instead of the default interface.

        :returns: The inferred values.
        :rtype: iterable
        NrD      r0   )extra_contextgetr4   listnodes_inferredlenr   _infer
lookupnamecallcontext	boundnodeinferredr   max_inferable_values	enumeratemax_inferredappendr   Uninferabletuple)r@   rD   rF   resultskeylimitiresults           rA   inferzNodeNG.infer   s       	?+//g>>G# 
	7t7gPPPPQQ ;**c'll:**""""""""&     	"t{==7=f=========FW')<g>OP'"" 	',,,,,,,,F 3";4;#I#Iw#I&#I#IJJ 	( 	(IAvEz g4w7KK t/000&&&&NN6"""LLL""a'""" !&gs   AA- -
A:9A:strc                     t           fddD                       r"t           dd          pt           dd          S dS )zGet a name for nice representation.

        This is either :attr:`name`, :attr:`attrname`, or the empty string.

        :returns: The nice name.
        :rtype: str
        c              3  *   K   | ]}|j         vV  d S N)r1   ).0namer@   s     rA   	<genexpr>z$NodeNG._repr_name.<locals>.<genexpr>   s+      QQDt4//QQQQQQrC   )re   attrnamere    rg   )allgetattrr@   s   `rA   
_repr_namezNodeNG._repr_name   sT     QQQQ<PQQQQQ 	N4,,Mj"0M0MMrrC   c                   |                                  }t          |           j        }|r%d}t          |          t          |          z   dz   }nd}t          |          dz   }g }| j        | j        z   D ]}t          | |          }dt          |          z
  |z
  }t          j        |d|          	                    d          }	|	d         g}
|	dd          D ]}|

                    d	|z  |z              |
                    | d
d                    |
                      |||dd	|z  z                       |          dz  S )Nz%(cname)s.%(rname)s(%(fields)s)   z%(cname)s(%(fields)s)rI   P   )indentwidthTr    =rh   ,
)cnamernamefields)rl   type__name__rN   r2   r1   rj   pprintpformat
splitlinesrW   join)r@   rv   ru   string	alignmentr^   fieldvaluerq   linesinnerlines               rA   __str__zNodeNG.__str__   sg   !!T

# 	'6FE

SZZ/!3II,FE

QI'$*>> 	7 	7ED%((EUOi/EN5%@@@KKDQQE1XJEabb	 5 5S9_t34444MMU55RWWU^^556666sY.44V<<
 
 
 	
rC   c                    |                                  }|rd}nd}|t          |           j        || j        t	          |           dz  S )Nz.<%(cname)s.%(rname)s l.%(lineno)s at 0x%(id)x>z$<%(cname)s l.%(lineno)s at 0x%(id)x>)ru   rv   r7   id)rl   rx   ry   
fromlinenor   )r@   rv   r~   s      rA   __repr__zNodeNG.__repr__   sY    !! 	<EFF;F$ZZ(oT((	
 
 
 	
rC   c                v    t          |d| j        j                                        z             } ||           S )z(Visit this node using the given visitor.visit_)rj   	__class__ry   lower)r@   visitorfuncs      rA   acceptzNodeNG.accept   s5    w4>+B+H+H+J+J JKKtDzzrC   Iterator[NodeNG]c              #     K   | j         D ]>}t          | |          }|t          |t          t          f          r	|E d{V  :|V  ?dE d{V  dS )z$Get the child nodes below this node.Nr0   r1   rj   
isinstancerL   rY   r@   r   attrs      rA   get_childrenzNodeNG.get_children   s{      ) 	 	E4''D $u.. 



rC   c                    | j         ddd         D ]>}t          | |          }|st          |t          t          f          r
|d         c S |c S dS )z1An optimized version of list(get_children())[-1].Nr   r   s      rA   
last_childzNodeNG.last_child
  sj    )$$B$/ 	 	E4''D $u..  BxKKKtrC   c              #  :   K   | j         }||V  |j         }|dS dS )z7Yield parent, grandparent, etc until there are no more.N)r:   )r@   r:   s     rA   node_ancestorszNodeNG.node_ancestors  sC       	#LLL]F  	# 	# 	# 	# 	#rC   boolc                ^     t           fd|                                D                       S )zCheck if this node is the parent of the given node.

        :param node: The node to check if it is the child.
        :type node: NodeNG

        :returns: Whether this node is the parent of the given node.
        c              3      K   | ]}|u V  	d S rc   r0   )rd   r:   r@   s     rA   rf   z#NodeNG.parent_of.<locals>.<genexpr>$  s'      FFf46>FFFFFFrC   )anyr   r@   nodes   ` rA   	parent_ofzNodeNG.parent_of  s4     FFFF0C0C0E0EFFFFFFrC   .futurer   nodes.Statement | nodes.Modulec                   d S rc   r0   r@   r   s     rA   	statementzNodeNG.statement&      rC   Literal[True]nodes.Statementc                   d S rc   r0   r   s     rA   r   zNodeNG.statement*  r   rC   Literal[None, True]c                   | j         rt          d|           S | j        s>|rt          |           t	          j        dt                     t          |  d          | j                            |          S )aP  The first parent node, including self, marked as statement node.

        TODO: Deprecate the future parameter and only raise StatementMissing and return
        nodes.Statement

        :raises AttributeError: If self has no parent attribute
        :raises StatementMissing: If self has no parent attribute and future is True
        r   targetzIn astroid 3.0.0 NodeNG.statement() will return either a nodes.Statement or raise a StatementMissing exception. AttributeError will no longer be raised. This behaviour can already be triggered by passing 'future=True' to a statement() call.! object has no attribute 'parent'r   )	r,   r   r:   r   warningswarnDeprecationWarningAttributeErrorr   r   s     rA   r   zNodeNG.statement.  s      	1)4000{ 
	M 4&d3333MB #   !D!K!K!KLLL{$$F$333rC   @nodes.FunctionDef | nodes.Module | nodes.ClassDef | nodes.Lambdac                   | j         >|rt          |           t          j        dt                     t          |  d          | j                             |          S )zThe first parent frame node.

        A frame node is a :class:`Module`, :class:`FunctionDef`,
        :class:`ClassDef` or :class:`Lambda`.

        :returns: The first parent frame node.
        Nr   zIn astroid 3.0.0 NodeNG.frame() will return either a Frame node, or raise ParentMissingError. AttributeError will no longer be raised. This behaviour can already be triggered by passing 'future=True' to a frame() call.r   r   )r:   r   r   r   r   r   framer   s     rA   r   zNodeNG.frameH  sx     ; 
	M 6(5555M> #   !D!K!K!KLLL{   ///rC   nodes.LocalsDictNodeNGc                b    | j         st          |           | j                                         S )zThe first parent node defining a new scope.

        These can be Module, FunctionDef, ClassDef, Lambda, or GeneratorExp nodes.

        :returns: The first parent scope node.
        r   )r:   r   scoperk   s    rA   r   zNodeNG.scope`  s3     { 	2$D1111{  """rC   nodes.Modulec                F    | j         r| j                                         S | S )zSReturn the root node of the syntax tree.

        :returns: The root node.
        )r:   rootrk   s    rA   r   zNodeNG.rootk  s'    
 ; 	&;##%%%rC   c                    | j         D ]?}t          | |          }||u r|gc S t          |t          t          f          r||v r|c S @d}t          |t          |          t          |           fz            )a_  Search for the sequence that contains this child.

        :param child: The child node to search sequences for.
        :type child: NodeNG

        :returns: The sequence containing the given child node.
        :rtype: iterable(NodeNG)

        :raises AstroidError: If no sequence could be found that contains
            the given child.
        "Could not find %s in %s's childrenr1   rj   r   rY   rL   r   reprr@   childr   node_or_sequencemsgs        rA   child_sequencezNodeNG.child_sequencet  s     ) 		( 		(E&tU335( *()))) +eT];;(--( ('''23$u++tDzz!::;;;rC   c                    | j         D ]B}t          | |          }||u r||fc S t          |t          t          f          r
||v r||fc S Cd}t          |t          |          t          |           fz            )a  Find the field of this node that contains the given child.

        :param child: The child node to search fields for.
        :type child: NodeNG

        :returns: A tuple of the name of the field that contains the child,
            and the sequence or node that contains the child node.
        :rtype: tuple(str, iterable(NodeNG) or NodeNG)

        :raises AstroidError: If no field could be found that contains
            the given child.
        r   r   r   s        rA   locate_childzNodeNG.locate_child  s     ) 		/ 		/E&tU33(( $e|###+eT];;/--/ .....23$u++tDzz!::;;;rC   c                4    | j                                         S )z|The next sibling statement node.

        :returns: The next sibling statement node.
        :rtype: NodeNG or None
        )r:   next_siblingrk   s    rA   r   zNodeNG.next_sibling  s     {'')))rC   c                4    | j                                         S )zThe previous sibling statement.

        :returns: The previous sibling statement node.
        :rtype: NodeNG or None
        )r:   previous_siblingrk   s    rA   r   zNodeNG.previous_sibling  s     {++---rC   c                F    | j         |                                 S | j         S )z<The first line that this node appears on in the source code.)r7   _fixed_source_linerk   s    rA   r   zNodeNG.fromlineno  s(     ; 	-**,,,{rC   c                z    | j         | j         S | j        sd}n|                                 }|| j        S |j        S )z;The last line that this node appears on in the source code.N)r5   r1   r   r   tolineno)r@   r   s     rA   r   zNodeNG.tolineno  sP     ? 	#?"# 	+JJ**J 	#?"""rC   c                    | j         }| }	 |*t          |                                          }|j         }|*n-# t          $ r  | j        }|r||j         }|j        }|r|Y nw xY w|S )zAttempt to find the line that this node appears on.

        We need this method since not all nodes have :attr:`lineno` set.
        )r7   nextr   StopIterationr:   )r@   r   _noder:   s       rA   r   zNodeNG._fixed_source_line  s    
 {	' $U//1122|  $  	' 	' 	'[F 'T '}  'T '	'
 s   ,8 'A"!A"c                    || j         fS )a@  Get a range from the given line number to where this node ends.

        :param lineno: The line number to start the range at.
        :type lineno: int

        :returns: The range of line numbers that this node belongs to,
            starting at the given line number.
        :rtype: tuple(int, int or None)
        )r   )r@   r7   s     rA   block_rangezNodeNG.block_range  s     t}$$rC   re   stmtc                N    | j         sJ | j                             ||           dS )a$  Define that the given name is declared in the given statement node.

        This definition is stored on the parent scope node.

        .. seealso:: :meth:`scope`

        :param name: The name that is being defined.

        :param stmt: The statement that defines the given name.
        N)r:   	set_local)r@   re   r   s      rA   r   zNodeNG.set_local  s0     {dD)))))rC   klasstype[_NodesT]
skip_klass
SkipKlassTIterator[_NodesT]c                    d S rc   r0   r@   r   r   s      rA   nodes_of_classzNodeNG.nodes_of_class  	     	rC   $tuple[type[_NodesT], type[_NodesT2]]&Iterator[_NodesT] | Iterator[_NodesT2]c                    d S rc   r0   r   s      rA   r   zNodeNG.nodes_of_class  r   rC   4tuple[type[_NodesT], type[_NodesT2], type[_NodesT3]];Iterator[_NodesT] | Iterator[_NodesT2] | Iterator[_NodesT3]c                    d S rc   r0   r   s      rA   r   zNodeNG.nodes_of_class  r   rC   tuple[type[_NodesT], ...]c                    d S rc   r0   r   s      rA   r   zNodeNG.nodes_of_class  r   rC   type[_NodesT] | tuple[type[_NodesT], type[_NodesT2]] | tuple[type[_NodesT], type[_NodesT2], type[_NodesT3]] | tuple[type[_NodesT], ...]c              #  (  K   t          | |          r| V  |5|                                 D ]}|                    ||          E d{V  dS |                                 D ]/}t          ||          r|                    ||          E d{V  0dS )a+  Get the nodes (including this one or below) of the given types.

        :param klass: The types of node to search for.

        :param skip_klass: The types of node to ignore. This is useful to ignore
            subclasses of :attr:`klass`.

        :returns: The node of the given types.
        N)r   r   r   )r@   r   r   
child_nodes       rA   r   zNodeNG.nodes_of_class  s      & dE"" 	JJJ 	"//11 H H
%44UJGGGGGGGGGGF++-- 	D 	DJ*j11 !00
CCCCCCCCCC	D 	DrC   c                    g S rc   r0   rk   s    rA   _get_assign_nodeszNodeNG._get_assign_nodes@  s    	rC   c              #  l   K   |                                  D ]}|                                E d {V  d S rc   )r   _get_name_nodes)r@   r   s     rA   r   zNodeNG._get_name_nodesD  sR      ++-- 	4 	4J!113333333333	4 	4rC   c              #     K   dE d {V  d S Nr0   r0   rk   s    rA    _get_return_nodes_skip_functionsz'NodeNG._get_return_nodes_skip_functionsH        rC   c              #     K   dE d {V  d S r   r0   rk   s    rA   _get_yield_nodes_skip_lambdasz$NodeNG._get_yield_nodes_skip_lambdasK  r   rC   c                    d S rc   r0   )r@   r   re   s      rA   _infer_namezNodeNG._infer_nameN  s    rC   ;Generator[InferenceResult, None, InferenceErrorInfo | None]c                &    t          d| |          )z4We don't know how to resolve a statement by default.z#No inference function for {node!r}.)r   rD   )r   )r@   rD   rF   s      rA   rO   zNodeNG._inferR  s"    
 1g
 
 
 	
rC   c                D    t          |                                           S )zGet a list of the inferred values.

        .. seealso:: :ref:`inference`

        :returns: The inferred values.
        :rtype: list
        )rL   r_   rk   s    rA   rS   zNodeNG.inferred[  s     DJJLL!!!rC   c                    | S )zInstantiate an instance of the defined class.

        .. note::

            On anything other than a :class:`ClassDef` this will return self.

        :returns: An instance of the defined class.
        :rtype: object
        r0   rk   s    rA   instantiate_classzNodeNG.instantiate_classe  s	     rC   c                    dS )zCheck if this node inherits from the given type.

        :param node: The node defining the base to look for.
            Usually this is a :class:`Name` node.
        :type node: NodeNG
        Fr0   r   s     rA   has_basezNodeNG.has_baseq  s	     urC   c                    dS )zWhether this node defines something that is callable.

        :returns: Whether this defines something that is callable.
        Fr0   rk   s    rA   callablezNodeNG.callablez  s	    
 urC   c                    dS )NFr0   )r@   r   s     rA   eqz	NodeNG.eq  s    urC   c                0     t                      |           S )z.Get the source code that this node represents.r   rk   s    rA   	as_stringzNodeNG.as_string  s       &&&rC      r   ro   c                z  
 t           dfd	            

                    t                    
                    t                    d
fd	                        }
                    t                    d
fd	            }g }	 
| |	t                                 d                    |	          S )a  Get a string representation of the AST from this node.

        :param ids: If true, includes the ids with the node type names.
        :type ids: bool

        :param include_linenos: If true, includes the line numbers and
            column offsets.
        :type include_linenos: bool

        :param ast_state: If true, includes information derived from
            the whole AST like local and global variables.
        :type ast_state: bool

        :param indent: A string to use to indent the output string.
        :type indent: str

        :param max_depth: If set to a positive integer, won't return
            nodes deeper than max_depth in the string.
        :type max_depth: int

        :param max_width: Attempt to format the output string to stay
            within this number of characters, but can exceed it under some
            circumstances. Only positive integer values are valid, the default is 80.
        :type max_width: int

        :returns: The string representation of the AST.
        :rtype: str
        rh   rI   c           	     B   t          j        | t          t                    z
  d                                        d          }|                    |d                    |                    fd|dd         D                        t          |          dk    S )zOutputs a representation of a non-tuple/list, non-node that's
            contained within an AST, including strings.
            rI   )rq   Tr   c                    g | ]}|z   S r0   r0   )rd   r   
cur_indents     rA   
<listcomp>z8NodeNG.repr_tree.<locals>._repr_tree.<locals>.<listcomp>  s    CCC:,CCCrC   N)rz   r{   maxrN   r|   rW   extend)r   r^   doner  depthr   	max_widths      `  rA   
_repr_treez$NodeNG.repr_tree.<locals>._repr_tree  s    
 NC	C
OO ;Q??  j  MM%(###MMCCCCqrrCCCDDDu::?"rC   c                   |z  }|                     d           | sd}n3t          |           dk    r | d         ||||          }n	t          |           dk    ro | d         ||||          }|s|                     d           n*|                     d           |                     |            | d         ||||          p|}n|                     d           |                     |           | d	d
         D ];} |||||           |                     d           |                     |           < | d
         ||||           d}|                     d           |S )z_Outputs a representation of a sequence that's contained within an
            AST.
            [FrI   r   rn   z, rt   
Nr   T])rW   rN   )	r   r^   r  r  r  brokenr   r  rp   s	          rA   	_repr_seqz#NodeNG.repr_tree.<locals>._repr_seq  s    & JMM# Ta #DGVT:uMMTa #DGVT:uMM .MM$''''MM%(((MM*---#DGVT:uMMWQWd###j)))!#2#Y . .EJufdJFFFMM%(((MM*----
48VT:uEEEMM#MrC   c           	     L   | |v r?|                     dt          |           j         dt          |            z              dS |                    |            r|k    r|                     d           dS |dz  }|z  }
r<|                     t          |           j         dt          |           dd           n*|                     t          |           j         d	           g }r|                    d
           |                    | j                   |                    | j                   	r|                    | j                   |sd}n5t          |          dk    rB|                     |d          d            t          | |d                   ||||          }n|                     d           |                     |           |dd         D ]h}|dk    r	|                     | d            t          | |          ||||           |                     d           |                     |           i|                     |d          d            t          | |d                   ||||           d}|                     d           |S )z4Outputs a strings representation of an astroid node.z<Recursion on z	 with id=Fz...rI   z<0xxz>(
()r7   r9   r   rs   r  Nr   docrt   T))rW   rx   ry   r   addr  r2   r1   r3   rN   rj   )r   r^   r  r  r  rw   r  r   r  	ast_stateidsinclude_linenosrp   	max_depths           rA   
_repr_nodez$NodeNG.repr_tree.<locals>._repr_node  s    t| Vd4jj.AVVBtHHVVV   uHHTNNN UY. e$$$uQJE& J 9d!4IIDIIIIJJJJd!4777888F 86777MM$,---MM$./// 8d6777 V! ooo...#D&),,fdJ  d###j)))#CRC[ . .E~ ! MMU+++...JwtU33VT:uUUUMM%(((MM*----...///
7444fdJPUVVVMM#MrC   )rh   rI   )_singledispatchregisterrY   rL   r'   setr}   )r@   r"  r#  r!  rp   r$  r  r  r%  r^   r  s    ``````   @rA   	repr_treezNodeNG.repr_tree  s   L 
		# 		# 		# 		# 		# 
		# 
		U	#	#			T	"	"	 	 	 	 	 	 
#	" 
$	#	> 
		V	$	$/	 /	 /	 /	 /	 /	 /	 /	 /	 /	 
%	$/	b 
4'''wwvrC   c                    t           j        S )ak  Determine the boolean value of this node.

        The boolean value of a node can have three
        possible values:

            * False: For instance, empty data structures,
              False, empty strings, instances which return
              explicitly False from the __nonzero__ / __bool__
              method.
            * True: Most of constructs are True by default:
              classes, functions, modules etc
            * Uninferable: The inference engine is uncertain of the
              node's value.

        :returns: The boolean value of this node.
        :rtype: bool or Uninferable
        )r   rX   )r@   rD   s     rA   
bool_valuezNodeNG.bool_value  s    $ rC   c                d    t          j        | j        j        t	          t                               S rc   )r   rK   r   ry   rN   rk   s    rA   op_precedencezNodeNG.op_precedence&  s"     !8#m:L:LMMMrC   c                    dS )NTr0   rk   s    rA   op_left_associativezNodeNG.op_left_associative*  s    trC   )NNN)r7   r8   r9   r8   r:   r;   r5   r8   r6   r8   r<   r=   rc   )rD   rE   rF   r   r<   rG   )r<   r`   )r<   r   )r<   r;   )r<   r   )r   r=   r<   r   )r   r   r<   r   )r   r   r<   r   )r   r   r<   r   )r<   r   )r<   r   )r<   r8   )re   r`   r   r'   r<   r=   ).)r   r   r   r   r<   r   )r   r   r   r   r<   r   )r   r   r   r   r<   r   )r   r   r   r   r<   r   )r   r   r   r   r<   r   )rD   rE   rF   r   r<   r   )FFFr	  r   ro   )rD   rE   )r<   r   )9ry   
__module____qualname____doc__r,   __annotations__r-   r.   r/   r1   r2   r3   r4   rB   r_   rl   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r$   r   r   r   r   r   r   r   cachedr   r   r   r   r   rO   rS   r   r  r  r  r  r)  r+  r-  r/  r0   rC   rA   r'   r'   ;   s]         
 $)L((((2 	      #(K''''1 %I%%%% 24O3333 02M1111:5777777*..... "!% $	- "&%)- - - - - -` 268 8 8 8 8t
 
 
 

 
 
 
4
 
 
 
  

 
 
 
	 	 	 	# # # #G G G G *-      X    X 044 4 4 4 4 46 040 0 0 0 0 00	# 	# 	# 	#   < < <4< < <:* * *. . .    _ # # # _#   $
% 
% 
%* * * *  "%    X  "%    X  "%    X  "%    X "&D D D D DB   4 4 4      
 26
 
 
 
 
" " "
 
 
         ' ' ' ' H H H H HT         (N N N     rC   )8
__future__r   rz   sysr   collections.abcr   r   	functoolsr   r&  typingr   r   r	   r
   r   r   r   r   r   astroidr   r   astroid.contextr   astroid.exceptionsr   r   r   r   r   astroid.managerr   astroid.nodes.as_stringr   astroid.nodes.constr   astroid.nodes.utilsr   astroid.typingr   r   r   r    version_infor#   typing_extensionsr$   astroid.decoratorsr%   r&   r)   r*   r   r'   r0   rC   rA   <module>rE     s  
 # " " " " "  



  / / / / / / / / 7 7 7 7 7 7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 % $ $ $ $ $ $ $ , , , , , ,              + * * * * * 3 3 3 3 3 3 - - - - - - ( ( ( ( ( ( G G G G G G G G G G v *))))))v E)))))))DDDDDD ')8
,
,
,7:X...7:X...4htH~s/B)CCD
q q q q q q q q q qrC   