Your IP : 216.73.216.213

Current Path : /opt/alt/python37/lib/python3.7/site-packages/astroid/__pycache__/
Current File : //opt/alt/python37/lib/python3.7/site-packages/astroid/__pycache__/node_classes.cpython-37.pyc
B

��\��@s�dZddlZddlZddlZddlZddlmZddlmZ	ddl
mZddl
mZddl
m
Zddl
mZdd	l
mZdd
l
mZddl
mZddl
mZejZe��Zejd�d
d��Zd�dd�Ze�Zd�dd�Zd�dd�Zd�dd�Zdd�e dgdgdgdgdgdgdgd gd!gd"d#gd$d%gd&d'd(d)d*gd+gd,gd-gg�D�Z!Gd.d/�d/�Z"Gd0d1�d1e"�Z#Gd2d3�d3ej$e"ej%ej&d4�Z'Gd5d6�d6�Z(Gd7d8�d8ej)e(ej$e"�Z*Gd9d:�d:ej)e(ej$e"�Z+Gd;d<�d<ej)e(e"�Z,Gd=d>�d>ej-e"�Z.d�d@dA�Z/d�dBdC�Z0GdDdE�dEej$e"�Z1GdFdG�dGe#�Z2GdHdI�dIej-e#�Z3GdJdK�dKej-e#�Z4GdLdM�dMej-e#�Z5GdNdO�dOe"�Z6GdPdQ�dQe"�Z7GdRdS�dSe"�Z8GdTdU�dUej)e#�Z9GdVdW�dWe"�Z:GdXd�de"�Z;GdYdZ�dZe"�Z<Gd[d\�d\ej)e"ej%�Z=Gd]d^�d^ej)e#�Z>Gd_d`�d`e"�Z?Gdadb�dbej$e"�Z@Gdcdd�ddej-e#�ZAGdedf�dfe"ej%�ZBGdgdh�dhe#�ZCGdidj�djej)e"�ZDGdkdl�dlej)e"�ZEGdmdn�dnejFej-e#�ZGGdodp�dpe#�ZHGdqdr�dre"�ZIGdsdt�dtejFejJej-e#�ZKGdudv�dveK�ZLGdwd-�d-e"�ZMGdxdy�dyej)ejNe#�ZOGdzd{�d{e"�ZPGd|d}�d}ej)e#�ZQGd~d�dejFejJe#�ZRGd�d�de"�ZSGd�d��d�ej)ejNe#�ZTGd�d��d�e"�ZUGd�d��d�e"�ZVGd�d��d�e'�ZWGd�d��d�ej)e#�ZXGd�d��d�ej)e#�ZYGd�d��d�e#�ZZGd�d��d�e#�Z[Gd�d��d�e#�Z\Gd�d��d�e'�Z]Gd�d��d�e"�Z^Gd�d��d�ej$e"�Z_Gd�d��d�e"�Z`Gd�d��d�ejFejJe#�ZaGd�d��d�ejFejJe#�ZbGd�d��d�e'�ZcGd�d+�d+e"�ZdGd�d��d�ejFejJe#�ZeGd�d��d�ejFejJej-e#�ZfGd�d��d�ef�ZgGd�d��d�e"�ZhGd�d��d�eh�ZiGd�d��d�ej)e"�ZjGd�d��d�e"�ZkGd�d��d�e"�ZlGd�d��d�ej-e"�ZmeneWeoecepeBeqe]erd�e=eres�e=iZtd�d��Zueu�d�d��Zvd�d��ZweWeveceveBewe]eve=d�d��iZxd�d��Zyd�d��ZzdS)�z<Module for some node classes. More nodes in scoped_nodes.py
�N)�	lru_cache)�singledispatch)�	as_string)�bases)�context)�
decorators)�
exceptions)�manager)�mixins)�utilccs�t|ttf�rLx0|jD]&}|tjkr,|Vqt||�EdHqWt||d�St|�	|��}||krt|Vt||d�Sx4|�	|�D]&}|tjkr�|Vq�t||�EdHq�Wt||d�S)z�recursively generate nodes inferred by the given statement.
    If the inferred value is a list or a tuple, recurse on the elements
    N)�noder)
�
isinstance�List�Tuple�eltsr�Uninferable�unpack_infer�dict�next�infer)�stmtr�elt�inferred�r�E/opt/alt/python37/lib/python3.7/site-packages/astroid/node_classes.pyr3s 

rcCsli}i}|j}|}x"|r4d||<|||<|}|j}qW|j}|}�x$|�rf||k�rZt|t�r�|dkr�|�|�d|�||�dk	r�dSn�t|t��rV|�|�\}}|�||�\}	}
|
|k	�r6|dko�|	dko�|�|�}|dko�|	dko�||�|�}|dk�o
|	dk}
|dk�o|	dk}t|||
|f��rVdSn |dk�rV|	dk�rV|||k	SdS|}|j}qDWdS)a�return true if the two given statements are mutually exclusive

    `exceptions` may be a list of exception names. If specified, discard If
    branches and check one of the statement is in an exception handler catching
    one of the given exceptions.

    algorithm :
     1) index stmt1's parents
     2) climb among stmt2's parents until we find a common parent
     3) if the common parent is a If or TryExcept statement, look if nodes are
        in exclusive branches
    �NT�handlers�body�orelseF)�parentr
�If�locate_child�	TryExcept�catch�any)Zstmt1Zstmt2rZ
stmt1_parents�childrenrZpreviousZc2attrZc2nodeZc1attrZc1nodeZ first_in_body_caught_by_handlersZ!second_in_body_caught_by_handlersZfirst_in_else_other_in_handlersZ second_in_else_other_in_handlersrrr�
are_exclusiveNsR






r&cCs�t|t�r&t|jttd�f�r�|jSn\|dkr2dSyt|j|d��}Wntjk
r\Yn&Xt|t�r�t|jttd�f�r�|jSt	S)z'Get the value of the given slice index.N)r)
r
�Const�value�int�typerrr�InferenceError�_SLICE_SENTINEL)�indexrrrrr�_slice_value�s

r.cCs`t|j|�}t|j|�}t|j|�}tdd�|||fD��rHt|||�Stjd||j|d��dS)Ncss|]}|tk	VqdS)N)r,)�.0�elemrrr�	<genexpr>�sz_infer_slice.<locals>.<genexpr>z'Could not infer slice used in subscript)�messagerr-r)	r.�lower�upper�step�all�slicer�AstroidTypeErrorr)rrr3r4r5rrr�_infer_slice�sr9c
Cs�yLt|t�r6t||d�}|��}|||_|j|_|St|t�rJ||jSWnjtk
r�}zt	j
d|||d�|�Wdd}~XYn6tk
r�}zt	jd|||d�|�Wdd}~XYnXt	�d|��dS)zHGet a slice or an item, using the given *index*, for the given sequence.)rzIndex {index!s} out of range)r2rr-rNzType error {error!r}z#Could not use %s as subscript index)
r
�Slicer9�	__class__rrr'r(�
IndexErrorr�AstroidIndexError�	TypeErrorr8)�instancerr-rZindex_sliceZnew_cls�excrrr�_container_getitem�s*


rAcCs i|]\}}|D]
}||�qqSrr)r/�
precedence�ops�oprrr�
<dictcomp>�srEZLambda�IfExp�or�and�not�Compare�|�^�&z<<z>>�+�-�*�@�/z//�%�UnaryOpz**�Awaitc@s�eZdZdZdZdZdZdZdZdZ	dZ
dZdZdZ
dZdXdd�ZdYdd�Zd	d
�Zdd�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Z e!j"d)d*��Z#e!j"d+d,��Z$d-d.�Z%d/d0�Z&d1d2�Z'dZd3d4�Z(e!j)d5d6��Z*d7d8�Z+d9d:�Z,d;d<�Z-d=d>�Z.d[d?d@�Z/dAdB�Z0dCdD�Z1dEdF�Z2dGdH�Z3dIdJ�Z4dKdL�Z5d\dPdQ�Z6dRdS�Z7dTdU�Z8dVdW�Z9dS)]�NodeNGzm A node of the new Abstract Syntax Tree (AST).

    This is the base class for all Astroid node classes.
    FNrcCs||_||_||_dS)aa
        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)�lineno�
col_offsetr)�selfrWrXrrrr�__init__9szNodeNG.__init__cKs�|dk	r|j�||�}|jdk	rHy|j||f|�Stjk
rFYnX|sZ|j|f|�S||j|j|jf}||j	kr�t
|j	|�S|�||j|f|��}t�
|tj�S)aVGet 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
        N)Z
extra_context�get�_explicit_inferencerZUseInferenceDefault�_inferZ
lookupnameZcallcontextZ	boundnoder�iterZcache_generatorrZlimit_inference�MANAGERZmax_inferable_values)rYr�kwargs�key�genrrrrIs


zNodeNG.infercs6ddh}t�fdd�|D��r2t�dt�dd��SdS)z�Get a name for nice representation.

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

        :returns: The nice name.
        :rtype: str
        �name�attrnamec3s|]}|�jkVqdS)N)�_astroid_fields)r/rc)rYrrr1ssz$NodeNG._repr_name.<locals>.<genexpr>�)r6�getattr)rY�namesr)rYr�
_repr_namejszNodeNG._repr_namecCs�|��}t|�j}|r0d}t|�t|�d}nd}t|�d}g}x�|j|jD]~}t||�}dt|�|}tj|d|d��	d�}	|	dg}
x&|	dd�D]}|
�
d	||�q�W|�
d
|d�|
�f�qRW|||dd	|�|�d
�S)Nz%(cname)s.%(rname)s(%(fields)s)�z%(cname)s(%(fields)s)r�P)�indent�widthTr� z%s=%srfz,
)�cname�rname�fields)rir*�__name__�len�
_other_fieldsrerg�pprint�pformat�
splitlines�append�join)rYrpro�string�	alignment�result�fieldr(rm�lines�inner�linerrr�__str__ws(


zNodeNG.__str__cCs4|��}|rd}nd}|t|�j||jt|�d�S)Nz.<%(cname)s.%(rname)s l.%(lineno)s at 0x%(id)x>z$<%(cname)s l.%(lineno)s at 0x%(id)x>)rorprW�id)rir*rr�
fromlinenor�)rYrprzrrr�__repr__�szNodeNG.__repr__cCst|d|jj���}||�S)z(Visit this node using the given visitor.Zvisit_)rgr;rrr3)rYZvisitor�funcrrr�accept�sz
NodeNG.acceptccsHxB|jD]8}t||�}|dkr qt|ttf�r:|EdHq|VqWdS)zoGet the child nodes below this node.

        :returns: The children.
        :rtype: iterable(NodeNG)
        N)rergr
�list�tuple)rYr}�attrrrr�get_children�s
zNodeNG.get_childrencCsFx@|jddd�D],}t||�}|s&qt|ttf�r<|dS|SWdS)z�An optimized version of list(get_children())[-1]

        :returns: The last child, or None if no children exist.
        :rtype: NodeNG or None
        N���)rergr
r�r�)rYr}r�rrr�
last_child�s
zNodeNG.last_childcCs*|j}x|dk	r$||krdS|j}qWdS)aCheck 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: True if this node is the parent of the given node,
            False otherwise.
        :rtype: bool
        NTF)r)rYrrrrr�	parent_of�s


zNodeNG.parent_ofcCs|jr
|S|j��S)z�The first parent node, including self, marked as statement node.

        :returns: The first parent statement.
        :rtype: NodeNG
        )�is_statementr�	statement)rYrrrr��szNodeNG.statementcCs
|j��S)z�The first parent frame node.

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

        :returns: The first parent frame node.
        :rtype: Module or FunctionDef or ClassDef
        )r�frame)rYrrrr��s	zNodeNG.framecCs
|j��S)z�The first parent node defining a new scope.

        :returns: The first parent scope node.
        :rtype: Module or FunctionDef or ClassDef or Lambda or GenExpr
        )r�scope)rYrrrr��szNodeNG.scopecCs|jr|j��S|S)zjReturn the root node of the syntax tree.

        :returns: The root node.
        :rtype: Module
        )r�root)rYrrrr��s
zNodeNG.rootcCsdx@|jD]6}t||�}||kr$|gSt|ttf�r||kr|SqWd}t�|t|�t|�f��dS)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.
        z"Could not find %s in %s's childrenN)rergr
r�r�r�AstroidError�repr)rY�childr}�node_or_sequence�msgrrr�child_sequence�s
zNodeNG.child_sequencecCsjxF|jD]<}t||�}||kr&||fSt|ttf�r||kr||fSqWd}t�|t|�t|�f��dS)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.
        z"Could not find %s in %s's childrenN)rergr
r�r�rr�r�)rYr�r}r�r�rrrr!s

zNodeNG.locate_childcCs
|j��S)z|The next sibling statement node.

        :returns: The next sibling statement node.
        :rtype: NodeNG or None
        )r�next_sibling)rYrrrr�1szNodeNG.next_siblingcCs
|j��S)zThe previous sibling statement.

        :returns: The previous sibling statement node.
        :rtype: NodeNG or None
        )r�previous_sibling)rYrrrr�9szNodeNG.previous_siblingcCsj|��}|j}d}xN|D]F}|��|ks8td||f��|j}|j|krJP||dkr||f}qW|dS)a�Get the node closest to this one from the given list of nodes.

        :param nodes: The list of nodes to search. All of these nodes must
            belong to the same module as this one. The list should be
            sorted by the line number of the nodes, smallest first.
        :type nodes: iterable(NodeNG)

        :returns: The node closest to this one in the source code,
            or None if one could not be found.
        :rtype: NodeNG or None
        )Nrz,nodes %s and %s are not from the same modulerr)r�r��AssertionError)rY�nodesZmyroot�mylineno�nearestrrWrrrr�As

zNodeNG.nearestcCs|jdkr|��S|jS)zaThe first line that this node appears on in the source code.

        :type: int or None
        N)rW�_fixed_source_line)rYrrrr�_s
zNodeNG.fromlinenocCs(|jsd}n|��}|dkr"|jS|jS)z`The last line that this node appears on in the source code.

        :type: int or None
        N)rer�r��tolineno)rYZ	lastchildrrrr�jszNodeNG.tolinenocCsl|j}|}y$x|dkr*t|���}|j}qWWn8tk
