format

Signed-off-by: Gregor Zeitlinger <[email protected]>

Author: zeitlinger

.mise/tasks/lint-bom.py

@@ -77,7 +77,9 @@ def collect_have(bom_pom: Path) -> List[str]:
 
     text = bom_pom.read_text(encoding="utf-8")
     # find artifactId values that start with MODULE_PREFIX
-    matches = re.findall(r"<artifactId>\s*(%s[^<\s]*)\s*</artifactId>" % re.escape(MODULE_PREFIX), text)
+    matches = re.findall(
+        r"<artifactId>\s*(%s[^<\s]*)\s*</artifactId>" % re.escape(MODULE_PREFIX), text
+    )
     return sorted(matches)
 
 
@@ -90,13 +92,20 @@ def main() -> int:
         have_text = "\n".join(have)
 
         if want_text != have_text:
-            print("The BOM file prometheus-metrics-bom/bom.xml does not match the current directory contents.")
+            print(
+                "The BOM file prometheus-metrics-bom/bom.xml does not match the current directory contents."
+            )
             print("Expected:")
             print(want_text)
             print("Found:")
             print(have_text)
             print()
-            diff = difflib.unified_diff(have_text.splitlines(keepends=True), want_text.splitlines(keepends=True), fromfile="found", tofile="expected")
+            diff = difflib.unified_diff(
+                have_text.splitlines(keepends=True),
+                want_text.splitlines(keepends=True),
+                fromfile="found",
+                tofile="expected",
+            )
             sys.stdout.writelines(diff)
             return 1
         else:
@@ -110,4 +119,3 @@ def main() -> int:
 
 if __name__ == "__main__":
     sys.exit(main())
-

.mise/tasks/super-linter.sh

@@ -4,8 +4,6 @@
 
 set -euo pipefail
 
-pushd "$(dirname "$0")/.."
-
 docker pull ghcr.io/super-linter/super-linter:latest
 
 docker run --rm \

.mise/tasks/test_update-benchmarks.py

@@ -16,11 +16,11 @@ class TestRunBenchmarksFiltering(unittest.TestCase):
     def setUp(self):
         # sample JMH table with mixed-class lines
         self.table = (
-            'Benchmark                                             Mode  Cnt       Score   Error  Units\n'
-            'CounterBenchmark.codahaleIncNoLabels                 thrpt        57881.585          ops/s\n'
-            'HistogramBenchmark.prometheusNative                  thrpt         2385.134          ops/s\n'
-            'TextFormatUtilBenchmark.prometheusWriteToNull        thrpt       885331.328          ops/s\n'
-            'CounterBenchmark.prometheusInc                       thrpt        54090.469          ops/s\n'
+            "Benchmark                                             Mode  Cnt       Score   Error  Units\n"
+            "CounterBenchmark.codahaleIncNoLabels                 thrpt        57881.585          ops/s\n"
+            "HistogramBenchmark.prometheusNative                  thrpt         2385.134          ops/s\n"
+            "TextFormatUtilBenchmark.prometheusWriteToNull        thrpt       885331.328          ops/s\n"
+            "CounterBenchmark.prometheusInc                       thrpt        54090.469          ops/s\n"
         )
 
         # create temp dir to act as module path
