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

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

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

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

@@ -0,0 +1,207 @@
+import { getActionStringsFromACPC } from "@kaggle-environments/core";
+
+const PLACEHOLDER_CARD = '2c';
+
+function _parseStepHistoryData(universalPokerJSON, nextPlayerIndex, numPlayers = 2) {
+  const result = {
+    cards: [],
+    communityCards: '',
+    bets: [],
+    playerActionStrings: Array(numPlayers).fill(''),
+    winOdds: [0, 0],
+  };
+
+  if (!universalPokerJSON) {
+    return result;
+  }
+
+  const lines = universalPokerJSON.acpc_state.trim().split('\n');
+  if (lines.length < 2) {
+    return result;
+  }
+
+  const stateLine = lines[0];
+  const spentLine = lines[1];
+
+  if (spentLine) {
+    const p0BetMatch = spentLine.match(/P0:\s*(\d+)/);
+    const p1BetMatch = spentLine.match(/P1:\s*(\d+)/);
+
+    const bets = [0, 0];
+
+    if (p0BetMatch) {
+      bets[0] = parseInt(p0BetMatch[1], 10);
+    }
+
+    if (p1BetMatch) {
+      bets[1] = parseInt(p1BetMatch[1], 10);
+    }
+
+    result.bets = bets;
+  }
+
+  if (stateLine) {
+    const stateParts = stateLine.split(':');
+    const cardString = stateParts[stateParts.length - 1];
+    const cardSegments = cardString.split('/');
+
+    if (cardSegments[0]) {
+      const playerHands = cardSegments[0].split('|');
+      if (playerHands.length >= 2) {
+        result.cards = [playerHands[0], playerHands[1]];
+      }
+    }
+
+    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
+      );
+    }
+  }
+
+  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;
+}
+
+function splitCards(cardString) {
+  if (!cardString) {
+    return [];
+  }
+  return cardString.match(/.{1,2}/g) || [];
+}
+
+function isPlaceholderString(cardString) {
+  return typeof cardString === 'string' && /^((2c)+)$/i.test(cardString);
+}
+
+function sanitizeCardList(cards) {
+  return (cards || []).filter((card) => card);
+}
+
+
+
+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;
+}
+
+function getHandCardsFromUniversal(universal, numPlayers) {
+  const parsed = _parseStepHistoryData(universal, null, numPlayers);
+  return (parsed.cards || []).map((cardString) => {
+    if (isPlaceholderString(cardString)) {
+      return [];
+    }
+    return sanitizeCardList(splitCards(cardString));
+  });
+}
+
+
+
+
+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)
+  };
+}
+
+export const getPokerStateForStep = (environment, step) => {
+  const numPlayers = 2;
+  if (!environment || !environment.info?.stateHistory) {
+    return null;
+  }
+
+  const event = environment.steps[step];
+
+  if (!event) {
+    return null;
+  }
+
+  const stateInfo = getUniversalState(environment, event.stateHistoryIndex);
+  if (!stateInfo) {
+    return null;
+  }
+
+  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] || [];
+    }
+  });
+
+  const displayCommunity = event.hideCommunity ? [] : communityCards;
+
+  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-1.23.7 → kaggle_environments-1.23.9}/kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js

@@ -539,6 +539,7 @@ export function renderer(options) {
       return defaultStateUiData;
     }
 
+
     return getPokerStateForStep(environment, step);
   }
 
@@ -710,6 +711,7 @@ export function renderer(options) {
   const uiData = _parseKagglePokerState(options);
   _renderPokerTableUI(uiData, options);
 
+
   // Apply initial scale
   _applyScale(parent);
 

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

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

kaggle_environments-1.23.9/web/core/src/index.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./adapter";
+export * from "./preact-adapter";
+export * from "./player";
+export * from "./transformers";
+export * from "./transformers/buildTimeline";

{kaggle_environments-1.23.7 → kaggle_environments-1.23.9}/web/core/src/player.ts

@@ -179,7 +179,6 @@ export class Player {
     }
 
     private setData(replay: ReplayData, agents: any[] = []) {
-        console.log('setData called', replay);
         this.replay = replay;
         this.agents = agents;