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

kaggle_environments/agent.py

@@ -174,8 +174,8 @@ class Agent:
             out = out_buffer.getvalue()
             err = err_buffer.getvalue()
             # Get the maximum log length
-            # Allow up to 1k (default) log characters per step which is ~1MB per 600 step episode
-            max_log_length = self.configuration.get('maxLogLength', 1024)
+            # Allow up to 10k (default) log characters per step which is ~10MB per 600 step episode
+            max_log_length = self.configuration.get('maxLogLength', 10000)
 
             # truncate if max_log_length is set to None, do not truncate
             if max_log_length is not None:

kaggle_environments/core.py

@@ -608,8 +608,8 @@ class Environment:
                     err = err_buffer.getvalue()
 
                     # strip if needed
-                    # Allow up to 1k (default) log characters per step which is ~1MB per 600 step episode
-                    max_log_length = self.configuration.get("maxLogLength", 1024)
+                    # Allow up to 10k (default) log characters per step which is ~10MB per 600 step episode
+                    max_log_length = self.configuration.get("maxLogLength", 10000)
                     if max_log_length is not None:
                         out = out[0:max_log_length]
                         err = err[0:max_log_length]

kaggle_environments/envs/open_spiel/games/chess/chess.js

@@ -1,41 +1,39 @@
 function renderer(options) {
-    const { environment, step, parent } = options;
+    const { environment, step, parent, width = 400, height = 400 } = options; // Chess-specific constants
 
-    // Chess-specific constants
     const DEFAULT_NUM_ROWS = 8;
     const DEFAULT_NUM_COLS = 8;
     const PIECE_SVG_URLS = {
-        'p': 'https://upload.wikimedia.org/wikipedia/commons/c/c7/Chess_pdt45.svg', // Black Pawn
-        'r': 'https://upload.wikimedia.org/wikipedia/commons/f/ff/Chess_rdt45.svg', // Black Rook
-        'n': 'https://upload.wikimedia.org/wikipedia/commons/e/ef/Chess_ndt45.svg', // Black Knight
-        'b': 'https://upload.wikimedia.org/wikipedia/commons/9/98/Chess_bdt45.svg', // Black Bishop
-        'q': 'https://upload.wikimedia.org/wikipedia/commons/4/47/Chess_qdt45.svg', // Black Queen
-        'k': 'https://upload.wikimedia.org/wikipedia/commons/f/f0/Chess_kdt45.svg', // Black King
-        'P': 'https://upload.wikimedia.org/wikipedia/commons/4/45/Chess_plt45.svg', // White Pawn
-        'R': 'https://upload.wikimedia.org/wikipedia/commons/7/72/Chess_rlt45.svg', // White Rook
-        'N': 'https://upload.wikimedia.org/wikipedia/commons/7/70/Chess_nlt45.svg', // White Knight
-        'B': 'https://upload.wikimedia.org/wikipedia/commons/b/b1/Chess_blt45.svg', // White Bishop
-        'Q': 'https://upload.wikimedia.org/wikipedia/commons/1/15/Chess_qlt45.svg', // White Queen
-        'K': 'https://upload.wikimedia.org/wikipedia/commons/4/42/Chess_klt45.svg'  // White King
+        p: 'https://upload.wikimedia.org/wikipedia/commons/c/c7/Chess_pdt45.svg', // Black Pawn
+        r: 'https://upload.wikimedia.org/wikipedia/commons/f/ff/Chess_rdt45.svg', // Black Rook
+        n: 'https://upload.wikimedia.org/wikipedia/commons/e/ef/Chess_ndt45.svg', // Black Knight
+        b: 'https://upload.wikimedia.org/wikipedia/commons/9/98/Chess_bdt45.svg', // Black Bishop
+        q: 'https://upload.wikimedia.org/wikipedia/commons/4/47/Chess_qdt45.svg', // Black Queen
+        k: 'https://upload.wikimedia.org/wikipedia/commons/f/f0/Chess_kdt45.svg', // Black King
+        P: 'https://upload.wikimedia.org/wikipedia/commons/4/45/Chess_plt45.svg', // White Pawn
+        R: 'https://upload.wikimedia.org/wikipedia/commons/7/72/Chess_rlt45.svg', // White Rook
+        N: 'https://upload.wikimedia.org/wikipedia/commons/7/70/Chess_nlt45.svg', // White Knight
+        B: 'https://upload.wikimedia.org/wikipedia/commons/b/b1/Chess_blt45.svg', // White Bishop
+        Q: 'https://upload.wikimedia.org/wikipedia/commons/1/15/Chess_qlt45.svg', // White Queen
+        K: 'https://upload.wikimedia.org/wikipedia/commons/4/42/Chess_klt45.svg' // White King
     };
     const LIGHT_SQUARE_COLOR = '#f0d9b5';
     const DARK_SQUARE_COLOR = '#b58863';
 
-    // Renderer state variables
     let currentBoardElement = null;
     let currentStatusTextElement = null;
     let currentWinnerTextElement = null;
     let currentMessageBoxElement = typeof document !== 'undefined' ? document.getElementById('messageBox') : null;
     let currentRendererContainer = null;
+    let currentBoardContainer = null;
     let currentTitleElement = null;
-    let squareSize = 50;
+    let squareSize = 0;
 
     function _showMessage(message, type = 'info', duration = 3000) {
         if (typeof document === 'undefined' || !document.body) return;
         if (!currentMessageBoxElement) {
             currentMessageBoxElement = document.createElement('div');
             currentMessageBoxElement.id = 'messageBox';
-            // Identical styling to the Connect Four renderer's message box
             Object.assign(currentMessageBoxElement.style, {
                 position: 'fixed',
                 top: '10px',
@@ -56,71 +54,148 @@ function renderer(options) {
         currentMessageBoxElement.textContent = message;
         currentMessageBoxElement.style.backgroundColor = type === 'error' ? '#ef4444' : '#10b981';
         currentMessageBoxElement.style.opacity = '1';
-        setTimeout(() => { if (currentMessageBoxElement) currentMessageBoxElement.style.opacity = '0'; }, duration);
+        setTimeout(() => {
+            if (currentMessageBoxElement) currentMessageBoxElement.style.opacity = '0';
+        }, duration);
     }
-
     function _ensureRendererElements(parentElementToClear, rows, cols) {
         if (!parentElementToClear) return false;
         parentElementToClear.innerHTML = '';
 
+        // NEW: Check for mobile screen size to apply responsive styles.
+        const isMobile = window.innerWidth < 768;
+
         currentRendererContainer = document.createElement('div');
         Object.assign(currentRendererContainer.style, {
             display: 'flex',
             flexDirection: 'column',
             alignItems: 'center',
-            padding: '20px',
+            padding: isMobile ? '10px' : '20px', // Responsive padding
             boxSizing: 'border-box',
             width: '100%',
             height: '100%',
             fontFamily: "'Inter', sans-serif"
         });
+        parentElementToClear.appendChild(currentRendererContainer);
 
         if (!environment.viewer) {
-          currentTitleElement = document.createElement('h1');
-          currentTitleElement.textContent = 'Chess';
-          // Identical styling to the Connect Four renderer's title
-          Object.assign(currentTitleElement.style, {
-            fontSize: '1.875rem',
-            fontWeight: 'bold',
-            marginBottom: '1rem',
-            textAlign: 'center',
-            color: '#2563eb'
-          });
-          currentRendererContainer.appendChild(currentTitleElement);
+            const headerContainer = document.createElement('div');
+            Object.assign(headerContainer.style, {
+                display: 'flex',
+                justifyContent: 'center',
+                alignItems: 'center',
+                width: '100%',
+                marginBottom: '1rem',
+                color: 'white',
+                flexShrink: '0',
+                flexDirection: isMobile ? 'column' : 'row' // Stacks header vertically on mobile
+            });
+
+            // Player 2 (White) - Left side
+            const whitePlayerContainer = document.createElement('div');
+            Object.assign(whitePlayerContainer.style, {
+                display: 'flex',
+                alignItems: 'center'
+            });
+            const whitePawnImg = document.createElement('img');
+            whitePawnImg.src = PIECE_SVG_URLS.P;
+            Object.assign(whitePawnImg.style, { height: '30px', marginRight: '8px' });
+            const whitePlayerName = document.createElement('span');
+            whitePlayerName.textContent = environment.info?.TeamNames?.[1] || 'Player 2';
+            Object.assign(whitePlayerName.style, {
+                fontSize: isMobile ? '1rem' : '1.1rem', // Responsive font size
+                fontWeight: 'bold'
+            });
+            whitePlayerContainer.appendChild(whitePawnImg);
+            whitePlayerContainer.appendChild(whitePlayerName);
+
+            // Center Title
+            currentTitleElement = document.createElement('h1');
+            currentTitleElement.textContent = 'Chess';
+            Object.assign(currentTitleElement.style, {
+                fontSize: isMobile ? '1.5rem' : '1.875rem', // Responsive font size
+                fontWeight: 'bold',
+                textAlign: 'center',
+                color: '#e5e7eb',
+                margin: isMobile ? '10px 0' : '0 40px', // Responsive margin
+                order: isMobile ? '0' : 'initial' // Ensures title is between players on desktop
+            });
+
+            // Player 1 (Black) - Right side
+            const blackPlayerContainer = document.createElement('div');
+            Object.assign(blackPlayerContainer.style, {
+                display: 'flex',
+                alignItems: 'center'
+            });
+            const blackPlayerName = document.createElement('span');
+            blackPlayerName.textContent = environment.info?.TeamNames?.[0] || 'Player 1';
+            Object.assign(blackPlayerName.style, {
+                fontSize: isMobile ? '1rem' : '1.1rem', // Responsive font size
+                fontWeight: 'bold'
+            });
+            const blackPawnImg = document.createElement('img');
+            blackPawnImg.src = PIECE_SVG_URLS.p;
+            Object.assign(blackPawnImg.style, { height: '30px', marginLeft: '8px' });
+            blackPlayerContainer.appendChild(blackPlayerName);
+            blackPlayerContainer.appendChild(blackPawnImg);
+
+            // Assemble the header - order matters for mobile stacking
+            if (isMobile) {
+                // On mobile: White Player, then Black Player, then Title for a "vs" feel
+                headerContainer.appendChild(whitePlayerContainer);
+                const vsText = document.createElement('div');
+                vsText.textContent = 'vs';
+                Object.assign(vsText.style, { margin: '4px 0', fontStyle: 'italic' });
+                headerContainer.appendChild(vsText);
+                headerContainer.appendChild(blackPlayerContainer);
+                // Title is not added here for mobile to keep it separate or could be added last
+            } else {
+                // On desktop: White Player, Title, Black Player
+                headerContainer.appendChild(whitePlayerContainer);
+                headerContainer.appendChild(currentTitleElement);
+                headerContainer.appendChild(blackPlayerContainer);
+            }
+            currentRendererContainer.appendChild(headerContainer);
         }
-        parentElementToClear.appendChild(currentRendererContainer);
 
-        const smallestParentEdge = Math.min(currentRendererContainer.offsetWidth, currentRendererContainer.offsetHeight);
-        squareSize = Math.floor(smallestParentEdge / DEFAULT_NUM_COLS);
+        // ... (The rest of the function for the board and status container remains the same, but let's add responsive fonts to the status)
+
+        // Board container...
+        currentBoardContainer = document.createElement('div');
+        Object.assign(currentBoardContainer.style, {
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center',
+            flexGrow: '1',
+            overflow: 'hidden',
+            width: '100%',
+            minHeight: '0'
+        });
+        currentRendererContainer.appendChild(currentBoardContainer);
+
+        // ... code to create board and squares ...
         currentBoardElement = document.createElement('div');
         Object.assign(currentBoardElement.style, {
             display: 'grid',
-            gridTemplateColumns: `repeat(${cols}, ${squareSize}px)`,
-            gridTemplateRows: `repeat(${rows}, ${squareSize}px)`,
-            width: `${cols * squareSize}px`,
-            height: `${rows * squareSize}px`,
             border: '2px solid #333'
         });
-
+        currentBoardContainer.appendChild(currentBoardElement);
         for (let r = 0; r < rows; r++) {
             for (let c = 0; c < cols; c++) {
                 const square = document.createElement('div');
                 square.id = `cell-${r}-${c}`;
                 Object.assign(square.style, {
-                    width: `${squareSize}px`,
-                    height: `${squareSize}px`,
                     backgroundColor: (r + c) % 2 === 0 ? LIGHT_SQUARE_COLOR : DARK_SQUARE_COLOR,
                     display: 'flex',
                     alignItems: 'center',
-                    justifyContent: 'center',
+                    justifyContent: 'center'
                 });
                 currentBoardElement.appendChild(square);
             }
         }
-        currentRendererContainer.appendChild(currentBoardElement);
 
+        // Status Container
         const statusContainer = document.createElement('div');
-        // Identical styling to the Connect Four renderer's status container
         Object.assign(statusContainer.style, {
             padding: '10px 15px',
             backgroundColor: 'white',
@@ -130,15 +205,16 @@ function renderer(options) {
             width: 'auto',
             minWidth: '200px',
             maxWidth: '90vw',
-            marginTop: '20px'
+            marginTop: '20px',
+            flexShrink: '0'
         });
         if (!environment.viewer) {
-          currentRendererContainer.appendChild(statusContainer);
+            currentRendererContainer.appendChild(statusContainer);
         }
 
         currentStatusTextElement = document.createElement('p');
         Object.assign(currentStatusTextElement.style, {
-            fontSize: '1.1rem',
+            fontSize: isMobile ? '0.9rem' : '1.1rem', // Responsive font size
             fontWeight: '600',
             margin: '0 0 5px 0'
         });
@@ -146,18 +222,41 @@ function renderer(options) {
 
         currentWinnerTextElement = document.createElement('p');
         Object.assign(currentWinnerTextElement.style, {
-            fontSize: '1.25rem',
+            fontSize: isMobile ? '1rem' : '1.25rem', // Responsive font size
             fontWeight: '700',
             margin: '5px 0 0 0'
         });
         statusContainer.appendChild(currentWinnerTextElement);
 
-        if (typeof document !== 'undefined' && !document.body.hasAttribute('data-renderer-initialized')) {
-            document.body.setAttribute('data-renderer-initialized', 'true');
-        }
         return true;
     }
 
+    function _getTeamNameForColor(color, teamNames) {
+        if (!teamNames || teamNames.length < 2) return null;
+        return color.toLowerCase() === 'white' ? teamNames[1] : teamNames[0];
+    }
+
+    function _deriveWinnerFromRewards(currentStepAgents, teamNames) {
+        if (!currentStepAgents || currentStepAgents.length < 2) return null;
+
+        const player0Reward = currentStepAgents[0].reward;
+        const player1Reward = currentStepAgents[1].reward;
+
+        if (player0Reward === player1Reward) {
+            return 'draw';
+        }
+
+        const winnerPlayerIndex = player0Reward === 1 ? 0 : 1;
+        const color = winnerPlayerIndex === 0 ? 'Black' : 'White';
+
+        if (teamNames) {
+            const teamName = _getTeamNameForColor(color, teamNames);
+            return `${color} (${teamName})`;
+        }
+
+        return color.toLowerCase();
+    }
+
     function _parseFen(fen) {
         if (!fen || typeof fen !== 'string') return null;
 
@@ -189,29 +288,51 @@ function renderer(options) {
         };
     }
 
-
     function _renderBoardDisplay(gameStateToDisplay, displayRows, displayCols) {
-        if (!currentBoardElement || !currentStatusTextElement || !currentWinnerTextElement) return;
+        if (!currentBoardContainer || !currentBoardElement || !currentStatusTextElement || !currentWinnerTextElement)
+            return;
+
+        const isMobile = window.innerWidth < 768;
+
+        // Calculate and apply board size
+        const containerWidth = currentBoardContainer?.clientWidth ?? width;
+        const containerHeight = currentBoardContainer?.clientHeight ?? height;
+        const smallestContainerEdge = Math.min(containerWidth, containerHeight);
+        const newSquareSize = Math.floor(smallestContainerEdge / displayCols);
+
+        if (newSquareSize !== squareSize) {
+            squareSize = newSquareSize;
+            Object.assign(currentBoardElement.style, {
+                gridTemplateColumns: `repeat(${displayCols}, ${squareSize}px)`,
+                gridTemplateRows: `repeat(${displayRows}, ${squareSize}px)`,
+                width: `${displayCols * squareSize}px`,
+                height: `${displayRows * squareSize}px`
+            });
 
-        // Clear board
+            const squares = currentBoardElement.querySelectorAll('div[id^="cell-"]');
+            squares.forEach((square) => {
+                Object.assign(square.style, {
+                    width: `${squareSize}px`,
+                    height: `${squareSize}px`
+                });
+            });
+        }
+
+        // Clear and render board pieces...
         for (let r = 0; r < displayRows; r++) {
             for (let c = 0; c < displayCols; c++) {
                 const squareElement = currentBoardElement.querySelector(`#cell-${r}-${c}`);
-                if (squareElement) {
-                    squareElement.innerHTML = '';
-                }
+                if (squareElement) squareElement.innerHTML = '';
             }
         }
-        
+
         if (!gameStateToDisplay || !gameStateToDisplay.board) {
-            currentStatusTextElement.textContent = "Waiting for game data...";
-            currentWinnerTextElement.textContent = "";
+            currentStatusTextElement.textContent = 'Waiting for game data...';
+            currentWinnerTextElement.textContent = '';
             return;
         }
 
-
         const { board, activeColor, isTerminal, winner } = gameStateToDisplay;
-
         const pieceSize = Math.floor(squareSize * 0.9);
         for (let r_data = 0; r_data < displayRows; r_data++) {
             for (let c_data = 0; c_data < displayCols; c_data++) {
@@ -227,73 +348,89 @@ function renderer(options) {
             }
         }
 
+        // Render status text
         currentStatusTextElement.innerHTML = '';
         currentWinnerTextElement.innerHTML = '';
         if (isTerminal) {
-            currentStatusTextElement.textContent = "Game Over!";
-            if (winner) {
-                 if (String(winner).toLowerCase() === 'draw') {
-                    currentWinnerTextElement.textContent = "It's a Draw!";
-                 } else {
-                    const winnerColor = String(winner).toLowerCase() === 'white' ? 'White' : 'Black';
-                    currentWinnerTextElement.innerHTML = `Winner: <span style="font-weight: bold;">${winnerColor}</span>`;
-                 }
+            const winnerText = winner
+                ? String(winner).toLowerCase() === 'draw'
+                    ? "It's a Draw!"
+                    : winner
+                : 'Game ended.';
+            if (isMobile) {
+                currentStatusTextElement.innerHTML = `<div style="font-size: 0.9rem; color: #666;">Winner</div>`;
+                currentWinnerTextElement.innerHTML = `<div style="font-size: 1.1rem; font-weight: bold;">${winnerText}</div>`;
             } else {
-                 currentWinnerTextElement.textContent = "Game ended.";
+                currentStatusTextElement.textContent = 'Game Over!';
+                currentWinnerTextElement.innerHTML = `Winner: <span style="font-weight: bold;">${winnerText}</span>`;
             }
         } else {
-          const playerColor = String(activeColor).toLowerCase() === 'w' ? 'White' : 'Black';
-          currentStatusTextElement.innerHTML = `Current Player: <span style="font-weight: bold;">${playerColor}</span>`;
+            const playerColor = String(activeColor).toLowerCase() === 'w' ? 'White' : 'Black';
+            const teamName = _getTeamNameForColor(playerColor, environment.info?.TeamNames);
+            const currentPlayerText = teamName ? `${playerColor} (${teamName})` : playerColor;
+
+            if (isMobile) {
+                currentStatusTextElement.innerHTML = `<div style="font-size: 0.9rem; color: #666;">Current Player</div>`;
+                currentWinnerTextElement.innerHTML = `<div style="font-size: 1.1rem; font-weight: bold;">${currentPlayerText}</div>`;
+            } else {
+                currentStatusTextElement.innerHTML = `Current Player: <span style="font-weight: bold;">${currentPlayerText}</span>`;
+                currentWinnerTextElement.innerHTML = ''; // Clear winner text when game is active
+            }
         }
     }
 
-    // --- Main execution logic ---
     if (!_ensureRendererElements(parent, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS)) {
         if (parent && typeof parent.innerHTML !== 'undefined') {
-            parent.innerHTML = "<p style='color:red; font-family: sans-serif;'>Critical Error: Renderer element setup failed.</p>";
+            parent.innerHTML =
+                "<p style='color:red; font-family: sans-serif;'>Critical Error: Renderer element setup failed.</p>";
         }
         return;
     }
 
     if (!environment || !environment.steps || !environment.steps[step]) {
         _renderBoardDisplay(null, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
-        if (currentStatusTextElement) currentStatusTextElement.textContent = "Initializing environment...";
+        if (currentStatusTextElement) currentStatusTextElement.textContent = 'Initializing environment...';
         return;
     }
 
     const currentStepAgents = environment.steps[step];
     if (!currentStepAgents || !Array.isArray(currentStepAgents) || currentStepAgents.length === 0) {
         _renderBoardDisplay(null, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
-        if (currentStatusTextElement) currentStatusTextElement.textContent = "Waiting for agent data...";
+        if (currentStatusTextElement) currentStatusTextElement.textContent = 'Waiting for agent data...';
         return;
     }
-    
-    // In chess, observation is the same for both agents. We can take it from the first.
+
     const agent = currentStepAgents[0];
 
     if (!agent || typeof agent.observation === 'undefined') {
         _renderBoardDisplay(null, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
-        if (currentStatusTextElement) currentStatusTextElement.textContent = "Waiting for observation data...";
+        if (currentStatusTextElement) currentStatusTextElement.textContent = 'Waiting for observation data...';
         return;
     }
     const observationForRenderer = agent.observation;
 
     let gameSpecificState = null;
 
-    if (observationForRenderer && typeof observationForRenderer.observationString === 'string' && observationForRenderer.observationString.trim() !== '') {
+    if (
+        observationForRenderer &&
+        typeof observationForRenderer.observationString === 'string' &&
+        observationForRenderer.observationString.trim() !== ''
+    ) {
         try {
             const fen = observationForRenderer.observationString;
             const parsedFen = _parseFen(fen);
             if (parsedFen) {
-                // Assuming `isTerminal` and `winner` are provided in the top-level observation
-                gameSpecificState = { 
+                const winner = observationForRenderer.isTerminal
+                    ? _deriveWinnerFromRewards(currentStepAgents, environment.info?.TeamNames)
+                    : null;
+                gameSpecificState = {
                     ...parsedFen,
                     isTerminal: observationForRenderer.isTerminal,
-                    winner: observationForRenderer.winner
+                    winner: winner
                 };
             }
         } catch (e) {
-            _showMessage("Error: Corrupted game state (obs_string).", 'error');
+            _showMessage('Error: Corrupted game state (obs_string).', 'error');
         }
     }
 

kaggle_environments/static/player.html

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 -->
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
   <head>
     <title>Kaggle Simulation Player</title>
@@ -96,7 +96,7 @@
             </g>
           </svg>
         </a>
-      `
+      `,
       )`
         display: inline-flex;
       `;
@@ -129,11 +129,9 @@
 
         useEffect(async () => {
           if (!ref.current) return;
-
           const renderFrame = async (start, step, lastFrame) => {
             if (step !== context.step) return;
             if (lastFrame === 1) {
-              if (!animate) return;
               start = Date.now();
             }
             const frame =
@@ -142,16 +140,18 @@
                 : 1;
             try {
               if (debug) console.time("render");
-              await renderer({
-                ...context,
-                frame,
-                height: ref.current.clientHeight,
-                hooks: preactHooks,
-                parent: ref.current,
-                preact,
-                styled,
-                width: ref.current.clientWidth,
-              });
+              if (typeof renderer === "function") {
+                await renderer({
+                  ...context,
+                  frame,
+                  height: ref.current.clientHeight,
+                  hooks: preactHooks,
+                  parent: ref.current,
+                  preact,
+                  styled,
+                  width: ref.current.clientWidth,
+                });
+              }
             } catch (error) {
               if (debug) console.error(error);
               console.log({ ...context, frame, error });
@@ -199,7 +199,7 @@
           ${processing && h`<${Processing} />`}
         </div>`;
       })`
-        background-color: #1C1D20;
+        background-color: #1c1d20;
         display: flex;
         flex: 1;
         overflow: hidden;
@@ -210,34 +210,40 @@
       // Partitions the elements of arr into subarrays of max length num.
       const groupIntoSets = (arr, num) => {
         const sets = [];
-        arr.forEach(a => {
+        arr.forEach((a) => {
           if (sets.length === 0 || sets[sets.length - 1].length === num) {
             sets.push([]);
           }
           sets[sets.length - 1].push(a);
         });
         return sets;
-      }
+      };
 
       // Expects `width` input prop to set proper max-width for agent name span.
       const Legend = styled((props) => {
         const { agents, legend } = useContext(Context);
 
-        const agentPairs = groupIntoSets(agents.sort((a, b) => a.index - b.index), 2);
+        const agentPairs = groupIntoSets(
+          agents.sort((a, b) => a.index - b.index),
+          2,
+        );
 
         return h`<div className=${props.className}>
-          ${agentPairs.map(agentList =>
-            h`<ul>
-                ${agentList.map(a =>
-                  h`<li key=${a.id} title="id: ${a.id}" style="color:${a.color || "#FFF"}">
+          ${agentPairs.map(
+            (agentList) =>
+              h`<ul>
+                ${agentList.map(
+                  (a) =>
+                    h`<li key=${a.id} title="id: ${a.id}" style="color:${a.color || "#FFF"}">
                       ${a.image && h`<img src=${a.image} />`}
                       <span>${a.name}</span>
-                    </li>`
+                    </li>`,
                 )}
-              </ul>`)}
+              </ul>`,
+          )}
         </div>`;
       })`
-        background-color: #1C1D20;
+        background-color: #1c1d20;
         font-family: sans-serif;
         font-size: 14px;
         height: 48px;
@@ -257,7 +263,7 @@
         }
 
         span {
-          max-width: ${p => (p.width || 400) * 0.5 - 36}px;
+          max-width: ${(p) => (p.width || 400) * 0.5 - 36}px;
           overflow: hidden;
           text-overflow: ellipsis;
           white-space: nowrap;
@@ -343,9 +349,8 @@
       `;
 
       const Controls = styled((props) => {
-        const { environment, pause, play, playing, setStep, step } = useContext(
-          Context
-        );
+        const { environment, pause, play, playing, setStep, step } =
+          useContext(Context);
         const value = step + 1;
         const onClick = () => (playing ? pause() : play());
         const onInput = (e) => {
@@ -356,13 +361,11 @@
         return h`
           <div className=${props.className}>
             <${PlayButton} onClick=${onClick}><svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24" fill="#FFFFFF">${
-          playing
-            ? h`<path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/><path d="M0 0h24v24H0z" fill="none"/>`
-            : h`<path d="M8 5v14l11-7z"/><path d="M0 0h24v24H0z" fill="none"/>`
-        }</svg><//>
-            <${StepInput} min="1" max=${
-          environment.steps.length
-        } value="${value}" onInput=${onInput} />
+              playing
+                ? h`<path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/><path d="M0 0h24v24H0z" fill="none"/>`
+                : h`<path d="M8 5v14l11-7z"/><path d="M0 0h24v24H0z" fill="none"/>`
+            }</svg><//>
+            <${StepInput} min="1" max=${environment.steps.length} value="${value}" onInput=${onInput} />
             <${StepCount}>${value} / ${environment.steps.length}<//>
           </div>
         `;
@@ -401,9 +404,8 @@
       `;
 
       const Settings = styled((props) => {
-        const { environment, pause, play, playing, setStep, step } = useContext(
-          Context
-        );
+        const { environment, pause, play, playing, setStep, step } =
+          useContext(Context);
 
         return h`
           <div className=${props.className}>
@@ -424,13 +426,14 @@
 
       const Player = styled((props) => {
         const context = useContext(Context);
-        const { agents, controls, header, legend, loading, settings, width } = context;
+        const { agents, controls, header, legend, loading, settings, width } =
+          context;
         return h`
           <div className=${props.className}>
             ${loading && h`<${Loading} />`}
             ${!loading && header && h`<${Header} />`}
             ${!loading && h`<${Viewer} />`}
-            ${!loading && legend && h`<${Legend} width=${width}/>`}
+            ${!loading && legend && agents?.length > 0 && h`<${Legend} width=${width}/>`}
             ${!loading && controls && h`<${Controls} />`}
             ${!loading && settings && h`<${Settings} />`}
           </div>`;
@@ -444,7 +447,6 @@
         justify-content: center;
         position: relative;
         width: 100%;
-
         &:not(.no-border) {
           border: 4px solid #212121;
         }
@@ -544,7 +546,7 @@
             updateContext(window.kaggle || {});
 
             if (window.kaggle?.playing) {
-                play(true);
+              play(true);
             }
 
             // Listen for messages received to update the context.
@@ -554,16 +556,19 @@
                 // Ensure the environment names match before updating.
                 try {
                   if (
-                    event.data.environment?.name == contextRef.current.environment.name ||
-                    event.data.environment?.name && !contextRef.current.environment.name ||
-                    event.data.environment?.loading !== contextRef.current.environment.loading
+                    event.data.environment?.name ==
+                      contextRef.current.environment.name ||
+                    (event.data.environment?.name &&
+                      !contextRef.current.environment.name) ||
+                    event.data.environment?.loading !==
+                      contextRef.current.environment.loading
                   ) {
                     const nextContext = {
                       ...event.data,
                       environment: {
                         ...event.data.environment,
-                        steps: event.data.environment?.steps ?? []
-                      }
+                        steps: event.data.environment?.steps ?? [],
+                      },
                     };
                     window.kaggle = nextContext;
                     if (!window.kaggle.renderer) {
@@ -576,21 +581,24 @@
                       ...(window.kaggle ?? {}),
                       environment: {
                         ...(window.kaggle?.environment ?? {}),
-                        steps: event.data.setSteps
-                      }
-                    }
+                        steps: event.data.setSteps,
+                      },
+                    };
                     window.kaggle = nextContext;
                     if (!window.kaggle.renderer) {
                       window.kaggle.renderer = window.renderer;
                     }
-                    updateContext(nextContext)
+                    updateContext(nextContext);
                   }
 
                   // Side load the renderer script if it is specified by the post message event and not already loaded.
-                  const renderScriptId = 'rendererScript'
-                  if (event.data.environment?.rendererUrl && !document.querySelector(`#${renderScriptId}`)) {
+                  const renderScriptId = "rendererScript";
+                  if (
+                    event.data.environment?.rendererUrl &&
+                    !document.querySelector(`#${renderScriptId}`)
+                  ) {
                     window.rendererUrl = event.data.environment?.rendererUrl;
-                    const script = document.createElement('script');
+                    const script = document.createElement("script");
                     script.id = renderScriptId;
                     script.onload = () => {
                       window.kaggle.renderer = window.renderer;
@@ -600,7 +608,7 @@
                   }
                 } catch {}
               },
-              false
+              false,
             );
             // Listen for keyboard commands.
             window.addEventListener(
@@ -614,12 +622,15 @@
                   environment,
                 } = contextRef.current;
                 const key = event.keyCode;
-                const zero_key = 48
-                const nine_key = 57
+                const zero_key = 48;
+                const nine_key = 57;
                 if (
                   interactive ||
                   isInteractive() ||
-                  (key !== 32 && key !== 37 && key !== 39 && !(key >= zero_key && key <= nine_key))
+                  (key !== 32 &&
+                    key !== 37 &&
+                    key !== 39 &&
+                    !(key >= zero_key && key <= nine_key))
                 )
                   return;
 
@@ -639,7 +650,7 @@
                 event.preventDefault();
                 return false;
               },
-              false
+              false,
             );
           }, 1);
         }, []);
@@ -711,7 +722,7 @@
 
         return h`
           <${Context.Provider} value=${contextRef.current}>
-            <${Player} className="${contextRef.current.environment.viewer ? 'no-border' : ''}" />
+            <${Player} className="${contextRef.current.environment.viewer ? "no-border" : ""}" />
           <//>`;
       };
 

{kaggle_environments-1.17.9.dist-info → kaggle_environments-1.17.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 1.17.9
+Version: 1.17.11
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle

{kaggle_environments-1.17.9.dist-info → kaggle_environments-1.17.11.dist-info}/RECORD

@@ -1,7 +1,7 @@
-kaggle_environments/__init__.py,sha256=8QsPJZNGNhDEtrXxvMEN4wlcphBUksoAC5kBxTNoUnE,2175
-kaggle_environments/agent.py,sha256=j9rLnCK_Gy0eRIuvlJ9vcMh3vxn-Wvu-pjCpannOolc,6703
+kaggle_environments/__init__.py,sha256=BoiIlX0lR_CDejEoWTSOXz8UVsK4HrVbCMLt6TtFtdc,2176
+kaggle_environments/agent.py,sha256=IgRagzcTi6F73nPeViDdh9wvHnx8fQhFmXJNutovGZE,6706
 kaggle_environments/api.py,sha256=eLBKqr11Ku4tdsMUdUqy74FIVEA_hdV3_QUpX84x3Z8,798
-kaggle_environments/core.py,sha256=Ense_M-2rP4KmVeuKFjM0NQ8M6ucUZTbhwrGekyR9LY,27857
+kaggle_environments/core.py,sha256=PzF9NR0rFfFikspJ3HE0uI8UOiv_tlDhGSbu11g9vQQ,27860
 kaggle_environments/errors.py,sha256=SzKjkZP7pJbf9g0GDjGq4XG194hCQXLMwrlMCcm7Ai8,3336
 kaggle_environments/helpers.py,sha256=xkOMXaOMifYHHstDZo8bexk-Qq9suPM7Gkfi2JbXu8M,10627
 kaggle_environments/main.py,sha256=10wtcEFcGIjdOd9AEps5WOAwslc6Wsx3eZ43LXJa8jE,11705
@@ -196,7 +196,7 @@ kaggle_environments/envs/open_spiel/proxy.py,sha256=8Shane4KWYKvbP9nV3l8VQfAFOfF
 kaggle_environments/envs/open_spiel/proxy_test.py,sha256=QkmRo_uS0DgDDm2pbU2vwal5KOMCWKw92rC2_g3MziM,1837
 kaggle_environments/envs/open_spiel/test_open_spiel.py,sha256=MwyjH-e00-3SP8_r10drYTFvplacbo0cDCI0XKtE4wU,3596
 kaggle_environments/envs/open_spiel/games/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaggle_environments/envs/open_spiel/games/chess/chess.js,sha256=cObFpGh4MG07UYbLWOosWvhclaFwAfnOPoyfm45xvrE,12966
+kaggle_environments/envs/open_spiel/games/chess/chess.js,sha256=1WEZrngIX-0zNltBg1lWj8aqTWTMGIzCLSR83sUXa3g,19277
 kaggle_environments/envs/open_spiel/games/connect_four/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kaggle_environments/envs/open_spiel/games/connect_four/connect_four.js,sha256=iO74ar3Hh64VYEx9v3eysgrPU-Mcokl9dkFxie6uISg,14893
 kaggle_environments/envs/open_spiel/games/connect_four/connect_four_proxy.py,sha256=2otG99felDYhNhWpsadbM9YUaHtrXqhV1GFNEHhuPwA,2348
@@ -223,10 +223,10 @@ kaggle_environments/envs/tictactoe/test_tictactoe.py,sha256=6CgQbRz-yxNoMfD5tzmC
 kaggle_environments/envs/tictactoe/tictactoe.js,sha256=NZDT-oSG0a6a-rso9Ldh9qkJwVrxrAsjKUC3_tJu3tw,8002
 kaggle_environments/envs/tictactoe/tictactoe.json,sha256=zMXZ8-fpT7FBhzz2FFBvRLn4XwtngjEqOieMvI6cCj8,1121
 kaggle_environments/envs/tictactoe/tictactoe.py,sha256=uq3sTHWNMg0dxX2v9pTbJAKM7fwerxQt7OQjCX96m-Y,3657
-kaggle_environments/static/player.html,sha256=TTxN-EU7_KCNIVDX4E4TrZ61FRWkGUDHMSbnUYsQSvg,24975
-kaggle_environments-1.17.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-1.17.9.dist-info/METADATA,sha256=WJv0FzLXP7eUEdZenlYdQyPdhSD2-UGKFhA73RAv8PU,10955
-kaggle_environments-1.17.9.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-kaggle_environments-1.17.9.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
-kaggle_environments-1.17.9.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
-kaggle_environments-1.17.9.dist-info/RECORD,,
+kaggle_environments/static/player.html,sha256=l00X3_tfLtr_DmP7xpJFs8lKaTQoZtdexnKlHvT1fHc,25320
+kaggle_environments-1.17.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kaggle_environments-1.17.11.dist-info/METADATA,sha256=ehWejRG8czTeFjtHtCWZxDt7BuJo57M3nM8xWjUx7Oo,10956
+kaggle_environments-1.17.11.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+kaggle_environments-1.17.11.dist-info/entry_points.txt,sha256=HbVC-LKGQFV6lEEYBYyDTtrkHgdHJUWQ8_qt9KHGqz4,70
+kaggle_environments-1.17.11.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
+kaggle_environments-1.17.11.dist-info/RECORD,,