def _build_cond_stmt(self, step_node, compare_node):
if not isinstance(step_node, (gast.Constant, gast.UnaryOp)):
raise NotImplementedError(
"Dynamic-to-Static only supports the step value is a constant or negative constant in 'for-range' statements, "
"such as '2', '-3'. But received: '{}'. Please fix code to be compatible with Dynamic-to-Static."
.format(ast_to_source_code(step_node).strip()))
if isinstance(step_node, gast.UnaryOp) or step_node.value < 0:
# eg:
# range(max, min, -2)
# ->
# i > min
return gast.Compare(left=gast.Name(
id=self.iter_var_name
if self.is_for_range_iter() else self.iter_idx_name,
ctx=gast.Load(),
annotation=None,
type_comment=None),
ops=[gast.Gt()],
comparators=[compare_node])
else:
# eg:
# range(min, max, 2)
# ->
# i < max
return gast.Compare(left=gast.Name(
id=self.iter_var_name
if self.is_for_range_iter() else self.iter_idx_name,
ctx=gast.Load(),
annotation=None,
type_comment=None),
ops=[gast.Lt()],
comparators=[compare_node])
def test_expected_result(self):
self.assertEqual(cmpop_node_to_str(gast.Eq()), "==")
self.assertEqual(cmpop_node_to_str(gast.NotEq()), "!=")
self.assertEqual(cmpop_node_to_str(gast.Lt()), "<")
self.assertEqual(cmpop_node_to_str(gast.LtE()), "<=")
self.assertEqual(cmpop_node_to_str(gast.Gt()), ">")
self.assertEqual(cmpop_node_to_str(gast.GtE()), ">=")
self.assertEqual(cmpop_node_to_str(gast.Is()), "is")
self.assertEqual(cmpop_node_to_str(gast.IsNot()), "is not")
self.assertEqual(cmpop_node_to_str(gast.In()), "in")
self.assertEqual(cmpop_node_to_str(gast.NotIn()), "not in")
def visit_BinOp(self, node):
node = self.generic_visit(node)
if not isinstance(node.op, ast.Mod):
return node
right_range = self.range_values[node.right]
left_range = self.range_values[node.left]
if right_range.low < 0 or isinf(right_range.high):
return node
if left_range.low < -right_range.low:
return node
if left_range.high > right_range.high * 2:
return node
cleft0, cleft1 = deepcopy(node.left), deepcopy(node.left)
cright = deepcopy(node.right)
self.update = True
return ast.IfExp(ast.Compare(node.left, [ast.Lt()], [node.right]),
cleft0, ast.BinOp(cleft1, ast.Sub(), cright))
def negate(node):
if isinstance(node, ast.Name):
# Not type info, could be anything :(
raise UnsupportedExpression()
if isinstance(node, ast.UnaryOp):
# !~x <> ~x == 0 <> x == ~0 <> x == -1
if isinstance(node.op, ast.Invert):
return ast.Compare(node.operand,
[ast.Eq()],
[ast.Constant(-1, None)])
# !!x <> x
if isinstance(node.op, ast.Not):
return node.operand
# !+x <> +x == 0 <> x == 0 <> !x
if isinstance(node.op, ast.UAdd):
return node.operand
# !-x <> -x == 0 <> x == 0 <> !x
if isinstance(node.op, ast.USub):
return node.operand
if isinstance(node, ast.BoolOp):
new_values = [ast.UnaryOp(ast.Not(), v) for v in node.values]
# !(x or y) <> !x and !y
if isinstance(node.op, ast.Or):
return ast.BoolOp(ast.And(), new_values)
# !(x and y) <> !x or !y
if isinstance(node.op, ast.And):
return ast.BoolOp(ast.Or(), new_values)
if isinstance(node, ast.Compare):
cmps = [ast.Compare(x, [negate(o)], [y])
for x, o, y
in zip([node.left] + node.comparators[:-1], node.ops,
node.comparators)]
if len(cmps) == 1:
return cmps[0]
return ast.BoolOp(ast.Or(), cmps)
if isinstance(node, ast.Eq):
return ast.NotEq()
if isinstance(node, ast.NotEq):
return ast.Eq()
if isinstance(node, ast.Gt):
return ast.LtE()
if isinstance(node, ast.GtE):
return ast.Lt()
if isinstance(node, ast.Lt):
return ast.GtE()
if isinstance(node, ast.LtE):
return ast.Gt()
if isinstance(node, ast.In):
return ast.NotIn()
if isinstance(node, ast.NotIn):
return ast.In()
if isinstance(node, ast.Attribute):
if node.attr == 'False':
return ast.Constant(True, None)
if node.attr == 'True':
return ast.Constant(False, None)
raise UnsupportedExpression()
