"""recursively generate nodes inferred by the given statement.

if isinstance(stmt, (List, Tuple)):

for elt in stmt.elts:

if elt is util.Uninferable:

yield elt

continue

for inferred_elt in unpack_infer(elt, context):

yield inferred_elt

# Explicit StopIteration to return error information, see comment

# in raise_if_nothing_inferred.

raise StopIteration(dict(node=stmt, context=context))

# if inferred is a final node, return it and stop

inferred = next(stmt.infer(context))

if inferred is stmt:

yield inferred

# Explicit StopIteration to return error information, see comment

# in raise_if_nothing_inferred.

raise StopIteration(dict(node=stmt, context=context))

# else, infer recursively, except Uninferable object that should be returned as is

for inferred in stmt.infer(context):

if inferred is util.Uninferable:

yield inferred

else:

for inf_inf in unpack_infer(inferred, context):

yield inf_inf

"""return true if the two given statements are mutually exclusive

# index stmt1's parents

stmt1_parents = {}

children = {}

node = stmt1.parent

previous = stmt1

while node:

stmt1_parents[node] = 1

children[node] = previous

previous = node

node = node.parent

# climb among stmt2's parents until we find a common parent

node = stmt2.parent

previous = stmt2

while node:

if node in stmt1_parents:

# if the common parent is a If or TryExcept statement, look if

# nodes are in exclusive branches

if isinstance(node, If) and exceptions is None:

if (node.locate_child(previous)[1]

is not node.locate_child(children[node])[1]):

return True

elif isinstance(node, TryExcept):

c2attr, c2node = node.locate_child(previous)

c1attr, c1node = node.locate_child(children[node])

if c1node is not c2node:

first_in_body_caught_by_handlers = (

c2attr == 'handlers'

and c1attr == 'body'

and previous.catch(exceptions))

second_in_body_caught_by_handlers = (

c2attr == 'body'

and c1attr == 'handlers'

and children[node].catch(exceptions))

first_in_else_other_in_handlers = (

c2attr == 'handlers' and c1attr == 'orelse')

second_in_else_other_in_handlers = (

c2attr == 'orelse' and c1attr == 'handlers')

if any((first_in_body_caught_by_handlers,

second_in_body_caught_by_handlers,

first_in_else_other_in_handlers,

second_in_else_other_in_handlers)):

return True

elif c2attr == 'handlers' and c1attr == 'handlers':

return previous is not children[node]

return False

previous = node

node = node.parent

"""Get the value of the given slice index."""

if isinstance(index, Const):

if isinstance(index.value, (int, type(None))):

return index.value

elif index is None:

return None

else:

# Try to infer what the index actually is.

# Since we can't return all the possible values,

# we'll stop at the first possible value.

try:

inferred = next(index.infer(context=context))

except exceptions.InferenceError:

pass

else:

if isinstance(inferred, Const):

if isinstance(inferred.value, (int, type(None))):

return inferred.value

# Use a sentinel, because None can be a valid

# value that this function can return,

# as it is the case for unspecified bounds.

lower = _slice_value(node.lower, context)

upper = _slice_value(node.upper, context)

step = _slice_value(node.step, context)

if all(elem is not _SLICE_SENTINEL for elem in (lower, upper, step)):

return slice(lower, upper, step)

