feat(sqlalchemy): add parts for orm

Author: emptybutton

pyproject.toml

@@ -15,10 +15,11 @@ dependencies = [
     "sqlalchemy==2.0.41",
     "psycopg[binary]==3.2.9",
     "alembic==1.16.1",
-    "aiogram==3.20.0.post0",
+    "alembic-postgresql-enum==1.7.0",
     "redis==6.2.0",
     "pydantic==2.10.6",
     "pydantic-settings[yaml]==2.9.1",
+    "aiogram==3.20.0.post0",
 ]
 
 [dependency-groups]

src/ttt/entities/core.py

@@ -16,23 +16,29 @@ class Player:
     number_of_wins: int
     number_of_draws: int
     number_of_defeats: int
-    tracking: Tracking
+    current_game_id: UUID | None
 
-    def lose(self) -> None:
+    def be_in_game(self, game_id: UUID) -> None:
+        self.current_game_id = game_id
+
+    def lose(self, tracking: Tracking) -> None:
+        self.current_game_id = None
         self.number_of_defeats += 1
-        self.tracking.register_mutated(self)
+        tracking.register_mutated(self)
 
-    def win(self) -> None:
+    def win(self, tracking: Tracking) -> None:
+        self.current_game_id = None
         self.number_of_wins += 1
-        self.tracking.register_mutated(self)
+        tracking.register_mutated(self)
 
-    def be_draw(self) -> None:
+    def be_draw(self, tracking: Tracking) -> None:
+        self.current_game_id = None
         self.number_of_draws += 1
-        self.tracking.register_mutated(self)
+        tracking.register_mutated(self)
 
 
 def create_player(id_: int, tracking: Tracking) -> Player:
-    player = Player(id_, 0, 0, 0, tracking)
+    player = Player(id_, 0, 0, 0, None)
     tracking.register_new(player)
 
     return player
@@ -47,19 +53,18 @@ class Cell:
     game_id: UUID
     board_position: Vector
     filler_id: int | None
-    tracking: Tracking
 
     def is_filled(self) -> bool:
         return self.filler_id is not None
 
-    def fill(self, filler_id: int) -> None:
+    def fill(self, filler_id: int, tracking: Tracking) -> None:
         """
         :raises ttt.entities.core.AlreadyFilledCellError:
         """
 
         assert_(not self.is_filled(), else_=AlreadyFilledCellError)
         self.filler_id = filler_id
-        self.tracking.register_mutated(self)
+        tracking.register_mutated(self)
 
 
 class GameState(Enum):
@@ -72,7 +77,7 @@ class GameState(Enum):
 
 
 def is_board_standard(board: Board) -> bool:
-    return board.column_size() == board.line_size() == 3  # noqa: PLR2004
+    return board.width() == board.height() == 3  # noqa: PLR2004
 
 
 class InvalidCellIDMatrixError(Exception): ...
