Fix ruff lint errors in onnx2c backend

- Extract _io_lines() and _parse_graph_io() and _build_binary() helpers
  to reduce McCabe complexity of _generate_harness (9→3) and prepare (11→4)
- Use math.prod() instead of manual shape product loops
- Fix Q003: use single outer quotes in f-strings containing double quotes
- Add missing docstrings (D102, D105, D107)
- Add strict=False to zip() calls (B905)
- Suppress BLE001 with noqa on intentional broad except clauses

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: andife

backends/onnx2c/backend.py

@@ -2,6 +2,7 @@
 
 """ONNX backend wrapper for onnx2c (ONNX to C code generator)."""
 
+import math
 import os
 import re
 import shutil
@@ -74,6 +75,24 @@ def _parse_tensor_info(value_info):
     return _c_name(value_info.name), c_type, np_dtype, shape
 
 
+def _io_lines(tensors_info, arg_offset, mode):
+    """Return C lines that open and read/write tensor binary files via argv."""
+    rw_func = "fread" if mode == "rb" else "fwrite"
+    direction = "input" if mode == "rb" else "output"
+    lines = []
+    for i, (c_nm, c_type, _, shape) in enumerate(tensors_info):
+        n = math.prod(shape)
+        arg_idx = arg_offset + i + 1
+        lines.append(f'    f = fopen(argv[{arg_idx}], "{mode}");')
+        lines.append(
+            f'    if (!f) {{ fprintf(stderr, "Cannot open {direction} {i}\\n"); '
+            f"return 1; }}"
+        )
+        lines.append(f"    {rw_func}({c_nm}, sizeof({c_type}), {n}, f);")
+        lines.append("    fclose(f);")
+    return lines
+
+
 def _generate_harness(inputs_info, outputs_info):
     """Return C harness source that feeds inputs, calls entry(), writes outputs."""
     lines = [
@@ -84,74 +103,109 @@ def _generate_harness(inputs_info, outputs_info):
         "",
     ]
 
-    # extern declarations for input/output tensors (defined in generated model.c)
     for c_nm, c_type, _, shape in inputs_info:
-        n = 1
-        for d in shape:
-            n *= d
-        lines.append(f"extern {c_type} {c_nm}[{n}];")
+        lines.append(f"extern {c_type} {c_nm}[{math.prod(shape)}];")
 
     for c_nm, c_type, _, shape in outputs_info:
-        n = 1
-        for d in shape:
-            n *= d
-        lines.append(f"extern {c_type} {c_nm}[{n}];")
+        lines.append(f"extern {c_type} {c_nm}[{math.prod(shape)}];")
 
     lines += ["", "void entry(void);", "", "int main(int argc, char** argv) {"]
     lines.append("    FILE* f;")
     lines.append("")
+    lines += _io_lines(inputs_info, 0, "rb")
+    lines += ["", "    entry();", ""]
+    lines += _io_lines(outputs_info, len(inputs_info), "wb")
+    lines += ["", "    return 0;", "}"]
+    return "\n".join(lines)
 
-    # Read inputs from files passed as argv[1..n_inputs]
-    for i, (c_nm, c_type, _, shape) in enumerate(inputs_info):
-        n = 1
-        for d in shape:
-            n *= d
-        lines.append(f"    f = fopen(argv[{i + 1}], \"rb\");")
-        lines.append(
-            f"    if (!f) {{ fprintf(stderr, \"Cannot open input {i}\\n\"); return 1; }}"
-        )
-        lines.append(f"    fread({c_nm}, sizeof({c_type}), {n}, f);")
-        lines.append("    fclose(f);")
 
