[ONOS-7104]: Fixing style check errors in core dir of TestON
Change-Id: Ia50ae6542b141ebe857d3c42b52bd165969664e6
diff --git a/TestON/core/ast.py b/TestON/core/ast.py
index fd5dfdb..c876b45 100644
--- a/TestON/core/ast.py
+++ b/TestON/core/ast.py
@@ -29,58 +29,58 @@
from _ast import __version__
-def parse(source, filename='<unknown>', mode='exec'):
+def parse( source, filename='<unknown>', mode='exec' ):
"""
Parse the source into an AST node.
Equivalent to compile(source, filename, mode, PyCF_ONLY_AST).
"""
- return compile(source, filename, mode, PyCF_ONLY_AST)
+ return compile( source, filename, mode, PyCF_ONLY_AST )
-def literal_eval(node_or_string):
+def literal_eval( node_or_string ):
"""
Safely evaluate an expression node or a string containing a Python
expression. The string or node provided may only consist of the following
Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
and None.
"""
- _safe_names = {'None': None, 'True': True, 'False': False}
- if isinstance(node_or_string, basestring):
- node_or_string = parse(node_or_string, mode='eval')
- if isinstance(node_or_string, Expression):
+ _safe_names = { 'None': None, 'True': True, 'False': False }
+ if isinstance( node_or_string, basestring ):
+ node_or_string = parse( node_or_string, mode='eval' )
+ if isinstance( node_or_string, Expression ):
node_or_string = node_or_string.body
- def _convert(node):
- if isinstance(node, Str):
+
+ def _convert( node ):
+ if isinstance( node, Str ):
return node.s
- elif isinstance(node, Num):
+ elif isinstance( node, Num ):
return node.n
- elif isinstance(node, Tuple):
- return tuple(map(_convert, node.elts))
- elif isinstance(node, List):
- return list(map(_convert, node.elts))
- elif isinstance(node, Dict):
- return dict((_convert(k), _convert(v)) for k, v
- in zip(node.keys, node.values))
- elif isinstance(node, Name):
+ elif isinstance( node, Tuple ):
+ return tuple( map( _convert, node.elts ) )
+ elif isinstance( node, List ):
+ return list( map( _convert, node.elts ) )
+ elif isinstance( node, Dict ):
+ return dict( ( _convert( k ), _convert( v ) ) for k, v in zip( node.keys, node.values ) )
+ elif isinstance( node, Name ):
if node.id in _safe_names:
- return _safe_names[node.id]
- elif isinstance(node, BinOp) and \
- isinstance(node.op, (Add, Sub)) and \
- isinstance(node.right, Num) and \
- isinstance(node.right.n, complex) and \
- isinstance(node.left, Num) and \
- isinstance(node.left.n, (int, long, float)):
+ return _safe_names[ node.id ]
+ elif isinstance( node, BinOp ) and \
+ isinstance( node.op, ( Add, Sub ) ) and \
+ isinstance( node.right, Num ) and \
+ isinstance( node.right.n, complex ) and \
+ isinstance( node.left, Num ) and \
+ isinstance( node.left.n, ( int, long, float ) ):
left = node.left.n
right = node.right.n
- if isinstance(node.op, Add):
+ if isinstance( node.op, Add ):
return left + right
else:
return left - right
- raise ValueError('malformed string')
- return _convert(node_or_string)
+ raise ValueError( 'malformed string' )
+ return _convert( node_or_string )
-def dump(node, annotate_fields=True, include_attributes=False):
+def dump( node, annotate_fields=True, include_attributes=False ):
"""
Return a formatted dump of the tree in *node*. This is mainly useful for
debugging purposes. The returned string will show the names and the values
@@ -89,40 +89,39 @@
numbers and column offsets are not dumped by default. If this is wanted,
*include_attributes* can be set to True.
"""
- def _format(node):
- if isinstance(node, AST):
- fields = [(a, _format(b)) for a, b in iter_fields(node)]
- rv = '%s(%s' % (node.__class__.__name__, ', '.join(
- ('%s=%s' % field for field in fields)
+ def _format( node ):
+ if isinstance( node, AST ):
+ fields = [ ( a, _format( b ) ) for a, b in iter_fields( node ) ]
+ rv = '%s(%s' % ( node.__class__.__name__, ', '.join(
+ ( '%s=%s' % field for field in fields )
if annotate_fields else
- (b for a, b in fields)
- ))
+ ( b for a, b in fields )
+ ) )
if include_attributes and node._attributes:
rv += fields and ', ' or ' '
- rv += ', '.join('%s=%s' % (a, _format(getattr(node, a)))
- for a in node._attributes)
+ rv += ', '.join( '%s=%s' % ( a, _format( getattr( node, a ) ) ) for a in node._attributes )
return rv + ')'
- elif isinstance(node, list):
- return '[%s]' % ', '.join(_format(x) for x in node)
- return repr(node)
- if not isinstance(node, AST):
- raise TypeError('expected AST, got %r' % node.__class__.__name__)
- return _format(node)
+ elif isinstance( node, list ):
+ return '[%s]' % ', '.join( _format( x ) for x in node )
+ return repr( node )
+ if not isinstance( node, AST ):
+ raise TypeError( 'expected AST, got %r' % node.__class__.__name__ )
+ return _format( node )
-def copy_location(new_node, old_node):
+def copy_location( new_node, old_node ):
"""
Copy source location (`lineno` and `col_offset` attributes) from
*old_node* to *new_node* if possible, and return *new_node*.
"""
for attr in 'lineno', 'col_offset':
if attr in old_node._attributes and attr in new_node._attributes \
- and hasattr(old_node, attr):
- setattr(new_node, attr, getattr(old_node, attr))
+ and hasattr( old_node, attr ):
+ setattr( new_node, attr, getattr( old_node, attr ) )
return new_node
-def fix_missing_locations(node):
+def fix_missing_locations( node ):
"""
When you compile a node tree with compile(), the compiler expects lineno and
col_offset attributes for every node that supports them. This is rather
@@ -130,91 +129,91 @@
recursively where not already set, by setting them to the values of the
parent node. It works recursively starting at *node*.
"""
- def _fix(node, lineno, col_offset):
+ def _fix( node, lineno, col_offset ):
if 'lineno' in node._attributes:
- if not hasattr(node, 'lineno'):
+ if not hasattr( node, 'lineno' ):
node.lineno = lineno
else:
lineno = node.lineno
if 'col_offset' in node._attributes:
- if not hasattr(node, 'col_offset'):
+ if not hasattr( node, 'col_offset' ):
node.col_offset = col_offset
else:
col_offset = node.col_offset
- for child in iter_child_nodes(node):
- _fix(child, lineno, col_offset)
- _fix(node, 1, 0)
+ for child in iter_child_nodes( node ):
+ _fix( child, lineno, col_offset )
+ _fix( node, 1, 0 )
return node
-def increment_lineno(node, n=1):
+def increment_lineno( node, n=1 ):
"""
Increment the line number of each node in the tree starting at *node* by *n*.
This is useful to "move code" to a different location in a file.
"""
- for child in walk(node):
+ for child in walk( node ):
if 'lineno' in child._attributes:
- child.lineno = getattr(child, 'lineno', 0) + n
+ child.lineno = getattr( child, 'lineno', 0 ) + n
return node
-def iter_fields(node):
+def iter_fields( node ):
"""
Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
that is present on *node*.
"""
for field in node._fields:
try:
- yield field, getattr(node, field)
+ yield field, getattr( node, field )
except AttributeError:
pass
-def iter_child_nodes(node):
+def iter_child_nodes( node ):
"""
Yield all direct child nodes of *node*, that is, all fields that are nodes
and all items of fields that are lists of nodes.
"""
- for name, field in iter_fields(node):
- if isinstance(field, AST):
+ for name, field in iter_fields( node ):
+ if isinstance( field, AST ):
yield field
- elif isinstance(field, list):
+ elif isinstance( field, list ):
for item in field:
- if isinstance(item, AST):
+ if isinstance( item, AST ):
yield item
-def get_docstring(node, clean=True):
+def get_docstring( node, clean=True ):
"""
Return the docstring for the given node or None if no docstring can
be found. If the node provided does not have docstrings a TypeError
will be raised.
"""
- if not isinstance(node, (FunctionDef, ClassDef, Module)):
- raise TypeError("%r can't have docstrings" % node.__class__.__name__)
- if node.body and isinstance(node.body[0], Expr) and \
- isinstance(node.body[0].value, Str):
+ if not isinstance( node, ( FunctionDef, ClassDef, Module ) ):
+ raise TypeError( "%r can't have docstrings" % node.__class__.__name__ )
+ if node.body and isinstance( node.body[ 0 ], Expr ) and \
+ isinstance( node.body[ 0 ].value, Str ):
if clean:
import inspect
- return inspect.cleandoc(node.body[0].value.s)
- return node.body[0].value.s
+ return inspect.cleandoc( node.body[ 0 ].value.s )
+ return node.body[ 0 ].value.s
-def walk(node):
+def walk( node ):
"""
Recursively yield all descendant nodes in the tree starting at *node*
(including *node* itself), in no specified order. This is useful if you
only want to modify nodes in place and don't care about the context.
"""
from collections import deque
- todo = deque([node])
+ todo = deque( [ node ] )
while todo:
node = todo.popleft()
- todo.extend(iter_child_nodes(node))
+ todo.extend( iter_child_nodes( node ) )
yield node
-class NodeVisitor(object):
+class NodeVisitor( object ):
"""
A node visitor base class that walks the abstract syntax tree and calls a
visitor function for every node found. This function may return a value
@@ -234,24 +233,24 @@
allows modifications.
"""
- def visit(self, node):
+ def visit( self, node ):
"""Visit a node."""
method = 'visit_' + node.__class__.__name__
- visitor = getattr(self, method, self.generic_visit)
- return visitor(node)
+ visitor = getattr( self, method, self.generic_visit )
+ return visitor( node )
- def generic_visit(self, node):
+ def generic_visit( self, node ):
"""Called if no explicit visitor function exists for a node."""
- for field, value in iter_fields(node):
- if isinstance(value, list):
+ for field, value in iter_fields( node ):
+ if isinstance( value, list ):
for item in value:
- if isinstance(item, AST):
- self.visit(item)
- elif isinstance(value, AST):
- self.visit(value)
+ if isinstance( item, AST ):
+ self.visit( item )
+ elif isinstance( value, AST ):
+ self.visit( value )
-class NodeTransformer(NodeVisitor):
+class NodeTransformer( NodeVisitor ):
"""
A :class:`NodeVisitor` subclass that walks the abstract syntax tree and
allows modification of nodes.
@@ -287,25 +286,25 @@
node = YourTransformer().visit(node)
"""
- def generic_visit(self, node):
- for field, old_value in iter_fields(node):
- old_value = getattr(node, field, None)
- if isinstance(old_value, list):
+ def generic_visit( self, node ):
+ for field, old_value in iter_fields( node ):
+ old_value = getattr( node, field, None )
+ if isinstance( old_value, list ):
new_values = []
for value in old_value:
- if isinstance(value, AST):
- value = self.visit(value)
+ if isinstance( value, AST ):
+ value = self.visit( value )
if value is None:
continue
- elif not isinstance(value, AST):
- new_values.extend(value)
+ elif not isinstance( value, AST ):
+ new_values.extend( value )
continue
- new_values.append(value)
- old_value[:] = new_values
- elif isinstance(old_value, AST):
- new_node = self.visit(old_value)
+ new_values.append( value )
+ old_value[ : ] = new_values
+ elif isinstance( old_value, AST ):
+ new_node = self.visit( old_value )
if new_node is None:
- delattr(node, field)
+ delattr( node, field )
else:
- setattr(node, field, new_node)
+ setattr( node, field, new_node )
return node