@@ -91,7 +96,7 @@ def create_empty_board(
 
     board = Matrix([
         [
-            Cell(cell_id_matrix[x, y], game_id, (x, y), None, tracking)
+            Cell(cell_id_matrix[x, y], game_id, Vector(x, y), None)
             for x in range(3)
         ]
         for y in range(3)
@@ -105,6 +110,8 @@ def create_empty_board(
 
 @dataclass(frozen=True)
 class GameResult:
+    id: UUID
+    game_id: UUID
     winner_id: int | None
 
 
@@ -120,7 +127,9 @@ class InvalidCellOrderError(Exception): ...
 class InvalidNumberOfUnfilledCellsError(Exception): ...
 
 
-class CompletedGameError(Exception): ...
+@dataclass(frozen=True)
+class CompletedGameError(Exception):
+    game_result: GameResult
 
 
 class NoCellError(Exception): ...
@@ -152,16 +161,15 @@ class Game:
     number_of_unfilled_cells: int
     result: GameResult | None
     state: GameState
-    tracking: Tracking
 
     def __post_init__(self) -> None:
         assert_(self.player1.id != self.player2.id, else_=OnePlayerError)
         assert_(is_board_standard(self.board), else_=NotStandardBoardError)
 
         is_cell_order_ok = all(
             self.board[x, y].board_position == (x, y)
-            for x in range(self.board.line_size())
-            for y in range(self.board.column_size())
+            for x in range(self.board.width())
+            for y in range(self.board.height())
         )
         assert_(is_cell_order_ok, else_=InvalidCellOrderError)
 
@@ -172,7 +180,11 @@ def __post_init__(self) -> None:
         )
 
     def make_move(
-        self, player_id: int, cell_position: Vector,
+        self,
+        player_id: int,
+        cell_position: Vector,
+        game_result_id: UUID,
+        tracking: Tracking,
     ) -> GameResult | None:
         """
         :raises ttt.entities.core.CompletedGameError:
@@ -183,37 +195,39 @@ def make_move(
         """
 
         current_player = self._current_player()
-        current_player = not_none(current_player, else_=CompletedGameError)
+
+        if current_player is None:
+            raise CompletedGameError(not_none(self.result))
 
         assert_(
             player_id in {self.player1.id, self.player2.id},
             else_=NotPlayerError(),
         )
         assert_(current_player.id == player_id, else_=NotCurrentPlayerError())
 
-        self._fill_cell(cell_position, player_id)
+        self._fill_cell(cell_position, player_id, tracking)
 
         if self._is_player_winner(current_player, cell_position):
             not_current_player = not_none(self._not_current_player())
 
-            current_player.win()
-            not_current_player.lose()
+            current_player.win(tracking)
+            not_current_player.lose(tracking)
 
-            return self._complete(current_player)
+            return self._complete(game_result_id, current_player, tracking)
 
         if not self._can_continue():
             not_current_player = not_none(self._not_current_player())
 
-            current_player.be_draw()
-            not_current_player.be_draw()
+            current_player.be_draw(tracking)
+            not_current_player.be_draw(tracking)
 
-            return self._complete(None)
+            return self._complete(game_result_id, None, tracking)
 
-        self._wait_next_move()
+        self._wait_next_move(tracking)
         return None
 
     def _fill_cell(
-        self, cell_position: Vector, player_id: int,
+        self, cell_position: Vector, player_id: int, tracking: Tracking,
     ) -> GameResult | None:
         """
         :raises ttt.entities.core.NoCellError:
@@ -225,9 +239,9 @@ def _fill_cell(
         except IndexError as error:
             raise NoCellError from error
 
-        cell.fill(player_id)
+        cell.fill(player_id, tracking)
         self.number_of_unfilled_cells -= 1
-        self.tracking.register_mutated(self)
+        tracking.register_mutated(self)
 
     def _can_continue(self) -> bool:
         return not self._is_board_filled()
@@ -240,11 +254,11 @@ def _is_player_winner(self, player: Player, cell_position: Vector) -> bool:
 
         is_winner = all(
             self.board[cell_x, y].filler_id == player.id
-            for y in range(self.board.column_size())
+            for y in range(self.board.height())
         )
         is_winner |= all(
             int(self.board[x, cell_y].filler_id == player.id)
-            for x in range(self.board.line_size())
+            for x in range(self.board.width())
         )
 
         is_winner |= {player.id} == {
@@ -278,7 +292,7 @@ def _not_current_player(self) -> Player | None:
             case GameState.completed:
                 return None
 
-    def _wait_next_move(self) -> None:
+    def _wait_next_move(self, tracking: Tracking) -> None:
         match self.state:
             case GameState.wait_player1:
                 self.state = GameState.wait_player2
@@ -287,16 +301,25 @@ def _wait_next_move(self) -> None:
             case GameState.completed:
                 raise ValueError
 
-        self.tracking.register_mutated(self)
+        tracking.register_mutated(self)
 
-    def _complete(self, winner: Player | None) -> GameResult:
-        self.result = GameResult(None if winner is None else winner.id)
+    def _complete(
+        self, game_result_id: UUID, winner: Player | None, tracking: Tracking,
+    ) -> GameResult:
+        self.result = GameResult(
+            game_result_id, self.id, None if winner is None else winner.id,
+        )
         self.state = GameState.completed
-        self.tracking.register_mutated(self)
+        tracking.register_mutated(self)
 
         return self.result
 
 
+@dataclass(frozen=True)
+class PlayerAlreadyInGameError(Exception):
+    players: tuple[Player, ...]
+
+
 def start_game(
     cell_id_matrix: Matrix[UUID],
     game_id: UUID,
@@ -305,9 +328,21 @@ def start_game(
     tracking: Tracking,
 ) -> Game:
     """
+    :raises ttt.entities.core.PlayerAlreadyInGameError:
     :raises ttt.entities.core.InvalidCellIDMatrixError:
+    :raises ttt.entities.core.OnePlayerError:
     """
 
+    players_in_game = tuple(
+        player
+        for player in (player1, player2)
+        if player.current_game_id is not None
+    )
+    assert_(
+        not players_in_game,
+        else_=PlayerAlreadyInGameError(players_in_game),
+    )
+
     board = create_empty_board(cell_id_matrix, game_id, tracking)
 
     game = Game(
@@ -318,8 +353,10 @@ def start_game(
         number_of_unfilled_cells(board),
         None,
         GameState.wait_player1,
-        tracking,
     )
     tracking.register_new(game)
 
+    player1.be_in_game(game_id)
+    player2.be_in_game(game_id)
+
     return game

src/ttt/entities/math.py

@@ -1,6 +1,6 @@
 from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, NamedTuple
 
 from ttt.entities.tools import assert_
 
@@ -11,7 +11,11 @@ class InconsistentMatrixError(Exception):
 
 
 type MatrixSize = tuple[int, int]
-type Vector = tuple[int, int]
+
+
+class Vector(NamedTuple):
+    x: int
+    y: int
 
 
 @dataclass
@@ -20,46 +24,46 @@ class Matrix[T]:
     :raises ttt.entities.math.InconsistentMatrixError:
     """
 
-    columns: list[list[T]]
+    lines: list[list[T]]
 
     def size(self) -> MatrixSize:
-        return self.line_size(), self.column_size()
+        return self.width(), self.height()
 
-    def line_size(self) -> int:
-        if not self.columns:
+    def width(self) -> int:
+        if not self.lines:
             return 0
 
-        return len(self.columns[0])
+        return len(self.lines[0])
 
-    def column_size(self) -> int:
-        return len(self.columns)
+    def height(self) -> int:
+        return len(self.lines)
 
     def __post_init__(self) -> None:
-        line_size = self.line_size()
+        line_size = self.width()
 
         assert_(
-            all(len(column) == line_size for column in self.columns),
+            all(len(column) == line_size for column in self.lines),
             else_=InconsistentMatrixError(self),
         )
 
-    def __setitem__(self, x_and_y: Vector, value: T) -> None:
+    def __setitem__(self, x_and_y: tuple[int, int], value: T) -> None:
         """
         :raises IndexError:
         """
 
         x, y = x_and_y
-        self.columns[y][x] = value
+        self.lines[y][x] = value
 
-    def __getitem__(self, x_and_y: Vector) -> T:
+    def __getitem__(self, x_and_y: tuple[int, int]) -> T:
         """
         :raises IndexError:
         """
 
         x, y = x_and_y
-        return self.columns[y][x]
+        return self.lines[y][x]
 
     def __iter__(self) -> Iterator[Iterable[T]]:
-        yield from self.columns
+        yield from self.lines
 
 
 def matrix_with_size[T](size: MatrixSize, zero: T) -> Matrix[T]: