puzzlekit 0.1.0__py3-none-any.whl

puzzlekit/__init__.py

@@ -0,0 +1,12 @@
+from typing import Dict, Any
+from puzzlekit.solvers import get_solver_class
+
+def solver(puzzle_type: str, data: Dict[str, Any] = None, **kwargs) -> Any:
+
+    init_params = (data or {}).copy()
+    init_params.update(kwargs)
+    
+    SolverClass = get_solver_class(puzzle_type)
+    return SolverClass(**init_params)
+
+__all__ = ["solver"]

puzzlekit/core/direction.py

@@ -0,0 +1,107 @@
+class Direction:
+    def __init__(self, value):
+        if isinstance(value, str):
+            if value == 'down':
+                self._value = Direction._DOWN
+                return
+            if value == 'right':
+                self._value = Direction._RIGHT
+                return
+            if value == 'up':
+                self._value = Direction._UP
+                return
+            if value == 'left':
+                self._value = Direction._LEFT
+                return
+            else:
+                raise ValueError(f"Unknown direction {value}")
+        if value not in Direction._orthogonal_directions_values() and value != Direction._NONE:
+            raise ValueError(f"Unknown direction {value}")
+        self._value = value
+
+    @staticmethod
+    def orthogonals():
+        return [Direction.up(), Direction.left(), Direction.down(), Direction.right()]
+
+    @staticmethod
+    def _orthogonal_directions_values():
+        return [Direction._UP, Direction._LEFT, Direction._DOWN, Direction._RIGHT]
+
+    @staticmethod
+    def up():
+        return Direction(Direction._UP)
+
+    @staticmethod
+    def down():
+        return Direction(Direction._DOWN)
+
+    @staticmethod
+    def right():
+        return Direction(Direction._RIGHT)
+
+    @staticmethod
+    def left():
+        return Direction(Direction._LEFT)
+
+    @staticmethod
+    def none():
+        return Direction(Direction._NONE)
+
+    @property
+    def opposite(self):
+        if self.value == Direction._DOWN:
+            return Direction.up()
+        if self.value == Direction._UP:
+            return Direction.down()
+        if self.value == Direction._RIGHT:
+            return Direction.left()
+        if self.value == Direction._LEFT:
+            return Direction.right()
+        return Direction(Direction._NONE)
+
+    @property
+    def value(self):
+        return self._value
+
+    def __str__(self):
+        if self._value == Direction._DOWN:
+            return 'D'
+        if self._value == Direction._RIGHT:
+            return 'R'
+        if self._value == Direction._UP:
+            return 'U'
+        if self._value == Direction._LEFT:
+            return 'L'
+        return 'X'
+    
+    # def __str__(self):
+    #     if self._value == Direction._DOWN:
+    #         return '⊓'
+    #     if self._value == Direction._RIGHT:
+    #         return '⊏'
+    #     if self._value == Direction._UP:
+    #         return '⊔'
+    #     if self._value == Direction._LEFT:
+    #         return '⊐'
+    #     return 'x'
+
+    def __eq__(self, other):
+        if isinstance(other, Direction):
+            return self.value == other.value
+        if isinstance(other, str):
+            return self.__str__() == other
+        if isinstance(other, int):
+            return self.value == other
+        return False
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __hash__(self):
+        return hash(self._value)
+
+    _NONE = 0
+    _DOWN = 1
+    _RIGHT = 2
+    _UP = 3
+    _LEFT = 4

puzzlekit/core/grid.py

