kaggle-environments 1.20.0__py3-none-any.whl → 1.21.0__py3-none-any.whl

kaggle_environments/envs/werewolf/game/states.py

@@ -0,0 +1,214 @@
+import logging
+from collections import defaultdict, deque
+from functools import cached_property
+from typing import Any, DefaultDict, Deque, Dict, List, Optional, Sequence, Union
+
+from pydantic import ConfigDict, Field, PrivateAttr, computed_field
+
+from .base import BaseRole, BaseState, EventHandler, PlayerID
+from .consts import MODERATOR_ID, DetailedPhase, EventName, Phase, PhaseDivider, RevealLevel, RoleConst, Team
+from .records import DataAccessLevel, DataEntry, Event, PhaseDividerDataEntry, PlayerEventView
+from .roles import Player
+
+logger = logging.getLogger(__name__)
+
+
+class EventBus:
+    def __init__(self):
+        self._subs: DefaultDict[EventName, List[EventHandler]] = defaultdict(list)
+
+    def register(self, event_name: EventName, handler: EventHandler):
+        self._subs[event_name].append(handler)
+
+    def dispatch(self, entry: Event):
+        for handler in self._subs[entry.event_name]:
+            handler(entry)
+
+
+class GameState(BaseState):
+    model_config = ConfigDict(use_enum_values=True)
+
+    players: List[Player]
+    phase: Phase = Phase.NIGHT
+    detailed_phase: DetailedPhase = DetailedPhase.NIGHT_START
+    day_count: int = 0
+    history: Dict[int, List[Event]] = Field(default_factory=dict)
+    wallet: dict[PlayerID, int] = Field(default_factory=dict)
+    night_elimination_reveal_level: RevealLevel = RevealLevel.ROLE
+    day_exile_reveal_level: RevealLevel = RevealLevel.ROLE
+    _id_to_player: Dict[PlayerID, Player] = PrivateAttr(default_factory=dict)
+    _event_by_type: Dict[EventName, List[Event]] = PrivateAttr(default_factory=lambda: defaultdict(list))
+    _event_queue: Deque[Event] = PrivateAttr(default_factory=deque)
+    _night_elimination_player_ids: List[PlayerID] = PrivateAttr(default_factory=list)
+    _day_exile_player_ids: List[PlayerID] = PrivateAttr(default_factory=list)
+    _event_bus: EventBus = PrivateAttr(default_factory=EventBus)
+
+    @computed_field
+    @cached_property
+    def all_player_ids(self) -> List[str]:
+        return [player.id for player in self.players]
+
+    @computed_field
+    @cached_property
+    def all_unique_roles(self) -> List[BaseRole]:
+        role_dict = {player.role.name: player.role for player in self.players}
+        return list(role_dict.values())
+
+    def model_post_init(self, context: Any, /) -> None:
+        self._id_to_player = {p.id: p for p in self.players}
+
+    def get_player_by_id(self, pid: PlayerID):
+        return self._id_to_player.get(pid)
+
+    def get_players_by_role(self, role: RoleConst):
+        return [p for p in self.players if p.role.name == role]
+
+    def get_players_by_team(self, team: Team):
+        return [p for p in self.players if p.role.team == team]
+
+    def alive_players(self):
+        return [p for p in self.players if p.alive]
+
+    def eliminated_players(self):
+        return [p for p in self.players if not p.alive]
+
+    def revealed_players(self) -> Dict[PlayerID, RoleConst | Team | None]:
+        revealed = {}
+        if self.night_elimination_reveal_level == RevealLevel.ROLE:
+            revealed.update({pid: self.get_player_by_id(pid).role.name for pid in self._night_elimination_player_ids})
+        elif self.night_elimination_reveal_level == RevealLevel.TEAM:
+            revealed.update({pid: self.get_player_by_id(pid).role.team for pid in self._night_elimination_player_ids})
+        elif self.night_elimination_reveal_level == RevealLevel.NO_REVEAL:
+            revealed.update({pid: None for pid in self._night_elimination_player_ids})
+
+        if self.day_exile_reveal_level == RevealLevel.ROLE:
+            revealed.update({pid: self.get_player_by_id(pid).role.name for pid in self._day_exile_player_ids})
+        elif self.day_exile_reveal_level == RevealLevel.TEAM:
+            revealed.update({pid: self.get_player_by_id(pid).role.team for pid in self._day_exile_player_ids})
+        elif self.day_exile_reveal_level == RevealLevel.NO_REVEAL:
+            revealed.update({pid: None for pid in self._day_exile_player_ids})
+        return revealed
+
+    def is_alive(self, player_id: PlayerID):
+        return self.get_player_by_id(player_id).alive
+
+    def alive_players_by_role(self, role: RoleConst):
+        return [p for p in self.alive_players() if p.role.name == role]
+
+    def alive_players_by_team(self, team: Team):
+        return [p for p in self.alive_players() if p.role.team == team]
+
+    def alive_player_counts_per_role(self):
+        counts = {role: len(self.alive_players_by_role(role)) for role in RoleConst}
+        return counts
+
+    def alive_player_counts_per_team(self):
+        return {team: len(self.alive_players_by_team(team)) for team in Team}
+
+    _night_eliminate_queue: List[PlayerID] = PrivateAttr(default_factory=list)
+
+    def queue_eliminate(self, target: Player):
+        self._night_eliminate_queue.append(target.id)
+
+    def clear_eliminate_queue(self):
+        self._night_eliminate_queue.clear()
+
+    _night_doctor_save_queue: List[PlayerID] = PrivateAttr(default_factory=list)
+
+    def queue_doctor_save(self, target: Player):
+        self._night_doctor_save_queue.append(target.id)
+
+    def get_event_by_name(self, event_name: EventName) -> List[Event]:
+        return self._event_by_type[event_name]
+
+    def push_event(
+        self,
+        description: str,
+        event_name: EventName,
+        public: bool,
+        visible_to: Optional[List[PlayerID]] = None,
+        data: Optional[Union[DataEntry, Dict[str, Any]]] = None,
+        source=MODERATOR_ID,
+        visible_in_ui: bool = True,
+    ):
+        visible_to = visible_to or []
+        # Night 0 will use day_count 0, Day 1 will use day_count 1, etc.
+        day_key = self.day_count
+        self.history.setdefault(day_key, [])
+        sys_entry = Event(
+            day=day_key,
+            phase=self.phase,
+            detailed_phase=self.detailed_phase,
+            event_name=event_name,
+            description=description,
+            public=public,
+            visible_to=visible_to or [],
+            data=data,
+            source=source,
+            visible_in_ui=visible_in_ui,
+        )
+
+        self.history[day_key].append(sys_entry)
+        self._event_by_type[event_name].append(sys_entry)
+        self._event_queue.append(sys_entry)
+
+        public_view = sys_entry.view_by_access(user_level=DataAccessLevel.PUBLIC)
+        personal_view = sys_entry.view_by_access(user_level=DataAccessLevel.PERSONAL)
+
+        # observers message pushing below
+        if public:
+            for player in self.players:
+                if player.id == source:
+                    player.update(personal_view)
+                else:
+                    player.update(public_view)
+        else:
+            for player_id in visible_to:
+                player = self.get_player_by_id(player_id)
+                if player:
+                    if player.id == source:
+                        player.update(personal_view)
+                    else:
+                        player.update(public_view)
+
+        # publish events
+        self._event_bus.dispatch(sys_entry)
+
+    def add_phase_divider(self, divider: PhaseDivider):
+        """The phase divider is used to clearly separate phase boundary. This is very useful
+        for visualizer updates, where some updates naturally takes a time slice of events as input.
+        """
+        self.push_event(
+            description=divider.value,
+            event_name=EventName.PHASE_DIVIDER,
+            public=False,
+            data=PhaseDividerDataEntry(divider_type=divider.value),
+        )
+
+    def eliminate_player(self, pid: PlayerID):
+        if pid not in self.all_player_ids:
+            logger.warning(f"Tried to eliminate {pid} who is not within valid player ids {self.all_player_ids}.")
+            return
+        player = self.get_player_by_id(pid)
+        if self.phase == Phase.NIGHT:
+            self._night_elimination_player_ids.append(pid)
+        else:
+            self._day_exile_player_ids.append(pid)
+        if player:
+            player.eliminate(day=self.day_count, phase=self.phase)
+
+    def consume_messages(self) -> List[Event]:
+        messages = list(self._event_queue)
+        self._event_queue.clear()
+        return messages
+
+    def get_elimination_info(self):
+        return [player.report_elimination() for player in self.players]
+
+    def register_event_handler(self, event_name: EventName, handler: EventHandler):
+        self._event_bus.register(event_name, handler)
+
+
+def get_last_action_request(event_views: Sequence[PlayerEventView], event_name: EventName) -> None | PlayerEventView:
+    """Get the action request from the new player history entry view updates."""
+    return next((entry for entry in event_views if entry.event_name == event_name), None)

