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

kaggle_environments/envs/chess/chess.js

@@ -37,6 +37,21 @@ async function renderer(context) {
       c.fillRect(x, y, squareSize, squareSize);
     }
   }
+  // 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 white = firstGame ? agent1 : agent2
+  const black = firstGame ? agent2 : agent1
+  const fontSize = Math.round(.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/chess/chess.json

@@ -6,12 +6,13 @@
     "agents": [2],
     "configuration": {
       "episodeSteps": 1000,
-      "actTimeout": 1,
+      "actTimeout": 0.1,
+      "runTimeout": 300,
       "agentTimeout": {
         "description": "Obsolete field kept for backwards compatibility, please use observation.remainingOverageTime.",
         "type": "number",
         "minimum": 0,
-        "default": 60
+        "default": 20
       }
     },
     "reward": {
@@ -31,7 +32,7 @@
         "defaults": ["white", "black"],
         "enum": ["white", "black"]
       },
-      "remainingOverageTime": 60 
+      "remainingOverageTime": 20
     },
     "action": {
       "description": "Move in UCI notation (e.g., e2e4)",
@@ -41,4 +42,4 @@
     "status": {
       "defaults": ["ACTIVE", "INACTIVE"]
     }
-  }
+  }

kaggle_environments/envs/chess/chess.py

@@ -1,28 +1,193 @@
-import chess
+import math
 import random
 import json
 from os import path
+from collections import defaultdict
+
+from Chessnut import Game
 
 ERROR = "ERROR"
 DONE = "DONE"
 INACTIVE = "INACTIVE"
 ACTIVE = "ACTIVE"
+WHITE = "white"
+
+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",
+]
+
+
+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"
+]
+
 
 def random_agent(obs):
-  """
-  Selects a random legal move from the board.
-  Returns:
+    """
+    Selects a random legal move from the board.
+    Returns:
     A string representing the chosen move in UCI notation (e.g., "e2e4").
-  """
-  board = obs.board
-  board_obj = chess.Board(board)
-  moves = list(board_obj.legal_moves)
-  return random.choice(moves).uci()
+    """
+    game = Game(obs.board)
+    moves = list(game.get_moves())
+    return random.choice(moves) if moves else None
+
+
+def king_shuffle_agent(obs):
+    """Moves the king pawn and then shuffles the king."""
+    game = Game(obs.board)
+    moves = list(game.get_moves())
+
+    to_move = ["e7e5", "e2e4", "e8e7", "e7e8", "e1e2", "e2e1"]
+    for move in to_move:
+        if move in moves:
+            return move
+
+    # If no other moves are possible, pick a random legal move (or return None)
+    return random.choice(moves) if moves else None
+
+
+def board_shuffle_agent(obs):
+    """Moves the king panw and then shuffles pieces."""
+    game = Game(obs.board)
+    moves = list(game.get_moves())
+
+    to_move = ["e7e5", "e2e4", "e8e7", "e7e6", "e1e2", "e2e3"]
+    for move in to_move:
+        if move in moves:
+            return move
+
+    # add shuffle moves for knights and bishop
+    to_shuffle = [
+        "b1c3",
+        "c3b1",
+        "g1f3",
+        "f3g1",
+        "b8c6",
+        "c6b8",
+        "g8f6",
+        "f6g8",
+        "f1e2",
+        "e2f1",
+        "f8e7",
+        "e7f8",
+    ]
+    # filter to only shuffle king moves
+    for move in moves:
+        f1 = move[0]
+        f2 = move[2]
+        r1 = int(move[1])
+        r2 = int(move[3])
+        df = abs(ord(f1) - ord(f2))
+        dr = abs(r2 - r1)
+        if r1 < 3 or r1 > 6:
+            continue
+        if r2 < 3 or r2 > 6:
+            continue
+        if dr > 1 or df > 1:
+            continue
+        if move[2:4] == "e5":
+            continue
+        if move[2:4] == "e4":
+            continue
+        to_shuffle.append(move)
+    random.shuffle(to_shuffle)
+    for move in to_shuffle:
+        if move in moves:
+            return move
+
+    # If no other moves are possible, pick a random legal move (or return None)
+    return random.choice(moves) if moves else None
+
+
+agents = {
+    "random": random_agent,
+    "king_shuffle": king_shuffle_agent,
+    "board_shuffle": board_shuffle_agent}
+
+
+def sufficient_material(pieces):
+    """Checks if the given pieces are sufficient for checkmate."""
+    if pieces['q'] > 0 or pieces['r'] > 0 or pieces['p'] > 0:
+        return True
+    # we only have knights and bishops left on this team
+    knight_bishop_count = pieces['n'] + pieces['b']
+    if knight_bishop_count >= 3:
+        return True
+    if knight_bishop_count == 2 and pieces['b'] >= 1:
+        return True
+
+    return False
+
+
+def is_insufficient_material(board):
+    white_pieces = defaultdict(int)
+    black_pieces = defaultdict(int)
+
+    for square in range(64):
+        piece = board.get_piece(square)
+        if piece and piece != " ":
+            if piece.isupper():
+                white_pieces[piece.lower()] += 1
+            else:
+                black_pieces[piece.lower()] += 1
+
+    if not sufficient_material(
+            white_pieces) and not sufficient_material(black_pieces):
+        return True
+
+    return False
+
+
+def square_str_to_int(square_str):
+    """Converts a square string (e.g., "a2") to an integer index (0-63)."""
+    if len(square_str) != 2 or not (
+            'a' <= square_str[0] <= 'h' and '1' <= square_str[1] <= '8'):
+        raise ValueError("Invalid square string")
+
+    col = ord(square_str[0]) - ord('a')  # Get column index (0-7)
+    row = int(square_str[1]) - 1        # Get row index (0-7)
+    return row * 8 + col
+
+
+seen_positions = defaultdict(int)
+game_one_complete = False
+game_start_position = math.floor(random.random() * len(OPENINGS))
 