@@ -30,61 +30,69 @@ def setUp(self):
         # Create three files with a javadoc <pre> block that contains mixed results
         self.files = {}
         javadoc_pre = (
-            '/**\n'
-            ' * Example javadoc\n'
-            ' * <pre>\n'
-            ' * Benchmark                                             Mode  Cnt       Score   Error  Units\n'
-            ' * CounterBenchmark.codahaleIncNoLabels                 thrpt        57881.585          ops/s\n'
-            ' * HistogramBenchmark.prometheusNative                  thrpt         2385.134          ops/s\n'
-            ' * TextFormatUtilBenchmark.prometheusWriteToNull        thrpt       885331.328          ops/s\n'
-            ' * CounterBenchmark.prometheusInc                       thrpt        54090.469          ops/s\n'
-            ' * </pre>\n'
-            ' */\n'
+            "/**\n"
+            " * Example javadoc\n"
+            " * <pre>\n"
+            " * Benchmark                                             Mode  Cnt       Score   Error  Units\n"
+            " * CounterBenchmark.codahaleIncNoLabels                 thrpt        57881.585          ops/s\n"
+            " * HistogramBenchmark.prometheusNative                  thrpt         2385.134          ops/s\n"
+            " * TextFormatUtilBenchmark.prometheusWriteToNull        thrpt       885331.328          ops/s\n"
+            " * CounterBenchmark.prometheusInc                       thrpt        54090.469          ops/s\n"
+            " * </pre>\n"
+            " */\n"
         )
 
-        for cls in ('CounterBenchmark', 'HistogramBenchmark', 'TextFormatUtilBenchmark'):
-            fname = os.path.join(self.module_path, f'{cls}.java')
-            with open(fname, 'w', encoding='utf-8') as f:
+        for cls in (
+            "CounterBenchmark",
+            "HistogramBenchmark",
+            "TextFormatUtilBenchmark",
+        ):
+            fname = os.path.join(self.module_path, f"{cls}.java")
+            with open(fname, "w", encoding="utf-8") as f:
                 f.write(javadoc_pre)
-                f.write(f'public class {cls} {{}}\n')
+                f.write(f"public class {cls} {{}}\n")
             self.files[cls] = fname
 
     def tearDown(self):
         self.tmpdir.cleanup()
 
     def _read_pre_contents(self, path):
-        with open(path, 'r', encoding='utf-8') as f:
+        with open(path, "r", encoding="utf-8") as f:
             content = f.read()
-        m = re.search(r'<pre>\n([\s\S]*?)</pre>', content)
-        return m.group(1) if m else ''
+        m = re.search(r"<pre>\n([\s\S]*?)</pre>", content)
+        return m.group(1) if m else ""
 
     def test_update_only_inserts_matching_class_lines(self):
         updated = update_pre_blocks_under_module(self.module_path, self.table)
         # All three files should be updated
-        self.assertEqual(set(os.path.basename(p) for p in updated),
-                         {os.path.basename(self.files['CounterBenchmark']),
-                          os.path.basename(self.files['HistogramBenchmark']),
-                          os.path.basename(self.files['TextFormatUtilBenchmark'])})
+        self.assertEqual(
+            set(os.path.basename(p) for p in updated),
+            {
+                os.path.basename(self.files["CounterBenchmark"]),
+                os.path.basename(self.files["HistogramBenchmark"]),
+                os.path.basename(self.files["TextFormatUtilBenchmark"]),
+            },
+        )
 
         # Verify CounterBenchmark file contains only CounterBenchmark lines
-        cb_pre = self._read_pre_contents(self.files['CounterBenchmark'])
-        self.assertIn('CounterBenchmark.codahaleIncNoLabels', cb_pre)
-        self.assertIn('CounterBenchmark.prometheusInc', cb_pre)
-        self.assertNotIn('HistogramBenchmark.prometheusNative', cb_pre)
-        self.assertNotIn('TextFormatUtilBenchmark.prometheusWriteToNull', cb_pre)
+        cb_pre = self._read_pre_contents(self.files["CounterBenchmark"])
+        self.assertIn("CounterBenchmark.codahaleIncNoLabels", cb_pre)
+        self.assertIn("CounterBenchmark.prometheusInc", cb_pre)
+        self.assertNotIn("HistogramBenchmark.prometheusNative", cb_pre)
+        self.assertNotIn("TextFormatUtilBenchmark.prometheusWriteToNull", cb_pre)
 
         # Verify HistogramBenchmark contains only its line
