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)