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

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

Author: pre-commit-ci[bot]

data_structures/simple/run_ds_tests.py

@@ -26,7 +26,7 @@ def run() -> None:
         assert ll.to_list() == [0, 2]
         print("LinkedList: OK")
     except Exception as e:
-        failures.append(('LinkedList', e))
+        failures.append(("LinkedList", e))
 
     try:
         s = ListStack()
@@ -36,13 +36,13 @@ def run() -> None:
         assert s.pop() == 2
 
         ls = LinkedStack()
-        ls.push('a')
-        ls.push('b')
-        assert ls.peek() == 'b'
-        assert ls.pop() == 'b'
+        ls.push("a")
+        ls.push("b")
+        assert ls.peek() == "b"
+        assert ls.pop() == "b"
         print("Stacks: OK")
     except Exception as e:
-        failures.append(('Stacks', e))
+        failures.append(("Stacks", e))
 
     try:
         q = Queue()
@@ -52,7 +52,7 @@ def run() -> None:
         assert q.dequeue() == 1
         print("Queue: OK")
     except Exception as e:
-        failures.append(('Queue', e))
+        failures.append(("Queue", e))
 
     try:
         bst = BinarySearchTree()
@@ -62,7 +62,7 @@ def run() -> None:
         assert bst.inorder() == [1, 2, 3, 4]
         print("BST: OK")
     except Exception as e:
-        failures.append(('BST', e))
+        failures.append(("BST", e))
 
     try:
         g = Graph()
@@ -74,16 +74,16 @@ def run() -> None:
         assert 1 in order_dfs
         print("Graph: OK")
     except Exception as e:
-        failures.append(('Graph', e))
+        failures.append(("Graph", e))
 
     try:
         t = Trie()
-        t.insert('hello')
-        assert t.search('hello')
-        assert t.starts_with('hel')
+        t.insert("hello")
+        assert t.search("hello")
+        assert t.starts_with("hel")
         print("Trie: OK")
     except Exception as e:
-        failures.append(('Trie', e))
+        failures.append(("Trie", e))
 
     try:
         uf = UnionFind()
@@ -93,7 +93,7 @@ def run() -> None:
         assert uf.find(1) == uf.find(2)
         print("UnionFind: OK")
     except Exception as e:
-        failures.append(('UnionFind', e))
+        failures.append(("UnionFind", e))
 
     try:
         h = MinHeap()
@@ -104,16 +104,16 @@ def run() -> None:
         assert h.pop() == 1
         print("MinHeap: OK")
     except Exception as e:
-        failures.append(('MinHeap', e))
+        failures.append(("MinHeap", e))
 
     if failures:
-        print('\nFAILURES:')
+        print("\nFAILURES:")
         for name, exc in failures:
             print(f"- {name}: {exc}")
         sys.exit(2)
     else:
-        print('\nAll data_structures.simple smoke tests passed.')
+        print("\nAll data_structures.simple smoke tests passed.")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()

data_structures/stacks/balanced_parentheses.py

@@ -10,7 +10,9 @@
     from pathlib import Path
 
     stack_path = Path(__file__).with_name("stack.py")
-    spec = importlib.util.spec_from_file_location("data_structures.stacks.stack", str(stack_path))
+    spec = importlib.util.spec_from_file_location(
+        "data_structures.stacks.stack", str(stack_path)
+    )
     _stack = importlib.util.module_from_spec(spec)
     sys.modules[spec.name] = _stack
     spec.loader.exec_module(_stack)  # type: ignore[attr-defined]

scripts/run_doctests.py

@@ -19,7 +19,9 @@
 import traceback
 from pathlib import Path
 
-ROOT = Path(__file__).resolve().parents[1]  # Python/ (project root where data_structures lives)
+ROOT = (
+    Path(__file__).resolve().parents[1]
+)  # Python/ (project root where data_structures lives)
 DATA_DIR = ROOT / "data_structures"
 
 
@@ -69,7 +71,9 @@ def main() -> int:
             except Exception as ex2:
                 print(f"Fallback testfile raised {ex2.__class__.__name__}: {ex2}")
                 traceback.print_exc()
-                results.append((str(rel), "error", f"import error: {e}; fallback error: {ex2}"))
+                results.append(
+                    (str(rel), "error", f"import error: {e}; fallback error: {ex2}")
+                )
 
     # Summary
     print("\n=== Summary ===")

simulated_annealing/__init__.py

