multi-puzzle-solver 0.9.31__py3-none-any.whl → 1.0.3__py3-none-any.whl

puzzle_solver/puzzles/binairo/binairo.py

@@ -56,13 +56,13 @@ class Board:
             self.disallow_three_in_a_row(pos, Direction.RIGHT)
             self.disallow_three_in_a_row(pos, Direction.DOWN)
 
-        # 3. Each row and column is unique. 
+        # 3. Each row and column is unique.
         if self.force_unique:
             # a list per row
             self.force_unique_double_list([[self.model_vars[pos] for pos in get_row_pos(row, self.H)] for row in range(self.V)])
             # a list per column
             self.force_unique_double_list([[self.model_vars[pos] for pos in get_col_pos(col, self.V)] for col in range(self.H)])
-        
+
         # if arithmetic is provided, add constraints for it
         if self.arith_rows is not None:
             assert self.arith_rows.shape == (self.V, self.H-1), f'arith_rows must be one column less than board, got {self.arith_rows.shape} for {self.board.shape}'
@@ -106,10 +106,10 @@ class Board:
 
         codes = []
         pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
-        for i, l in enumerate(model_vars):
+        for i, line in enumerate(model_vars):
             code = self.model.NewIntVar(0, (1 << m) - 1, f"code_{i}")
             # Sum 2^k * r[k] == code
-            self.model.Add(code == sum(pow2[k] * l[k] for k in range(m)))
+            self.model.Add(code == sum(pow2[k] * line[k] for k in range(m)))
             codes.append(code)
 
         self.model.AddAllDifferent(codes)

puzzle_solver/puzzles/black_box/black_box.py

@@ -50,7 +50,7 @@ class Board:
         self.right_values = right
         self.bottom_values = bottom
         self.left_values = left
-        
+
         self.model = cp_model.CpModel()
         self.ball_states: dict[Pos, cp_model.IntVar] = {}
         # (entry_pos, T, cell_pos, direction) -> True if the beam that entered from the board at "entry_pos" is present in "cell_pos" and is going in the direction "direction" at time T
@@ -86,7 +86,7 @@ class Board:
                 for cell in self.get_all_pos_extended():
                     for direction in Direction:
                         self.beam_states[(entry_pos, t, cell, direction)] = self.model.NewBoolVar(f'beam:{entry_pos}:{t}:{cell}:{direction}')
-        
+
         for (entry_pos, t, cell, direction) in self.beam_states.keys():
             if t not in self.beam_states_at_t:
                 self.beam_states_at_t[t] = {}
@@ -110,7 +110,7 @@ class Board:
         beam_ids.extend((beam_id, Direction.LEFT) for beam_id in self.right_cells)
         beam_ids.extend((beam_id, Direction.UP) for beam_id in self.bottom_cells)
         beam_ids.extend((beam_id, Direction.RIGHT) for beam_id in self.left_cells)
-        
+
         for (beam_id, direction) in beam_ids:
             # beam at t=0 is present at beam_id and facing direction
             self.model.Add(self.beam_states[(beam_id, 0, beam_id, direction)] == 1)
@@ -189,7 +189,7 @@ class Board:
         else:
             ball_right = False
             ball_right_not = True
-        
+
         pos_left = get_next_pos(cur_pos, direction_left)
         pos_right = get_next_pos(cur_pos, direction_right)
         pos_reflected = get_next_pos(cur_pos, reflected)
@@ -304,10 +304,4 @@ class Board:
                 ball_state = 'O' if single_res.assignment[pos] else ' '
                 res[pos.y][pos.x] = ball_state
             print(res)
-        r = generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
-        # print('non unique count:', count)
-
-
-
-
-
+        generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/bridges/bridges.py

@@ -73,7 +73,7 @@ class Board:
         xhoriz_min = min(horiz_bridge[0].x, horiz_bridge[1].x)
         xhoriz_max = max(horiz_bridge[0].x, horiz_bridge[1].x)
         yhoriz = horiz_bridge[0].y
-        
+
         # no equals because thats what the puzzle says
         x_contained = xhoriz_min < xvert < xhoriz_max
         y_contained = yvert_min < yhoriz < yvert_max