raise exceptions.AstroidTypeError(

message='Could not infer slice used in subscript',

"""Get a slice or an item, using the given *index*, for the given sequence."""

try:

if isinstance(index, Slice):

index_slice = _infer_slice(index, context=context)

new_cls = instance.__class__()

new_cls.elts = elts[index_slice]

new_cls.parent = instance.parent

return new_cls

elif isinstance(index, Const):

return elts[index.value]

except IndexError:

util.reraise(exceptions.AstroidIndexError(

message='Index {index!s} out of range',

node=instance, index=index, context=context))

except TypeError as exc:

util.reraise(exceptions.AstroidTypeError(

message='Type error {error!r}', error=exc,

node=instance, index=index, context=context))

raise exceptions.AstroidTypeError(

'Could not use %s as subscript index' % index

"""Base Class for all Astroid node classes.

is_statement = False

optional_assign = False # True for For (and for Comprehension if py <3.0)

is_function = False # True for FunctionDef nodes

# attributes below are set by the builder module or by raw factories

lineno = None

col_offset = None

# parent node in the tree

parent = None

# attributes containing child node(s) redefined in most concrete classes:

_astroid_fields = ()

# attributes containing non-nodes:

_other_fields = ()

# attributes containing AST-dependent fields:

_other_other_fields = ()

# instance specific inference function infer(node, context)

_explicit_inference = None

def __init__(self, lineno=None, col_offset=None, parent=None):

self.lineno = lineno

self.col_offset = col_offset

self.parent = parent

def infer(self, context=None, **kwargs):

"""main interface to the interface system, return a generator on inferred

if self._explicit_inference is not None:

# explicit_inference is not bound, give it self explicitly

try:

# pylint: disable=not-callable

return self._explicit_inference(self, context, **kwargs)

except exceptions.UseInferenceDefault:

pass

if not context:

return self._infer(context, **kwargs)

key = (self, context.lookupname,

context.callcontext, context.boundnode)

if key in context.inferred:

return iter(context.inferred[key])

return context.cache_generator(key, self._infer(context, **kwargs))

def _repr_name(self):

"""return self.name or self.attrname or '' for nice representation"""

return getattr(self, 'name', getattr(self, 'attrname', ''))

def __str__(self):

rname = self._repr_name()

cname = type(self).__name__

if rname:

string = '%(cname)s.%(rname)s(%(fields)s)'

alignment = len(cname) + len(rname) + 2

else:

string = '%(cname)s(%(fields)s)'

alignment = len(cname) + 1

result = []

for field in self._other_fields + self._astroid_fields:

value = getattr(self, field)

width = 80 - len(field) - alignment

lines = pprint.pformat(value, indent=2,

width=width).splitlines(True)

inner = [lines[0]]

for line in lines[1:]:

inner.append(' ' * alignment + line)

result.append('%s=%s' % (field, ''.join(inner)))

return string % {'cname': cname,

'rname': rname,

'fields': (',\n' + ' ' * alignment).join(result)}

def __repr__(self):

rname = self._repr_name()

if rname:

string = '<%(cname)s.%(rname)s l.%(lineno)s at 0x%(id)x>'

else:

string = '<%(cname)s l.%(lineno)s at 0x%(id)x>'

return string % {'cname': type(self).__name__,

'rname': rname,

'lineno': self.fromlineno,

'id': id(self)}

def accept(self, visitor):

func = getattr(visitor, "visit_" + self.__class__.__name__.lower())

return func(self)

def get_children(self):

for field in self._astroid_fields:

attr = getattr(self, field)

if attr is None:

continue

if isinstance(attr, (list, tuple)):

for elt in attr:

yield elt

else:

yield attr

def last_child(self):

"""an optimized version of list(get_children())[-1]"""

for field in self._astroid_fields[::-1]:

attr = getattr(self, field)

if not attr: # None or empty listy / tuple

continue

if isinstance(attr, (list, tuple)):

return attr[-1]

return attr

return None

def parent_of(self, node):

"""return true if i'm a parent of the given node"""

parent = node.parent

while parent is not None:

if self is parent:

return True

parent = parent.parent

return False

def statement(self):

"""return the first parent node marked as statement node"""

if self.is_statement:

return self

return self.parent.statement()

def frame(self):

"""return the first parent frame node (i.e. Module, FunctionDef or

return self.parent.frame()

def scope(self):

"""return the first node defining a new scope (i.e. Module,

return self.parent.scope()

def root(self):

"""return the root node of the tree, (i.e. a Module)"""

if self.parent:

return self.parent.root()

return self

def child_sequence(self, child):

"""search for the right sequence where the child lies in"""

for field in self._astroid_fields:

node_or_sequence = getattr(self, field)

if node_or_sequence is child:

return [node_or_sequence]

# /!\ compiler.ast Nodes have an __iter__ walking over child nodes

if (isinstance(node_or_sequence, (tuple, list))

and child in node_or_sequence):

return node_or_sequence

msg = 'Could not find %s in %s\'s children'

raise exceptions.AstroidError(msg % (repr(child), repr(self)))

def locate_child(self, child):

"""return a 2-uple (child attribute name, sequence or node)"""

for field in self._astroid_fields:

node_or_sequence = getattr(self, field)

# /!\ compiler.ast Nodes have an __iter__ walking over child nodes

if child is node_or_sequence:

return field, child

if isinstance(node_or_sequence, (tuple, list)) and child in node_or_sequence:

return field, node_or_sequence

msg = 'Could not find %s in %s\'s children'

raise exceptions.AstroidError(msg % (repr(child), repr(self)))

# FIXME : should we merge child_sequence and locate_child ? locate_child

# is only used in are_exclusive, child_sequence one time in pylint.

def next_sibling(self):

"""return the next sibling statement"""

return self.parent.next_sibling()

def previous_sibling(self):

"""return the previous sibling statement"""

return self.parent.previous_sibling()

def nearest(self, nodes):

"""return the node which is the nearest before this one in the

myroot = self.root()

mylineno = self.fromlineno

nearest = None, 0

for node in nodes:

assert node.root() is myroot, \

'nodes %s and %s are not from the same module' % (self, node)

lineno = node.fromlineno

if node.fromlineno > mylineno:

break

if lineno > nearest[1]:

nearest = node, lineno

# FIXME: raise an exception if nearest is None ?

return nearest[0]

# these are lazy because they're relatively expensive to compute for every

# single node, and they rarely get looked at

@decorators.cachedproperty

def fromlineno(self):

if self.lineno is None:

return self._fixed_source_line()

return self.lineno

@decorators.cachedproperty

def tolineno(self):

if not self._astroid_fields:

# can't have children

lastchild = None

else:

lastchild = self.last_child()

if lastchild is None:

return self.fromlineno

return lastchild.tolineno

def _fixed_source_line(self):

"""return the line number where the given node appears

line = self.lineno

_node = self

try:

while line is None:

_node = next(_node.get_children())

line = _node.lineno

except StopIteration:

_node = self.parent

while _node and line is None:

line = _node.lineno

_node = _node.parent

return line

def block_range(self, lineno):

"""handle block line numbers range for non block opening statements

return lineno, self.tolineno

def set_local(self, name, stmt):

"""delegate to a scoped parent handling a locals dictionary"""

self.parent.set_local(name, stmt)

def nodes_of_class(self, klass, skip_klass=None):

"""return an iterator on nodes which are instance of the given class(es)

if isinstance(self, klass):

yield self

for child_node in self.get_children():

if skip_klass is not None and isinstance(child_node, skip_klass):

continue

for matching in child_node.nodes_of_class(klass, skip_klass):

yield matching

def _infer_name(self, frame, name):

# overridden for ImportFrom, Import, Global, TryExcept and Arguments

return None

def _infer(self, context=None):

"""we don't know how to resolve a statement by default"""

# this method is overridden by most concrete classes

raise exceptions.InferenceError('No inference function for {node!r}.',

node=self, context=context)

def inferred(self):

'''return list of inferred values for a more simple inference usage'''

return list(self.infer())

def infered(self):

warnings.warn('%s.infered() is deprecated and slated for removal '

'in astroid 2.0, use %s.inferred() instead.'

% (type(self).__name__, type(self).__name__),

PendingDeprecationWarning, stacklevel=2)

return self.inferred()

def instantiate_class(self):

"""instantiate a node if it is a ClassDef node, else return self"""

return self

def has_base(self, node):

return False

def callable(self):

return False

def eq(self, value):

return False

def as_string(self):

return as_string.to_code(self)

def repr_tree(self, ids=False, include_linenos=False,

ast_state=False, indent=' ', max_depth=0, max_width=80):

"""Returns a string representation of the AST from this node.

@_singledispatch

def _repr_tree(node, result, done, cur_indent='', depth=1):

"""Outputs a representation of a non-tuple/list, non-node that's

lines = pprint.pformat(node,

width=max(max_width - len(cur_indent),

1)).splitlines(True)

result.append(lines[0])

result.extend([cur_indent + line for line in lines[1:]])

return len(lines) != 1

# pylint: disable=unused-variable; doesn't understand singledispatch

@_repr_tree.register(tuple)

@_repr_tree.register(list)

def _repr_seq(node, result, done, cur_indent='', depth=1):

"""Outputs a representation of a sequence that's contained within an AST."""

cur_indent += indent

result.append('[')

if not node:

broken = False

elif len(node) == 1:

broken = _repr_tree(node[0], result, done, cur_indent, depth)

elif len(node) == 2:

broken = _repr_tree(node[0], result, done, cur_indent, depth)

if not broken:

result.append(', ')

else:

result.append(',\n')

result.append(cur_indent)

broken = (_repr_tree(node[1], result, done, cur_indent, depth)

or broken)

else:

result.append('\n')

result.append(cur_indent)

for child in node[:-1]:

_repr_tree(child, result, done, cur_indent, depth)

result.append(',\n')

result.append(cur_indent)

_repr_tree(node[-1], result, done, cur_indent, depth)

broken = True

result.append(']')

return broken

# pylint: disable=unused-variable; doesn't understand singledispatch

@_repr_tree.register(NodeNG)

def _repr_node(node, result, done, cur_indent='', depth=1):

"""Outputs a strings representation of an astroid node."""

if node in done:

result.append(indent + '<Recursion on %s with id=%s' %

(type(node).__name__, id(node)))

return False

else:

done.add(node)

if max_depth and depth > max_depth:

result.append('...')

return False

depth += 1

cur_indent += indent

if ids:

result.append('%s<0x%x>(\n' % (type(node).__name__, id(node)))

else:

result.append('%s(' % type(node).__name__)

fields = []

if include_linenos:

fields.extend(('lineno', 'col_offset'))

fields.extend(node._other_fields)

fields.extend(node._astroid_fields)

if ast_state:

fields.extend(node._other_other_fields)

if not fields:

broken = False

elif len(fields) == 1:

result.append('%s=' % fields[0])

broken = _repr_tree(getattr(node, fields[0]), result, done,

cur_indent, depth)

else:

result.append('\n')

result.append(cur_indent)

for field in fields[:-1]:

result.append('%s=' % field)

_repr_tree(getattr(node, field), result, done, cur_indent,

depth)

result.append(',\n')

result.append(cur_indent)

result.append('%s=' % fields[-1])

_repr_tree(getattr(node, fields[-1]), result, done, cur_indent,

depth)

broken = True

result.append(')')

return broken

result = []

_repr_tree(self, result, set())

return ''.join(result)

def bool_value(self):

"""Determine the bool value of this node

"""Statement node adding a few attributes"""

is_statement = True

def next_sibling(self):

"""return the next sibling statement"""

stmts = self.parent.child_sequence(self)

index = stmts.index(self)

try:

return stmts[index +1]

except IndexError:

pass

def previous_sibling(self):

"""return the previous sibling statement"""

stmts = self.parent.child_sequence(self)

index = stmts.index(self)

if index >= 1:

NodeNG, bases.Instance):

"""Base class for Set, FrozenSet, Tuple and List."""

_astroid_fields = ('elts',)

def __init__(self, lineno=None, col_offset=None, parent=None):

self.elts = []

super(_BaseContainer, self).__init__(lineno, col_offset, parent)

def postinit(self, elts):

self.elts = elts

@classmethod

def from_constants(cls, elts=None):

node = cls()

if elts is None:

node.elts = []

else:

node.elts = [const_factory(e) for e in elts]

return node

def itered(self):

return self.elts

def bool_value(self):

return bool(self.elts)

@abc.abstractmethod

def pytype(self):

"""Mixin looking up a name in the right scope

def lookup(self, name):

"""lookup a variable name

return self.scope().scope_lookup(self, name)

def ilookup(self, name):

"""inferred lookup

frame, stmts = self.lookup(name)

context = contextmod.InferenceContext()

return bases._infer_stmts(stmts, context, frame)

def _filter_stmts(self, stmts, frame, offset):

"""filter statements to remove ignorable statements.

# if offset == -1, my actual frame is not the inner frame but its parent

#

# class A(B): pass

#

# we need this to resolve B correctly

if offset == -1:

myframe = self.frame().parent.frame()

else:

myframe = self.frame()

# If the frame of this node is the same as the statement

# of this node, then the node is part of a class or

# a function definition and the frame of this node should be the

# the upper frame, not the frame of the definition.

# For more information why this is important,

# see Pylint issue #295.

# For example, for 'b', the statement is the same

# as the frame / scope:

#

# def test(b=1):

# ...

if self.statement() is myframe and myframe.parent:

myframe = myframe.parent.frame()

mystmt = self.statement()

# line filtering if we are in the same frame

#

# take care node may be missing lineno information (this is the case for

# nodes inserted for living objects)

if myframe is frame and mystmt.fromlineno is not None:

assert mystmt.fromlineno is not None, mystmt

mylineno = mystmt.fromlineno + offset

else:

# disabling lineno filtering

mylineno = 0

_stmts = []

_stmt_parents = []

for node in stmts:

stmt = node.statement()

# line filtering is on and we have reached our location, break

if mylineno > 0 and stmt.fromlineno > mylineno:

break

assert hasattr(node, 'assign_type'), (node, node.scope(),

node.scope().locals)

assign_type = node.assign_type()

if node.has_base(self):

break

_stmts, done = assign_type._get_filtered_stmts(self, node, _stmts, mystmt)

if done:

break

optional_assign = assign_type.optional_assign

if optional_assign and assign_type.parent_of(self):

# we are inside a loop, loop var assignment is hiding previous

# assignment

_stmts = [node]

_stmt_parents = [stmt.parent]

continue

# XXX comment various branches below!!!

try:

pindex = _stmt_parents.index(stmt.parent)

except ValueError:

pass

else:

# we got a parent index, this means the currently visited node

# is at the same block level as a previously visited node

if _stmts[pindex].assign_type().parent_of(assign_type):

# both statements are not at the same block level

continue

# if currently visited node is following previously considered

# assignment and both are not exclusive, we can drop the

# previous one. For instance in the following code ::

#

# if a:

# x = 1

# else:

# x = 2

# print x

#

# we can't remove neither x = 1 nor x = 2 when looking for 'x'

# of 'print x'; while in the following ::

#

# x = 1

# x = 2

# print x

#

# we can remove x = 1 when we see x = 2

#

# moreover, on loop assignment types, assignment won't

# necessarily be done if the loop has no iteration, so we don't

# want to clear previous assignments if any (hence the test on

# optional_assign)

if not (optional_assign or are_exclusive(_stmts[pindex], node)):

del _stmt_parents[pindex]

del _stmts[pindex]

if isinstance(node, AssignName):

if not optional_assign and stmt.parent is mystmt.parent:

_stmts = []

_stmt_parents = []

elif isinstance(node, DelName):

_stmts = []

_stmt_parents = []

continue

if not are_exclusive(self, node):

_stmts.append(node)

_stmt_parents.append(stmt.parent)

"""class representing an AssignName node"""

_other_fields = ('name',)

def __init__(self, name=None, lineno=None, col_offset=None, parent=None):

self.name = name

"""class representing a DelName node"""

_other_fields = ('name',)

def __init__(self, name=None, lineno=None, col_offset=None, parent=None):

self.name = name

"""class representing a Name node"""

_other_fields = ('name',)

def __init__(self, name=None, lineno=None, col_offset=None, parent=None):

self.name = name

"""class representing an Arguments node"""

if six.PY3:

# Python 3.4+ uses a different approach regarding annotations,

# each argument is a new class, _ast.arg, which exposes an

# 'annotation' attribute. In astroid though, arguments are exposed

# as is in the Arguments node and the only way to expose annotations

# is by using something similar with Python 3.3:

# - we expose 'varargannotation' and 'kwargannotation' of annotations

# of varargs and kwargs.

# - we expose 'annotation', a list with annotations for

# for each normal argument. If an argument doesn't have an

# annotation, its value will be None.

_astroid_fields = ('args', 'defaults', 'kwonlyargs',

'kw_defaults', 'annotations', 'varargannotation',

'kwargannotation', 'kwonlyargs_annotations')

varargannotation = None

kwargannotation = None

else:

_astroid_fields = ('args', 'defaults', 'kwonlyargs', 'kw_defaults')

_other_fields = ('vararg', 'kwarg')

def __init__(self, vararg=None, kwarg=None, parent=None):

super(Arguments, self).__init__(parent=parent)

self.vararg = vararg

self.kwarg = kwarg

self.args = []

self.defaults = []

self.kwonlyargs = []

self.kw_defaults = []

self.annotations = []

self.kwonlyargs_annotations = []

def postinit(self, args, defaults, kwonlyargs, kw_defaults,

annotations,

kwonlyargs_annotations=None,

varargannotation=None,

kwargannotation=None):

self.args = args

self.defaults = defaults

self.kwonlyargs = kwonlyargs

self.kw_defaults = kw_defaults

self.annotations = annotations

self.kwonlyargs_annotations = kwonlyargs_annotations

self.varargannotation = varargannotation

self.kwargannotation = kwargannotation

def _infer_name(self, frame, name):

if self.parent is frame:

return name

return None

@decorators.cachedproperty

def fromlineno(self):

lineno = super(Arguments, self).fromlineno

return max(lineno, self.parent.fromlineno or 0)

def format_args(self):

"""return arguments formatted as string"""

result = []

if self.args:

result.append(

_format_args(self.args, self.defaults,

getattr(self, 'annotations', None))

)

if self.vararg:

result.append('*%s' % self.vararg)

if self.kwonlyargs:

if not self.vararg:

result.append('*')

result.append(_format_args(

self.kwonlyargs,

self.kw_defaults,

self.kwonlyargs_annotations

))

if self.kwarg:

result.append('**%s' % self.kwarg)

return ', '.join(result)

def default_value(self, argname):

"""return the default value for an argument

i = _find_arg(argname, self.args)[0]

if i is not None:

idx = i - (len(self.args) - len(self.defaults))

if idx >= 0:

return self.defaults[idx]

i = _find_arg(argname, self.kwonlyargs)[0]

if i is not None and self.kw_defaults[i] is not None:

return self.kw_defaults[i]

raise exceptions.NoDefault(func=self.parent, name=argname)

def is_argument(self, name):

"""return True if the name is defined in arguments"""

if name == self.vararg:

return True

if name == self.kwarg:

return True

return (self.find_argname(name, True)[1] is not None or

self.kwonlyargs and _find_arg(name, self.kwonlyargs, True)[1] is not None)

def find_argname(self, argname, rec=False):

"""return index and Name node with given name"""

if self.args: # self.args may be None in some cases (builtin function)

return _find_arg(argname, self.args, rec)

return None, None

def get_children(self):

"""override get_children to skip over None elements in kw_defaults"""

for child in super(Arguments, self).get_children():

if child is not None:

for i, arg in enumerate(args):

if isinstance(arg, Tuple):

if rec:

found = _find_arg(argname, arg.elts)

if found[0] is not None:

return found

elif arg.name == argname:

return i, arg