def _validate_restrictions(node):
validations.raise_if_try_in_node_body(node.body)
validations.raise_if_try_in_node_body(node.orelse)
if validations.check_if_any_in_block(ast.Return, node.body) or \
validations.check_if_any_in_block(ast.Return, node.orelse):
raise errors.TranslateError(
_errormessages.return_unsupported_unless_last)
if validations.check_if_any_in_block(ast.FunctionDef, node.body) or \
validations.check_if_any_in_block(ast.FunctionDef, node.orelse):
raise errors.TranslateError(_errormessages.invalid_nested_funcdef)
def get_channel_name(node):
if type(node) is ast.Str:
channel_name = node.s
else:
raise errors.TranslateError(
_errormessages.invalid_type_for_channel_ref)
return channel_name
def get_channel_name(node):
if is_node_ast_str(node):
channel_name = get_value_from_str_node(node)
else:
raise errors.TranslateError(
_errormessages.invalid_type_for_channel_ref)
return channel_name
def update_parameter(self, param_name, default_value, by_value):
if param_name not in self._parameters:
raise errors.TranslateError(
_errormessages.param_description_no_param)
rt_seq_param_name = _py_param_name_to_rtseq_param_name(param_name)
self._parameters[param_name] = _Parameter(rt_seq_param_name,
default_value, by_value)
self._local_variables[param_name].py_value = default_value
def _validate_restrictions(node):
if validations.check_if_any_in_block(ast.FunctionDef, node.body):
raise errors.TranslateError(_errormessages.invalid_function_definition)
if node.returns is not None \
or len(node.args.kwonlyargs) != 0 \
or len(node.args.kw_defaults) != 0 \
or node.args.vararg is not None \
or node.args.kwarg is not None \
or len(node.args.defaults) != 0:
raise errors.TranslateError(_errormessages.invalid_function_definition)
if validations.check_if_any_in_block(validations.ast_try(), node.body):
if not isinstance(node.body[0], validations.ast_try()):
raise errors.TranslateError(_errormessages.try_must_be_first_stmt)
if len(node.body) > 2:
raise errors.TranslateError(_errormessages.invalid_stmt_after_try)
elif len(node.body) == 2:
if not isinstance(node.body[1], ast.Return):
raise errors.TranslateError(
_errormessages.invalid_stmt_after_try)
return_statements = [
statement for statement in node.body
if isinstance(statement, ast.Return)
]
if len(return_statements) > 1:
raise errors.TranslateError(_errormessages.multiple_return_statements)
if validations.check_if_any_in_block(ast.Return, node.body[:-1]):
raise errors.TranslateError(
_errormessages.return_unsupported_unless_last)
for decorator in node.decorator_list:
decorator_name_node = decorator.func if isinstance(
decorator, ast.Call) else decorator
decorator_name = utils.get_variable_name_from_node(decorator_name_node)
decorator_name = decorator_name.split(".")[-1]
_raise_if_invalid_decorator(decorator_name)
def constant_transformer(node, resources):
if node.value is True or node.value is False:
return str(node.value).lower()
elif isinstance(node.value, (int, float, complex)) and str(node.value) not in ("True", "False", "None"):
return str(node.value)
elif isinstance(node.value, str):
return node.value
else:
raise errors.TranslateError(_errormessages.constant_not_supported)
def _validate_task(node, mt_name):
body = node.body
validations.raise_if_try_in_node_body(body)
if validations.check_if_any_in_block(ast.FunctionDef, body):
raise errors.TranslateError(_errormessages.invalid_function_definition)
if validations.check_if_any_in_block(ast.Return, body):
raise errors.TranslateError(
_errormessages.return_unsupported_unless_last)
if len(node.args.args) > 0:
raise errors.TranslateError(_errormessages.invalid_with_block)
decs = node.decorator_list
if len(decs) is not 1 \
or not(isinstance(decs[0], ast.Call)) \
or _get_name_without_namespace_from_node(decs[0].func) != _decorators.task.__name__ \
or len(decs[0].args) is not 1 \
or decs[0].args[0].id is not mt_name.id:
raise errors.TranslateError(_errormessages.invalid_with_block)
return node
def raise_if_invalid_invert_operand(node, resources):
invalid_operand = False
try:
if isinstance(utils.get_value_from_node(node, resources).value, (bool, float)):
invalid_operand = True
except errors.TranslateError:
pass
if invalid_operand:
raise errors.TranslateError(_errormessages.invalid_operand_for_unary_invert_operator)
def raise_if_invalid_bool_operand(node, resources):
invalid_operand = False
try:
if not isinstance(utils.get_value_from_node(node, resources).value, bool):
invalid_operand = True
except errors.TranslateError:
pass
if invalid_operand:
raise errors.TranslateError(_errormessages.invalid_operand_for_boolean_operator)
def _validate_node():
from niveristand._translation.py2rtseq import exp_transformer
# There's only one valid way to call nivs_yield which is this call stack:
# 0: _validate_node
# 1: custom_nivs_yield
# 2: call_transformer
# 3: generic_ast_transform
# 4: exp_transformer
exp_frame = inspect.stack()[4]
func = exp_frame.function
if func is not exp_transformer.exp_transformer.__name__:
raise errors.TranslateError(_errormessages.invalid_nivs_yield)
def raise_if_negative_binary_operator_operand(node, resources):
invalid_operand = False
if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
invalid_operand = True
else:
try:
value = utils.get_value_from_node(node, resources).value
if value < 0:
invalid_operand = True
except errors.TranslateError:
pass
if invalid_operand:
raise errors.TranslateError(_errormessages.negative_operand_for_binary_operator)
def _validate_node():
from niveristand._translation.py2rtseq import exp_transformer
# There's only one valid way to call nivs_yield which is this call stack:
# 0: _validate_node
# 1: custom_nivs_yield
# 2: call_transformer
# 3: generic_ast_transform
# 4: exp_transformer
exp_frame = inspect.stack()[4]
# Py27 doesn't have the 'function' element but in Py35 frame[3] is valid for backwards compatibility.
# We can remove this nasty check if we drop 2.7
func = exp_frame.function if 'function' in dir(exp_frame) else exp_frame[3]
if func is not exp_transformer.exp_transformer.__name__:
raise errors.TranslateError(_errormessages.invalid_nivs_yield)
def call_transformer(node, resources):
if rtprimitives.is_channel_ref_type(node.func.id):
if isinstance(node.args[0], ast.Str):
identifier = resources.get_channel_ref_rtseq_name_from_channel_name(
node.args[0].s)
else:
raise errors.TranslateError(
_errormessages.invalid_type_for_channel_ref)
return identifier
if rtprimitives.is_supported_data_type(node.func.id):
if rtprimitives.is_scalar_type(node.func.id):
return _transform_data_type_scalar(node)
elif isinstance(node.args[0], ast.List):
return _transform_datatype_non_scalar(node, resources)
else:
raise errors.TranslateError(_errormessages.init_var_invalid_type)
if node.func.id in custom_action_symbols._custom_action_symbols:
# Custom action symbols are basically transformers for functions that don't have
# their own ast node. Invoke them here
return custom_action_symbols._custom_action_symbols[node.func.id](
node, resources)
if node.func.id in symbols._symbols:
# In case of a builtin expression get it out from symbols and add any arguments it may have
func_name = symbols._symbols[node.func.id]
else:
# It only can be a RT sequence call, so treat it accordingly
func_name = str(utils.generic_ast_node_transform(node.func, resources))
resources.add_referenced_sequence(func_name)
node_str = func_name + "("
for arg in node.args:
node_str += str(utils.generic_ast_node_transform(arg, resources))
node_str += " ,"
if not node.args:
return node_str + ")"
else:
# remove space and comma
return node_str[:-2] + ")"
def attribute_transformer(node, resources):
var_name = utils.get_variable_name_from_node(node)
if resources.has_variable(var_name):
if isinstance(node.value, ast.Subscript):
return utils.generic_ast_node_transform(node.value, resources)
else:
return resources.get_variable_rtseq_name(var_name)
try:
# Try to get the value of the node in case it's a DataType(x).value style.
node_value = utils.get_value_from_node(node.value, resources)
return str(node_value)
except errors.TranslateError:
# If we get a TranslateError it's because it wasn't a DataType(x).value, so move on.
pass
built_exp = utils.generic_ast_node_transform(node.value,
resources) + '.' + node.attr
if built_exp in symbols._symbols:
return symbols._symbols[built_exp]
else:
raise errors.TranslateError(_errormessages.unknown_identifier %
var_name)
def nameconstant_transformer(node, resources):
if node.value is True or node.value is False:
return str(node.value).lower()
else:
raise errors.TranslateError(_errormessages.name_constant_not_supported)
def break_transformer(node, resources):
raise errors.TranslateError(_errormessages.break_unsupported)
def raise_if_invalid_if_test(node):
if isinstance(node, ast.UnaryOp):
node = node.operand
if isinstance(node, ast.Call) and utils.get_variable_name_from_node(node.func) in VALID_TYPES:
raise errors.TranslateError(_errormessages.invalid_type_for_if_test)
def _raise_if_invalid_decorator(attribute):
if not (attribute in _decorators._VALID_DECORATORS):
raise errors.TranslateError(_errormessages.invalid_decorator)
def _to_data_value(self, value):
raise nivsexceptions.TranslateError(_errormessages.invalid_type_to_convert)
def raise_if_try_in_node_body(statements):
if check_if_any_in_block(ast_try(), statements):
raise errors.TranslateError(_errormessages.try_only_in_top_level_func)