puzzle_solver/puzzles/chess_range/chess_range.py

@@ -173,11 +173,11 @@ class Board:
         self.H = 8  # board size
         # the puzzle rules mean the only legal positions are the starting positions of the pieces
         self.all_legal_positions: set[Pos] = {pos for _, pos in self.pieces.values()}
-        assert len(self.all_legal_positions) == len(self.pieces), f'positions are not unique'
+        assert len(self.all_legal_positions) == len(self.pieces), 'positions are not unique'
 
         self.model = cp_model.CpModel()
         # Input numbers: N is number of piece, T is number of time steps (=N here), B is board size (=N here because the only legal positions are the starting positions of the pieces):
-        # Number of variables 
+        # Number of variables
         # piece_positions: O(NTB)
         # is_dead: O(NT)
         # mover: O(NT)
@@ -341,7 +341,7 @@ class Board:
         for t in range(self.T - 1):
             self.model.AddExactlyOne([self.victim[(p, t)] for p in range(self.N)])
 
-        # optional parameter to force 
+        # optional parameter to force
         if self.max_moves_per_piece is not None:
             for p in range(self.N):
                 self.model.Add(sum([self.mover[(p, t)] for t in range(self.T - 1)]) <= self.max_moves_per_piece)

puzzle_solver/puzzles/chess_range/chess_solo.py

@@ -4,6 +4,6 @@ from .chess_range import PieceType
 class Board(RangeBoard):
     def __init__(self, pieces: list[str]):
         king_pieces = [p for p in range(len(pieces)) if pieces[p][0] == 'K']
-        assert len(king_pieces) == 1, f'exactly one king piece is required'
+        assert len(king_pieces) == 1, 'exactly one king piece is required'
         super().__init__(pieces, max_moves_per_piece=2, last_piece_alive=PieceType.KING)
 

puzzle_solver/puzzles/filling/filling.py

@@ -3,8 +3,8 @@ from dataclasses import dataclass
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, Shape, get_all_pos, get_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 
 @dataclass
@@ -85,7 +85,7 @@ class Board:
             # exactly one shape is active at that position
             self.model.AddExactlyOne(s.is_active for d in self.digits for s in self.body_loc_to_shape[(d,pos)])
         # if a shape is active then all its body is active
-        
+
         for s_list in self.body_loc_to_shape.values():
             for s in s_list:
                 for p in s.body:

puzzle_solver/puzzles/flood_it/flood_it.py