-agents = {"random": random_agent}
 
 def interpreter(state, env):
+    global seen_positions
+    global game_one_complete
+    global game_start_position
     if env.done:
+        game_one_complete = False
+        seen_positions = defaultdict(int)
+        game_start_position = math.floor(random.random() * len(OPENINGS))
+        state[0].observation.board = OPENINGS[game_start_position]
+        state[1].observation.board = OPENINGS[game_start_position]
+        return state
+
+    if state[0].status == ACTIVE and state[1].status == ACTIVE:
+        # set up new game
+        state[0].observation.mark, state[1].observation.mark = state[1].observation.mark, state[0].observation.mark
+        state[0].observation.board = OPENINGS[game_start_position]
+        state[1].observation.board = OPENINGS[game_start_position]
+        state[0].status = ACTIVE if state[0].observation.mark == WHITE else INACTIVE
+        state[0].status = ACTIVE if state[0].observation.mark == WHITE else INACTIVE
         return state
 
     # Isolate the active and inactive agents.
@@ -36,39 +201,44 @@ def interpreter(state, env):
     # The board is shared, only update the first state.
     board = state[0].observation.board
 
-    # Create a chess board object from the FEN string
-    board_obj = chess.Board(board)
+   # Create a chessnut game object from the FEN string
+    game = Game(board)
 
     # Get the action (move) from the agent
     action = active.action
 
     # Check if the move is legal
     try:
-        move = chess.Move.from_uci(action)
-        if not board_obj.is_legal(move):
-            raise ValueError("Illegal move") 
-    except:
+        game.apply_move(action)
+    except BaseException:
         active.status = ERROR
         active.reward = -1
         inactive.status = DONE
         return state
-
-    # Make the move
-    board_obj.push(move)
+    fen = game.get_fen()
+    board_str = fen.split(" ", maxsplit=1)[0]
+    seen_positions[board_str] += 1
 
     # Update the board in the observation
-    state[0].observation.board = board_obj.fen() 
-    state[1].observation.board = board_obj.fen()
+    state[0].observation.board = fen
+    state[1].observation.board = fen
 
+    terminal_state = DONE if game_one_complete else ACTIVE
+    pawn_or_capture_move_count = int(
+        fen.split(" ")[4])  # fen keeps track of this
     # Check for game end conditions
-    if board_obj.is_checkmate():
-        active.reward = 1
-        active.status = DONE
-        inactive.reward = -1
-        inactive.status = DONE
-    elif board_obj.is_stalemate() or board_obj.is_insufficient_material() or board_obj.is_game_over():
-        active.status = DONE
-        inactive.status = DONE
+    if pawn_or_capture_move_count == 100 or is_insufficient_material(
+            game.board) or seen_positions[board_str] >= 3 or game.status == Game.STALEMATE:
+        active.reward += .5
+        inactive.reward += .5
+        active.status = terminal_state
+        inactive.status = terminal_state
+        game_one_complete = True
+    elif game.status == Game.CHECKMATE:
+        active.reward += 1
+        active.status = terminal_state
+        inactive.status = terminal_state
+        game_one_complete = True
     else:
         # Switch turns
         active.status = INACTIVE
@@ -76,34 +246,19 @@ def interpreter(state, env):
 
     return state
 
+
 def renderer(state, env):
-  board_str = state[0].observation.board
-  board_obj = chess.Board(board_str)
-
-  # Unicode characters for chess pieces
-  piece_symbols = {
-      'P': '♙', 'R': '♖', 'N': '♘', 'B': '♗', 'Q': '♕', 'K': '♔',
-      'p': '♟', 'r': '♜', 'n': '♞', 'b': '♝', 'q': '♛', 'k': '♚',
-      '.': ' '  # Empty square
-  }
-
-  board_repr = ""
-  for square in chess.SQUARES:
-    piece = board_obj.piece_at(square)
-    if piece:
-      board_repr += piece_symbols[piece.symbol()]
-    else:
-      board_repr += piece_symbols['.']
-    if chess.square_file(square) == 7:  # End of a rank
-      board_repr += "\n"
+    board_fen = state[0].observation.board
+    game = Game(board_fen)
+    return game.board
 
-  return board_repr
 
 jsonpath = path.abspath(path.join(path.dirname(__file__), "chess.json"))
 with open(jsonpath) as f:
     specification = json.load(f)
 
+
 def html_renderer():
     jspath = path.abspath(path.join(path.dirname(__file__), "chess.js"))
-    with open(jspath) as f:
-        return f.read()
+    with open(jspath) as g:
+        return g.read()

kaggle_environments/envs/chess/test_chess.py

@@ -1,8 +1,50 @@
 from kaggle_environments import make
+from Chessnut import Game
+from chess import is_insufficient_material
 
 def test_chess_inits():
     env = make("chess", debug=True)
     env.run(["random", "random"])
     json = env.toJSON()
     assert json["name"] == "chess"
-    assert json["statuses"] == ["ERROR", "DONE"]
+    assert json["statuses"] == ["DONE", "DONE"]
+
+def test_chess_three_fold():
+    env = make("chess", debug=True)
+    env.run(["king_shuffle", "king_shuffle"])
+    json = env.toJSON()
+    assert json["name"] == "chess"
+    assert json["statuses"] == ["DONE", "DONE"]
+    assert json["rewards"] == [0, 0]
+
+def test_chess_100_move_rule():
+    env = make("chess", debug=True)
+    env.run(["board_shuffle", "board_shuffle"])
+    json = env.toJSON()
+    assert json["name"] == "chess"
+    assert json["statuses"] == ["DONE", "DONE"]
+    assert json["rewards"] == [0, 0]
+
+def test_sufficient_material():
+    game = Game()
+    assert not is_insufficient_material(game.board)
+
+def test_insufficient_material_with_two_kings():
+    game = Game('8/8/K7/8/8/3k4/8/8 w - - 58 282')
+    assert is_insufficient_material(game.board)
+
+def test_insufficient_material_with_two_kings_and_bishop():
+    game = Game('6k1/8/7B/8/8/8/8/2K5 b - - 90 250')
+    assert is_insufficient_material(game.board)
+
+def test_insufficient_material_with_two_kings_and_two_knights():
+    game = Game('6k1/8/6NN/8/8/8/8/2K5 b - - 90 250')
+    assert is_insufficient_material(game.board)
+
+def test_sufficient_material_with_king_knight_and_bishop():
+    game = Game('6k1/8/6NB/8/8/8/8/2K5 b - - 90 250')
+    assert not is_insufficient_material(game.board)
+
+def test_sufficient_material_with_king_bishop_and_bishop():
+    game = Game('6k1/8/6BB/8/8/8/8/2K5 b - - 90 250')
+    assert not is_insufficient_material(game.board)

