Refactor: some methods to properties at Cell & Grid

Author: Kartones

algorithms/aldous_broder.py

@@ -17,7 +17,7 @@ def on(grid: Grid) -> Grid:
         unvisited_count = grid.size - 1
 
         while unvisited_count > 0:
-            neighbor = choice(current_cell.neighbors())
+            neighbor = choice(current_cell.neighbors)
             if neighbor is None:
                 raise ValueError("Aldous-Broder algorithm needs all cells to have at least one neighbor")
             if len(neighbor.links) == 0:

base/cell.py

@@ -17,6 +17,19 @@ def column(self) -> int:
     def links(self) -> List["Cell"]:
         return list(self._links.keys())
 
+    @property
+    def neighbors(self) -> List[Optional["Cell"]]:
+        neighbors_list = []         # type: List[Optional[Cell]]
+        if self.north:
+            neighbors_list.append(self.north)
+        if self.south:
+            neighbors_list.append(self.south)
+        if self.east:
+            neighbors_list.append(self.east)
+        if self.west:
+            neighbors_list.append(self.west)
+        return neighbors_list
+
     def __init__(self, row: int, column: int) -> None:
         if row is None or row < 0:
             raise ValueError("Row must be a positive integer")
@@ -46,18 +59,7 @@ def unlink(self, cell: "Cell", bidirectional: bool = True) -> "Cell":
     def linked_to(self, cell: "Cell") -> bool:
         return cell in self._links
 
-    def neighbors(self) -> List[Optional["Cell"]]:
-        neighbors_list = []         # type: List[Optional[Cell]]
-        if self.north:
-            neighbors_list.append(self.north)
-        if self.south:
-            neighbors_list.append(self.south)
-        if self.east:
-            neighbors_list.append(self.east)
-        if self.west:
-            neighbors_list.append(self.west)
-        return neighbors_list
-
+    @property
     def distances(self) -> Distances:
         distances = Distances(self)
         frontier = [self]   # type: List[Cell]

base/grid.py

@@ -29,7 +29,7 @@ def __init__(self, rows: int, columns: int) -> None:
         self._grid = self.prepare_grid()
         self.configure_cells()
 
-    def get_cell(self, row: int, column: int) -> Optional[Cell]:
+    def cell_at(self, row: int, column: int) -> Optional[Cell]:
         if not (0 <= row < self.rows):
             return None
         if not (0 <= column < self.columns):
@@ -41,15 +41,15 @@ def prepare_grid(self) -> List[List[Cell]]:
 
     def configure_cells(self) -> None:
         for cell in self.each_cell():
-            cell.north = self.get_cell(cell.row - 1, cell.column)
-            cell.south = self.get_cell(cell.row + 1, cell.column)
-            cell.east = self.get_cell(cell.row, cell.column + 1)
-            cell.west = self.get_cell(cell.row, cell.column - 1)
+            cell.north = self.cell_at(cell.row - 1, cell.column)
+            cell.south = self.cell_at(cell.row + 1, cell.column)
+            cell.east = self.cell_at(cell.row, cell.column + 1)
+            cell.west = self.cell_at(cell.row, cell.column - 1)
 
     def random_cell(self) -> Cell:
         column = randint(0, self.columns - 1)
         row = randint(0, self.rows - 1)
-        return cast(Cell, self.get_cell(row, column))
+        return cast(Cell, self.cell_at(row, column))
 
     def each_row(self) -> Generator:
         for row in range(self.rows):
@@ -58,7 +58,7 @@ def each_row(self) -> Generator:
     def each_cell(self) -> Generator:
         for row in range(self.rows):
             for column in range(self.columns):
-                yield self.get_cell(row, column)
+                yield self.cell_at(row, column)
 
     def contents_of(self, cell: Cell) -> str:
         return "   "

demos/image_demo.py

@@ -67,10 +67,10 @@ def get_coloring() -> bool:
         start_row = round(grid.rows / 2)
         start_column = round(grid.columns / 2)
         print("Drawing colored maze with start row {} column {}".format(start_row, start_column))
-        start_cell = grid.get_cell(start_row, start_column)
+        start_cell = grid.cell_at(start_row, start_column)
         if start_cell is None:
             raise IndexError("Invalid start cell row {} column {}".format(start_row, start_column))
-        grid.distances = start_cell.distances()     # type: ignore
+        grid.distances = start_cell.distances     # type: ignore
 
     filename = strftime("%Y%m%d%H%M%S", gmtime())
 

pathfinders/dijkstra.py