@@ -0,0 +1,174 @@
+import sys
+import time
+from collections import defaultdict
+from typing import Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, nodes: dict[int, int], edges: dict[int, set[int]], horizon: int, start_node_id: int):
+        self.T = horizon
+        self.nodes = nodes
+        self.edges = edges
+        self.start_node_id = start_node_id
+        self.K = len(set(nodes.values()))
+
+        self.model = cp_model.CpModel()
+        self.decision: dict[tuple[int, int], cp_model.IntVar] = {}  # (t, k)
+        self.connected: dict[tuple[int, int], cp_model.IntVar] = {}  # (t, cluster_id)
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for t in range(self.T - 1):  # (N-1) actions (we dont need to decide at time N)
+            for k in range(self.K):
+                self.decision[t, k] = self.model.NewBoolVar(f'decision:{t}:{k}')
+        for t in range(self.T):
+            for cluster_id in self.nodes:
+                self.connected[t, cluster_id] = self.model.NewBoolVar(f'connected:{t}:{cluster_id}')
+
+    def add_all_constraints(self):
+        # init time t=0, all clusters are not connected except start_node
+        for cluster_id in self.nodes:
+            if cluster_id == self.start_node_id:
+                self.model.Add(self.connected[0, cluster_id] == 1)
+            else:
+                self.model.Add(self.connected[0, cluster_id] == 0)
+        # each timestep I will pick either one or zero colors
+        for t in range(self.T - 1):
+            # print('fixing decision at time t=', t, 'to single action with colors', self.K)
+            self.model.Add(lxp.sum([self.decision[t, k] for k in range(self.K)]) <= 1)
+        # at the end of the game, all clusters must be connected
+        for cluster_id in self.nodes:
+            self.model.Add(self.connected[self.T-1, cluster_id] == 1)
+
+        for t in range(1, self.T):
+            for cluster_id in self.nodes:
+                # connected[t, i] must be 0 if all connencted clusters at t-1 are 0 (thus connected[t, i] <= sum(connected[t-1, j] for j in touching)
+                sum_neighbors = lxp.sum([self.connected[t-1, j] for j in self.edges[cluster_id]]) + self.connected[t-1, cluster_id]
+                self.model.Add(self.connected[t, cluster_id] <= sum_neighbors)
+                # connected[t, i] must be 0 if color chosen at time t does not match color of cluster i and not connected at t-1
+                cluster_color = self.nodes[cluster_id]
+                self.model.Add(self.connected[t, cluster_id] == 0).OnlyEnforceIf([self.decision[t-1, cluster_color].Not(), self.connected[t-1, cluster_id].Not()])
+                self.model.Add(self.connected[t, cluster_id] == 1).OnlyEnforceIf([self.connected[t-1, cluster_id]])
+
+        pairs = [(self.decision[t, k], t+1) for t in range(self.T - 1) for k in range(self.K)]
+        self.model.Minimize(lxp.weighted_sum([p[0] for p in pairs], [p[1] for p in pairs]))
+
+    def solve(self) -> list[SingleSolution]:
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: list[str] = [None for _ in range(self.T - 1)]
+            for t in range(self.T - 1):
+                for k in range(self.K):
+                    if solver.Value(self.decision[t, k]) == 1:
+                        assignment[t] = k
+                        break
+            return SingleSolution(assignment=assignment)
+        return generic_solve_all(self, board_to_solution, verbose=False, max_solutions=1)
+
+
+def solve_minimum_steps(board: np.array, start_pos: Optional[Pos] = None, verbose: bool = True) -> int:
+    tic = time.time()
+    all_colors: set[str] = {c.item().strip() for c in np.nditer(board) if c.item().strip()}
+    color_to_int: dict[str, int] = {c: i for i, c in enumerate(sorted(all_colors))}  # colors string to color id
+    int_to_color: dict[int, str] = {i: c for c, i in color_to_int.items()}
+
+    graph: dict[Pos, int] = _board_to_graph(board)  # position to cluster id
+    nodes: dict[int, int] = {cluster_id: color_to_int[get_char(board, pos)] for pos, cluster_id in graph.items()}
+    edges = _graph_to_edges(board, graph)  # cluster id to touching cluster ids
+    if start_pos is None:
+        start_pos = Pos(0,0)
+
+    def solution_int_to_str(solution: SingleSolution):
+        return [int_to_color.get(color_id, '?') for color_id in solution.assignment]
+
+    def print_solution(solution: SingleSolution):
+        solution = solution_int_to_str(solution)
+        print("Solution:", solution)
+    solution = _binary_search_solution(nodes, edges, graph[start_pos], callback=print_solution if verbose else None, verbose=verbose)
+    if verbose:
+        if solution is None:
+            print("No solution found")
+        else:
+            solution = solution_int_to_str(solution)
+            print(f"Best Horizon is: T={len(solution)}")
+            print("Best solution is:", solution)
+        toc = time.time()
+        print(f"Time taken: {toc - tic:.2f} seconds")
+    return solution
+
+
+def _board_to_graph(board: np.array) -> dict[int, set[int]]:
+    def dfs_flood(board: np.array, pos: Pos, cluster_id: int, graph: dict[Pos, int]):
+        if pos in graph:
+            return
+        graph[pos] = cluster_id
+        for neighbor in get_neighbors4(pos, board.shape[0], board.shape[1]):
+            if get_char(board, neighbor) == get_char(board, pos):
+                dfs_flood(board, neighbor, cluster_id, graph)
+    graph: dict[Pos, int] = {}
+    cluster_id = 0
+    V, H = board.shape
+    for pos in get_all_pos(V, H):
+        if pos in graph:
+            continue
+        dfs_flood(board, pos, cluster_id, graph)
+        cluster_id += 1
+    return graph
+
+
+def _graph_to_edges(board: np.array, graph: dict[Pos, int]) -> dict[int, set[int]]:
+    cluster_edges: dict[int, set[int]] = defaultdict(set)
+    V, H = board.shape
+    for pos in get_all_pos(V, H):
+        for neighbor in get_neighbors4(pos, V, H):
+            n1, n2 = graph[pos], graph[neighbor]
+            if n1 != n2:
+                cluster_edges[n1].add(n2)
+                cluster_edges[n2].add(n1)
+    return cluster_edges
+
+
+def _binary_search_solution(nodes, edges, start_node_id, callback, verbose: bool = True):
+    if len(nodes) <= 1:
+        return SingleSolution(assignment=[])
+    min_T = 2
+    max_T = len(nodes)
+    hist = {}  # record historical T and best solution
+    while min_T <= max_T:
+        if max_T - min_T <= 20:  # small gap, just take the middle
+            T = min_T + (max_T - min_T) // 2
+        else:  # large gap, just +5 the min to not go too far
+            T = min_T + 15
+        # main check for binary search
+        if T in hist:  # already done and found solution
+            solutions = hist[T]
+        else:
+            if verbose:
+                print(f"Trying with exactly {T-1} moves...", end='')
+                sys.stdout.flush()
+            binst = Board(nodes=nodes, edges=edges, horizon=T, start_node_id=start_node_id)
+            solutions = binst.solve()
+            if verbose:
+                print(' Possible!' if len(solutions) > 0 else ' Not possible!')
+                if len(solutions) > 0:
+                    callback(solutions[0])
+        if min_T == max_T:
+            hist[T] = solutions
+            break
+        if len(solutions) > 0:
+            hist[T] = solutions
+            max_T = T
+        else:
+            min_T = T + 1
+    best_solution = min(hist.items(), key=lambda x: x[0])[1][0]
+    return best_solution
+
+

