kaggle-environments 1.22.8__tar.gz → 1.24.2__tar.gz

{kaggle_environments-1.22.8 → kaggle_environments-1.24.2}/.gitignore

@@ -146,6 +146,8 @@ temp.*
 
 # node.js files
 node_modules
+**/node_modules
+**/tsconfig.tsbuildinfo
 
 # Java class files
 *.class

kaggle_environments-1.24.2/.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.2/.stylelintrc.js

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

{kaggle_environments-1.22.8 → kaggle_environments-1.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 1.22.8
+Version: 1.24.2
 Summary: Kaggle Environments
 Author-email: Kaggle <support@kaggle.com>
 Requires-Python: >=3.10

kaggle_environments-1.24.2/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.2/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.22.8 → kaggle_environments-1.24.2}/docker/cicd-publish-to-pypi.sh

@@ -1,15 +1,12 @@
 #!/bin/bash
 set -e
 
-# The python:3.11-slim container doesn't have git, which flit needs to build the package.
 echo "Installing git..."
 apt-get update -y && apt-get install -y git --no-install-recommends
 
-# Ensure python dependencies are installed first
 pip install requests --quiet
 
-# Read version directly from pyproject.toml
-PACKAGE_NAME="kaggle-environments" # Define package name for reuse
+PACKAGE_NAME="kaggle-environments"
 VERSION_FROM_PYPROJECT=$(grep -E "^version\s*=\s*\"[0-9]+\.[0-9]+\.[0-9]+\"$" pyproject.toml | cut -d '"' -f 2)
 CLOUD_RUN_REQS_PATH="docker/cloud-run-source/requirements.txt"
 
@@ -20,7 +17,6 @@ fi
 
 echo "Found version $VERSION_FROM_PYPROJECT in pyproject.toml. Checking against PyPI."
 
-# (Your Python script to check for existing version remains the same)
 cat > /tmp/check_pypi.py << EOL
 import sys
 import requests
@@ -52,6 +48,7 @@ else
 
   flit publish
   
+  # It takes a bit for the package to show up on PyPI. Make sure it's visible through Pip before proceeding.
   # --- RETRY LOGIC START ---
   echo "Verifying that package '$PACKAGE_NAME==$VERSION_FROM_PYPROJECT' is available from PyPI..."
   MAX_RETRIES=10
@@ -60,7 +57,6 @@ else
 
   for i in $(seq 1 $MAX_RETRIES)
   do
-    # Use 'pip install' with --no-cache-dir as the check. This is the most reliable method.
     if python -m pip install --no-cache-dir "$PACKAGE_NAME==$VERSION_FROM_PYPROJECT" --quiet; then
       echo "✅ Successfully found and installed package from PyPI."
       SUCCESS=true
@@ -75,11 +71,14 @@ else
     echo "❌ Failed to find package on PyPI after $MAX_RETRIES attempts. Aborting."
     exit 1
   fi
+  # --- SAFETY BUFFER ---
+  # The package is available, but let's wait a bit longer for CDN propagation.
+  echo "Waiting 45 seconds as a safety buffer for CDN propagation..."
+  sleep 45
   # --- RETRY LOGIC END ---
 
   echo "Successfully published and verified. Updating Cloud Run requirements at $CLOUD_RUN_REQS_PATH..."
   
-  # Use sed to replace the placeholder with the actual version
   sed -i "s/VERSION_FROM_CICD_DEPLOY/${VERSION_FROM_PYPROJECT}/" "$CLOUD_RUN_REQS_PATH"
   
   echo "Cloud Run requirements.txt updated."

kaggle_environments-1.24.2/docker/cloud-run-source/Procfile

@@ -0,0 +1 @@
+web: functions-framework --target=main

{kaggle_environments-1.22.8 → kaggle_environments-1.24.2}/docker/cloudbuild.yaml

@@ -61,10 +61,11 @@ steps:
       - |
         if [ -f /workspace/published_new_version.flag ]; then
           echo "✅ New version was published. Deploying update to Cloud Run."
-          gcloud run deploy kaggle-simulations-v2\
-            --source ./docker/cloud-run-source \
-            --region us-central1 \
-            --project kaggle-comps-prod-eval
+          gcloud run deploy kaggle-simulations-v2 \
+          --source ./docker/cloud-run-source \
+          --region us-central1 \
+          --project kaggle-comps-prod-eval
+          # This command implicitly updates traffic to 100% on the new revision
         else
           echo "⏩ No new version was published. Skipping Cloud Run deployment."
         fi

kaggle_environments-1.24.2/eslint.config.mjs

@@ -0,0 +1,14 @@
+import eslint from "@eslint/js";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
+
+export default defineConfig([
+  eslint.configs.recommended,
+  tseslint.configs.recommended,
+  {
+    files: ["**/*.ts", "**/*.tsx", "**/*.d.ts"], // Apply these rules only to TypeScript files
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+    },
+  },
+]);

kaggle_environments-1.24.2/kaggle_environments/envs/connectx/visualizer/default/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>ConnectX Visualizer</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

kaggle_environments-1.24.2/kaggle_environments/envs/connectx/visualizer/default/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@kaggle-environments/connectx-visualizer",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "cross-env VITE_REPLAY_FILE=./replays/test-replay.json vite",
+    "dev:iframe": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "cross-env": "^10.1.0",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0"
+  },
+  "dependencies": {
+    "@kaggle-environments/core": "workspace:*",
+    "htm": "^3.1.1",
+    "preact": "^10.27.2"
+  }
+}