kaggle-environments 1.17.5__tar.gz → 1.17.6__tar.gz

{kaggle_environments-1.17.5/kaggle_environments.egg-info → kaggle_environments-1.17.6}/PKG-INFO

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

{kaggle_environments-1.17.5 → kaggle_environments-1.17.6}/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.6"
 
 __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
            "make", "register", "utils", "__version__",

{kaggle_environments-1.17.5 → kaggle_environments-1.17.6}/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-1.17.5 → kaggle_environments-1.17.6}/kaggle_environments/envs/open_spiel/games/chess/chess.js

@@ -273,15 +273,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
                 gameSpecificState = { 
                     ...parsedFen,
-                    is_terminal: observationForRenderer.is_terminal,
+                    is_terminal: observationForRenderer.isTerminal,
                     winner: observationForRenderer.winner
                 };
             }

{kaggle_environments-1.17.5 → kaggle_environments-1.17.6}/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-1.17.5 → kaggle_environments-1.17.6}/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-1.17.5 → kaggle_environments-1.17.6}/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-1.17.5 → kaggle_environments-1.17.6}/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-1.17.5 → kaggle_environments-1.17.6}/kaggle_environments/envs/open_spiel/open_spiel.py

@@ -14,6 +14,12 @@ from kaggle_environments import utils
 import numpy as np
 import pyspiel
 
+ERROR = "ERROR"
+DONE = "DONE"
+INACTIVE = "INACTIVE"
+ACTIVE = "ACTIVE"
+TIMEOUT = "TIMEOUT"
+
 _log = logging.getLogger(__name__) 
 _log.setLevel(logging.INFO) 
 _handler = logging.StreamHandler(sys.stdout) 
@@ -35,7 +41,7 @@ for proxy_file in GAMES_DIR.glob("**/*_proxy.py"):
 
 
 # --- Constants ---
-DEFAULT_ACT_TIMEOUT = 5
+DEFAULT_ACT_TIMEOUT = 120
 DEFAULT_RUN_TIMEOUT = 1200
 # Buffer in addition to max game length to account for timeouts, retrys, etc.
 DEFAULT_STEP_BUFFER = 100
@@ -77,35 +83,33 @@ 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"
         },
@@ -115,6 +119,11 @@ OBSERVATION_SPEC_TEMPLATE = {
     "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 +133,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 +146,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,9 +163,10 @@ 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
@@ -167,8 +174,16 @@ def interpreter(
   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.")
+  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
@@ -186,18 +201,23 @@ def interpreter(
     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))
+          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)
+      else:
+        env.info["moveDurations"].append(None)
   elif acting_agent == pyspiel.PlayerId.SIMULTANEOUS:
     raise NotImplementedError
   elif acting_agent == pyspiel.PlayerId.TERMINAL:
@@ -212,8 +232,8 @@ 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 ---
   for player_id, agent_state in enumerate(kaggle_state):
@@ -234,19 +254,19 @@ def interpreter(
 
     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["actionApplied"] = action_applied
 
     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(),
     }
 
     # Apply updates
@@ -295,14 +315,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 +369,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 = {

{kaggle_environments-1.17.5 → kaggle_environments-1.17.6/kaggle_environments.egg-info}/PKG-INFO

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