remaining mypy issues solved locally, excluded ipynb from disallow-caps hook

Author: LSHerzog

.pre-commit-config.yaml

@@ -106,7 +106,7 @@ repos:
         name: Disallow improper capitalization
         language: pygrep
         entry: PyBind|Numpy|Cmake|CCache|Github|PyTest|Mqt|Tum
-        exclude: .pre-commit-config.yaml
+        exclude: '(\.pre-commit-config\.yaml$|\.ipynb$)'
 
   # Check best practices for scientific Python code
   - repo: https://github.com/scientific-python/cookie

src/mqt/qecc/co3/plots/evaluation.py

@@ -6,6 +6,7 @@
 import logging
 import pickle  # noqa: S403
 from pathlib import Path
+from typing import TYPE_CHECKING, Any
 
 import matplotlib.patheffects as path_effects
 import matplotlib.pyplot as plt
@@ -14,10 +15,13 @@
 
 import mqt.qecc.co3 as co
 
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
 
 def collect_data_space_time(
-    instances: list[dict], hc_params: dict, reps: int, path: str, both_metric: bool = False
-) -> list[dict]:
+    instances: list[dict[str, Any]], hc_params: dict[str, Any], reps: int, path: str, both_metric: bool = False
+) -> list[dict[str, Any]]:
     """Collects the data for a run which will compare space and time cost.
 
     Args:
@@ -371,7 +375,7 @@ def collect_data_space_time(
 
 
 def plot_improvement_circuit_types(
-    res_lst: list[dict], path: str = "./results", size: tuple[int, int] = (5, 4)
+    res_lst: list[dict[str, Any]], path: str = "./results", size: tuple[int, int] = (5, 4)
 ) -> None:
     """Based on a run of collect_data_space time with different circuit types and constant t, and constant factories.
 
@@ -603,13 +607,13 @@ def plot_improvement_circuit_types(
 
 
 def plot_f_vs_t(
-    res_lst: list[dict],
+    res_lst: list[dict[str, Any]],
     q: int,
     ratio: float,
     layout_name: str,
     min_depth: int,
     graphtype: str,
-    hc_params: dict,
+    hc_params: dict[str, Any],
     path: str = "./results",
     size: tuple[int, int] = (5, 4),
 ) -> None:
@@ -682,11 +686,11 @@ def plot_f_vs_t(
     available_t_dct = {t: i for i, t in enumerate(available_t)}
 
     # order the entries
-    available_t = sorted(available_t)
-    available_f = sorted(available_f)
+    available_t_sorted = sorted(available_t)
+    available_f_sorted = sorted(available_f)
 
-    available_f_dct = {f: i for i, f in enumerate(available_f)}
-    available_t_dct = {t: i for i, t in enumerate(available_t)}
+    available_f_dct = {f: i for i, f in enumerate(available_f_sorted)}
+    available_t_dct = {t: i for i, t in enumerate(available_t_sorted)}
 
     for el in dct_mat:
         f_idx = available_f_dct[len(el["factory_locs"])]
@@ -863,7 +867,7 @@ def plot_f_vs_t(
 
 
 def plot_ratio_vs_t(
-    res_lst: list[dict],
+    res_lst: list[dict[str, Any]],
     q: int,
     num_factories: int,
     layout_name: str,
@@ -938,8 +942,8 @@ def plot_ratio_vs_t(
     available_t_dct = {t: i for i, t in enumerate(available_t)}
 
     # order the entries
-    available_t = sorted(available_t)
-    available_ratio = sorted(available_ratio)
+    # available_t = sorted(available_t)
+    # available_ratio = sorted(available_ratio)
 
     for el in dct_mat:
         ratio_idx = available_ratio_dct[el["ratio"]]
@@ -1035,7 +1039,11 @@ def plot_ratio_vs_t(
 
 
 def plot_space_time(
-    instances: list[dict], hc_params: dict, res_lst: list[dict], path: str = "./results", size: tuple[int, int] = (5, 4)
+    instances: list[dict[str, Any]],
+    hc_params: dict[str, Any],
+    res_lst: list[dict[str, Any]],
+    path: str = "./results",
+    size: tuple[int, int] = (5, 4),
 ) -> None:
     """Plots the results from collect_data_space_time.
 
@@ -1138,8 +1146,8 @@ def plot_space_time(
 
 
 def plot_improvement_f_variation(
-    res_lst_crossing: list[dict],
-    res_lst_routing: list[dict],
+    res_lst_crossing: list[dict[str, Any]],
+    res_lst_routing: list[dict[str, Any]],
     t: int,
     ratio: float,
     q: int,
@@ -1268,9 +1276,9 @@ def plot_improvement_f_variation(
     data_abs_r = data_c.copy()
     data_abs_std_r = data_c.copy()
 
-    available_f_c = sorted(available_f_c)
+    # available_f_c = sorted(available_f_c)
 
-    available_f_dct = {f: i for i, f in enumerate(available_f_c)}
+    available_f_dct = {f: i for i, f in enumerate(sorted(available_f_c))}
     available_layout_dct = {f: i for i, f in enumerate(available_layout_c)}
 
     for el in dct_mat_c:
@@ -1344,20 +1352,20 @@ def plot_improvement_f_variation(
 
 
 def plot_f_vs_t_subfigs(
-    res_lst1: list[dict],
-    res_lst2: list[dict],
+    res_lst1: list[dict[str, Any]],
+    res_lst2: list[dict[str, Any]],
     q: int,
     ratio: float,
     layout_name: str,
     min_depth: int,
     graphtype: str,
-    hc_params: dict,
+    hc_params: dict[str, Any],
     path: str = "./results",
     size: tuple[int, int] = (5, 5),
 ) -> None:
     """Plots a Matrix Plot with variation in number of factories and t for two result lists in subplots."""
 
-    def process_res_list(res_lst: list) -> tuple:
+    def process_res_list(res_lst: list[dict[str, Any]]) -> tuple[Any, ...]:
         instances = res_lst[0]["instances"][: len(res_lst)]
         idx_include = [
             i
@@ -1371,8 +1379,8 @@ def process_res_list(res_lst: list) -> tuple:
 
         for i in idx_include:
             res = res_lst[i]
-            num_init_lst = res["num_init_lst"]
-            num_final_lst = res["num_final_lst"]
+            num_init_lst: list[int] = res["num_init_lst"]
+            num_final_lst: list[int] = res["num_final_lst"]
             improvements = [(ni - nf) / ni for ni, nf in zip(num_init_lst, num_final_lst)]
             dct_mat.append({
                 "mean_final_layers": np.mean(num_final_lst),
@@ -1410,7 +1418,7 @@ def process_res_list(res_lst: list) -> tuple:
 
     fig, axes = plt.subplots(2, 2, figsize=size, gridspec_kw={"width_ratios": [1, 1], "height_ratios": [1, 1]})
 
-    def plot_with_text(ax: plt.axes.Axes, data: np.ndarray, data_std: np.ndarray, r: int) -> plt.image.AxesImage:
+    def plot_with_text(ax: plt.axes.Axes, data: NDArray[Any], data_std: NDArray[Any], r: int) -> plt.image.AxesImage:
         im = ax.imshow(data, cmap="viridis", aspect="auto")
         for i in range(data.shape[0]):
             for j in range(data.shape[1]):
@@ -1427,7 +1435,7 @@ def plot_with_text(ax: plt.axes.Axes, data: np.ndarray, data_std: np.ndarray, r:
                 ax.text(
                     j,
                     i + 0.25,
-                    "$\pm$" + str(round(data_std[i, j], r)),
+                    r"$\pm$" + str(round(data_std[i, j], r)),
                     ha="center",
                     va="center",
                     color="white",
@@ -1440,7 +1448,7 @@ def plot_with_text(ax: plt.axes.Axes, data: np.ndarray, data_std: np.ndarray, r:
         ax.set_yticklabels(list(available_f_dct.keys()))
         return im
 
-    def plot_with_text_int(ax: plt.axes.Axes, data: np.ndarray, data_std: np.ndarray) -> plt.image.AxesImage:
+    def plot_with_text_int(ax: plt.axes.Axes, data: NDArray[Any], data_std: NDArray[Any]) -> plt.image.AxesImage:
         im = ax.imshow(data, cmap="viridis", aspect="auto")
         r = 0
         for i in range(data.shape[0]):
@@ -1458,7 +1466,7 @@ def plot_with_text_int(ax: plt.axes.Axes, data: np.ndarray, data_std: np.ndarray
                 ax.text(
                     j,
                     i + 0.25,
-                    "$\pm$" + str(int(round(data_std[i, j], r))),
+                    r"$\pm$" + str(int(round(data_std[i, j], r))),
                     ha="center",
                     va="center",
                     color="white",

src/mqt/qecc/co3/utils/hill_climber.py

@@ -25,11 +25,13 @@
 
 random.seed(45)
 
+
 class HistoryTemp(TypedDict, total=False):
     """Type for history dictionaries."""
+
     scores: list[int]
-    layout_init: dict[int | str, tuple[int, int] | list[tuple[int, int]]]
-    layout_final: dict[int | str, tuple[int, int] | list[tuple[int, int]]]
+    layout_init: dict[int | str, Any]  # tuple[int, int] | list[tuple[int, int]]]
+    layout_final: dict[int | str, Any]  # tuple[int, int] | list[tuple[int, int]]]
 
 
 def save_to_file(path: str, data: Any) -> None:  # noqa: ANN401
@@ -55,7 +57,7 @@ def __init__(
         free_rows: list[str] | None = None,
         t: int | None = None,
         optimize_factories: bool = False,
-        custom_layout: list[list[tuple[int,int]] | nx.Graph] | None = None,
+        custom_layout: list[list[tuple[int, int]] | nx.Graph] | None = None,
         routing: str = "static",
     ) -> None:
         """Initializes the Hill Climbing with Random Restarts algorithm.
@@ -133,7 +135,7 @@ def __init__(
         elif layout_type == "hex":
             data_qubit_locs = lat.gen_layout_hex()
         elif layout_type == "custom":
-            if custom_layout is not None: #only for mypy
+            if custom_layout is not None:  # only for mypy
                 data_qubit_locs = custom_layout[0]
                 self.lat.G = custom_layout[1]
         else:
@@ -148,7 +150,9 @@ def __init__(
                 num for tup in self.circuit for num in (tup if isinstance(tup, tuple) else (tup,))
             ]
         else:
-            flattened_qubit_labels =  [num for tup in self.circuit if isinstance(tup, tuple) for num in tup] #isinstance only added for mypy
+            flattened_qubit_labels = [
+                num for tup in self.circuit if isinstance(tup, tuple) for num in tup
+            ]  # isinstance only added for mypy
         self.q = max(flattened_qubit_labels) + 1
         if self.q < len(self.data_qubit_locs):
             self.data_qubit_locs = self.data_qubit_locs[: self.q]  # cut-off unnecessary qubit spots.
@@ -234,16 +238,22 @@ def add_left_g(g: nx.Graph) -> nx.Graph:
 
         return g
 
-    def evaluate_solution(self, layout: dict[int | str, tuple[int, int] | list[tuple[int,int]]]) -> int:
+    def evaluate_solution(self, layout: dict[int | str, tuple[int, int] | list[tuple[int, int]]]) -> int:
         """Evaluates the layout=solution according to self.metric."""
         terminal_pairs = translate_layout_circuit(self.circuit, layout)
-        factory_positions: list[tuple[int,int]]
-        #if type(layout["factory_positions"]) is list[tuple[int,int]] or list:
-        factory_positions = layout["factory_positions"]
-        #else:
+        # factory_positions: list[tuple[int, int]]
+        # if type(layout["factory_positions"]) is list[tuple[int,int]] or list:
+        factory_positions_temp = layout["factory_positions"]
+        if isinstance(factory_positions_temp, list):
+            factory_positions: list[tuple[int, int]] = factory_positions_temp
+        else:
+            msg = "`layout['factory_positions']` must be of type list[tuple[int,int]] but this is not even a list."
+            raise TypeError(msg)
+
+        # else:
         #    msg = f"factory positions of layout must be list[tuple[int,int]]. But you got {type(layout['factory_positions'])}"
         #    raise TypeError(msg)
-        router : ShortestFirstRouter | ShortestFirstRouterTGatesDyn | ShortestFirstRouterTGates
+        router: ShortestFirstRouter | ShortestFirstRouterTGatesDyn | ShortestFirstRouterTGates
         if any(type(el) is int for el in self.circuit):
             if self.t is not None:
                 if self.routing == "static":
@@ -258,7 +268,7 @@ def evaluate_solution(self, layout: dict[int | str, tuple[int, int] | list[tuple
                     router.G = self.lat.G.copy()
                 else:  # if not custom, update self.lat.G by the router's G because m,n might differ from initial values.
                     self.lat.G = router.G  # also add to self
-                    if self.free_rows is not None: #for mypy  # noqa: SIM102
+                    if self.free_rows is not None:  # for mypy  # noqa: SIM102
                         if "left" in self.free_rows:
                             router.G = self.add_left_g(router.G)
                             self.lat.G = router.G  # also add to self
@@ -281,15 +291,15 @@ def evaluate_solution(self, layout: dict[int | str, tuple[int, int] | list[tuple
         cost: int
         if self.metric == "crossing":
             if self.optimize_factories and any(type(el) is int for el in self.circuit):
-                router = cast("ShortestFirstRouterTGates | ShortestFirstRouterTGatesDyn", router) 
+                router = cast("ShortestFirstRouterTGates | ShortestFirstRouterTGatesDyn", router)
                 cost = np.sum(router.count_crossings_per_layer(t_crossings=True))
             elif self.optimize_factories is False and any(type(el) is int for el in self.circuit):
-                router = cast("ShortestFirstRouterTGates | ShortestFirstRouterTGatesDyn", router) 
+                router = cast("ShortestFirstRouterTGates | ShortestFirstRouterTGatesDyn", router)
                 cost = np.sum(router.count_crossings_per_layer(t_crossings=False))
             else:
                 cost = np.sum(router.count_crossings_per_layer())
         elif self.metric == "distance":
-            router = cast("ShortestFirstRouter", router) 
+            router = cast("ShortestFirstRouter", router)
             distances = router.measure_terminal_pair_distances()
             cost = np.sum(distances)
             if any(type(el) is int for el in self.circuit):
@@ -298,14 +308,14 @@ def evaluate_solution(self, layout: dict[int | str, tuple[int, int] | list[tuple
             if self.routing == "static":
                 vdp_layers = router.find_total_vdp_layers()
             elif self.routing == "dynamic":
-                router = cast("ShortestFirstRouterTGatesDyn", router) 
+                router = cast("ShortestFirstRouterTGatesDyn", router)
                 vdp_layers = router.find_total_vdp_layers_dyn()
             cost = len(vdp_layers)
         return cost
 
-    def gen_random_qubit_assignment(self) -> dict[int | str, tuple[int, int] | list[tuple[int,int]]]:
+    def gen_random_qubit_assignment(self) -> dict[int | str, tuple[int, int] | list[tuple[int, int]]]:
         """Yields a random qubit assignment given the `data_qubit_locs`."""
-        layout: dict[int | str, tuple[int, int] | list[tuple[int,int]]] = {}
+        layout: dict[int | str, tuple[int, int] | list[tuple[int, int]]] = {}
         perm = list(range(self.q))
         random.shuffle(perm)
         for i, j in zip(
@@ -323,7 +333,9 @@ def gen_random_qubit_assignment(self) -> dict[int | str, tuple[int, int] | list[
 
         return layout
 
-    def gen_neighborhood(self, layout: dict[int | str, tuple[int, int] | list[tuple[int,int]]]) -> list[dict[int | str, tuple[int, int] | list[tuple[int,int]]]]:
+    def gen_neighborhood(
+        self, layout: dict[int | str, tuple[int, int] | list[tuple[int, int]]]
+    ) -> list[dict[int | str, tuple[int, int] | list[tuple[int, int]]]]:
         """Creates the Neighborhood of a given layout by going through each terminal pair and swapping their positions.
 
         If there are no T gates, there will be l=len(terminal_pairs) elements in the neighborhood.
@@ -364,12 +376,9 @@ def gen_neighborhood(self, layout: dict[int | str, tuple[int, int] | list[tuple[
 
         return neighborhood
 
-    def _parallel_hill_climbing(self, restart: int) -> tuple[
-        int,
-        dict[int | str, tuple[int, int] | list[tuple[int,int]]],
-        int,
-        HistoryTemp
-    ]:
+    def _parallel_hill_climbing(
+        self, restart: int
+    ) -> tuple[int, dict[int | str, tuple[int, int] | list[tuple[int, int]]], int, HistoryTemp]:
         """Helper method for parallel execution of hill climbing restarts.
 
         Args:
@@ -408,7 +417,9 @@ def _parallel_hill_climbing(self, restart: int) -> tuple[
         history_temp.update({"layout_final": current_solution.copy()})
         return restart, current_solution, current_score, history_temp
 
-    def run(self, prefix: str, suffix: str, parallel: bool, processes: int = 8) -> tuple[dict[int | str, tuple[int, int] | list[tuple[int, int]]], int, int, dict[int,HistoryTemp]]:
+    def run(
+        self, prefix: str, suffix: str, parallel: bool, processes: int = 8
+    ) -> tuple[dict[int | str, tuple[int, int] | list[tuple[int, int]]], int, int, dict[int, HistoryTemp]]:
         """Executes the Hill Climbing algorithm with random restarts.
 
         Args:
@@ -495,7 +506,10 @@ def run(self, prefix: str, suffix: str, parallel: bool, processes: int = 8) -> t
         return best_solution, best_score, best_rep, score_history
 
     def plot_history(
-        self, score_history: HistoryTemp, filename: str = "./hc_history_plot.pdf", size: tuple[float, float] = (5, 5)
+        self,
+        score_history: dict[int, HistoryTemp],
+        filename: str = "./hc_history_plot.pdf",
+        size: tuple[float, float] = (5, 5),
     ) -> None:
         """Plots the scores for each restart and iteration.