kaggle-environments 1.17.6__py2.py3-none-any.whl → 1.17.8__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.6"
+__version__ = "1.17.8"
 
 __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
            "make", "register", "utils", "__version__",

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,14 +152,39 @@ 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');
         }
         return true;
     }
 
+    // White is in position 1, Black is in position 0
+    function _getTeamNameForColor(color, teamNames) {
+        if (!teamNames || teamNames.length < 2) return null;
+        return color.toLowerCase() === 'white' ? teamNames[1] : teamNames[0];
+    }
+
+    function _deriveWinnerFromRewards(currentStepAgents, teamNames) {
+        if (!currentStepAgents || currentStepAgents.length < 2) return null;
+        
+        const player0Reward = currentStepAgents[0].reward;
+        const player1Reward = currentStepAgents[1].reward;
+        
+        if (player0Reward === player1Reward) {
+            return 'draw';
+        }
+        
+        const winnerPlayerIndex = player0Reward === 1 ? 0 : 1;
+        const color = winnerPlayerIndex === 0 ? 'Black' : 'White';
+        
+        if (teamNames) {
+            const teamName = _getTeamNameForColor(color, teamNames);
+            return `${color} (${teamName})`;
+        }
+        
+        return color.toLowerCase();
+    }
+
     function _parseFen(fen) {
         if (!fen || typeof fen !== 'string') return null;
 
@@ -204,8 +237,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 +247,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,21 +256,23 @@ function renderer(options) {
 
         currentStatusTextElement.innerHTML = '';
         currentWinnerTextElement.innerHTML = '';
-        if (is_terminal) {
+        if (isTerminal) {
             currentStatusTextElement.textContent = "Game Over!";
             if (winner) {
                  if (String(winner).toLowerCase() === 'draw') {
                     currentWinnerTextElement.textContent = "It's a Draw!";
                  } else {
-                    const winnerColor = String(winner).toLowerCase() === 'white' ? 'White' : 'Black';
-                    currentWinnerTextElement.innerHTML = `Winner: <span style="font-weight: bold;">${winnerColor}</span>`;
+                    currentWinnerTextElement.innerHTML = `Winner: <span style="font-weight: bold;">${winner}</span>`;
                  }
             } else {
                  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';
+          const teamName = _getTeamNameForColor(playerColor, environment.info?.TeamNames);
+          const currentPlayerText = teamName ? `${playerColor} (${teamName})` : playerColor;
+          
+          currentStatusTextElement.innerHTML = `Current Player: <span style="font-weight: bold;">${currentPlayerText}</span>`;
         }
     }
 
@@ -278,11 +314,12 @@ function renderer(options) {
             const fen = observationForRenderer.observationString;
             const parsedFen = _parseFen(fen);
             if (parsedFen) {
-                // Assuming `is_terminal` and `winner` are provided in the top-level observation
+                const winner = observationForRenderer.isTerminal ? 
+                    _deriveWinnerFromRewards(currentStepAgents, environment.info?.TeamNames) : null;
                 gameSpecificState = { 
                     ...parsedFen,
-                    is_terminal: observationForRenderer.isTerminal,
-                    winner: observationForRenderer.winner
+                    isTerminal: observationForRenderer.isTerminal,
+                    winner: winner
                 };
             }
         } catch (e) {
@@ -291,4 +328,4 @@ function renderer(options) {
     }
 
     _renderBoardDisplay(gameSpecificState, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
-}
+}

kaggle_environments/envs/open_spiel/open_spiel.py

@@ -19,6 +19,7 @@ DONE = "DONE"
 INACTIVE = "INACTIVE"
 ACTIVE = "ACTIVE"
 TIMEOUT = "TIMEOUT"
+INVALID = "INVALID"
 
 _log = logging.getLogger(__name__) 
 _log.setLevel(logging.INFO) 
@@ -41,8 +42,16 @@ for proxy_file in GAMES_DIR.glob("**/*_proxy.py"):
 
 
 # --- Constants ---
-DEFAULT_ACT_TIMEOUT = 120
-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.
@@ -71,6 +80,11 @@ CONFIGURATION_SPEC_TEMPLATE = {
         "type": "object",
         "default": {}
     },
+    "metadata": {
+        "description": "Arbitrary metadata.",
+        "type": "object",
+        "default": {}
+    },
 }
 
 OBSERVATION_SPEC_TEMPLATE = {
@@ -113,6 +127,10 @@ OBSERVATION_SPEC_TEMPLATE = {
             "description": "Boolean indicating game end.",
             "type": "boolean"
         },
+        "serializedGameAndState": {
+            "description": "Enables reconstructing the Game and State objects.",
+            "type": "string"
+        },
         "remainingOverageTime": 60,
         "step": 0
     },
@@ -171,19 +189,6 @@ def interpreter(
   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):
-    for player_id in range(num_players):
-      p = kaggle_state[player_id]
-      if p.status in [ERROR, TIMEOUT]:
-        # TODO: properly set the reward per game
-        p.reward = -1
-      elif p.status in [INACTIVE]:
-        p.reward = 1
-        p.status = DONE
-    return;
 
   # TODO(jhtschultz): Test reset behavior.
   is_initial_step = len(env.steps) == 1
@@ -193,31 +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["submission"]
+      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['actionHistory'].append(str(action_applied))
-          env.info['stateHistory'].append(str(os_state))
-        except Exception as e:  # pylint: disable=broad-exception-caught
-          _log.debug(e)
-          kaggle_state[acting_agent].status = "ERROR"
-      else:
-        kaggle_state[acting_agent].status = "INVALID"
-      if "duration" in logs[acting_agent]:
-        move_duration = round(logs[acting_agent]["duration"], 3)
-        env.info["moveDurations"].append(move_duration)
+        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:
-        env.info["moveDurations"].append(None)
+        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:
@@ -236,10 +246,36 @@ def interpreter(
     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]
@@ -251,11 +287,17 @@ def interpreter(
         )
     else:
       status = "INACTIVE"
+    assert status is not None
 
     info_dict = {}
     if acting_agent == player_id:
       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 = {
       "observationString": os_state.observation_string(player_id),
@@ -267,14 +309,17 @@ def interpreter(
       "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
 
@@ -400,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.6.dist-info → kaggle_environments-1.17.8.dist-info}/METADATA

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

{kaggle_environments-1.17.6.dist-info → kaggle_environments-1.17.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kaggle_environments/__init__.py,sha256=7GZjb3wxfZNOWoRk8zrsHJne9OMzVOMNomEwrP7CXI8,2175
+kaggle_environments/__init__.py,sha256=_wgrdspX3nmKV-ySMVlvuqmo-d6UmFceru-fk2fFpVg,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=Ense_M-2rP4KmVeuKFjM0NQ8M6ucUZTbhwrGekyR9LY,27857
@@ -8,7 +8,7 @@ kaggle_environments/main.py,sha256=10wtcEFcGIjdOd9AEps5WOAwslc6Wsx3eZ43LXJa8jE,1
 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,12 +191,12 @@ 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=2SRuz08htViEINCQ7odHCA0UeLQ7Tj0AEz__1w1PLvI,15914
+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=hQktt0rQ4msQKUiR1Z4qWi__aK6KcUSNPn6eP54TF1U,12543
+kaggle_environments/envs/open_spiel/games/chess/chess.js,sha256=JYL3nDL_sayz3YPeMpsuE-waTZKkkuK4VRJN9lZYCKc,14045
 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=iO74ar3Hh64VYEx9v3eysgrPU-Mcokl9dkFxie6uISg,14893
 kaggle_environments/envs/open_spiel/games/connect_four/connect_four_proxy.py,sha256=2otG99felDYhNhWpsadbM9YUaHtrXqhV1GFNEHhuPwA,2348
@@ -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.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-1.17.6.dist-info/METADATA,sha256=kFwWfkd4-DwVzrxYOSZyUoRCERzdFwLzMJo-61FsWkk,10955
-kaggle_environments-1.17.6.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-kaggle_environments-1.17.6.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
-kaggle_environments-1.17.6.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
-kaggle_environments-1.17.6.dist-info/RECORD,,
+kaggle_environments/static/player.html,sha256=TTxN-EU7_KCNIVDX4E4TrZ61FRWkGUDHMSbnUYsQSvg,24975
+kaggle_environments-1.17.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kaggle_environments-1.17.8.dist-info/METADATA,sha256=pP8vJJsca01VGe2qDDRjfGgcOpb4VQVchXzX7qyO8AM,10955
+kaggle_environments-1.17.8.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+kaggle_environments-1.17.8.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
+kaggle_environments-1.17.8.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
+kaggle_environments-1.17.8.dist-info/RECORD,,