kaggle-environments 1.17.5__py2.py3-none-any.whl → 1.17.7__py2.py3-none-any.whl

kaggle_environments/__init__.py

@@ -20,7 +20,7 @@ from .core import *
 from .main import http_request
 from . import errors
 
-__version__ = "1.17.5"
+__version__ = "1.17.7"
 
 __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
            "make", "register", "utils", "__version__",

kaggle_environments/core.py

@@ -579,7 +579,7 @@ class Environment:
         try:
             with StringIO() as out_buffer, StringIO() as err_buffer, redirect_stdout(out_buffer), redirect_stderr(err_buffer):
                 try:
-                    args = [structify(state), self]
+                    args = [structify(state), self, logs]
                     new_state = structify(self.interpreter(
                         *args[:self.interpreter.__code__.co_argcount]))
                     new_state[0].observation.step = (

kaggle_environments/envs/chess/chess.js

@@ -4045,14 +4045,14 @@ async function renderer(context) {
 
   // Create the Download PGN button
   let downloadButton = parent.querySelector("#copy-pgn");
-  if (!downloadButton) {
+  if (!downloadButton && environment.steps.length) {
     try {
       const board = environment.steps[0][0].observation.board;
       const info = environment.info;
       const agent1 = info?.TeamNames?.[0] || "Agent 1";
       const agent2 = info?.TeamNames?.[1] || "Agent 2";
       const game = new Chess();
-      let result = environment.rewards;
+      let result = environment.rewards ?? [];
       if (result.some((r) => r === undefined || r === null)) {
         result = result.map((r) => (r === undefined || r === null ? 0 : 1));
       }
@@ -4103,7 +4103,9 @@ async function renderer(context) {
       downloadButton.style.top = "10px";
       downloadButton.style.left = "10px";
       downloadButton.style.zIndex = 1;
-      parent.appendChild(downloadButton);
+      if(!environment.viewer) {
+        parent.appendChild(downloadButton);
+      }
 
       downloadButton.addEventListener("click", async () => {
         try {
@@ -4179,26 +4181,28 @@ async function renderer(context) {
     }
   }
   // Draw the team names and game status
-  const info = environment.info;
-  const agent1 = info?.TeamNames?.[0] || "Agent 1";
-  const agent2 = info?.TeamNames?.[1] || "Agent 2";
-  const firstGame = environment.steps[step][0].observation.mark == "white";
-  const fontSize = Math.round(0.33 * offset);
-  c.font = `${fontSize}px sans-serif`;
-  c.fillStyle = "#FFFFFF";
-  const agent1Reward = environment.steps[step][0].reward;
-  const agent2Reward = environment.steps[step][1].reward;
-  const charCount = agent1.length + agent2.length + 12;
-  const title = `${
-    firstGame ? "\u25A0" : "\u25A1"
-  }${agent1} (${agent1Reward}) vs ${
-    firstGame ? "\u25A1" : "\u25A0"
-  }${agent2} (${agent2Reward})`;
-  c.fillText(
-    title,
-    offset + 4 * squareSize - Math.floor((charCount * fontSize) / 4),
-    40
-  );
+  if (!environment.viewer) {
+    const info = environment.info;
+    const agent1 = info?.TeamNames?.[0] || "Agent 1";
+    const agent2 = info?.TeamNames?.[1] || "Agent 2";
+    const firstGame = environment.steps[step][0].observation.mark == "white";
+    const fontSize = Math.round(0.33 * offset);
+    c.font = `${fontSize}px sans-serif`;
+    c.fillStyle = "#FFFFFF";
+    const agent1Reward = environment.steps[step][0].reward;
+    const agent2Reward = environment.steps[step][1].reward;
+    const charCount = agent1.length + agent2.length + 12;
+    const title = `${
+      firstGame ? "\u25A0" : "\u25A1"
+    }${agent1} (${agent1Reward}) vs ${
+      firstGame ? "\u25A1" : "\u25A0"
+    }${agent2} (${agent2Reward})`;
+    c.fillText(
+      title,
+      offset + 4 * squareSize - Math.floor((charCount * fontSize) / 4),
+      40
+    );
+  }
 
   // Draw the Pieces
   const board = environment.steps[step][0].observation.board;

kaggle_environments/envs/open_spiel/games/chess/chess.js

@@ -1,5 +1,5 @@
 function renderer(options) {
-    const { environment, step, parent, interactive, isInteractive } = options;
+    const { environment, step, parent, width = 400, height = 400 } = options;
 
     // Chess-specific constants
     const DEFAULT_NUM_ROWS = 8;
@@ -28,6 +28,7 @@ function renderer(options) {
     let currentMessageBoxElement = typeof document !== 'undefined' ? document.getElementById('messageBox') : null;
     let currentRendererContainer = null;
     let currentTitleElement = null;
+    let squareSize = 50;
 
     function _showMessage(message, type = 'info', duration = 3000) {
         if (typeof document === 'undefined' || !document.body) return;
@@ -74,25 +75,30 @@ function renderer(options) {
             fontFamily: "'Inter', sans-serif"
         });
 
-        currentTitleElement = document.createElement('h1');
-        currentTitleElement.textContent = 'Chess';
-        // Identical styling to the Connect Four renderer's title
-        Object.assign(currentTitleElement.style, {
+        if (!environment.viewer) {
+          currentTitleElement = document.createElement('h1');
+          currentTitleElement.textContent = 'Chess';
+          // Identical styling to the Connect Four renderer's title
+          Object.assign(currentTitleElement.style, {
             fontSize: '1.875rem',
             fontWeight: 'bold',
             marginBottom: '1rem',
             textAlign: 'center',
             color: '#2563eb'
-        });
-        currentRendererContainer.appendChild(currentTitleElement);
+          });
+          currentRendererContainer.appendChild(currentTitleElement);
+        }
+        parentElementToClear.appendChild(currentRendererContainer);
 
+        const smallestParentEdge = Math.min(width, height);
+        squareSize = Math.floor(smallestParentEdge / DEFAULT_NUM_COLS);
         currentBoardElement = document.createElement('div');
         Object.assign(currentBoardElement.style, {
             display: 'grid',
-            gridTemplateColumns: `repeat(${cols}, 50px)`,
-            gridTemplateRows: `repeat(${rows}, 50px)`,
-            width: `${cols * 50}px`,
-            height: `${rows * 50}px`,
+            gridTemplateColumns: `repeat(${cols}, ${squareSize}px)`,
+            gridTemplateRows: `repeat(${rows}, ${squareSize}px)`,
+            width: `${cols * squareSize}px`,
+            height: `${rows * squareSize}px`,
             border: '2px solid #333'
         });
 
@@ -101,8 +107,8 @@ function renderer(options) {
                 const square = document.createElement('div');
                 square.id = `cell-${r}-${c}`;
                 Object.assign(square.style, {
-                    width: '50px',
-                    height: '50px',
+                    width: `${squareSize}px`,
+                    height: `${squareSize}px`,
                     backgroundColor: (r + c) % 2 === 0 ? LIGHT_SQUARE_COLOR : DARK_SQUARE_COLOR,
                     display: 'flex',
                     alignItems: 'center',
@@ -126,7 +132,9 @@ function renderer(options) {
             maxWidth: '90vw',
             marginTop: '20px'
         });
-        currentRendererContainer.appendChild(statusContainer);
+        if (!environment.viewer) {
+          currentRendererContainer.appendChild(statusContainer);
+        }
 
         currentStatusTextElement = document.createElement('p');
         Object.assign(currentStatusTextElement.style, {
@@ -144,8 +152,6 @@ function renderer(options) {
         });
         statusContainer.appendChild(currentWinnerTextElement);
 
-        parentElementToClear.appendChild(currentRendererContainer);
-
         if (typeof document !== 'undefined' && !document.body.hasAttribute('data-renderer-initialized')) {
             document.body.setAttribute('data-renderer-initialized', 'true');
         }
@@ -204,8 +210,9 @@ function renderer(options) {
         }
 
 
-        const { board, activeColor, is_terminal, winner } = gameStateToDisplay;
+        const { board, activeColor, isTerminal, winner } = gameStateToDisplay;
 
+        const pieceSize = Math.floor(squareSize * 0.9);
         for (let r_data = 0; r_data < displayRows; r_data++) {
             for (let c_data = 0; c_data < displayCols; c_data++) {
                 const piece = board[r_data][c_data];
@@ -213,8 +220,8 @@ function renderer(options) {
                 if (squareElement && piece) {
                     const pieceImg = document.createElement('img');
                     pieceImg.src = PIECE_SVG_URLS[piece];
-                    pieceImg.style.width = '45px';
-                    pieceImg.style.height = '45px';
+                    pieceImg.style.width = `${pieceSize}px`;
+                    pieceImg.style.height = `${pieceSize}px`;
                     squareElement.appendChild(pieceImg);
                 }
             }
@@ -222,7 +229,7 @@ function renderer(options) {
 
         currentStatusTextElement.innerHTML = '';
         currentWinnerTextElement.innerHTML = '';
-        if (is_terminal) {
+        if (isTerminal) {
             currentStatusTextElement.textContent = "Game Over!";
             if (winner) {
                  if (String(winner).toLowerCase() === 'draw') {
@@ -235,8 +242,8 @@ function renderer(options) {
                  currentWinnerTextElement.textContent = "Game ended.";
             }
         } else {
-            const playerColor = String(activeColor).toLowerCase() === 'w' ? 'White' : 'Black';
-            currentStatusTextElement.innerHTML = `Current Player: <span style="font-weight: bold;">${playerColor}</span>`;
+          const playerColor = String(activeColor).toLowerCase() === 'w' ? 'White' : 'Black';
+          currentStatusTextElement.innerHTML = `Current Player: <span style="font-weight: bold;">${playerColor}</span>`;
         }
     }
 
@@ -273,15 +280,15 @@ function renderer(options) {
 
     let gameSpecificState = null;
 
-    if (observationForRenderer && typeof observationForRenderer.observation_string === 'string' && observationForRenderer.observation_string.trim() !== '') {
+    if (observationForRenderer && typeof observationForRenderer.observationString === 'string' && observationForRenderer.observationString.trim() !== '') {
         try {
-            const fen = observationForRenderer.observation_string;
+            const fen = observationForRenderer.observationString;
             const parsedFen = _parseFen(fen);
             if (parsedFen) {
-                // Assuming `is_terminal` and `winner` are provided in the top-level observation
+                // Assuming `isTerminal` and `winner` are provided in the top-level observation
                 gameSpecificState = { 
                     ...parsedFen,
-                    is_terminal: observationForRenderer.is_terminal,
+                    isTerminal: observationForRenderer.isTerminal,
                     winner: observationForRenderer.winner
                 };
             }
@@ -291,4 +298,4 @@ function renderer(options) {
     }
 
     _renderBoardDisplay(gameSpecificState, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
-}
+}

kaggle_environments/envs/open_spiel/games/connect_four/connect_four.js

@@ -264,9 +264,9 @@ function renderer(options) {
 
     let gameSpecificState = null;
 
-    if (observationForRenderer && typeof observationForRenderer.observation_string === 'string' && observationForRenderer.observation_string.trim() !== '') {
+    if (observationForRenderer && typeof observationForRenderer.observationString === 'string' && observationForRenderer.observationString.trim() !== '') {
         try {
-            gameSpecificState = JSON.parse(observationForRenderer.observation_string);
+            gameSpecificState = JSON.parse(observationForRenderer.observationString);
         } catch (e) {
             _showMessage("Error: Corrupted game state (obs_string).", 'error');
         }
@@ -280,17 +280,5 @@ function renderer(options) {
         }
     }
     
-    if (!gameSpecificState && observationForRenderer && 
-        Array.isArray(observationForRenderer.board) && 
-        typeof observationForRenderer.current_player !== 'undefined'
-       ) {
-        if( (observationForRenderer.board.length === DEFAULT_NUM_ROWS &&
-             (observationForRenderer.board.length === 0 || 
-              (Array.isArray(observationForRenderer.board[0]) && observationForRenderer.board[0].length === DEFAULT_NUM_COLS)))
-          ){
-            gameSpecificState = observationForRenderer;
-        }
-    }
-    
     _renderBoardDisplay_svg(gameSpecificState, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
 }

kaggle_environments/envs/open_spiel/games/go/go.js

@@ -410,9 +410,9 @@ function renderer(options) {
                 let gameState = null;
                 
                 // Try to parse game state from observation
-                if (gameMasterAgent.observation.observation_string) {
+                if (gameMasterAgent.observation.observationString) {
                     try {
-                        gameState = JSON.parse(gameMasterAgent.observation.observation_string);
+                        gameState = JSON.parse(gameMasterAgent.observation.observationString);
                     } catch (e) {}
                 }
                 
@@ -461,9 +461,9 @@ function renderer(options) {
     const observationForRenderer = gameMasterAgent.observation;
     let gameSpecificState = null;
 
-    if (observationForRenderer && typeof observationForRenderer.observation_string === 'string' && observationForRenderer.observation_string.trim() !== '') {
+    if (observationForRenderer && typeof observationForRenderer.observationString === 'string' && observationForRenderer.observationString.trim() !== '') {
         try {
-            gameSpecificState = JSON.parse(observationForRenderer.observation_string);
+            gameSpecificState = JSON.parse(observationForRenderer.observationString);
         } catch (e) {
             _showMessage("Error: Corrupted game state (obs_string).", 'error');
         }

kaggle_environments/envs/open_spiel/games/tic_tac_toe/tic_tac_toe.js

@@ -283,9 +283,9 @@ function renderer(options) {
         let boardArray = null;
         let currentPlayerForState = null;
 
-        if (typeof observationForBoardState.observation_string === 'string' && observationForBoardState.observation_string.trim().startsWith('{')) {
+        if (typeof observationForBoardState.observationString === 'string' && observationForBoardState.observationString.trim().startsWith('{')) {
             try {
-                const parsedState = JSON.parse(observationForBoardState.observation_string);
+                const parsedState = JSON.parse(observationForBoardState.observationString);
                 if (parsedState && Array.isArray(parsedState.board)) {
                     boardArray = parsedState.board;
                 }
@@ -294,7 +294,7 @@ function renderer(options) {
                 }
             } catch (e) {
                 _showMessage("Error parsing game state from observation string.", 'error');
-                console.error("Failed to parse observation_string JSON:", e);
+                console.error("Failed to parse observation string JSON:", e);
             }
         }
 
@@ -306,8 +306,8 @@ function renderer(options) {
         }
 
         if (!currentPlayerForState) {
-             if (observationForBoardState.current_player === 0) { currentPlayerForState = 'x'; }
-             else if (observationForBoardState.current_player === 1) { currentPlayerForState = 'o'; }
+             if (observationForBoardState.currentPlayer === 0) { currentPlayerForState = 'x'; }
+             else if (observationForBoardState.currentPlayer === 1) { currentPlayerForState = 'o'; }
         }
 
         const isTerminal = !!observationForBoardState.is_terminal;
@@ -320,7 +320,7 @@ function renderer(options) {
                 else if (finalRewards[1] === 1.0) winnerForState = 'o';
                 else if (finalRewards[0] === 0.0 && finalRewards[1] === 0.0) winnerForState = 'draw';
             }
-            if (observationForBoardState.current_player === -2 && winnerForState === null) {
+            if (observationForBoardState.currentPlayer === -2 && winnerForState === null) {
                 winnerForState = 'draw';
             }
         }

kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker.js

@@ -247,8 +247,8 @@ function renderer(options) {
         // --- Observation Extraction & Merging ---
         let obsP0 = null, obsP1 = null;
         try {
-            obsP0 = JSON.parse(currentStepAgents[0].observation.observation_string);
-            obsP1 = JSON.parse(currentStepAgents[1].observation.observation_string);
+            obsP0 = JSON.parse(currentStepAgents[0].observation.observationString);
+            obsP1 = JSON.parse(currentStepAgents[1].observation.observationString);
         } catch (e) {
             defaultUIData.gameMessage = "Error parsing observation JSON.";
             return defaultUIData;

kaggle_environments/envs/open_spiel/open_spiel.py

@@ -14,6 +14,13 @@ from kaggle_environments import utils
 import numpy as np
 import pyspiel
 
+ERROR = "ERROR"
+DONE = "DONE"
+INACTIVE = "INACTIVE"
+ACTIVE = "ACTIVE"
+TIMEOUT = "TIMEOUT"
+INVALID = "INVALID"
+
 _log = logging.getLogger(__name__) 
 _log.setLevel(logging.INFO) 
 _handler = logging.StreamHandler(sys.stdout) 
@@ -35,8 +42,16 @@ for proxy_file in GAMES_DIR.glob("**/*_proxy.py"):
 
 
 # --- Constants ---
-DEFAULT_ACT_TIMEOUT = 5
-DEFAULT_RUN_TIMEOUT = 1200
+# TODO(jhtschultz): Make this configurable per-game. For instance, in poker, a
+# invalid action would likely result in a fold, forfeiting the player's
+# contribution to the pot.
+DEFAULT_INVALID_ACTION_REWARD = -1
+
+# Can be used by agents to signal an internal error to the environement.
+AGENT_ERROR_ACTION = -2
+
+DEFAULT_ACT_TIMEOUT = 60 * 60 # sixty minutes
+DEFAULT_RUN_TIMEOUT = 60 * 60 * 30 # thirty hours
 # Buffer in addition to max game length to account for timeouts, retrys, etc.
 DEFAULT_STEP_BUFFER = 100
 # TODO(jhtschultz): Add individual game descriptions.
@@ -65,6 +80,11 @@ CONFIGURATION_SPEC_TEMPLATE = {
         "type": "object",
         "default": {}
     },
+    "metadata": {
+        "description": "Arbitrary metadata.",
+        "type": "object",
+        "default": {}
+    },
 }
 
 OBSERVATION_SPEC_TEMPLATE = {
@@ -77,44 +97,51 @@ OBSERVATION_SPEC_TEMPLATE = {
             "description": "Short name of the OpenSpiel game.",
             "type": "string"
         },
-        "observation_string": {
+        "observationString": {
             "description": "String representation of state.",
             "type": "string"
         },
-        # TODO(jhtschultz): Use camel case for consistency with spec, or snake
-        # case for consistency with pyspiel?
-        "legal_actions": {
+        "legalActions": {
             "description": "List of OpenSpiel legal action integers.",
             "type": "array",
             "items": {
                 "type": "integer"
             }
         },
-        "legal_action_strings": {
+        "legalActionStrings": {
             "description": "List of OpenSpiel legal actions strings.",
             "type": "array",
             "items": {
                 "type": "string"
             }
         },
-        "current_player": {
+        "currentPlayer": {
             "description": "ID of player whose turn it is.",
             "type": "integer"
         },
-        "player_id": {
+        "playerId": {
             "description": "ID of the agent receiving this observation.",
             "type": "integer"
         },
-        "is_terminal": {
+        "isTerminal": {
             "description": "Boolean indicating game end.",
             "type": "boolean"
         },
+        "serializedGameAndState": {
+            "description": "Enables reconstructing the Game and State objects.",
+            "type": "string"
+        },
         "remainingOverageTime": 60,
         "step": 0
     },
     "default": {}
 }
 
+ACTION_SPEC_TEMPLATE = {
+    "description": "Action object MUST contain a field `submission`, and MAY contain arbitrary additional information.",
+    "type": "object",
+    "default": {"submission": -1}
+}
 
 ENV_SPEC_TEMPLATE = {
     "name": "PLACEHOLDER_NAME",
@@ -124,11 +151,7 @@ ENV_SPEC_TEMPLATE = {
     "agents": ["PLACEHOLDER_NUM_AGENTS"],
     "configuration": CONFIGURATION_SPEC_TEMPLATE,
     "observation": OBSERVATION_SPEC_TEMPLATE,
-    "action": {
-        "type": ["integer"],
-        "minimum": -1,
-        "default": -1
-    },
+    "action": ACTION_SPEC_TEMPLATE,
     "reward": {
         "type": ["number"],
         "default": 0.0
@@ -141,6 +164,7 @@ ENV_SPEC_TEMPLATE = {
 def interpreter(
   state: list[utils.Struct],
   env: core.Environment,
+  logs: list[dict[str, Any]],
 ) -> list[utils.Struct]:
   """Updates environment using player responses and returns new observations."""
   kaggle_state = state  # Not to be confused with OpenSpiel state.
@@ -157,18 +181,14 @@ def interpreter(
     env.os_game = pyspiel.load_game(game_string)
   if not hasattr(env, 'os_state'):
     env.os_state = env.os_game.new_initial_state()
-  if "state_history" not in env.info:
-    env.info['state_history'] = [str(env.os_state)]
-    env.info['action_history'] = []
+  if "stateHistory" not in env.info:
+    env.info['stateHistory'] = [str(env.os_state)]
+    env.info['actionHistory'] = []
+    env.info['moveDurations'] = []
   
   os_game = env.os_game
   os_state = env.os_state
   num_players = os_game.num_players()
-  statuses = [
-      kaggle_state[player_id].status for player_id in range(num_players)
-  ]
-  if not any(status == "ACTIVE" for status in statuses):
-    raise ValueError("Environment not done and no active agents.")
 
   # TODO(jhtschultz): Test reset behavior.
   is_initial_step = len(env.steps) == 1
@@ -178,26 +198,36 @@ def interpreter(
 
   # --- Apply agent action ---
   acting_agent = os_state.current_player()
-  action_submitted = None
-  action_applied = None
+  action_submitted: int | None = None
+  action_submitted_to_string: str | None = None
+  action_applied: int | None = None
+  move_duration: float | None = None
   if is_initial_step:
     pass
   elif 0 <= acting_agent < num_players:
-    if kaggle_state[acting_agent].status != "ACTIVE":
+    if kaggle_state[acting_agent]["status"] != "ACTIVE":
       pass
     else:
-      action_submitted = kaggle_state[acting_agent].action
+      action_submitted = kaggle_state[acting_agent]["action"]["submission"]
       if action_submitted in os_state.legal_actions():
-        try:
-          os_state.apply_action(action_submitted)
-          action_applied = action_submitted
-          env.info['action_history'].append(str(action_applied))
-          env.info['state_history'].append(str(os_state))
-        except Exception as e:  # pylint: disable=broad-exception-caught
-          _log.debug(e)
-          kaggle_state[acting_agent].status = "ERROR"
+        action_submitted_to_string = os_state.action_to_string(action_submitted)
+        os_state.apply_action(action_submitted)
+        action_applied = action_submitted
+        env.info['actionHistory'].append(str(action_applied))
+        env.info['stateHistory'].append(str(os_state))
+      elif action_submitted == AGENT_ERROR_ACTION:
+        kaggle_state[acting_agent]["status"] = "ERROR"
       else:
-        kaggle_state[acting_agent].status = "INVALID"
+        kaggle_state[acting_agent]["status"] = "INVALID"
+      try:
+        if "duration" in logs[acting_agent]:
+          move_duration = round(logs[acting_agent]["duration"], 3)
+          env.info["moveDurations"].append(move_duration)
+        else:
+          env.info["moveDurations"].append(None)
+      except Exception:
+        pass  # No logs when stepping the env manually.
+
   elif acting_agent == pyspiel.PlayerId.SIMULTANEOUS:
     raise NotImplementedError
   elif acting_agent == pyspiel.PlayerId.TERMINAL:
@@ -212,14 +242,40 @@ def interpreter(
     outcomes, probs = zip(*os_state.chance_outcomes())
     chance_action = np.random.choice(outcomes, p=probs)
     os_state.apply_action(chance_action)
-    env.info['action_history'].append(str(chance_action))
-    env.info['state_history'].append(str(os_state))
+    env.info['actionHistory'].append(str(chance_action))
+    env.info['stateHistory'].append(str(os_state))
 
   # --- Update agent states ---
+  agent_error = any(
+    kaggle_state[player_id]["status"] in ["TIMEOUT", "ERROR"]
+    for player_id in range(num_players)
+  )
+  if agent_error:
+    _log.info("AGENT ERROR DETECTED")
+  
+  invalid_action = any(
+    kaggle_state[player_id]["status"] == "INVALID"
+    for player_id in range(num_players)
+  )
+  if invalid_action:
+    _log.info("INVALID ACTION DETECTED")
+
+  status: str | None = None
   for player_id, agent_state in enumerate(kaggle_state):
     reward = None
-    if agent_state.status in ["TIMEOUT", "ERROR", "INVALID"]:
-      status = agent_state.status
+    if agent_error:
+      # Set all agent statuses to ERROR in order not to score episode. Preserve
+      # TIMEOUT which has the same effect.
+      if agent_state["status"] == "TIMEOUT":
+        status = "TIMEOUT"
+      else:
+        status = "ERROR"
+    elif invalid_action:
+      if agent_state["status"] == "INVALID":
+        reward = DEFAULT_INVALID_ACTION_REWARD
+      else:
+        reward = -DEFAULT_INVALID_ACTION_REWARD
+      status = "DONE"
     elif os_state.is_terminal():
       status = "DONE"
       reward = os_state.returns()[player_id]
@@ -231,30 +287,39 @@ def interpreter(
         )
     else:
       status = "INACTIVE"
+    assert status is not None
 
     info_dict = {}
     if acting_agent == player_id:
-      info_dict["action_submitted"] = action_submitted
-      info_dict["action_applied"] = action_applied
+      info_dict["actionSubmitted"] = action_submitted
+      info_dict["actionSubmittedToString"] = action_submitted_to_string
+      info_dict["actionApplied"] = action_applied
+      info_dict["timeTaken"] = move_duration
+      info_dict[
+        "agentSelfReportedStatus"
+      ] = kaggle_state[acting_agent]["action"].get("status") if kaggle_state[acting_agent]["action"] else "unknown"
 
     obs_update_dict = {
-      "observation_string": os_state.observation_string(player_id),
-      "legal_actions": os_state.legal_actions(player_id),
-      "legal_action_strings": [
+      "observationString": os_state.observation_string(player_id),
+      "legalActions": os_state.legal_actions(player_id),
+      "legalActionStrings": [
           os_state.action_to_string(action) for action
           in os_state.legal_actions(player_id)
       ],
-      "current_player": os_state.current_player(),
-      "is_terminal": os_state.is_terminal(),
-      "player_id": player_id,
+      "currentPlayer": os_state.current_player(),
+      "playerId": player_id,
+      "isTerminal": os_state.is_terminal(),
+      "serializedGameAndState": pyspiel.serialize_game_and_state(
+          os_game, os_state
+      ),
     }
 
     # Apply updates
     for k, v in obs_update_dict.items():
       setattr(agent_state.observation, k, v)
-    agent_state.reward = reward
-    agent_state.info = info_dict
-    agent_state.status = status
+    agent_state["reward"] = reward
+    agent_state["info"] = info_dict
+    agent_state["status"] = status
 
   return kaggle_state
 
@@ -295,14 +360,14 @@ function renderer(context) {
     // Try to get obs_string from game_master of current step
     if (currentStepData[agentObsIndex] && 
         currentStepData[agentObsIndex].observation && 
-        typeof currentStepData[agentObsIndex].observation.observation_string === 'string') {
-        obsString = currentStepData[agentObsIndex].observation.observation_string;
+        typeof currentStepData[agentObsIndex].observation.observationString === 'string') {
+        obsString = currentStepData[agentObsIndex].observation.observationString;
     } 
     // Fallback to initial step if current is unavailable (e.g. very first render call)
     else if (step === 0 && environment.steps[0] && environment.steps[0][agentObsIndex] && 
              environment.steps[0][agentObsIndex].observation &&
-             typeof environment.steps[0][agentObsIndex].observation.observation_string === 'string') {
-        obsString = environment.steps[0][agentObsIndex].observation.observation_string;
+             typeof environment.steps[0][agentObsIndex].observation.observationString === 'string') {
+        obsString = environment.steps[0][agentObsIndex].observation.observationString;
     }
 
     const pre = document.createElement("pre");
@@ -349,11 +414,11 @@ def random_agent(
 ) -> int:
   """A built-in random agent specifically for OpenSpiel environments."""
   del configuration
-  legal_actions = observation.get("legal_actions")
+  legal_actions = observation.get("legalActions")
   if not legal_actions:
     return None
   action = random.choice(legal_actions)
-  return int(action)
+  return {"submission": int(action)}
 
 
 AGENT_REGISTRY = {
@@ -380,14 +445,13 @@ def _build_env(game_string: str) -> dict[str, Any]:
   env_spec["title"] = f"Open Spiel: {short_name}"
   env_spec["agents"] = [game.num_players()]
 
-  env_config = copy.deepcopy(CONFIGURATION_SPEC_TEMPLATE)
-  env_spec["configuration"] = env_config
+  env_config = env_spec["configuration"]
   env_config["episodeSteps"] = game.max_history_length() + DEFAULT_STEP_BUFFER
   env_config["openSpielGameString"]["default"] = str(game)
   env_config["openSpielGameName"]["default"] = short_name
+  env_config["openSpielGameParameters"]["default"] = game.get_parameters()
 
-  env_obs = copy.deepcopy(OBSERVATION_SPEC_TEMPLATE)
-  env_spec["observation"] = env_obs
+  env_obs = env_spec["observation"]
   env_obs["properties"]["openSpielGameString"]["default"] = str(game)
   env_obs["properties"]["openSpielGameName"]["default"] = short_name
 

kaggle_environments/envs/open_spiel/test_open_spiel.py

@@ -19,15 +19,78 @@ class OpenSpielEnvTest(absltest.TestCase):
     )
     self.assertTrue(len(envs) > _REGISTERED_GAMES_THRESHOLD)
 
-  def test_tic_tac_toe_playthrough(self):
+  def test_tic_tac_toe_agent_playthrough(self):
     envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
-    print(envs)
     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"])
+
 
 if __name__ == '__main__':
-  absltest.main()
+  absltest.main()

kaggle_environments/static/player.html

@@ -199,12 +199,7 @@
           ${processing && h`<${Processing} />`}
         </div>`;
       })`
-        background-color: #000b2a;
-        background-image: radial-gradient(
-          circle closest-side,
-          #000b49,
-          #000b2a
-        );
+        background-color: #1C1D20;
         display: flex;
         flex: 1;
         overflow: hidden;
@@ -242,7 +237,7 @@
               </ul>`)}
         </div>`;
       })`
-        background-color: #000b2a;
+        background-color: #1C1D20;
         font-family: sans-serif;
         font-size: 14px;
         height: 48px;
@@ -442,7 +437,6 @@
       })`
         align-items: center;
         background: #212121;
-        border: 4px solid #212121;
         box-sizing: border-box;
         display: flex;
         flex-direction: column;
@@ -450,6 +444,10 @@
         justify-content: center;
         position: relative;
         width: 100%;
+
+        &:not(.no-border) {
+          border: 4px solid #212121;
+        }
       `;
 
       const App = () => {
@@ -545,7 +543,7 @@
             // Initialize context with window.kaggle.
             updateContext(window.kaggle || {});
 
-            if (window.kaggle.playing) {
+            if (window.kaggle?.playing) {
                 play(true);
             }
 
@@ -556,10 +554,49 @@
                 // Ensure the environment names match before updating.
                 try {
                   if (
-                    event.data.environment.name ==
-                    contextRef.current.environment.name
+                    event.data.environment?.name == contextRef.current.environment.name ||
+                    event.data.environment?.name && !contextRef.current.environment.name ||
+                    event.data.environment?.loading !== contextRef.current.environment.loading
                   ) {
-                    updateContext(event.data);
+                    const nextContext = {
+                      ...event.data,
+                      environment: {
+                        ...event.data.environment,
+                        steps: event.data.environment?.steps ?? []
+                      }
+                    };
+                    window.kaggle = nextContext;
+                    if (!window.kaggle.renderer) {
+                      window.kaggle.renderer = window.renderer;
+                    }
+                    updateContext(nextContext);
+                  }
+                  if (event.data.setSteps) {
+                    const nextContext = {
+                      ...(window.kaggle ?? {}),
+                      environment: {
+                        ...(window.kaggle?.environment ?? {}),
+                        steps: event.data.setSteps
+                      }
+                    }
+                    window.kaggle = nextContext;
+                    if (!window.kaggle.renderer) {
+                      window.kaggle.renderer = window.renderer;
+                    }
+                    updateContext(nextContext)
+                  }
+
+                  // Side load the renderer script if it is specified by the post message event and not already loaded.
+                  const renderScriptId = 'rendererScript'
+                  if (event.data.environment?.rendererUrl && !document.querySelector(`#${renderScriptId}`)) {
+                    window.rendererUrl = event.data.environment?.rendererUrl;
+                    const script = document.createElement('script');
+                    script.id = renderScriptId;
+                    script.onload = () => {
+                      window.kaggle.renderer = window.renderer;
+                    };
+                    script.src = window.rendererUrl;
+                    document.body.appendChild(script);
                   }
                 } catch {}
               },
@@ -674,7 +711,7 @@
 
         return h`
           <${Context.Provider} value=${contextRef.current}>
-            <${Player} />
+            <${Player} className="${contextRef.current.environment.viewer ? 'no-border' : ''}" />
           <//>`;
       };
 

{kaggle_environments-1.17.5.dist-info → kaggle_environments-1.17.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 1.17.5
+Version: 1.17.7
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle

{kaggle_environments-1.17.5.dist-info → kaggle_environments-1.17.7.dist-info}/RECORD

@@ -1,14 +1,14 @@
-kaggle_environments/__init__.py,sha256=NFCwapaNv9MXVBKTTm7AgYLswbUKb7RPELyxidmJqxs,2175
+kaggle_environments/__init__.py,sha256=GzrKQBWH-dKbhfDK2K0GYTnHxw31m8DhnbzcHNMRn7c,2175
 kaggle_environments/agent.py,sha256=j9rLnCK_Gy0eRIuvlJ9vcMh3vxn-Wvu-pjCpannOolc,6703
 kaggle_environments/api.py,sha256=eLBKqr11Ku4tdsMUdUqy74FIVEA_hdV3_QUpX84x3Z8,798
-kaggle_environments/core.py,sha256=IrEkN9cIA2djBAxI8Sz1GRpGNKjhqbnBdV6irAeTm8Q,27851
+kaggle_environments/core.py,sha256=Ense_M-2rP4KmVeuKFjM0NQ8M6ucUZTbhwrGekyR9LY,27857
 kaggle_environments/errors.py,sha256=SzKjkZP7pJbf9g0GDjGq4XG194hCQXLMwrlMCcm7Ai8,3336
 kaggle_environments/helpers.py,sha256=xkOMXaOMifYHHstDZo8bexk-Qq9suPM7Gkfi2JbXu8M,10627
 kaggle_environments/main.py,sha256=10wtcEFcGIjdOd9AEps5WOAwslc6Wsx3eZ43LXJa8jE,11705
 kaggle_environments/schemas.json,sha256=zGzLyhqPdH6QQ0d48SrP5LKbvupprrWvgfQBerLqmhw,3307
 kaggle_environments/status_codes.json,sha256=6a8HuS_Vth95W0f2fov21QLdRfA3KbizUvjKmJhYtBc,995
 kaggle_environments/utils.py,sha256=FcI17PA4QK2-hyNp0dryS0TQ2pFlH9K19zDUMmuF4-E,5713
-kaggle_environments/envs/chess/chess.js,sha256=sZBnS1RKkP1kss2FrxMI6ceurjnlAA4yUJU_jfkgCZw,274447
+kaggle_environments/envs/chess/chess.js,sha256=QYA1arYF_qOfchN8HHQ4hL5z3C9XeT5hYigT75CgvKo,274596
 kaggle_environments/envs/chess/chess.json,sha256=fc8Qa1IHWmYbiEgorXIjMj2JmqP95x_reqFe6Mon2Wk,1692
 kaggle_environments/envs/chess/chess.py,sha256=41LMA8--APQOhl6aeWgJvkSaRBjAch2FgS7ELIoOT3w,245361
 kaggle_environments/envs/chess/test_chess.py,sha256=ayZEIWRSD3D6BqhJv0q_M5a-j8-pMm8kb4ACAW-DhBE,1748
@@ -191,24 +191,24 @@ kaggle_environments/envs/mab/mab.py,sha256=bkSIxkstS98Vr3eOA9kxQkseDqa1MlG2Egfze
 kaggle_environments/envs/open_spiel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kaggle_environments/envs/open_spiel/html_playthrough_generator.py,sha256=qzvi9wMZKz1WfpaIpBxP5LPlVYKAk9npEtdKLXYHMWo,950
 kaggle_environments/envs/open_spiel/observation.py,sha256=yrJ_iZ9sBUTB6YOyEpKNwYiQEWmsPPtaDYtL4zsw1Ko,4834
-kaggle_environments/envs/open_spiel/open_spiel.py,sha256=kJDOApsaSPJ53MVcG9vKXuMW-MJNx093gn32vj2TFKw,15304
+kaggle_environments/envs/open_spiel/open_spiel.py,sha256=HzN1ngjeOqxLoetI1g56PdlioRY26VoCJMQpbD4S-Vk,17517
 kaggle_environments/envs/open_spiel/proxy.py,sha256=8Shane4KWYKvbP9nV3l8VQfAFOfFSUrS78h_4xQthVM,4881
 kaggle_environments/envs/open_spiel/proxy_test.py,sha256=QkmRo_uS0DgDDm2pbU2vwal5KOMCWKw92rC2_g3MziM,1837
-kaggle_environments/envs/open_spiel/test_open_spiel.py,sha256=YhmEyyxc68JmjzmsdoIUEO-ds1O8HiICsiCKkMFth5s,1033
+kaggle_environments/envs/open_spiel/test_open_spiel.py,sha256=MwyjH-e00-3SP8_r10drYTFvplacbo0cDCI0XKtE4wU,3596
 kaggle_environments/envs/open_spiel/games/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaggle_environments/envs/open_spiel/games/chess/chess.js,sha256=XoX0R7zYqPGh4EYnxUJCXPBb44fbLAVsDLQ8p9oibhA,12547
+kaggle_environments/envs/open_spiel/games/chess/chess.js,sha256=e5QFnMCaNXMRskO0qbdhy7q0W3ov9yFGmvfpC48Dd6k,12931
 kaggle_environments/envs/open_spiel/games/connect_four/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaggle_environments/envs/open_spiel/games/connect_four/connect_four.js,sha256=sT8rVfjkyY_DUQSHpZUP7I7QEoJwa7Oq9H82wD7vnbQ,15440
+kaggle_environments/envs/open_spiel/games/connect_four/connect_four.js,sha256=iO74ar3Hh64VYEx9v3eysgrPU-Mcokl9dkFxie6uISg,14893
 kaggle_environments/envs/open_spiel/games/connect_four/connect_four_proxy.py,sha256=2otG99felDYhNhWpsadbM9YUaHtrXqhV1GFNEHhuPwA,2348
 kaggle_environments/envs/open_spiel/games/connect_four/connect_four_proxy_test.py,sha256=vYn-QDPyRRigL8XdaHMN4FTO9zc1T9YB096HDGQH_T4,1870
 kaggle_environments/envs/open_spiel/games/go/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaggle_environments/envs/open_spiel/games/go/go.js,sha256=cmwq64L77iVjYJpMKCKaRDfNXDaO7R7PJT78xu60Qwg,23756
+kaggle_environments/envs/open_spiel/games/go/go.js,sha256=SWUPrnQCMBlDjUiKTgVn9LeTUM85YbR10JRrq3ddw14,23751
 kaggle_environments/envs/open_spiel/games/go/go_proxy.py,sha256=f5jaS6O7mngq8LHRkxfyf_M57BTb_3yxb7FjELR2aqg,3146
 kaggle_environments/envs/open_spiel/games/tic_tac_toe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaggle_environments/envs/open_spiel/games/tic_tac_toe/tic_tac_toe.js,sha256=_W7zGtpnKlqw3ghZspwwXYe3sdOdL3h_yYzo9wHAnzA,17345
+kaggle_environments/envs/open_spiel/games/tic_tac_toe/tic_tac_toe.js,sha256=OD7FbhhOqmL8OC7UqPt0S9znwcUY4YTuhRCdsBd3ALE,17339
 kaggle_environments/envs/open_spiel/games/tic_tac_toe/tic_tac_toe_proxy.py,sha256=3Imu-0-lMNUF9FQQ4V3Y3NnkS-9_-IhbSprlWgecTLA,2771
 kaggle_environments/envs/open_spiel/games/universal_poker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker.js,sha256=eDtjUYtt1a26zQXOk-BhgcIsYfTCD0OLSZikC2Z5YKQ,21822
+kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker.js,sha256=7QQlSITZjzEJbnS930Ht2MzDSMBulhU59HaSwnKvf4g,21820
 kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker_proxy.py,sha256=WKFgbdES3JGyL5Su5wi6jE8yrSJaBCvXL3z_IgmWJLs,5219
 kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker_proxy_test.py,sha256=YHWaVVO8fA9NKrTMM7VpAH_U94yh5d0Z-gNhXX4A7sA,1531
 kaggle_environments/envs/rps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -223,10 +223,10 @@ kaggle_environments/envs/tictactoe/test_tictactoe.py,sha256=6CgQbRz-yxNoMfD5tzmC
 kaggle_environments/envs/tictactoe/tictactoe.js,sha256=NZDT-oSG0a6a-rso9Ldh9qkJwVrxrAsjKUC3_tJu3tw,8002
 kaggle_environments/envs/tictactoe/tictactoe.json,sha256=zMXZ8-fpT7FBhzz2FFBvRLn4XwtngjEqOieMvI6cCj8,1121
 kaggle_environments/envs/tictactoe/tictactoe.py,sha256=uq3sTHWNMg0dxX2v9pTbJAKM7fwerxQt7OQjCX96m-Y,3657
-kaggle_environments/static/player.html,sha256=XyVoe0XxMa2MO1fTDY_rjyjzPN-JZgbVwJIDoLSnlw0,23016
-kaggle_environments-1.17.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-1.17.5.dist-info/METADATA,sha256=6E3MWC0cXRLQJrMBbBdxnmSCNBTYIM49xS68wmIYTzE,10955
-kaggle_environments-1.17.5.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-kaggle_environments-1.17.5.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
-kaggle_environments-1.17.5.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
-kaggle_environments-1.17.5.dist-info/RECORD,,
+kaggle_environments/static/player.html,sha256=TTxN-EU7_KCNIVDX4E4TrZ61FRWkGUDHMSbnUYsQSvg,24975
+kaggle_environments-1.17.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kaggle_environments-1.17.7.dist-info/METADATA,sha256=va0iBjyCpXB4osbBWVdDGdhgUUig8nPEIR540OJU7vM,10955
+kaggle_environments-1.17.7.dist-info/WHEEL,sha256=7wAbZI8A1UjN-j4-aYf66qBxOZ0Ioy0QNykkY5NcGJo,109
+kaggle_environments-1.17.7.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
+kaggle_environments-1.17.7.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
+kaggle_environments-1.17.7.dist-info/RECORD,,

{kaggle_environments-1.17.5.dist-info → kaggle_environments-1.17.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any