kaggle_environments/envs/werewolf/game/test_actions.py

@@ -0,0 +1,45 @@
+import pytest
+
+from kaggle_environments.envs.werewolf.game.actions import filter_language
+
+test_data = [
+    # Test 1: Basic lowercase substitution
+    ("We must kill the monster.", "We must eliminate the monster."),
+    # Test 2: Title case substitution
+    ("Killing is wrong.", "Eliminating is wrong."),
+    # Test 3: Uppercase substitution
+    ("The town should not LYNCH anyone.", "The town should not EXILE anyone."),
+    # Test 4: Word boundary check (should not affect "skill")
+    ("His skill is unparalleled.", "His skill is unparalleled."),
+    # Test 5: Mixed case and multiple substitutions
+    (
+        "The Mob will lynch the player they think will Kill them.",
+        "The Mob will exile the player they think will Eliminate them.",
+    ),
+    # Test 6: Handling different word endings ('-ed', '-s')
+    ("He killed the dragon, and she kills the goblin.", "He eliminated the dragon, and she eliminates the goblin."),
+    # Test 7: No inappropriate words, should return original string
+    ("This is a perfectly safe sentence.", "This is a perfectly safe sentence."),
+    # Test 8: A more complex sentence with a third rule ('murder')
+    (
+        "The detective solved the Murder, preventing the killer from killing again.",
+        "The detective solved the Remove, preventing the eliminator from eliminating again.",
+    ),
+    # Test 9: A tricky title case that isn't at the start of a sentence
+    ("I think Killing is not the answer.", "I think Eliminating is not the answer."),
+]
+
+
+@pytest.mark.parametrize("input_text, expected_text", test_data)
+def test_clean_script_scenarios(input_text, expected_text):
+    """
+    Tests the clean_script_preserve_case function with various scenarios.
+    """
+    assert filter_language(input_text) == expected_text
+
+
+def test_empty_string():
+    """
+    Tests that an empty string input results in an empty string output.
+    """
+    assert filter_language("") == ""