puzzle_solver/puzzles/flood_it/parse_map/parse_map.py

@@ -0,0 +1,198 @@
+"""
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk and converts them to a json file.
+    Look at the ./input_output/ directory for examples of input images and output json files.
+    The output json is used in the test_solve.py file to test the solver.
+"""
+# import json
+from pathlib import Path
+import numpy as np
+cv = None
+Image = None
+
+
+def extract_lines(bw):
+    # Create the images that will use to extract the horizontal and vertical lines
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = cols // 20
+    # Create structure element for extracting horizontal lines through morphology operations
+    horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv.erode(horizontal, horizontalStructure)
+    horizontal = cv.dilate(horizontal, horizontalStructure)
+    horizontal_means = np.mean(horizontal, axis=1)
+    horizontal_cutoff = np.percentile(horizontal_means, 50)
+    # location where the horizontal lines are
+    horizontal_idx = np.where(horizontal_means > horizontal_cutoff)[0]
+    # print(f"horizontal_idx: {horizontal_idx}")
+    # height = len(horizontal_idx)
+    # show_wait_destroy("horizontal", horizontal)  # this has the horizontal lines
+
+    rows = vertical.shape[0]
+    verticalsize = rows // 20
+    # Create structure element for extracting vertical lines through morphology operations
+    verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+    vertical = cv.erode(vertical, verticalStructure)
+    vertical = cv.dilate(vertical, verticalStructure)
+    vertical_means = np.mean(vertical, axis=0)
+    vertical_cutoff = np.percentile(vertical_means, 50)
+    vertical_idx = np.where(vertical_means > vertical_cutoff)[0]
+    # print(f"vertical_idx: {vertical_idx}")
+    # width = len(vertical_idx)
+    # print(f"height: {height}, width: {width}")
+    # print(f"vertical_means: {vertical_means}")
+    # show_wait_destroy("vertical", vertical)  # this has the vertical lines
+
+    vertical = cv.bitwise_not(vertical)
+    # show_wait_destroy("vertical_bit", vertical)
+
+    return horizontal_idx, vertical_idx
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+def mean_consecutives(arr: np.ndarray) -> np.ndarray:
+    """if a sequence of values is consecutive, then average the values"""
+    sums = []
+    counts = []
+    for i in range(len(arr)):
+        if i == 0:
+            sums.append(arr[i])
+            counts.append(1)
+        elif arr[i] == arr[i-1] + 1:
+            sums[-1] += arr[i]
+            counts[-1] += 1
+        else:
+            sums.append(arr[i])
+            counts.append(1)
+    return np.array(sums) // np.array(counts)
+
+def main(image):
+    global Image
+    global cv
+    import matplotlib.pyplot as plt
+    from PIL import Image as Image_module
+    import cv2 as cv_module
+    Image = Image_module
+    cv = cv_module
+
+
+    image_path = Path(image)
+    output_path = image_path.parent / (image_path.stem + '.json')
+    src = cv.imread(image, cv.IMREAD_COLOR)
+    assert src is not None, f'Error opening image: {image}'
+    if len(src.shape) != 2:
+        gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    else:
+        gray = src
+    # now the image is in grayscale
+
+    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
+    gray = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(gray.copy(), 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 15, -2)
+    # show_wait_destroy("binary", bw)
+
+    # show_wait_destroy("src", src)
+    horizontal_idx, vertical_idx = extract_lines(bw)
+    horizontal_idx = mean_consecutives(horizontal_idx)
+    vertical_idx = mean_consecutives(vertical_idx)
+    median_vertical_dist = np.median(np.diff(vertical_idx))
+    median_horizontal_dist = np.median(np.diff(horizontal_idx))
+    print(f"median_vertical_dist: {median_vertical_dist}, median_horizontal_dist: {median_horizontal_dist}")
+    height = len(horizontal_idx)
+    width = len(vertical_idx)
+    print(f"height: {height}, width: {width}")
+    print(f"horizontal_idx: {horizontal_idx}")
+    print(f"vertical_idx: {vertical_idx}")
+    output_rgb = {}
+    j_idx = 0
+    for j in range(height - 1):
+        i_idx = 0
+        for i in range(width - 1):
+            hidx1, hidx2 = horizontal_idx[j], horizontal_idx[j+1]
+            vidx1, vidx2 = vertical_idx[i], vertical_idx[i+1]
+            hidx1 = max(0, hidx1 - 2)
+            hidx2 = min(src.shape[0], hidx2 + 4)
+            vidx1 = max(0, vidx1 - 2)
+            vidx2 = min(src.shape[1], vidx2 + 4)
+            if (hidx2 - hidx1) < median_horizontal_dist * 0.5 or (vidx2 - vidx1) < median_vertical_dist * 0.5:
+                continue
+            cell = src[hidx1:hidx2, vidx1:vidx2]
+            mid_x = cell.shape[1] // 2
+            mid_y = cell.shape[0] // 2
+            print(f"mid_x: {mid_x}, mid_y: {mid_y}")
+            cell_50_percent = cell[int(mid_y*0.5):int(mid_y*1.5), int(mid_x*0.5):int(mid_x*1.5)]
+            # show_wait_destroy(f"cell_{i_idx}_{j_idx}", cell_50_percent)
+            output_rgb[j_idx, i_idx] = cell_50_percent.mean(axis=(0, 1))
+            print(f"output_rgb[{j_idx}, {i_idx}]: {output_rgb[j_idx, i_idx]}")
+            i_idx += 1
+        j_idx += 1
+
+    colors_to_cluster = cluster_colors(output_rgb)
+    width = max(pos[1] for pos in output_rgb.keys()) + 1
+    height = max(pos[0] for pos in output_rgb.keys()) + 1
+    out = np.zeros((height, width), dtype=object)
+    print(colors_to_cluster)
+    for pos, cluster_id in colors_to_cluster.items():
+        out[pos[0], pos[1]] = cluster_id
+    print('Shape of out:', out.shape)
+
+    with open(output_path, 'w') as f:
+        f.write('[\n')
+        for i, row in enumerate(out):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(out) - 1:
+                f.write(',')
+            f.write('\n')
+        f.write(']')
+    print('output json: ', output_path)
+
+def euclidean_distance(a: tuple[int, int, int], b: tuple[int, int, int]) -> int:
+    return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2) ** 0.5
+
+KNOWN_COLORS = {
+    (0, 0, 255): 'Red',
+    (0, 255, 0): 'Green',
+    (255, 77, 51): 'Blue',
+    (0, 255, 255): 'Yellow',
+    (255, 153, 255): 'Pink',
+    (0, 128, 255): 'Orange',
+    (255, 204, 102): 'Cyan',
+    (179, 255, 179): 'Washed Green',
+    (77, 77, 128): 'Brown',
+    (179, 0, 128): 'Purple',
+}
+
+def cluster_colors(rgb: dict[tuple[int, int], tuple[int, int, int]]) -> dict[tuple[int, int, int], int]:
+    MIN_DIST = 10  # if distance between two colors is less than this, then they are the same color
+    colors_to_cluster = KNOWN_COLORS.copy()
+    for pos, color in rgb.items():
+        color = tuple(color)
+        if color in colors_to_cluster:
+            continue
+        for existing_color, existing_cluster_id in colors_to_cluster.items():
+            if euclidean_distance(color, existing_color) < MIN_DIST:
+                colors_to_cluster[color] = existing_cluster_id
+                break
+        else:
+            new_name = str(', '.join(str(int(c)) for c in color))
+            print('WARNING: new color found:', new_name, 'at pos:', pos)
+            colors_to_cluster[color] = new_name
+    pos_to_cluster = {pos: colors_to_cluster[tuple(color)] for pos, color in rgb.items()}
+    return pos_to_cluster
+
+
+if __name__ == '__main__':
+    # to run this script and visualize the output, in the root run:
+    #  python .\src\puzzle_solver\puzzles\flood_it\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
+    # main(Path(__file__).parent / 'input_output' / 'flood.html#12x12c10m5%23637467359431429.png')
+    # main(Path(__file__).parent / 'input_output' / 'flood.html#12x12c6m5%23132018455881870.png')
+    # main(Path(__file__).parent / 'input_output' / 'flood.html#12x12c6m0%23668276603006993.png')
+    # main(Path(__file__).parent / 'input_output' / 'flood.html#20x20c8m0%23991967486182787.png')flood.html#20x20c4m0%23690338575695152
+    main(Path(__file__).parent / 'input_output' / 'flood.html#20x20c4m0%23690338575695152.png')

