kaggle-environments 1.23.5__py3-none-any.whl → 1.23.6__py3-none-any.whl

kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js

@@ -1,63 +1,65 @@
-function _getActionStringsFromACPC(bettingString, currentPlayer) {
-  const moves = [];
+const PLACEHOLDER_CARD = '2c';
 
-  // Split the action string by street (e.g., ["r5c", "cr11f"])
+function _getActionStringsFromACPC(bettingString, nextPlayerIndex, numPlayers = 2) {
+  const moves = [];
   const streets = bettingString.split('/');
-
-  // Process each street's actions
   for (let streetIndex = 0; streetIndex < streets.length; streetIndex++) {
     const streetAction = streets[streetIndex];
     let i = 0;
-
-    // 4. Parse the moves within the street
     while (i < streetAction.length) {
       const char = streetAction[i];
-
       if (char === 'r') {
         let amount = '';
         i++;
-        // parse all digits of the raise amount
         while (i < streetAction.length && streetAction[i] >= '0' && streetAction[i] <= '9') {
           amount += streetAction[i];
           i++;
         }
-        moves.push(`r${amount}`)
+        moves.push(`r${amount}`);
       } else {
         moves.push(char);
         i++;
-        continue;
       }
     }
   }
 
-  // 6. Get the last two moves from our complete list
   const lastMove = moves.length > 0 ? moves[moves.length - 1] : null;
-
-  const actionStrings = currentPlayer === 0 ? [lastMove, ''] : ['', lastMove];
+  const actionStrings = Array(numPlayers).fill('');
+
+  if (lastMove) {
+    if (typeof nextPlayerIndex === 'number' && nextPlayerIndex >= 0) {
+      const lastActor = (nextPlayerIndex + numPlayers - 1) % numPlayers;
+      actionStrings[lastActor] = lastMove;
+    } else {
+      const inferredActor = (moves.length - 1) % numPlayers;
+      actionStrings[inferredActor] = lastMove;
+    }
+  }
 
   return actionStrings;
 }
 
-function _parseStepHistoryData(universalPokerJSON) {
+function _parseStepHistoryData(universalPokerJSON, nextPlayerIndex, numPlayers = 2) {
   const result = {
     cards: [],
     communityCards: '',
     bets: [],
-    playerActionStrings: ['', ''],
+    playerActionStrings: Array(numPlayers).fill(''),
     winOdds: [0, 0],
   };
 
-  // Split the string into its main lines
+  if (!universalPokerJSON) {
+    return result;
+  }
+
   const lines = universalPokerJSON.acpc_state.trim().split('\n');
   if (lines.length < 2) {
-    console.error("Invalid state string format.");
     return result;
   }
 
-  const stateLine = lines[0]; // example: "STATE:0:r5c/cr11c/:6cKd|AsJc/7hQh6d/2c"
-  const spentLine = lines[1]; // example: "Spent: [P0: 11  P1: 11  ]"
+  const stateLine = lines[0];
+  const spentLine = lines[1];
 
-  // --- Parse the Spent Line ---
   if (spentLine) {
     const p0BetMatch = spentLine.match(/P0:\s*(\d+)/);
     const p1BetMatch = spentLine.match(/P1:\s*(\d+)/);
@@ -75,167 +77,334 @@ function _parseStepHistoryData(universalPokerJSON) {
     result.bets = bets;
   }
 
-  // --- Parse the State Line ---
   if (stateLine) {
     const stateParts = stateLine.split(':');
+    const cardString = stateParts[stateParts.length - 1];
+    const cardSegments = cardString.split('/');
 
-    // --- Parse Cards ---
-    // The card string is always the last part
-    const cardString = stateParts[stateParts.length - 1]; // example: "6cKd|AsJc/7hQh6d/2c"
-
-    // Split card string by '/' to separate hand block from board blocks
-    const cardSegments = cardString.split('/'); // example: ["6cKd|AsJc", "7hQh6d", "2c"]
-
-    // Parse the first segment (player hands)
     if (cardSegments[0]) {
       const playerHands = cardSegments[0].split('|');
       if (playerHands.length >= 2) {
-        // example: "6cKd"
         result.cards = [playerHands[0], playerHands[1]];
       }
     }
 
-    // The rest of the segments are community cards, one per street
     result.communityCards = cardSegments
-      .slice(1) // gets all elements AFTER the player hands
-      .filter(Boolean) // removes any empty strings (e.g., from a trailing "/")
-      .join(''); // joins the remaining segments into a single string
+      .slice(1)
+      .filter(Boolean)
+      .join('');
 
-    // --- Parse Betting String --
-    // The betting string is everything between the 2nd colon and the last colon.
-    // This handles edge cases like "STATE:0:r5c/cr11c/:cards"
     const bettingString = stateParts.slice(2, stateParts.length - 1).join(':');
-
     if (bettingString) {
-      result.playerActionStrings = _getActionStringsFromACPC(bettingString);
+      result.playerActionStrings = _getActionStringsFromACPC(
+        bettingString,
+        nextPlayerIndex,
+        numPlayers
+      );
     }
   }
 
-  // Parse win odds
-  const p0WinOdds = Number(universalPokerJSON.odds[0]).toLocaleString(undefined, { style: 'percent', minimumFractionDigits: 2 })
-  const p1WinOdds = Number(universalPokerJSON.odds[1]).toLocaleString(undefined, { style: 'percent', minimumFractionDigits: 2 })
+  const odds = universalPokerJSON.odds || [];
+  const p0WinOdds = Number(odds[0] ?? 0).toLocaleString(undefined, {
+    style: 'percent',
+    minimumFractionDigits: 2
+  });
+  const p1WinOdds = Number(odds[1] ?? 0).toLocaleString(undefined, {
+    style: 'percent',
+    minimumFractionDigits: 2
+  });
   result.winOdds = [p0WinOdds, p1WinOdds];
 
   return result;
 }
 
-export const getPokerStateForStep = (environment, step) => {
-  const numPlayers = 2;
-  // --- Step Validation ---
-  if (!environment || !environment.steps || !environment.steps[step] || !environment.info) {
-    // return default state
-    return null;
+function splitCards(cardString) {
+  if (!cardString) {
+    return [];
   }
+  return cardString.match(/.{1,2}/g) || [];
+}
 
-  const stepsWithEndStates = environment.steps;
+function isPlaceholderString(cardString) {
+  return typeof cardString === 'string' && /^((2c)+)$/i.test(cardString);
+}
 
-  // --- Default State ---
-  const stateUIData = {
-    players: Array(numPlayers).fill(null).map((_, i) => {
-      const agentName = environment?.info?.TeamNames?.[i] ||
-        `Player ${i}`;
-      const thumbnail = environment?.info?.Agents?.[i].ThumbnailUrl;
-      return {
-        id: `player${i}`,
-        name: agentName,
-        thumbnail: thumbnail,
-        stack: 0,
-        cards: [], // Will be filled with nulls or cards
-        currentBet: 0,
-        isDealer: i === 0,
-        isTurn: false,
-        reward: null,
-        actionDisplayText: ""
-      };
-    }),
-    communityCards: [],
-    pot: 0,
-    isTerminal: false,
-    rawObservation: null, // For debugging
-    step: step,
-    winOdds: [],
-    fiveCardBestHands: [],
-    currentPlayer: -1,
-    winner: -1,
-  };
+function sanitizeCardList(cards) {
+  return (cards || []).filter((card) => card);
+}
 
-  // We have two sources for current game state: stepHistory and steps
-  // This is because neither source contains all the information we need 
-  const currentStepData = stepsWithEndStates[step > 2 ? step - 2 : 0]; // Skip over setup steps
+function formatActionDisplay(actionString) {
+  if (!actionString) {
+    return '';
+  }
+  const playerMatch = actionString.match(/move=([^\s]+)/);
+  if (!playerMatch) {
+    return '';
+  }
+  const moveRaw = playerMatch[1];
+  const moveLower = moveRaw.toLowerCase();
+  if (moveLower.startsWith('bet') || moveLower.startsWith('raise')) {
+    const amountMatch = moveRaw.match(/\d+/);
+    return amountMatch ? `r${amountMatch[0]}` : 'r';
+  }
+  if (moveLower === 'call') {
+    return 'c';
+  }
+  if (moveLower === 'check') {
+    return 'k';
+  }
+  if (moveLower === 'fold') {
+    return 'f';
+  }
+  return moveRaw;
+}
 
-  const currentPlayer = currentStepData?.step?.observation?.currentPlayer || 0; // TODO: find better way to get current player
+function getBlinds(configuration) {
+  const blindConfig = configuration?.openSpielGameParameters?.universal_poker_game_string?.blind;
+  if (typeof blindConfig !== 'string') {
+    return { bigBlind: null, smallBlind: null };
+  }
+  const parts = blindConfig
+    .trim()
+    .split(/\s+/)
+    .map((entry) => Number(entry))
+    .filter((n) => !Number.isNaN(n));
+  if (parts.length >= 2) {
+    return { bigBlind: parts[0], smallBlind: parts[1] };
+  }
+  return { bigBlind: null, smallBlind: null };
+}
 
-  const currentStateHistoryEntry = JSON.parse(currentStepData.stateHistory);
-  const currentUniversalPokerJSON = JSON.parse(currentStateHistoryEntry.current_universal_poker_json);
+function getCommunityCardsFromUniversal(universal, numPlayers) {
+  const parsed = _parseStepHistoryData(universal, null, numPlayers);
+  const cards = splitCards(parsed.communityCards);
+  const actual = cards.filter((card) => card && card.toLowerCase() !== PLACEHOLDER_CARD);
+  if (actual.length < 3) {
+    return [];
+  }
+  return actual;
+}
 
-  // TODO: Handle the flop phase steps (chance steps)
+function getHandCardsFromUniversal(universal, numPlayers) {
+  const parsed = _parseStepHistoryData(universal, null, numPlayers);
+  return (parsed.cards || []).map((cardString) => {
+    if (isPlaceholderString(cardString)) {
+      return [];
+    }
+    return sanitizeCardList(splitCards(cardString));
+  });
+}
 
-  const currentStepFromStateHistory = _parseStepHistoryData(currentUniversalPokerJSON);
+function buildTimeline(environment, numPlayers) {
+  const stateHistory = environment?.info?.stateHistory || [];
+  if (!stateHistory.length) {
+    return [];
+  }
 
-  const currentStepAgents = environment.steps[step];
-  if (!currentStepAgents || currentStepAgents.length < numPlayers) {
-    return stateUIData;
+  const parsedStates = stateHistory.map((entry, idx) => {
+    const outer = JSON.parse(entry);
+    return {
+      idx,
+      outer,
+      universal: JSON.parse(outer.current_universal_poker_json)
+    };
+  });
+
+  const hands = [];
+  let currentHandNumber = parsedStates[0]?.outer?.hand_number ?? 0;
+  let currentStates = [];
+  parsedStates.forEach((stateInfo) => {
+    const handNumber = stateInfo.outer?.hand_number ?? currentHandNumber;
+    if (handNumber !== currentHandNumber) {
+      if (currentStates.length) {
+        hands.push({ handNumber: currentHandNumber, states: currentStates });
+      }
+      currentStates = [];
+      currentHandNumber = handNumber;
+    }
+    currentStates.push(stateInfo);
+  });
+  if (currentStates.length) {
+    hands.push({ handNumber: currentHandNumber, states: currentStates });
   }
 
-  const pot_size = currentStepFromStateHistory.bets.reduce((a, b) => a + b, 0);
-  const player_contributions = currentStepFromStateHistory.bets;
-  const starting_stacks = currentUniversalPokerJSON.starting_stacks;
-  const player_hands = [
-    currentStepFromStateHistory.cards[0]?.match(/.{1,2}/g) || [],
-    currentStepFromStateHistory.cards[1]?.match(/.{1,2}/g) || []
-  ];
-  const board_cards = currentStepFromStateHistory.communityCards ? currentStepFromStateHistory.communityCards.match(/.{1,2}/g).reverse() : [];
+  const processedSteps = environment.__processedSteps || environment.steps || [];
+  const actionsByHand = new Map();
+  processedSteps.forEach((step) => {
+    const handNumber = step?.hand ?? 0;
+    if (!actionsByHand.has(handNumber)) {
+      actionsByHand.set(handNumber, []);
+    }
+    if (!step?.isEndState && step?.step?.action && step.step.action.submission !== -1) {
+      const actionString = step.step.action.actionString || '';
+      const playerMatch = actionString.match(/player=(\d+)/);
+      const playerIndex = playerMatch ? parseInt(playerMatch[1], 10) : null;
+      actionsByHand.get(handNumber).push({
+        playerIndex,
+        actionText: formatActionDisplay(actionString),
+        stateHistoryIndex: step.stateHistoryIndex
+      });
+    }
+  });
+
+  const events = [];
+  let orderCounter = 0;
+  const pushEvent = (stateIndex, event) => {
+    events.push({
+      order: orderCounter++,
+      stateIndex,
+      highlightPlayer: event.highlightPlayer,
+      actionText: event.actionText,
+      hideHoleCards: event.hideHoleCards,
+      hideCommunity: event.hideCommunity
+    });
+  };
+
+  hands.forEach(({ handNumber, states }) => {
+    if (!states.length) {
+      return;
+    }
 
-  // TODO: Add odds, best_five_card_hands best_hand_rank_types
+    const firstState = states[0];
+    const dealer = firstState.outer?.dealer ?? 0;
+    const { bigBlind, smallBlind } = getBlinds(environment.configuration);
+    const smallBlindPlayer = dealer % numPlayers;
+    const bigBlindPlayer = (dealer + 1) % numPlayers;
+
+    pushEvent(firstState.idx, { highlightPlayer: null, actionText: '', hideHoleCards: true, hideCommunity: true });
+    pushEvent(firstState.idx, { highlightPlayer: smallBlindPlayer, actionText: smallBlind != null ? `SB ${smallBlind}` : 'SB', hideHoleCards: true, hideCommunity: true });
+    pushEvent(firstState.idx, { highlightPlayer: bigBlindPlayer, actionText: bigBlind != null ? `BB ${bigBlind}` : 'BB', hideHoleCards: true, hideCommunity: true });
+
+    const firstActionState = states.find((stateInfo) => stateInfo.universal.current_player !== -1) || firstState;
+    pushEvent(firstActionState.idx, { highlightPlayer: null, actionText: '', hideHoleCards: false, hideCommunity: true });
+
+    const actions = actionsByHand.get(handNumber) || [];
+    actions.forEach((action) => {
+      const targetIndex = typeof action.stateHistoryIndex === 'number' ? action.stateHistoryIndex : states[0].idx;
+      const postState = states.find((stateInfo) => stateInfo.idx > targetIndex) || states[states.length - 1];
+      pushEvent(postState.idx, {
+        highlightPlayer: action.playerIndex,
+        actionText: action.actionText,
+        hideHoleCards: false,
+        hideCommunity: false
+      });
+    });
+
+    let currentStageCommunityLength = 0;
+    states.forEach((stateInfo) => {
+      const communityCards = getCommunityCardsFromUniversal(stateInfo.universal, numPlayers);
+      const communityLength = communityCards.length;
+      if (communityLength > currentStageCommunityLength) {
+        currentStageCommunityLength = communityLength;
+        if (communityLength === 3 || communityLength === 4 || communityLength === 5) {
+          pushEvent(stateInfo.idx, {
+            highlightPlayer: null,
+            actionText: '',
+            hideHoleCards: false,
+            hideCommunity: false
+          });
+        }
+      }
+    });
+  });
+
+  events.sort((a, b) => a.order - b.order);
+  return events.map(({ stateIndex, highlightPlayer, actionText, hideHoleCards, hideCommunity }) => ({
+    stateIndex,
+    highlightPlayer,
+    actionText,
+    hideHoleCards: !!hideHoleCards,
+    hideCommunity: !!hideCommunity
+  }));
+}
 
-  // TODO: Add current player
+function getTimeline(environment, numPlayers) {
+  if (!environment.__timeline) {
+    environment.__timeline = buildTimeline(environment, numPlayers);
+  }
+  return environment.__timeline;
+}
 
-  const isTerminal = false // TODO: read isTerminal from observation
-  stateUIData.isTerminal = isTerminal;
-  stateUIData.pot = pot_size || 0;
-  stateUIData.communityCards = board_cards || [];
+function getUniversalState(environment, index) {
+  const entry = environment?.info?.stateHistory?.[index];
+  if (!entry) {
+    return null;
+  }
+  const outer = JSON.parse(entry);
+  return {
+    outer,
+    universal: JSON.parse(outer.current_universal_poker_json)
+  };
+}
 
-  // --- Update Players ---
-  for (let i = 0; i < numPlayers; i++) {
-    const pData = stateUIData.players[i];
-    const contribution = player_contributions ? player_contributions[i] : 0;
-    const startStack = starting_stacks ? starting_stacks[i] : 0;
+export const getPokerStateForStep = (environment, step) => {
+  const numPlayers = 2;
+  if (!environment || !environment.info?.stateHistory) {
+    return null;
+  }
 
-    pData.currentBet = contribution;
-    pData.stack = startStack - contribution;
-    pData.cards = (player_hands[i] || []).map(c => c === "??" ? null : c);
-    pData.isTurn = currentPlayer === i; // TODO: this may need to be flipped to show the other player responding to this move, which will display instantly
-    pData.isDealer = currentStateHistoryEntry.dealer === i;
-    pData.actionDisplayText = currentStepFromStateHistory.playerActionStrings[i];
+  const timeline = getTimeline(environment, numPlayers);
+  const event = timeline[step];
+  if (!event) {
+    return null;
+  }
+  const stateInfo = getUniversalState(environment, event.stateIndex);
+  if (!stateInfo) {
+    return null;
+  }
 
-    if (currentStepData.isEndState) {
-      pData.isTurn = false;
-      pData.isWinner = currentStepData.winner === i;
-      if (currentStepData.winner === i) {
-        pData.actionDisplayText = "WINNER"
-      } else {
-        if (currentStepData.handConclusion === "fold") {
-          pData.actionDisplayText = "FOLD"
-        } else {
-          pData.actionDisplayText = "LOSER"
-        }
-      }
+  const parsedStateHistory = _parseStepHistoryData(
+    stateInfo.universal,
+    stateInfo.universal?.current_player,
+    numPlayers
+  );
+
+  const startingStacks = stateInfo.universal?.starting_stacks || 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);
+
+  const players = Array(numPlayers)
+    .fill(null)
+    .map((_, i) => {
+      const agentName = environment?.info?.TeamNames?.[i] || `Player ${i}`;
+      const thumbnail = environment?.info?.Agents?.[i]?.ThumbnailUrl;
+      return {
+        id: `player${i}`,
+        name: agentName,
+        thumbnail,
+        stack: startingStacks[i] - (contributions[i] || 0),
+        cards: [],
+        currentBet: contributions[i] || 0,
+        isDealer: stateInfo.outer?.dealer === i,
+        isTurn: stateInfo.universal?.current_player === i,
+        isLastActor: event.highlightPlayer === i,
+        reward: rewards[0]?.[i] ?? null,
+        actionDisplayText: event.highlightPlayer === i ? event.actionText : ''
+      };
+    });
+
+  const handCards = getHandCardsFromUniversal(stateInfo.universal, numPlayers);
+  players.forEach((player, index) => {
+    if (event.hideHoleCards) {
+      player.cards = [];
+    } else {
+      player.cards = handCards[index] || [];
     }
+  });
 
-    if (isTerminal) {
-      const reward = environment.rewards ? environment.rewards[i] : null;
-      pData.reward = reward;
-      if (reward > 0) {
-        pData.name = `${pData.name} wins 🎉`;
-        pData.isWinner = true;
-        pData.status = null;
-      } else {
-        pData.status = null;
-      }
-    } else if (pData.stack === 0 && pData.currentBet > 0) {
-      pData.status = "All-in";
-    }
-  }
+  const displayCommunity = event.hideCommunity ? [] : communityCards;
 
-  return stateUIData;
-}
+  return {
+    players,
+    communityCards: displayCommunity,
+    pot: contributions.reduce((sum, value) => sum + (value || 0), 0),
+    isTerminal: false,
+    rawObservation: stateInfo.universal,
+    step,
+    winOdds: parsedStateHistory.winOdds,
+    fiveCardBestHands: [],
+    currentPlayer: stateInfo.universal?.current_player ?? -1,
+    winner: -1
+  };
+};

kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/main.ts

@@ -1,37 +1,37 @@
-import { Player, GameAdapter, ReplayData } from '@kaggle-environments/core';
-import { renderer } from './repeated_poker_renderer.js';
-import { render } from 'preact';
+import { Player, GameAdapter, ReplayData } from "@kaggle-environments/core";
+import { renderer } from "./repeated_poker_renderer.js";
+import { render } from "preact";
 
 class LegacyAdapter implements GameAdapter {
-    private container: HTMLElement | null = null;
+  private container: HTMLElement | null = null;
 
-    mount(container: HTMLElement): void {
-        this.container = container;
-    }
+  mount(container: HTMLElement): void {
+    this.container = container;
+  }
 
-    render(step: number, replay: ReplayData, agents: any[]): void {
-        if (!this.container) return;
-        this.container.innerHTML = ''; // Clear container before rendering
-        renderer({
-            parent: this.container,
-            environment: replay,
-            step: step,
-            agents: agents,
-            // These are probably not used by poker but good to have
-            width: this.container.clientWidth,
-            height: this.container.clientHeight
-        });
-    }
+  render(step: number, replay: ReplayData, agents: any[]): void {
+    if (!this.container) return;
+    this.container.innerHTML = ""; // Clear container before rendering
+    renderer({
+      parent: this.container,
+      environment: replay,
+      step: step,
+      agents: agents,
+      // These are probably not used by poker but good to have
+      width: this.container.clientWidth,
+      height: this.container.clientHeight,
+    });
+  }
 
-    unmount(): void {
-        if (this.container) {
-            render(null, this.container);
-        }
-        this.container = null;
+  unmount(): void {
+    if (this.container) {
+      render(null, this.container);
     }
+    this.container = null;
+  }
 }
 
-const app = document.getElementById('app');
+const app = document.getElementById("app");
 if (app) {
-    new Player(app, new LegacyAdapter());
+  new Player(app, new LegacyAdapter());
 }

kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js

@@ -525,7 +525,6 @@ export function renderer(options) {
   // --- State Parsing ---
   function _parseKagglePokerState(options) {
     const { environment, step } = options;
-    const numPlayers = 2;
 
     // --- Default State ---
     const defaultStateUiData = {
@@ -536,7 +535,7 @@ export function renderer(options) {
     };
 
     // --- Step Validation ---
-    if (!environment || !environment.steps || !environment.steps[step] || !environment.info?.stateHistory) {
+    if (!environment || !step) {
       return defaultStateUiData;
     }
 
@@ -559,7 +558,7 @@ export function renderer(options) {
     elements.gameLayout.style.transform = `scale(${scale})`;
   }
 
-  function _renderPokerTableUI(data, passedOptions) {
+  function _renderPokerTableUI(data) {
     if (!elements.pokerTable || !data) return;
     const { players, communityCards, pot, isTerminal, step } = data;
 
@@ -603,8 +602,8 @@ export function renderer(options) {
       if (playerNameElement) {
         playerNameElement.textContent = playerData.name;
 
-        // Highlight current player's turn
-        if (playerData.isTurn && !isTerminal) {
+        // Highlight the player who took the most recent action
+        if (playerData.isLastActor) {
           playerNameElement.classList.add('current-turn');
         } else {
           playerNameElement.classList.remove('current-turn');
@@ -650,7 +649,7 @@ export function renderer(options) {
       const playerInfoArea = elements.playerInfoAreas[index];
       if (playerInfoArea) {
         // Highlight active player's pod
-        if (playerData.isTurn && !isTerminal) {
+        if (playerData.isLastActor) {
           playerInfoArea.classList.add('active-player');
         } else {
           playerInfoArea.classList.remove('active-player');

{kaggle_environments-1.23.5.dist-info → kaggle_environments-1.23.6.dist-info}/METADATA

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

{kaggle_environments-1.23.5.dist-info → kaggle_environments-1.23.6.dist-info}/RECORD

@@ -194,9 +194,9 @@ kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/tsconfig.json,sha256=3X9dsQOgFw_cZ_uXByZIsGrQ5jhFfAZZL7QC6ApJWak,133
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/vite.config.ts,sha256=KhIjUn0WWhaoQzQ5YKuWjNndimRF0kFlYDgEnZ0cg7U,208
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/replays/test-replay.json,sha256=jf4ilR6SmOYPNohkIGJvmKP5Gju5FY6sfSStX1qtFZg,28919900
-kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/main.ts,sha256=5NZlic4P9aSdMJpWxckaDrObEx2OJj8FNG49g-Z9_ow,1095
-kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js,sha256=RmbMsVoJobYNypSiyv1kdG-hleRR5-jquIZJZZdVcyM,26598
-kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js,sha256=T-2pegCVHT1OP6PhllPS-3RRQYWe912v2dw5eR5tb0k,8051
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/main.ts,sha256=Its2m61qv7RHlHUzIW6JkmySaHWq1h2bJ5sWY9woots,1000
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js,sha256=rEAJf5I7GKyot9H8BqyatneWvzKJFUfl7G9_hNPHA5Y,26482
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js,sha256=6nTmNT2iD2wpc0li2RU-URHM8jlKd4MRJDsVMLRcMI8,12490
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/utils.js,sha256=pXDAu4V2OppRCvMdJKQ56q1uFTJReMPIvBL6gwxIJoI,5734
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/images/poker_chip_1.svg,sha256=v9yCvpnaQAg8OSUJdJ5PhuTHm9_zXnww-9_7oR_DJpc,22160
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/images/poker_chip_10.svg,sha256=z3CP2h5eUGlgBdqNoWGcioekAyPgiuzhyRNr-nbutOE,22160
@@ -279,8 +279,8 @@ kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_p
 kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_parallel_voting_no_tie_exile.yaml,sha256=sfSFlFU4F7doZ-wXUWBl-JgJtmpjrLR-SpCAqKnUYeQ,3662
 kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_parallel_voting_roundbiddiscussion.yaml,sha256=UGSLfOhmC-4pRqWsJvOtZRU0YLUuOMAGeEHtxTf3wf8,3710
 kaggle_environments/static/player.html,sha256=Icl5yYscPe4BRoWt0HLOSRJWnznQq2MdTHHCaC2OrQQ,27753
-kaggle_environments-1.23.5.dist-info/entry_points.txt,sha256=h03sq76TdcHvXKcsre1Qm3lIni9dkWehu61xJqI-p8k,69
-kaggle_environments-1.23.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-1.23.5.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-kaggle_environments-1.23.5.dist-info/METADATA,sha256=fO4oOApn4Mfm40bqXjJHUdnUYh9nqeKvB6ju2FHGLIc,916
-kaggle_environments-1.23.5.dist-info/RECORD,,
+kaggle_environments-1.23.6.dist-info/entry_points.txt,sha256=h03sq76TdcHvXKcsre1Qm3lIni9dkWehu61xJqI-p8k,69
+kaggle_environments-1.23.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kaggle_environments-1.23.6.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+kaggle_environments-1.23.6.dist-info/METADATA,sha256=EQ9xVZR7e9fuaBqASk1B3rEJwOTii36QXXSU198jlLA,916
+kaggle_environments-1.23.6.dist-info/RECORD,,