kaggle-environments 1.16.5__tar.gz → 1.16.7__tar.gz

{kaggle-environments-1.16.5/kaggle_environments.egg-info → kaggle-environments-1.16.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaggle-environments
-Version: 1.16.5
+Version: 1.16.7
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle

{kaggle-environments-1.16.5 → kaggle-environments-1.16.7}/kaggle_environments/__init__.py

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

{kaggle-environments-1.16.5 → kaggle-environments-1.16.7}/kaggle_environments/agent.py

@@ -79,7 +79,7 @@ class UrlAgent:
                 "observation": observation,
             },
         }
-        timeout = float(observation.remainingOverageTime) + float(configuration.actTimeout) + 10
+        timeout = float(observation.remainingOverageTime) + float(configuration.actTimeout) + 1
         try:
             response = requests.post(url=self.raw, data=json.dumps(data), timeout=timeout)
             response.raise_for_status()

{kaggle-environments-1.16.5 → kaggle-environments-1.16.7}/kaggle_environments/envs/chess/chess.js

@@ -8,6 +8,28 @@ async function renderer(context) {
     width = 400,
   } = context;
 
+  const OPENINGS = [
+    "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
+    "rnbqkbnr/1p2pp1p/p2p2p1/8/2PNP3/8/PP3PPP/RNBQKB1R w KQkq - 0 6",
+    "r1b1kb1r/ppppq1pp/2n2n2/1B2p3/4N3/5N2/PPPPQPPP/R1B1K2R w KQkq - 3 7",
+    "rnbqkb1r/p2ppppp/5n2/2pP4/2p5/2N5/PP2PPPP/R1BQKBNR w KQkq - 0 5",
+    "rnbqk1nr/p1p1bppp/1p2p3/3pP3/3P4/2N5/PPP2PPP/R1BQKBNR w KQkq - 0 5",
+    "r2qk1nr/ppp2pp1/2np3p/2b1p3/2B1P1b1/2PP1N2/PP3PPP/RNBQ1RK1 w kq - 0 7",
+    "rn1qk1nr/pp2ppbp/3p2p1/2p5/2PP2b1/2N1PN2/PP3PPP/R1BQKB1R w KQkq c6 0 6",
+    "rnbqkbnr/1p2pp1p/p2p2p1/8/2PNP3/8/PP3PPP/RNBQKB1R w KQkq - 0 6",
+  ];
+
+  const MOVES = [
+    "",
+    "e2e4 c7c5 g1f3 d7d6 d2d4 c5d4 f3d4 a7a6 c2c4 g7g6",
+    "e2e4 e7e5 g1f3 b8c6 f1b5 f7f5 b1c3 f5e4 c3e4 g8f6 d1e2 d8e7",
+    "d2d4 g8f6 c2c4 c7c5 d4d5 b7b5 b1c3 b5c4",
+    "e2e4 e7e6 d2d4 d7d5 b1c3 f8e7 e4e5 b7b6",
+    "e2e4 e7e5 g1f3 b8c6 f1c4 f8c5 e1g1 d7d6 c2c3 c8g4 d2d3 h7h6",
+    "d2d4 g7g6 c2c4 f8g7 b1c3 d7d6 g1f3 c8g4 e2e3 c7c5",
+    "e2e4 c7c5 g1f3 d7d6 d2d4 c5d4 f3d4 a7a6 c2c4 g7g6",
+  ];
+
   // Common Dimensions.
   const canvasSize = Math.min(height, width);
   const boardSize = canvasSize * 0.8;
@@ -21,6 +43,76 @@ async function renderer(context) {
     parent.appendChild(canvas);
   }
 