rf|j}x|r`|dkr`|j}|j}qFWYnX|S)aAttempt to find the line that this node appears on.

        We need this method since not all nodes have :attr:`lineno` set.

        :returns: The line number of this node,
            or None if this could not be determined.
        :rtype: int or None
        N)rWrr��
StopIterationr)rYr��_noderrrr�zs	
zNodeNG._fixed_source_linecCs
||jfS)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�)rYrWrrr�block_range�s
zNodeNG.block_rangecCs|j�||�dS)aWDefine 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.
        :type name: str

        :param stmt: The statement that defines the given name.
        :type stmt: NodeNG
        N)r�	set_local)rYrcrrrrr��s
zNodeNG.set_localccstt||�r|V|dkr@x"|��D]}|�||�EdHq"WdSx.|��D]"}t||�rZqJ|�||�EdHqJWdS)a�Get the nodes (including this one or below) of the given type.

        :param klass: The type of node to search for.
        :type klass: builtins.type

        :param skip_klass: A type of node to ignore. This is useful to ignore
            subclasses of :attr:`klass`.
        :type skip_klass: builtins.type

        :returns: The node of the given type.
        :rtype: iterable(NodeNG)
        N)r
r��nodes_of_class)rY�klassZ
skip_klass�
child_noderrrr��s

zNodeNG.nodes_of_classcCsgS)Nr)rYrrr�_get_assign_nodes�szNodeNG._get_assign_nodesccs$x|��D]}|��EdHq
WdS)N)r��_get_name_nodes)rYr�rrrr��szNodeNG._get_name_nodesccsdEdHdS)Nrr)rYrrr� _get_return_nodes_skip_functions�sz'NodeNG._get_return_nodes_skip_functionsccsdEdHdS)Nrr)rYrrr�_get_yield_nodes_skip_lambdas�sz$NodeNG._get_yield_nodes_skip_lambdascCsdS)Nr)rYr�rcrrr�_infer_name�szNodeNG._infer_namecCstjd||d��dS)z3we don't know how to resolve a statement by defaultz#No inference function for {node!r}.)rrN)rr+)rYrrrrr]�sz
NodeNG._infercCst|���S)z�Get a list of the inferred values.

        .. seealso:: :ref:`inference`

        :returns: The inferred values.
        :rtype: list
        )r�r)rYrrrr�szNodeNG.inferredcCs|S)z�Instantiate 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
        r)rYrrr�instantiate_class�s
zNodeNG.instantiate_classcCsdS)z�Check 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
        Fr)rYrrrr�has_base�szNodeNG.has_basecCsdS)z�Whether this node defines something that is callable.

        :returns: True if this defines something that is callable,
            False otherwise.
        :rtype: bool
        Fr)rYrrr�callable�szNodeNG.callablecCsdS)NFr)rYr(rrr�eqsz	NodeNG.eqcCs
t�|�S)zoGet the source code that this node represents.

        :returns: The source code.
        :rtype: str
        )rZto_code)rYrrrr
szNodeNG.as_string�   rrkc
sttd	�fdd�	����t���t�d
��fdd�	��}��t�d������fdd�	�}g}	�||	t��d�|	�S)aGet 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
        rfrcs\tj|t�t��d�d��d�}|�|d�|��fdd�|dd�D��t|�dkS)z�Outputs a representation of a non-tuple/list, non-node that's
            contained within an AST, including strings.
            r)rmTrcsg|]}�|�qSrr)r/r�)�
cur_indentrr�
<listcomp>Asz8NodeNG.repr_tree.<locals>._repr_tree.<locals>.<listcomp>N)rurv�maxrsrwrx�extend)rr|�doner��depthr~)�	max_width)r�r�
_repr_tree8s z$NodeNG.repr_tree.<locals>._repr_treecs|�7}|�d�|sd}n�t|�dkr>�|d||||�}n�t|�dkr��|d||||�}|sn|�d�n|�d�|�|��|d||||�p�|}nf|�d�|�|�x8|d	d
�D](}�|||||�|�d�|�|�q�W�|d
||||�d}|�d�|S)
zFOutputs a representation of a sequence that's contained within an AST.�[Frrrjz, z,
�
Nr�T�])rxrs)rr|r�r�r��brokenr�)r�rlrr�	_repr_seqEs.






z#NodeNG.repr_tree.<locals>._repr_seqcs�||kr,|��dt|�jt|�f�dS|�|��rP|�krP|�d�dS|d7}|�7}�r�|�dt|�jt|�f�n|�dt|�j�g}�r�|�d�|�|j�|�|j��r�|�|j�|s�d}n�t	|�dk�r|�d|d	��t
||d	�||||�}n�|�d
�|�|�xN|dd�D]>}|�d|��t
||�||||�|�d
�|�|��q8W|�d|d��t
||d�||||�d}|�d�|S)z4Outputs a strings representation of an astroid node.z<Recursion on %s with id=%sFz...rz
%s<0x%x>(
z%s()rWrXz%s=rr�Nr�z,
T�))rxr*rrr��addr�rtre�_other_other_fieldsrsrg)rr|r�r�r�rqr�r})r��	ast_state�ids�include_linenosrl�	max_depthrr�
_repr_nodedsN






z$NodeNG.repr_tree.<locals>._repr_node)rfr)rfr)rfr)�_singledispatch�registerr�r�rV�setry)
rYr�r�r�rlr�r�r�r�r|r)r�r�r�r�rlr�r�r�	repr_trees&/zNodeNG.repr_treecCstjS)akDetermine 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
        )rr)rYrrr�
bool_value�szNodeNG.bool_valuecCst�|jjtt��S)N)�
OP_PRECEDENCEr[r;rrrs)rYrrr�
op_precedence�szNodeNG.op_precedencecCsdS)NTr)rYrrr�op_left_associative�szNodeNG.op_left_associative)NNN)N)N)N)FFFr�rrk):rr�
__module__�__qualname__�__doc__r��optional_assign�is_function�	is_lambdarWrXrrertr�r\rZrrir�r�r�r�r�r�r�r�r�r�r�r!r�r�r�r�cachedpropertyr�r�r�r�r�r��cachedr�r�r�r�r�r]rr�r�r�r�rr�r�r�r�rrrrrV�sr	

!






		

rVc@s$eZdZdZdZdd�Zdd�ZdS)�	Statementz&Statement node adding a few attributesTcCs<|j�|�}|�|�}y||dStk
r6YnXdS)z|The next sibling statement node.

        :returns: The next sibling statement node.
        :rtype: NodeNG or None
        rN)rr�r-r<)rY�stmtsr-rrrr��s
zStatement.next_siblingcCs.|j�|�}|�|�}|dkr*||dSdS)zThe previous sibling statement.

        :returns: The previous sibling statement node.
        :rtype: NodeNG or None
        rN)rr�r-)rYr�r-rrrr��s

zStatement.previous_siblingN)rrr�r�r�r�r�r�rrrrr��s
r�csbeZdZdZdZd�fdd�	Zdd�Zeddd	��Zd
d�Z	dd
�Z
ejdd��Z
dd�Z�ZS)�_BaseContainerz.Base class for Set, FrozenSet, Tuple and List.)rNcsg|_tt|��|||�dS)aa
        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)r�superr�rZ)rYrWrXr)r;rrrZ�sz_BaseContainer.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param elts: The list of elements the that node contains.
        :type elts: list(NodeNG)
        N)r)rYrrrr�postinit�sz_BaseContainer.postinitcCs*|�}|dkrg|_ndd�|D�|_|S)aCreate a node of this type from the given list of elements.

        :param elts: The list of elements that the node should contain.
        :type elts: list(NodeNG)

        :returns: A new node containing the given elements.
        :rtype: NodeNG
        NcSsg|]}t|��qSr)�
const_factory)r/�errrr�	sz1_BaseContainer.from_constants.<locals>.<listcomp>)r)�clsrrrrr�from_constants�s

z_BaseContainer.from_constantscCs|jS)z�An iterator over the elements this node contains.

        :returns: The contents of this node.
        :rtype: iterable(NodeNG)
        )r)rYrrr�iteredsz_BaseContainer.iteredcCs
t|j�S)z�Determine the boolean value of this node.

        :returns: The boolean value of this node.
        :rtype: bool or Uninferable
        )�boolr)rYrrrr�sz_BaseContainer.bool_valuecCsdS)zyGet the name of the type that this node represents.

        :returns: The name of the type.
        :rtype: str
        Nr)rYrrr�pytypesz_BaseContainer.pytypeccs|jEdHdS)N)r)rYrrrr�$sz_BaseContainer.get_children)NNN)N)rrr�r�r�rerZr��classmethodr�r�r��abc�abstractmethodr�r��
__classcell__rr)r;rr��sr�)�	metaclassc@s:eZdZdZedd�dd��Zdd�Zdd	�Zd
d�ZdS)�LookupMixInz+Mixin to look up a name in the right scope.N)�maxsizecCs|���||�S)adLookup 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.
        :type name: str

        :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).
        :rtype: tuple(str, list(NodeNG))
        )r�Zscope_lookup)rYrcrrr�lookup+szLookupMixIn.lookupcCs$|�|�\}}t��}t�|||�S)a
