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

kaggle_environments/envs/chess/chess.json

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

kaggle_environments/envs/chess/chess.py

@@ -1,28 +1,194 @@
-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
 
-agents = {"random": random_agent}
+    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))
 
 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[0].observation.remainingOverageTime = 10
+        state[1].observation.board = OPENINGS[game_start_position]
+        state[1].observation.remainingOverageTime = 10
+        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 +202,46 @@ 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):
+        active.status = terminal_state
+        inactive.status = terminal_state
+        game_one_complete = True
+    elif seen_positions[board_str] >= 3 or game.status == Game.STALEMATE:
+        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 +249,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)