kaggle_environments/envs/werewolf/test_werewolf.py

@@ -0,0 +1,161 @@
+import pytest
+
+from kaggle_environments import make
+
+URLS = {
+    "gemini": "https://logos-world.net/wp-content/uploads/2025/01/Google-Gemini-Symbol.png",
+    "openai": "https://images.seeklogo.com/logo-png/46/1/chatgpt-logo-png_seeklogo-465219.png",
+    "claude": "https://images.seeklogo.com/logo-png/55/1/claude-logo-png_seeklogo-554534.png",
+    "grok": "https://images.seeklogo.com/logo-png/61/1/grok-logo-png_seeklogo-613403.png",
+}
+
+
+@pytest.fixture
+def agents_config():
+    roles = ["Werewolf", "Werewolf", "Doctor", "Seer", "Villager", "Villager", "Villager"]
+    names = [f"player_{i}" for i in range(len(roles))]
+    thumbnails = [
+        URLS["gemini"],
+        URLS["gemini"],
+        URLS["openai"],
+        URLS["openai"],
+        URLS["openai"],
+        URLS["claude"],
+        URLS["grok"],
+    ]
+    agents_config = [
+        {"role": role, "id": name, "agent_id": "random", "thumbnail": url}
+        for role, name, url in zip(roles, names, thumbnails)
+    ]
+    return agents_config
+
+
+@pytest.fixture
+def env(agents_config):
+    env = make("werewolf", debug=True, configuration={"agents": agents_config})
+    return env
+
+
+def test_load_env(env):
+    agents = ["random"] * 7
+    env.run(agents)
+
+    for i, state in enumerate(env.steps):
+        env.render_step_ind = i
+        env.renderer(state, env)
+
+
+def test_discussion_protocol(agents_config):
+    env = make(
+        "werewolf",
+        debug=True,
+        configuration={
+            "agents": agents_config,
+            "discussion_protocol": {"name": "RoundRobinDiscussion", "params": {"max_rounds": 2}},
+        },
+    )
+    agents = ["random"] * 7
+    env.run(agents)
+    env.toJSON()
+
+
+def test_no_reveal_options(agents_config):
+    env = make(
+        "werewolf",
+        debug=True,
+        configuration={
+            "agents": agents_config,
+            "night_elimination_reveal_level": "no_reveal",
+            "day_exile_reveal_level": "no_reveal",
+        },
+    )
+    agents = ["random"] * 7
+    env.run(agents)
+    env.toJSON()
+
+
+def test_disable_doctor_self_save():
+    roles = ["Werewolf", "Werewolf", "Doctor", "Seer", "Villager", "Villager", "Villager"]
+    names = [f"player_{i}" for i in range(len(roles))]
+    thumbnails = [
+        URLS["gemini"],
+        URLS["gemini"],
+        URLS["openai"],
+        URLS["openai"],
+        URLS["openai"],
+        URLS["claude"],
+        URLS["grok"],
+    ]
+    agents_config = [
+        {"role": role, "id": name, "agent_id": "random", "thumbnail": url}
+        for role, name, url in zip(roles, names, thumbnails)
+    ]
+    agents_config[2]["role_params"] = {"allow_self_save": False}
+    env = make(
+        "werewolf",
+        debug=True,
+        configuration={
+            "agents": agents_config,
+        },
+    )
+    agents = ["random"] * 7
+    env.run(agents)
+    env.toJSON()
+
+
+def test_turn_by_turn_bidding_discussion(agents_config):
+    """Tests the bidding -> chat -> bidding -> chat ... cycle."""
+    env = make(
+        "werewolf",
+        debug=True,
+        configuration={
+            "agents": agents_config,
+            "discussion_protocol": {
+                "name": "TurnByTurnBiddingDiscussion",
+                "params": {
+                    "bidding": {
+                        "name": "UrgencyBiddingProtocol",
+                    },
+                    "max_turns": 16,
+                    "bid_result_public": False,
+                },
+            },
+        },
+    )
+    agents = ["random"] * 7
+    env.run(agents)
+    env.render(mode="html")
+
+
+@pytest.mark.skip("Slow test, meant for manual testing.")
+def test_llm_players(agents_config):
+    env = make("werewolf", debug=True, configuration={"actTimeout": 30, "agents": agents_config})
+    agents = [
+        "llm/gemini/gemini-2.5-flash",
+        "random",
+        "llm/gemini/gemini-2.5-flash",
+        "llm/gemini/gemini-2.5-flash",
+        "llm/gemini/gemini-2.5-flash",
+        "random",
+        "random",
+    ]
+    env.run(agents)
+    for i, state in enumerate(env.steps):
+        env.render_step_ind = i
+        env.renderer(state, env)
+
+
+def test_default_env():
+    env = make("werewolf", debug=True)
+    agents = ["random"] * 7
+    env.run(agents)
+
+
+def test_html_render(env, tmp_path):
+    agents = ["random"] * 7
+    env.run(agents)
+    content = env.render(mode="html")
+    replay_file = tmp_path / "game_replay.html"
+    with open(replay_file, "w") as handle:
+        handle.write(content)
+    assert replay_file.exists()