puzzle_solver/puzzles/galaxies/galaxies.py

@@ -85,7 +85,7 @@ class Board:
             self.model.AddExactlyOne(pos_vars)
             for galaxy_idx, v in self.pos_to_galaxy[pos].items():
                 galaxy_vars.setdefault(galaxy_idx, {})[pos] = v
-        for galaxy_idx, pos_vars in galaxy_vars.items():
+        for pos_vars in galaxy_vars.values():
             force_connected_component(self.model, pos_vars)
 
 

puzzle_solver/puzzles/galaxies/parse_map/parse_map.py

@@ -1,5 +1,5 @@
 """
-    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.html and converts them to a json file. 
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.html and converts them to a json file.
     Look at the ./input_output/ directory for examples of input images and output json files.
     The output json is used in the test_solve.py file to test the solver.
 """
@@ -25,7 +25,7 @@ def extract_lines(bw):
     # location where the horizontal lines are
     horizontal_idx = np.where(horizontal_means > horizontal_cutoff)[0]
     # print(f"horizontal_idx: {horizontal_idx}")
-    height = len(horizontal_idx)
+    # height = len(horizontal_idx)
     # show_wait_destroy("horizontal", horizontal)  # this has the horizontal lines
 
     rows = vertical.shape[0]
@@ -38,7 +38,7 @@ def extract_lines(bw):
     vertical_cutoff = np.percentile(vertical_means, 50)
     vertical_idx = np.where(vertical_means > vertical_cutoff)[0]
     # print(f"vertical_idx: {vertical_idx}")
