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

kaggle_environments/envs/open_spiel/proxy.py

@@ -0,0 +1,138 @@
+"""OpenSpiel Game and State proxies.
+
+Proxies that act as a pyspiel.State/Game by wrapping the original object and
+forwarding calls. Subclassing allows to override specific methods or add
+additional functionality, or payload to the State/Game object.
+
+WARNING: Serialization of proxy games and states is not supported.
+"""
+
+from typing import Any
+
+import pyspiel
+
+from . import observation
+
+
+class State(pyspiel.State):
+    """Base class for a pyspiel.State proxy."""
+
+    def __init__(self, wrapped: pyspiel.State, game: "Game"):
+        super().__init__(game)
+        self.__wrapped__ = wrapped
+
+    def current_player(self) -> int:
+        return self.__wrapped__.current_player()
+
+    def _legal_actions(self, player: int) -> list[int]:
+        return self.__wrapped__.legal_actions(player)
+
+    def _apply_action(self, action: int) -> None:
+        return self.__wrapped__.apply_action(action)
+
+    def _action_to_string(self, player: int, action: int) -> str:
+        return self.__wrapped__.action_to_string(player, action)
+
+    def chance_outcomes(self) -> list[tuple[int, float]]:
+        return self.__wrapped__.chance_outcomes()
+
+    def is_terminal(self) -> bool:
+        return self.__wrapped__.is_terminal()
+
+    def returns(self) -> list[float]:
+        return self.__wrapped__.returns()
+
+    def rewards(self) -> list[float]:
+        return self.__wrapped__.rewards()
+
+    def __str__(self) -> str:
+        return self.__wrapped__.__str__()
+
+    def to_string(self) -> str:
+        return self.__wrapped__.to_string()
+
+    def __getattr__(self, name: str) -> Any:
+        # Escape hatch when proxying Python implementations that have attributes
+        # that need to be accessed, e.g. TicTacToeState.board from its observer.
+        return object.__getattribute__(self.__wrapped__, name)
+
+
+class Game(pyspiel.Game):
+    """Base class for a pyspiel.Game proxy."""
+
+    def __init__(self, wrapped: pyspiel.Game, **kwargs):
+        # TODO(hennes): Add serialization.
+        game_info = pyspiel.GameInfo(
+            num_distinct_actions=wrapped.num_distinct_actions(),
+            max_chance_outcomes=wrapped.max_chance_outcomes(),
+            num_players=wrapped.num_players(),
+            min_utility=wrapped.min_utility(),
+            max_utility=wrapped.max_utility(),
+            utility_sum=wrapped.utility_sum(),
+            max_game_length=wrapped.max_game_length(),
+        )
+        super().__init__(
+            _game_type(wrapped.get_type(), **kwargs),
+            game_info,
+            wrapped.get_parameters(),
+        )
+        self.__wrapped__ = wrapped
+
+    def new_initial_state(self, from_string: str | None = None) -> State:
+        args = () if from_string is None else (from_string)
+        return State(wrapped=self.__wrapped__.new_initial_state(*args), game=self)
+
+    def max_chance_nodes_in_history(self) -> int:
+        return self.__wrapped__.max_chance_nodes_in_history()
+
+    def make_py_observer(
+        self,
+        iig_obs_type: pyspiel.IIGObservationType | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> pyspiel.Observer:
+        return _Observation(observation.make_observation(self.__wrapped__, iig_obs_type, params))
+
+
+class _Observation(observation._Observation):  # pylint: disable=protected-access
+    """_Observation proxy that passes the wrapped state to the observation."""
+
+    def __init__(self, wrapped: observation._Observation):
+        self.__wrapped__ = wrapped
+        self.dict = self.__wrapped__.dict
+        self.tensor = self.__wrapped__.tensor
+
+    def set_from(self, state: State, player: int):
+        self.__wrapped__.set_from(state.__wrapped__, player)
+
+    def string_from(self, state: State, player: int) -> str | None:
+        return self.__wrapped__.string_from(state.__wrapped__, player)
+
+    def compress(self) -> Any:
+        return self.__wrapped__.compress()
+
+    def decompress(self, compressed_observation: Any):
+        self.__wrapped__.decompress(compressed_observation)
+
+
+def _game_type(game_type: pyspiel.GameType, **overrides) -> pyspiel.GameType:
+    """Returns a GameType with the given overrides."""
+    kwargs = dict(
+        short_name=game_type.short_name,
+        long_name=game_type.long_name,
+        dynamics=game_type.dynamics,
+        chance_mode=game_type.chance_mode,
+        information=game_type.information,
+        utility=game_type.utility,
+        reward_model=game_type.reward_model,
+        max_num_players=game_type.max_num_players,
+        min_num_players=game_type.min_num_players,
+        provides_information_state_string=game_type.provides_information_state_string,
+        provides_information_state_tensor=game_type.provides_information_state_tensor,
+        provides_observation_string=game_type.provides_observation_string,
+        provides_observation_tensor=game_type.provides_observation_tensor,
+        parameter_specification=game_type.parameter_specification,
+        default_loadable=game_type.default_loadable,
+        provides_factored_observation_string=game_type.provides_factored_observation_string,
+    )
+    kwargs.update(**overrides)
+    return pyspiel.GameType(**kwargs)

kaggle_environments/envs/open_spiel/test_open_spiel.py

@@ -0,0 +1,191 @@
+import json
+import pathlib
+
+import pyspiel
+from absl.testing import absltest
+
+from kaggle_environments import make
+
+from . import open_spiel as open_spiel_env
+
+# Expected that not all pyspiel registered games can be registered as Kaggle
+# envs (e.g. does not yet support simultaneous move games), but should register
+# at least this many
+_REGISTERED_GAMES_THRESHOLD = 50
+
+
+class OpenSpielEnvTest(absltest.TestCase):
+    def test_envs_load(self):
+        envs = open_spiel_env._register_game_envs([game_type.short_name for game_type in pyspiel.registered_games()])
+        self.assertTrue(len(envs) > _REGISTERED_GAMES_THRESHOLD)
+
+    def test_tic_tac_toe_agent_playthrough(self):
+        envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+        env = make("open_spiel_tic_tac_toe", debug=True)
+        env.run(["random", "random"])
+        json = env.toJSON()
+        self.assertEqual(json["name"], "open_spiel_tic_tac_toe")
+        self.assertTrue(all([status == "DONE" for status in json["statuses"]]))
+
+    def test_tic_tac_toe_manual_playthrough(self):
+        envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+        env = make("open_spiel_tic_tac_toe", debug=True)
+        env.reset()
+        env.step([{"submission": -1}, {"submission": -1}])  # Initial setup step.
+        env.step([{"submission": 0}, {"submission": -1}])
+        env.step([{"submission": -1}, {"submission": 1}])
+        env.step([{"submission": 3}, {"submission": -1}])
+        env.step([{"submission": -1}, {"submission": 4}])
+        env.step([{"submission": 6}, {"submission": -1}])
+        self.assertTrue(env.done)
+        self.assertEqual(env.toJSON()["rewards"], [1, -1])
+
+    def test_invalid_action(self):
+        envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+        env = make("open_spiel_tic_tac_toe", debug=True)
+        env.reset()
+        for i in range(5):  # Try repeatedly applying an illegal action
+            env.step(
+                [
+                    {"submission": pyspiel.INVALID_ACTION},
+                    {"submission": pyspiel.INVALID_ACTION},
+                ]
+            )
+            if env.done:
+                break
+        self.assertEqual(i, 1)  # Zeroth step is setup step, should fail next step.
+        json = env.toJSON()
+        self.assertTrue(all([status == "DONE" for status in json["statuses"]]))
+        self.assertEqual(
+            json["rewards"],
+            [
+                open_spiel_env.DEFAULT_INVALID_ACTION_REWARD,
+                -open_spiel_env.DEFAULT_INVALID_ACTION_REWARD,
+            ],
+        )
+
+    def test_serialized_game_and_state(self):
+        envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+        env = make("open_spiel_tic_tac_toe", debug=True)
+        env.reset()
+        env.step([{"submission": -1}, {"submission": -1}])  # Initial setup step.
+        kaggle_state = env.step([{"submission": 0}, {"submission": -1}])
+        serialize_game_and_state = kaggle_state[1]["observation"]["serializedGameAndState"]
+        game, state = pyspiel.deserialize_game_and_state(serialize_game_and_state)
+        self.assertEqual(game.get_type().short_name, "tic_tac_toe_proxy")
+        self.assertEqual(state.history(), [0])
+
+    def test_agent_error(self):
+        envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+        env = make("open_spiel_tic_tac_toe", debug=True)
+        env.reset()
+        # Setup step
+        env.step(
+            [
+                {"submission": pyspiel.INVALID_ACTION},
+                {"submission": pyspiel.INVALID_ACTION},
+            ]
+        )
+        env.step(
+            [
+                {"submission": open_spiel_env.AGENT_ERROR_ACTION},
+                {"submission": pyspiel.INVALID_ACTION},
+            ]
+        )
+        self.assertTrue(env.done)
+        json = env.toJSON()
+        self.assertEqual(json["rewards"], [None, None])
+        self.assertEqual(json["statuses"], ["ERROR", "ERROR"])
+
+    def test_initial_actions(self):
+        open_spiel_env._register_game_envs(["tic_tac_toe"])
+        env = make(
+            "open_spiel_tic_tac_toe",
+            {"initialActions": [0, 1, 3, 4]},
+            debug=True,
+        )
+        env.reset()
+        # Setup step
+        env.step(
+            [
+                {"submission": pyspiel.INVALID_ACTION},
+                {"submission": pyspiel.INVALID_ACTION},
+            ]
+        )
+        env.step(
+            [
+                {"submission": 2},
+                {"submission": pyspiel.INVALID_ACTION},
+            ]
+        )
+        env.step(
+            [
+                {"submission": pyspiel.INVALID_ACTION},
+                {"submission": 7},
+            ]
+        )
+        self.assertTrue(env.done)
+        json_playthrough = env.toJSON()
+        self.assertEqual(json_playthrough["rewards"], [-1, 1])
+
+    def test_chess_openings_manually_configured(self):
+        open_spiel_env._register_game_envs(["chess"])
+        openings_path = pathlib.Path(
+            open_spiel_env.GAMES_DIR,
+            "chess/openings.jsonl",
+        )
+        self.assertTrue(openings_path.is_file())
+        with open(openings_path, "r", encoding="utf-8") as f:
+            for line in f:
+                opening = json.loads(line)
+                config = {
+                    "initialActions": opening.pop("initialActions"),
+                    "metadata": opening,
+                }
+                env = make(
+                    "open_spiel_chess",
+                    config,
+                    debug=True,
+                )
+                env.reset()
+                # Setup step
+                env.step(
+                    [
+                        {"submission": pyspiel.INVALID_ACTION},
+                        {"submission": pyspiel.INVALID_ACTION},
+                    ]
+                )
+                obs = env.state[0]["observation"]
+                _, state = pyspiel.deserialize_game_and_state(obs["serializedGameAndState"])
+                self.assertEqual(str(state), opening["fen"])
+                self.assertEqual(str(state), env.toJSON()["configuration"]["metadata"]["fen"])
+
+    def test_chess_openings_configured_with_seed(self):
+        open_spiel_env._register_game_envs(["chess"])
+        config = {
+            "useImage": True,
+            "seed": 1,
+        }
+        env = make(
+            "open_spiel_chess",
+            config,
+            debug=True,
+        )
+        env.reset()
+        # Image config is loaded during setup step.
+        self.assertFalse("imageConfig" in env.configuration)
+        # Setup step
+        env.step(
+            [
+                {"submission": pyspiel.INVALID_ACTION},
+                {"submission": pyspiel.INVALID_ACTION},
+            ]
+        )
+        self.assertTrue("imageConfig" in env.configuration)
+        self.assertEqual(env.configuration["imageConfig"]["color"], "blue")
+        self.assertEqual(env.configuration["imageConfig"]["pieceSet"], "cardinal")
+        self.assertTrue("imageConfig" in env.state[0]["observation"])
+
+
+if __name__ == "__main__":
+    absltest.main()

kaggle_environments/envs/rps/agents.py

@@ -0,0 +1,84 @@
+import random
+
+from .utils import get_score
+
+
+def rock(observation, configuration):
+    return 0
+
+
+def paper(observation, configuration):
+    return 1
+
+
+def scissors(observation, configuration):
+    return 2
+
+
+def copy_opponent(observation, configuration):
+    if observation.step > 0:
+        return observation.lastOpponentAction
+    else:
+        return random.randrange(0, configuration.signs)
+
+
+last_react_action = None
+
+
+def reactionary(observation, configuration):
+    global last_react_action
+    if observation.step == 0:
+        last_react_action = random.randrange(0, configuration.signs)
+    elif get_score(last_react_action, observation.lastOpponentAction) <= 1:
+        last_react_action = (observation.lastOpponentAction + 1) % configuration.signs
+
+    return last_react_action
+
+
+last_counter_action = None
+
+
+def counter_reactionary(observation, configuration):
+    global last_counter_action
+    if observation.step == 0:
+        last_counter_action = random.randrange(0, configuration.signs)
+    elif get_score(last_counter_action, observation.lastOpponentAction) == 1:
+        last_counter_action = (last_counter_action + 2) % configuration.signs
+    else:
+        last_counter_action = (observation.lastOpponentAction + 1) % configuration.signs
+
+    return last_counter_action
+
+
+action_histogram = {}
+
+
+def statistical(observation, configuration):
+    global action_histogram
+    if observation.step == 0:
+        action_histogram = {}
+        return
+    action = observation.lastOpponentAction
+    if action not in action_histogram:
+        action_histogram[action] = 0
+    action_histogram[action] += 1
+    mode_action = None
+    mode_action_count = None
+    for k, v in action_histogram.items():
+        if mode_action_count is None or v > mode_action_count:
+            mode_action = k
+            mode_action_count = v
+            continue
+
+    return (mode_action + 1) % configuration.signs
+
+
+agents = {
+    "rock": rock,
+    "paper": paper,
+    "scissors": scissors,
+    "copy_opponent": copy_opponent,
+    "reactionary": reactionary,
+    "counter_reactionary": counter_reactionary,
+    "statistical": statistical,
+}

kaggle_environments/envs/rps/helpers.py

@@ -0,0 +1,25 @@
+from kaggle_environments.helpers import *
+
+
+class Observation(Observation):
+    """
+    Observation primarily used as a helper to construct the State from the raw observation.
+    This provides bindings for the observation type described at https://github.com/Kaggle/kaggle-environments/blob/master/kaggle_environments/envs/rps/rps.json
+    """
+
+    @property
+    def last_opponent_action(self) -> int:
+        """Move the opponent took on the last turn."""
+        return self["halite"]
+
+
+class Configuration(Configuration):
+    """
+    Configuration provides access to tunable parameters in the environment.
+    This provides bindings for the configuration type described at https://github.com/Kaggle/kaggle-environments/blob/master/kaggle_environments/envs/rps/rps.json
+    """
+
+    @property
+    def signs(self) -> int:
+        """Number of choices each step (3 for the normal rock, paper, scissors)"""
+        return self["signs"]

kaggle_environments/envs/rps/rps.js

@@ -0,0 +1,117 @@
+async function renderer(context) {
+    const {
+        act,
+        agents,
+        environment,
+        frame,
+        height = 400,
+        interactive,
+        isInteractive,
+        parent,
+        step,
+        update,
+        width = 400,
+    } = context;
+
+    const sign_names = ["Rock", "Paper", "Scissors", "Spock", "Lizard"]
+    const sign_icons = ["\u{1f44a}", "\u{270b}", "\u{2702}\u{fe0f}", "\u{1f596}", "\u{1f98e}"]
+
+    // Common Dimensions.
+    const maxWidth = 960;
+    const maxHeight = 280;
+    const canvasSize = Math.min(height, width);
+    const unit = 8;
+    const offset = canvasSize > 400 ? canvasSize * 0.1 : unit / 2;
+    const cellSize = (canvasSize - offset * 2) / 3;
+
+    // Canvas Setup.
+    let canvas = parent.querySelector("canvas");
+    if (!canvas) {
+        canvas = document.createElement("canvas");
+        parent.appendChild(canvas);
+
+        if (interactive) {
+            canvas.addEventListener("click", evt => {
+                if (!isInteractive()) return;
+                const rect = evt.target.getBoundingClientRect();
+                const x = evt.clientX - rect.left - offset;
+                const y = evt.clientY - rect.top - offset;
+                act(Math.floor(x / cellSize) + Math.floor(y / cellSize) * 3);
+            });
+        }
+    }
+
+    canvas.style.cursor = isInteractive() ? "pointer" : "default";
+
+    // Canvas setup and reset.
+    let c = canvas.getContext("2d");
+    canvas.width = Math.min(maxWidth, width);
+    canvas.height = Math.min(maxHeight, height);
+    c.clearRect(0, 0, canvas.width, canvas.height);
+
+    // ------------------------------------------------------------------------------------//
+
+    if (step < environment.steps.length - 1) {
+        const state = environment.steps[step + 1]
+        const last_state = environment.steps[step]
+        const delta_reward = state[0].reward - last_state[0].reward
+
+        const p1_move = state[1].observation.lastOpponentAction;
+        const p2_move = state[0].observation.lastOpponentAction;
+
+        const info = environment.info;
+        const player1_text = info?.TeamNames?.[0] || "Player 1";
+        const player2_text = info?.TeamNames?.[1] || "Player 2";
+
+        const ctx = canvas.getContext("2d");
+        const padding = 20;
+        const row_width = (Math.min(maxWidth, width) - padding * 2) / 3;
+        const label_x = padding;
+        const player1_x = padding + row_width;
+        const player2_x = padding + 2 * row_width;
+        const middle_x = padding + row_width * 1.5;
+        const label_y = 40;
+        const sign_id_y = 80;
+        const sign_name_y = 120;
+        const sign_icon_y = 160;
+        const result_y = 200;
+        const score_y = 240;
+
+        ctx.font = "30px sans-serif";
+        ctx.fillStyle = "#FFFFFF";
+
+        // Player Row
+        ctx.fillText(player1_text, player1_x, label_y)
+        ctx.fillText(player2_text, player2_x, label_y)
+
+        // Action Id Row
+        ctx.fillText("Action:", label_x, sign_id_y);
+        ctx.fillText(p1_move, player1_x, sign_id_y);
+        ctx.fillText(p2_move, player2_x, sign_id_y);
+
+        // Action Name Row
+        ctx.fillText("Name:", label_x, sign_name_y);
+        ctx.fillText(sign_names[p1_move], player1_x, sign_name_y);
+        ctx.fillText(sign_names[p2_move], player2_x, sign_name_y);
+
+        // Emoji Row
+        ctx.fillText("Icon:", label_x, sign_icon_y);
+        ctx.fillText(sign_icons[p1_move], player1_x, sign_icon_y);
+        ctx.fillText(sign_icons[p2_move], player2_x, sign_icon_y);
+
+        // Result Row
+        ctx.fillText("Result:", label_x, result_y);
+        if (delta_reward === 1) {
+            ctx.fillText("Win", player1_x, result_y);
+        } else if (delta_reward === -1) {
+            ctx.fillText("Win", player2_x, result_y);
+        } else {
+            ctx.fillText("Tie", middle_x, result_y);
+        }
+
+        // Reward Row
+        ctx.fillText("Reward:", label_x, score_y);
+        ctx.fillText(state[0].reward, player1_x, score_y);
+        ctx.fillText(state[1].reward, player2_x, score_y);
+    }
+}

kaggle_environments/envs/rps/rps.json

@@ -0,0 +1,63 @@
+{
+  "name": "rps",
+  "title": "Rock Paper Scissors",
+  "description": "Repeated Rock Paper Scissors",
+  "version": "1.0.0",
+  "agents": [2],
+  "configuration": {
+    "signs": {
+      "description": "Number of choices each step (Rock = 0, Paper = 1, Scissors = 2, etc).",
+      "type": "integer",
+      "minimum": 3,
+      "maximum": 5,
+      "default": 3
+    },
+    "episodeSteps": {
+      "description": "Maximum number of steps the environment can run. Total is this number -1.",
+      "type": "integer",
+      "minimum": 2,
+      "default": 1000
+    },
+    "tieRewardThreshold": {
+      "description": "Minimum reward needed to achieve a win rather than a tie.",
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 1000,
+      "default": 20
+    },
+    "agentTimeout": {
+      "description": "Obsolete field kept for backwards compatibility, please use observation.remainingOverageTime.",
+      "type": "number",
+      "minimum": 0,
+      "default": 60
+    },
+    "actTimeout": 1
+  },
+  "reward": {
+    "description": "-1 = Lost, 0 = Draw, 1 = Won",
+    "enum": [-1, 0, 1],
+    "default": 0
+  },
+  "observation": {
+    "lastOpponentAction": {
+      "description": "Symbol returned by opponent last step. None on the first step.",
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 4
+    },
+    "remainingOverageTime": 60,
+    "reward": {
+      "description": "Current reward of the agent.",
+      "type": "integer",
+      "minimum": -999,
+      "maximum": 999,
+      "default": 0
+    }
+  },
+  "action": {
+    "description": "Choice of sign for the step (Rock = 0, Paper = 1, Scissors = 2, etc)",
+    "type": "integer",
+    "minimum": 0,
+    "maximum": 4
+  }
+}