[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

benchmark/scripts/benchmark_matrix_gen.py

@@ -33,11 +33,11 @@
 import numpy as np
 import pandas as pd
 
-
 # ---------------------------------------------------------------------------
 # Model builders
 # ---------------------------------------------------------------------------
 
+
 def build_scigrid(n_snapshots: int):
     """Return a linopy Model from PyPSA SciGrid-DE with extended snapshots."""
     import pypsa
@@ -57,9 +57,15 @@ def build_scigrid(n_snapshots: int):
             if df is not None and not df.empty:
                 tiles = int(np.ceil(n_snapshots / orig_len)) + 1
                 tiled = np.tile(df.values, (tiles, 1))[:n_snapshots]
-                setattr(component_t, attr, pd.DataFrame(
-                    tiled, index=new_snapshots, columns=df.columns,
-                ))
+                setattr(
+                    component_t,
+                    attr,
+                    pd.DataFrame(
+                        tiled,
+                        index=new_snapshots,
+                        columns=df.columns,
+                    ),
+                )
 
     n.optimize.create_model(include_objective_constant=False)
     return n.model
@@ -83,6 +89,7 @@ def build_synthetic(n: int):
 # Benchmark phases
 # ---------------------------------------------------------------------------
 
+
 def time_phase(func, label: str, repeats: int = 3) -> dict:
     """Time a callable, return best-of-N result."""
     times = []
@@ -95,8 +102,12 @@ def time_phase(func, label: str, repeats: int = 3) -> dict:
         gc.enable()
         times.append(elapsed)
         del result
-    return {"phase": label, "best_s": min(times), "median_s": sorted(times)[len(times) // 2],
-            "times": times}
+    return {
+        "phase": label,
+        "best_s": min(times),
+        "median_s": sorted(times)[len(times) // 2],
+        "times": times,
+    }
 
 
 def benchmark_model(model, repeats: int = 3) -> list[dict]:
@@ -168,38 +179,42 @@ def run_benchmarks(model_type: str, quick: bool, repeats: int) -> list[dict]:
     if model_type in ("scigrid", "all"):
         sizes = QUICK_SNAPSHOTS if quick else FULL_SNAPSHOTS
         for n_snap in sizes:
-            print(f"\n{'='*60}")
+            print(f"\n{'=' * 60}")
             print(f"SciGrid-DE  {n_snap} snapshots")
-            print(f"{'='*60}")
+            print(f"{'=' * 60}")
             model = build_scigrid(n_snap)
             n_vars = len(model.variables.flat)
             n_cons = len(model.constraints.flat)
             print(f"  {n_vars:,} variables, {n_cons:,} constraints")
 
             for r in benchmark_model(model, repeats):
-                r.update(model_type="scigrid", size=n_snap,
-                         n_vars=n_vars, n_cons=n_cons)
+                r.update(
+                    model_type="scigrid", size=n_snap, n_vars=n_vars, n_cons=n_cons
+                )
                 all_results.append(r)
-                print(f"  {r['phase']:20s}  {r['best_s']:.4f}s  (median {r['median_s']:.4f}s)")
+                print(
+                    f"  {r['phase']:20s}  {r['best_s']:.4f}s  (median {r['median_s']:.4f}s)"
+                )
 
             del model
             gc.collect()
 
     if model_type in ("synthetic", "all"):
         sizes = [20, 50] if quick else SYNTHETIC_SIZES
         for n in sizes:
-            print(f"\n{'='*60}")
-            print(f"Synthetic  N={n}  ({2*n*n} vars, {2*n*n} cons)")
-            print(f"{'='*60}")
+            print(f"\n{'=' * 60}")
+            print(f"Synthetic  N={n}  ({2 * n * n} vars, {2 * n * n} cons)")
+            print(f"{'=' * 60}")
             model = build_synthetic(n)
             n_vars = 2 * n * n
             n_cons = 2 * n * n
 
             for r in benchmark_model(model, repeats):
-                r.update(model_type="synthetic", size=n,
-                         n_vars=n_vars, n_cons=n_cons)
+                r.update(model_type="synthetic", size=n, n_vars=n_vars, n_cons=n_cons)
                 all_results.append(r)
-                print(f"  {r['phase']:20s}  {r['best_s']:.4f}s  (median {r['median_s']:.4f}s)")
+                print(
+                    f"  {r['phase']:20s}  {r['best_s']:.4f}s  (median {r['median_s']:.4f}s)"
+                )
 
             del model
             gc.collect()
@@ -211,7 +226,9 @@ def format_comparison(before: list[dict], after: list[dict]) -> str:
     """Format a before/after comparison table."""
     df_b = pd.DataFrame(before).set_index(["model_type", "size", "phase"])
     df_a = pd.DataFrame(after).set_index(["model_type", "size", "phase"])
-    merged = df_b[["best_s"]].join(df_a[["best_s"]], lsuffix="_before", rsuffix="_after")
+    merged = df_b[["best_s"]].join(
+        df_a[["best_s"]], lsuffix="_before", rsuffix="_after"
+    )
     merged["speedup"] = merged["best_s_before"] / merged["best_s_after"]
     lines = [
         f"{'Model':>10s} {'Size':>6s} {'Phase':>20s} {'Before':>8s} {'After':>8s} {'Speedup':>8s}",
@@ -230,20 +247,29 @@ def format_comparison(before: list[dict], after: list[dict]) -> str:
 # CLI
 # ---------------------------------------------------------------------------
 
+
 def main():
     parser = argparse.ArgumentParser(
         description="Benchmark linopy matrix generation (PRs #616–#619)"
     )
     parser.add_argument(
-        "--model", choices=["scigrid", "synthetic", "all"], default="all",
+        "--model",
+        choices=["scigrid", "synthetic", "all"],
+        default="all",
         help="Model type to benchmark (default: all)",
     )
-    parser.add_argument("--quick", action="store_true", help="Quick mode (smallest sizes only)")
-    parser.add_argument("--repeats", type=int, default=3, help="Timing repeats per phase (default: 3)")
+    parser.add_argument(
+        "--quick", action="store_true", help="Quick mode (smallest sizes only)"
+    )
+    parser.add_argument(
+        "--repeats", type=int, default=3, help="Timing repeats per phase (default: 3)"
+    )
     parser.add_argument("-o", "--output", type=str, help="Save results to JSON file")
     parser.add_argument("--label", type=str, default="", help="Label for this run")
     parser.add_argument(
-        "--compare", nargs=2, metavar=("BEFORE", "AFTER"),
+        "--compare",
+        nargs=2,
+        metavar=("BEFORE", "AFTER"),
         help="Compare two JSON result files instead of running benchmarks",
     )
     args = parser.parse_args()
@@ -254,9 +280,11 @@ def main():
         print(format_comparison(before, after))
         return
 
-    print(f"linopy matrix generation benchmark")
-    print(f"Python {sys.version.split()[0]}, numpy {np.__version__}, "
-          f"{platform.machine()}, {platform.system()}")
+    print("linopy matrix generation benchmark")
+    print(
+        f"Python {sys.version.split()[0]}, numpy {np.__version__}, "
+        f"{platform.machine()}, {platform.system()}"
+    )
 
     results = run_benchmarks(args.model, args.quick, args.repeats)
 
@@ -272,9 +300,9 @@ def main():
         print(f"\nResults saved to {args.output}")
 
     # Summary table
-    print(f"\n{'='*60}")
+    print(f"\n{'=' * 60}")
     print("Summary (best times)")
-    print(f"{'='*60}")
+    print(f"{'=' * 60}")
     df = pd.DataFrame(results)
     for (mtype, size), group in df.groupby(["model_type", "size"]):
         n_vars = group.iloc[0]["n_vars"]