kaggle-environments 1.23.9__tar.gz → 1.23.11__tar.gz

kaggle_environments-1.23.11/.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: 'none',
+        quoteProps: 'preserve',
+        semi: true,
+        printWidth: 120
+      }
+    }
+  ]
+};

{kaggle_environments-1.23.9 → kaggle_environments-1.23.11}/PKG-INFO

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

{kaggle_environments-1.23.9 → kaggle_environments-1.23.11}/kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js

@@ -1,4 +1,4 @@
-import { getActionStringsFromACPC } from "@kaggle-environments/core";
+import { getActionStringsFromACPC } from '@kaggle-environments/core';
 
 const PLACEHOLDER_CARD = '2c';
 
@@ -8,7 +8,7 @@ function _parseStepHistoryData(universalPokerJSON, nextPlayerIndex, numPlayers =
     communityCards: '',
     bets: [],
     playerActionStrings: Array(numPlayers).fill(''),
-    winOdds: [0, 0],
+    winOdds: [0, 0]
   };
 
   if (!universalPokerJSON) {
@@ -52,18 +52,11 @@ function _parseStepHistoryData(universalPokerJSON, nextPlayerIndex, numPlayers =
       }
     }
 
-    result.communityCards = cardSegments
-      .slice(1)
-      .filter(Boolean)
-      .join('');
+    result.communityCards = cardSegments.slice(1).filter(Boolean).join('');
 
     const bettingString = stateParts.slice(2, stateParts.length - 1).join(':');
     if (bettingString) {
-      result.playerActionStrings = getActionStringsFromACPC(
-        bettingString,
-        nextPlayerIndex,
-        numPlayers
-      );
+      result.playerActionStrings = getActionStringsFromACPC(bettingString, nextPlayerIndex, numPlayers);
     }
   }
 
@@ -96,8 +89,6 @@ function sanitizeCardList(cards) {
   return (cards || []).filter((card) => card);
 }
 
-
-
 function getCommunityCardsFromUniversal(universal, numPlayers) {
   const parsed = _parseStepHistoryData(universal, null, numPlayers);
   const cards = splitCards(parsed.communityCards);
@@ -118,9 +109,6 @@ function getHandCardsFromUniversal(universal, numPlayers) {
   });
 }
 
-
-
-
 function getUniversalState(environment, index) {
   const entry = environment?.info?.stateHistory?.[index];
   if (!entry) {
@@ -157,7 +145,8 @@ export const getPokerStateForStep = (environment, step) => {
   );
 
   const startingStacks = stateInfo.universal?.starting_stacks || Array(numPlayers).fill(0);
-  const contributions = stateInfo.universal?.player_contributions || parsedStateHistory.bets || Array(numPlayers).fill(0);
+  const contributions =
+    stateInfo.universal?.player_contributions || parsedStateHistory.bets || Array(numPlayers).fill(0);
   const rewards = stateInfo.outer?.hand_returns || [];
   const communityCards = getCommunityCardsFromUniversal(stateInfo.universal, numPlayers);
 
@@ -177,7 +166,8 @@ export const getPokerStateForStep = (environment, step) => {
         isTurn: stateInfo.universal?.current_player === i,
         isLastActor: event.highlightPlayer === i,
         reward: rewards[0]?.[i] ?? null,
-        actionDisplayText: event.highlightPlayer === i ? event.actionText : ''
+        actionDisplayText: event.highlightPlayer === i ? event.actionText : '',
+        handCount: 0
       };
     });
 
@@ -202,6 +192,7 @@ export const getPokerStateForStep = (environment, step) => {
     winOdds: parsedStateHistory.winOdds,
     fiveCardBestHands: [],
     currentPlayer: stateInfo.universal?.current_player ?? -1,
-    winner: -1
+    winner: -1,
+    handCount: event.hand,
   };
 };

{kaggle_environments-1.23.9 → kaggle_environments-1.23.11}/kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js

