Pin black==25.1.0 and apply formatting

jaypantone · jaypantone · commit 0c51ffbf35e7 · 2026-01-15T11:22:11.000-06:00
diff --git a/tests/algorithms/test_enumeration.py b/tests/algorithms/test_enumeration.py
@@ -251,10 +251,7 @@ def test_not_verified(self, enum_with_list_req, onebyone_enum, enum_with_crossin
     def test_get_genf(self, enum_verified):
         x = sympy.Symbol("x")
         expected_gf = -(
-            sympy.sqrt(
-                -(4 * x**3 - 14 * x**2 + 8 * x - 1) / (2 * x**2 - 4 * x + 1)
-            )
-            - 1
+            sympy.sqrt(-(4 * x**3 - 14 * x**2 + 8 * x - 1) / (2 * x**2 - 4 * x + 1)) - 1
         ) / (2 * x * (x**2 - 3 * x + 1))
         assert sympy.simplify(enum_verified.get_genf() - expected_gf) == 0
         t = Tiling(
@@ -324,8 +321,7 @@ def test_interleave_fixed_length(self, enum_verified):
             == 20 * x**11 * dummy_var**3 * cell_var**3
         )
         assert (
-            enum_verified._interleave_fixed_length(F, (1, 0), 0)
-            == x**8 * dummy_var**3
+            enum_verified._interleave_fixed_length(F, (1, 0), 0) == x**8 * dummy_var**3
         )
 
     def test_interleave_fixed_lengths(self, enum_verified):
@@ -392,14 +388,7 @@ def test_genf_with_big_finite_cell(self):
         genf = enum.get_genf().expand()
         x = sympy.var("x")
         assert (
-            genf
-            == 1
-            + 2 * x
-            + 4 * x**2
-            + 8 * x**3
-            + 14 * x**4
-            + 20 * x**5
-            + 20 * x**6
+            genf == 1 + 2 * x + 4 * x**2 + 8 * x**3 + 14 * x**4 + 20 * x**5 + 20 * x**6
         )
 
     def test_with_two_reqs(self):
diff --git a/tests/strategies/test_verification.py b/tests/strategies/test_verification.py
@@ -677,10 +677,7 @@ def test_get_specification(self, strategy, enum_verified):
     def test_get_genf(self, strategy, enum_verified):
         x = sympy.Symbol("x")
         expected_gf = -(
-            sympy.sqrt(
-                -(4 * x**3 - 14 * x**2 + 8 * x - 1) / (2 * x**2 - 4 * x + 1)
-            )
-            - 1
+            sympy.sqrt(-(4 * x**3 - 14 * x**2 + 8 * x - 1) / (2 * x**2 - 4 * x + 1)) - 1
         ) / (2 * x * (x**2 - 3 * x + 1))
         assert sympy.simplify(strategy.get_genf(enum_verified[0]) - expected_gf) == 0
 
@@ -758,14 +755,7 @@ def test_genf_with_big_finite_cell(self, strategy):
         genf = strategy.get_genf(t).expand()
         x = sympy.var("x")
         assert (
-            genf
-            == 1
-            + 2 * x
-            + 4 * x**2
-            + 8 * x**3
-            + 14 * x**4
-            + 20 * x**5
-            + 20 * x**6
+            genf == 1 + 2 * x + 4 * x**2 + 8 * x**3 + 14 * x**4 + 20 * x**5 + 20 * x**6
         )
 
     def test_with_two_reqs(self, strategy):
diff --git a/tilings/algorithms/fusion.py b/tilings/algorithms/fusion.py
@@ -1,6 +1,7 @@
 """
 The implementation of the fusion algorithm
 """
+
 import collections
 from itertools import chain
 from typing import (
diff --git a/tilings/algorithms/requirement_placement.py b/tilings/algorithms/requirement_placement.py
@@ -153,9 +153,11 @@ def _gridded_perm_translation_with_point(
         # TODO: to prepare for intervals consider all ways of drawing a
         #       rectangle around point in cell.
         new_pos = [
-            self._point_translation(gp, i, (point_index, gp.patt[point_index]))
-            if i != point_index
-            else self._placed_cell(gp.pos[point_index])
+            (
+                self._point_translation(gp, i, (point_index, gp.patt[point_index]))
+                if i != point_index
+                else self._placed_cell(gp.pos[point_index])
+            )
             for i in range(len(gp))
         ]
         return gp.__class__(gp.patt, new_pos)
diff --git a/tilings/algorithms/row_col_separation.py b/tilings/algorithms/row_col_separation.py
@@ -7,6 +7,7 @@
 The role of the class `RowColSeparation` is to make sure that row columns
 separation is idempotent by applying the core algorithm until it stabilises.
 """
+
 import heapq
 from itertools import combinations, product
 from typing import TYPE_CHECKING, Dict, List, Tuple
diff --git a/tilings/algorithms/sliding.py b/tilings/algorithms/sliding.py
@@ -82,9 +82,11 @@ def slide_assumption(
                         gp.patt,
                         (
                             (
-                                c2
-                                if gp.pos[0][0] == c1
-                                else (c1 if gp.pos[0][0] == c2 else gp.pos[0][0]),
+                                (
+                                    c2
+                                    if gp.pos[0][0] == c1
+                                    else (c1 if gp.pos[0][0] == c2 else gp.pos[0][0])
+                                ),
                                 0,
                             ),
                         ),
@@ -99,9 +101,11 @@ def slide_assumption(
                         gp.patt,
                         (
                             (
-                                c2
-                                if gp.pos[0][0] == c1
-                                else (c1 if gp.pos[0][0] == c2 else gp.pos[0][0]),
+                                (
+                                    c2
+                                    if gp.pos[0][0] == c1
+                                    else (c1 if gp.pos[0][0] == c2 else gp.pos[0][0])
+                                ),
                                 0,
                             ),
                         ),
@@ -405,9 +409,11 @@ def _slide_obstructions(
                 # The 12...n obstrudtion that connects av12 and av123
                 yield GriddedPerm(
                     range(n),
-                    ((av_12, 0),) * (n - 1) + ((av_123, 0),)
-                    if av_12 < av_123
-                    else ((av_123, 0),) + ((av_12, 0),) * (n - 1),
+                    (
+                        ((av_12, 0),) * (n - 1) + ((av_123, 0),)
+                        if av_12 < av_123
+                        else ((av_123, 0),) + ((av_12, 0),) * (n - 1)
+                    ),
                 )
             elif gp in self.col_info[av_123][2]:
                 # The one with two points in av_123 are altered so that the two
@@ -435,9 +441,7 @@ def _slide_obstructions(
                 yield gp
 
     @staticmethod
-    def _gp_slide_split(
-        gp: GriddedPerm, c1: int, c2: int
-    ) -> Tuple[
+    def _gp_slide_split(gp: GriddedPerm, c1: int, c2: int) -> Tuple[
         Tuple[Deque[int], Deque[int], Deque[int], Deque[int], Deque[int], Deque[int]],
         Tuple[List[int], List[int], List[int]],
     ]:
diff --git a/tilings/bijections.py b/tilings/bijections.py
@@ -91,7 +91,7 @@ def _init_assumptions(self) -> Tuple[AssumptionLabels, AssumptionLabels]:
 
     @staticmethod
     def _get_next(
-        path: Deque[Tuple[AbstractRule, int]]
+        path: Deque[Tuple[AbstractRule, int]],
     ) -> Tuple[Rule[Tiling, GriddedPerm], int]:
         """Get next rule and the index of its child we traverse through."""
         r, idx = path.popleft()
diff --git a/tilings/misc.py b/tilings/misc.py
@@ -2,6 +2,7 @@
 Collection of function that are not directly related to the code but still
 useful.
 """
+
 from functools import reduce
 from typing import (
     Collection,
diff --git a/tilings/strategies/assumption_insertion.py b/tilings/strategies/assumption_insertion.py
@@ -77,9 +77,11 @@ def _build_child_param_map(self, parent: Tiling, child: Tiling) -> ParametersMap
         }
         child_param_to_parent_param = {v: k for k, v in self.extra_parameters.items()}
         child_pos_to_parent_pos: Tuple[Tuple[int, ...], ...] = tuple(
-            tuple()
-            if param in self.new_parameters
-            else (parent_param_to_pos[child_param_to_parent_param[param]],)
+            (
+                tuple()
+                if param in self.new_parameters
+                else (parent_param_to_pos[child_param_to_parent_param[param]],)
+            )
             for param in child.extra_parameters
         )
         return self.build_param_map(
diff --git a/tilings/strategies/assumption_splitting.py b/tilings/strategies/assumption_splitting.py
@@ -77,7 +77,7 @@ def compositions_dict(value: int, parameters: Tuple[str, ...]):
                 yield dict(zip(parameters, comp))
 
         def union_params(
-            sub_params: Tuple[Dict[str, int], ...]
+            sub_params: Tuple[Dict[str, int], ...],
         ) -> Optional[Dict[str, int]]:
             new_params: Dict[str, int] = {}
             for params in sub_params:
diff --git a/tilings/strategies/cell_reduction.py b/tilings/strategies/cell_reduction.py
@@ -1,4 +1,5 @@
 """The cell reduction strategy."""
+
 from typing import Callable, Dict, Iterator, List, Optional, Set, Tuple, cast
 
 import sympy
diff --git a/tilings/strategies/deflation.py b/tilings/strategies/deflation.py
@@ -1,4 +1,5 @@
 """The deflation strategy."""
+
 from typing import Callable, Dict, Iterator, List, Optional, Tuple, cast
 
 import sympy
diff --git a/tilings/strategies/detect_components.py b/tilings/strategies/detect_components.py
@@ -163,9 +163,9 @@ def extra_parameters(
         for assumption in comb_class.assumptions:
             mapped_assumption = assumption.remove_components(comb_class)
             if mapped_assumption.gps:
-                extra_parameters[
-                    comb_class.get_assumption_parameter(assumption)
-                ] = child.get_assumption_parameter(mapped_assumption)
+                extra_parameters[comb_class.get_assumption_parameter(assumption)] = (
+                    child.get_assumption_parameter(mapped_assumption)
+                )
         return (extra_parameters,)
 
     def formal_step(self) -> str:
diff --git a/tilings/strategies/factor.py b/tilings/strategies/factor.py
@@ -297,7 +297,7 @@ def assumptions_to_add(self, comb_class: Tiling) -> Tuple[TrackingAssumption, ..
 
     @staticmethod
     def interleaving_rows_and_cols(
-        partition: Tuple[Tuple[Cell, ...], ...]
+        partition: Tuple[Tuple[Cell, ...], ...],
     ) -> Tuple[Set[int], Set[int]]:
         """
         Return the set of cols and the set of rows that are being interleaved when
diff --git a/tilings/strategies/fusion/constructor.py b/tilings/strategies/fusion/constructor.py
@@ -13,6 +13,7 @@
 We will assume we are always fusing two adjacent columns, and discuss the left
 and right hand sides accordingly.
 """
+
 import enum
 from collections import Counter, defaultdict
 from functools import reduce
@@ -100,9 +101,11 @@ def __init__(
             (
                 "left"
                 if parent_fusion_parameter in self.left_sided_parameters
-                else "right"
-                if parent_fusion_parameter in self.right_sided_parameters
-                else "both"
+                else (
+                    "right"
+                    if parent_fusion_parameter in self.right_sided_parameters
+                    else "both"
+                )
             )
             for parent_fusion_parameter in self.parent_fusion_parameters
         ]
@@ -506,9 +509,11 @@ def update_subparams(
             updated_value = (
                 value + number_of_left_points
                 if parameter in self.right_sided_parameters
-                else value + number_of_right_points
-                if parameter in self.left_sided_parameters
-                else value
+                else (
+                    value + number_of_right_points
+                    if parameter in self.left_sided_parameters
+                    else value
+                )
             )
             child_parameter = self.extra_parameters[parameter]
             if child_parameter not in res:
diff --git a/tilings/strategies/pointing.py b/tilings/strategies/pointing.py
@@ -2,6 +2,7 @@
 The directionless point placement strategy that is counted
 by the 'pointing' constructor.
 """
+
 from collections import Counter
 from itertools import product
 from typing import (
@@ -158,9 +159,9 @@ def extra_parameters(
             ]
             for ass, mapped_ass in zip(comb_class.assumptions, mapped_assumptions):
                 if mapped_ass.gps:
-                    params[
-                        comb_class.get_assumption_parameter(ass)
-                    ] = child.get_assumption_parameter(mapped_ass)
+                    params[comb_class.get_assumption_parameter(ass)] = (
+                        child.get_assumption_parameter(mapped_ass)
+                    )
             res.append(params)
         return tuple(res)
 
@@ -206,9 +207,11 @@ def get_terms(
         terms = DisjointUnion.get_terms(self, parent_terms, subterms, n)
         return Counter(
             {
-                key: value // (key[self.division_index] + self.shift)
-                if (key[self.division_index] + self.shift) != 0
-                else value
+                key: (
+                    value // (key[self.division_index] + self.shift)
+                    if (key[self.division_index] + self.shift) != 0
+                    else value
+                )
                 for key, value in terms.items()
             }
         )
diff --git a/tilings/strategies/row_and_col_separation.py b/tilings/strategies/row_and_col_separation.py
@@ -2,6 +2,7 @@
 The row and column separation strategy. The details of the algorithm can be
 found in the algorithms folder.
 """
+
 from typing import Dict, Iterator, Optional, Tuple
 
 from comb_spec_searcher import DisjointUnionStrategy
diff --git a/tilings/strategies/verification.py b/tilings/strategies/verification.py
@@ -118,9 +118,9 @@ def get_genf(
         gp = next(comb_class.minimal_gridded_perms())
         expected = {"x": len(gp)}
         for assumption in comb_class.assumptions:
-            expected[
-                comb_class.get_assumption_parameter(assumption)
-            ] = assumption.get_value(gp)
+            expected[comb_class.get_assumption_parameter(assumption)] = (
+                assumption.get_value(gp)
+            )
         return reduce(mul, [var(k) ** n for k, n in expected.items()], 1)
 
     def __repr__(self) -> str:
diff --git a/tilings/strategy_pack.py b/tilings/strategy_pack.py
@@ -33,7 +33,7 @@ def add_basis(self, basis: Iterable[Perm]) -> "TileScopePack":
         symmetry = bool(self.symmetries)
 
         def replace_list(
-            strats: Tuple[Union[AbstractStrategy, StrategyFactory], ...]
+            strats: Tuple[Union[AbstractStrategy, StrategyFactory], ...],
         ) -> List[Union[AbstractStrategy, StrategyFactory]]:
             """Return a new list with the replaced 1x1 strat."""
             res: List[Union[AbstractStrategy, StrategyFactory]] = []
@@ -74,7 +74,7 @@ def setup_subclass_verification(self, start_tiling: "Tiling") -> "TileScopePack"
         """
 
         def replace_list(
-            strats: Tuple[Union[AbstractStrategy, StrategyFactory], ...]
+            strats: Tuple[Union[AbstractStrategy, StrategyFactory], ...],
         ) -> List[Union[AbstractStrategy, StrategyFactory]]:
             """
             Find subclass verification and alter its perms_to_check variable.
diff --git a/tox.ini b/tox.ini
@@ -65,5 +65,5 @@ commands = mypy
 description = check that comply with autoformating
 basepython = {[default]basepython}
 deps =
-    black>=22.10.0
+    black==25.1.0
 commands = black --check --diff .