@@ -4,6 +4,7 @@
 - SimulatedAnnealing: core optimizer class
 - example_functions: a small collection of test functions
 """
+
 from .simulated_annealing import SimulatedAnnealing
 from .example import example_functions
 

simulated_annealing/example.py

@@ -8,7 +8,9 @@ def sphere(x: Sequence[float]) -> float:
 def rastrigin(x: Sequence[float]) -> float:
     # Rastrigin function (common test function)
     A = 10
-    return A * len(x) + sum((v * v - A * __import__("math").cos(2 * __import__("math").pi * v)) for v in x)
+    return A * len(x) + sum(
+        (v * v - A * __import__("math").cos(2 * __import__("math").pi * v)) for v in x
+    )
 
 
 example_functions: Dict[str, Callable[[Sequence[float]], float]] = {
@@ -20,10 +22,18 @@ def rastrigin(x: Sequence[float]) -> float:
 def cli_example():
     # CLI demo minimizing 2D sphere
     from .simulated_annealing import SimulatedAnnealing
+
     func = sphere
     initial = [5.0, -3.0]
     bounds = [(-10, 10), (-10, 10)]
-    sa = SimulatedAnnealing(func, initial, bounds=bounds, temperature=50, cooling_rate=0.95, iterations_per_temp=200)
+    sa = SimulatedAnnealing(
+        func,
+        initial,
+        bounds=bounds,
+        temperature=50,
+        cooling_rate=0.95,
+        iterations_per_temp=200,
+    )
     best, cost, history = sa.optimize()
     print("Best:", best)
     print("Cost:", cost)
@@ -41,7 +51,9 @@ def tsp_example():
     initial = [float(i) for i in init_tour]
     cost_fn = make_tsp_cost(coords)
 
-    sa = SimulatedAnnealing(cost_fn, initial, temperature=100.0, cooling_rate=0.995, iterations_per_temp=500)
+    sa = SimulatedAnnealing(
+        cost_fn, initial, temperature=100.0, cooling_rate=0.995, iterations_per_temp=500
+    )
     best, cost, history = sa.optimize()
     best_tour = vector_to_tour(best)
     print("Best tour:", best_tour)

simulated_annealing/gui.py

@@ -4,6 +4,7 @@
 from typing import Optional
 
 import matplotlib
+
 matplotlib.use("TkAgg")
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 import matplotlib.pyplot as plt
@@ -24,15 +25,22 @@ def __init__(self):
 
         ttk.Label(ctrl, text="Function:").pack(anchor=tk.W)
         self.func_var = tk.StringVar(value="sphere")
-        func_menu = ttk.Combobox(ctrl, textvariable=self.func_var, values=list(example_functions.keys()), state="readonly")
+        func_menu = ttk.Combobox(
+            ctrl,
+            textvariable=self.func_var,
+            values=list(example_functions.keys()),
+            state="readonly",
+        )
         func_menu.pack(fill=tk.X)
 
         ttk.Label(ctrl, text="Initial (comma-separated)").pack(anchor=tk.W, pady=(8, 0))
         self.init_entry = ttk.Entry(ctrl)
         self.init_entry.insert(0, "5, -3")
         self.init_entry.pack(fill=tk.X)
 
-        ttk.Label(ctrl, text="Bounds (lo:hi comma-separated for each)").pack(anchor=tk.W, pady=(8, 0))
+        ttk.Label(ctrl, text="Bounds (lo:hi comma-separated for each)").pack(
+            anchor=tk.W, pady=(8, 0)
+        )
         self.bounds_entry = ttk.Entry(ctrl)
         self.bounds_entry.insert(0, "-10:10, -10:10")
         self.bounds_entry.pack(fill=tk.X)
@@ -56,7 +64,9 @@ def __init__(self):
         self.run_btn.pack(fill=tk.X, pady=(12, 0))
 
         self.stop_flag = threading.Event()
-        self.stop_btn = ttk.Button(ctrl, text="Stop", command=self._on_stop, state=tk.DISABLED)
+        self.stop_btn = ttk.Button(
+            ctrl, text="Stop", command=self._on_stop, state=tk.DISABLED
+        )
         self.stop_btn.pack(fill=tk.X, pady=(6, 0))
 
         # Right: plot
@@ -65,7 +75,7 @@ def __init__(self):
         self.canvas = FigureCanvasTkAgg(fig, master=self)
         self.canvas.get_tk_widget().pack(side=tk.RIGHT, fill=tk.BOTH, expand=1)
 
-        self._plot_line, = self.ax.plot([], [], label="best_cost")
+        (self._plot_line,) = self.ax.plot([], [], label="best_cost")
         self.ax.set_xlabel("Iterations")
         self.ax.set_ylabel("Best cost")
         self.ax.grid(True)
@@ -120,13 +130,22 @@ def _on_run(self):
         self.stop_flag.clear()
 
         def worker():
-            sa = SimulatedAnnealing(func, initial, bounds=bounds, temperature=temp, cooling_rate=cooling, iterations_per_temp=iterations)
+            sa = SimulatedAnnealing(
+                func,
+                initial,
+                bounds=bounds,
+                temperature=temp,
+                cooling_rate=cooling,
+                iterations_per_temp=iterations,
+            )
 
             def progress_cb(step, best_cost, current_cost):
                 # schedule a plot update on the main thread
                 self.after(0, lambda: self._update_plot_partial(step, best_cost))
 
-            best, cost, history = sa.optimize(stop_event=self.stop_flag, progress_callback=progress_cb)
+            best, cost, history = sa.optimize(
+                stop_event=self.stop_flag, progress_callback=progress_cb
+            )
             # update final plot on main thread
             self.after(0, lambda: self._on_complete(best, cost, history))
 
@@ -158,7 +177,11 @@ def _on_complete(self, best, cost, history):
     def _update_plot_partial(self, step: int, best_cost: float):
         # Append a new point to plot (x=step, y=best_cost)
         # We'll redraw full plot for simplicity
-        line_x = list(range(len(self.ax.lines[0].get_xdata()) + 1)) if self.ax.lines else [step]
+        line_x = (
+            list(range(len(self.ax.lines[0].get_xdata()) + 1))
+            if self.ax.lines
+            else [step]
+        )
         if self.ax.lines:
             ydata = list(self.ax.lines[0].get_ydata())
             ydata.append(best_cost)

simulated_annealing/simulated_annealing.py

@@ -21,7 +21,17 @@ def __init__(
         min_temperature: float = 1e-3,
         iterations_per_temp: int = 100,
         neighbor_scale: float = 0.1,
-        local_search: Optional[Callable[[Sequence[float], Callable[[Sequence[float]], float], Callable[[Sequence[float]], Sequence[float]], int], Tuple[Sequence[float], float]]] = None,
+        local_search: Optional[
+            Callable[
+                [
+                    Sequence[float],
+                    Callable[[Sequence[float]], float],
+                    Callable[[Sequence[float]], Sequence[float]],
+                    int,
+                ],
+                Tuple[Sequence[float], float],
+            ]
+        ] = None,
         local_search_iters: int = 10,
         seed: Optional[int] = None,
     ):
@@ -70,7 +80,12 @@ def _accept(self, delta: float, temp: float) -> bool:
             prob = 0.0
         return random.random() < prob
 
-    def optimize(self, max_steps: Optional[int] = None, stop_event: Optional[object] = None, progress_callback: Optional[Callable[[int, float, float], None]] = None) -> Tuple[List[float], float, dict]:
+    def optimize(
+        self,
+        max_steps: Optional[int] = None,
+        stop_event: Optional[object] = None,
+        progress_callback: Optional[Callable[[int, float, float], None]] = None,
+    ) -> Tuple[List[float], float, dict]:
         """Run optimization and return best solution, cost, and history.
 
         New optional args:
