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

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

@@ -0,0 +1,296 @@
+function renderer(options) {
+    const { environment, step, parent, interactive, isInteractive } = options;
+
+    const DEFAULT_NUM_ROWS = 6;
+    const DEFAULT_NUM_COLS = 7;
+    const PLAYER_SYMBOLS = ['O', 'X']; // O: Player 0 (Yellow), X: Player 1 (Red)
+    const PLAYER_COLORS = ['#facc15', '#ef4444']; // Yellow for 'O', Red for 'X'
+    const EMPTY_CELL_COLOR = '#e5e7eb'; 
+    const BOARD_COLOR = '#3b82f6';      
+
+    const SVG_NS = "http://www.w3.org/2000/svg";
+    const CELL_UNIT_SIZE = 100; 
+    const CIRCLE_RADIUS = CELL_UNIT_SIZE * 0.42; 
+    const SVG_VIEWBOX_WIDTH = DEFAULT_NUM_COLS * CELL_UNIT_SIZE;
+    const SVG_VIEWBOX_HEIGHT = DEFAULT_NUM_ROWS * CELL_UNIT_SIZE;
+
+    let currentBoardSvgElement = null; 
+    let currentStatusTextElement = null;
+    let currentWinnerTextElement = null;
+    let currentMessageBoxElement = typeof document !== 'undefined' ? document.getElementById('messageBox') : null;
+    let currentRendererContainer = null;
+    let currentTitleElement = null;
+
+    function _showMessage(message, type = 'info', duration = 3000) {
+        if (typeof document === 'undefined' || !document.body) return;
+        if (!currentMessageBoxElement) {
+            currentMessageBoxElement = document.createElement('div');
+            currentMessageBoxElement.id = 'messageBox';
+            currentMessageBoxElement.style.position = 'fixed';
+            currentMessageBoxElement.style.top = '10px';
+            currentMessageBoxElement.style.left = '50%';
+            currentMessageBoxElement.style.transform = 'translateX(-50%)';
+            currentMessageBoxElement.style.padding = '0.75rem 1rem';
+            currentMessageBoxElement.style.borderRadius = '0.375rem';
+            currentMessageBoxElement.style.boxShadow = '0 2px 4px rgba(0,0,0,0.1)';
+            currentMessageBoxElement.style.zIndex = '1000';
+            currentMessageBoxElement.style.opacity = '0';
+            currentMessageBoxElement.style.transition = 'opacity 0.3s ease-in-out, background-color 0.3s';
+            currentMessageBoxElement.style.fontSize = '0.875rem';
+            currentMessageBoxElement.style.fontFamily = "'Inter', sans-serif";
+            document.body.appendChild(currentMessageBoxElement);
+        }
+        currentMessageBoxElement.textContent = message;
+        currentMessageBoxElement.style.backgroundColor = type === 'error' ? '#ef4444' : '#10b981';
+        currentMessageBoxElement.style.color = 'white';
+        currentMessageBoxElement.style.opacity = '1';
+        setTimeout(() => { if (currentMessageBoxElement) currentMessageBoxElement.style.opacity = '0'; }, duration);
+    }
+
+    function _ensureRendererElements(parentElementToClear, rows, cols) {
+        if (!parentElementToClear) return false;
+        parentElementToClear.innerHTML = ''; 
+
+        currentRendererContainer = document.createElement('div');
+        currentRendererContainer.style.display = 'flex';
+        currentRendererContainer.style.flexDirection = 'column';
+        currentRendererContainer.style.alignItems = 'center';
+        currentRendererContainer.style.padding = '20px';
+        currentRendererContainer.style.boxSizing = 'border-box';
+        currentRendererContainer.style.width = '100%';
+        currentRendererContainer.style.height = '100%';
+        currentRendererContainer.style.fontFamily = "'Inter', sans-serif";
+
+        currentTitleElement = document.createElement('h1');
+        currentTitleElement.textContent = 'Connect Four';
+        currentTitleElement.style.fontSize = '1.875rem';
+        currentTitleElement.style.fontWeight = 'bold';
+        currentTitleElement.style.marginBottom = '1rem';
+        currentTitleElement.style.textAlign = 'center';
+        currentTitleElement.style.color = '#2563eb';
+        currentRendererContainer.appendChild(currentTitleElement);
+
+        currentBoardSvgElement = document.createElementNS(SVG_NS, "svg");
+        currentBoardSvgElement.setAttribute("viewBox", `0 0 ${SVG_VIEWBOX_WIDTH} ${SVG_VIEWBOX_HEIGHT}`);
+        currentBoardSvgElement.setAttribute("preserveAspectRatio", "xMidYMid meet");
+        currentBoardSvgElement.style.width = "auto"; 
+        currentBoardSvgElement.style.maxWidth = "500px"; 
+        currentBoardSvgElement.style.maxHeight = `calc(100vh - 200px)`; 
+        currentBoardSvgElement.style.aspectRatio = `${cols} / ${rows}`;
+        currentBoardSvgElement.style.display = "block"; 
+        currentBoardSvgElement.style.margin = "0 auto 20px auto"; 
+
+        const boardBgRect = document.createElementNS(SVG_NS, "rect");
+        boardBgRect.setAttribute("x", "0");
+        boardBgRect.setAttribute("y", "0");
+        boardBgRect.setAttribute("width", SVG_VIEWBOX_WIDTH.toString());
+        boardBgRect.setAttribute("height", SVG_VIEWBOX_HEIGHT.toString());
+        boardBgRect.setAttribute("fill", BOARD_COLOR);
+        boardBgRect.setAttribute("rx", (CELL_UNIT_SIZE * 0.1).toString()); 
+        currentBoardSvgElement.appendChild(boardBgRect);
+
+        // SVG Circles are created with (0,0) being top-left visual circle
+        for (let r_visual = 0; r_visual < rows; r_visual++) {
+            for (let c_visual = 0; c_visual < cols; c_visual++) {
+                const circle = document.createElementNS(SVG_NS, "circle");
+                const cx = c_visual * CELL_UNIT_SIZE + CELL_UNIT_SIZE / 2;
+                const cy = r_visual * CELL_UNIT_SIZE + CELL_UNIT_SIZE / 2;
+                circle.setAttribute("id", `cell-${r_visual}-${c_visual}`);
+                circle.setAttribute("cx", cx.toString());
+                circle.setAttribute("cy", cy.toString());
+                circle.setAttribute("r", CIRCLE_RADIUS.toString());
+                circle.setAttribute("fill", EMPTY_CELL_COLOR);
+                currentBoardSvgElement.appendChild(circle);
+            }
+        }
+        currentRendererContainer.appendChild(currentBoardSvgElement);
+
+        const statusContainer = document.createElement('div');
+        statusContainer.style.padding = '10px 15px';
+        statusContainer.style.backgroundColor = 'white';
+        statusContainer.style.borderRadius = '8px';
+        statusContainer.style.boxShadow = '0 4px 6px -1px rgba(0,0,0,0.1), 0 2px 4px -1px rgba(0,0,0,0.06)';
+        statusContainer.style.textAlign = 'center';
+        statusContainer.style.width = 'auto';
+        statusContainer.style.minWidth = '200px'; 
+        statusContainer.style.maxWidth = '90vw';
+        currentRendererContainer.appendChild(statusContainer);
+
+        currentStatusTextElement = document.createElement('p');
+        currentStatusTextElement.style.fontSize = '1.1rem';
+        currentStatusTextElement.style.fontWeight = '600';
+        currentStatusTextElement.style.margin = '0 0 5px 0';
+        statusContainer.appendChild(currentStatusTextElement);
+        
+        currentWinnerTextElement = document.createElement('p');
+        currentWinnerTextElement.style.fontSize = '1.25rem';
+        currentWinnerTextElement.style.fontWeight = '700';
+        currentWinnerTextElement.style.margin = '5px 0 0 0';
+        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;
+    }
+
+    function _renderBoardDisplay_svg(gameStateToDisplay, displayRows, displayCols) {
+        if (!currentBoardSvgElement || !currentStatusTextElement || !currentWinnerTextElement) return;
+
+        if (!gameStateToDisplay || typeof gameStateToDisplay.board !== 'object' || !Array.isArray(gameStateToDisplay.board) || gameStateToDisplay.board.length === 0) {
+            currentStatusTextElement.textContent = "Waiting for game data...";
+            currentWinnerTextElement.textContent = "";
+            for (let r_visual = 0; r_visual < displayRows; r_visual++) {
+                for (let c_visual = 0; c_visual < displayCols; c_visual++) {
+                    const circleElement = currentBoardSvgElement.querySelector(`#cell-${r_visual}-${c_visual}`);
+                    if (circleElement) {
+                        circleElement.setAttribute("fill", EMPTY_CELL_COLOR);
+                    }
+                }
+            }
+            return;
+        }
+
+        const { board, current_player, is_terminal, winner } = gameStateToDisplay;
+
+        for (let r_data = 0; r_data < displayRows; r_data++) {
+            const dataRow = board[r_data]; 
+            if (!dataRow || !Array.isArray(dataRow) || dataRow.length !== displayCols) {
+                // Error handling for malformed row
+                for (let c_fill = 0; c_fill < displayCols; c_fill++) {
+                    // Determine visual row for error display. If r_data=0 is top data,
+                    // and we want to flip, then this error is for visual row (displayRows-1)-0.
+                    const visual_row_for_error = (displayRows - 1) - r_data;
+                    const circleElement = currentBoardSvgElement.querySelector(`#cell-${visual_row_for_error}-${c_fill}`);
+                    if (circleElement) circleElement.setAttribute("fill", '#FF00FF'); // Magenta for error
+                }
+                continue;
+            }
+
+            const visual_svg_row_index = (displayRows - 1) - r_data;
+
+            for (let c_data = 0; c_data < displayCols; c_data++) { // c_data iterates through columns of `board[r_data]`
+                const originalCellValue = dataRow[c_data];
+                const cellValueForComparison = String(originalCellValue).trim().toLowerCase();
+                
+                // The column index for SVG is the same as c_data
+                const visual_svg_col_index = c_data;
+                const circleElement = currentBoardSvgElement.querySelector(`#cell-${visual_svg_row_index}-${visual_svg_col_index}`);
+                
+                if (!circleElement) continue;
+                
+                let fillColor = EMPTY_CELL_COLOR;
+                if (cellValueForComparison === "o") { 
+                    fillColor = PLAYER_COLORS[0]; // Yellow
+                } else if (cellValueForComparison === "x") { 
+                    fillColor = PLAYER_COLORS[1]; // Red
+                }
+                circleElement.setAttribute("fill", fillColor);
+            }
+        }
+
+        currentStatusTextElement.innerHTML = '';
+        currentWinnerTextElement.innerHTML = '';
+        if (is_terminal) {
+            currentStatusTextElement.textContent = "Game Over!";
+            if (winner !== null && winner !== undefined) {
+                if (String(winner).toLowerCase() === 'draw') {
+                    currentWinnerTextElement.textContent = "It's a Draw!";
+                } else {
+                    let winnerSymbolDisplay, winnerColorDisplay;
+                    if (String(winner).toLowerCase() === "o") {
+                        winnerSymbolDisplay = PLAYER_SYMBOLS[0]; 
+                        winnerColorDisplay = PLAYER_COLORS[0];   
+                    } else if (String(winner).toLowerCase() === "x") {
+                        winnerSymbolDisplay = PLAYER_SYMBOLS[1]; 
+                        winnerColorDisplay = PLAYER_COLORS[1];   
+                    }
+                    if (winnerSymbolDisplay) {
+                         currentWinnerTextElement.innerHTML = `Player <span style="color: ${winnerColorDisplay}; font-weight: bold;">${winnerSymbolDisplay}</span> Wins!`;
+                    } else {
+                        currentWinnerTextElement.textContent = `Winner: ${String(winner).toUpperCase()}`; 
+                    }
+                }
+            } else { currentWinnerTextElement.textContent = "Game ended."; }
+        } else { 
+            let playerSymbolToDisplay, playerColorToDisplay;
+            if (String(current_player).toLowerCase() === "o") {
+                playerSymbolToDisplay = PLAYER_SYMBOLS[0]; 
+                playerColorToDisplay = PLAYER_COLORS[0];   
+            } else if (String(current_player).toLowerCase() === "x") {
+                playerSymbolToDisplay = PLAYER_SYMBOLS[1]; 
+                playerColorToDisplay = PLAYER_COLORS[1];   
+            }
+            if (playerSymbolToDisplay) {
+                currentStatusTextElement.innerHTML = `Current Player: <span style="color: ${playerColorToDisplay}; font-weight: bold;">${playerSymbolToDisplay}</span>`;
+            } else {
+                currentStatusTextElement.textContent = "Waiting for player...";
+            }
+        }
+    }
+
+    // --- Main execution logic ---
+    if (!_ensureRendererElements(parent, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS)) {
+        if (parent && typeof parent.innerHTML !== 'undefined') {
+            parent.innerHTML = "<p style='color:red; font-family: sans-serif;'>Critical Error: Renderer element setup failed.</p>";
+        }
+        return;
+    }
+    
+    if (!environment || !environment.steps || !environment.steps[step]) {
+        _renderBoardDisplay_svg(null, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS); 
+        if(currentStatusTextElement) currentStatusTextElement.textContent = "Initializing environment...";
+        return;
+    }
+
+    const currentStepAgents = environment.steps[step];
+    if (!currentStepAgents || !Array.isArray(currentStepAgents) || currentStepAgents.length === 0) {
+        _renderBoardDisplay_svg(null, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
+        if(currentStatusTextElement) currentStatusTextElement.textContent = "Waiting for agent data...";
+        return;
+    }
+    
+    const gameMasterAgentIndex = currentStepAgents.length - 1;
+    const gameMasterAgent = currentStepAgents[gameMasterAgentIndex];
+
+    if (!gameMasterAgent || typeof gameMasterAgent.observation === 'undefined') {
+        _renderBoardDisplay_svg(null, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
+        if(currentStatusTextElement) currentStatusTextElement.textContent = "Waiting for observation data...";
+        return;
+    }
+    const observationForRenderer = gameMasterAgent.observation;
+
+    let gameSpecificState = null;
+
+    if (observationForRenderer && typeof observationForRenderer.observation_string === 'string' && observationForRenderer.observation_string.trim() !== '') {
+        try {
+            gameSpecificState = JSON.parse(observationForRenderer.observation_string);
+        } catch (e) {
+            _showMessage("Error: Corrupted game state (obs_string).", 'error');
+        }
+    }
+    
+    if (!gameSpecificState && observationForRenderer && typeof observationForRenderer.json === 'string' && observationForRenderer.json.trim() !== '') {
+        try {
+            gameSpecificState = JSON.parse(observationForRenderer.json);
+        } catch (e) {
+            _showMessage("Error: Corrupted game state (json).", 'error');
+        }
+    }
+    
+    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/connect_four/connect_four_proxy.py

@@ -0,0 +1,86 @@
+"""Change Connect Four state and action string representations."""
+
+import json
+from typing import Any
+
+from ... import proxy
+import pyspiel
+
+
+class ConnectFourState(proxy.State):
+  """Connect Four state proxy."""
+
+  def _player_string(self, player: int) -> str:
+    if player < 0:
+      return pyspiel.PlayerId(player).name.lower()
+    elif player == 0:
+      return 'x'
+    elif player == 1:
+      return 'o'
+    else:
+      raise ValueError(f'Invalid player: {player}')
+
+  def state_dict(self) -> dict[str, Any]:
+    # row 0 is now bottom row
+    rows = reversed(self.to_string().strip().split('\n'))
+    board = [list(row) for row in rows]
+    winner = None
+    if self.is_terminal():
+      if self.returns()[0] > self.returns()[1]:
+        winner = 'x'
+      elif self.returns()[1] > self.returns()[0]:
+        winner = 'o'
+      else:
+        winner = 'draw'
+    return {
+        'board': board,
+        'current_player': self._player_string(self.current_player()),
+        'is_terminal': self.is_terminal(),
+        'winner': winner,
+    }
+
+  def to_json(self) -> str:
+    return json.dumps(self.state_dict())
+
+  def action_to_dict(self, action: int) -> dict[str, Any]:
+    return {'col': action}
+
+  def action_to_json(self, action: int) -> str:
+    return json.dumps(self.action_to_dict(action))
+
+  def dict_to_action(self, action_dict: dict[str, Any]) -> int:
+    return int(action_dict['col'])
+
+  def json_to_action(self, action_json: str) -> int:
+    action_dict = json.loads(action_json)
+    return self.dict_to_action(action_dict)
+
+  def observation_string(self, player: int) -> str:
+    return self.observation_json(player)
+
+  def observation_json(self, player: int) -> str:
+    del player
+    return self.to_json()
+
+  def __str__(self):
+    return self.to_json()
+
+
+class ConnectFourGame(proxy.Game):
+  """Connect Four game proxy."""
+
+  def __init__(self, params: Any | None = None):
+    params = params or {}
+    wrapped = pyspiel.load_game('connect_four', params)
+    super().__init__(
+        wrapped,
+        short_name='connect_four_proxy',
+        long_name='Connect Four (proxy)',
+    )
+
+  def new_initial_state(self, *args) -> ConnectFourState:
+    return ConnectFourState(self.__wrapped__.new_initial_state(*args),
+                            game=self)
+
+
+pyspiel.register_game(ConnectFourGame().get_type(), ConnectFourGame)

kaggle_environments/envs/open_spiel/games/connect_four/connect_four_proxy_test.py

@@ -0,0 +1,57 @@
+"""Test for proxied Connect Four game."""
+
+import json
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import pyspiel
+from . import connect_four_proxy as connect_four
+
+
+NUM_ROWS = 6
+NUM_COLS = 7
+
+
+class ConnectFourTest(parameterized.TestCase):
+
+  def test_game_is_registered(self):
+    game = pyspiel.load_game('connect_four_proxy')
+    self.assertIsInstance(game, connect_four.ConnectFourGame)
+
+  def test_random_sim(self):
+    game = connect_four.ConnectFourGame()
+    pyspiel.random_sim_test(game, num_sims=10, serialize=False, verbose=False)
+
+  def test_state_to_json(self):
+    game = connect_four.ConnectFourGame()
+    state = game.new_initial_state()
+    json_state = json.loads(state.to_json())
+    expected_board = [['.'] * NUM_COLS for _ in range(NUM_ROWS)]
+    self.assertEqual(json_state['board'], expected_board)
+    self.assertEqual(json_state['current_player'], 'x')
+    state.apply_action(3)
+    json_state = json.loads(state.to_json())
+    expected_board[0][3] = 'x'
+    self.assertEqual(json_state['board'], expected_board)
+    self.assertEqual(json_state['current_player'], 'o')
+    state.apply_action(2)
+    json_state = json.loads(state.to_json())
+    expected_board[0][2] = 'o'
+    self.assertEqual(json_state['board'], expected_board)
+    self.assertEqual(json_state['current_player'], 'x')
+    state.apply_action(2)
+    json_state = json.loads(state.to_json())
+    expected_board[1][2] = 'x'
+    self.assertEqual(json_state['board'], expected_board)
+    self.assertEqual(json_state['current_player'], 'o')
+
+  def test_action_to_json(self):
+    game = connect_four.ConnectFourGame()
+    state = game.new_initial_state()
+    action = json.loads(state.action_to_json(3))
+    self.assertEqual(json.loads(state.action_to_json(3)), action)
+    self.assertEqual(action['col'], 3)
+
+
+if __name__ == '__main__':
+  absltest.main()

kaggle_environments/envs/open_spiel/observation.py

@@ -0,0 +1,133 @@
+# Copyright 2019 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""An observation of a game.
+
+This is intended to be the main way to get observations of states in Python.
+The usage pattern is as follows:
+
+0. Create the game we will be playing
+1. Create each kind of observation required, using `make_observation`
+2. Every time a new observation is required, call:
+      `observation.set_from(state, player)`
+   The tensor contained in the Observation class will be updated with an
+   observation of the supplied state. This tensor is updated in-place, so if
+   you wish to retain it, you must make a copy.
+
+The following options are available when creating an Observation:
+ - perfect_recall: if true, each observation must allow the observing player to
+   reconstruct their history of actions and observations.
+ - public_info: if true, the observation should include public information
+ - private_info: specifies for which players private information should be
+   included - all players, the observing player, or no players
+ - params: game-specific parameters for observations
+
+We ultimately aim to have all games support all combinations of these arguments.
+However, initially many games will only support the combinations corresponding
+to ObservationTensor and InformationStateTensor:
+ - ObservationTensor: perfect_recall=False, public_info=True,
+   private_info=SinglePlayer
+ - InformationStateTensor: perfect_recall=True, public_info=True,
+   private_info=SinglePlayer
+
+Three formats of observation are supported:
+a. 1-D numpy array, accessed by `observation.tensor`
+b. Dict of numpy arrays, accessed by `observation.dict`. These are pieces of the
+   1-D array, reshaped. The np.array objects refer to the same memory as the
+   1-D array (no copying!).
+c. String, hopefully human-readable (primarily for debugging purposes)
+
+For usage examples, see `observation_test.py`.
+"""
+
+import numpy as np
+
+import pyspiel
+
+
+# Corresponds to the old information_state_XXX methods.
+INFO_STATE_OBS_TYPE = pyspiel.IIGObservationType(perfect_recall=True)
+
+
+class _Observation:
+  """Contains an observation from a game."""
+
+  def __init__(self, game, observer):
+    self._observation = pyspiel._Observation(game, observer)
+    self.dict = {}
+    if self._observation.has_tensor():
+      self.tensor = np.frombuffer(self._observation, np.float32)
+      offset = 0
+      for tensor_info in self._observation.tensors_info():
+        size = np.prod(tensor_info.shape, dtype=np.int64)
+        values = self.tensor[offset:offset + size].reshape(tensor_info.shape)
+        self.dict[tensor_info.name] = values
+        offset += size
+    else:
+      self.tensor = None
+
+  def set_from(self, state, player):
+    self._observation.set_from(state, player)
+
+  def string_from(self, state, player):
+    return (self._observation.string_from(state, player)
+            if self._observation.has_string() else None)
+
+  def compress(self):
+    return self._observation.compress()
+
+  def decompress(self, compressed_observation):
+    self._observation.decompress(compressed_observation)
+
+
+def make_observation(
+    game,
+    imperfect_information_observation_type=None,
+    params=None,
+):
+  """Returns an _Observation instance if the imperfect_information_observation_type is supported, otherwise None."""
+  params = params or {}
+  if hasattr(game, 'make_py_observer'):
+    return game.make_py_observer(imperfect_information_observation_type, params)
+  else:
+    if imperfect_information_observation_type is not None:
+      observer = game.make_observer(
+          imperfect_information_observation_type, params
+      )
+    else:
+      observer = game.make_observer(params)
+    if observer is None:
+      return None
+    return _Observation(game, observer)
+
+
+class IIGObserverForPublicInfoGame:
+  """Observer for imperfect information obvservations of public-info games."""
+
+  def __init__(self, iig_obs_type, params):
+    if params:
+      raise ValueError(f'Observation parameters not supported; passed {params}')
+    self._iig_obs_type = iig_obs_type
+    self.tensor = None
+    self.dict = {}
+
+  def set_from(self, state, player):
+    pass
+
+  def string_from(self, state, player):
+    del player
+    if self._iig_obs_type.public_info:
+      return state.history_str()
+    else:
+      return ''  # No private information to return

kaggle_environments/envs/open_spiel/open_spiel.py

@@ -1,14 +1,16 @@
 """Kaggle environment wrapper for OpenSpiel games."""
 
 import copy
+import os
+import pathlib
 import random
-from typing import Any
+from typing import Any, Callable
 
 from kaggle_environments import core
 from kaggle_environments import utils
 import numpy as np
 import pyspiel
-
+from .games.connect_four import connect_four_proxy
 
 DEFAULT_ACT_TIMEOUT = 5
 DEFAULT_RUN_TIMEOUT = 1200
@@ -236,43 +238,84 @@ def renderer(state: list[utils.Struct], env: core.Environment) -> str:
     print(f"Error rendering {env.name} at state: {state}.")
     raise e
 
+# --- HTML Renderer Logic ---
 
-def html_renderer():
-  """Provides the simplest possible HTML/JS renderer for OpenSpiel text observations."""
+def _default_html_renderer() -> str:
+  """Provides the JavaScript string for the default HTML renderer."""
   return """
 function renderer(context) {
     const { parent, environment, step } = context;
     parent.innerHTML = ''; // Clear previous rendering
 
-    // Get the current step's data
     const currentStepData = environment.steps[step];
-    const numAgents = currentStepData.length
-    const gameMasterIndex = numAgents - 1
+    if (!currentStepData) {
+        parent.textContent = "Waiting for step data...";
+        return;
+    }
+    const numAgents = currentStepData.length;
+    const gameMasterIndex = numAgents - 1;
     let obsString = "Observation not available for this step.";
+    let title = `Step: ${step}`;
+
+    if (environment.configuration && environment.configuration.openSpielGameName) {
+        title = `${environment.configuration.openSpielGameName} - Step: ${step}`;
+    }
 
-    // Try to get the raw observation string from the game master agent.
-    if (currentStepData && currentStepData[gameMasterIndex] && currentStepData[gameMasterIndex].observation && currentStepData[gameMasterIndex].observation.observation_string !== undefined) {
+    // Try to get obs_string from game_master of current step
+    if (currentStepData[gameMasterIndex] && 
+        currentStepData[gameMasterIndex].observation && 
+        typeof currentStepData[gameMasterIndex].observation.observation_string === 'string') {
         obsString = currentStepData[gameMasterIndex].observation.observation_string;
-    } else if (step === 0 && environment.steps[0] && environment.steps[0][gameMasterIndex] && environment.steps[0][gameMasterIndex].observation && environment.steps[0][gameMasterIndex].observation.observation_string !== undefined) {
-        // Fallback for initial state if current step data is missing
+    } 
+    // Fallback to initial step if current is unavailable (e.g. very first render call)
+    else if (step === 0 && environment.steps[0] && environment.steps[0][gameMasterIndex] && 
+             environment.steps[0][gameMasterIndex].observation &&
+             typeof environment.steps[0][gameMasterIndex].observation.observation_string === 'string') {
         obsString = environment.steps[0][gameMasterIndex].observation.observation_string;
     }
 
-    // Create a <pre> element to preserve formatting
     const pre = document.createElement("pre");
-    pre.style.fontFamily = "monospace"; // Ensure monospace font
-    pre.style.margin = "10px";        // Add some padding
+    pre.style.fontFamily = "monospace";
+    pre.style.margin = "10px";
     pre.style.border = "1px solid #ccc";
-    pre.style.padding = "5px";
-    pre.style.backgroundColor = "#f0f0f0";
-
-    // Set the text content (safer than innerHTML for plain text)
-    pre.textContent = `Step: ${step}\\n\\n${obsString}`; // Add step number for context
+    pre.style.padding = "10px";
+    pre.style.backgroundColor = "#f9f9f9";
+    pre.style.whiteSpace = "pre-wrap";
+    pre.style.wordBreak = "break-all";
 
+    pre.textContent = `${title}\\n\\n${obsString}`;
     parent.appendChild(pre);
 }
 """
 
+def _get_html_renderer_content(
+    open_spiel_short_name: str,
+    base_path_for_custom_renderers: pathlib.Path,
+    default_renderer_func: Callable[[], str]
+) -> str:
+  """
+  Tries to load a custom JS renderer for the game.
+  Falls back to the default renderer if not found or on error.
+  """
+  if "proxy" not in open_spiel_short_name:
+    return default_renderer_func()
+  sanitized_game_name = open_spiel_short_name.replace('-', '_').replace('.', '_')
+  sanitized_game_name = sanitized_game_name.removesuffix("_proxy")
+  custom_renderer_js_path = (
+      base_path_for_custom_renderers /
+      sanitized_game_name /
+      f"{sanitized_game_name}.js"
+  )
+  if custom_renderer_js_path.is_file():
+    try:
+      with open(custom_renderer_js_path, "r", encoding="utf-8") as f:
+        content = f.read()
+      print(f"INFO: Using custom HTML renderer for {open_spiel_short_name} from {custom_renderer_js_path}")
+      return content
+    except Exception as e_render:
+      pass
+  return default_renderer_func()
+
 
 # --- Agents ---
 def random_agent(
@@ -299,6 +342,8 @@ def _register_open_spiel_envs(
   successfully_loaded_games = []
   skipped_games = []
   registered_envs = {}
+  current_file_dir = pathlib.Path(__file__).parent.resolve()
+  custom_renderers_base = current_file_dir / "games"
   if games_list is None:
     games_list = pyspiel.registered_names()
   for short_name in games_list:
@@ -330,16 +375,33 @@ https://github.com/google-deepmind/open_spiel/tree/master/open_spiel/games
       game_spec["observation"]["properties"]["openSpielGameName"][
           "default"] = short_name
 
+      # Building html_renderer_callable is a bit convoluted but other approaches
+      # failed for a variety of reasons. Returning a simple lambda function
+      # doesn't work because of late-binding. The last env registered will
+      # overwrite all previous renderers.
+      js_string_content = _get_html_renderer_content(
+          open_spiel_short_name=short_name,
+          base_path_for_custom_renderers=custom_renderers_base,
+          default_renderer_func=_default_html_renderer,
+      )
+
+      def create_html_renderer_closure(captured_content):
+          def html_renderer_callable_no_args():
+              return captured_content
+          return html_renderer_callable_no_args
+
+      html_renderer_callable = create_html_renderer_closure(js_string_content)
+
       registered_envs[env_name] = {
           "specification": game_spec,
           "interpreter": interpreter,
           "renderer": renderer,
-          "html_renderer": html_renderer,
+          "html_renderer": html_renderer_callable,
           "agents": agents,
       }
       successfully_loaded_games.append(short_name)
 
-    except Exception:  # pylint: disable=broad-exception-caught
+    except Exception as e:  # pylint: disable=broad-exception-caught
       skipped_games.append(short_name)
       continue
 

kaggle_environments/envs/open_spiel/proxy.py

@@ -0,0 +1,139 @@
+"""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
+
+from . import observation
+import pyspiel
+
+
+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/proxy_test.py

@@ -0,0 +1,64 @@
+"""Proxy tests."""
+
+from . import proxy
+from absl.testing import absltest
+from absl.testing import parameterized
+import pyspiel
+
+
+def make_game() -> proxy.Game:
+  return proxy.Game(pyspiel.load_game('tic_tac_toe()'))
+
+
+class TestState(proxy.State):
+
+  def __str__(self) -> str:
+    return 'TestState: ' + super().__str__()
+
+
+class TestGame(proxy.Game):
+
+  def new_initial_state(self, *args, **kwargs) -> TestState:
+    return TestState(
+        self.__wrapped__.new_initial_state(*args, **kwargs), game=self
+    )
+
+
+class ProxiesTest(parameterized.TestCase):
+
+  def test_types(self):
+    game = make_game()
+    self.assertIsInstance(game, pyspiel.Game)
+    state = game.new_initial_state()
+    self.assertIsInstance(state, pyspiel.State)
+
+  def test_get_game(self):
+    game = make_game()
+    state = game.new_initial_state()
+    self.assertIsInstance(state.get_game(), proxy.Game)
+    new_state = state.get_game().new_initial_state()
+    self.assertIsInstance(new_state, proxy.State)
+    self.assertIsNot(new_state, state)
+
+  def test_clone(self):
+    game = make_game()
+    state = game.new_initial_state()
+    state.apply_action(state.legal_actions()[0])
+    clone = state.clone()
+    self.assertIsInstance(clone, proxy.State)
+    self.assertEqual(state.history(), clone.history())
+    clone.apply_action(clone.legal_actions()[0])
+    self.assertEqual(state.history(), clone.history()[:-1])
+
+  def test_subclassing(self):
+    game = TestGame(pyspiel.load_game('tic_tac_toe()'))
+    state = game.new_initial_state()
+    self.assertIsInstance(state, TestState)
+    self.assertIsInstance(state.clone(), TestState)
+    self.assertIsInstance(state.get_game(), TestGame)
+    wrapped_state = state.__wrapped__  # type: ignore
+    self.assertEqual(str(state), 'TestState: ' + str(wrapped_state))
+
+
+if __name__ == '__main__':
+  absltest.main()

kaggle_environments/envs/open_spiel/test_open_spiel.py

@@ -1,6 +1,6 @@
 import sys
 from kaggle_environments import make
-import open_spiel as open_spiel_env
+from . import open_spiel as open_spiel_env
 
 
 def test_envs_load():

{kaggle_environments-1.17.2.dist-info → kaggle_environments-1.17.3.dist-info}/METADATA

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

{kaggle_environments-1.17.2.dist-info → kaggle_environments-1.17.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kaggle_environments/__init__.py,sha256=gfZpgAMb07ABEi0ZWy18VtUqHEaY-tBcrDkSitkbcwM,2189
+kaggle_environments/__init__.py,sha256=rkTFEuN8ZVrkb3vR3ravIenS9gIZBIjcnlUoA_zi7ic,2189
 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
@@ -188,8 +188,17 @@ kaggle_environments/envs/mab/agents.py,sha256=vPHNN5oRcbTG3FaW9iYmoeQjufXFJMjYOL
 kaggle_environments/envs/mab/mab.js,sha256=zsKGVRL9qFyUoukRj-ES5dOh8Wig7UzNf0z5Potw84E,3256
 kaggle_environments/envs/mab/mab.json,sha256=VAlpjJ7_ytYO648swQW_ICjC5JKTAdmnShuGggeSX4A,2077
 kaggle_environments/envs/mab/mab.py,sha256=bkSIxkstS98Vr3eOA9kxQkseDqa1MlG2Egfzeaf-8EA,5241
-kaggle_environments/envs/open_spiel/open_spiel.py,sha256=eGoV9EpOz2v_41NSZ6mJMGcwF29Y-0fZA3IuoOd8Psk,11812
-kaggle_environments/envs/open_spiel/test_open_spiel.py,sha256=ZDzXa8te8MCdgJ7d-8IdC8al72r3YPxYIJ7Gjhk-NkM,534
+kaggle_environments/envs/open_spiel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kaggle_environments/envs/open_spiel/observation.py,sha256=yrJ_iZ9sBUTB6YOyEpKNwYiQEWmsPPtaDYtL4zsw1Ko,4834
+kaggle_environments/envs/open_spiel/open_spiel.py,sha256=UMH_flpyKIBAyC40iU8HUip-COq9AqulBLjTuZujrik,14038
+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=55oTMpGiK401rtZTiqKj5QBW0_UNYDdJqPF5YJyewUc,541
+kaggle_environments/envs/open_spiel/games/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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_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/rps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kaggle_environments/envs/rps/agents.py,sha256=iBtBjPbutWickm-K1EzBEYvLWj5fvU3ks0AYQMYWgEI,2140
 kaggle_environments/envs/rps/helpers.py,sha256=NUqhJafNSzlC_ArwDIYzbLx15pkmBpzfVuG8Iv4wX9U,966
@@ -203,9 +212,9 @@ kaggle_environments/envs/tictactoe/tictactoe.js,sha256=NZDT-oSG0a6a-rso9Ldh9qkJw
 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.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-1.17.2.dist-info/METADATA,sha256=FeHjMl4YWtcFWOflJV9P6vToQ6ZGJ0n8CZ6ijFsfr-E,10955
-kaggle_environments-1.17.2.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-kaggle_environments-1.17.2.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
-kaggle_environments-1.17.2.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
-kaggle_environments-1.17.2.dist-info/RECORD,,
+kaggle_environments-1.17.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kaggle_environments-1.17.3.dist-info/METADATA,sha256=3yV9E05vePRsHqStWawS_yKoWzNG59fK5Ak4sbpPAYU,10955
+kaggle_environments-1.17.3.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+kaggle_environments-1.17.3.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
+kaggle_environments-1.17.3.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
+kaggle_environments-1.17.3.dist-info/RECORD,,