kaggle-environments 1.17.8__tar.gz → 1.24.3__tar.gz

kaggle_environments-1.24.3/.gcloudignore

@@ -0,0 +1,17 @@
+# This file specifies files that are *not* uploaded to Google Cloud Platform
+# using gcloud. It follows the same syntax as .gitignore, with the addition of
+# "#!include" directives (which insert the entries of the given .gitignore-style
+# file at that point).
+#
+# For more information, run:
+#   $ gcloud topic gcloudignore
+#
+.gcloudignore
+# If you would like to upload your .git directory, .gitignore file or files
+# from your .gitignore file, remove the corresponding line
+# below:
+.git
+.gitignore
+
+node_modules
+#!include:.gitignore

kaggle_environments-1.24.3/.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# pyenv
+bin/
+lib64
+pyvenv.cfg
+share/
+
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+!docker/envs/football/egl/gfootball/env/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Temp Files
+temp.*
+
+.idea/
+
+# Git merge artifacts
+*.orig
+
+# node.js files
+node_modules
+**/node_modules
+**/tsconfig.tsbuildinfo
+
+# Java class files
+*.class
+
+.vscode
+
+submission.tar.gz
+
+replay.html
+
+
+# Mac cruft
+__MACOSX/
+*.DS_Store

kaggle_environments-1.24.3/.prettierrc.js

@@ -0,0 +1,16 @@
+module.exports = {
+  overrides: [
+    {
+      // Target all JavaScript and TypeScript files
+      files: ['*.js', '*.jsx', '*.ts', '*.tsx'],
+      options: {
+        tabWidth: 2,
+        singleQuote: true,
+        trailingComma: 'preserve',
+        quoteProps: 'preserve',
+        semi: true,
+        printWidth: 120
+      }
+    }
+  ]
+};

kaggle_environments-1.24.3/.stylelintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+    extends: ['stylelint-config-recommended'],
+    customSyntax: 'postcss-styled-syntax'
+};

kaggle_environments-1.24.3/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# How to Contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution;
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to <https://cla.developers.google.com/> to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
+
+## Community Guidelines
+
+This project follows
+[Google's Open Source Community Guidelines](https://opensource.google/conduct/).

{kaggle_environments-1.17.8 → kaggle_environments-1.24.3}/MANIFEST.in

@@ -4,4 +4,7 @@ recursive-include kaggle_environments *.html
 recursive-include kaggle_environments *.js
 recursive-include kaggle_environments *.ts
 global-exclude */node_modules
-recursive-include kaggle_environments *.json
+recursive-include kaggle_environments *.json
+recursive-include kaggle_environments *.jsonl
+recursive-include kaggle_environments/envs/cabt *.so
+recursive-include kaggle_environments/envs/cabt *.dll

kaggle_environments-1.24.3/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: kaggle-environments
+Version: 1.24.3
+Summary: Kaggle Environments
+Author-email: Kaggle <support@kaggle.com>
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: accelerate
+Requires-Dist: bitsandbytes
+Requires-Dist: Flask >= 1.1.2
+Requires-Dist: gymnasium == 1.2.0
+Requires-Dist: gymnax==0.0.8
+Requires-Dist: jax
+Requires-Dist: jsonschema >= 3.0.1
+Requires-Dist: litellm
+Requires-Dist: numpy >= 2.2.6
+Requires-Dist: open_spiel >= 1.6.8
+Requires-Dist: pettingzoo == 1.24.0
+Requires-Dist: pokerkit==0.6.3
+Requires-Dist: pydantic >= 2.11.4
+Requires-Dist: pygame
+Requires-Dist: pyjson5
+Requires-Dist: termcolor
+Requires-Dist: requests >= 2.25.1
+Requires-Dist: shimmy >= 1.2.1
+Requires-Dist: stable-baselines3 == 2.7.0
+Requires-Dist: transformers >= 4.33.1
+Requires-Dist: tenacity
+Requires-Dist: google-auth >= 2.35.0
+Project-URL: Homepage, https://github.com/Kaggle/kaggle-environments

{kaggle_environments-1.17.8 → kaggle_environments-1.24.3}/README.md

@@ -1,7 +1,7 @@
 # [<img src="https://kaggle.com/static/images/site-logo.png" height="50" style="margin-bottom:-15px" />](https://kaggle.com) Environments
 
 ```bash
-pip install kaggle-environments
+uv pip install kaggle-environments
 ```
 
 # TLDR;
@@ -284,72 +284,3 @@ The following rendering modes are supported:
 out = env.render(mode="ansi")
 print(out)
 ```
-
-# Command Line
-
-```sh
-> python main.py -h
-```
-
-## List Registered Environments
-
-```sh
-> python main.py list
-```
-
-## Evaluate Episode Rewards
-
-```sh
-python main.py evaluate --environment tictactoe --agents random random --episodes 10
-```
-
-## Run an Episode
-
-```sh
-> python main.py run --environment tictactoe --agents random /pathtomy/agent.py --debug True
-```
-
-## Load an Episode
-
-This is useful when converting an episode json output into html.
-
-```sh
-python main.py load --environment tictactoe --steps [...] --render '{"mode": "html"}'
-```
-
-# HTTP Server
-
-The HTTP server contains the same interface/actions as the CLI above merging both POST body and GET params.
-
-## Setup
-
-```bash
-python main.py http-server --port=8012 --host=0.0.0.0
-```
-
-### Running Agents on Separate Servers
-
-```python
-# How to run agent on a separate server.
-import requests
-import json
-
-path_to_agent1 = "/home/ajeffries/git/playground/agent1.py"
-path_to_agent2 = "/home/ajeffries/git/playground/agent2.py"
-
-agent1_url = f"http://localhost:5001?agents[]={path_to_agent1}"
-agent2_url = f"http://localhost:5002?agents[]={path_to_agent2}"
-
-body = {
-    "action": "run",
-    "environment": "tictactoe",
-    "agents": [agent1_url, agent2_url]
-}
-resp = requests.post(url="http://localhost:5000", data=json.dumps(body)).json()
-
-# Inflate the response replay to visualize.
-from kaggle_environments import make
-env = make("tictactoe", steps=resp["steps"], debug=True)
-env.render(mode="ipython")
-print(resp)
-```

kaggle_environments-1.24.3/VISUALIZER_README.md

@@ -0,0 +1,89 @@
+# Kaggle Environments Visualizer Development
+
+This document provides technical guidance for developers working on simulation visualizers. It covers the current Vite-based development workflow and explains the legacy Cloud Function-based system for historical context.
+
+## How to Develop a Visualizer (Vite Workflow)
+
+All new visualizers are developed as standalone packages within a `pnpm` monorepo. This approach uses Vite for a fast, modern development experience with hot-reloading and generates static assets for production.
+
+### 1. Directory Structure
+
+Each visualizer lives in its own package directory. To create a new visualizer for a game named `my-game`, you would create the following structure:
+
+```
+/kaggle_environments
+└── envs/
+    └── my-game/
+        ├── my-game.py
+        └── visualizer/
+            └── default/
+                ├── src/
+                │   └── main.ts         // Your visualizer's entry point
+                ├── index.html          // The HTML entry point for Vite
+                ├── package.json        // Defines dependencies (e.g., three.js)
+                ├── tsconfig.json       // TypeScript configuration
+                └── vite.config.ts      // Vite configuration (can often extend a base config)
+```
+
+### 2. Development Workflow
+
+1.  **Install Dependencies**: From the root of the `kaggle-environments` repository, run `pnpm install`. This will install all dependencies for all visualizer packages.
+
+2.  **Run the Dev Server**: To start the development server for a specific visualizer, use the `--filter` flag with the `pnpm dev` script. For example, to run the `connectx` visualizer:
+
+    ```bash
+    # The package name is defined in kaggle_environments/envs/connectx/visualizer/default/package.json
+    pnpm --filter @kaggle-environments/connectx-visualizer dev
+    ```
+
+    This will start a local server with hot-reloading, allowing you to see your changes instantly.
+
+    You can also run the dev server from the folder you are working in, or just run `pnpm dev` from the root of the repository and a selector will find the currently existing visualizers
+
+### 3. Data Handling
+
+Visualizers are rendered inside an iframe on the Kaggle platform. The replay data is not loaded directly by the visualizer. Instead, it is passed from the parent window using `window.postMessage`.
+
+Your `main.ts` file should include a listener to receive this data:
+
+```typescript
+// src/main.ts
+
+window.addEventListener("message", (event) => {
+  const replayData = event.data;
+
+  render(replayData);
+});
+
+function render(data) {
+  console.log("Received data:", data);
+}
+```
+
+A test replay file (e.g., `replays/test-replay.json`) is often included in the visualizer package to allow for local development and testing of the rendering logic.
+
+### 4. Building for Production
+
+To create a production-ready build, run the build script from the root directory:
+
+```bash
+pnpm build
+```
+
+This command iterates through all visualizer packages and runs `vite build` for each one, generating a `dist` directory containing the optimized static HTML, JavaScript, and CSS files. These are the files that will be deployed to Google Cloud Storage (GCS).
+
+---
+
+## How the Legacy System Worked (Cloud Function)
+
+The previous system relied on a Google Cloud Function to render visualizers on the server side. This process is now deprecated but is documented here for context.
+
+### Rendering Process
+
+1.  **Request**: A user's browser requested a replay from the Kaggle backend.
+2.  **Cloud Function Invocation**: If a pre-rendered static HTML file was not available in GCS, the backend invoked a Cloud Function.
+3.  **File Fetching**: The Cloud Function would fetch the necessary raw assets from the repository, such as a generic `player.html` template and the game-specific JavaScript file (e.g., `connectx.js`).
+4.  **On-the-Fly Bundling**: The function would dynamically inject the game's JavaScript and the replay JSON data directly into the HTML template. The replay data was often placed inside a `<script>` tag as a global variable.
+5.  **Response**: The fully-formed HTML file was returned to the user's browser and rendered.
+
+This server-side rendering approach was slow and made for a difficult developer experience, which is why the project was migrated to the current static-site generation model.

kaggle_environments-1.24.3/cicd/cloudbuild.yaml

@@ -0,0 +1,51 @@
+steps:
+  # Step 1: Install dependencies, sync versions, and build all static assets.
+  # This runs our 'build-ci' script which builds all visualizers and
+  # collects the artifacts into a single './build' directory.
+  - name: "gcr.io/cloud-builders/npm"
+    id: "build-all-visualizers"
+    entrypoint: "bash"
+    args:
+      - "-c"
+      - |
+        set -e
+        apt-get update && apt-get install -y jq
+        npm install -g pnpm
+        pnpm install
+        node web/scripts/sync-version.js
+        pnpm build-ci
+
+  # Step 2: Publish the core package to NPM.
+  # This runs after the build to ensure the package is up-to-date.
+  - name: "gcr.io/cloud-builders/npm"
+    id: "publish-to-npm"
+    entrypoint: "bash"
+    args: ["web/scripts/publish-core.sh"]
+    waitFor: ["build-all-visualizers"]
+    secretEnv: ["NPM_TOKEN"]
+
+  # Step 3: Deploy the collected artifacts to Google Cloud Storage.
+  # 'rsync -d' syncs the directory and deletes any files in the destination
+  # that are not in the source, We probably want to change this to keep versions
+  # once we figure out a decent versioning scheme.
+  - name: "gcr.io/cloud-builders/gcloud"
+    id: "deploy-to-gcs"
+    entrypoint: "gsutil"
+    args:
+      - "-m"
+      - "rsync"
+      - "-d"
+      - "-r"
+      - "./build"
+      - "gs://$_BUCKET_NAME/episode-visualizers"
+    waitFor: ["publish-to-npm"]
+
+substitutions:
+  _BUCKET_NAME: "kaggle-static"
+
+availableSecrets:
+  secretManager:
+    - versionName: projects/kaggle-cicd/secrets/npm-token-kaggle-environments/versions/latest
+      env: "NPM_TOKEN"
+
+tags: ["kaggle-environments", "visualizer-deployment", "npm-publish"]

kaggle_environments-1.24.3/deprecated_envs/README.md

@@ -0,0 +1,4 @@
+### Deprecation causes:
+- chess: required a special Dockerfile with all other environments deleted.
+- Lux AI s2: dependency conflicts due to `vec_noise`.
+- LLM 20 questions: required gymnasium < 1.0.

{kaggle_environments-1.17.8/kaggle_environments/envs → kaggle_environments-1.24.3/deprecated_envs}/chess/chess.py

@@ -1,8 +1,8 @@
+import json
 import math
 import random
-import json
-from os import path
 from collections import defaultdict
+from os import path
 
 from Chessnut import Game
 
@@ -4097,21 +4097,18 @@ def board_shuffle_agent(obs):
     return random.choice(moves) if moves else None
 
 
-agents = {
-    "random": random_agent,
-    "king_shuffle": king_shuffle_agent,
-    "board_shuffle": board_shuffle_agent}
+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:
+    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']
+    knight_bishop_count = pieces["n"] + pieces["b"]
     if knight_bishop_count >= 3:
         return True
-    if knight_bishop_count == 2 and pieces['b'] >= 1:
+    if knight_bishop_count == 2 and pieces["b"] >= 1:
         return True
 
     return False
@@ -4129,8 +4126,7 @@ def is_insufficient_material(board):
             else:
                 black_pieces[piece.lower()] += 1
 
-    if not sufficient_material(
-            white_pieces) and not sufficient_material(black_pieces):
+    if not sufficient_material(white_pieces) and not sufficient_material(black_pieces):
         return True
 
     return False
@@ -4138,12 +4134,11 @@ def is_insufficient_material(board):
 
 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'):
+    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)
+    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
 
 
@@ -4173,7 +4168,7 @@ def interpreter(state, env):
     # The board is shared, only update the first state.
     board = state[0].observation.board
 
-   # Create a Chessnut game object from the FEN string
+    # Create a Chessnut game object from the FEN string
     game = Game(board)
 
     # Get the action (move) from the agent
@@ -4190,7 +4185,7 @@ def interpreter(state, env):
     fen = game.get_fen()
     # board, player turn, en passant, and castling status form board status
     # for 3-fold draws
-    board_position = ' '.join(fen.split()[:4])
+    board_position = " ".join(fen.split()[:4])
     seen_positions[board_position] += 1
 
     # Update the board in the observation
@@ -4205,13 +4200,16 @@ def interpreter(state, env):
     state[0].observation.lastMove = action
     state[1].observation.lastMove = action
 
-    pawn_or_capture_move_count = int(
-        fen.split(" ")[4])  # fen keeps track of this
+    pawn_or_capture_move_count = int(fen.split(" ")[4])  # fen keeps track of this
     # Check for game end conditions
-    if pawn_or_capture_move_count == 100 or is_insufficient_material(
-            game.board) or seen_positions[board_position] >= 3 or game.status == Game.STALEMATE:
-        active.reward += .5
-        inactive.reward += .5
+    if (
+        pawn_or_capture_move_count == 100
+        or is_insufficient_material(game.board)
+        or seen_positions[board_position] >= 3
+        or game.status == Game.STALEMATE
+    ):
+        active.reward += 0.5
+        inactive.reward += 0.5
         active.status = DONE
         inactive.status = DONE
     elif game.status == Game.CHECKMATE:

{kaggle_environments-1.17.8/kaggle_environments/envs → kaggle_environments-1.24.3/deprecated_envs}/chess/test_chess.py

@@ -1,6 +1,8 @@
-from kaggle_environments import make
-from Chessnut import Game
 from chess import is_insufficient_material
+from Chessnut import Game
+
+from kaggle_environments import make
+
 
 def test_chess_inits():
     env = make("chess", debug=True)
@@ -9,6 +11,7 @@ def test_chess_inits():
     assert json["name"] == "chess"
     assert json["statuses"] == ["DONE", "DONE"]
 
+
 def test_chess_three_fold():
     env = make("chess", debug=True)
     env.run(["king_shuffle", "king_shuffle"])
@@ -17,6 +20,7 @@ def test_chess_three_fold():
     assert json["statuses"] == ["DONE", "DONE"]
     assert json["rewards"] == [0.5, 0.5]
 
+
 def test_chess_100_move_rule():
     env = make("chess", debug=True)
     env.run(["board_shuffle", "board_shuffle"])
@@ -25,26 +29,32 @@ def test_chess_100_move_rule():
     assert json["statuses"] == ["DONE", "DONE"]
     assert json["rewards"] == [0.5, 0.5]
 
+
 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')
+    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')
+    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')
+    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')
+    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)
+    game = Game("6k1/8/6BB/8/8/8/8/2K5 b - - 90 250")
+    assert not is_insufficient_material(game.board)