Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
element_node: the part being evaluated for each item.
comp_nodes: a list of Comprehension nodes.
"""
__slots__ = 'element_node', 'comp_nodes'
class SetComp(Node):
""" Set comprehension. See ListComp.
"""
__slots__ = 'element_node', 'comp_nodes'
class GeneratorExp(Node):
""" Generor expression. See ListComp.
"""
__slots__ = 'element_node', 'comp_nodes'
class DictComp(Node):
""" Dict comprehension.
Attributes:
key_node: the key of the item being evaluated.
value_node: the value of the item being evaluated.
comp_nodes: a list of Comprehension nodes.
"""
__slots__ = 'key_node', 'value_node', 'comp_nodes'
class Comprehension(Node):
""" Represents a single for-clause in a comprehension.
Attributes:
target_node: reference to use for each element, typically a
Name or Tuple node.
iter_node: the object to iterate over.
""" Continue with next iteration of a loop.
"""
__slots__ = ()
class Try(Node):
""" Try-block.
Attributes:
body_nodes: the body of the try-block (i.e. the code to try).
handler_nodes: a list of ExceptHandler instances.
else_nodes: the body of the else-clause of the try-block.
finally_nodes: the body of the finally-clause of the try-block.
"""
__slots__ = 'body_nodes', 'handler_nodes', 'else_nodes', 'finally_nodes'
class ExceptHandler(Node):
""" Single except-clause.
Attributes:
type_node: the type of exception to catch. Often a Name node
or None to catch all.
name: the string name of the exception object in case of ``as err``.
None otherwise.
body_nodes: the body of the except-clause.
"""
__slots__ = 'type_node', 'name', 'body_nodes'
class With(Node):
""" A with-block (i.e. a context manager).
Attributes:
item_nodes: a list of WithItem nodes (i.e. context managers).
op: the operator (an enum from ``Node.OPS``).
right_node: the operand at the right of the operator.
"""
__slots__ = 'op', 'right_node'
class BinOp(Node):
""" A binary operation (e.g. ``a / b``, ``a + b``).
Attributes:
op: the operator (an enum from ``Node.OPS``).
left_node: the node to the left of the operator.
right_node: the node to the right of the operator.
"""
__slots__ = 'op', 'left_node', 'right_node'
class BoolOp(Node):
""" A boolean operator (``and``, ``or``, but not ``not``).
Attributes:
op: the operator (an enum from ``Node.OPS``).
value_nodes: a list of nodes. ``a``, ``b`` and ``c`` in
``a or b or c``.
"""
__slots__ = 'op', 'value_nodes'
class Compare(Node):
""" A comparison of two or more values.
Attributes:
op: the comparison operator (an enum from ``Node.COMP``).
left_node: the node to the left of the operator.
right_node: the node to the right of the operator.
body_nodes: the body of the for-loop.
else_nodes: the body of the else-clause of the for-loop.
"""
__slots__ = 'target_node', 'iter_node', 'body_nodes', 'else_nodes'
class While(Node):
""" A while-loop.
Attributes:
test_node: the test to perform on each iteration.
body_nodes: the body of the for-loop.
else_nodes: the body of the else-clause of the for-loop.
"""
__slots__ = 'test_node', 'body_nodes', 'else_nodes'
class Break(Node):
""" Break from a loop.
"""
__slots__ = ()
class Continue(Node):
""" Continue with next iteration of a loop.
"""
__slots__ = ()
class Try(Node):
""" Try-block.
Attributes:
body_nodes: the body of the try-block (i.e. the code to try).
handler_nodes: a list of ExceptHandler instances.
else_nodes: the body of the else-clause of the try-block.
class List(Node):
"""
Attributes:
element_nodes: the items in the list.
"""
__slots__ = 'element_nodes',
class Tuple(Node):
"""
Attributes:
element_nodes: the items in the tuple.
"""
__slots__ = 'element_nodes',
class Set(Node):
"""
Attributes:
element_nodes: the items in the set.
"""
__slots__ = 'element_nodes',
class Dict(Node):
"""
Attributes:
key_nodes: the keys of the dict.
value_nodes: the corresponding values.
"""
__slots__ = 'key_nodes', 'value_nodes'
class Ellipsis(Node):
""" Represents the ``...`` syntax for the Ellipsis singleton.
for name, val in zip(names, args):
assert not isinstance(val, ast.AST)
if name == 'name':
assert isinstance(val, (basestring, NoneType)), 'name not a string'
elif name == 'op':
assert val in Node.OPS.__dict__ or val in Node.COMP.__dict__
elif name.endswith('_node'):
assert isinstance(val, (Node, NoneType)), '%r is not a Node' % name
elif name.endswith('_nodes'):
islistofnodes = (isinstance(val, list) and
all(isinstance(n, Node) for n in val))
assert islistofnodes, '%r is not a list of nodes' % name
else:
assert not isinstance(val, Node), '%r should not be a Node' % name
assert not (isinstance(val, list) and
all(isinstance(n, Node) for n in val))
# Assign
for name, val in zip(names, args):
setattr(self, name, val)
Attributes:
test_node: the condition to test.
msg_node: the failure message (commonly a Str node)
"""
__slots__ = 'test_node', 'msg_node'
class Delete(Node):
""" A del statement.
Attributes:
target_nodes: the variables to delete, such as Name, Attribute
or Subscript nodes.
"""
__slots__ = 'target_nodes',
class Pass(Node):
""" Do nothing.
"""
__slots__ = ()
class Import(Node):
""" An import statement.
Attributes:
root: the name of the module to import from. None if this is
not a from-import.
names: list of (name, alias) tuples, where alias can be None.
level: an integer indicating depth of import. Zero means
absolute import.
"""
__slots__ = 'root', 'names', 'level'
class Comprehension(Node):
""" Represents a single for-clause in a comprehension.
Attributes:
target_node: reference to use for each element, typically a
Name or Tuple node.
iter_node: the object to iterate over.
if_nodes: a list of test expressions.
"""
__slots__ = 'target_node', 'iter_node', 'if_nodes'
## Statements
class Assign(Node):
""" Assignment of a value to a variable.
Attributes:
target_nodes: variables to assign to, Name or SubScript.
value_node: the object to assign.
"""
__slots__ = 'target_nodes', 'value_node'
class AugAssign(Node):
""" Augmented assignment, such as ``a += 1``.
Attributes:
target_node: variable to assign to, Name or SubScript.
op: operator enum (e.g. ``Node.OPS.Add``)
value_node: the object to assign.
"""
class Call(Node):
""" A function call.
Attributes:
func_node: Name, Attribute or SubScript node that represents
the function.
arg_nodes: list of nodes representing positional arguments.
kwarg_nodes: list of Keyword nodes representing keyword arguments.
Note that an argument ``*x`` would be specified as a Starred node
in arg_nodes, and ``**y`` as a Keyword node with a name being ``None``.
"""
__slots__ = ('func_node', 'arg_nodes', 'kwarg_nodes')
class Keyword(Node):
""" Keyword argument used in a Call.
Attributes:
name: the (string) name of the argument. Is None for ``**kwargs``.
value_node: the value of the arg.
"""
__slots__ = ('name', 'value_node')
class IfExp(Node):
""" An expression such as ``a if b else c``.
Attributes:
test_node: the ``b`` in the above.
body_node: the ``a`` in the above.
else_node: the ``c`` in the above.
"""
Attributes:
value_node: holds one of the other nodes in this section, or a
literal, a Name, a Lambda, or a Yield or YieldFrom node.
"""
__slots__ = 'value_node',
class UnaryOp(Node):
""" A unary operation (e.g. ``-x``, ``not x``).
Attributes:
op: the operator (an enum from ``Node.OPS``).
right_node: the operand at the right of the operator.
"""
__slots__ = 'op', 'right_node'
class BinOp(Node):
""" A binary operation (e.g. ``a / b``, ``a + b``).
Attributes:
op: the operator (an enum from ``Node.OPS``).
left_node: the node to the left of the operator.
right_node: the node to the right of the operator.
"""
__slots__ = 'op', 'left_node', 'right_node'
class BoolOp(Node):
""" A boolean operator (``and``, ``or``, but not ``not``).
Attributes:
op: the operator (an enum from ``Node.OPS``).
value_nodes: a list of nodes. ``a``, ``b`` and ``c`` in
``a or b or c``.