Lookup 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��
contextmodZInferenceContextrZ_infer_stmts)rYrcr�r�rrrr�ilookup=s
zLookupMixIn.ilookupcsBdd�|D�}t|�dkr>tdd�|D��r>�fdd�|D�}|S)NcSsg|]}||��f�qSr)r�)r/rrrrr�Lsz=LookupMixIn._get_filtered_node_statements.<locals>.<listcomp>rcss|]\}}t|t�VqdS)N)r
�
ExceptHandler)r/�_rrrrr1Psz<LookupMixIn._get_filtered_node_statements.<locals>.<genexpr>cs"g|]\}}|���r||f�qSr)r�)r/rr)rYrrr�Ss)rsr6)rYr��
statementsr)rYr�_get_filtered_node_statementsKs
z)LookupMixIn._get_filtered_node_statementsc	Cs6|dkr|��j��}n$|��}|��|kr<|jr<|j��}|��}||krt|jdk	rt|jdk	sht|��|j|}nd}g}g}|�|�}	�x�|	D�]�\}
}|j|kr�dkr�nnP||kr�t|�r�q�t|
d�s�t|
|
��|
��j	f��|
�
�}|
�|��rP|�||
||�\}}
|
�rP|j
}|�rF|�|��rF|
g}|jg}q�y|�|j�}Wntk
�rlYnbX||�
��|��r�q�|�s�t|||
��s�|
j�r�|
��dk�s�|
j||jk�r�||=||=t|
t��r�|�s|j|jk�rg}g}nt|
t��rg}g}q�t||
�s�|�|
�|�|j�q�W|S)apFilter the given list of statements to remove ignorable statements.

        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 stmts: The statements to filter.
        :type stmts: list(NodeNG)

        :param frame: The frame that all of the given statements belong to.
        :type frame: NodeNG

        :param offset: The line offset to filter statements up to.
        :type offset: int

        :returns: The filtered statements.
        :rtype: list(NodeNG)
        r�Nr�assign_typeZPartialFunction)r�rr�r�r�r��is_from_decorator�hasattrr��localsr�r��_get_filtered_stmtsr�r�r-�
ValueErrorr&r��qnamercr
�
AssignName�DelNamerx)rYr�r��offsetZmyframe�mystmtr�Z_stmtsZ
_stmt_parentsr�rrr�r�r�Zpindexrrr�
_filter_stmtsWsr




zLookupMixIn._filter_stmts)	rrr�r�r�rr�r�r�r�rrrrr�(s
r�cs&eZdZdZdZd�fdd�	Z�ZS)r�a�Variation of :class:`ast.Assign` representing assignment to a name.

    An :class:`AssignName` is the name of something that is assigned to.
    This includes variables defined in a function signature or in a loop.

    >>> node = astroid.extract_node('variable = range(10)')
    >>> node
    <Assign l.1 at 0x7effe1db8550>
    >>> list(node.get_children())
    [<AssignName.variable l.1 at 0x7effe1db8748>, <Call l.1 at 0x7effe1db8630>]
    >>> list(node.get_children())[0].as_string()
    'variable'
    )rcNcs||_tt|��|||�dS)a�
        :param name: The name that is assigned to.
        :type name: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rcr�r�rZ)rYrcrWrXr)r;rrrZszAssignName.__init__)NNNN)rrr�r�r�rtrZr�rr)r;rr��sr�cs&eZdZdZdZd�fdd�	Z�ZS)r�aQVariation of :class:`ast.Delete` representing deletion of a name.

    A :class:`DelName` is the name of something that is deleted.

    >>> node = astroid.extract_node("del variable #@")
    >>> list(node.get_children())
    [<DelName.variable l.1 at 0x7effe1da4d30>]
    >>> list(node.get_children())[0].as_string()
    'variable'
    )rcNcs||_tt|��|||�dS)a�
        :param name: The name that is being deleted.
        :type name: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rcr�r�rZ)rYrcrWrXr)r;rrrZ(szDelName.__init__)NNNN)rrr�r�r�rtrZr�rr)r;rr�sr�cs.eZdZdZdZd�fdd�	Zdd�Z�ZS)	�Namea�Class representing an :class:`ast.Name` node.

    A :class:`Name` node is something that is named, but not covered by
    :class:`AssignName` or :class:`DelName`.

    >>> node = astroid.extract_node('range(10)')
    >>> node
    <Call l.1 at 0x7effe1db8710>
    >>> list(node.get_children())
    [<Name.range l.1 at 0x7effe1db86a0>, <Const.int l.1 at 0x7effe1db8518>]
    >>> list(node.get_children())[0].as_string()
    'range'
    )rcNcs||_tt|��|||�dS)a�
        :param name: The name that this node refers to.
        :type name: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rcr�r�rZ)rYrcrWrXr)r;rrrZQsz
Name.__init__ccs*|Vx|��D]}|��EdHqWdS)N)r�r�)rYr�rrrr�hszName._get_name_nodes)NNNN)rrr�r�r�rtrZr�r�rr)r;rr�@s
r�cs�eZdZdZdZdZdZdZd�fdd�	Zddd�Z	d	d
�Z
ej�fdd��Z
d
d�Zdd�Zdd�Zddd�Zdd�Z�ZS)�	Argumentsa;Class representing an :class:`ast.arguments` node.

    An :class:`Arguments` node represents that arguments in a
    function definition.

    >>> node = astroid.extract_node('def foo(bar): pass')
    >>> node
    <FunctionDef.foo l.1 at 0x7effe1db8198>
    >>> node.args
    <Arguments l.1 at 0x7effe1db82e8>
    )�args�defaults�
kwonlyargs�kw_defaults�annotations�varargannotation�kwargannotation�kwonlyargs_annotationsN)�vararg�kwargcsFtt|�j|d�||_||_g|_g|_g|_g|_g|_	g|_
dS)a9
        :param vararg: The name of the variable length arguments.
        :type vararg: str or None

        :param kwarg: The name of the variable length keyword arguments.
        :type kwarg: str or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        )rN)r�r�rZrrr�rrrrr)rYrrr)r;rrrZ�szArguments.__init__c		Cs4||_||_||_||_||_||_||_||_dS)a�Do some setup after initialisation.

        :param args: The names of the required arguments.
        :type args: list(AssignName)

        :param defaults: The default values for arguments that can be passed
            positionally.
        :type defaults: list(NodeNG)

        :param kwonlyargs: The keyword arguments that cannot be passed
            positionally.
        :type kwonlyargs: list(AssignName)

        :param kw_defaults: The default values for keyword arguments that
            cannot be passed positionally.
        :type kw_defaults: list(NodeNG)

        :param annotations: The type annotations of arguments that can be
            passed positionally.
        :type annotations: list(NodeNG)

        :param kwonlyargs_annotations: The type annotations of arguments that
            cannot be passed positionally. This should always be passed in
            Python 3.
        :type kwonlyargs_annotations: list(NodeNG)

        :param varargannotation: The type annotation for the variable length
            arguments.
        :type varargannotation: NodeNG

        :param kwargannotation: The type annotation for the variable length
            keyword arguments.
        :type kwargannotation: NodeNG
        N)r�rrrrrrr)	rYr�rrrrrrrrrrr��s-zArguments.postinitcCs|j|kr|SdS)N)r)rYr�rcrrrr�s
zArguments._infer_namecstt|�j}t||jjpd�S)zaThe first line that this node appears on in the source code.

        :type: int or None
        r)r�r�r�r�r)rYrW)r;rrr�szArguments.fromlinenoc	Cs�g}|jr(|�t|j|jt|dd���|jr>|�d|j�|jrl|jsT|�d�|�t|j|j|j��|j	r�|�d|j	�d�
|�S)zoGet the arguments formatted as string.

        :returns: The formatted arguments.
        :rtype: str
        rNz*%srPz**%sz, )r�rx�_format_argsrrgrrrrrry)rYr|rrr�format_argss 
zArguments.format_argscCs�t||j�d}|dk	rB|t|j�t|j�}|dkrB|j|St||j�d}|dk	rr|j|dk	rr|j|Stj|j|d��dS)z�Get the default value for an argument.

        :param argname: The name of the argument to get the default value for.
        :type argname: str

        :raises NoDefault: If there is no default value defined for the
            given argument.
        rN)r�rc)	�	_find_argr�rsrrrrZ	NoDefaultr)rY�argname�i�idxrrr�
default_value9s	

zArguments.default_valuecCsL||jkrdS||jkrdS|�|d�ddk	pJ|joJt||jd�ddk	S)z�Check if the given name is defined in the arguments.

        :param name: The name to check for.
        :type name: str

        :returns: True if the given name is defined in the arguments,
            False otherwise.
        :rtype: bool
        TrN)rr�find_argnamerr)rYrcrrr�is_argumentLs