+  // Create the Download PGN button
+  let downloadButton = parent.querySelector("#copy-pgn");
+  if (!downloadButton) {
+    try {
+      downloadButton = document.createElement("button");
+      downloadButton.id = "copy-pgn";
+      downloadButton.textContent = "Copy PGN";
+      downloadButton.style.position = "absolute";
+      downloadButton.style.top = "10px";
+      downloadButton.style.left = "10px";
+      downloadButton.style.zIndex = 1;
+      parent.appendChild(downloadButton);
+
+      const board = environment.steps[step][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(board);
+      let result = environment.rewards;
+      if (result.some(r => r === undefined || r === null)) {
+        result = result.map(r => r === undefined || r === null ? 0 : 1)
+      }
+
+      game.header(
+        "Event",
+        "FIDE & Google Efficient Chess AI Challenge (https://www.kaggle.com/competitions/fide-google-efficiency-chess-ai-challenge)",
+        "White",
+        agent1,
+        "Black",
+        agent2,
+        "Result",
+        result.join(" - ")
+      );
+
+      const openingIdx = OPENINGS.indexOf(board);
+      const moves = MOVES[openingIdx].split(" ");
+
+      for (let i = 0; i < moves.length; i++) {
+        const move = moves[i];
+        game.move({ from: move.slice(0, 2), to: move.slice(2, 4) });
+      }
+
+      for (let i = 1; i < environment.steps.length; i++) {
+        const move = environment.steps[i][(i - 1) % 2].action;
+        if (move.length === 4) {
+          game.move({ from: move.slice(0, 2), to: move.slice(2, 4) });
+        } else if (move.length === 5) {
+          game.move({
+            from: move.slice(0, 2),
+            to: move.slice(2, 4),
+            promotion: move.slice(4, 5),
+          });
+        }
+      }
+
+      downloadButton.addEventListener("click", async () => {
+        try {
+          await navigator.clipboard.writeText(game.pgn());
+          alert("PGN Copied");
+        } catch (err) {
+          console.error("Failed to copy: ", err);
+          alert("Failed to copy PGN");
+        }
+      });
+    } catch (e) {
+      console.error('Cannot create game pgn')
+      console.error(e);
+    }
+  }
+
   // Canvas setup and reset.
   let c = canvas.getContext("2d");
   canvas.width = canvasSize;
@@ -41,15 +133,23 @@ async function renderer(context) {
   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(.33 * offset)
+  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)
+  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-1.16.7/kaggle_environments/envs/lux_ai_s3/lux_ai_s3.py

@@ -0,0 +1,141 @@
+import dataclasses
+import json
+import math
+import os
+import random
+import sys
+from os import path
+from .agents import all_agents
+from sys import path as syspath
+from os import path as osp
+
+# next two lines enables importing local packages e.g. luxai_s3
+__dir__ = osp.dirname(__file__)
+syspath.append(__dir__)
+import numpy as np
+
+import copy
+import json
+def to_json(state):
+    if isinstance(state, np.ndarray):
+        return state.tolist()
+    elif isinstance(state, np.int64):
+        return state.tolist()
+    elif isinstance(state, list):
+        return [to_json(s) for s in state]
+    elif isinstance(state, dict):
+        out = {}
+        for k in state:
+            out[k] = to_json(state[k])
+        return out
+    else:
+        return state
+prev_step = 0
+luxenv = None
+prev_obs = None
+state_obs = None
+default_env_cfg = None
+def enqueue_output(out, queue):
+    for line in iter(out.readline, b''):
+        queue.put(line)
+    out.close()
+    
+def interpreter(state, env):
+    try:
+        from luxai_s3.wrappers import LuxAIS3GymEnv, RecordEpisode
+        global luxenv, prev_obs, state_obs, default_env_cfg
+        player_0 = state[0]
+        player_1 = state[1]
+        # filter out actions such as debug annotations so they aren't saved
+        # filter_actions(state, env)
+
+        if env.done:
+            if "seed" in env.configuration:
+                seed = int(env.configuration["seed"])
+            else:
+                seed = math.floor(random.random() * 1e9);
+                env.configuration["seed"] = seed
+
+            luxenv = LuxAIS3GymEnv(numpy_output=True)
+            luxenv = RecordEpisode(luxenv, save_on_close=False, save_on_reset=False)
+            obs, info = luxenv.reset(seed=seed)
+
+            env_cfg_json = info["params"]
+
+            env.configuration.env_cfg = env_cfg_json
+            
+            player_0.observation.player = "player_0"
+            player_1.observation.player = "player_1"
+            player_0.observation.obs = json.dumps(to_json(obs["player_0"]))
+            player_1.observation.obs = json.dumps(to_json(obs["player_1"]))
+            
+            replay_frame = luxenv.serialize_episode_data(dict(
+                states=[luxenv.episode["states"][-1]],
+                metadata=luxenv.episode["metadata"],
+                params=luxenv.episode["params"]
+            ))
+            # don't need to keep metadata/params beyond first step
+            player_0.info = dict(replay=replay_frame)
+            return state
+        
+        new_state_obs, rewards, terminations, truncations, infos = luxenv.step({
+            "player_0": np.array(player_0.action["action"]),
+            "player_1": np.array(player_1.action["action"])
+        })
+        
+        # cannot store np arrays in replay jsons so must convert to list
+        player_0.action = player_0.action["action"]
+        player_1.action = player_1.action["action"]
+        
+        dones = dict()
+        for k in terminations:
+            dones[k] = terminations[k] | truncations[k]
+
+        player_0.observation.player = "player_0"
+        player_1.observation.player = "player_1"
+
+        player_0.observation.obs = json.dumps(to_json(new_state_obs["player_0"]))
+        player_1.observation.obs = json.dumps(to_json(new_state_obs["player_1"]))
+        
+
+        player_0.reward = int(rewards["player_0"])
+        player_1.reward = int(rewards["player_1"])
+
+        player_0.observation.reward = int(player_0.reward)
+        player_1.observation.reward = int(player_1.reward)
+        replay_frame = luxenv.serialize_episode_data(dict(
+            states=[luxenv.episode["states"][-1]],
+            actions=[luxenv.episode["actions"][-1]],
+            metadata=luxenv.episode["metadata"],
+            params=luxenv.episode["params"]
+        ))
+        # don't need to keep metadata/params beyond first step
+        del replay_frame["metadata"]
+        del replay_frame["params"]
+        player_0.info = dict(replay=replay_frame)
+
+        if np.all([dones[k] for k in dones]):
+            if player_0.status == "ACTIVE":
+                player_0.status = "DONE"
+            if player_1.status == "ACTIVE":
+                player_1.status = "DONE"
+        return state
+    except ModuleNotFoundError as e:
+        print("Lux AI S3 Dependencies are missing, interpreter will not work")
+    return state
+
+def renderer(state, env):
+    raise NotImplementedError("To render the replay, please set the render mode to json or html")
+
+
+dir_path = path.dirname(__file__)
+json_path = path.abspath(path.join(dir_path, "lux_ai_s3.json"))
+with open(json_path) as json_file:
+    specification = json.load(json_file)
+
+
+def html_renderer():
+    html_path = path.abspath(path.join(dir_path, "index.html"))
+    return ("html_path", html_path)
+
+agents = all_agents

{kaggle-environments-1.16.5 → kaggle-environments-1.16.7/kaggle_environments.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaggle-environments
-Version: 1.16.5
+Version: 1.16.7
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle

kaggle-environments-1.16.5/kaggle_environments/envs/lux_ai_s3/lux_ai_s3.py

@@ -1,137 +0,0 @@
-import dataclasses
-import json
-import math
-import os
-import random
-import sys
-from os import path
-from .agents import all_agents
-from sys import path as syspath
-from os import path as osp
-
-# next two lines enables importing local packages e.g. luxai_s3
-__dir__ = osp.dirname(__file__)
-syspath.append(__dir__)
-import numpy as np
-
-import copy
-import json
-def to_json(state):
-    if isinstance(state, np.ndarray):
-        return state.tolist()
-    elif isinstance(state, np.int64):
-        return state.tolist()
-    elif isinstance(state, list):
-        return [to_json(s) for s in state]
-    elif isinstance(state, dict):
-        out = {}
-        for k in state:
-            out[k] = to_json(state[k])
-        return out
-    else:
-        return state
-prev_step = 0
-luxenv = None
-prev_obs = None
-state_obs = None
-default_env_cfg = None
-def enqueue_output(out, queue):
-    for line in iter(out.readline, b''):
-        queue.put(line)
-    out.close()
-    
-def interpreter(state, env):
-    from luxai_s3.wrappers import LuxAIS3GymEnv, RecordEpisode
-    global luxenv, prev_obs, state_obs, default_env_cfg
-    player_0 = state[0]
-    player_1 = state[1]
-    # filter out actions such as debug annotations so they aren't saved
-    # filter_actions(state, env)
-
-    if env.done:
-        if "seed" in env.configuration:
-            seed = int(env.configuration["seed"])
-        else:
-            seed = math.floor(random.random() * 1e9);
-            env.configuration["seed"] = seed
-
-        luxenv = LuxAIS3GymEnv(numpy_output=True)
-        luxenv = RecordEpisode(luxenv, save_on_close=False, save_on_reset=False)
-        obs, info = luxenv.reset(seed=seed)
-
-        env_cfg_json = info["params"]
-
-        env.configuration.env_cfg = env_cfg_json
-        
-        player_0.observation.player = "player_0"
-        player_1.observation.player = "player_1"
-        player_0.observation.obs = json.dumps(to_json(obs["player_0"]))
-        player_1.observation.obs = json.dumps(to_json(obs["player_1"]))
-        
-        replay_frame = luxenv.serialize_episode_data(dict(
-            states=[luxenv.episode["states"][-1]],
-            metadata=luxenv.episode["metadata"],
-            params=luxenv.episode["params"]
-        ))
-        # don't need to keep metadata/params beyond first step
-        player_0.info = dict(replay=replay_frame)
-        return state
-    
-    new_state_obs, rewards, terminations, truncations, infos = luxenv.step({
-        "player_0": np.array(player_0.action["action"]),
-        "player_1": np.array(player_1.action["action"])
-    })
-    
-    # cannot store np arrays in replay jsons so must convert to list
-    player_0.action = player_0.action["action"]
-    player_1.action = player_1.action["action"]
-    
-    dones = dict()
-    for k in terminations:
-        dones[k] = terminations[k] | truncations[k]
-
-    player_0.observation.player = "player_0"
-    player_1.observation.player = "player_1"
-
-    player_0.observation.obs = json.dumps(to_json(new_state_obs["player_0"]))
-    player_1.observation.obs = json.dumps(to_json(new_state_obs["player_1"]))
-    
-
-    player_0.reward = int(rewards["player_0"])
-    player_1.reward = int(rewards["player_1"])
-
-    player_0.observation.reward = int(player_0.reward)
-    player_1.observation.reward = int(player_1.reward)
-    replay_frame = luxenv.serialize_episode_data(dict(
-        states=[luxenv.episode["states"][-1]],
-        actions=[luxenv.episode["actions"][-1]],
-        metadata=luxenv.episode["metadata"],
-        params=luxenv.episode["params"]
-    ))
-    # don't need to keep metadata/params beyond first step
-    del replay_frame["metadata"]
-    del replay_frame["params"]
-    player_0.info = dict(replay=replay_frame)
-
-    if np.all([dones[k] for k in dones]):
-        if player_0.status == "ACTIVE":
-            player_0.status = "DONE"
-        if player_1.status == "ACTIVE":
-            player_1.status = "DONE"
-    return state
-
-def renderer(state, env):
-    raise NotImplementedError("To render the replay, please set the render mode to json or html")
-
-
-dir_path = path.dirname(__file__)
-json_path = path.abspath(path.join(dir_path, "lux_ai_s3.json"))
-with open(json_path) as json_file:
-    specification = json.load(json_file)
-
-
-def html_renderer():
-    html_path = path.abspath(path.join(dir_path, "index.html"))
-    return ("html_path", html_path)
-
-agents = all_agents