multi-puzzle-solver 0.9.30__py3-none-any.whl → 1.0.2__py3-none-any.whl

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

puzzle_solver/puzzles/inertia/tsp.py

@@ -197,7 +197,7 @@ def solve_optimal_walk(
             changed = False
             i = 0
             while i + 3 < len(ns):
-                u, v, w, z = ns[i], ns[i+1], ns[i+2], ns[i+3]
+                u, v, w = ns[i], ns[i+1], ns[i+2]
                 if w == u:  # u->v, v->u
                     before_edges = walk_edges(ns[:i+1])
                     removed_edges = [(u, v), (v, u)]
@@ -235,7 +235,7 @@ def solve_optimal_walk(
         for i in range(N_no_depot):
             gi = state_group[i]
             for j in range(N_no_depot):
-                if i == j: 
+                if i == j:
                     continue
                 gj = state_group[j]
                 if gi != gj:
@@ -244,9 +244,9 @@ def solve_optimal_walk(
         # ring + shift
         INF = 10**12
         succ_in_cluster: Dict[int, int] = {}
-        for g, order in cluster_orders.items():
+        for order in cluster_orders.values():
             k = len(order)
-            if k == 0: 
+            if k == 0:
                 continue
             pred = {}
             for idx, v in enumerate(order):
@@ -327,7 +327,6 @@ def solve_optimal_walk(
 
     best_nodes = None
     best_cost = float('inf')
-    best_reps = None
 
     # initial deterministic order as a baseline
     def shuffled_cluster_orders():
@@ -339,7 +338,7 @@ def solve_optimal_walk(
         return orders
 
     attempts = max(1, restarts)
-    for attempt in range(attempts):
+    for _ in range(attempts):
         cluster_orders = shuffled_cluster_orders()
         for meta in meta_list:
             # print('solve once')
@@ -382,7 +381,6 @@ def solve_optimal_walk(
             if cost < best_cost:
                 best_cost = cost
                 best_nodes = nodes_seq
-                best_reps = reps
 
     if best_nodes is None:
         raise RuntimeError("No solution found.")

puzzle_solver/puzzles/kakuro/kakuro.py

@@ -4,7 +4,7 @@ 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 Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, set_char, get_char, get_neighbors8
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, get_char
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 from puzzle_solver.core.utils_visualizer import render_shaded_grid
 

puzzle_solver/puzzles/keen/keen.py

@@ -75,9 +75,9 @@ class Board:
         for col in range(self.N):
             col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.N)]
             self.model.AddAllDifferent(col_vars)
-    
+
     def constrain_block_results(self):
-        # The digits in each block can be combined to form the number stated in the clue, using the arithmetic operation given in the clue. That is: 
+        # The digits in each block can be combined to form the number stated in the clue, using the arithmetic operation given in the clue. That is:
         for block, (op, result) in self.block_results.items():
             block_vars = [self.model_vars[p] for p in self.get_block_pos(block)]
             add_opcode_constraint(self.model, block_vars, op, result)

puzzle_solver/puzzles/minesweeper/minesweeper.py

@@ -103,7 +103,7 @@ def give_next_guess(board: np.array, mine_count: Optional[int] = None, verbose:
             print(new_garuneed_mine_positions)
             print('-'*10)
         if len(wrong_flag_positions) > 0:
-            print(f"WARNING | "*4 + "WARNING")
+            print("WARNING | "*4 + "WARNING")
             print(f"Found {len(wrong_flag_positions)} wrong flag positions")
             print(wrong_flag_positions)
             print('-'*10)
@@ -120,5 +120,4 @@ def print_board(board: np.array, safe_positions: set[Pos], new_garuneed_mine_pos
             set_char(res, pos, 'M')
         elif get_char(board, pos) == 'F' and pos not in wrong_flag_positions:
             set_char(res, pos, 'F')
-    
-    print(res)
+    print(res)

puzzle_solver/puzzles/nonograms/nonograms.py

@@ -7,8 +7,8 @@ from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 class Board:
     def __init__(self, top: list[list[int]], side: list[list[int]]):
-        assert all(isinstance(i, int) for l in top for i in l), 'top must be a list of lists of integers'
-        assert all(isinstance(i, int) for l in side for i in l), 'side must be a list of lists of integers'
+        assert all(isinstance(i, int) for line in top for i in line), 'top must be a list of lists of integers'
+        assert all(isinstance(i, int) for line in side for i in line), 'side must be a list of lists of integers'
         self.top = top
         self.side = side
         self.V = len(side)
@@ -63,7 +63,7 @@ class Board:
         # Start variables for each run. This is the most critical variable for the problem.
         starts = []
         self.extra_vars[f"{ns}_starts"] = starts
-        for i, c in enumerate(clues):
+        for i in range(len(clues)):
             s = self.model.NewIntVar(0, L, f"{ns}_s[{i}]")
             starts.append(s)
         # Enforce order and >=1 blank between consecutive runs.

puzzle_solver/puzzles/norinori/norinori.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, Shape, get_all_pos, get_char, set_char, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 
 @dataclass

puzzle_solver/puzzles/nurikabe/nurikabe.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 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, in_bounds, set_char, get_char, polyominoes, Shape, Direction, get_next_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, in_bounds, get_char, polyominoes, Shape, Direction, get_next_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
 from puzzle_solver.core.utils_visualizer import render_shaded_grid
 
@@ -62,7 +62,7 @@ class Board:
             assert len(hint_shapes) > 0, f'no shapes found for hint {hint_pos} with value {hint_value}'
             self.model.AddExactlyOne([s.is_active for s in hint_shapes])
             self.shapes_on_board.extend(hint_shapes)
-        
+
         # if no shape is active on the spot then it must be black
         for pos in self.get_all_legal_pos():
             shapes_here = [s for s in self.shapes_on_board if pos in s.body]

puzzle_solver/puzzles/range/range.py

@@ -2,7 +2,7 @@ import numpy as np
 from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_neighbors4, in_bounds, Direction, get_next_pos, get_char
-from puzzle_solver.core.utils_ortools import and_constraint, or_constraint, generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
 
 
 def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -97,7 +97,7 @@ class Board:
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, int] = {}
-            for (i, rectangle) in enumerate(self.rectangles):
+            for rectangle in self.rectangles:
                 if solver.Value(rectangle.active) == 1:
                     for pos in rectangle.body:
                         assignment[pos] = f'id{rectangle.clue_id}:N={rectangle.N}:{rectangle.height}x{rectangle.width}'
@@ -121,10 +121,6 @@ class Board:
                     set_char(res, pos, get_char(res, pos) + 'U')
                 if bottom_pos not in single_res.assignment or single_res.assignment[bottom_pos] != cur:
                     set_char(res, pos, get_char(res, pos) + 'D')
-            # print('[')
-            # for row in id_board:
-            #     print('       ', row.tolist(), end=',\n')
-            # print('    ])')
-            print(render_grid(res, center_char=self.board))
+            print(render_grid(res, center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else ' '))
 
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/shingoki/shingoki.py

@@ -76,7 +76,7 @@ class Board:
                 continue
             self.enforce_corner_color(pos, self.board_colors[pos])
             self.enforce_corner_number(pos, self.board_numbers[pos])
-        
+
         # enforce single connected component
         def is_neighbor(edge1: tuple[Pos, Pos], edge2: tuple[Pos, Pos]) -> bool:
             return any(c1 == c2 for c1 in edge1 for c2 in edge2)

puzzle_solver/puzzles/signpost/signpost.py

@@ -65,7 +65,7 @@ class Board:
                 continue
             direction = CHAR_TO_DIRECTION8[c]
             self.constrain_plus_one(pos, direction)
-    
+
     def constrain_plus_one(self, pos: Pos, direction: Direction8):
         beam_res = beam(pos, self.V, self.H, direction)
         is_eq_list = []
@@ -75,7 +75,7 @@ class Board:
             self.model.Add(self.model_vars[p] != self.model_vars[pos] + 1).OnlyEnforceIf(aux.Not())
             is_eq_list.append(aux)
         self.model.Add(lxp.Sum(is_eq_list) == 1)
-    
+
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, str] = {}

puzzle_solver/puzzles/slant/parse_map/parse_map.py

@@ -1,10 +1,10 @@
 """
-    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.
 """
 
-import json, itertools
+import itertools
 from pathlib import Path
 import numpy as np
 cv = None
@@ -37,9 +37,11 @@ def mean_consecutives(arr):
     sums, counts = [arr[0]], [1]
     for k in arr[1:]:
         if k == sums[-1] + counts[-1]:
-            sums[-1] += k; counts[-1] += 1
+            sums[-1] += k
+            counts[-1] += 1
         else:
-            sums.append(k); counts.append(1)
+            sums.append(k)
+            counts.append(1)
     return np.array(sums)//np.array(counts)
 
 def main(img_path):
@@ -90,7 +92,7 @@ def main(img_path):
 
     # Build KD-like search by grid proximity
     tol = int(cell*0.5)  # max distance from an intersection to accept a circle
-    for (cx, cy, r) in detected:
+    for (cx, cy, _) in detected:
         # find nearest indices
         j = int(np.argmin(np.abs(h_idx - cy)))
         i = int(np.argmin(np.abs(v_idx - cx)))

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -56,7 +56,7 @@ class Board:
         next_pos = get_next_pos(pos, direction)
         if in_bounds(next_pos, self.V, self.H):
             self.cell_borders[(next_pos, get_opposite_direction(direction))] = var
-    
+
     def add_corner_vars(self, cell_border: CellBorder, var: cp_model.IntVar):
         """
         An edge always belongs to two corners. Note that the cell xi,yi has the 4 corners (xi,yi), (xi+1,yi), (xi,yi+1), (xi+1,yi+1). (memorize these 4 coordinates or the function wont make sense)

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -1,5 +1,5 @@
 """
-    This file is a simple helper that parses the images from https://www.puzzle-stitches.com/ and converts them to a json file. 
+    This file is a simple helper that parses the images from https://www.puzzle-stitches.com/ 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.
 """
@@ -26,7 +26,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]
@@ -39,7 +39,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
@@ -126,7 +126,6 @@ def main(image):
     print(f"vertical_idx: {vertical_idx}")
     arr = np.zeros((height - 1, width - 1), dtype=object)
     output = {'top': arr.copy(), 'left': arr.copy(), 'right': arr.copy(), 'bottom': arr.copy()}
-    target = 200_000
     hists = {'top': {}, 'left': {}, 'right': {}, 'bottom': {}}
     for j in range(height - 1):
         for i in range(width - 1):
@@ -244,4 +243,6 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.png')
     # main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')
     # main(Path(__file__).parent / 'input_output' / 'heyawake_MDoxNiwxNDQ=.png')
-    main(Path(__file__).parent / 'input_output' / 'heyawake_MTQ6ODQ4LDEzOQ==.png')
+    # main(Path(__file__).parent / 'input_output' / 'heyawake_MTQ6ODQ4LDEzOQ==.png')
+    main(Path(__file__).parent / 'input_output' / 'sudoku_jigsaw.png')
+

puzzle_solver/puzzles/stitches/stitches.py

@@ -77,7 +77,7 @@ class Board:
                 # print(f'{pos}:{direction} must == {neighbor}:{opposite_direction}')
 
         # all blocks connected exactly N times (N usually 1 but can be 2 or 3)
-        for (block_i, block_j), connections in self.block_neighbors.items():
+        for connections in self.block_neighbors.values():
             is_connected_list = []
             for pos_a, direction_a, pos_b, direction_b in connections:
                 v = self.model.NewBoolVar(f'{pos_a}:{direction_a}->{pos_b}:{direction_b}')