# Copyright (c) 2009-2011, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>

# Copyright (c) 2013-2014, 2016 Google, Inc.

# Copyright (c) 2014-2016 Claudiu Popa <pcmanticore@gmail.com>

# Copyright (c) 2015-2016 Cara Vinson <ceridwenv@gmail.com>

# Copyright (c) 2016 Jakub Wilk <jwilk@jwilk.net>

# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html

# For details: https://github.com/PyCQA/astroid/blob/master/COPYING.LESSER

"""Module for some node classes. More nodes in scoped_nodes.py

"""

import abc

import pprint

import warnings

try:

from functools import singledispatch as _singledispatch

except ImportError:

from singledispatch import singledispatch as _singledispatch

import six

from astroid import as_string

from astroid import bases

from astroid import context as contextmod

from astroid import decorators

from astroid import exceptions

from astroid import manager

from astroid import mixins

from astroid import util

BUILTINS = six.moves.builtins.__name__

MANAGER = manager.AstroidManager()

@decorators.raise_if_nothing_inferred

def unpack_infer(stmt, context=None):

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

If the inferred value is a list or a tuple, recurse on the elements

"""

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

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

def are_exclusive(stmt1, stmt2, exceptions=None): # pylint: disable=redefined-outer-name

"""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

"""

# 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

return False

# getitem() helpers.

_SLICE_SENTINEL = object()

def _slice_value(index, context=None):

"""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.

return _SLICE_SENTINEL

def _infer_slice(node, context=None):

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',

node=node, index=node.parent, context=context)

def _container_getitem(instance, elts, index, context=None):

"""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

)

class NodeNG(object):

"""Base Class for all Astroid node classes.

It represents a node of the new abstract syntax tree.

"""

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

values.

If the instance has some explicit inference function set, it will be

called instead of the default interface.

"""

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

ClassDef)

"""

return self.parent.frame()

def scope(self):

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

FunctionDef, ClassDef, Lambda but also GenExpr)

"""

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

given list of nodes

"""

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

we need this method since not all nodes have the lineno attribute

correctly set...

"""

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)

klass may be a class object or a tuple of class objects

"""

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.

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

:param include_linenos: If true, includes the line numbers and

column offsets.

:param ast_state: If true, includes information derived from

the whole AST like local and global variables.

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

:param max_depth: If set to a positive integer, won't return

nodes deeper than max_depth in the string.

:param max_width: Only positive integer values are valid, the

default is 80. Attempts to format the output string to stay

within max_width characters, but can exceed it under some

circumstances.

"""

@_singledispatch

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

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

contained within an AST, including strings.

"""

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

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.

"""

return util.Uninferable

class Statement(NodeNG):

"""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:

return stmts[index -1]

@six.add_metaclass(abc.ABCMeta)

class _BaseContainer(mixins.ParentAssignTypeMixin,

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):

pass

class LookupMixIn(object):

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

"""

def lookup(self, name):

"""lookup a variable name

return 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)

The lookup is starting 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

"""

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

def ilookup(self, name):

"""inferred lookup

return an iterator on inferred values of the statements returned by

the lookup method

"""

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 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

"""

# 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)

return _stmts

# Name classes

class AssignName(LookupMixIn, mixins.ParentAssignTypeMixin, NodeNG):

"""class representing an AssignName node"""

_other_fields = ('name',)

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

self.name = name

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

class DelName(LookupMixIn, mixins.ParentAssignTypeMixin, NodeNG):

"""class representing a DelName node"""

_other_fields = ('name',)

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

self.name = name

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

class Name(LookupMixIn, NodeNG):

"""class representing a Name node"""

_other_fields = ('name',)

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

self.name = name

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

class Arguments(mixins.AssignTypeMixin, NodeNG):

"""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

:raise `NoDefault`: if there is no default value defined

"""

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:

yield child

def _find_arg(argname, args, rec=False):

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

return None, None