kaggle_environments/envs/werewolf/test_werewolf_deterministic.py

@@ -0,0 +1,211 @@
+import pytest
+
+from kaggle_environments import make
+from kaggle_environments.envs.werewolf.game.protocols.vote import TieBreak
+from kaggle_environments.envs.werewolf.game.consts import EnvInfoKeys, Team
+from kaggle_environments.envs.werewolf.game.records import GameEndResultsDataEntry
+
+URLS = {
+    "gemini": "https://logos-world.net/wp-content/uploads/2025/01/Google-Gemini-Symbol.png",
+    "openai": "https://images.seeklogo.com/logo-png/46/1/chatgpt-logo-png_seeklogo-465219.png",
+    "claude": "https://images.seeklogo.com/logo-png/55/1/claude-logo-png_seeklogo-554534.png",
+    "grok": "https://images.seeklogo.com/logo-png/61/1/grok-logo-png_seeklogo-613403.png",
+}
+
+
+@pytest.fixture
+def deterministic_agents_config():
+    roles = ["Werewolf", "Werewolf", "Doctor", "Seer", "Villager", "Villager", "Villager"]
+    names = [f"player_{i}" for i in range(len(roles))]
+    thumbnails = [
+        URLS["gemini"],
+        URLS["gemini"],
+        URLS["openai"],
+        URLS["openai"],
+        URLS["openai"],
+        URLS["claude"],
+        URLS["grok"],
+    ]
+    agents_config = [
+        {"role": role, "id": name, "agent_id": "deterministic", "thumbnail": url}
+        for role, name, url in zip(roles, names, thumbnails)
+    ]
+    return agents_config
+
+
+@pytest.fixture
+def deterministic_config_options():
+    options = {
+        "discussion_protocol": {
+            "name": "RoundRobinDiscussion",
+            "params": {"max_rounds": 1, "assign_random_first_speaker": False},
+        },
+        "day_voting_protocol": {
+            "name": "SequentialVoting",
+            "params": {"assign_random_first_voter": True, "tie_break": TieBreak.NO_EXILE},
+        },
+        "werewolf_night_vote_protocol": {
+            "name": "SequentialVoting",
+            "params": {"assign_random_first_voter": True, "tie_break": TieBreak.NO_EXILE},
+        },
+    }
+    return options
+
+
+def test_game_result(deterministic_agents_config, deterministic_config_options):
+    """
+    Tests that the deterministic werewolves vote to eliminate the first valid target.
+    """
+    env = make(
+        "werewolf", debug=True, configuration={"agents": deterministic_agents_config, **deterministic_config_options}
+    )
+    agents = ["deterministic"] * 7
+    env.run(agents)
+
+    result = GameEndResultsDataEntry(**env.info[EnvInfoKeys.GAME_END])
+
+    assert len(env.steps) == 24
+    assert result.winner_team == Team.VILLAGERS
+    assert result.winner_ids == ["player_2", "player_3", "player_4", "player_5", "player_6"]
+    assert result.loser_ids == ["player_0", "player_1"]
+    assert result.scores == {
+        "player_2": 1,
+        "player_3": 1,
+        "player_4": 1,
+        "player_5": 1,
+        "player_6": 1,
+        "player_0": 0,
+        "player_1": 0,
+    }
+    assert result.elimination_info == [
+        {"player_id": "player_0", "eliminated_during_day": 1, "eliminated_during_phase": "Day"},
+        {"player_id": "player_1", "eliminated_during_day": 2, "eliminated_during_phase": "Day"},
+        {"player_id": "player_2", "eliminated_during_day": 0, "eliminated_during_phase": "Night"},
+        {"player_id": "player_3", "eliminated_during_day": 1, "eliminated_during_phase": "Night"},
+        {"player_id": "player_4", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_5", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_6", "eliminated_during_day": -1, "eliminated_during_phase": None},
+    ]
+
+
+def test_parallel_discussion_simultaneous_majority_vote(deterministic_agents_config, deterministic_config_options):
+    config = {"agents": deterministic_agents_config, **deterministic_config_options}
+    config.update(
+        {
+            "discussion_protocol": {"name": "ParallelDiscussion", "params": {"ticks": 2}},
+            "day_voting_protocol": {"name": "SimultaneousMajority", "params": {"tie_break": TieBreak.NO_EXILE}},
+            "werewolf_night_vote_protocol": {
+                "name": "SimultaneousMajority",
+                "params": {"tie_break": TieBreak.NO_EXILE},
+            },
+        }
+    )
+
+    env = make("werewolf", debug=True, configuration=config)
+    agents = ["deterministic"] * 7
+    env.run(agents)
+
+    result = GameEndResultsDataEntry(**env.info[EnvInfoKeys.GAME_END])
+
+    assert len(env.steps) == 11
+    assert result.winner_team == Team.VILLAGERS
+    assert result.winner_ids == ["player_2", "player_3", "player_4", "player_5", "player_6"]
+    assert result.loser_ids == ["player_0", "player_1"]
+    assert result.scores == {
+        "player_2": 1,
+        "player_3": 1,
+        "player_4": 1,
+        "player_5": 1,
+        "player_6": 1,
+        "player_0": 0,
+        "player_1": 0,
+    }
+    assert result.elimination_info == [
+        {"player_id": "player_0", "eliminated_during_day": 1, "eliminated_during_phase": "Day"},
+        {"player_id": "player_1", "eliminated_during_day": 2, "eliminated_during_phase": "Day"},
+        {"player_id": "player_2", "eliminated_during_day": 0, "eliminated_during_phase": "Night"},
+        {"player_id": "player_3", "eliminated_during_day": 1, "eliminated_during_phase": "Night"},
+        {"player_id": "player_4", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_5", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_6", "eliminated_during_day": -1, "eliminated_during_phase": None},
+    ]
+
+
+def test_round_by_round_bidding_discussion_sequential_vote(deterministic_agents_config, deterministic_config_options):
+    config = {"agents": deterministic_agents_config, **deterministic_config_options}
+    config.update(
+        {
+            "discussion_protocol": {
+                "name": "RoundByRoundBiddingDiscussion",
+                "params": {"bidding": {"name": "UrgencyBiddingProtocol"}, "max_rounds": 2, "bid_result_public": True},
+            }
+        }
+    )
+    env = make("werewolf", debug=True, configuration=config)
+    agents = ["deterministic"] * 7
+    env.run(agents)
+
+    result = GameEndResultsDataEntry(**env.info[EnvInfoKeys.GAME_END])
+
+    assert len(env.steps) == 34
+    assert result.winner_team == Team.VILLAGERS
+    assert result.winner_ids == ["player_2", "player_3", "player_4", "player_5", "player_6"]
+    assert result.loser_ids == ["player_0", "player_1"]
+    assert result.scores == {
+        "player_2": 1,
+        "player_3": 1,
+        "player_4": 1,
+        "player_5": 1,
+        "player_6": 1,
+        "player_0": 0,
+        "player_1": 0,
+    }
+    assert result.elimination_info == [
+        {"player_id": "player_0", "eliminated_during_day": 1, "eliminated_during_phase": "Day"},
+        {"player_id": "player_1", "eliminated_during_day": 2, "eliminated_during_phase": "Day"},
+        {"player_id": "player_2", "eliminated_during_day": 0, "eliminated_during_phase": "Night"},
+        {"player_id": "player_3", "eliminated_during_day": 1, "eliminated_during_phase": "Night"},
+        {"player_id": "player_4", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_5", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_6", "eliminated_during_day": -1, "eliminated_during_phase": None},
+    ]
+
+
+def test_turn_by_turn_bidding(deterministic_agents_config, deterministic_config_options):
+    config = {"agents": deterministic_agents_config, **deterministic_config_options}
+    config.update(
+        {
+            "discussion_protocol": {
+                "name": "TurnByTurnBiddingDiscussion",
+                "params": {"bidding": {"name": "UrgencyBiddingProtocol"}, "max_turns": 10, "bid_result_public": False},
+            }
+        }
+    )
+    env = make("werewolf", debug=True, configuration=config)
+    agents = ["deterministic"] * 7
+    env.run(agents)
+
+    result = GameEndResultsDataEntry(**env.info[EnvInfoKeys.GAME_END])
+
+    assert len(env.steps) == 34
+    assert result.winner_team == Team.VILLAGERS
+    assert result.winner_ids == ["player_2", "player_3", "player_4", "player_5", "player_6"]
+    assert result.loser_ids == ["player_0", "player_1"]
+    assert result.scores == {
+        "player_2": 1,
+        "player_3": 1,
+        "player_4": 1,
+        "player_5": 1,
+        "player_6": 1,
+        "player_0": 0,
+        "player_1": 0,
+    }
+    assert result.elimination_info == [
+        {"player_id": "player_0", "eliminated_during_day": 1, "eliminated_during_phase": "Day"},
+        {"player_id": "player_1", "eliminated_during_day": 2, "eliminated_during_phase": "Day"},
+        {"player_id": "player_2", "eliminated_during_day": 0, "eliminated_during_phase": "Night"},
+        {"player_id": "player_3", "eliminated_during_day": 1, "eliminated_during_phase": "Night"},
+        {"player_id": "player_4", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_5", "eliminated_during_day": -1, "eliminated_during_phase": None},
+        {"player_id": "player_6", "eliminated_during_day": -1, "eliminated_during_phase": None},
+    ]