@@ -0,0 +1,197 @@
+from collections import defaultdict
+from typing import Generic, TypeVar, FrozenSet, Generator, Any
+from puzzlekit.core.position import Position
+
+T = TypeVar("T")
+
+class Grid(Generic[T]):
+    def __init__(self, matrix: list[list[T]]):
+        self._matrix = matrix if matrix is not None else []
+        try:
+            self.num_rows = len(self._matrix)
+            self.num_cols = len(self._matrix[0]) if self.num_rows > 0 else 0
+        except (TypeError, IndexError):
+            self.num_cols = 0
+        self._walls : set[FrozenSet[Position]] = set()
+    
+    def __getitem__(self, key) -> T:
+        if isinstance(key, Position):
+            return self._matrix[key.r][key.c]
+        if isinstance(key, tuple):
+            return self._matrix[key[0]][key[1]]
+        return self._matrix[key]
+    
+    def __eq__(self, other):
+        if not issubclass(type(other), Grid):
+            return False
+        if all(isinstance(cell, bool) for cell in self._matrix):
+            return all(value == other.value(position) for position, value in self)
+        return self.matrix == other.matrix
+    
+    def __hash__(self):
+        return hash(str(self._matrix))
+    
+    def __repr__(self) -> str:
+        if self.is_empty():
+            return "Grid.empty()"
+        return "\n".join(" ".join(str(cell) for cell in row) for row in self._matrix)
+
+    def __contains__(self, item: Position | T) -> bool:
+        if item is None:
+            return False
+        return 0 <= item.r < self.num_rows and 0 <= item.c < self.num_cols
+    
+    def __iter__(self) -> Generator[tuple[Position, T | Any], None, None]:
+        for r, row in enumerate(self._matrix):
+            for c, cell in enumerate(row):
+                yield Position(r, c), cell
+
+    @property
+    def matrix(self):
+        return self._matrix
+
+    @property
+    def walls(self):
+        return self._walls
+    
+    @staticmethod
+    def empty() -> 'Grid':
+        return Grid([[]])
+    
+    def is_empty(self):
+        return self == Grid.empty()
+    
+    def value(self, r, c = None):
+        if isinstance(r, Position):
+            # in case directly input Position
+            return self._matrix[r.r][r.c]
+        return self._matrix[r][c]
+    
+    # def get_regions(self) -> dict[T, frozenset[Position]]:
+    #     regions = defaultdict(set)
+    #     for r in range(self.num_rows):
+    #         for c in range(self.num_cols):
+    #             if self._matrix[r][c] not in regions:
+    #                 regions[self._matrix[r][c]] = set()
+    #             regions[self._matrix[r][c]].add(Position(r, c))
+    #     return {key: frozenset(value) for key, value in regions.items()} if regions else {}
+    
+    def set_value(self, position: Position, value):
+        self._matrix[position.r][position.c] = value
+    
+    def get_index_from_position(self, position: Position) -> int:
+        return position.r * self.num_cols + position.c
+    
+    def get_position_from_index(self, index: int) -> Position:
+        return Position(index // self.num_cols, index % self.num_rows)
+    
+    def _depth_first_search(self, position: Position, value, mode = "orthogonal", visited = None) -> set[Position]:
+        if visited is None:
+            visited = set()
+        if (self.value(position) != value) or (position in visited):
+            return visited
+        visited.add(position)
+        directions = [(0, 1), (0, -1), (1, 0), (-1, 0)] if mode != 'diagonal' else [(1, 1), (1, -1), (-1, 1), (-1, -1)]
+        for dr, dc in directions:
+            if 0 <= position.r + dr < self.num_rows and 0 <= position.c + dc < self.num_cols and (position.r + dr, position.c + dc) not in visited:
+                current_position = position + Position(dr, dc)
+                if self.value(current_position) == value:
+                    new_visited = self._depth_first_search(current_position, value, mode, visited)
+                    if new_visited != visited:
+                        return new_visited
+        return visited
+    
+    # define neighbor
+    def neighbor_up(self, position: Position) -> Position:
+        return position.up if position.up in self and {position, position.up} not in self._walls else None
+    
+    def neighbor_down(self, position: Position) -> Position:
+        return position.down if position.down in self and {position, position.down} not in self._walls else None
+    
+    def neighbor_left(self, position: Position) -> Position:
+        return position.left if position.left in self and {position, position.left} not in self._walls else None
+    
+    def neighbor_right(self, position: Position) -> Position:
+        return position.right if position.right in self and {position, position.right} not in self._walls else None
+    
+    def neighbor_right(self, position: Position) -> Position:
+        return position.right if position.right in self and {position, position.right} not in self._walls else None
+
+    def neighbor_up_left(self, position: Position) -> Position:
+        return position.up_left if position.up_left in self else None  # check if wall is not between position and position.up_left ?
+
+    def neighbor_up_right(self, position: Position) -> Position:
+        return position.up_right if position.up_right in self else None  # check if wall is not between position and position.up_right ?
+
+    def neighbor_down_left(self, position: Position) -> Position:
+        return position.down_left if position.down_left in self else None  # check if wall is not between position and position.down_left ?
+
+    def neighbor_down_right(self, position: Position) -> Position:
+        return position.down_right if position.down_right in self else None  # check if wall is not between position and position.down_right ?
+    
+    def get_neighbors(self, position: Position, mode = "orthogonal"):
+        if mode == 'diagonal_only':
+            return {self.neighbor_up_left(position), self.neighbor_up_right(position), self.neighbor_down_left(position), self.neighbor_down_right(position)} - {None}
+
+        orthogonal_neighbors = {self.neighbor_up(position), self.neighbor_down(position), self.neighbor_left(position), self.neighbor_right(position)} - {None}
+       
+        if mode == 'orthogonal':
+            return orthogonal_neighbors
+
+        if mode == 'diagonal' or mode == 'all':
+            diagonal_neighbors = {self.neighbor_up_left(position), self.neighbor_up_right(position), self.neighbor_down_left(position), self.neighbor_down_right(position)} - {None}
+            return orthogonal_neighbors | diagonal_neighbors
+
+        raise ValueError(f"Invalid mode: {mode}")
+
+    def get_line_of_sight(self, position : Position, mode = "orthogonal", end = None):
+        directions_orthogonal = [(-1, 0), (1, 0), (0, 1), (0, -1)]
+        directions_diagonal = [(-1, -1), (-1, 1), (1, -1), (1, 1)]
+        directions = []
+        if mode == "orthogonal":
+            directions = directions_orthogonal
+        elif mode == "diagonal_only":
+            directions = directions_diagonal
+        elif mode == "diagonal" or mode == "all":
+            directions = directions_orthogonal + directions_diagonal
+        else:
+            raise ValueError(f"Invalid mode: {mode}")
+        
+        line_of_sight = set()
+        
+        if end is None:
+            end = set()
+        for (x_, y_) in directions:
+            i, j = position.r, position.c
+            while 0 <= i + x_ < self.num_rows and 0 <= j + y_ < self.num_cols and (i + x_, j + y_) not in end:
+                line_of_sight.add(Position(i + x_, j + y_))
+                i += x_ 
+                j += y_
+                
+        return line_of_sight - {None}
+
+    
+    def is_bijective(self, other):
+        if not issubclass(type(other), Grid):
+            return False
+        mapping_1_to_2 = {}  
+        mapping_2_to_1 = {}  
+        r2, c2 = other.num_rows, other.num_cols
+        if self.num_rows != r2 or self.num_cols != c2:
+            return False
+        for i in range(self.num_rows):
+            for j in range(self.num_cols):
+                elem1 = self.value(i, j)
+                elem2 = other.value(i, j)
+                if elem1 in mapping_1_to_2:
+                    if mapping_1_to_2[elem1] != elem2:
+                        return False
+                else:
+                    mapping_1_to_2[elem1] = elem2
+                if elem2 in mapping_2_to_1:
+                    if mapping_2_to_1[elem2] != elem1:
+                        return False
+                else:
+                    mapping_2_to_1[elem2] = elem1
+        return True
+        

puzzlekit/core/position.py

@@ -0,0 +1,173 @@
+import math 
+from puzzlekit.core.direction import Direction
+class Position:
+    def __init__(self, r, c):
+        self.r = r
+        self.c = c
+
+    def neighbors(self, mode='orthogonal') -> list['Position']:
+        if mode == 'orthogonal':
+            return [self.up, self.left, self.down, self.right, ]
+        if mode == 'diagonal':
+            return [self.up, self.up_left, self.left, self.down_left, self.down, self.down_right, self.right, self.up_right]
+        raise ValueError(f"Unknown mode {mode}")
+
+    def direction_to(self, other: 'Position') -> Direction:
+        if other is None or self == other:
+            return Direction(Direction.none())
+        if self.r == other.r:
+            if self.c < other.c:
+                return Direction.right()
+            return Direction.left()
+        if self.c == other.c:
+            if self.r < other.r:
+                return Direction.down()
+            return Direction.up()
+        return Direction(Direction.none())
+
+    def direction_from(self, other: 'Position') -> Direction:
+        return other.direction_to(self)
+
+    def distance_to(self, other: 'Position') -> float:
+        if self.r == other.r:
+            return abs(self.c - other.c)
+        if self.c == other.c:
+            return abs(self.r - other.r)
+        return math.sqrt(math.pow(self.r - other.r, 2) + math.pow(self.c - other.c, 2))
+
+    def after(self, direction: Direction, count=1) -> 'Position':
+        if direction == Direction.down():
+            return Position(self.r + count, self.c)
+        if direction == Direction.right():
+            return Position(self.r, self.c + count)
+        if direction == Direction.up():
+            return Position(self.r - count, self.c)
+        if direction == Direction.left():
+            return Position(self.r, self.c - count)
+        return self
+
+    def before(self, direction, count=1) -> 'Position':
+        return self.after(direction.opposite, count)
+
+    @property
+    def left(self):
+        return Position(self.r, self.c - 1)
+
+    @property
+    def right(self):
+        return Position(self.r, self.c + 1)
+
+    @property
+    def up(self):
+        return Position(self.r - 1, self.c)
+
+    @property
+    def down(self):
+        return Position(self.r + 1, self.c)
+
+    @property
+    def up_left(self):
+        return Position(self.r - 1, self.c - 1)
+
+    @property
+    def up_right(self):
+        return Position(self.r - 1, self.c + 1)
+
+    @property
+    def down_left(self):
+        return Position(self.r + 1, self.c - 1)
+
+    @property
+    def down_right(self):
+        return Position(self.r + 1, self.c + 1)
+
+    def all_positions_between(self, position: 'Position') -> list['Position']:
+        if self.r == position.r:
+            return [Position(self.r, c) for c in range(min(self.c, position.c) + 1, max(self.c, position.c))]
+        if self.c == position.c:
+            return [Position(r, self.c) for r in range(min(self.r, position.r) + 1, max(self.r, position.r))]
+        return []
+
+    def all_positions_and_bounds_between(self, position: 'Position') -> list['Position']:
+        if self.r == position.r:
+            return [Position(self.r, c) for c in range(min(self.c, position.c), max(self.c, position.c) + 1)]
+        if self.c == position.c:
+            return [Position(r, self.c) for r in range(min(self.r, position.r), max(self.r, position.r) + 1)]
+        return []
+
+    def symmetric(self, position, to_int=True) -> 'Position':
+        if to_int:
+            return Position(int(2 * position.r - self.r), int(2 * position.c - self.c))
+        return Position(2 * position.r - self.r, 2 * position.c - self.c)
+
+    def is_on_row(self):
+        return self.r == math.floor(self.r)
+
+    def is_on_column(self):
+        return self.c == math.floor(self.c)
+
+    def __floor__(self):
+        return Position(math.floor(self.r), math.floor(self.c))
+
+    def __ceil__(self):
+        return Position(math.ceil(self.r), math.ceil(self.c))
+
+    def __eq__(self, other):
+        return isinstance(other, Position) and self.r == other.r and self.c == other.c
+
+    def __hash__(self):
+        return hash((self.r, self.c))
+
+    def __str__(self):
+        return f'({self.r}, {self.c})'
+
+    def __repr__(self):
+        return f'Position{self.__str__()}'
+
+    def __add__(self, other):
+        return Position(self.r + other.r, self.c + other.c)
+
+    def __sub__(self, other):
+        return Position(self.r - other.r, self.c - other.c)
+
+    def __mul__(self, other):
+        return Position(self.r * other, self.c * other)
+
+    def __truediv__(self, other):
+        return Position(self.r / other, self.c / other)
+
+    def __floordiv__(self, other):
+        return Position(self.r // other, self.c // other)
+
+    def __mod__(self, other):
+        return Position(self.r % other, self.c % other)
+
+    def __lt__(self, other):
+        return self.r < other.r or (self.r == other.r and self.c < other.c)
+
+    def __le__(self, other):
+        return self.r <= other.r or (self.r == other.r and self.c <= other.c)
+
+    def __gt__(self, other):
+        return self.r > other.r or (self.r == other.r and self.c > other.c)
+
+    def __ge__(self, other):
+        return self.r >= other.r or (self.r == other.r and self.c >= other.c)
+
+    def __getitem__(self, item):
+        return self.r if item == 0 else self.c
+
+    def __setitem__(self, key, value):
+        if key == 0:
+            self.r = value
+        else:
+            self.c = value
+
+    def __iter__(self):
+        return iter([self.r, self.c])
+
+    def __neg__(self):
+        return Position(-self.r, -self.c)
+
+    def __len__(self):  # get air of rectangle from (0, 0) to self
+        return abs(self.r) + abs(self.c) + 1

puzzlekit/core/regionsgrid.py

@@ -0,0 +1,51 @@
+from typing import Generic, TypeVar, FrozenSet, Generator, Any, List, Set
+from puzzlekit.core.grid import Grid
+from puzzlekit.core.position import Position
+from collections import defaultdict
+
+T = TypeVar("T")
+
+class RegionsGrid(Grid):
+    def __init__(self, matrix: list[list[T]]):
+        super().__init__(matrix)
+        self._matrix = matrix
+        self.num_rows = len(matrix)
+        self.num_cols = len(matrix[0])
+        self._walls : set[FrozenSet[Position]] = set()
+        self._helper_grid = Grid(matrix)
+        self.regions, self.pos_to_regions, self.region_borders = self._get_regions()
+        self.num_regions = len(self.regions) if self.regions else 0
+
+    @staticmethod
+    def from_grid(grid: Grid):
+        return RegionsGrid(grid.matrix)
+    
+    def _get_regions(self) -> dict[T, frozenset[Position]]:
+        regions = defaultdict(set)
+        pos_to_regions = dict()
+        region_borders = dict() # record the border of current region
+        for r in range(self.num_rows):
+            for c in range(self.num_cols):
+                curr_region = self._matrix[r][c]
+                curr_position = Position(r, c)
+                if curr_region not in regions:
+                    regions[curr_region] = set()
+                    region_borders[curr_region] = set()
+                
+                regions[curr_region].add(Position(r, c))
+                pos_to_regions[r, c] = curr_region
+                for nbr in self._helper_grid.get_neighbors(curr_position, "orthogonal"):
+                    if self._matrix[nbr.r][nbr.c] != curr_region:
+                        if nbr == curr_position.up:
+                            region_borders[curr_region].add((nbr, curr_position))
+                        elif nbr == curr_position.left:
+                            region_borders[curr_region].add((nbr, curr_position))
+                        elif nbr == curr_position.right:
+                            region_borders[curr_region].add((curr_position, nbr))
+                        elif nbr == curr_position.down:
+                            region_borders[curr_region].add((curr_position, nbr))
+                    # if str(curr_region) == "13":
+                    #     print(nbr, (r, c))
+        return {key: frozenset(value) for key, value in regions.items()} if regions else {}, \
+                pos_to_regions if pos_to_regions else {}, \
+                {key: frozenset(value) for key, value in region_borders.items()} if region_borders else {}

puzzlekit/core/result.py

@@ -0,0 +1,49 @@
+import time
+from typing import Dict, Any, Optional
+from puzzlekit.core.grid import Grid
+from puzzlekit.viz import visualize
+
+class PuzzleResult:
+    def __init__(self, 
+                 puzzle_type: str, 
+                 puzzle_data: Dict[str, Any], 
+                 solution_data: Dict[str, Any]):
+        self.puzzle_type = puzzle_type
+        self.puzzle_data = puzzle_data              # Original meta data (clues, rows, etc.)
+        self.solution_data = solution_data      # Solution data (status, solution_grid, cpu_time, build_time, etc.)
+        
+        # save additional data
+        self.sol_grid = self.solution_data.get('solution_grid', None)
+    
+    @property
+    def is_solved(self) -> bool:
+        return self.solution_data.get("status") in ["Optimal", "Feasible"]
+    
+    def __repr__(self) -> str:
+        header = f"[{self.puzzle_type.title()}] \nStatus: {self.solution_data['status']} \nCPU time {self.solution_data['cpu_time']:.4f} s \nBuild time {self.solution_data['build_time']:.4f} s"
+        if self.is_solved and self.sol_grid:
+            return f"{header}\n{self.sol_grid}"
+        return header
+    
+    def _call_visualizer(self, show: bool, save_path: Optional[str], auto_close_sec: float = 0):
+        try:
+            # print(self.puzzle_data,)
+            visualize(
+                puzzle_type = self.puzzle_type,
+                solution_grid = self.sol_grid,
+                puzzle_data = self.puzzle_data,
+                title=f"{self.puzzle_type.title()} Result",
+                show=show,
+                save_path=save_path,
+                auto_close_sec=auto_close_sec
+            )
+        except NotImplementedError:
+            print(f"Visualizer for {self.puzzle_type} is not implemented yet.")
+        except Exception as e:
+            print(f"Visualization failed: {e}")
+    
+    def show(self, auto_close_sec: float = 0, block: bool = True):
+        self._call_visualizer(show=True, save_path=None, auto_close_sec=auto_close_sec)
+
+    def save(self, path: str):
+        self._call_visualizer(show=False, save_path=path)