-        hb_pre = self._read_pre_contents(self.files['HistogramBenchmark'])
-        self.assertIn('HistogramBenchmark.prometheusNative', hb_pre)
-        self.assertNotIn('CounterBenchmark.codahaleIncNoLabels', hb_pre)
-        self.assertNotIn('TextFormatUtilBenchmark.prometheusWriteToNull', hb_pre)
+        hb_pre = self._read_pre_contents(self.files["HistogramBenchmark"])
+        self.assertIn("HistogramBenchmark.prometheusNative", hb_pre)
+        self.assertNotIn("CounterBenchmark.codahaleIncNoLabels", hb_pre)
+        self.assertNotIn("TextFormatUtilBenchmark.prometheusWriteToNull", hb_pre)
 
         # Verify TextFormatUtilBenchmark contains only its line
-        tf_pre = self._read_pre_contents(self.files['TextFormatUtilBenchmark'])
-        self.assertIn('TextFormatUtilBenchmark.prometheusWriteToNull', tf_pre)
-        self.assertNotIn('CounterBenchmark.prometheusInc', tf_pre)
-        self.assertNotIn('HistogramBenchmark.prometheusNative', tf_pre)
+        tf_pre = self._read_pre_contents(self.files["TextFormatUtilBenchmark"])
+        self.assertIn("TextFormatUtilBenchmark.prometheusWriteToNull", tf_pre)
+        self.assertNotIn("CounterBenchmark.prometheusInc", tf_pre)
+        self.assertNotIn("HistogramBenchmark.prometheusNative", tf_pre)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

.mise/tasks/update_benchmarks.py