kaggle_environments/envs/lux_ai_s3/agents.py

@@ -0,0 +1,4 @@
+from .test_agents.python.main import agent_fn as random_agent
+all_agents = {
+    "random_agent": random_agent,
+}

kaggle_environments/envs/lux_ai_s3/index.html

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="https://s3vis.lux-ai.org/eye.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
+    <title>Lux Eye S3</title>
+
+    <!-- Start Single Page Apps for GitHub Pages -->
+    <script type="text/javascript">
+      // Single Page Apps for GitHub Pages
+      // MIT License
+      // https://github.com/rafgraph/spa-github-pages
+      // This script checks to see if a redirect is present in the query string,
+      // converts it back into the correct url and adds it to the
+      // browser's history using window.history.replaceState(...),
+      // which won't cause the browser to attempt to load the new url.
+      // When the single page app is loaded further down in this file,
+      // the correct url will be waiting in the browser's history for
+      // the single page app to route accordingly.
+      (function (l) {
+        if (l.search[1] === '/') {
+          const decoded = l.search
+            .slice(1)
+            .split('&')
+            .map(function (s) {
+              return s.replace(/~and~/g, '&');
+            })
+            .join('?');
+          window.history.replaceState(null, null, l.pathname.slice(0, -1) + decoded + l.hash);
+        }
+      })(window.location);
+    </script>
+    <!-- End Single Page Apps for GitHub Pages -->
+    <script type="module" crossorigin src="https://s3vis.lux-ai.org/index.js"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+    
+  </body>
+</html>

kaggle_environments/envs/lux_ai_s3/lux_ai_s3.json

@@ -0,0 +1,47 @@
+{
+  "name": "lux_ai_s3",
+  "title": "Lux AI Challenge Season 3",
+  "description": "A Novel AI Programming Challenge about Lux",
+  "version": "0.0.1",
+  "agents": [2],
+  "configuration": {
+    "episodeSteps": 506,
+    "seed": {
+      "description": "Seed to use for episodes",
+      "type": "integer"
+    },
+    "actTimeout": 3,
+    "runTimeout": 60,
+    "env_cfg": {
+      "description": "Environment configuration. Not to be filled out by user as it is randomly generated.",
+      "type": "object"
+    }
+  },
+  "reward": {
+    "description": "Reward of the agent. Equal to number of games won.",
+    "type": "integer",
+    "default": 0
+  },
+  "observation": {
+    "remainingOverageTime": 60,
+    "reward": {
+      "description": "Current reward of the agent. Equal to amount of lichen grown.",
+      "type": "integer",
+      "default": 0
+    },
+    "obs": {
+      "description": "String containing the observations",
+      "type": "string",
+      "shared": false
+    },
+    "player": {
+      "description": "Current player's index / team id",
+      "type": "string",
+      "defaults": "player_0"
+    }
+  },
+  "action": {
+    "description": "Actions",
+    "type": "object"
+  }
+}

kaggle_environments/envs/lux_ai_s3/lux_ai_s3.py

@@ -0,0 +1,138 @@
+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__)
+
+from luxai_s3.wrappers import LuxAIS3GymEnv, RecordEpisode
+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: RecordEpisode = 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):
+    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

kaggle_environments/envs/lux_ai_s3/luxai_s3/__init__.py

@@ -0,0 +1 @@
+from .env import LuxAIS3Env