-    width = len(vertical_idx)
+    # width = len(vertical_idx)
     # print(f"height: {height}, width: {width}")
     # print(f"vertical_means: {vertical_means}")
     # show_wait_destroy("vertical", vertical)  # this has the vertical lines

puzzle_solver/puzzles/guess/guess.py

@@ -5,7 +5,7 @@ import numpy as np
 
 
 class Board:
-    def __init__(self, num_pegs: int = 4, all_colors: list[str] = ['R', 'Y', 'G', 'B', 'O', 'P'], show_warnings: bool = True, show_progress: bool = False):
+    def __init__(self, num_pegs: int = 4, all_colors: tuple[str] = ('R', 'Y', 'G', 'B', 'O', 'P'), show_warnings: bool = True, show_progress: bool = False):
         assert num_pegs >= 1, 'num_pegs must be at least 1'
         assert len(all_colors) == len(set(all_colors)), 'all_colors must contain only unique colors'
         self.previous_guesses = []

puzzle_solver/puzzles/heyawake/heyawake.py

@@ -1,12 +1,13 @@
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, set_char, get_char
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, get_char
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
 from puzzle_solver.core.utils_visualizer import render_shaded_grid
 
+
 def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
-    """Given a list of integers (mostly with duplicates), return every consecutive sequence of 3 integer changes. 
+    """Given a list of integers (mostly with duplicates), return every consecutive sequence of 3 integer changes.
     i.e. return a list of (begin_idx, end_idx) tuples where for each r=int_list[begin_idx:end_idx] we have r[0]!=r[1] and r[-2]!=r[-1] and len(r)>=3"""
     out = []
     change_indices = [i for i in range(len(int_list) - 1) if int_list[i] != int_list[i+1]]
@@ -18,7 +19,6 @@ def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
             continue
         out.append((begin_idx, end_idx))
     return out
-    
 
 class Board:
     def __init__(self, board: np.array, region_to_clue: dict[str, int]):

puzzle_solver/puzzles/inertia/inertia.py

@@ -118,4 +118,4 @@ def solve_optimal_walk(
     seed: int = 0,
     verbose: bool = False
 ) -> list[tuple[Pos, Pos]]:
-    return tsp.solve_optimal_walk(start_pos, edges, gems_to_edges, restarts=restarts, time_limit_ms=time_limit_ms, seed=seed, verbose=verbose)
+    return tsp.solve_optimal_walk(start_pos, edges, gems_to_edges, restarts=restarts, time_limit_ms=time_limit_ms, seed=seed, verbose=verbose)

puzzle_solver/puzzles/inertia/parse_map/parse_map.py

@@ -1,25 +1,24 @@
 """
-    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html and converts them to a json file. 
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html and converts them to a json file.
     Look at the ./input_output/ directory for examples of input images and output json files.
     The output json is used in the test_solve.py file to test the solver.
 """
 from pathlib import Path
 import numpy as np
-import numpy as np
 cv = None
 Image = None
 
 def load_cell_templates(p: Path) -> dict[str, dict]:
-    img = Image.open(p)
+    # img = Image.open(p)
     src = cv.imread(p, cv.IMREAD_COLOR)
-    rgb = np.asarray(img).astype(np.float32) / 255.0
+    # rgb = np.asarray(img).astype(np.float32) / 255.0
     if len(src.shape) != 2:
         gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
     else:
         gray = src
     gray = cv.bitwise_not(gray)
-    bw = cv.adaptiveThreshold(gray.copy(), 255, cv.ADAPTIVE_THRESH_MEAN_C, \
-                                cv.THRESH_BINARY, 15, -2)
+    # bw = cv.adaptiveThreshold(gray.copy(), 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+    #                             cv.THRESH_BINARY, 15, -2)
     return {"gray": gray}
 
 
@@ -53,10 +52,14 @@ def get_distance_robust(cell: np.ndarray, template: np.ndarray, max_shift: int =
     for dy in range(-max_shift, max_shift + 1):
         for dx in range(-max_shift, max_shift + 1):
             # compute overlapping slices for this shift
-            y0a = max(0,  dy); y1a = H + min(0,  dy)
-            x0a = max(0,  dx); x1a = W + min(0,  dx)
-            y0b = max(0, -dy); y1b = H + min(0, -dy)
-            x0b = max(0, -dx); x1b = W + min(0, -dx)
+            y0a = max(0,  dy)
+            y1a = H + min(0,  dy)
+            x0a = max(0,  dx)
+            x1a = W + min(0,  dx)
+            y0b = max(0, -dy)
+            y1b = H + min(0, -dy)
+            x0b = max(0, -dx)
+            x1b = W + min(0, -dx)
 
             if y1a <= y0a or x1a <= x0a:  # no overlap
                 continue