@@ -1,10 +1,10 @@
-import { getPokerStateForStep } from "./components/getRepeatedPokerStateForStep";
-import { acpcCardToDisplay, suitSVGs } from "./components/utils";
-import poker_chip_1 from "./images/poker_chip_1.svg";
-import poker_chip_5 from "./images/poker_chip_5.svg";
-import poker_chip_10 from "./images/poker_chip_10.svg";
-import poker_chip_25 from "./images/poker_chip_25.svg";
-import poker_chip_100 from "./images/poker_chip_100.svg";
+import { getPokerStateForStep } from './components/getRepeatedPokerStateForStep';
+import { acpcCardToDisplay, suitSVGs } from './components/utils';
+import poker_chip_1 from './images/poker_chip_1.svg';
+import poker_chip_5 from './images/poker_chip_5.svg';
+import poker_chip_10 from './images/poker_chip_10.svg';
+import poker_chip_25 from './images/poker_chip_25.svg';
+import poker_chip_100 from './images/poker_chip_100.svg';
 
 export function renderer(options) {
   const chipImages = {
@@ -28,7 +28,8 @@ export function renderer(options) {
     dealerButton: null,
     chipStacks: [],
     diagnosticHeader: null,
-    stepCounter: null
+    stepCounter: null,
+    handCounter: null
   };
 
   const css = `
@@ -253,6 +254,12 @@ export function renderer(options) {
       font-size: 14px; font-weight: 600;
       box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
     }
+    .hand-counter {
+      position: absolute; bottom: 12px; right: 12px; z-index: 20;
+      color: #535965;
+      padding: 6px 12px; border-radius: 6px;
+      font-size: 40px; font-weight: 600;
+    }
     .chip-stack {
       position: absolute;
       display: flex;
@@ -519,6 +526,12 @@ export function renderer(options) {
     elements.stepCounter.className = 'step-counter';
     elements.stepCounter.textContent = 'Standby';
     elements.gameLayout.appendChild(elements.stepCounter);
+
+    elements.handCounter = document.createElement('div');
+    elements.handCounter.className = 'hand-counter';
+    elements.handCounter.textContent = '';
+    elements.gameLayout.appendChild(elements.handCounter);
+
     return true;
   }
 
@@ -531,7 +544,7 @@ export function renderer(options) {
       players: [],
       communityCards: [],
       pot: 0,
-      isTerminal: false,
+      isTerminal: false
     };
 
     // --- Step Validation ---
@@ -539,7 +552,6 @@ export function renderer(options) {
       return defaultStateUiData;
     }
 
-
     return getPokerStateForStep(environment, step);
   }
 
@@ -561,13 +573,18 @@ export function renderer(options) {
 
   function _renderPokerTableUI(data) {
     if (!elements.pokerTable || !data) return;
-    const { players, communityCards, pot, isTerminal, step } = data;
+    const { players, communityCards, pot, isTerminal, step, handCount } = data;
 
     // Update step counter
     if (elements.stepCounter && step !== undefined) {
       elements.stepCounter.textContent = `Debug Step: ${step}`;
     }
 
+    // Update hand counter
+    if (elements.handCounter && handCount !== undefined) {
+      elements.handCounter.textContent = `Hand ${handCount + 1}/100`; // 1-index hands
+    }
+
     if (elements.diagnosticHeader && data.rawObservation) {
       // Optional: Show diagnostics for debugging
       // elements.diagnosticHeader.textContent = `[${passedOptions.step}] P_TURN:${data.rawObservation.current_player} POT:${data.pot}`;
@@ -580,10 +597,6 @@ export function renderer(options) {
     const numCommunityCards = 5;
     const numCards = communityCards ? communityCards.length : 0;
 
-    // Since the 4th and 5th street cards are appended to the communityCards array, we need to
-    // reverse it so that the added cards are put at the end of the display area on the board.
-    if (communityCards) communityCards.reverse();
-
     // Add actual cards
     for (let i = 0; i < numCards; i++) {
       elements.communityCardsContainer.appendChild(createCardElement(communityCards[i]));
@@ -711,7 +724,6 @@ export function renderer(options) {
   const uiData = _parseKagglePokerState(options);
   _renderPokerTableUI(uiData, options);
 
-
   // Apply initial scale
   _applyScale(parent);
 

{kaggle_environments-1.23.9 → kaggle_environments-1.23.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kaggle-environments"
-version = "1.23.9"
+version = "1.23.11"
 description = "Kaggle Environments"
 authors = [
     {name = "Kaggle", email = "support@kaggle.com"},

{kaggle_environments-1.23.9 → kaggle_environments-1.23.11}/web/core/src/transformers/repeatedPokerTransformer.ts

@@ -1,5 +1,39 @@
 import { PokerGameStep } from "../types";
 
+const _parseRoundState = (currentStateHistory: string) => {
+  const currentState = JSON.parse(
+    JSON.parse(currentStateHistory).current_universal_poker_json,
+  ).acpc_state;
+
+  /**
+   * Example lines:
+   * STATE:0:r5c/cr9c/:Ks4s|5hAs/2dJs7s/Qh
+   * Spent: [P0: 9  P1: 9  ]
+   */
+  const lines = currentState.trim().split("\n");
+  if (lines.length < 2) {
+    return "";
+  }
+  const stateParts = lines[0].split(":");
+
+  const currentCardString = stateParts[stateParts.length - 1]; // example: "6cKd|AsJc/7hQh6d/2c"
+  // Grab the hand and board blocks
+  const currentCardSegments = currentCardString.split("|");
+  // Split card string by '/' to separate hand and board blocks
+  const currentCommunitySegments =
+    currentCardSegments.length > 1 ? currentCardSegments[1].split("/") : [];
+
+  if (currentCommunitySegments.length === 2) {
+    return "### Flop";
+  } else if (currentCommunitySegments.length === 3) {
+    return "### 4th Street";
+  } else if (currentCommunitySegments.length === 4) {
+    return "### 5th Street";
+  } else {
+    return "";
+  }
+};
+
 const _isStateHistoryAgentAction = (stateHistoryEntry: string): boolean =>
   JSON.parse(JSON.parse(stateHistoryEntry).current_universal_poker_json)
     .current_player !== -1;
@@ -63,6 +97,104 @@ function _getMovesFromBettingStringACPC(bettingString: string): string[] {
   return moves;
 }
 
+export function _getReadableMovesFromBettingStringACPC(
+  bettingString: string,
+): string[] {
+  if (!bettingString) {
+    return [];
+  }
+
+  const moves: string[] = [];
+  const streets = bettingString.split("/");
+  // Heads-up specific ordering: SB acts first preflop, BB acts first postflop
+  const FIRST_ACTOR_BY_STREET = [1, 0, 0, 0];
+  const NUM_PLAYERS = 2;
+
+  // Track the total amount contributed by each player across the hand.
+  // Start with blinds posted (BB=2, SB=1) for repeated poker.
+  const totalContributions: number[] = [2, 1];
+  // Track the contributions each player had at the start of the street.
+  // Preflop baseline excludes blinds so that we report the amount invested during the action.
+  let streetBaselines: number[] = [0, 0];
+
+  streets.forEach((streetAction, streetIndex) => {
+    const trimmedAction = streetAction.trim();
+    // Update baselines for every street after preflop
+    if (streetIndex > 0) {
+      streetBaselines = [...totalContributions];
+    }
+
+    if (!trimmedAction) {
+      return;
+    }
+
+    let actingPlayer =
+      FIRST_ACTOR_BY_STREET[
+        Math.min(streetIndex, FIRST_ACTOR_BY_STREET.length - 1)
+      ];
+
+    let i = 0;
+    while (i < trimmedAction.length) {
+      const char = trimmedAction[i];
+      const currentMax = Math.max(...totalContributions);
+
+      if (char === "r") {
+        let amount = "";
+        i++;
+        while (
+          i < trimmedAction.length &&
+          trimmedAction[i] >= "0" &&
+          trimmedAction[i] <= "9"
+        ) {
+          amount += trimmedAction[i];
+          i++;
+        }
+        const targetTotal = parseInt(amount || "0", 10);
+        const previousTotal = totalContributions[actingPlayer];
+        const roundBaseline = streetBaselines[actingPlayer];
+        const roundTotal = Math.max(targetTotal - roundBaseline, 0);
+        const hasOutstandingBet = currentMax > previousTotal;
+        const verb = hasOutstandingBet ? "Raise" : "Bet";
+
+        if (!Number.isFinite(targetTotal)) {
+          throw new Error(
+            `Invalid raise amount '${amount}' parsed from betting string '${bettingString}'.`,
+          );
+        }
+        if (targetTotal <= previousTotal) {
+          throw new Error(
+            `Invalid raise target ${targetTotal} for player ${actingPlayer} (previous total ${previousTotal}).`,
+          );
+        }
+
+        moves.push(`${verb} ${roundTotal}`);
+        totalContributions[actingPlayer] = targetTotal;
+      } else if (char === "c") {
+        const previousTotal = totalContributions[actingPlayer];
+        if (previousTotal === currentMax) {
+          moves.push("Check");
+        } else {
+          const callAmount = currentMax - previousTotal;
+          moves.push(callAmount > 0 ? `Call ${callAmount}` : "Call");
+          totalContributions[actingPlayer] = currentMax;
+        }
+        i++;
+      } else if (char === "f") {
+        moves.push("Fold");
+        i++;
+      } else {
+        throw new Error(
+          `Unknown betting token '${char}' encountered in '${bettingString}'.`,
+        );
+      }
+
+      actingPlayer = (actingPlayer + 1) % NUM_PLAYERS;
+    }
+  });
+
+  return moves;
+}
+
 const _getEndCondition = (
   stateHistory: any[],
   stateHistoryPointer: number,
@@ -131,26 +263,34 @@ export const getPokerStepLabel = (gameStep: PokerGameStep) => {
   return "";
 };
 
-export const getPokerStepDescription = (gameStep: PokerGameStep) => {
+export const getPokerStepDescription = (
+  gameStep: PokerGameStep,
+  playerNames: string[],
+) => {
   if (gameStep.step?.action?.thoughts) {
     return gameStep.step.action.thoughts;
-  } else if (gameStep.isEndState) {
+  } else if (gameStep.isEndState && gameStep.winner !== undefined) {
+    if (gameStep.winner === -1) {
+      return `
+### ${playerNames.join(" and ")} tie
+`;
+    }
+
+    const loser = gameStep.winner.toString() === "0" ? 1 : 0;
     if (gameStep.handConclusion === "showdown") {
       return `
-## Player ${gameStep.winner} wins round ${gameStep.hand + 1} 
-### Wins with ${gameStep.bestHandRankType} 
-### ${gameStep.bestFiveCardHands} 
+###🎉 ${playerNames[gameStep.winner]} wins round ${gameStep.hand + 1}
+#### ${gameStep.bestHandRankType?.join(" and ")}
 `;
     } else {
       return `
-## Player ${gameStep.winner} wins round ${gameStep.hand + 1} 
-### Other player folds
+###🎉 ${playerNames[gameStep.winner]} wins round ${gameStep.hand + 1}
+#### ${playerNames[loser]} folds
 `;
     }
   }
 
-  // TODO player names
-  return "TODO";
+  return _parseRoundState(gameStep.stateHistory);
 };
 
 /* interface TimelineEvent {
@@ -168,7 +308,7 @@ export const getPokerStepsWithEndStates = (
   let handCount = 0;
   let stateHistoryPointer = 0;
 
-  const stateHistory = environment.info.state_history ?? [];
+  const stateHistory = environment.info.stateHistory ?? [];
   const steps = environment.steps ?? [];
 
   const advanceToNextAgentEntry = () => {
@@ -317,3 +457,8 @@ export const getPokerStepsWithEndStates = (
 
   return stepsWithEndStates;
 };
+
+export const __testing = {
+  _getMovesFromBettingStringACPC,
+  _getReadableMovesFromBettingStringACPC,
+};

kaggle_environments-1.23.11/web/core/src/transformers/test_getMovesFromBettingString.ts

@@ -0,0 +1,141 @@
+import { __testing } from "./repeatedPokerTransformer.js";
+
+type TestCase = {
+  name: string;
+  bettingString: string;
+  expected?: string[];
+  expectedError?: string;
+};
+
+function runTest(
+  { name, bettingString, expected, expectedError }: TestCase,
+  transformer: (bettingString: string) => string[],
+) {
+  try {
+    const result = transformer(bettingString);
+
+    if (expectedError) {
+      console.error(`❌ ${name}`);
+      console.error(
+        `   Expected error containing "${expectedError}" but execution succeeded with ${JSON.stringify(
+          result,
+        )}`,
+      );
+      return;
+    }
+
+    if (!expected) {
+      console.error(`❌ ${name}`);
+      console.error(
+        `   No expected moves provided but transformer returned ${JSON.stringify(result)}`,
+      );
+      return;
+    }
+
+    const pass =
+      result.length === expected.length &&
+      result.every((move, idx) => move === expected[idx]);
+
+    if (pass) {
+      console.log(`✅ ${name}`);
+    } else {
+      console.error(`❌ ${name}`);
+      console.error(`   bettingString: ${bettingString}`);
+      console.error(`   expected: ${JSON.stringify(expected)}`);
+      console.error(`   received: ${JSON.stringify(result)}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (expectedError && message.includes(expectedError)) {
+      console.log(`✅ ${name} (threw expected error)`);
+    } else {
+      console.error(`❌ ${name}`);
+      console.error(`   bettingString: ${bettingString}`);
+      if (expectedError) {
+        console.error(`   expected error containing: ${expectedError}`);
+      }
+      console.error(`   received error: ${message}`);
+    }
+  }
+}
+
+const testCases: TestCase[] = [
+  {
+    name: "preflop raise-call sequence",
+    bettingString: "r5c",
+    expected: ["r5", "c"],
+  },
+  {
+    name: "multi-street action with fold",
+    bettingString: "r5c/cr11f",
+    expected: ["r5", "c", "c", "r11", "f"],
+  },
+  {
+    name: "check-check through two streets",
+    bettingString: "cc/cc",
+    expected: ["c", "c", "c", "c"],
+  },
+  {
+    name: "empty betting string",
+    bettingString: "",
+    expected: [""].filter(Boolean),
+  },
+];
+
+const readableTestCases: TestCase[] = [
+  {
+    name: "preflop raise and call",
+    bettingString: "r4c",
+    expected: ["Raise 4", "Call 2"],
+  },
+  {
+    name: "flop betting with call",
+    bettingString: "r4c/cr8c",
+    expected: ["Raise 4", "Call 2", "Check", "Bet 4", "Call 4"],
+  },
+  {
+    name: "immediate check back",
+    bettingString: "r4c/c",
+    expected: ["Raise 4", "Call 2", "Check"],
+  },
+  {
+    name: "multi-raise same street",
+    bettingString: "r5r11",
+    expected: ["Raise 5", "Raise 11"],
+  },
+  {
+    name: "invalid raise target throws",
+    bettingString: "r4r2",
+    expectedError: "Invalid raise target",
+  },
+  {
+    name: "unknown betting token throws",
+    bettingString: "r4x",
+    expectedError: "Unknown betting token",
+  },
+  {
+    name: "empty readable betting string",
+    bettingString: "",
+    expected: [],
+  },
+  {
+    name: "full hand example 1",
+    bettingString: "r5c/cc/r11c/r122r200c",
+    expected: ["Raise 5", "Call 3", "Check", "Check", "Bet 6", "Call 6", "Bet 111", "Raise 189", "Call 78"],
+  },
+  {
+    name: "full hand example 2",
+    bettingString: "r10r20r30c/r32r34r44r54c/r56r80c/cr100r150r200c",
+    expected: ["Raise 10","Raise 20","Raise 30","Call 10","Bet 2","Raise 4","Raise 14","Raise 24","Call 10","Bet 2","Raise 26","Call 24","Check","Bet 20","Raise 70","Raise 120","Call 50"],
+  },
+];
+
+const { _getMovesFromBettingStringACPC, _getReadableMovesFromBettingStringACPC } =
+  __testing;
+
+testCases.forEach((test) =>
+  runTest(test, _getMovesFromBettingStringACPC),
+);
+readableTestCases.forEach((test) =>
+  runTest(test, _getReadableMovesFromBettingStringACPC),
+);

{kaggle_environments-1.23.9 → kaggle_environments-1.23.11}/web/core/src/transformers.ts

@@ -31,11 +31,12 @@ export const getGameStepLabel = (
 
 export const getGameStepDescription = (
   gameStep: GameStep,
+  players: string[],
   gameName: string,
 ): string => {
   switch (gameName) {
     case "repeated_poker":
-      return getPokerStepDescription(gameStep as PokerGameStep);
+      return getPokerStepDescription(gameStep as PokerGameStep, players);
     default:
       return "";
   }

kaggle_environments-1.23.9/.prettierrc.js

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