-    lines += ["", "    entry();", ""]
+def _parse_graph_io(graph):
+    """Parse graph inputs/outputs; return (inputs_info, outputs_info) or raise."""
+    initializer_names = {init.name for init in graph.initializer}
+    inputs_info = []
+    for vi in graph.input:
+        if vi.name in initializer_names:
+            continue
+        info = _parse_tensor_info(vi)
+        if info is None:
+            raise BackendIsNotSupposedToImplementIt(
+                f"Input '{vi.name}' has unsupported type or dynamic shape"
+            )
+        inputs_info.append(info)
+
+    outputs_info = []
+    for vi in graph.output:
+        info = _parse_tensor_info(vi)
+        if info is None:
+            raise BackendIsNotSupposedToImplementIt(
+                f"Output '{vi.name}' has unsupported type or dynamic shape"
+            )
+        outputs_info.append(info)
 
-    # Write outputs to files passed as argv[n_inputs+1..n_inputs+n_outputs]
-    n_in = len(inputs_info)
-    for i, (c_nm, c_type, _, shape) in enumerate(outputs_info):
-        n = 1
-        for d in shape:
-            n *= d
-        lines.append(f"    f = fopen(argv[{n_in + i + 1}], \"wb\");")
-        lines.append(
-            f"    if (!f) {{ fprintf(stderr, \"Cannot open output {i}\\n\"); return 1; }}"
-        )
-        lines.append(f"    fwrite({c_nm}, sizeof({c_type}), {n}, f);")
-        lines.append("    fclose(f);")
+    return inputs_info, outputs_info
 
-    lines += ["", "    return 0;", "}"]
-    return "\n".join(lines)
+
+def _build_binary(workdir, model, inputs_info, outputs_info):
+    """Compile the ONNX model to a native binary; return the binary path."""
+    model_path = os.path.join(workdir, "model.onnx")
+    with open(model_path, "wb") as f:
+        f.write(model.SerializeToString())
+
+    result = subprocess.run(
+        ["onnx2c", model_path], capture_output=True, timeout=120
+    )
+    if result.returncode != 0:
+        raise BackendIsNotSupposedToImplementIt(
+            f"onnx2c failed: {result.stderr.decode()}"
+        )
+    model_c_path = os.path.join(workdir, "model.c")
+    with open(model_c_path, "wb") as f:
+        f.write(result.stdout)
+
+    harness_path = os.path.join(workdir, "harness.c")
+    with open(harness_path, "w") as f:
+        f.write(_generate_harness(inputs_info, outputs_info))
+
+    binary_path = os.path.join(workdir, "model_exec")
+    result = subprocess.run(
+        ["gcc", "-O2", "-o", binary_path, harness_path, model_c_path, "-lm"],
+        capture_output=True,
+        timeout=120,
+    )
+    if result.returncode != 0:
+        raise BackendIsNotSupposedToImplementIt(
+            f"Compilation failed: {result.stderr.decode()}"
+        )
+    return binary_path
 
 
 class Onnx2cBackendRep(BackendRep):
     """Holds a compiled onnx2c binary and runs it for each inference call."""
 
     def __init__(self, binary_path, workdir, inputs_info, outputs_info):
+        """Store compiled binary path and run-time type/shape information."""
         self._binary = binary_path
         self._workdir = workdir
         # Store only dtype and shape needed at run time
         self._input_dtypes = [np_dtype for _, _, np_dtype, _ in inputs_info]
-        self._output_info = [(np_dtype, shape) for _, _, np_dtype, shape in outputs_info]
+        self._output_info = [
+            (np_dtype, shape) for _, _, np_dtype, shape in outputs_info
+        ]
 
     def __del__(self):
+        """Remove the temporary working directory on garbage collection."""
         if self._workdir and os.path.isdir(self._workdir):
             shutil.rmtree(self._workdir, ignore_errors=True)
 
     def run(self, inputs, **kwargs):
+        """Write inputs as binary files, invoke compiled binary, return outputs."""
         run_dir = tempfile.mkdtemp()
         try:
             # Write each input as raw binary with the expected dtype
             input_files = []
-            for i, (inp, dtype) in enumerate(zip(inputs, self._input_dtypes)):
+            for i, (inp, dtype) in enumerate(
+                zip(inputs, self._input_dtypes, strict=False)
+            ):
                 path = os.path.join(run_dir, f"input_{i}.bin")
                 np.asarray(inp, dtype=dtype).flatten().tofile(path)
                 input_files.append(path)
@@ -172,7 +226,9 @@ def run(self, inputs, **kwargs):
                 )
 
             outputs = []
-            for path, (dtype, shape) in zip(output_files, self._output_info):
+            for path, (dtype, shape) in zip(
+                output_files, self._output_info, strict=False
+            ):
                 arr = np.fromfile(path, dtype=dtype).reshape(shape)
                 outputs.append(arr)
             return outputs
@@ -185,91 +241,38 @@ class Onnx2cBackend(Backend):
 
     @classmethod
     def is_compatible(cls, model, device="CPU", **kwargs):
+        """Return whether this backend can attempt to handle the model."""
         return True
 
     @classmethod
     def prepare(cls, model, device="CPU", **kwargs):
-        # Run ONNX shape inference so output shapes are concrete where possible
+        """Compile the ONNX model to native code and return a runnable rep."""
         try:
             model = shape_inference.infer_shapes(model)
-        except Exception:
+        except Exception:  # noqa: BLE001
             pass
 
-        initializer_names = {init.name for init in model.graph.initializer}
-
-        # Parse inputs (exclude initializers / weights)
-        inputs_info = []
-        for vi in model.graph.input:
-            if vi.name in initializer_names:
-                continue
-            info = _parse_tensor_info(vi)
-            if info is None:
-                raise BackendIsNotSupposedToImplementIt(
-                    f"Input '{vi.name}' has unsupported type or dynamic shape"
-                )
-            inputs_info.append(info)
-
-        # Parse outputs
-        outputs_info = []
-        for vi in model.graph.output:
-            info = _parse_tensor_info(vi)
-            if info is None:
-                raise BackendIsNotSupposedToImplementIt(
-                    f"Output '{vi.name}' has unsupported type or dynamic shape"
-                )
-            outputs_info.append(info)
+        inputs_info, outputs_info = _parse_graph_io(model.graph)
 
         workdir = tempfile.mkdtemp()
         try:
-            # Serialize model
-            model_path = os.path.join(workdir, "model.onnx")
-            with open(model_path, "wb") as f:
-                f.write(model.SerializeToString())
-
-            # Generate C code with onnx2c
-            result = subprocess.run(
-                ["onnx2c", model_path], capture_output=True, timeout=120
-            )
-            if result.returncode != 0:
-                raise BackendIsNotSupposedToImplementIt(
-                    f"onnx2c failed: {result.stderr.decode()}"
-                )
-            model_c_path = os.path.join(workdir, "model.c")
-            with open(model_c_path, "wb") as f:
-                f.write(result.stdout)
-
-            # Write harness
-            harness_path = os.path.join(workdir, "harness.c")
-            with open(harness_path, "w") as f:
-                f.write(_generate_harness(inputs_info, outputs_info))
-
-            # Compile
-            binary_path = os.path.join(workdir, "model_exec")
-            result = subprocess.run(
-                ["gcc", "-O2", "-o", binary_path, harness_path, model_c_path, "-lm"],
-                capture_output=True,
-                timeout=120,
-            )
-            if result.returncode != 0:
-                raise BackendIsNotSupposedToImplementIt(
-                    f"Compilation failed: {result.stderr.decode()}"
-                )
-
+            binary_path = _build_binary(workdir, model, inputs_info, outputs_info)
             return Onnx2cBackendRep(binary_path, workdir, inputs_info, outputs_info)
-
         except BackendIsNotSupposedToImplementIt:
             shutil.rmtree(workdir, ignore_errors=True)
             raise
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             shutil.rmtree(workdir, ignore_errors=True)
             raise BackendIsNotSupposedToImplementIt(str(e)) from e
 
     @classmethod
     def run_model(cls, model, inputs, device="CPU", **kwargs):
+        """Prepare then run a model in one call."""
         return cls.prepare(model, device, **kwargs).run(inputs)
 
     @classmethod
     def supports_device(cls, device):
+        """Return whether the backend supports the given device."""
         return device == "CPU"