🐲 Better state constructors, pydantic fixes

Author: asaf-kali

Makefile

@@ -61,7 +61,7 @@ cover-html: cover-base
 	coverage report
 
 cover: cover-html
-	$(OPEN_FILE_COMMAND) htmlcov/index.html &
+	$(OPEN_FILE_COMMAND) htmlcov/index.html > /dev/null 2>&1 &
 	$(DEL_COMMAND) .coverage*
 
 cover-fast:

codenames/classic/board.py

@@ -2,11 +2,13 @@
 
 import logging
 import random
+from typing import Self
 
 from codenames.classic.color import ClassicColor, ClassicTeam
 from codenames.classic.types import ClassicCard, ClassicCards
 from codenames.generic.board import Board, Vocabulary
 from codenames.utils.builder import extract_random_subset
+from codenames.utils.vocabulary.languages import get_vocabulary
 
 log = logging.getLogger(__name__)
 
@@ -29,6 +31,11 @@ def neutral_cards(self) -> ClassicCards:
     def assassin_cards(self) -> ClassicCards:
         return self.cards_for_color(ClassicColor.ASSASSIN)
 
+    @classmethod
+    def from_language(cls, language: str) -> Self:
+        vocabulary = get_vocabulary(language=language)
+        return cls.from_vocabulary(vocabulary=vocabulary)
+
     @classmethod
     def from_vocabulary(
         cls,
@@ -37,7 +44,7 @@ def from_vocabulary(
         assassin_amount: int = 1,
         first_team: ClassicTeam | None = None,
         seed: int | None = None,
-    ) -> ClassicBoard:
+    ) -> Self:
         if seed:
             random.seed(seed)
 

codenames/classic/runner.py

@@ -5,8 +5,7 @@
 from typing import Collection, Iterator
 
 from codenames.classic.board import ClassicBoard
-from codenames.classic.color import ClassicColor, ClassicTeam
-from codenames.classic.score import Score, TeamScore
+from codenames.classic.color import ClassicTeam
 from codenames.classic.state import ClassicGameState
 from codenames.classic.winner import Winner
 from codenames.generic.exceptions import InvalidGuess
@@ -19,7 +18,6 @@
     TeamPlayers,
 )
 from codenames.utils.formatting import wrap
-from codenames.utils.vocabulary.languages import get_vocabulary
 
 log = logging.getLogger(__name__)
 
@@ -64,9 +62,11 @@ def __init__(
         self, players: ClassicGamePlayers, state: ClassicGameState | None = None, board: ClassicBoard | None = None
     ):
         self.players = players
-        if (not state and not board) or (state and board):
-            raise ValueError("Exactly one of state or board must be provided.")
-        self.state = state or new_game_state(board=board)
+        if not state:
+            if not board:
+                raise ValueError("Exactly one of state or board must be provided.")
+            state = ClassicGameState.from_board(board=board)
+        self.state = state
         self.clue_given_subscribers: list[ClueGivenSubscriber] = []
         self.guess_given_subscribers: list[GuessGivenSubscriber] = []
 
@@ -144,42 +144,6 @@ def _get_guess_until_valid(self, operative: Operative) -> GivenGuess | None:
                 pass
 
 
-def new_game_state(board: ClassicBoard | None = None, language: str | None = None) -> ClassicGameState:
-    board = _get_board(board=board, language=language)
-    if not board.is_clean:
-        raise ValueError("Board must be clean.")
-    first_team = _determine_first_team(board)
-    score = build_score(board)
-    return ClassicGameState(
-        board=board,
-        score=score,
-        current_team=first_team,
-        current_player_role=PlayerRole.SPYMASTER,
-    )
-
-
-def _get_board(board: ClassicBoard | None, language: str | None) -> ClassicBoard:
-    if board is not None:
-        return board
-    if language is None:
-        raise ValueError("Either board or language must be provided.")
-    vocabulary = get_vocabulary(language=language)
-    return ClassicBoard.from_vocabulary(vocabulary=vocabulary)
-
-
-def build_score(board: ClassicBoard) -> Score:
-    blue_score = TeamScore(total=len(board.blue_cards), revealed=len(board.revealed_cards_for_color(ClassicColor.BLUE)))
-    red_score = TeamScore(total=len(board.red_cards), revealed=len(board.revealed_cards_for_color(ClassicColor.RED)))
-    score = Score(blue=blue_score, red=red_score)
-    return score
-
-
-def _determine_first_team(board: ClassicBoard) -> ClassicTeam:
-    if len(board.blue_cards) >= len(board.red_cards):
-        return ClassicTeam.BLUE
-    return ClassicTeam.RED
-
-
 def find_team(players: Collection[Player], team: ClassicTeam) -> TeamPlayers:
     spymaster = operative = None
     for player in players:

codenames/classic/state.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any
+from typing import Any, Self
 
 from pydantic import field_validator
 
@@ -18,7 +18,12 @@
 )
 from codenames.generic.move import PASS_GUESS, QUIT_GAME, Clue, GivenClue, Guess
 from codenames.generic.player import PlayerRole
-from codenames.generic.state import OperativeState, PlayerState, SpymasterState
+from codenames.generic.state import (
+    OperativeState,
+    PlayerState,
+    SpymasterState,
+    TeamScore,
+)
 from codenames.utils.formatting import wrap
 
 log = logging.getLogger(__name__)
@@ -63,6 +68,24 @@ class ClassicGameState(ClassicSpymasterState):
     left_guesses: int = 0
     winner: Winner | None = None
 
+    @classmethod
+    def from_language(cls, language: str) -> Self:
+        board = ClassicBoard.from_language(language)
+        return cls.from_board(board=board)
+
+    @classmethod
+    def from_board(cls, board: ClassicBoard) -> Self:
+        if not board.is_clean:
+            raise ValueError("Board must be clean.")
+        first_team = _determine_first_team(board)
+        score = _build_score(board)
+        return cls(
+            board=board,
+            score=score,
+            current_team=first_team,
+            current_player_role=PlayerRole.SPYMASTER,
+        )
+
     @property
     def spymaster_state(self) -> ClassicSpymasterState:
         return ClassicSpymasterState(
@@ -181,3 +204,16 @@ def _update_score(self, given_guess: ClassicGivenGuess):
         game_ended = self.score.add_point(score_team)
         if game_ended:
             self.winner = Winner(team=score_team, reason=WinningReason.TARGET_SCORE_REACHED)
+
+
+def _determine_first_team(board: ClassicBoard) -> ClassicTeam:
+    if len(board.blue_cards) >= len(board.red_cards):
+        return ClassicTeam.BLUE
+    return ClassicTeam.RED
+
+
+def _build_score(board: ClassicBoard) -> Score:
+    blue_score = TeamScore(total=len(board.blue_cards), revealed=len(board.revealed_cards_for_color(ClassicColor.BLUE)))
+    red_score = TeamScore(total=len(board.red_cards), revealed=len(board.revealed_cards_for_color(ClassicColor.RED)))
+    score = Score(blue=blue_score, red=red_score)
+    return score

codenames/duet/board.py

@@ -2,6 +2,7 @@
 
 import logging
 import random
+from typing import Self
 
 from codenames.duet.card import DuetColor
 from codenames.duet.types import DuetCard, DuetCards
@@ -34,6 +35,10 @@ def assassin_cards(self) -> DuetCards:
     def irrelevant_cards(self) -> DuetCards:
         return self.cards_for_color(DuetColor.IRRELEVANT)
 
+    @classmethod
+    def cast_board(cls, board: Board[DuetColor]) -> Self:
+        return cls(language=board.language, cards=board.cards)
+
     @classmethod
     def from_vocabulary(
         cls,
@@ -42,7 +47,7 @@ def from_vocabulary(
         green_amount: int = 9,
         assassin_amount: int = 3,
         seed: int | None = None,
-    ) -> DuetBoard:
+    ) -> Self:
         if seed:
             random.seed(seed)
 
@@ -60,11 +65,7 @@ def from_vocabulary(
         return cls(language=vocabulary.language, cards=all_cards)
 
     @classmethod
-    def from_board(cls, board: Board[DuetColor]) -> DuetBoard:
-        return cls(language=board.language, cards=board.cards)
-
-    @classmethod
-    def dual_board(cls, board: DuetBoard, overlap_ratio: float = 3, seed: int | None = None) -> DuetBoard:
+    def dual_board(cls, board: DuetBoard, overlap_ratio: float = 3, seed: int | None = None) -> Self:
         if seed:
             random.seed(seed)
         # Given board analysis

codenames/duet/state.py

@@ -4,7 +4,7 @@
 from enum import StrEnum
 from typing import Any, Self
 
-from pydantic import BaseModel, field_validator, model_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 from codenames.duet.board import DuetBoard
 from codenames.duet.card import DuetColor
@@ -41,7 +41,7 @@ class DuetPlayerState(PlayerState[DuetColor, DuetTeam]):
     score: Score
     current_player_role: PlayerRole = PlayerRole.SPYMASTER
     current_team: DuetTeam = DuetTeam.MAIN
-    dual_given_words: list[str] = []
+    dual_given_words: list[str] = Field(default_factory=list)
 
     @property
     def illegal_clue_words(self) -> WordGroup:
@@ -165,7 +165,7 @@ def get_spymaster_state(self, dual_state: DuetSideState | None) -> DuetSpymaster
     def get_operative_state(self, dual_state: DuetSideState | None) -> DuetOperativeState:
         dual_player_state = dual_state.get_spymaster_state(None) if dual_state else None
         return DuetOperativeState(
-            board=DuetBoard.from_board(self.board.censored),
+            board=DuetBoard.cast_board(self.board.censored),
             given_clues=self.given_clues,
             given_guesses=self.given_guesses,
             score=self.score,

codenames/generic/state.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Generic
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from codenames.generic.board import Board, WordGroup
 from codenames.generic.card import C
@@ -20,8 +20,8 @@ class PlayerState(BaseModel, Generic[C, T]):
 
     board: Board[C]
     current_team: T
-    given_clues: list[GivenClue[T]] = []
-    given_guesses: list[GivenGuess[C, T]] = []
+    given_clues: list[GivenClue[T]] = Field(default_factory=list)
+    given_guesses: list[GivenGuess[C, T]] = Field(default_factory=list)
 
     @property
     def given_clue_words(self) -> WordGroup:
@@ -37,7 +37,7 @@ class SpymasterState(PlayerState, Generic[C, T]):
     Represents all the information that is available to a Spymaster.
     """
 
-    clues: list[Clue] = []
+    clues: list[Clue] = Field(default_factory=list)
 
 
 class OperativeState(PlayerState, Generic[C, T]):

pyproject.toml

@@ -75,6 +75,7 @@ minor_tags = [
     "✨",
     "🔥",
     "🐲",
+    "🎡",
 ]
 patch_tags = [
     "📝",
@@ -87,7 +88,6 @@ patch_tags = [
     "🌴",
     "🎢",
     "🏖️",
-    "🎡",
 ]
 
 # Test

tests/classic/test_game_state.py

@@ -4,18 +4,18 @@
 
 from codenames.classic.board import ClassicBoard
 from codenames.classic.color import ClassicColor, ClassicTeam
-from codenames.classic.runner import new_game_state
 from codenames.classic.state import ClassicGameState, ClassicPlayerState
 from codenames.classic.types import ClassicCard, ClassicGivenClue, ClassicGivenGuess
 from codenames.classic.winner import Winner, WinningReason
 from codenames.generic.exceptions import InvalidGuess, InvalidTurn
 from codenames.generic.move import PASS_GUESS, Clue, Guess
 from codenames.generic.player import PlayerRole
+from codenames.utils.vocabulary.languages import SupportedLanguage
 from tests.utils.moves import ClueMove, GuessMove, Move, PassMove, get_moves
 
 
 def test_game_state_flow(board_10: ClassicBoard):
-    game_state = new_game_state(board=board_10)
+    game_state = ClassicGameState.from_board(board=board_10)
     assert game_state.current_team == ClassicTeam.BLUE
     assert game_state.current_player_role == PlayerRole.SPYMASTER
     assert _get_moves(game_state) == []
@@ -138,7 +138,7 @@ def test_game_state_flow(board_10: ClassicBoard):
 
 
 def test_game_state_json_serialization_and_load(board_10: ClassicBoard):
-    game_state = new_game_state(board=board_10)
+    game_state = ClassicGameState.from_board(board=board_10)
     game_state.process_clue(Clue(word="A", card_amount=2))
     game_state.process_guess(Guess(card_index=0))
     game_state.process_guess(Guess(card_index=1))
@@ -156,3 +156,8 @@ def _get_moves(state: ClassicPlayerState) -> list[Move]:
         given_guesses=state.given_guesses,
         current_turn=state.current_player_role,
     )
+
+
+def test_game_state_from_language():
+    game_state = ClassicGameState.from_language(language=SupportedLanguage.ENGLISH)
+    assert len(game_state.board.cards) == 25