Black linting

Author: mcgalcode

pyproject.toml

@@ -113,6 +113,7 @@ enabled = true
 
 [dependency-groups]
 dev = [
+    "black>=24.8.0",
     "pytest>=7.1.3",
     "pytest-cov>=4.0.0",
-]
+]

src/pylattica/core/basic_controller.py

@@ -39,4 +39,6 @@ def get_random_site(self, state: SimulationState):
         return random.randint(0, state.size - 1)
 
     def instantiate_result(self, starting_state: SimulationState):
-        return SimulationResult(starting_state=starting_state, max_history=self.max_history)
+        return SimulationResult(
+            starting_state=starting_state, max_history=self.max_history
+        )

src/pylattica/core/neighborhood_builders.py

@@ -146,9 +146,9 @@ def get(self, struct: PeriodicStructure, site_class: str = None) -> Neighborhood
         site_ids = np.array([s[SITE_ID] for s in all_sites])
 
         # Convert to fractional coordinates for periodic KD-tree
-        frac_coords = np.array([
-            struct.lattice.get_fractional_coords(loc) for loc in locations
-        ])
+        frac_coords = np.array(
+            [struct.lattice.get_fractional_coords(loc) for loc in locations]
+        )
 
         # Compute the maximum fractional radius that could correspond to
         # the Cartesian cutoff. For non-orthogonal lattices, we need to use
@@ -163,9 +163,7 @@ def get(self, struct: PeriodicStructure, site_class: str = None) -> Neighborhood
         dim = struct.lattice.dim
 
         # Build boxsize array: 1.0 for periodic dimensions, large value for non-periodic
-        boxsize = np.array([
-            1.0 if periodic[i] else 1e10 for i in range(dim)
-        ])
+        boxsize = np.array([1.0 if periodic[i] else 1e10 for i in range(dim)])
 
         # Wrap fractional coordinates to [0, 1) for periodic dimensions
         frac_coords_wrapped = frac_coords.copy()
@@ -296,9 +294,9 @@ def get(self, struct: PeriodicStructure, site_class: str = None) -> Neighborhood
         site_ids = np.array([s[SITE_ID] for s in all_sites])
 
         # Convert to fractional coordinates for periodic KD-tree
-        frac_coords = np.array([
-            struct.lattice.get_fractional_coords(loc) for loc in locations
-        ])
+        frac_coords = np.array(
+            [struct.lattice.get_fractional_coords(loc) for loc in locations]
+        )
 
         # Compute the maximum fractional radius for the outer cutoff.
         # Use the maximum stretch factor of the inverse matrix for non-orthogonal lattices.
@@ -311,9 +309,7 @@ def get(self, struct: PeriodicStructure, site_class: str = None) -> Neighborhood
         dim = struct.lattice.dim
 
         # Build boxsize array
-        boxsize = np.array([
-            1.0 if periodic[i] else 1e10 for i in range(dim)
-        ])
+        boxsize = np.array([1.0 if periodic[i] else 1e10 for i in range(dim)])
 
         # Wrap fractional coordinates to [0, 1) for periodic dimensions
         frac_coords_wrapped = frac_coords.copy()

src/pylattica/core/simulation_result.py

@@ -39,7 +39,9 @@ def from_dict(cls, res_dict):
         )
         # Restore checkpoint if present
         if "checkpoint_state" in res_dict and res_dict["checkpoint_state"] is not None:
-            res._checkpoint_state = SimulationState.from_dict(res_dict["checkpoint_state"])
+            res._checkpoint_state = SimulationState.from_dict(
+                res_dict["checkpoint_state"]
+            )
             res._checkpoint_step = res_dict.get("checkpoint_step", 0)
 
         for diff in diffs:
@@ -50,11 +52,18 @@ def from_dict(cls, res_dict):
             res._diffs.append(diff)  # Bypass add_step to avoid re-checkpointing
 
         # Restore total_steps from serialized data, or compute from diffs + checkpoint
-        res._total_steps = res_dict.get("total_steps", res._checkpoint_step + len(diffs))
+        res._total_steps = res_dict.get(
+            "total_steps", res._checkpoint_step + len(diffs)
+        )
 
         return res
 
-    def __init__(self, starting_state: SimulationState, compress_freq: int = 1, max_history: int = None):
+    def __init__(
+        self,
+        starting_state: SimulationState,
+        compress_freq: int = 1,
+        max_history: int = None,
+    ):
         """Initializes a SimulationResult with the specified starting_state.
 
         Parameters

src/pylattica/models/game_of_life/__init__.py

@@ -1,2 +1,2 @@
 from .controller import GameOfLifeController, Life, Seeds, Anneal, Diamoeba, Maze
-from .life_phase_set import LIFE_PHASE_SET
+from .life_phase_set import LIFE_PHASE_SET

src/pylattica/models/game_of_life/life_phase_set.py

@@ -1,3 +1,3 @@
 from ...discrete.phase_set import PhaseSet
 
-LIFE_PHASE_SET = PhaseSet(["alive", "dead"])
+LIFE_PHASE_SET = PhaseSet(["alive", "dead"])

src/pylattica/structures/square_grid/grid_setup.py

@@ -348,7 +348,9 @@ def setup_random_sites(
 
         while num_sites_planted < num_sites_desired:
             if total_attempts > 1000 * num_sites_desired:
-                print(f"Only able to place {num_sites_planted} in {total_attempts} attempts")
+                print(
+                    f"Only able to place {num_sites_planted} in {total_attempts} attempts"
+                )
                 break
 
             rand_site = random.choice(all_sites)

src/pylattica/structures/square_grid/neighborhoods.py

@@ -54,13 +54,13 @@ def __init__(self, size: int):
         # Generate Von Neumann neighborhood offsets (excluding origin)
         points = get_points_in_cube(-size, size + 1, 3)
         self._offsets = [
-            tuple(point) for point in points
+            tuple(point)
+            for point in points
             if sum(np.abs(p) for p in point) <= size and any(p != 0 for p in point)
         ]
         # Precompute distances for edge weights
         self._distances = {
-            offset: np.sqrt(sum(p**2 for p in offset))
-            for offset in self._offsets
+            offset: np.sqrt(sum(p**2 for p in offset)) for offset in self._offsets
         }
         # Cache for grid size (computed once per structure)
         self._cached_n = None
@@ -70,8 +70,8 @@ def _get_grid_size(self, struct: PeriodicStructure) -> int:
         """Infer grid size n from structure (cached)."""
         n_sites = len(struct.site_ids)
         if n_sites != self._cached_n_sites:
-            n = int(round(n_sites ** (1/3)))
-            if n ** 3 != n_sites:
+            n = int(round(n_sites ** (1 / 3)))
+            if n**3 != n_sites:
                 raise ValueError(f"Structure has {n_sites} sites, not a perfect cube.")
             self._cached_n = n
             self._cached_n_sites = n_sites

src/pylattica/visualization/square_grid_artist_2D.py

@@ -62,7 +62,9 @@ def _draw_image(self, state: SimulationState, **kwargs):
 
             for phase in legend_order:
                 color = legend.get(phase)
-                p_col_start = state_size * cell_size + legend_border_width + legend_hoffset
+                p_col_start = (
+                    state_size * cell_size + legend_border_width + legend_hoffset
+                )
                 p_row_start = count * cell_size + legend_voffset
                 for p_x in range(p_col_start, p_col_start + cell_size):
                     for p_y in range(p_row_start, p_row_start + cell_size):