@@ -3,13 +3,13 @@
 
 def calculate_distances(grid: DistanceGrid, start_row: int, start_column: int, end_row: int,
                         end_column: int) -> DistanceGrid:
-    start_cell = grid.get_cell(start_row, start_column)
+    start_cell = grid.cell_at(start_row, start_column)
     if start_cell is None:
         raise IndexError("Invalid start cell row {} column {}".format(start_row, start_column))
-    destination_cell = grid.get_cell(end_row, end_column)
+    destination_cell = grid.cell_at(end_row, end_column)
     if destination_cell is None:
         raise IndexError("Invalid destination cell row {} column {}".format(end_row, end_row))
-    distances = start_cell.distances()
+    distances = start_cell.distances
     grid.distances = distances.path_to(destination_cell)
 
     return grid

pathfinders/longest_path.py

@@ -9,11 +9,11 @@
 
 
 def calculate(grid: DistanceGrid) -> Tuple[int, int, int, int]:
-    start_cell = grid.get_cell(0, 0)
+    start_cell = grid.cell_at(0, 0)
     if start_cell is None:
         raise IndexError("Invalid start cell row {} column {}".format(0, 0))
 
-    new_start_cell, distance = start_cell.distances().max
-    goal_cell, distance = new_start_cell.distances().max
+    new_start_cell, distance = start_cell.distances.max
+    goal_cell, distance = new_start_cell.distances.max
 
     return new_start_cell.row, new_start_cell.column, goal_cell.row, goal_cell.column

renderers/unicode_renderer.py

@@ -27,7 +27,7 @@ def render(grid: Grid, **kwargs: Any) -> None:
 
         output = JUNCTIONS[12]
         for x in range(grid.columns - 1):
-            output += (horizontal_wall * 3 + get_topmost_junction(cast(Cell, grid.get_cell(row=0, column=x))))
+            output += (horizontal_wall * 3 + get_topmost_junction(cast(Cell, grid.cell_at(row=0, column=x))))
         output += horizontal_wall * 3 + JUNCTIONS[10] + "\n"
 
         for row in grid.each_row():

test/test_cell.py

@@ -60,7 +60,7 @@ def test_links_listing() -> None:
 
 
 def test_has_no_neighbors() -> None:
-    assert Cell(1, 1).neighbors() == []
+    assert Cell(1, 1).neighbors == []
 
 
 def test_has_neighbors() -> None:
@@ -73,15 +73,15 @@ def test_has_neighbors() -> None:
     yet_another_cell.east = another_cell
     yet_another_cell.west = a_cell
 
-    assert another_cell in a_cell.neighbors()
-    assert yet_another_cell not in a_cell.neighbors()
-    assert len(a_cell.neighbors()) == 1
-    assert a_cell not in another_cell.neighbors()
-    assert yet_another_cell in another_cell.neighbors()
-    assert len(another_cell.neighbors()) == 1
-    assert a_cell in yet_another_cell.neighbors()
-    assert another_cell in yet_another_cell.neighbors()
-    assert len(yet_another_cell.neighbors()) == 2
+    assert another_cell in a_cell.neighbors
+    assert yet_another_cell not in a_cell.neighbors
+    assert len(a_cell.neighbors) == 1
+    assert a_cell not in another_cell.neighbors
+    assert yet_another_cell in another_cell.neighbors
+    assert len(another_cell.neighbors) == 1
+    assert a_cell in yet_another_cell.neighbors
+    assert another_cell in yet_another_cell.neighbors
+    assert len(yet_another_cell.neighbors) == 2
 
 
 def test_distances() -> None:
@@ -93,7 +93,7 @@ def test_distances() -> None:
     a_cell.link(another_cell)
     another_cell.east = yet_another_cell
     another_cell.link(yet_another_cell)
-    distances = a_cell.distances()
+    distances = a_cell.distances
     assert distances.cells == [yet_another_cell, another_cell, a_cell]
     assert distances[a_cell] == 0
     assert distances[another_cell] == 1

test/test_grid.py

@@ -16,39 +16,39 @@ def test_constructor() -> None:
 def test_cell_access() -> None:
     grid = Grid(2, 2)
 
-    assert grid.get_cell(0, 0) == Cell(0, 0)    # type: ignore
-    assert grid.get_cell(0, 1) == Cell(0, 1)    # type: ignore
-    assert grid.get_cell(1, 0) == Cell(1, 0)    # type: ignore
-    assert grid.get_cell(1, 1) == Cell(1, 1)    # type: ignore
+    assert grid.cell_at(0, 0) == Cell(0, 0)    # type: ignore
+    assert grid.cell_at(0, 1) == Cell(0, 1)    # type: ignore
+    assert grid.cell_at(1, 0) == Cell(1, 0)    # type: ignore
+    assert grid.cell_at(1, 1) == Cell(1, 1)    # type: ignore
 