zArguments.is_argumentFcCs|jrt||j|�SdS)a�Get the index and :class:`AssignName` node for given name.

        :param argname: The name of the argument to search for.
        :type argname: str

        :param rec: Whether or not to include arguments in unpacked tuples
            in the search.
        :type rec: bool

        :returns: The index and node for the argument.
        :rtype: tuple(str or None, AssignName or None)
        )NN)r�r)rYr�recrrrr`s
zArguments.find_argnameccs�|jpdEdH|jEdH|jEdHx|jD]}|dk	r0|Vq0Wx|jD]}|dk	rN|VqNW|jdk	rv|jV|jdk	r�|jVx|jD]}|dk	r�|Vq�WdS)Nr)r�rrrrrrr)rYrrrrr�qs 



zArguments.get_children)NNN)NNN)F)rrr�r�r�rerrrtrZr�r�rr�r�r
rrrr�r�rr)r;rr�os 	C
-	
r�FcCsXxRt|�D]F\}}t|t�r>|rPt||j�}|ddk	rP|Sq
|j|kr
||fSq
WdS)Nr)NN)�	enumerater
rrrrc)rr�rr
�arg�foundrrrr�s

rc
Cs�g}|dkrdS|dkrg}|dk	r4t|�t|�}t�||�}x�t|�D]�\}\}}t|t�rv|�dt|j��qJ|j	}	|dk	r�|	d|�
�7}	|�|	�|dk	rJ||krJ|||dk	rJ|dd|||�
�7<qJWd�|�S)Nrfz(%s)�:r��=z, )rs�	itertools�zip_longestrr
rrxr	rrcrry)
r�rr�valuesZdefault_offsetZpackedr
r�
annotationrrrrr	�s&

$r	cs@eZdZdZdZdZdZd�fdd�	Zddd�Zd	d
�Z	�Z
S)
�
AssignAttrazVariation of :class:`ast.Assign` representing assignment to an attribute.

    >>> node = astroid.extract_node('self.attribute = range(10)')
    >>> node
    <Assign l.1 at 0x7effe1d521d0>
    >>> list(node.get_children())
    [<AssignAttr.attribute l.1 at 0x7effe1d52320>, <Call l.1 at 0x7effe1d522e8>]
    >>> list(node.get_children())[0].as_string()
    'self.attribute'
    )�expr)rdNcs||_tt|��|||�dS)a�
        :param attrname: The name of the attribute being assigned to.
        :type attrname: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rdr�rrZ)rYrdrWrXr)r;rrrZ�szAssignAttr.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param expr: What has the attribute that is being assigned to.
        :type expr: NodeNG or None
        N)r)rYrrrrr��szAssignAttr.postinitccs|jVdS)N)r)rYrrrr��szAssignAttr.get_children)NNNN)N)rrr�r�r�rertrrZr�r�r�rr)r;rr�s

rc@s.eZdZdZdZdZdZddd�Zdd�ZdS)	�Assertz�Class representing an :class:`ast.Assert` node.

    An :class:`Assert` node represents an assert statement.

    >>> node = astroid.extract_node('assert len(things) == 10, "Not enough things"')
    >>> node
    <Assert l.1 at 0x7effe1d527b8>
    )�test�failNcCs||_||_dS)z�Do some setup after initialisation.

        :param test: The test that passes or fails the assertion.
        :type test: NodeNG or None

        :param fail: The message shown when the assertion fails.
        :type fail: NodeNG or None
        N)r r)rYrr rrrr��s	zAssert.postinitccs|jV|jdk	r|jVdS)N)rr )rYrrrr�s
zAssert.get_children)NN)	rrr�r�r�rerr r�r�rrrrr�s
rc@sLeZdZdZdZdZdZdZdZd
dd�Z	dd�Z
ejd	d
��Z
dd�ZdS)�Assignz�Class representing an :class:`ast.Assign` node.

    An :class:`Assign` is a statement where something is explicitly
    asssigned to.

    >>> node = astroid.extract_node('variable = range(10)')
    >>> node
    <Assign l.1 at 0x7effe1db8550>
    )�targetsr()�type_annotationNcCs||_||_||_dS)z�Do some setup after initialisation.

        :param targets: What is being assigned to.
        :type targets: list(NodeNG) or None

        :param value: The value being assigned to the variables.
        :type: NodeNG or None
        N)r"r(r#)rYr"r(r#rrrr�+s	zAssign.postinitccs|jEdH|jVdS)N)r"r()rYrrrr�8szAssign.get_childrencCs|gt|j���S)N)r�r(r�)rYrrrr�=szAssign._get_assign_nodesccs|j��EdHdS)N)r(r�)rYrrrr�Asz$Assign._get_yield_nodes_skip_lambdas)NNN)rrr�r�r�rer�r"r(r#r�r�rr�r�r�rrrrr!s	

r!c@s:eZdZdZdZdZdZdZdZdZ	d	dd�Z
dd�ZdS)
�	AnnAssignz�Class representing an :class:`ast.AnnAssign` node.

    An :class:`AnnAssign` is an assignment with a type annotation.

    >>> node = astroid.extract_node('variable: List[int] = range(10)')
    >>> node
    <AnnAssign l.1 at 0x7effe1d4c630>
    )�targetrr()�simpleNcCs||_||_||_||_dS)a�Do some setup after initialisation.

        :param target: What is being assigned to.
        :type target: NodeNG

        :param annotation: The type annotation of what is being assigned to.
        :type: NodeNG

        :param simple: Whether :attr:`target` is a pure name
            or a complex statement.
        :type simple: int

        :param value: The value being assigned to the variables.
        :type: NodeNG or None
        N)r%rr(r&)rYr%rr&r(rrrr�fszAnnAssign.postinitccs&|jV|jV|jdk	r"|jVdS)N)r%rr()rYrrrr�{s
zAnnAssign.get_children)N)rrr�r�r�rertr%rr(r&r�r�rrrrr$Es
r$csXeZdZdZdZdZdZdZd�fdd�	Zddd�Z	dd	d
�Z
ddd�Zd
d�Z�Z
S)�	AugAssignz�Class representing an :class:`ast.AugAssign` node.

    An :class:`AugAssign` is an assignment paired with an operator.

    >>> node = astroid.extract_node('variable += 1')
    >>> node
    <AugAssign l.1 at 0x7effe1db4d68>
    )r%r()rDNcs||_tt|��|||�dS)a�
        :param op: The operator that is being combined with the assignment.
            This includes the equals sign.
        :type op: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rDr�r'rZ)rYrDrWrXr)r;rrrZ�szAugAssign.__init__cCs||_||_dS)z�Do some setup after initialisation.

        :param target: What is being assigned to.
        :type target: NodeNG or None

        :param value: The value being assigned to the variable.
        :type: NodeNG or None
        N)r%r()rYr%r(rrrr��s	zAugAssign.postinitcCst�dS)N)�NotImplementedError)rYrrrr�_infer_augassign�szAugAssign._infer_augassigncCs6y|j|d�}dd�|D�Stjk
r0gSXdS)a&Get a list of type errors which can occur during inference.

        Each TypeError is represented by a :class:`BadBinaryOperationMessage` ,
        which holds the original exception.

        :returns: The list of possible type errors.
        :rtype: list(BadBinaryOperationMessage)
        )rcSsg|]}t|tj�r|�qSr)r
r�BadBinaryOperationMessage)r/r|rrrr��sz)AugAssign.type_errors.<locals>.<listcomp>N)r)rr+)rYr�resultsrrr�type_errors�s	zAugAssign.type_errorsccs|jV|jVdS)N)r%r()rYrrrr��szAugAssign.get_children)NNNN)NN)N)N)rrr�r�r�rertr%r(rZr�r)r,r�r�rr)r;rr'�s


r'c@s"eZdZdZdZdZddd�ZdS)�RepraClass representing an :class:`ast.Repr` node.

    A :class:`Repr` node represents the backtick syntax,
    which is a deprecated alias for :func:`repr` removed in Python 3.

    >>> node = astroid.extract_node('`variable`')
    >>> node
    <Repr l.1 at 0x7fa0951d75d0>
    )r(NcCs
||_dS)z�Do some setup after initialisation.

        :param value: What is having :func:`repr` called on it.
        :type value: NodeNG or None
        N)r()rYr(rrrr��sz
Repr.postinit)N)rrr�r�r�rer(r�rrrrr-�s	r-csheZdZdZdZdZdZdZd�fdd�	Zddd�Z	dd	d
�Z
ddd�Zd
d�Zdd�Z
dd�Z�ZS)�BinOpz�Class representing an :class:`ast.BinOp` node.

    A :class:`BinOp` node is an application of a binary operator.

    >>> node = astroid.extract_node('a + b')
    >>> node
    <BinOp l.1 at 0x7f23b2e8cfd0>
    )�left�right)rDNcs||_tt|��|||�dS)a�
        :param op: The operator.
        :type: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rDr�r.rZ)rYrDrWrXr)r;rrrZszBinOp.__init__cCs||_||_dS)aDo some setup after initialisation.

        :param left: What is being applied to the operator on the left side.
        :type left: NodeNG or None

        :param right: What is being applied to the operator on the right side.
        :type right: NodeNG or None
        N)r/r0)rYr/r0rrrr�%s	zBinOp.postinitcCst�dS)N)r()rYrrrr�_infer_binop2szBinOp._infer_binopcCs6y|j|d�}dd�|D�Stjk
r0gSXdS)a%Get a list of type errors which can occur during inference.

        Each TypeError is represented by a :class:`BadBinaryOperationMessage`,
        which holds the original exception.

        :returns: The list of possible type errors.
        :rtype: list(BadBinaryOperationMessage)
        )rcSsg|]}t|tj�r|�qSr)r
rr*)r/r|rrrr�Asz%BinOp.type_errors.<locals>.<listcomp>N)r1rr+)rYrr+rrrr,5s	zBinOp.type_errorsccs|jV|jVdS)N)r/r0)rYrrrr�HszBinOp.get_childrencCs
t|jS)N)r�rD)rYrrrr�LszBinOp.op_precedencecCs
|jdkS)Nz**)rD)rYrrrr�OszBinOp.op_left_associative)NNNN)NN)N)N)rrr�r�r�rertr/r0rZr�r1r,r�r�r�r�rr)r;rr.�s


r.csHeZdZdZdZdZdZd
�fdd�	Zddd�Zd	d
�Z	dd�Z
�ZS)�BoolOpz�Class representing an :class:`ast.BoolOp` node.

    A :class:`BoolOp` is an application of a boolean operator.

    >>> node = astroid.extract_node('a and b')
    >>> node
    <BinOp l.1 at 0x7f23b2e71c50>
    )r)rDNcs||_tt|��|||�dS)a�
        :param op: The operator.
        :type: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rDr�r2rZ)rYrDrWrXr)r;rrrZfszBoolOp.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param values: The values being applied to the operator.
        :type values: list(NodeNG) or None
        N)r)rYrrrrr�}szBoolOp.postinitccs|jEdHdS)N)r)rYrrrr��szBoolOp.get_childrencCs
t|jS)N)r�rD)rYrrrr��szBoolOp.op_precedence)NNNN)N)rrr�r�r�rertrrZr�r�r�r�rr)r;rr2Ts
r2c@seZdZdZdS)�Breakz�Class representing an :class:`ast.Break` node.

    >>> node = astroid.extract_node('break')
    >>> node
    <Break l.1 at 0x7f23b2e9e5c0>
    N)rrr�r�r�rrrrr3�sr3c@sJeZdZdZdZdZdZdZddd�Ze	dd��Z
e	dd	��Zd
d�ZdS)
�Callz�Class representing an :class:`ast.Call` node.

    A :class:`Call` node is a call to a function, method, etc.

    >>> node = astroid.extract_node('function()')
    >>> node
    <Call l.1 at 0x7f23b2e71eb8>
    )r�r��keywordsNcCs||_||_||_dS)abDo some setup after initialisation.

        :param func: What is being called.
        :type func: NodeNG or None

        :param args: The positional arguments being given to the call.
        :type args: list(NodeNG) or None

        :param keywords: The keyword arguments being given to the call.
        :type keywords: list(NodeNG) or None
        N)r�r�r5)rYr�r�r5rrrr��sz
Call.postinitcCs|jpg}dd�|D�S)zVThe positional arguments that unpack something.

        :type: list(Starred)
        cSsg|]}t|t�r|�qSr)r
�Starred)r/rrrrr��sz!Call.starargs.<locals>.<listcomp>)r�)rYr�rrr�starargs�s
z
Call.starargscCs|jpg}dd�|D�S)zSThe keyword arguments that unpack something.

        :type: list(Keyword)
        cSsg|]}|jdkr|�qS)N)r)r/�keywordrrrr��szCall.kwargs.<locals>.<listcomp>)r5)rYr5rrrr`�s
