feat(models): Enhanced data classes with more methods and frozen class

Author: FlysonBot

src/mastermind/core/models/game_configuration.py

@@ -3,21 +3,24 @@
 from mastermind.core.models.game_mode import GameMode
 
 
-@dataclass
+@dataclass(frozen=True)
 class GameConfiguration:
     """
     Dataclass for the configuration of a game.
 
     This class defines the settings that determine how a game is structured, including the number of colors, dots, allowed attempts, and game mode.
 
     Attributes:
-        number_of_colors (int): The number of colors a dot can be.
-        number_of_dots (int): The number of dots in a code.
-        attempts_allowed (int): The maximum number of attempts allowed for the code cracker to guess the code.
-        game_mode (GameMode): The game mode determine who is Player 1 and Player 2.
+        NUMBER_OF_COLORS (int): The number of colors a dot can be.
+        NUMBER_OF_DOTS (int): The number of dots in a code.
+        ATTEMPTS_ALLOWED (int): The maximum number of attempts allowed for the code  to guess the code.
+        GAME_MODE (GameMode): The game mode determine who is Player 1 and Player 2.
     """
 
-    number_of_colors: int
-    number_of_dots: int
-    attempts_allowed: int
-    game_mode: GameMode
+    NUMBER_OF_COLORS: int
+    NUMBER_OF_DOTS: int
+    ATTEMPTS_ALLOWED: int
+    GAME_MODE: GameMode
+
+    def __str__(self):
+        return f"{self.NUMBER_OF_COLORS}x{self.NUMBER_OF_DOTS}, {self.ATTEMPTS_ALLOWED} attempts in {self.GAME_MODE} mode"

src/mastermind/core/models/game_entities.py

@@ -3,17 +3,20 @@
 from mastermind.core.controllers.players import Player
 
 
-@dataclass
+@dataclass(frozen=True)
 class GameEntities:
     """
     Dataclass for the entities of a game (such as players or those from plugins).
 
     This class represents the key participants in a game, specifically the players involved in setting and breaking the code. It serves as a structured way to manage and reference these entities throughout the game's lifecycle.
 
     Attributes:
-        code_setter (Player): The player responsible for setting the code.
-        code_breaker (Player): The player tasked with breaking the code.
+        CODE_SETTER (Player): The player responsible for setting the code.
+        CODE_BREAKER (Player): The player tasked with breaking the code.
     """
 
-    code_setter: Player
-    code_breaker: Player
+    CODE_SETTER: Player
+    CODE_BREAKER: Player
+
+    def __str__(self):
+        return f"Code Setter: {self.CODE_SETTER.__qualname__}, Code Breaker: {self.CODE_BREAKER.__qualname__}"

src/mastermind/core/models/game_round.py

@@ -2,17 +2,24 @@
 from typing import Tuple
 
 
-@dataclass
+@dataclass(frozen=True)
 class GameRound:
     """
     Dataclass for a single round of the game.
 
     This class encapsulates the guess made during a round and the corresponding feedback received.
 
     Attributes:
-        guess (Tuple[int, ...]): A tuple representing the player's guess.
-        feedback (Tuple[int, int]): A tuple containing feedback information, typically indicating the number of correct guesses and their positions.
+        GUESS (Tuple[int, ...]): A tuple representing the player's guess.
+        FEEDBACK (Tuple[int, int]): A tuple containing feedback information, typically indicating the number of correct guesses and their positions.
+
+    Examples:
+        >>> round = GameRound(GUESS=(1, 2, 3, 4), FEEDBACK=(2, 1))
+        >>> print(round.GUESS)
+        (1, 2, 3, 4)
+        >>> print(round.FEEDBACK)
+        (2, 1)
     """
 
-    guess: Tuple[int, ...]
-    feedback: Tuple[int, int]
+    GUESS: Tuple[int, ...]
+    FEEDBACK: Tuple[int, int]

src/mastermind/core/models/game_state.py

@@ -11,7 +11,7 @@ class GameState:
     Attributes:
         game_started (bool): A flag indicating if the game has started.
         game_over (bool): A flag indicating if the game has ended.
-        winner (Player): The player who won the game, if any. Only top level player (CodeSetter or CodeCracker) is allowed.
+        winner (Player): The player who won the game, if any. Only top level player (CodeSetter or Codebreaker) is allowed.
     """
 
     game_started: bool

src/mastermind/core/models/gameboard.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Deque
+from typing import Deque, Generator, Tuple
 
 from mastermind.core.models.game_round import GameRound
 
@@ -16,3 +16,51 @@ class GameBoard:
     """
 
     game_rounds: Deque[GameRound]
+
+    def __len__(self) -> int:
+        """
+        Returns the number of game rounds in the game board.
+
+        Returns:
+            int: Number of game rounds in the game board.
+
+        Examples:
+            >>> game_board = GameBoard(game_rounds=[GameRound(guess=(1, 2, 3, 4), result=(1, 0)), GameRound(guess=(3, 4, 5, 6), result=(2, 1))])
+            >>> len(game_board)
+            2
+        """
+        return len(self.game_rounds)
+
+    @property
+    def guesses(self) -> Generator[Tuple[int, ...], None, None]:
+        """
+        Returns a generator of all guesses made in the game to allow for easy iteration.
+
+        Returns:
+            Generator[Tuple[int, ...], None, None]: _description_
+
+        Examples:
+            >>> game_board = GameBoard(game_rounds=[GameRound(guess=(1, 2, 3, 4), result=(1, 0)), GameRound(guess=(3, 4, 5, 6), result=(2, 1))])
+            >>> for guess in game_board.guesses:
+            ...     print(guess)
+            (1, 2, 3, 4)
+            (3, 4, 5, 6)
+        """
+        return (round.GUESS for round in self.game_rounds)
+
+    @property
+    def feedbacks(self) -> Generator[Tuple[int, int], None, None]:
+        """
+        Returns a generator of all feedbacks received in the game to allow for easy iteration.
+
+        Yields:
+            Generator[Tuple[int], None, None]: A generator of all feedbacks received in the game.
+
+        Examples:
+            >>> game_board = GameBoard(game_rounds=[GameRound(guess=(1, 2, 3, 4), result=(1, 0)), GameRound(guess=(3, 4, 5, 6), result=(2, 1))])
+            >>> for feedback in game_board.feedbacks:
+            ...     print(feedback)
+            (1, 0)
+            (2, 1)
+        """
+        return (round.FEEDBACK for round in self.game_rounds)