@@ -38,7 +38,9 @@ def run_cmd(cmd: List[str], cwd: Optional[str] = None) -> str:
     progress in real time while the command runs.
     """
     try:
-        proc = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        proc = subprocess.Popen(
+            cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+        )
     except FileNotFoundError:
         # Helpful message if the executable is not found
         print(f"Command not found: {cmd[0]}")
@@ -50,45 +52,49 @@ def run_cmd(cmd: List[str], cwd: Optional[str] = None) -> str:
         # Stream lines as they appear and capture them for returning
         for line in proc.stdout:
             # Print immediately so callers (and CI) can observe progress
-            print(line, end='')
+            print(line, end="")
             output_lines.append(line)
         proc.wait()
     except KeyboardInterrupt:
         # If the user interrupts, ensure the child process is terminated
         proc.kill()
         proc.wait()
-        print('\nCommand interrupted by user.')
+        print("\nCommand interrupted by user.")
         raise
 
-    output = ''.join(output_lines)
+    output = "".join(output_lines)
     if proc.returncode != 0:
-        print(f"Command failed: {' '.join(cmd)}\nExit: {proc.returncode}\nOutput:\n{output}")
+        print(
+            f"Command failed: {' '.join(cmd)}\nExit: {proc.returncode}\nOutput:\n{output}"
+        )
         raise SystemExit(proc.returncode)
     return output
 
 
 def build_benchmarks(mvnw: str, module: str) -> None:
     print(f"Building Maven module '{module}' using {mvnw} (this may take a while)...")
-    cmd = [mvnw, '-pl', module, '-am', '-DskipTests', 'package']
+    cmd = [mvnw, "-pl", module, "-am", "-DskipTests", "package"]
     run_cmd(cmd)
     print("Build completed.")
 
 
 def find_benchmarks_jar(module: str) -> str:
-    pattern = os.path.join(module, 'target', '*.jar')
-    jars = [p for p in glob.glob(pattern) if 'original' not in p and p.endswith('.jar')]
+    pattern = os.path.join(module, "target", "*.jar")
+    jars = [p for p in glob.glob(pattern) if "original" not in p and p.endswith(".jar")]
     # prefer jar whose basename contains module name
     jars_pref = [j for j in jars if module in os.path.basename(j)]
     chosen = (jars_pref or jars)[:1]
     if not chosen:
-        raise FileNotFoundError(f"No jar found in {os.path.join(module, 'target')} (tried: {pattern})")
+        raise FileNotFoundError(
+            f"No jar found in {os.path.join(module, 'target')} (tried: {pattern})"
+        )
     jar = chosen[0]
     print(f"Using jar: {jar}")
     return jar
 
 
 def run_jmh(jar: str, java_cmd: str, extra_args: Optional[str]) -> str:
-    args = [java_cmd, '-jar', jar, '-rf', 'text']
+    args = [java_cmd, "-jar", jar, "-rf", "text"]
     if extra_args:
         args += shlex.split(extra_args)
     print(f"Running JMH: {' '.join(args)}")
@@ -99,16 +105,23 @@ def run_jmh(jar: str, java_cmd: str, extra_args: Optional[str]) -> str:
 
 def extract_first_table(jmh_output: str) -> str:
     # Try to extract the first table that starts with "Benchmark" header and continues until a blank line
-    m = re.search(r'(\nBenchmark\s+Mode[\s\S]*?)(?:\n\s*\n|\Z)', jmh_output)
+    m = re.search(r"(\nBenchmark\s+Mode[\s\S]*?)(?:\n\s*\n|\Z)", jmh_output)
     if not m:
         # fallback: collect all lines that contain 'thrpt' plus a header if present
-        lines = [l for l in jmh_output.splitlines() if 'thrpt' in l]
+        lines = [l for l in jmh_output.splitlines() if "thrpt" in l]
         if not lines:
             raise ValueError('Could not find any "thrpt" lines in JMH output')
         # try to find header
-        header = next((l for l in jmh_output.splitlines() if l.startswith('Benchmark') and 'Mode' in l), 'Benchmark                                     Mode  Cnt      Score     Error  Units')
-        return header + '\n' + '\n'.join(lines)
-    table = m.group(1).strip('\n')
+        header = next(
+            (
+                l
+                for l in jmh_output.splitlines()
+                if l.startswith("Benchmark") and "Mode" in l
+            ),
+            "Benchmark                                     Mode  Cnt      Score     Error  Units",
+        )
+        return header + "\n" + "\n".join(lines)
+    table = m.group(1).strip("\n")
     # Ensure we return only the table lines (remove any leading iteration info lines that JMH sometimes prints)
     # Normalize spaces: keep as-is
     return table
@@ -123,35 +136,39 @@ def filter_table_for_class(table: str, class_name: str) -> Optional[str]:
     # find header line index (starts with 'Benchmark' and contains 'Mode')
     header_idx = None
     for i, ln in enumerate(lines):
-        if ln.strip().startswith('Benchmark') and 'Mode' in ln:
+        if ln.strip().startswith("Benchmark") and "Mode" in ln:
             header_idx = i
             break
-    header = lines[header_idx] if header_idx is not None else 'Benchmark                                     Mode  Cnt      Score     Error  Units'
+    header = (
+        lines[header_idx]
+        if header_idx is not None
+        else "Benchmark                                     Mode  Cnt      Score     Error  Units"
+    )
 
     matched = []
-    pattern = re.compile(r'^\s*' + re.escape(class_name) + r'\.')
-    for ln in lines[header_idx + 1 if header_idx is not None else 0:]:
-        if 'thrpt' in ln and pattern.search(ln):
+    pattern = re.compile(r"^\s*" + re.escape(class_name) + r"\.")
+    for ln in lines[header_idx + 1 if header_idx is not None else 0 :]:
+        if "thrpt" in ln and pattern.search(ln):
             matched.append(ln)
 
     if not matched:
         return None
-    return header + '\n' + '\n'.join(matched)
+    return header + "\n" + "\n".join(matched)
 
 
 def update_pre_blocks_under_module(module: str, table: str) -> List[str]:
     # Find files under module and update any <pre>...</pre> block that contains 'thrpt'
     updated_files = []
-    for path in glob.glob(os.path.join(module, '**'), recursive=True):
+    for path in glob.glob(os.path.join(module, "**"), recursive=True):
         if os.path.isdir(path):
             continue
         try:
-            with open(path, 'r', encoding='utf-8') as f:
+            with open(path, "r", encoding="utf-8") as f:
                 content = f.read()
         except Exception:
             continue
         # quick filter
-        if '<pre>' not in content or 'thrpt' not in content:
+        if "<pre>" not in content or "thrpt" not in content:
             continue
 
         original = content
@@ -169,21 +186,21 @@ def update_pre_blocks_under_module(module: str, table: str) -> List[str]:
 
         # Regex to find any line-starting Javadoc prefix like " * " before <pre>
         # This will match patterns like: " * <pre>... </pre>" and capture the prefix (e.g. " * ")
-        pattern = re.compile(r'(?m)^(?P<prefix>[ \t]*\*[ \t]*)<pre>[\s\S]*?</pre>')
+        pattern = re.compile(r"(?m)^(?P<prefix>[ \t]*\*[ \t]*)<pre>[\s\S]*?</pre>")
 
         def repl(m: re.Match) -> str:
-            prefix = m.group('prefix')
+            prefix = m.group("prefix")
             # Build the new block with the same prefix on each line
             lines = filtered_table.splitlines()
-            replaced = prefix + '<pre>\n'
+            replaced = prefix + "<pre>\n"
             for ln in lines:
-                replaced += prefix + ln.rstrip() + '\n'
-            replaced += prefix + '</pre>'
+                replaced += prefix + ln.rstrip() + "\n"
+            replaced += prefix + "</pre>"
             return replaced
 
         new_content, nsubs = pattern.subn(repl, content)
         if nsubs > 0 and new_content != original:
-            with open(path, 'w', encoding='utf-8') as f:
+            with open(path, "w", encoding="utf-8") as f:
                 f.write(new_content)
             updated_files.append(path)
             print(f"Updated {path}: replaced {nsubs} <pre> block(s)")
@@ -192,34 +209,41 @@ def repl(m: re.Match) -> str:
 
 def main(argv: List[str]):
     parser = argparse.ArgumentParser()
-    parser.add_argument('--mvnw', default='./mvnw', help='Path to maven wrapper')
-    parser.add_argument('--module', default='benchmarks', help='Module directory to build/run')
-    parser.add_argument('--java', default='java', help='Java command')
-    parser.add_argument('--jmh-args', default='', help='Extra arguments to pass to the JMH main (e.g. "-f 1 -wi 0 -i 1")')
+    parser.add_argument("--mvnw", default="./mvnw", help="Path to maven wrapper")
+    parser.add_argument(
+        "--module", default="benchmarks", help="Module directory to build/run"
+    )
+    parser.add_argument("--java", default="java", help="Java command")
+    parser.add_argument(
+        "--jmh-args",
+        default="",
+        help='Extra arguments to pass to the JMH main (e.g. "-f 1 -wi 0 -i 1")',
+    )
     args = parser.parse_args(argv)
 
     build_benchmarks(args.mvnw, args.module)
     jar = find_benchmarks_jar(args.module)
     output = run_jmh(jar, args.java, args.jmh_args)
 
     # Print a short preview of the JMH output
-    preview = '\n'.join(output.splitlines()[:120])
-    print('\n--- JMH output preview ---')
+    preview = "\n".join(output.splitlines()[:120])
+    print("\n--- JMH output preview ---")
     print(preview)
-    print('--- end preview ---\n')
+    print("--- end preview ---\n")
 
     table = extract_first_table(output)
 
     updated = update_pre_blocks_under_module(args.module, table)
 
     if not updated:
-        print('No files were updated (no <pre> blocks with "thrpt" found under the module).')
+        print(
+            'No files were updated (no <pre> blocks with "thrpt" found under the module).'
+        )
     else:
-        print('\nUpdated files:')
+        print("\nUpdated files:")
         for p in updated:
-            print(' -', p)
+            print(" -", p)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1:])
-