@@ -91,15 +106,23 @@ def optimize(self, max_steps: Optional[int] = None, stop_event: Optional[object]
         while temp > self.min_temperature:
             for _ in range(self.iterations_per_temp):
                 # Check stop event
-                if stop_event is not None and getattr(stop_event, "is_set", lambda: False)():
+                if (
+                    stop_event is not None
+                    and getattr(stop_event, "is_set", lambda: False)()
+                ):
                     self.current = current
                     return best, best_cost, history
 
                 candidate = self._neighbor(current)
                 # Optionally refine candidate with local search before evaluating/accepting
                 if self.local_search is not None:
                     try:
-                        improved, improved_cost = self.local_search(candidate, self.func, self._neighbor, self.local_search_iters)
+                        improved, improved_cost = self.local_search(
+                            candidate,
+                            self.func,
+                            self._neighbor,
+                            self.local_search_iters,
+                        )
                         candidate = list(improved)
                         candidate_cost = float(improved_cost)
                     except Exception:
@@ -120,7 +143,10 @@ def optimize(self, max_steps: Optional[int] = None, stop_event: Optional[object]
                 history["current_costs"].append(current_cost)
 
                 steps += 1
-                if progress_callback is not None and steps % max(1, self.iterations_per_temp // 10) == 0:
+                if (
+                    progress_callback is not None
+                    and steps % max(1, self.iterations_per_temp // 10) == 0
+                ):
                     try:
                         progress_callback(steps, best_cost, current_cost)
                     except Exception:
@@ -141,12 +167,19 @@ def optimize(self, max_steps: Optional[int] = None, stop_event: Optional[object]
 def _test_quadratic():
     # Simple test: minimize f(x) = (x-3)^2
     func = lambda x: (x[0] - 3) ** 2
-    sa = SimulatedAnnealing(func, [0.0], bounds=[(-10, 10)], temperature=10, iterations_per_temp=50)
+    sa = SimulatedAnnealing(
+        func, [0.0], bounds=[(-10, 10)], temperature=10, iterations_per_temp=50
+    )
     best, cost, hist = sa.optimize()
     print("best:", best, "cost:", cost)
 
 
-def simple_local_search(solution: Sequence[float], func: Callable[[Sequence[float]], float], neighbor_fn: Callable[[Sequence[float]], Sequence[float]], iterations: int = 10) -> Tuple[Sequence[float], float]:
+def simple_local_search(
+    solution: Sequence[float],
+    func: Callable[[Sequence[float]], float],
+    neighbor_fn: Callable[[Sequence[float]], Sequence[float]],
+    iterations: int = 10,
+) -> Tuple[Sequence[float], float]:
     """A tiny hill-climbing local search that repeatedly accepts improving neighbors.
 
     Parameters