zCall.kwargsccs(|jV|jEdH|jpdEdHdS)Nr)r�r�r5)rYrrrr��szCall.get_children)NNN)
rrr�r�r�rer�r�r5r��propertyr7r`r�rrrrr4�s
		r4c@s6eZdZdZdZdZdZd
dd�Zdd�Zdd	�Z	dS)rJa5Class representing an :class:`ast.Compare` node.

    A :class:`Compare` node indicates a comparison.

    >>> node = astroid.extract_node('a <= b <= c')
    >>> node
    <Compare l.1 at 0x7f23b2e9e6d8>
    >>> node.ops
    [('<=', <Name.b l.1 at 0x7f23b2e9e2b0>), ('<=', <Name.c l.1 at 0x7f23b2e9e390>)]
    )r/rCNcCs||_||_dS)aHDo some setup after initialisation.

        :param left: The value at the left being applied to a comparison
            operator.
        :type left: NodeNG or None

        :param ops: The remainder of the operators
            and their relevant right hand value.
        :type ops: list(tuple(str, NodeNG)) or None
        N)r/rC)rYr/rCrrrr��szCompare.postinitccs&|jVx|jD]\}}|VqWdS)z�Get the child nodes below this node.

        Overridden to handle the tuple fields and skip returning the operator
        strings.

        :returns: The children.
        :rtype: iterable(NodeNG)
        N)r/rC)rYr�Z
comparatorrrrr�	s	zCompare.get_childrencCs|jddS)zsAn optimized version of list(get_children())[-1]

        :returns: The last child.
        :rtype: NodeNG
        r�r)rC)rYrrrr�
	szCompare.last_child)NN)
rrr�r�r�rer/rCr�r�r�rrrrrJ�s


cs`eZdZdZdZdZdZdZdZdZ	d�fdd�	Z
ddd�Zd	Zd
d�Z
dd
�Zdd�Z�ZS)�
Comprehensiona�Class representing an :class:`ast.comprehension` node.

    A :class:`Comprehension` indicates the loop inside any type of
    comprehension including generator expressions.

    >>> node = astroid.extract_node('[x for x in some_values]')
    >>> list(node.get_children())
    [<Name.x l.1 at 0x7f23b2e352b0>, <Comprehension l.1 at 0x7f23b2e35320>]
    >>> list(node.get_children())[1].as_string()
    'for x in some_values'
    )r%r^�ifs)�is_asyncNcstt|���||_dS)zi
        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)r�r:rZr)rYr)r;rrrZ<	szComprehension.__init__cCs||_||_||_||_dS)a�Do some setup after initialisation.

        :param target: What is assigned to by the comprehension.
        :type target: NodeNG or None

        :param iter: What is iterated over by the comprehension.
        :type iter: NodeNG or None

        :param ifs: The contents of any if statements that filter
            the comprehension.
        :type ifs: list(NodeNG) or None

        :param is_async: Whether this is an asynchronous comprehension or not.
        :type: bool or None
        N)r%r^r;r<)rYr%r^r;r<rrrr�E	szComprehension.postinitTcCs|S)zwThe type of assignment that this node performs.

        :returns: The assignment type.
        :rtype: NodeNG
        r)rYrrrr�`	szComprehension.assign_typecCs@||kr"t|ttf�r8|gdfSn|��|kr8|gdfS|dfS)zmethod used in filter_stmtsTF)r
r'r�r�)rYZlookup_noderr�r�rrrr�h	s
z!Comprehension._get_filtered_stmtsccs |jV|jV|jEdHdS)N)r%r^r;)rYrrrr�v	szComprehension.get_children)N)NNNN)rrr�r�r�rertr%r^r;r<rZr�r�r�r�r�r�rr)r;rr:	s	
r:cs\eZdZdZdZd�fdd�	Z�fdd�Zddd	�Zd
d�Zdd
�Z	dd�Z
dd�Z�ZS)r'a�Class representing any constant including num, str, bool, None, bytes.

    >>> node = astroid.extract_node('(5, "This is a string.", True, None, b"bytes")')
    >>> node
    <Tuple.tuple l.1 at 0x7f23b2e358d0>
    >>> list(node.get_children())
    [<Const.int l.1 at 0x7f23b2e35940>,
    <Const.str l.1 at 0x7f23b2e35978>,
    <Const.bool l.1 at 0x7f23b2e359b0>,
    <Const.NoneType l.1 at 0x7f23b2e359e8>,
    <Const.bytes l.1 at 0x7f23b2e35a20>]
    )r(Ncs||_tt|��|||�dS)a�
        :param value: The value that the constant represents.
        :type value: object

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)r(r�r'rZ)rYr(rWrXr)r;rrrZ�	szConst.__init__cs|dkrt�t��|�S)Nr()�AttributeErrorr��__getattr__)rYrc)r;rrr>�	szConst.__getattr__c
Cs�t|t�r|j}n,t|t�r*t||d�}nt�d�t|����y"t|jt	t
f�r^t|j|�SWnjtk
r�}ztjd|||d�|�Wdd}~XYn6t
k
r�}ztjd|||d�|�Wdd}~XYnXt�d||jf��dS)a%Get an item from this node if subscriptable.

        :param index: The node to use as a subscript index.
        :type index: Const or Slice

        :raises AstroidTypeError: When the given index cannot be used as a
            subscript index, or if this node is not subscriptable.
        )rz(Could not use type {} as subscript indexzIndex {index!r} out of range)r2rr-rNzType error {error!r}z
%r (value=%s))r
r'r(r:r9rr8�formatr*�str�bytesr<r=r>)rYr-rZindex_valuer@rrr�getitem�	s*	

z
Const.getitemcCsdS)aCheck if the node has a custom __getattr__ or __getattribute__.

        :returns: True if the class has a custom
            __getattr__ or __getattribute__, False otherwise.
            For a :class:`Const` this is always ``False``.
        :rtype: bool
        Fr)rYrrr�has_dynamic_getattr�	szConst.has_dynamic_getattrcCst|jt�r|jSt��dS)z�An iterator over the elements this node contains.

        :returns: The contents of this node.
        :rtype: iterable(str)

        :raises TypeError: If this node does not represent something that is iterable.
        N)r
r(r@r>)rYrrrr��	szConst.iteredcCs
|j��S)zyGet the name of the type that this node represents.

        :returns: The name of the type.
        :rtype: str
        )�_proxiedr�)rYrrrr��	szConst.pytypecCs
t|j�S)zzDetermine the boolean value of this node.

        :returns: The boolean value of this node.
        :rtype: bool
        )r�r()rYrrrr��	szConst.bool_value)NNN)N)
rrr�r�r�rtrZr>rBrCr�r�r�r�rr)r;rr'}	s
$
r'c@seZdZdZdS)�Continuez�Class representing an :class:`ast.Continue` node.

    >>> node = astroid.extract_node('continue')
    >>> node
    <Continue l.1 at 0x7f23b2e35588>
    N)rrr�r�r�rrrrrE�	srEc@s0eZdZdZdZdZdd�Zdd�Zdd	�ZdS)
�
Decoratorsa�A node representing a list of decorators.

    A :class:`Decorators` is the decorators that are applied to
    a method or function.

    >>> node = astroid.extract_node('''
    @property
    def my_property(self):
        return 3
    ''')
    >>> node
    <FunctionDef.my_property l.2 at 0x7f23b2e35d30>
    >>> list(node.get_children())[0]
    <Decorators l.1 at 0x7f23b2e35d68>
    )r�NcCs
||_dS)z�Do some setup after initialisation.

        :param nodes: The decorators that this node contains.
        :type nodes: list(Name or Call)
        N)r�)rYr�rrrr�
szDecorators.postinitcCs|jj��S)z�The first parent node defining a new scope.

        :returns: The first parent scope node.
        :rtype: Module or FunctionDef or ClassDef or Lambda or GenExpr
        )rr�)rYrrrr�#
szDecorators.scopeccs|jEdHdS)N)r�)rYrrrr�,
szDecorators.get_children)	rrr�r�r�rer�r�r�r�rrrrrF
s	rFcs@eZdZdZdZdZdZd�fdd�	Zddd�Zd	d
�Z	�Z
S)
�DelAttraVariation of :class:`ast.Delete` representing deletion of an attribute.

    >>> node = astroid.extract_node('del self.attr')
    >>> node
    <Delete l.1 at 0x7f23b2e35f60>
    >>> list(node.get_children())[0]
    <DelAttr.attr l.1 at 0x7f23b2e411d0>
    )r)rdNcs||_tt|��|||�dS)a�
        :param attrname: The name of the attribute that is being deleted.
        :type attrname: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rdr�rGrZ)rYrdrWrXr)r;rrrZB
szDelAttr.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param expr: The name that this node represents.
        :type expr: Name or None
        N)r)rYrrrrr�Y
szDelAttr.postinitccs|jVdS)N)r)rYrrrr�a
szDelAttr.get_children)NNNN)N)rrr�r�r�rertrrZr�r�r�rr)r;rrG0
s
rGc@s*eZdZdZdZdZddd�Zdd�ZdS)	�Deletez�Class representing an :class:`ast.Delete` node.

    A :class:`Delete` is a ``del`` statement this is deleting something.

    >>> node = astroid.extract_node('del self.attr')
    >>> node
    <Delete l.1 at 0x7f23b2e35f60>
    )r"NcCs
||_dS)z�Do some setup after initialisation.

        :param targets: What is being deleted.
        :type targets: list(NodeNG) or None
        N)r")rYr"rrrr�v
szDelete.postinitccs|jEdHdS)N)r")rYrrrr�~
szDelete.get_children)N)rrr�r�r�rer"r�r�rrrrrHe
s

rHcsneZdZdZdZd�fdd�	Zdd�Zeddd	��Zd
d�Z	dd
�Z
dd�Zdd�Zddd�Z
dd�Z�ZS)�Dictz�Class representing an :class:`ast.Dict` node.

    A :class:`Dict` is a dictionary that is created with ``{}`` syntax.

    >>> node = astroid.extract_node('{1: "1"}')
    >>> node
    <Dict.dict l.1 at 0x7f23b2e35cc0>
    )�itemsNcsg|_tt|��|||�dS)aa
        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rJr�rIrZ)rYrWrXr)r;rrrZ�
sz
Dict.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param items: The key-value pairs contained in the dictionary.
        :type items: list(tuple(NodeNG, NodeNG))
        N)rJ)rYrJrrrr��
sz
Dict.postinitcCs.|�}|dkrg|_ndd�|��D�|_|S)z�Create a :class:`Dict` of constants from a live dictionary.

        :param items: The items to store in the node.
        :type items: dict

        :returns: The created dictionary node.
        :rtype: Dict
        NcSs g|]\}}t|�t|�f�qSr)r�)r/�k�vrrrr��
sz'Dict.from_constants.<locals>.<listcomp>)rJ)r�rJrrrrr��
s

zDict.from_constantscCsdtS)zyGet the name of the type that this node represents.

        :returns: The name of the type.
        :rtype: str
        z%s.dict)�BUILTINS)rYrrrr��
szDict.pytypeccs$x|jD]\}}|V|VqWdS)z�Get the key and value nodes below this node.

        Children are returned in the order that they are defined in the source
        code, key first then the value.

        :returns: The children.
        :rtype: iterable(NodeNG)
        N)rJ)rYrar(rrrr��
s	zDict.get_childrencCs|jr|jddSdS)z�An optimized version of list(get_children())[-1]

        :returns: The last child, or None if no children exist.
        :rtype: NodeNG or None
        r�rN)rJ)rYrrrr��
szDict.last_childcCsdd�|jD�S)z�An iterator over the keys this node contains.

        :returns: The keys of this node.
        :rtype: iterable(NodeNG)
        cSsg|]\}}|�qSrr)r/rar�rrrr��
szDict.itered.<locals>.<listcomp>)rJ)rYrrrr��
szDict.iteredc
Cs�x�|jD]�\}}t|t�rFy|�||�Stjtjfk
rDwYnXxB|�|�D]4}|tj	krbqRt|t
�rRt|t
�rR|j|jkrR|SqRWqWt�|��dS)axGet an item from this node.

        :param index: The node to use as a subscript index.
        :type index: Const or Slice

        :raises AstroidTypeError: When the given index cannot be used as a
            subscript index, or if this node is not subscriptable.
        :raises AstroidIndexError: If the given index does not exist in the
            dictionary.
        N)rJr
�
DictUnpackrBrr8r=rrrr'r()rYr-rrar(ZinferredkeyrrrrB�
s

zDict.getitemcCs
t|j�S)zzDetermine the boolean value of this node.

        :returns: The boolean value of this node.
        :rtype: bool
        )r�rJ)rYrrrr��
szDict.bool_value)NNN)N)N)rrr�r�r�rerZr�r�r�r�r�r�r�rBr�r�rr)r;rrI�
s


rIc@s2eZdZdZdZdZd
dd�Zdd�Zdd	�ZdS)�ExpraClass representing an :class:`ast.Expr` node.

    An :class:`Expr` is any expression that does not have its value used or
    stored.

    >>> node = astroid.extract_node('method()')
    >>> node
    <Call l.1 at 0x7f23b2e352b0>
    >>> node.parent
    <Expr l.1 at 0x7f23b2e35278>
    )r(NcCs
||_dS)z�Do some setup after initialisation.

        :param value: What the expression does.
        :type value: NodeNG or None
        N)r()rYr(rrrr�sz
Expr.postinitccs|jVdS)N)r()rYrrrr�$szExpr.get_childrenccs|jjs|j��EdHdS)N)r(r�r�)rYrrrr�'sz"Expr._get_yield_nodes_skip_lambdas)N)	rrr�r�r�rer(r�r�r�rrrrrOs
rOc@seZdZdZdd�ZdS)�Ellipsisz�Class representing an :class:`ast.Ellipsis` node.

    An :class:`Ellipsis` is the ``...`` syntax.

    >>> node = astroid.extract_node('...')
    >>> node
    <Ellipsis l.1 at 0x7f23b2e35160>
    cCsdS)z�Determine the boolean value of this node.

        :returns: The boolean value of this node.
            For an :class:`Ellipsis` this is always ``True``.
        :rtype: bool
        Tr)rYrrrr�6szEllipsis.bool_valueN)rrr�r�r�r�rrrrrP,srPc@seZdZdZdZdS)�	EmptyNodezAHolds an arbitrary object in the :attr:`LocalsDictNodeNG.locals`.N)rrr�r�r��objectrrrrrQ@srQc@sLeZdZdZdZdZdZdZdZdd�Z	d
dd�Z
ejd	d
��Z
dd�ZdS)r�a�Class representing an :class:`ast.ExceptHandler`. node.

    An :class:`ExceptHandler` is an ``except`` block on a try-except.

    >>> node = astroid.extract_node('''
        try:
            do_something()
        except Exception as error:
            print("Error!")
        ''')
    >>> node
    <TryExcept l.2 at 0x7f23b2e9d908>
    >>> >>> node.handlers
    [<ExceptHandler l.4 at 0x7f23b2e9e860>]
    )r*rcr)rNccs4|jdk	r|jV|jdk	r$|jV|jEdHdS)N)r*rcr)rYrrrr�is


zExceptHandler.get_childrencCs||_||_||_dS)aYDo some setup after initialisation.

        :param type: The types that the block handles.
        :type type: Tuple or NodeNG or None

        :param name: The name that the caught exception is assigned to.
        :type name: AssignName or None

        :param body:The contents of the block.
        :type body: list(NodeNG) or None
        N)r*rcr)rYr*rcrrrrr�sszExceptHandler.postinitcCs"|jr|jjS|jr|jjS|jS)zPThe line on which the beginning of this block ends.

        :type: int
        )rcr�r*rW)rYrrr�blockstart_tolineno�s
z!ExceptHandler.blockstart_tolinenocCs<|jdks|dkrdSx |j��D]}|j|kr"dSq"WdS)z�Check if this node handles any of the given exceptions.

        If ``exceptions`` is empty, this will default to ``True``.

        :param exceptions: The name of the exceptions to check for.
        :type exceptions: list(str)
        NTF)r*r�rc)rYrrrrrr#�s
zExceptHandler.catch)NNN)rrr�r�r�re�_multi_line_block_fieldsr*rcrr�r�rr�rSr#rrrrr�Fs

r�c@s*eZdZdZdZdZdZdZddd�ZdS)�Execz�Class representing the ``exec`` statement.

    >>> node = astroid.extract_node('exec "True"')
    >>> node
    <Exec l.1 at 0x7f0e8106c6d0>
    )r�globalsr�NcCs||_||_||_dS)aNDo some setup after initialisation.

        :param expr: The expression to be executed.
        :type expr: NodeNG or None

        :param globals:The globals dictionary to execute with.
        :type globals: NodeNG or None

        :param locals: The locals dictionary to execute with.
        :type locals: NodeNG or None
        N)rrVr�)rYrrVr�rrrr��sz
Exec.postinit)NNN)	rrr�r�r�rerrVr�r�rrrrrU�srUc@s"eZdZdZdZdZddd�ZdS)�ExtSliceaClass representing an :class:`ast.ExtSlice` node.

    An :class:`ExtSlice` is a complex slice expression.

    >>> node = astroid.extract_node('l[1:3, 5]')
    >>> node
    <Subscript l.1 at 0x7f23b2e9e550>
    >>> node.slice
    <ExtSlice l.1 at 0x7f23b7b05ef0>
    )�dimsNcCs
||_dS)z�Do some setup after initialisation.

        :param dims: The simple dimensions that form the complete slice.
        :type dims: list(NodeNG) or None
        N)rX)rYrXrrrr��szExtSlice.postinit)N)rrr�r�r�rerXr�rrrrrW�s
rWc@sTeZdZdZdZdZdZdZdZdZ	dZ
dZd
dd�ZdZ
ejd	d
��Zdd�ZdS)�Forz�Class representing an :class:`ast.For` node.

    >>> node = astroid.extract_node('for thing in things: print(thing)')
    >>> node
    <For l.1 at 0x7f23b2e8cf28>
    )r%r^rr)r#)rrNcCs"||_||_||_||_||_dS)a�Do some setup after initialisation.

        :param target: What the loop assigns to.
        :type target: NodeNG or None

        :param iter: What the loop iterates over.
        :type iter: NodeNG or None

        :param body: The contents of the body of the loop.
        :type body: list(NodeNG) or None

        :param orelse: The contents of the ``else`` block of the loop.
        :type orelse: list(NodeNG) or None
        N)r%r^rrr#)rYr%r^rrr#rrrr�s
zFor.postinitTcCs|jjS)zPThe line on which the beginning of this block ends.

        :type: int
        )r^r�)rYrrrrS0szFor.blockstart_tolinenoccs,|jV|jV|jEdH|jEdHdS)N)r%r^rr)rYrrrr�8szFor.get_children)NNNNN)rrr�r�r�rer�rTr%r^rrr#r�r�rr�rSr�rrrrrY�s
rYc@seZdZdZdS)�AsyncFora�Class representing an :class:`ast.AsyncFor` node.

    An :class:`AsyncFor` is an asynchronous :class:`For` built with
    the ``async`` keyword.

    >>> node = astroid.extract_node('''
    async def func(things):
        async for thing in things:
            print(thing)
    ''')
    >>> node
    <AsyncFunctionDef.func l.2 at 0x7f23b2e416d8>
    >>> node.body[0]
    <AsyncFor l.3 at 0x7f23b2e417b8>
    N)rrr�r�r�rrrrrZ@srZc@s*eZdZdZdZdZddd�Zdd�ZdS)	rUa�Class representing an :class:`ast.Await` node.

    An :class:`Await` is the ``await`` keyword.

    >>> node = astroid.extract_node('''
    async def func(things):
        await other_func()
    ''')
    >>> node
    <AsyncFunctionDef.func l.2 at 0x7f23b2e41748>
    >>> node.body[0]
    <Expr l.3 at 0x7f23b2e419e8>
    >>> list(node.body[0].get_children())[0]
    <Await l.3 at 0x7f23b2e41a20>
    )r(NcCs
||_dS)zyDo some setup after initialisation.

        :param value: What to wait for.
        :type value: NodeNG or None
        N)r()rYr(rrrr�jszAwait.postinitccs|jVdS)N)r()rYrrrr�rszAwait.get_children)N)rrr�r�r�rer(r�r�rrrrrURs

cs&eZdZdZdZd�fdd�	Z�ZS)�
ImportFromz�Class representing an :class:`ast.ImportFrom` node.

    >>> node = astroid.extract_node('from my_package import my_module')
    >>> node
    <ImportFrom l.1 at 0x7f23b2e415c0>
    )�modnamerh�levelrNcs*||_||_||_tt|��|||�dS)a�
        :param fromname: The module that is being imported from.
        :type fromname: str or None

        :param names: What is being imported from the module.
        :type names: list(tuple(str, str or None))

        :param level: The level of relative import.
        :type level: int

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)r\rhr]r�r[rZ)rY�fromnamerhr]rWrXr)r;rrrZ�s		zImportFrom.__init__)rNNN)rrr�r�r�rtrZr�rr)r;rr[vsr[cs@eZdZdZdZdZdZd�fdd�	Zddd�Zd	d
�Z	�Z
S)
�	Attributez2Class representing an :class:`ast.Attribute` node.)r)rdNcs||_tt|��|||�dS)a�
        :param attrname: The name of the attribute.
        :type attrname: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rdr�r_rZ)rYrdrWrXr)r;rrrZ�szAttribute.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param expr: The name that this node represents.
        :type expr: Name or None
        N)r)rYrrrrr��szAttribute.postinitccs|jVdS)N)r)rYrrrr��szAttribute.get_children)NNNN)N)rrr�r�r�rertrrZr�r�r�rr)r;rr_�s
r_cs.eZdZdZdZd�fdd�	Zdd�Z�ZS)	�Globalz�Class representing an :class:`ast.Global` node.

    >>> node = astroid.extract_node('global a_global')
    >>> node
    <Global l.1 at 0x7f23b2e9de10>
    )rhNcs||_tt|��|||�dS)a�
        :param names: The names being declared as global.
        :type names: list(str)

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rhr�r`rZ)rYrhrWrXr)r;rrrZ�szGlobal.__init__cCs|S)Nr)rYr�rcrrrr�
szGlobal._infer_name)NNN)rrr�r�r�rtrZr�r�rr)r;rr`�sr`c@sTeZdZdZdZdZdZdZdZddd�Z	e
jdd��Zd	d
�Z
dd�Zd
d�ZdS)r z�Class representing an :class:`ast.If` node.

    >>> node = astroid.extract_node('if condition: print(True)')
    >>> node
    <If l.1 at 0x7f23b2e9dd30>
    )rrr)rrNcCs||_||_||_dS)aNDo some setup after initialisation.

        :param test: The condition that the statement tests.
        :type test: NodeNG or None

        :param body: The contents of the block.
        :type body: list(NodeNG) or None

        :param orelse: The contents of the ``else`` block.
        :type orelse: list(NodeNG) or None
        N)rrr)rYrrrrrrr�!