-    assert grid.get_cell(-1, 0) is None
-    assert grid.get_cell(0, -1) is None
-    assert grid.get_cell(4, 0) is None
-    assert grid.get_cell(0, 4) is None
+    assert grid.cell_at(-1, 0) is None
+    assert grid.cell_at(0, -1) is None
+    assert grid.cell_at(4, 0) is None
+    assert grid.cell_at(0, 4) is None
 
 
 def test_neighbors_setup_when_grid_is_created() -> None:
     grid = Grid(2, 2)
 
-    assert grid.get_cell(0, 0).north is None        # type: ignore
-    assert grid.get_cell(0, 0).south == Cell(1, 0)  # type: ignore
-    assert grid.get_cell(0, 0).east == Cell(0, 1)   # type: ignore
-    assert grid.get_cell(0, 0).west is None         # type: ignore
-
-    assert grid.get_cell(0, 1).north is None        # type: ignore
-    assert grid.get_cell(0, 1).south == Cell(1, 1)  # type: ignore
-    assert grid.get_cell(0, 1).east is None         # type: ignore
-    assert grid.get_cell(0, 1).west == Cell(0, 0)   # type: ignore
-
-    assert grid.get_cell(1, 0).north == Cell(0, 0)  # type: ignore
-    assert grid.get_cell(1, 0).south is None        # type: ignore
-    assert grid.get_cell(1, 0).east == Cell(1, 1)   # type: ignore
-    assert grid.get_cell(1, 0).west is None         # type: ignore
-
-    assert grid.get_cell(1, 1).north == Cell(0, 1)  # type: ignore
-    assert grid.get_cell(1, 1).south is None        # type: ignore
-    assert grid.get_cell(1, 1).east is None         # type: ignore
-    assert grid.get_cell(1, 1).west == Cell(1, 0)   # type: ignore
+    assert grid.cell_at(0, 0).north is None        # type: ignore
+    assert grid.cell_at(0, 0).south == Cell(1, 0)  # type: ignore
+    assert grid.cell_at(0, 0).east == Cell(0, 1)   # type: ignore
+    assert grid.cell_at(0, 0).west is None         # type: ignore
+
+    assert grid.cell_at(0, 1).north is None        # type: ignore
+    assert grid.cell_at(0, 1).south == Cell(1, 1)  # type: ignore
+    assert grid.cell_at(0, 1).east is None         # type: ignore
+    assert grid.cell_at(0, 1).west == Cell(0, 0)   # type: ignore
+
+    assert grid.cell_at(1, 0).north == Cell(0, 0)  # type: ignore
+    assert grid.cell_at(1, 0).south is None        # type: ignore
+    assert grid.cell_at(1, 0).east == Cell(1, 1)   # type: ignore
+    assert grid.cell_at(1, 0).west is None         # type: ignore
+
+    assert grid.cell_at(1, 1).north == Cell(0, 1)  # type: ignore
+    assert grid.cell_at(1, 1).south is None        # type: ignore
+    assert grid.cell_at(1, 1).east is None         # type: ignore
+    assert grid.cell_at(1, 1).west == Cell(1, 0)   # type: ignore
 
 
 def test_random_cell() -> None:

utils/rotator.py

@@ -23,7 +23,7 @@ def on(grid: Union[Grid, "DistanceGrid", "ColoredGrid"]) -> Union[Grid, "Distanc
 
         for old_cell in grid.each_cell():
             row, column = Rotator._rotated_coordinates(old_cell, rotated_grid)
-            new_cell = rotated_grid.get_cell(row, column)
+            new_cell = rotated_grid.cell_at(row, column)
             if new_cell is None:
                 raise IndexError("Cell not found at row {} column {}".format(row, column))
             Rotator._rotate_cell_neighbors(new_cell, old_cell, rotated_grid)
@@ -40,7 +40,7 @@ def _rotated_coordinates(cell: Cell, grid: Grid) -> Tuple[int, int]:
     def _rotate_cell_neighbors(new_cell: Cell, old_cell: Cell, grid: Grid) -> None:
         for link in old_cell.links:
             row, column = Rotator._rotated_coordinates(link, grid)
-            neighbor = grid.get_cell(row, column)
+            neighbor = grid.cell_at(row, column)
             if neighbor is None:
                 raise IndexError("Cell not found at row {} column {}".format(row, column))
             new_cell.link(neighbor)