From fee53bce3b324c476c0a9c8b930f1d57f5985254 Mon Sep 17 00:00:00 2001 From: StrikerRUS Date: Tue, 23 Jun 2020 04:49:54 +0300 Subject: [PATCH] migrate from format to f-strings (2) --- m2cgen/assemblers/__init__.py | 6 +- m2cgen/assemblers/boosting.py | 2 +- m2cgen/assemblers/linear.py | 5 +- m2cgen/assemblers/svm.py | 3 +- m2cgen/ast.py | 57 ++++++------------- m2cgen/cli.py | 2 +- m2cgen/interpreters/c/code_generator.py | 16 +++--- m2cgen/interpreters/c/interpreter.py | 4 +- m2cgen/interpreters/c_sharp/code_generator.py | 17 +++--- m2cgen/interpreters/code_generator.py | 11 ++-- m2cgen/interpreters/dart/code_generator.py | 15 ++--- m2cgen/interpreters/go/code_generator.py | 15 ++--- m2cgen/interpreters/haskell/code_generator.py | 21 ++++--- m2cgen/interpreters/interpreter.py | 2 +- m2cgen/interpreters/java/code_generator.py | 15 ++--- .../interpreters/javascript/code_generator.py | 6 +- m2cgen/interpreters/mixins.py | 8 +-- m2cgen/interpreters/php/code_generator.py | 11 ++-- .../interpreters/powershell/code_generator.py | 19 +++---- m2cgen/interpreters/python/code_generator.py | 12 ++-- m2cgen/interpreters/r/code_generator.py | 7 +-- m2cgen/interpreters/ruby/code_generator.py | 9 +-- m2cgen/interpreters/utils.py | 3 +- .../visual_basic/code_generator.py | 14 ++--- 24 files changed, 113 insertions(+), 167 deletions(-) diff --git a/m2cgen/assemblers/__init__.py b/m2cgen/assemblers/__init__.py index a3782fd4..7e9e91ad 100644 --- a/m2cgen/assemblers/__init__.py +++ b/m2cgen/assemblers/__init__.py @@ -125,8 +125,7 @@ def _get_full_model_name(model): type_name = type(model) - return "{}_{}".format(type_name.__module__.split(".")[0], - type_name.__name__) + return f"{type_name.__module__.split('.')[0]}_{type_name.__name__}" def get_assembler_cls(model): @@ -134,7 +133,6 @@ def get_assembler_cls(model): assembler_cls = SUPPORTED_MODELS.get(model_name) if not assembler_cls: - raise NotImplementedError( - "Model '{}' is not supported".format(model_name)) + raise NotImplementedError(f"Model '{model_name}' is not supported") return assembler_cls diff --git a/m2cgen/assemblers/boosting.py b/m2cgen/assemblers/boosting.py index f0377db3..d8ee81f8 100644 --- a/m2cgen/assemblers/boosting.py +++ b/m2cgen/assemblers/boosting.py @@ -164,7 +164,7 @@ def _assemble_child_tree(self, tree, child_id): for child in tree["children"]: if child["nodeid"] == child_id: return self._assemble_tree(child) - assert False, "Unexpected child ID: {}".format(child_id) + assert False, f"Unexpected child ID: {child_id}" class XGBoostLinearModelAssembler(BaseBoostingAssembler): diff --git a/m2cgen/assemblers/linear.py b/m2cgen/assemblers/linear.py index ab2d8bfd..764c4ada 100644 --- a/m2cgen/assemblers/linear.py +++ b/m2cgen/assemblers/linear.py @@ -94,8 +94,7 @@ def _final_transform(self, ast_to_transform): "nbinom": self._negativebinomial_inversed } if link_function_lower not in supported_inversed_functions: - raise ValueError( - "Unsupported link function '{}'".format(link_function)) + raise ValueError(f"Unsupported link function '{link_function}'") fun = supported_inversed_functions[link_function_lower] return fun(ast_to_transform) @@ -175,7 +174,7 @@ def __init__(self, model): self.assembler = StatsmodelsLinearModelAssembler(model) else: raise NotImplementedError( - "Model '{}' is not supported".format(underlying_model)) + f"Model '{underlying_model}' is not supported") def assemble(self): return self.assembler.assemble() diff --git a/m2cgen/assemblers/svm.py b/m2cgen/assemblers/svm.py index e3e05ed8..ad234d9e 100644 --- a/m2cgen/assemblers/svm.py +++ b/m2cgen/assemblers/svm.py @@ -13,8 +13,7 @@ def __init__(self, model): kernel_type = model.kernel supported_kernels = self._get_supported_kernels() if kernel_type not in supported_kernels: - raise ValueError( - "Unsupported kernel type '{}'".format(kernel_type)) + raise ValueError(f"Unsupported kernel type '{kernel_type}'") self._kernel_fun = supported_kernels[kernel_type] gamma = self._get_gamma() diff --git a/m2cgen/ast.py b/m2cgen/ast.py index 757885d5..3f7202a9 100644 --- a/m2cgen/ast.py +++ b/m2cgen/ast.py @@ -20,8 +20,7 @@ def __init__(self, expr, to_reuse=False): self.output_size = expr.output_size def __str__(self): - args = ",".join([str(self.expr), "to_reuse=" + str(self.to_reuse)]) - return "IdExpr(" + args + ")" + return f"IdExpr({self.expr},to_reuse={self.to_reuse})" def __eq__(self, other): return type(other) is IdExpr and self.expr == other.expr @@ -35,7 +34,7 @@ def __init__(self, index): self.index = index def __str__(self): - return "FeatureRef(" + str(self.index) + ")" + return f"FeatureRef({self.index})" def __eq__(self, other): return type(other) is FeatureRef and self.index == other.index @@ -61,7 +60,7 @@ def __init__(self, value, dtype=None): self.value = value def __str__(self): - return "NumVal(" + str(self.value) + ")" + return f"NumVal({self.value})" def __eq__(self, other): return type(other) is NumVal and self.value == other.value @@ -78,8 +77,7 @@ def __init__(self, expr, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([str(self.expr), "to_reuse=" + str(self.to_reuse)]) - return "AbsExpr(" + args + ")" + return f"AbsExpr({self.expr},to_reuse={self.to_reuse})" def __eq__(self, other): return type(other) is AbsExpr and self.expr == other.expr @@ -96,8 +94,7 @@ def __init__(self, expr, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([str(self.expr), "to_reuse=" + str(self.to_reuse)]) - return "ExpExpr(" + args + ")" + return f"ExpExpr({self.expr},to_reuse={self.to_reuse})" def __eq__(self, other): return type(other) is ExpExpr and self.expr == other.expr @@ -114,8 +111,7 @@ def __init__(self, expr, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([str(self.expr), "to_reuse=" + str(self.to_reuse)]) - return "LogExpr(" + args + ")" + return f"LogExpr({self.expr},to_reuse={self.to_reuse})" def __eq__(self, other): return type(other) is LogExpr and self.expr == other.expr @@ -132,8 +128,7 @@ def __init__(self, expr, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([str(self.expr), "to_reuse=" + str(self.to_reuse)]) - return "Log1pExpr(" + args + ")" + return f"Log1pExpr({self.expr},to_reuse={self.to_reuse})" def __eq__(self, other): return type(other) is Log1pExpr and self.expr == other.expr @@ -150,8 +145,7 @@ def __init__(self, expr, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([str(self.expr), "to_reuse=" + str(self.to_reuse)]) - return "SqrtExpr(" + args + ")" + return f"SqrtExpr({self.expr},to_reuse={self.to_reuse})" def __eq__(self, other): return type(other) is SqrtExpr and self.expr == other.expr @@ -168,8 +162,7 @@ def __init__(self, expr, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([str(self.expr), "to_reuse=" + str(self.to_reuse)]) - return "TanhExpr(" + args + ")" + return f"TanhExpr({self.expr},to_reuse={self.to_reuse})" def __eq__(self, other): return type(other) is TanhExpr and self.expr == other.expr @@ -188,12 +181,8 @@ def __init__(self, base_expr, exp_expr, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([ - str(self.base_expr), - str(self.exp_expr), - "to_reuse=" + str(self.to_reuse) - ]) - return "PowExpr(" + args + ")" + return (f"PowExpr({self.base_expr},{self.exp_expr}," + f"to_reuse={self.to_reuse})") def __eq__(self, other): return (type(other) is PowExpr and @@ -222,13 +211,7 @@ def __init__(self, left, right, op, to_reuse=False): self.to_reuse = to_reuse def __str__(self): - args = ",".join([ - str(self.left), - str(self.right), - self.op.name, - "to_reuse=" + str(self.to_reuse) - ]) - return "BinNumExpr(" + args + ")" + return f"BinNumExpr({self.left},{self.right},to_reuse={self.to_reuse})" def __eq__(self, other): return _eq_bin_exprs(self, other, type(self)) @@ -254,7 +237,7 @@ def __init__(self, exprs): def __str__(self): args = ",".join([str(e) for e in self.exprs]) - return "VectorVal([" + args + "])" + return f"VectorVal([{args}])" def __eq__(self, other): return (type(other) is VectorVal and @@ -278,8 +261,7 @@ def __init__(self, left, right, op): self.output_size = left.output_size def __str__(self): - args = ",".join([str(self.left), str(self.right), self.op.name]) - return "BinVectorExpr(" + args + ")" + return f"BinVectorExpr({self.left},{self.right},{self.op.name})" def __eq__(self, other): return _eq_bin_exprs(self, other, type(self)) @@ -300,8 +282,7 @@ def __init__(self, left, right, op): self.output_size = left.output_size def __str__(self): - args = ",".join([str(self.left), str(self.right), self.op.name]) - return "BinVectorNumExpr(" + args + ")" + return f"BinVectorNumExpr({self.left},{self.right},{self.op.name})" def __eq__(self, other): return _eq_bin_exprs(self, other, type(self)) @@ -342,8 +323,7 @@ def __init__(self, left, right, op): self.op = op def __str__(self): - args = ",".join([str(self.left), str(self.right), self.op.name]) - return "CompExpr(" + args + ")" + return f"CompExpr({self.left},{self.right},{self.op.name})" def __eq__(self, other): return _eq_bin_exprs(self, other, type(self)) @@ -369,8 +349,7 @@ def __init__(self, test, body, orelse): self.output_size = body.output_size def __str__(self): - args = ",".join([str(self.test), str(self.body), str(self.orelse)]) - return "IfExpr(" + args + ")" + return f"IfExpr({self.test},{self.body},{self.orelse})" def __eq__(self, other): return (type(other) is IfExpr and @@ -413,7 +392,7 @@ def count_exprs(expr, exclude_list=None): nested_f(expr))) expr_type_name = expr_type.__name__ - raise ValueError("Unexpected expression type '{}'".format(expr_type_name)) + raise ValueError(f"Unexpected expression type '{expr_type_name}'") def _eq_bin_exprs(expr_one, expr_two, expected_type): diff --git a/m2cgen/cli.py b/m2cgen/cli.py index af86ddf9..02e531b5 100644 --- a/m2cgen/cli.py +++ b/m2cgen/cli.py @@ -87,7 +87,7 @@ default=MAX_RECURSION_DEPTH) parser.add_argument( "--version", "-v", action="version", - version='%(prog)s {}'.format(m2cgen.__version__)) + version=f"%(prog)s {m2cgen.__version__}") def parse_args(args): diff --git a/m2cgen/interpreters/c/code_generator.py b/m2cgen/interpreters/c/code_generator.py index 38f44fa3..7014cd1f 100644 --- a/m2cgen/interpreters/c/code_generator.py +++ b/m2cgen/interpreters/c/code_generator.py @@ -18,11 +18,10 @@ def __init__(self, *args, **kwargs): def add_function_def(self, name, args, is_scalar_output): return_type = self.scalar_type if is_scalar_output else "void" - function_def = return_type + " " + name + "(" - function_def += ", ".join([ - self._get_var_type(is_vector) + " " + n + func_args = ", ".join([ + f"{self._get_var_type(is_vector)} {n}" for is_vector, n in args]) - function_def += ") {" + function_def = f"{return_type} {name}({func_args}) {{" self.add_code_line(function_def) self.increase_indent() @@ -52,15 +51,14 @@ def add_var_assignment(self, var_name, value, value_size): self.add_assign_array_statement(value, var_name, value_size) def add_assign_array_statement(self, source_var, target_var, size): - self.add_code_line("memcpy({}, {}, {} * sizeof(double));".format( - target_var, source_var, size)) + self.add_code_line(f"memcpy({target_var}, {source_var}, " + f"{size} * sizeof(double));") def add_dependency(self, dep): - dep_str = "#include " + dep - super().prepend_code_line(dep_str) + super().prepend_code_line(f"#include {dep}") def vector_init(self, values): - return "(double[]){" + ", ".join(values) + "}" + return f"(double[]){{{', '.join(values)}}}" def _get_var_type(self, is_vector): return ( diff --git a/m2cgen/interpreters/c/interpreter.py b/m2cgen/interpreters/c/interpreter.py index 8ff4a6c7..0d853da7 100644 --- a/m2cgen/interpreters/c/interpreter.py +++ b/m2cgen/interpreters/c/interpreter.py @@ -84,7 +84,7 @@ def interpret_bin_vector_expr(self, expr, **kwargs): func_inv = super().interpret_bin_vector_expr( expr, extra_func_args=[expr.output_size, var_name], **kwargs) - self._cg.add_code_line(func_inv + ";") + self._cg.add_code_line(f"{func_inv};") return var_name @@ -95,6 +95,6 @@ def interpret_bin_vector_num_expr(self, expr, **kwargs): func_inv = super().interpret_bin_vector_num_expr( expr, extra_func_args=[expr.output_size, var_name], **kwargs) - self._cg.add_code_line(func_inv + ";") + self._cg.add_code_line(f"{func_inv};") return var_name diff --git a/m2cgen/interpreters/c_sharp/code_generator.py b/m2cgen/interpreters/c_sharp/code_generator.py index 502449b3..ec63f399 100644 --- a/m2cgen/interpreters/c_sharp/code_generator.py +++ b/m2cgen/interpreters/c_sharp/code_generator.py @@ -12,23 +12,22 @@ def __init__(self, *args, **kwargs): super(CSharpCodeGenerator, self).__init__(*args, **kwargs) def add_class_def(self, class_name, modifier="public"): - class_def = modifier + " static class " + class_name + " {" + class_def = f"{modifier} static class {class_name} {{" self.add_code_line(class_def) self.increase_indent() def add_method_def(self, name, args, is_vector_output, modifier="private"): return_type = self._get_var_declare_type(is_vector_output) - method_def = modifier + " static " + return_type + " " + name + "(" - method_def += ",".join([ - self._get_var_declare_type(is_vector) + " " + n + func_args = ",".join([ + f"{self._get_var_declare_type(is_vector)} {n}" for is_vector, n in args]) - method_def += ") {" + method_def = f"{modifier} static {return_type} {name}({func_args}) {{" self.add_code_line(method_def) self.increase_indent() def add_namespace_def(self, namespace): - namespace_def = "namespace " + namespace + " {" + namespace_def = f"namespace {namespace} {{" self.add_code_line(namespace_def) self.increase_indent() @@ -52,8 +51,7 @@ def namespace_definition(self, namespace): self.add_block_termination() def vector_init(self, values): - return ("new double[{}] {{".format(len(values)) + - ", ".join(values) + "}") + return (f"new double[{len(values)}] {{{', '.join(values)}}}") def _get_var_declare_type(self, is_vector): return ( @@ -61,5 +59,4 @@ def _get_var_declare_type(self, is_vector): else self.scalar_type) def add_dependency(self, dep, modifier="static"): - dep_str = "using {0} {1};".format(modifier, dep) - self.prepend_code_line(dep_str) + self.prepend_code_line(f"using {modifier} {dep};") diff --git a/m2cgen/interpreters/code_generator.py b/m2cgen/interpreters/code_generator.py index 94ebac38..32d11271 100644 --- a/m2cgen/interpreters/code_generator.py +++ b/m2cgen/interpreters/code_generator.py @@ -73,7 +73,7 @@ def increase_indent(self): def decrease_indent(self): self._current_indent -= self._indent assert self._current_indent >= 0, ( - "Invalid indentation: {}".format(self._current_indent)) + f"Invalid indentation: {self._current_indent}") # All code modifications should be implemented via following methods. @@ -87,7 +87,7 @@ def add_code_lines(self, lines): lines = lines.strip().split("\n") indent = " " * self._current_indent self._write_to_code_buffer( - indent + "\n{}".format(indent).join(lines) + "\n") + indent + f"\n{indent}".join(lines) + "\n") def prepend_code_line(self, line): if not line: @@ -97,7 +97,8 @@ def prepend_code_line(self, line): def prepend_code_lines(self, lines): if isinstance(lines, str): lines = lines.strip().split("\n") - self._write_to_code_buffer("\n".join(lines) + "\n", prepend=True) + new_line = "\n" + self._write_to_code_buffer(f"{new_line.join(lines)}\n", prepend=True) # Following methods simply compute expressions using templates without # changing result. @@ -113,7 +114,7 @@ def array_index_access(self, array_name, index): array_name=array_name, index=index) def function_invocation(self, function_name, *args): - return function_name + "(" + ", ".join(map(str, args)) + ")" + return f"{function_name}({', '.join(map(str, args))})" # Helpers @@ -142,7 +143,7 @@ def reset_state(self): self._var_idx = 0 def get_var_name(self): - var_name = "var" + str(self._var_idx) + var_name = f"var{self._var_idx}" self._var_idx += 1 return var_name diff --git a/m2cgen/interpreters/dart/code_generator.py b/m2cgen/interpreters/dart/code_generator.py index 2f2f62b1..cf50f53c 100644 --- a/m2cgen/interpreters/dart/code_generator.py +++ b/m2cgen/interpreters/dart/code_generator.py @@ -13,11 +13,10 @@ def __init__(self, *args, **kwargs): def add_function_def(self, name, args, is_vector_output): return_type = self._get_var_declare_type(is_vector_output) - function_def = return_type + " " + name + "(" - function_def += ",".join([ - self._get_var_declare_type(is_vector) + " " + n + func_args = ",".join([ + f"{self._get_var_declare_type(is_vector)} {n}" for is_vector, n in args]) - function_def += ") {" + function_def = f"{return_type} {name}({func_args}) {{" self.add_code_line(function_def) self.increase_indent() @@ -28,11 +27,10 @@ def function_definition(self, name, args, is_vector_output): self.add_block_termination() def method_invocation(self, method_name, obj, args): - return ("(" + str(obj) + ")." + method_name + - "(" + ", ".join(map(str, args)) + ")") + return f"({obj}).{method_name}({', '.join(map(str, args))})" def vector_init(self, values): - return "[" + ", ".join(values) + "]" + return f"[{', '.join(values)}]" def _get_var_declare_type(self, is_vector): return ( @@ -40,5 +38,4 @@ def _get_var_declare_type(self, is_vector): else self.scalar_type) def add_dependency(self, dep): - dep_str = "import '" + dep + "';" - self.prepend_code_line(dep_str) + self.prepend_code_line(f"import '{dep}';") diff --git a/m2cgen/interpreters/go/code_generator.py b/m2cgen/interpreters/go/code_generator.py index 16917d31..e86a141d 100644 --- a/m2cgen/interpreters/go/code_generator.py +++ b/m2cgen/interpreters/go/code_generator.py @@ -24,11 +24,10 @@ def __init__(self, *args, **kwargs): def add_function_def(self, name, args, is_scalar_output): return_type = self._get_var_declare_type(not is_scalar_output) - function_def = "func " + name + "(" - function_def += ", ".join([ - n + " " + self._get_var_declare_type(is_vector) + func_args = ", ".join([ + f"{n} {self._get_var_declare_type(is_vector)}" for is_vector, n in args]) - function_def += ") " + return_type + " {" + function_def = f"func {name}({func_args}) {return_type} {{" self.add_code_line(function_def) self.increase_indent() @@ -42,9 +41,7 @@ def _get_var_declare_type(self, is_vector): return self.vector_type if is_vector else self.scalar_type def add_dependency(self, dep): - dep_str = 'import "' + dep + '"' - super().prepend_code_line(dep_str) + super().prepend_code_line(f'import "{dep}"') - @staticmethod - def vector_init(values): - return "[]float64{" + ", ".join(values) + "}" + def vector_init(self, values): + return f"[]float64{{{', '.join(values)}}}" diff --git a/m2cgen/interpreters/haskell/code_generator.py b/m2cgen/interpreters/haskell/code_generator.py index 26a34ec0..11cf8027 100644 --- a/m2cgen/interpreters/haskell/code_generator.py +++ b/m2cgen/interpreters/haskell/code_generator.py @@ -22,7 +22,7 @@ def array_index_access(self, array_name, index): left=array_name, op="!!", right=index) def add_if_statement(self, if_def): - self.add_code_line("if ({})".format(if_def)) + self.add_code_line(f"if ({if_def})") self.increase_indent() self.add_code_line("then") self.increase_indent() @@ -37,30 +37,29 @@ def add_if_termination(self): self.decrease_indent() def get_func_name(self): - func_name = "func" + str(self._func_idx) + func_name = f"func{self._func_idx}" self._func_idx += 1 return func_name def add_function(self, function_name, function_body): - self.add_code_line("{} =".format(function_name)) + self.add_code_line(f"{function_name} =") self.increase_indent() self.add_code_lines(function_body) self.decrease_indent() def function_invocation(self, function_name, *args): - return (function_name + " " + - " ".join(map(lambda x: "({})".format(x), args))) + function_args = " ".join(map(lambda x: f"({x})", args)) + return f"{function_name} {function_args}" def add_function_def(self, name, args, is_scalar_output): - signature = name + " :: " - signature += " -> ".join( + types = " -> ".join( ["[Double]" if is_vector else "Double" for is_vector, _ in [*args, (not is_scalar_output, None)]]) + signature = f"{name} :: {types}" self.add_code_line(signature) - function_def = name + " " - function_def += " ".join([n for _, n in args]) - function_def += " =" + func_args = " ".join([n for _, n in args]) + function_def = f"{name} {func_args} =" self.add_code_line(function_def) self.increase_indent() @@ -72,7 +71,7 @@ def function_definition(self, name, args, is_scalar_output): self.decrease_indent() def vector_init(self, values): - return "[" + ", ".join(values) + "]" + return f"[{', '.join(values)}]" def _comp_op_overwrite(self, op): if op == CompOpType.NOT_EQ: diff --git a/m2cgen/interpreters/interpreter.py b/m2cgen/interpreters/interpreter.py index 1e8fdaea..f142abbe 100644 --- a/m2cgen/interpreters/interpreter.py +++ b/m2cgen/interpreters/interpreter.py @@ -58,7 +58,7 @@ def _select_handler(self, expr): if hasattr(self, handler_name): return getattr(self, handler_name) raise NotImplementedError( - "No handler found for '{}'".format(type(expr).__name__)) + f"No handler found for '{type(expr).__name__}'") class BaseToCodeInterpreter(BaseInterpreter): diff --git a/m2cgen/interpreters/java/code_generator.py b/m2cgen/interpreters/java/code_generator.py index 598c4694..e243e1e3 100644 --- a/m2cgen/interpreters/java/code_generator.py +++ b/m2cgen/interpreters/java/code_generator.py @@ -12,24 +12,22 @@ def __init__(self, *args, **kwargs): super(JavaCodeGenerator, self).__init__(*args, **kwargs) def add_class_def(self, class_name, modifier="public"): - class_def = modifier + " class " + class_name + " {\n" + class_def = f"{modifier} class {class_name} {{" self.add_code_line(class_def) self.increase_indent() def add_method_def(self, name, args, is_vector_output, modifier="public"): return_type = self._get_var_declare_type(is_vector_output) - method_def = modifier + " static " + return_type + " " + name + "(" - method_def += ",".join([ - self._get_var_declare_type(is_vector) + " " + n + func_args = ",".join([ + f"{self._get_var_declare_type(is_vector)} {n}" for is_vector, n in args]) - method_def += ") {" + method_def = f"{modifier} static {return_type} {name}({func_args}) {{" self.add_code_line(method_def) self.increase_indent() def add_package_name(self, package_name): - package_def = "package " + package_name + ";\n" - self.add_code_line(package_def) + self.add_code_line(f"package {package_name};") @contextlib.contextmanager def class_definition(self, class_name): @@ -45,8 +43,7 @@ def method_definition(self, name, args, is_vector_output, self.add_block_termination() def vector_init(self, values): - return "new " + self.vector_output_type + ( - " {" + ", ".join(values) + "}") + return f"new {self.vector_output_type} {{{', '.join(values)}}}" def _get_var_declare_type(self, is_vector): return ( diff --git a/m2cgen/interpreters/javascript/code_generator.py b/m2cgen/interpreters/javascript/code_generator.py index 2c1726f9..e8f6f727 100644 --- a/m2cgen/interpreters/javascript/code_generator.py +++ b/m2cgen/interpreters/javascript/code_generator.py @@ -8,9 +8,7 @@ def __init__(self, *args, **kwargs): super(JavascriptCodeGenerator, self).__init__(*args, **kwargs) def add_function_def(self, name, args): - function_def = "function " + name + "(" - function_def += ",".join(args) - function_def += ") {" + function_def = f"function {name}({', '.join(args)}) {{" self.add_code_line(function_def) self.increase_indent() @@ -21,7 +19,7 @@ def function_definition(self, name, args): self.add_block_termination() def vector_init(self, values): - return "[" + ", ".join(values) + "]" + return f"[{', '.join(values)}]" def _get_var_declare_type(self, is_vector): return "var" diff --git a/m2cgen/interpreters/mixins.py b/m2cgen/interpreters/mixins.py index bb1dbdf8..54c54adc 100644 --- a/m2cgen/interpreters/mixins.py +++ b/m2cgen/interpreters/mixins.py @@ -62,8 +62,7 @@ class LinearAlgebraMixin(BaseToCodeInterpreter): def interpret_bin_vector_expr(self, expr, extra_func_args=(), **kwargs): if expr.op not in self.supported_bin_vector_ops: - raise NotImplementedError( - "Op '{}' is unsupported".format(expr.op.name)) + raise NotImplementedError(f"Op '{expr.op.name}' is unsupported") self.with_linear_algebra = True @@ -78,8 +77,7 @@ def interpret_bin_vector_expr(self, expr, extra_func_args=(), **kwargs): def interpret_bin_vector_num_expr(self, expr, extra_func_args=(), **kwargs): if expr.op not in self.supported_bin_vector_num_ops: - raise NotImplementedError( - "Op '{}' is unsupported".format(expr.op.name)) + raise NotImplementedError(f"Op '{expr.op.name}' is unsupported") self.with_linear_algebra = True @@ -192,7 +190,7 @@ def _process_subroutine(self, subroutine): return self._cg.finalize_and_get_generated_code() def _get_subroutine_name(self): - subroutine_name = "subroutine" + str(self._subroutine_idx) + subroutine_name = f"subroutine{self._subroutine_idx}" self._subroutine_idx += 1 return subroutine_name diff --git a/m2cgen/interpreters/php/code_generator.py b/m2cgen/interpreters/php/code_generator.py index c75649bd..62184572 100644 --- a/m2cgen/interpreters/php/code_generator.py +++ b/m2cgen/interpreters/php/code_generator.py @@ -13,11 +13,10 @@ def __init__(self, *args, **kwargs): super(PhpCodeGenerator, self).__init__(*args, **kwargs) def add_function_def(self, name, args): - function_def = "function " + name + "(" - function_def += ", ".join([ - ("array " if is_vector else "") + "$" + n + func_args = ", ".join([ + f"{'array ' if is_vector else ''}${n}" for is_vector, n in args]) - function_def += ") {" + function_def = f"function {name}({func_args}) {{" self.add_code_line(function_def) self.increase_indent() @@ -28,7 +27,7 @@ def function_definition(self, name, args): self.add_block_termination() def get_var_name(self): - return "$" + super().get_var_name() + return f"${super().get_var_name()}" def add_var_declaration(self, size): var_name = self.get_var_name() @@ -39,7 +38,7 @@ def add_var_declaration(self, size): return var_name def vector_init(self, values): - return "array(" + ", ".join(values) + ")" + return f"array({', '.join(values)})" def _comp_op_overwrite(self, op): if op == CompOpType.EQ: diff --git a/m2cgen/interpreters/powershell/code_generator.py b/m2cgen/interpreters/powershell/code_generator.py index e6577ba0..a1854bde 100644 --- a/m2cgen/interpreters/powershell/code_generator.py +++ b/m2cgen/interpreters/powershell/code_generator.py @@ -23,11 +23,10 @@ def __init__(self, *args, **kwargs): super(PowershellCodeGenerator, self).__init__(*args, **kwargs) def add_function_def(self, name, args, is_scalar_output): - function_def = "function " + name + "(" - function_def += ", ".join([ - self._get_var_type(is_vector) + " $" + n + func_args = ", ".join([ + f"{self._get_var_type(is_vector)} ${n}" for is_vector, n in args]) - function_def += ") {" + function_def = f"function {name}({func_args}) {{" self.add_code_line(function_def) self.increase_indent() @@ -38,14 +37,14 @@ def function_definition(self, name, args, is_scalar_output): self.add_block_termination() def function_invocation(self, function_name, *args): - return (function_name + " " + - " ".join(map(lambda x: "$({})".format(x), args))) + functions_args = " ".join(map(lambda x: f"$({x})", args)) + return f"{function_name} {functions_args}" def math_function_invocation(self, function_name, *args): - return function_name + "(" + ", ".join(map(str, args)) + ")" + return f"{function_name}({', '.join(map(str, args))})" def get_var_name(self): - return "$" + super().get_var_name() + return f"${super().get_var_name()}" def add_var_declaration(self, size): var_name = self.get_var_name() @@ -56,8 +55,8 @@ def add_var_declaration(self, size): return var_name def vector_init(self, values): - return ("@(" + - ", ".join(map(lambda x: "$({})".format(x), values)) + ")") + vals = ", ".join(map(lambda x: f"$({x})", values)) + return f"@({vals})" def _get_var_type(self, is_vector): return self.vector_type if is_vector else self.scalar_type diff --git a/m2cgen/interpreters/python/code_generator.py b/m2cgen/interpreters/python/code_generator.py index 37ea1907..8cbb5796 100644 --- a/m2cgen/interpreters/python/code_generator.py +++ b/m2cgen/interpreters/python/code_generator.py @@ -18,10 +18,8 @@ class PythonCodeGenerator(ImperativeCodeGenerator): tpl_block_termination = CT("") def add_function_def(self, name, args): - method_def = "def " + name + "(" - method_def += ", ".join(args) - method_def += "):" - self.add_code_line(method_def) + function_def = f"def {name}({', '.join(args)}):" + self.add_code_line(function_def) self.increase_indent() @contextlib.contextmanager @@ -30,10 +28,10 @@ def function_definition(self, name, args): yield def vector_init(self, values): - return "[" + ", ".join(values) + "]" + return f"[{', '.join(values)}]" def add_dependency(self, dep, alias=None): - dep_str = "import " + dep + dep_str = f"import {dep}" if alias: - dep_str += " as " + alias + dep_str += f" as {alias}" self.prepend_code_line(dep_str) diff --git a/m2cgen/interpreters/r/code_generator.py b/m2cgen/interpreters/r/code_generator.py index 29f89d29..54cf65c0 100644 --- a/m2cgen/interpreters/r/code_generator.py +++ b/m2cgen/interpreters/r/code_generator.py @@ -16,9 +16,8 @@ def add_var_declaration(self, size): return self.get_var_name() def add_function_def(self, name, args): - function_def = name + " <- function(" - function_def += ",".join([arg for _, arg in args]) - function_def += ") {" + func_args = ', '.join([arg for _, arg in args]) + function_def = f"{name} <- function({func_args}) {{" self.add_code_line(function_def) self.increase_indent() @@ -32,4 +31,4 @@ def array_index_access(self, array_name, index): return super().array_index_access(array_name, index + 1) def vector_init(self, values): - return "c(" + ", ".join(values) + ")" + return f"c({', '.join(values)})" diff --git a/m2cgen/interpreters/ruby/code_generator.py b/m2cgen/interpreters/ruby/code_generator.py index 98cb0e6e..83dfdf91 100644 --- a/m2cgen/interpreters/ruby/code_generator.py +++ b/m2cgen/interpreters/ruby/code_generator.py @@ -17,9 +17,7 @@ class RubyCodeGenerator(ImperativeCodeGenerator): tpl_var_assignment = CT("{var_name} = {value}") def add_function_def(self, name, args): - func_def = "def " + name + "(" - func_def += ", ".join(args) - func_def += ")" + func_def = f"def {name}({', '.join(args)})" self.add_code_line(func_def) self.increase_indent() @@ -30,8 +28,7 @@ def function_definition(self, name, args): self.add_block_termination() def method_invocation(self, method_name, obj, args): - return ("(" + str(obj) + ")." + method_name + - "(" + ", ".join(map(str, args)) + ")") + return f"({obj}).{method_name}({', '.join(map(str, args))})" def vector_init(self, values): - return "[" + ", ".join(values) + "]" + return f"[{', '.join(values)}]" diff --git a/m2cgen/interpreters/utils.py b/m2cgen/interpreters/utils.py index e43580d3..f32cd68c 100644 --- a/m2cgen/interpreters/utils.py +++ b/m2cgen/interpreters/utils.py @@ -17,8 +17,7 @@ def get_file_content(path): @lru_cache(maxsize=1 << ceil(log(TOTAL_NUMBER_OF_EXPRESSIONS, 2))) def _get_handler_name(expr_tpe): - expr_name = _normalize_expr_name(expr_tpe.__name__) - return "interpret_" + expr_name + return f"interpret_{_normalize_expr_name(expr_tpe.__name__)}" def _normalize_expr_name(name): diff --git a/m2cgen/interpreters/visual_basic/code_generator.py b/m2cgen/interpreters/visual_basic/code_generator.py index 57f63633..f4ac5415 100644 --- a/m2cgen/interpreters/visual_basic/code_generator.py +++ b/m2cgen/interpreters/visual_basic/code_generator.py @@ -30,7 +30,7 @@ def add_return_statement(self, value, func_name): def add_var_declaration(self, size, exac_size=False): var_name = self.get_var_name() - type_modifier = ("({})".format((size - 1) if exac_size else "") + type_modifier = (f"({(size - 1) if exac_size else ''})" if size > 1 else "") self.add_code_line( self.tpl_var_declaration( @@ -44,15 +44,13 @@ def add_block_termination(self, block_name="If"): self.add_code_line(self.tpl_block_termination(block_name=block_name)) def add_function_def(self, name, args, is_scalar_output): - return_type = self.scalar_type - return_type += "" if is_scalar_output else "()" + return_type = f"{self.scalar_type}{'' if is_scalar_output else '()'}" - function_def = "Function " + name + "(" - function_def += ", ".join([ - ("ByRef " if is_vector else "ByVal ") + n + - ("()" if is_vector else "") + " As " + self.scalar_type + func_args = ", ".join([ + f"{'ByRef' if is_vector else 'ByVal'} {n}" + f"{'()' if is_vector else ''} As {self.scalar_type}" for is_vector, n in args]) - function_def += ") As " + return_type + function_def = f"Function {name}({func_args}) As {return_type}" self.add_code_line(function_def) self.increase_indent()