szIf.postinitcCs|jjS)zPThe line on which the beginning of this block ends.

        :type: int
        )rr�)rYrrrrS1
szIf.blockstart_tolinenocCsT||jdjkr||fS||jdjkr8||jdjfS|�||j|jdjd�S)a8Get 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)
        rr�r)rr�r��_elsed_block_ranger)rYrWrrrr�9
s

zIf.block_rangeccs$|jV|jEdH|jEdHdS)N)rrr)rYrrrr�I
szIf.get_childrencCst|j�dkot|jdt�S)Nrr)rsrr
r )rYrrr�has_elif_blockO
szIf.has_elif_block)NNN)rrr�r�r�rerTrrrr�rr�rSr�r�rbrrrrr 
s
r c@s:eZdZdZdZdZdZdZd
dd�Zdd�Z	dd	�Z
dS)rFz�Class representing an :class:`ast.IfExp` node.

    >>> node = astroid.extract_node('value if condition else other')
    >>> node
    <IfExp l.1 at 0x7f23b2e9dbe0>
    )rrrNcCs||_||_||_dS)aNDo some setup after initialisation.

        :param test: The condition that the statement tests.
        :type test: NodeNG or None

        :param body: The contents of the block.
        :type body: list(NodeNG) or None

        :param orelse: The contents of the ``else`` block.
        :type orelse: list(NodeNG) or None
        N)rrr)rYrrrrrrr�l
szIfExp.postinitccs|jV|jV|jVdS)N)rrr)rYrrrr�|
szIfExp.get_childrencCsdS)NFr)rYrrrr��
szIfExp.op_left_associative)NNN)rrr�r�r�rerrrr�r�r�rrrrrFS
s
cs&eZdZdZdZd�fdd�	Z�ZS)�Importz�Class representing an :class:`ast.Import` node.

    >>> node = astroid.extract_node('import astroid')
    >>> node
    <Import l.1 at 0x7f23b2e4e5c0>
    )rhNcs||_tt|��|||�dS)a�
        :param names: The names being imported.
        :type names: list(tuple(str, str or None)) or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rhr�rcrZ)rYrhrWrXr)r;rrrZ�
s	zImport.__init__)NNNN)rrr�r�r�rtrZr�rr)r;rrc�
srcc@s*eZdZdZdZdZddd�Zdd�ZdS)	�Indexz�Class representing an :class:`ast.Index` node.

    An :class:`Index` is a simple subscript.

    >>> node = astroid.extract_node('things[1]')
    >>> node
    <Subscript l.1 at 0x7f23b2e9e2b0>
    >>> node.slice
    <Index l.1 at 0x7f23b2e9e6a0>
    )r(NcCs
||_dS)z�Do some setup after initialisation.

        :param value: The value to subscript with.
        :type value: NodeNG or None
        N)r()rYr(rrrr��
szIndex.postinitccs|jVdS)N)r()rYrrrr��
szIndex.get_children)N)rrr�r�r�rer(r�r�rrrrrd�
s


rdcs@eZdZdZdZdZdZd�fdd�	Zddd�Zd	d
�Z	�Z
S)
�Keywordz�Class representing an :class:`ast.keyword` node.

    >>> node = astroid.extract_node('function(a_kwarg=True)')
    >>> node
    <Call l.1 at 0x7f23b2e9e320>
    >>> node.keywords
    [<Keyword l.1 at 0x7f23b2e9e9b0>]
    )r()rNcs||_tt|��|||�dS)a�
        :param arg: The argument being assigned to.
        :type arg: Name or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rr�rerZ)rYrrWrXr)r;rrrZ�
szKeyword.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param value: The value being assigned to the ketword argument.
        :type value: NodeNG or None
        N)r()rYr(rrrr��
szKeyword.postinitccs|jVdS)N)r()rYrrrr��
szKeyword.get_children)NNNN)N)rrr�r�r�rertr(rZr�r�r�rr)r;rre�
s
recs8eZdZdZdZd
�fdd�	Zdd�Zddd	�Z�ZS)rz�Class representing an :class:`ast.List` node.

    >>> node = astroid.extract_node('[1, 2, 3]')
    >>> node
    <List.list l.1 at 0x7f23b2e9e128>
    )�ctxNcs||_tt|��|||�dS)a�
        :param ctx: Whether the list is assigned to or loaded from.
        :type ctx: Context or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rfr�rrZ)rYrfrWrXr)r;rrrZ
sz
List.__init__cCsdtS)zyGet the name of the type that this node represents.

        :returns: The name of the type.
        :rtype: str
        z%s.list)rM)rYrrrr�!szList.pytypecCst||j||d�S)z�Get an item from this node.

        :param index: The node to use as a subscript index.
        :type index: Const or Slice
        )r)rAr)rYr-rrrrrB)szList.getitem)NNNN)N)	rrr�r�r�rtrZr�rBr�rr)r;rrs
rcs.eZdZdZdZd�fdd�	Zdd�Z�ZS)	�Nonlocala	Class representing an :class:`ast.Nonlocal` node.

    >>> node = astroid.extract_node('''
    def function():
        nonlocal var
    ''')
    >>> node
    <FunctionDef.function l.2 at 0x7f23b2e9e208>
    >>> node.body[0]
    <Nonlocal l.3 at 0x7f23b2e9e908>
    )rhNcs||_tt|��|||�dS)a�
        :param names: The names being declared as not local.
        :type names: list(str)

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rhr�rgrZ)rYrhrWrXr)r;rrrZAszNonlocal.__init__cCs|S)Nr)rYr�rcrrrr�XszNonlocal._infer_name)NNN)rrr�r�r�rtrZr�r�rr)r;rrg2srgc@seZdZdZdS)�Passz�Class representing an :class:`ast.Pass` node.

    >>> node = astroid.extract_node('pass')
    >>> node
    <Pass l.1 at 0x7f23b2e9e748>
    N)rrr�r�r�rrrrrh\srhcs8eZdZdZdZdZdZd�fdd�	Zd	dd�Z�Z	S)
�Printz�Class representing an :class:`ast.Print` node.

    >>> node = astroid.extract_node('print "A message"')
    >>> node
    <Print l.1 at 0x7f0e8101d290>
    )�destrNcs||_tt|��|||�dS)a�
        :param nl: Whether to print a new line.
        :type nl: bool or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)�nlr�rirZ)rYrkrWrXr)r;rrrZyszPrint.__init__cCs||_||_dS)z�Do some setup after initialisation.

        :param dest: Where to print to.
        :type dest: NodeNG or None

        :param values: What to print.
        :type values: list(NodeNG) or None
        N)rjr)rYrjrrrrr��s	zPrint.postinit)NNNN)NN)
rrr�r�r�rerjrrZr�r�rr)r;rriesric@s6eZdZdZdZdZdZd
dd�Zdd�Zdd	�Z	dS)�Raisez�Class representing an :class:`ast.Raise` node.

    >>> node = astroid.extract_node('raise RuntimeError("Something bad happened!")')
    >>> node
    <Raise l.1 at 0x7f23b2e9e828>
    N)r@�causecCs||_||_dS)z�Do some setup after initialisation.

        :param exc: What is being raised.
        :type exc: NodeNG or None

        :param cause: The exception being used to raise this one.
        :type cause: NodeNG or None
        N)r@rm)rYr@rmrrrr��s	zRaise.postinitcCs0|js
dSx |j��D]}|jdkrdSqWdS)z�Check if this node raises a :class:`NotImplementedError`.

        :returns: True if this node raises a :class:`NotImplementedError`,
            False otherwise.
        :rtype: bool
        Fr(T)r@r�rc)rYrcrrr�raises_not_implemented�s
zRaise.raises_not_implementedccs(|jdk	r|jV|jdk	r$|jVdS)N)r@rm)rYrrrr��s

zRaise.get_children)NN)
rrr�r�r�r@rermr�rnr�rrrrrl�s
rlc@s:eZdZdZdZdZddd�Zdd�Zdd	�Zd
d�Z	dS)
�Returnz�Class representing an :class:`ast.Return` node.

    >>> node = astroid.extract_node('return True')
    >>> node
    <Return l.1 at 0x7f23b8211908>
    )r(NcCs
||_dS)z�Do some setup after initialisation.

        :param value: The value being returned.
        :type value: NodeNG or None
        N)r()rYr(rrrr��szReturn.postinitccs|jdk	r|jVdS)N)r()rYrrrr��s
zReturn.get_childrencCst|jt�S)N)r
r(r)rYrrr�is_tuple_return�szReturn.is_tuple_returnccs
|VdS)Nr)rYrrrr��sz'Return._get_return_nodes_skip_functions)N)
rrr�r�r�rer(r�r�rpr�rrrrro�s
roc@seZdZdZdd�ZdS)�Setz�Class representing an :class:`ast.Set` node.

    >>> node = astroid.extract_node('{1, 2, 3}')
    >>> node
    <Set.set l.1 at 0x7f23b2e71d68>
    cCsdtS)zyGet the name of the type that this node represents.

        :returns: The name of the type.
        :rtype: str
        z%s.set)rM)rYrrrr��sz
Set.pytypeN)rrr�r�r�r�rrrrrq�srqc@sdeZdZdZdZdZdZdZddd�Zdd�Z	e
jdd	��Zd
d�Z
ddd
�Zddd�Zdd�ZdS)r:z�Class representing an :class:`ast.Slice` node.

    >>> node = astroid.extract_node('things[1:3]')
    >>> node
    <Subscript l.1 at 0x7f23b2e71f60>
    >>> node.slice
    <Slice l.1 at 0x7f23b2e71e80>
    )r3r4r5NcCs||_||_||_dS)a:Do some setup after initialisation.

        :param lower: The lower index in the slice.
        :value lower: NodeNG or None

        :param upper: The upper index in the slice.
        :value upper: NodeNG or None

        :param step: The step to take between index.
        :param step: NodeNG or None
        N)r3r4r5)rYr3r4r5rrrr�!szSlice.postinitcCs|st|�}||_|S|S)z7Wrap the empty attributes of the Slice in a Const node.)r�r)rYr��constrrr�_wrap_attribute1s
zSlice._wrap_attributecCstj}|�d�dS)Nr7r)r_Zbuiltins_modulerg)rY�builtinsrrrrD9szSlice._proxiedcCsdtS)zyGet the name of the type that this node represents.

        :returns: The name of the type.
        :rtype: str
        z%s.slice)rM)rYrrrr�>szSlice.pytypeccs`|dkr|�|j�VnD|dkr0|�|j�Vn,|dkrH|�|j�Vn|j||d�EdHdS)z�Infer the possible values of the given attribute on the slice.

        :param attrname: The name of the attribute to infer.
        :type attrname: str

        :returns: The inferred possible values.
        :rtype: iterable(NodeNG)
        �start�stopr5)rN)rsr3r4r5rg)rYrdrrrr�igetattrFs	zSlice.igetattrcCs|j�||�S)N)rDrg)rYrdrrrrrgXsz
Slice.getattrccs:|jdk	r|jV|jdk	r$|jV|jdk	r6|jVdS)N)r3r4r5)rYrrrr�[s


zSlice.get_children)NNN)N)N)rrr�r�r�rer3r4r5r�rsrr�rDr�rwrgr�rrrrr:s


r:cs@eZdZdZdZdZdZd�fdd�	Zddd�Zd	d
�Z	�Z
S)
r6z�Class representing an :class:`ast.Starred` node.

    >>> node = astroid.extract_node('*args')
    >>> node
    <Starred l.1 at 0x7f23b2e41978>
    )r()rfNcs ||_tt|�j|||d�dS)a�
        :param ctx: Whether the list is assigned to or loaded from.
        :type ctx: Context or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        )rWrXrN)rfr�r6rZ)rYrfrWrXr)r;rrrZvs
zStarred.__init__cCs
||_dS)zDo some setup after initialisation.

        :param value: What is being unpacked.
        :type value: NodeNG or None
        N)r()rYr(rrrr��szStarred.postinitccs|jVdS)N)r()rYrrrr��szStarred.get_children)NNNN)N)rrr�r�r�rertr(rZr�r�r�rr)r;rr6fs
r6csDeZdZdZdZdZdZdZd�fdd�	Zddd�Z	d	d
�Z
�ZS)
�	Subscriptz�Class representing an :class:`ast.Subscript` node.

    >>> node = astroid.extract_node('things[1:3]')
    >>> node
    <Subscript l.1 at 0x7f23b2e71f60>
    )r(r7)rfNcs ||_tt|�j|||d�dS)a�
        :param ctx: Whether the subscripted item is assigned to or loaded from.
        :type ctx: Context or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        )rWrXrN)rfr�rxrZ)rYrfrWrXr)r;rrrZ�s
zSubscript.__init__cCs||_||_dS)z�Do some setup after initialisation.

        :param value: What is being indexed.
        :type value: NodeNG or None

        :param slice: The slice being used to lookup.
        :type slice: NodeNG or None
        N)r(r7)rYr(r7rrrr��s	zSubscript.postinitccs|jV|jVdS)N)r(r7)rYrrrr��szSubscript.get_children)NNNN)NN)rrr�r�r�rertr(r7rZr�r�r�rr)r;rrx�s
rxc@sFeZdZdZdZdZdZdZdZddd�Z	dd�Z
dd	�Zd
d�ZdS)
r"aClass representing an :class:`ast.TryExcept` node.

    >>> node = astroid.extract_node('''
        try:
            do_something()
        except Exception as error:
            print("Error!")
        ''')
    >>> node
    <TryExcept l.2 at 0x7f23b2e9d908>
    )rrrNcCs||_||_||_dS)alDo some setup after initialisation.

        :param body: The contents of the block to catch exceptions from.
        :type body: list(NodeNG) or None

        :param handlers: The exception handlers.
        :type handlers: list(ExceptHandler) or None

        :param orelse: The contents of the ``else`` block.
        :type orelse: list(NodeNG) or None
        N)rrr)rYrrrrrrr��szTryExcept.postinitcCs|S)Nr)rYr�rcrrrr�
szTryExcept._infer_namecCs�d}xx|jD]n}|jr*||jjkr*||fS|jdj|krN|jdjkrbnn||jdjfS|dkr|jdjd}qW|�||j|�S)a8Get 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)
        Nrr�r)rr*r�rr�rar)rYrW�lastZ	exhandlerrrrr�
s
(zTryExcept.block_rangeccs0|jEdH|jpdEdH|jp$dEdHdS)Nr)rrr)rYrrrr�!szTryExcept.get_children)NNN)
rrr�r�r�rerTrrrr�r�r�r�rrrrr"�s
r"c@s:eZdZdZdZdZdZdZd
dd�Zdd�Z	dd	�Z
dS)�
TryFinallyaClass representing an :class:`ast.TryFinally` node.

    >>> node = astroid.extract_node('''
    try:
        do_something()
    except Exception as error:
        print("Error!")
    finally:
        print("Cleanup!")
    ''')
    >>> node
    <TryFinally l.2 at 0x7f23b2e41d68>
    )r�	finalbodyNcCs||_||_dS)aDo some setup after initialisation.

        :param body: The try-except that the finally is attached to.
        :type body: list(TryExcept) or None

        :param finalbody: The contents of the ``finally`` block.
        :type finalbody: list(NodeNG) or None
        N)rr{)rYrr{rrrr�Ds	zTryFinally.postinitcCsT|jd}t|t�rF|j|jkrF|j|kr8|jkrFnn
|�|�S|�||j�S)a8Get 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)
        r)rr
r"r�r�r�rar{)rYrWr�rrrr�Ps



zTryFinally.block_rangeccs|jEdH|jEdHdS)N)rr{)rYrrrr�dszTryFinally.get_children)NN)rrr�r�r�rerTrr{r�r�r�rrrrrz(s

rzcs8eZdZdZdZd
�fdd�	Zdd�Zddd	�Z�ZS)rz�Class representing an :class:`ast.Tuple` node.

    >>> node = astroid.extract_node('(1, 2, 3)')
    >>> node
    <Tuple.tuple l.1 at 0x7f23b2e41780>
    )rfNcs||_tt|��|||�dS)a�
        :param ctx: Whether the tuple is assigned to or loaded from.
        :type ctx: Context or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rfr�rrZ)rYrfrWrXr)r;rrrZsszTuple.__init__cCsdtS)zyGet the name of the type that this node represents.

        :returns: The name of the type.
        :rtype: str
        z%s.tuple)rM)rYrrrr��szTuple.pytypecCst||j||d�S)z�Get an item from this node.

        :param index: The node to use as a subscript index.
        :type index: Const or Slice
        )r)rAr)rYr-rrrrrB�sz
Tuple.getitem)NNNN)N)	rrr�r�r�rtrZr�rBr�rr)r;rris
rcs`eZdZdZdZdZdZd�fdd�	Zddd�Zdd	d
�Z	ddd�Z
d
d�Z�fdd�Z�Z
S)rTz�Class representing an :class:`ast.UnaryOp` node.

    >>> node = astroid.extract_node('-5')
    >>> node
    <UnaryOp l.1 at 0x7f23b2e4e198>
    )�operand)rDNcs||_tt|��|||�dS)a�
        :param op: The operator.
        :type: str or None

        :param lineno: The line that this node appears on in the source code.
        :type lineno: int or None

        :param col_offset: The column that this node appears on in the
            source code.
        :type col_offset: int or None

        :param parent: The parent node in the syntax tree.
        :type parent: NodeNG or None
        N)rDr�rTrZ)rYrDrWrXr)r;rrrZ�szUnaryOp.__init__cCs
||_dS)z�Do some setup after initialisation.

        :param operand: What the unary operator is applied to.
        :type operand: NodeNG or None
        N)r|)rYr|rrrr��szUnaryOp.postinitcCst�dS)N)r()rYrrrr�_infer_unaryop�szUnaryOp._infer_unaryopcCs6y|j|d�}dd�|D�Stjk
r0gSXdS)a%Get a list of type errors which can occur during inference.

        Each TypeError is represented by a :class:`BadBinaryOperationMessage`,
        which holds the original exception.

        :returns: The list of possible type errors.
        :rtype: list(BadBinaryOperationMessage)
        )rcSsg|]}t|tj�r|�qSr)r
rZBadUnaryOperationMessage)r/r|rrrr��sz'UnaryOp.type_errors.<locals>.<listcomp>N)r}rr+)rYrr+rrrr,�s	zUnaryOp.type_errorsccs|jVdS)N)r|)rYrrrr��szUnaryOp.get_childrencs|jdkrt|jSt���S)NrI)rDr�r�r�)rY)r;rrr��s

zUnaryOp.op_precedence)NNNN)N)N)N)rrr�r�r�rertr|rZr�r}r,r�r�r�rr)r;rrT�s
	

c@sLeZdZdZdZdZdZdZdZd
dd�Z	e
jdd��Zd	d
�Z
dd�ZdS)�Whilez�Class representing an :class:`ast.While` node.

    >>> node = astroid.extract_node('''
    while condition():
        print("True")
    ''')
    >>> node
    <While l.2 at 0x7f23b2e4e390>
    )rrr)rrNcCs||_||_||_dS)aHDo some setup after initialisation.

        :param test: The condition that the loop tests.
        :type test: NodeNG or None

        :param body: The contents of the loop.
        :type body: list(NodeNG) or None

        :param orelse: The contents of the ``else`` block.
        :type orelse: list(NodeNG) or None
        N)rrr)rYrrrrrrr�szWhile.postinitcCs|jjS)zPThe line on which the beginning of this block ends.

        :type: int
        )rr�)rYrrrrSszWhile.blockstart_tolinenocCs|�||j�S)a8Get 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)
        )rar)rYrWrrrr� s
zWhile.block_rangeccs$|jV|jEdH|jEdHdS)N)rrr)rYrrrr�,szWhile.get_children)NNN)rrr�r�r�rerTrrrr�rr�rSr�r�rrrrr~�s	
r~c@sHeZdZdZdZdZdZdZdZdZ	ddd�Z
ejdd	��Z
d
d�ZdS)
�Withz�Class representing an :class:`ast.With` node.

    >>> node = astroid.extract_node('''
    with open(file_path) as file_:
        print(file_.read())
    ''')
    >>> node
    <With l.2 at 0x7f23b2e4e710>
    )rJr)r#)rNcCs||_||_||_dS)a9Do some setup after initialisation.

        :param items: The pairs of context managers and the names
            they are assigned to.
        :type items: list(tuple(NodeNG, AssignName or None)) or None

        :param body: The contents of the ``with`` block.
        :type body: list(NodeNG) or None
        N)rJrr#)rYrJrr#rrrr�Vs
z
With.postinitcCs|jddjS)zPThe line on which the beginning of this block ends.

        :type: int
        r�r)rJr�)rYrrrrSdszWith.blockstart_tolinenoccs4x"|jD]\}}|V|r|VqW|jEdHdS)zoGet the child nodes below this node.

        :returns: The children.
        :rtype: iterable(NodeNG)
        N)rJr)rYr�varrrrr�ls

zWith.get_children)NNN)rrr�r�r�rer�rTrJrr#r�rr�rSr�rrrrr3s
rc@seZdZdZdS)�	AsyncWithz7Asynchronous ``with`` built with the ``async`` keyword.N)rrr�r�r�rrrrr�ysr�c@s2eZdZdZdZdZd
dd�Zdd�Zdd	�ZdS)�Yieldz�Class representing an :class:`ast.Yield` node.

    >>> node = astroid.extract_node('yield True')
    >>> node
    <Yield l.1 at 0x7f23b2e4e5f8>
    )r(NcCs
||_dS)z{Do some setup after initialisation.

        :param value: The value to yield.
        :type value: NodeNG or None
        N)r()rYr(rrrr��szYield.postinitccs|jdk	r|jVdS)N)r()rYrrrr��s
zYield.get_childrenccs
|VdS)Nr)rYrrrr��sz#Yield._get_yield_nodes_skip_lambdas)N)	rrr�r�r�rer(r�r�r�rrrrr�}s
r�c@seZdZdZdS)�	YieldFromz2Class representing an :class:`ast.YieldFrom` node.N)rrr�r�r�rrrrr��sr�c@seZdZdZdS)rNz>Represents the unpacking of dicts into dicts using :pep:`448`.N)rrr�r�r�rrrrrN�srNc@s2eZdZdZdZdZdZdZddd�Zdd�Z	dS)	�FormattedValuea9Class representing an :class:`ast.FormattedValue` node.

    Represents a :pep:`498` format string.

    >>> node = astroid.extract_node('f"Format {type_}"')
    >>> node
    <JoinedStr l.1 at 0x7f23b2e4ed30>
    >>> node.values
    [<Const.str l.1 at 0x7f23b2e4eda0>, <FormattedValue l.1 at 0x7f23b2e4edd8>]
    )r(�format_specNcCs||_||_||_dS)atDo some setup after initialisation.

        :param value: The value to be formatted into the string.
        :type value: NodeNG

        :param conversion: The type of formatting to be applied to the value.
        :type conversion: int or None

        :param format_spec: The formatting to be applied to the value.
        :type format_spec: JoinedStr or None
        N)r(�
conversionr�)rYr(r�r�rrrr��szFormattedValue.postinitccs|jV|jdk	r|jVdS)N)r(r�)rYrrrr��s
zFormattedValue.get_children)NN)
rrr�r�r�rer(r�r�r�r�rrrrr��s
	
r�c@s*eZdZdZdZdZddd�Zdd�ZdS)	�	JoinedStrz�Represents a list of string expressions to be joined.

    >>> node = astroid.extract_node('f"Format {type_}"')
    >>> node
    <JoinedStr l.1 at 0x7f23b2e4ed30>
    )rNcCs
||_dS)z�Do some setup after initialisation.

        :param value: The string expressions to be joined.

        :type: list(FormattedValue or Const) or None
        N)r)rYrrrrr��szJoinedStr.postinitccs|jEdHdS)N)r)rYrrrr��szJoinedStr.get_children)N)rrr�r�r�rerr�r�rrrrr��s

	r�c@s&eZdZdZdZdd�Zddd�ZdS)�Unknownz�This node represents a node in a constructed AST where
    introspection is not possible.  At the moment, it's only used in
    the args attribute of FunctionDef nodes where function signature
    introspection failed.
    cCsdS)Nr�r)rYrrrr�sz
Unknown.qnameNckstjVdS)z4Inference on an Unknown node immediately terminates.N)rr)rYrr`rrrrsz
Unknown.infer)N)rrr�r�r�rcr�rrrrrr��sr�cCs*ttttttf}x|D]}tt|<qWdS)z?update constant classes, so the keys of CONST_CLS can be reusedN)r�r)�float�complexr@rAr'�	CONST_CLS)ZklassesZklsrrr�_update_const_classess
r�cCs|�}|�|�|S)N)r�)r�r(r?rrr�_two_step_initialization!s
r�cCs t|t�rt|���}t||�S)N)r
rr�rJr�)r�r(rrr�_dict_initialization's
r�cCs||�S)Nr)r�r(rrr�<lambda>2�r�c	Cspt|t�rt�t|ttttf�r&g}n|}yt|j}t	|}|||�St
tfk
rjt�}||_
|SXdS)z)return an astroid node for a python valueN)r
rVr�r�r�r�rr�r;�_CONST_CLS_CONSTRUCTORS�KeyErrorr=rQrR)r(rZinitializer_clsZinitializerrrrrr�6s

r�cCs,|j}x |dk	r&t|t�rdS|j}qWdS)z9Return True if the given node is the child of a decoratorNTF)rr
rF)rrrrrr�Rs


r�)N)N)N)N)N)F)NN){r�r�rtZbuiltins_modrru�	functoolsrrr��astroidrrrr�rrr	r
rrrrMZAstroidManagerr_Zraise_if_nothing_inferredrr&rRr,r.r9rArr�rVr�ZParentAssignTypeMixinZInstance�ABCMetar�r�ZNoChildrenMixinr�r�r�ZAssignTypeMixinr�rr	rrr!r$r'r-r.r2r3r4rJr:r'rErFrGrHrIrOrPrQZMultiLineBlockMixinr�rUrWZBlockRangeMixInrYrZrUZImportFromMixinr[r_r`r rFrcrdrerrgrhrirlrorqr:r6rxr"rzrrTr~rr�r�r�rNr�r�r�r�r�rr�r*�NotImplementedr�r�r�r�r�r�r�rrrr�<module>s"
L


?#
OF
*
'/

7)7>Y]8	E>e}	-5$Y+
V$>.%L4%52*	86"`5@MA2PH
B: