kaggle-environments 1.23.10__py3-none-any.whl → 1.23.12__py3-none-any.whl

kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/scripts/print_first_steps.mjs

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+import path from "path";
+import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
+
+function parseArgs(defaultReplayPath, defaultStepLimit) {
+  const args = process.argv.slice(2);
+  let replayPath = defaultReplayPath;
+  let stepLimit = defaultStepLimit;
+
+  const usage = `Usage: node ${path.basename(
+    process.argv[1]
+  )} [options]\n\nOptions:\n  -r, --replay <path>   Replay JSON to inspect (default: ${defaultReplayPath})\n  -s, --steps <count>   Number of steps to print (default: ${defaultStepLimit})\n  -h, --help            Show this help message\n`;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(usage);
+      process.exit(0);
+    } else if ((arg === "-r" || arg === "--replay") && args[i + 1]) {
+      replayPath = path.resolve(args[i + 1]);
+      i += 1;
+    } else if ((arg === "-s" || arg === "--steps") && args[i + 1]) {
+      const value = Number(args[i + 1]);
+      if (!Number.isInteger(value) || value <= 0) {
+        console.error("Steps limit must be a positive integer.");
+        console.log(usage);
+        process.exit(1);
+      }
+      stepLimit = value;
+      i += 1;
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      console.log(usage);
+      process.exit(1);
+    }
+  }
+
+  return { replayPath, stepLimit };
+}
+
+function truncate(text, maxLength = 120) {
+  if (typeof text !== "string") {
+    return text;
+  }
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, maxLength - 3)}...`;
+}
+
+function summarizeAction(action) {
+  if (action == null) {
+    return "-";
+  }
+
+  if (typeof action !== "object") {
+    return String(action);
+  }
+
+  const parts = [];
+  if (Object.prototype.hasOwnProperty.call(action, "actionString")) {
+    parts.push(`actionString=${action.actionString}`);
+  }
+  if (Object.prototype.hasOwnProperty.call(action, "submission")) {
+    parts.push(`submission=${action.submission}`);
+  }
+  if (Object.prototype.hasOwnProperty.call(action, "status") && action.status) {
+    parts.push(`status=${truncate(action.status, 60)}`);
+  }
+
+  if (parts.length > 0) {
+    return parts.join(" | ");
+  }
+
+  return truncate(JSON.stringify(action));
+}
+
+function summarizeObservation(observation) {
+  if (observation == null) {
+    return "-";
+  }
+
+  if (typeof observation !== "object") {
+    return String(observation);
+  }
+
+  const parts = [];
+  if (Object.prototype.hasOwnProperty.call(observation, "step")) {
+    parts.push(`step=${observation.step}`);
+  }
+  if (Object.prototype.hasOwnProperty.call(observation, "currentPlayer")) {
+    parts.push(`currentPlayer=${observation.currentPlayer}`);
+  }
+  if (Object.prototype.hasOwnProperty.call(observation, "isTerminal")) {
+    parts.push(`isTerminal=${observation.isTerminal}`);
+  }
+  if (
+    Object.prototype.hasOwnProperty.call(observation, "observationString") &&
+    observation.observationString
+  ) {
+    parts.push(
+      `observationString="${truncate(observation.observationString, 80)}"`
+    );
+  }
+  if (
+    Object.prototype.hasOwnProperty.call(
+      observation,
+      "serializedGameAndState"
+    ) &&
+    observation.serializedGameAndState
+  ) {
+    parts.push("serializedGameAndState=<omitted>");
+  }
+
+  if (parts.length > 0) {
+    return parts.join(" | ");
+  }
+
+  return truncate(JSON.stringify(observation));
+}
+
+async function main() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const defaultReplayPath = path.resolve(
+    __dirname,
+    "../replays/test-replay.json"
+  );
+  const defaultStepLimit = 5;
+
+  const { replayPath, stepLimit } = parseArgs(
+    defaultReplayPath,
+    defaultStepLimit
+  );
+
+  let replayRaw;
+  try {
+    replayRaw = await readFile(replayPath, "utf-8");
+  } catch (error) {
+    console.error(`Failed to read replay at ${replayPath}: ${error.message}`);
+    process.exit(1);
+  }
+
+  let replay;
+  try {
+    replay = JSON.parse(replayRaw);
+  } catch (error) {
+    console.error(
+      `Replay file ${replayPath} is not valid JSON: ${error.message}`
+    );
+    process.exit(1);
+  }
+
+  const steps = Array.isArray(replay?.steps) ? replay.steps : [];
+  if (steps.length === 0) {
+    console.error("Replay does not contain any steps.");
+    process.exit(1);
+  }
+
+  const limit = Math.min(stepLimit, steps.length);
+  console.log(`Loaded replay: ${replayPath}`);
+  console.log(`Printing first ${limit} of ${steps.length} steps\n`);
+
+  for (let stepIndex = 0; stepIndex < limit; stepIndex += 1) {
+    const step = steps[stepIndex];
+    console.log(`Step ${stepIndex}`);
+
+    if (!Array.isArray(step)) {
+      console.log("  (step is not an array)\n");
+      continue;
+    }
+
+    step.forEach((playerStep, playerIndex) => {
+      if (!playerStep || typeof playerStep !== "object") {
+        console.log(`  Player ${playerIndex}: <invalid step payload>`);
+        return;
+      }
+
+      const { action, observation, reward, status } = playerStep;
+      const actionSummary = summarizeAction(action);
+      const observationSummary = summarizeObservation(observation);
+      const rewardSummary =
+        reward == null ? "-" : JSON.stringify(reward, null, 0);
+      const statusSummary = status ?? "-";
+
+      console.log(
+        `  Player ${playerIndex}: status=${statusSummary} | reward=${rewardSummary}`
+      );
+      console.log(`    action: ${actionSummary}`);
+      console.log(`    observation: ${observationSummary}`);
+    });
+
+    console.log("");
+  }
+}
+
+main().catch((error) => {
+  console.error("Failed to print steps:", error);
+  process.exit(1);
+});

kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/scripts/print_replay.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+
+async function loadCoreModules(repoRoot) {
+  const require = createRequire(import.meta.url);
+  const corePath = path.resolve(repoRoot, "web/core/dist/index.umd.cjs");
+  const timelinePath = path.resolve(
+    repoRoot,
+    "web/core/dist/transformers/buildTimeline.js"
+  );
+
+  const { processEpisodeData } = require(corePath);
+  const { buildTimeline, getPokerStateForStep } = await import(
+    pathToFileURL(timelinePath).href
+  );
+
+  return { processEpisodeData, buildTimeline, getPokerStateForStep };
+}
+
+function parseArgs(defaultReplayPath, defaultStepLimit) {
+  const args = process.argv.slice(2);
+  let replayPath = defaultReplayPath;
+  let stepLimit = defaultStepLimit;
+
+  const usage = `Usage: node ${path.basename(
+    process.argv[1]
+  )} [options]\n\nOptions:\n  -r, --replay <path>   Replay JSON to inspect (default: ${defaultReplayPath})\n  -s, --steps <count>   Number of timeline steps to print (default: ${defaultStepLimit})\n  -h, --help            Show this help message\n`;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(usage);
+      process.exit(0);
+    } else if ((arg === "-r" || arg === "--replay") && args[i + 1]) {
+      replayPath = path.resolve(args[i + 1]);
+      i += 1;
+    } else if ((arg === "-s" || arg === "--steps") && args[i + 1]) {
+      const value = Number(args[i + 1]);
+      if (!Number.isInteger(value) || value <= 0) {
+        console.error("Steps limit must be a positive integer.");
+        console.log(usage);
+        process.exit(1);
+      }
+      stepLimit = value;
+      i += 1;
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      console.log(usage);
+      process.exit(1);
+    }
+  }
+
+  return { replayPath, stepLimit };
+}
+
+function extractStateHistory(replay) {
+  return (
+    replay?.info?.stateHistory ??
+    replay?.info?.state_history ??
+    replay?.stateHistory ??
+    replay?.state_history ??
+    []
+  );
+}
+
+function formatCommunityCards(cards) {
+  if (!Array.isArray(cards) || cards.length === 0) {
+    return "--";
+  }
+  return cards.join(" ");
+}
+
+function formatWinOdds(winOdds) {
+  if (!Array.isArray(winOdds) || winOdds.length === 0) {
+    return "--";
+  }
+  return winOdds.join(" vs ");
+}
+
+async function main() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const repoRoot = path.resolve(__dirname, "../../../../../../../..");
+  const defaultReplayPath = path.resolve(
+    __dirname,
+    "../replays/test-replay.json"
+  );
+  const defaultStepLimit = 5;
+
+  const { replayPath, stepLimit } = parseArgs(
+    defaultReplayPath,
+    defaultStepLimit
+  );
+
+  const { processEpisodeData, buildTimeline, getPokerStateForStep } =
+    await loadCoreModules(repoRoot);
+
+  let replayRaw;
+  try {
+    replayRaw = await readFile(replayPath, "utf-8");
+  } catch (error) {
+    console.error(`Failed to read replay at ${replayPath}: ${error.message}`);
+    process.exit(1);
+  }
+
+  let replay;
+  try {
+    replay = JSON.parse(replayRaw);
+  } catch (error) {
+    console.error(
+      `Replay file ${replayPath} is not valid JSON: ${error.message}`
+    );
+    process.exit(1);
+  }
+
+  const stateHistory = extractStateHistory(replay);
+  if (!Array.isArray(stateHistory) || stateHistory.length === 0) {
+    console.error("Replay does not contain a state history.");
+    process.exit(1);
+  }
+
+  const processedSteps = processEpisodeData(
+    {
+      steps: replay.steps,
+      state_history: stateHistory,
+      info: replay.info,
+      configuration: replay.configuration,
+    },
+    "repeated_poker"
+  );
+
+  const environment = {
+    configuration: replay.configuration,
+    info: {
+      ...replay.info,
+      stateHistory,
+    },
+    steps: processedSteps,
+    __processedSteps: processedSteps,
+    __rawSteps: replay.steps,
+  };
+
+  const timeline = buildTimeline(environment, 2);
+  environment.__timeline = timeline;
+
+  console.log(`Loaded replay: ${replayPath}`);
+  console.log(
+    `Printing first ${Math.min(stepLimit, timeline.length)} of ${
+      timeline.length
+    } timeline steps\n`
+  );
+
+  for (let stepIndex = 0; stepIndex < timeline.length; stepIndex += 1) {
+    if (stepIndex >= stepLimit) {
+      break;
+    }
+
+    const event = timeline[stepIndex];
+    const uiState = getPokerStateForStep(environment, stepIndex);
+
+    const headerParts = [
+      `Step ${stepIndex}`,
+      `stateIndex=${event?.stateIndex ?? "N/A"}`,
+      `highlight=${event?.highlightPlayer ?? "-"}`,
+      `action='${event?.actionText ?? ""}'`,
+    ];
+    if (event?.hideHoleCards) {
+      headerParts.push("hideHoleCards");
+    }
+    if (event?.hideCommunity) {
+      headerParts.push("hideCommunity");
+    }
+
+    console.log(headerParts.join(" | "));
+
+    if (!uiState) {
+      console.log("  (UI state unavailable)\n");
+      continue;
+    }
+
+    console.log(
+      `  pot=${uiState.pot} | community=${formatCommunityCards(
+        uiState.communityCards
+      )} | winOdds=${formatWinOdds(uiState.winOdds)}`
+    );
+
+    uiState.players.forEach((player, seat) => {
+      const cards =
+        Array.isArray(player.cards) && player.cards.length > 0
+          ? player.cards.join(" ")
+          : "--";
+      const flags = [
+        player.isDealer ? "D" : "",
+        player.isTurn ? "T" : "",
+        player.isLastActor ? "LA" : "",
+      ]
+        .filter(Boolean)
+        .join(",") || "-";
+      console.log(
+        `    P${seat}: stack=${player.stack} bet=${player.currentBet} cards=${cards} flags=${flags} action='${player.actionDisplayText || ""}'`
+      );
+    });
+
+    console.log("");
+  }
+}
+
+main().catch((error) => {
+  console.error("Failed to print replay steps:", error);
+  process.exit(1);
+});

kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/scripts/print_steps_with_end_states.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+
+async function loadCoreModules(repoRoot) {
+  const require = createRequire(import.meta.url);
+  const corePath = path.resolve(repoRoot, "web/core/dist/index.umd.cjs");
+  const transformerPath = path.resolve(
+    repoRoot,
+    "web/core/dist/transformers/repeatedPokerTransformer.js"
+  );
+
+  const { processEpisodeData } = require(corePath);
+  const { getPokerStepsWithEndStates } = await import(
+    pathToFileURL(transformerPath).href
+  );
+
+  return { processEpisodeData, getPokerStepsWithEndStates };
+}
+
+function parseArgs(defaultReplayPath, defaultLimit, defaultJsonOutput) {
+  const args = process.argv.slice(2);
+  let replayPath = defaultReplayPath;
+  let limit = defaultLimit;
+  let asJson = defaultJsonOutput;
+
+  const usage = `Usage: node ${path.basename(
+    process.argv[1]
+  )} [options]\n\nOptions:\n  -r, --replay <path>   Replay JSON to inspect (default: ${defaultReplayPath})\n  -l, --limit <count>   Number of entries to print (0 = all) (default: ${defaultLimit})\n  --json                Print raw JSON instead of formatted text\n  -h, --help            Show this help message\n`;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(usage);
+      process.exit(0);
+    } else if ((arg === "-r" || arg === "--replay") && args[i + 1]) {
+      replayPath = path.resolve(args[i + 1]);
+      i += 1;
+    } else if ((arg === "-l" || arg === "--limit") && args[i + 1]) {
+      const value = Number(args[i + 1]);
+      if (!Number.isInteger(value) || value < 0) {
+        console.error("Limit must be a non-negative integer.");
+        console.log(usage);
+        process.exit(1);
+      }
+      limit = value;
+      i += 1;
+    } else if (arg === "--json") {
+      asJson = true;
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      console.log(usage);
+      process.exit(1);
+    }
+  }
+
+  return { replayPath, limit, asJson };
+}
+
+function extractStateHistory(replay) {
+  return (
+    replay?.info?.stateHistory ??
+    replay?.info?.state_history ??
+    replay?.stateHistory ??
+    replay?.state_history ??
+    []
+  );
+}
+
+function buildEnvironment(
+  replay,
+  processedSteps,
+  processedInfo,
+  processedConfig,
+  stateHistory
+) {
+  return {
+    configuration: processedConfig ?? replay.configuration ?? null,
+    info: {
+      ...(processedInfo || replay.info || {}),
+      stateHistory,
+    },
+    steps: processedSteps,
+    __processedSteps: processedSteps,
+    __rawSteps: replay.steps,
+  };
+}
+
+function describeStep(step, index) {
+  const baseParts = [
+    `Index ${index}`,
+    `hand=${step.hand}`,
+    `stateHistoryIndex=${step.stateHistoryIndex ?? "?"}`,
+    `isEndState=${step.isEndState}`,
+  ];
+
+  if (step.postActionOf != null) {
+    baseParts.push(`postActionOf=${step.postActionOf}`);
+  }
+
+  if (step.actingPlayer != null) {
+    const label =
+      step.actingPlayerName && step.actingPlayerName.length > 0
+        ? `${step.actingPlayer}(${step.actingPlayerName})`
+        : `${step.actingPlayer}`;
+    baseParts.push(`actingPlayer=${label}`);
+  }
+
+  if (step.currentPlayer != null) {
+    const label =
+      step.currentPlayerName && step.currentPlayerName.length > 0
+        ? `${step.currentPlayer}(${step.currentPlayerName})`
+        : `${step.currentPlayer}`;
+    baseParts.push(`currentPlayer=${label}`);
+  }
+
+  if (step.isEndState) {
+    baseParts.push(`conclusion=${step.handConclusion ?? "-"}`);
+    baseParts.push(`winner=${step.winner ?? "-"}`);
+  } else if (step.step?.action?.actionString) {
+    baseParts.push(`action=${step.step.action.actionString}`);
+  } else if (step.actionText) {
+    baseParts.push(`actionText=${step.actionText}`);
+  }
+
+  return baseParts.join(" | ");
+}
+
+async function main() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const repoRoot = path.resolve(__dirname, "../../../../../../../..");
+  const defaultReplayPath = path.resolve(
+    __dirname,
+    "../replays/test-replay.json"
+  );
+  const defaultLimit = 10;
+  const defaultJsonOutput = false;
+
+  const { replayPath, limit, asJson } = parseArgs(
+    defaultReplayPath,
+    defaultLimit,
+    defaultJsonOutput
+  );
+
+  const { processEpisodeData, getPokerStepsWithEndStates } =
+    await loadCoreModules(repoRoot);
+
+  let replayRaw;
+  try {
+    replayRaw = await readFile(replayPath, "utf-8");
+  } catch (error) {
+    console.error(`Failed to read replay at ${replayPath}: ${error.message}`);
+    process.exit(1);
+  }
+
+  let replay;
+  try {
+    replay = JSON.parse(replayRaw);
+  } catch (error) {
+    console.error(
+      `Replay file ${replayPath} is not valid JSON: ${error.message}`
+    );
+    process.exit(1);
+  }
+
+  const stateHistory = extractStateHistory(replay);
+  if (!Array.isArray(stateHistory) || stateHistory.length === 0) {
+    console.error("Replay does not contain a state history.");
+    process.exit(1);
+  }
+
+  const processedResult = processEpisodeData(
+    {
+      steps: replay.steps,
+      state_history: stateHistory,
+      info: replay.info,
+      configuration: replay.configuration,
+    },
+    "repeated_poker"
+  );
+
+  const processedSteps = Array.isArray(processedResult?.steps)
+    ? processedResult.steps
+    : [];
+
+  if (processedSteps.length === 0) {
+    console.error("Processed episode contains no steps.");
+    process.exit(1);
+  }
+
+  const environment = buildEnvironment(
+    replay,
+    processedSteps,
+    processedResult?.info,
+    processedResult?.configuration,
+    stateHistory
+  );
+
+  const stepsWithEndStates = getPokerStepsWithEndStates(environment);
+
+  console.log(`Loaded replay: ${replayPath}`);
+  console.log(
+    `Derived ${stepsWithEndStates.length} entries via getPokerStepsWithEndStates`
+  );
+
+  if (asJson) {
+    const subset =
+      limit === 0 ? stepsWithEndStates : stepsWithEndStates.slice(0, limit);
+    console.log(JSON.stringify(subset, null, 2));
+    return;
+  }
+
+  const entriesToPrint =
+    limit === 0 ? stepsWithEndStates : stepsWithEndStates.slice(0, limit);
+
+  entriesToPrint.forEach((entry, index) => {
+    console.log(describeStep(entry, index));
+  });
+
+  if (limit > 0 && stepsWithEndStates.length > limit) {
+    console.log(
+      `\n(${stepsWithEndStates.length - limit} additional entries not shown; rerun with -l 0 to display all or --json for raw output.)`
+    );
+  }
+}
+
+main().catch((error) => {
+  console.error("Failed to print steps:", error);
+  process.exit(1);
+});

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,31 +52,31 @@ 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);
     }
   }
 
   const odds = universalPokerJSON.odds || [];
-  const p0WinOdds = Number(odds[0] ?? 0).toLocaleString(undefined, {
+  // The odds array is structured as [Player1_Win_Prob, Tie_Prob, Player2_Win_Prob, Tie_Prob_Repeated]
+  const p0WinProb = Number(odds[0] ?? 0);
+  const tieProb = Number(odds[1] ?? 0);
+  const p1WinProb = Number(odds[2] ?? 0);
+  const fiveCardBestHands = universalPokerJSON.best_hand_rank_types || [];
+
+  result.winProb = [
+    p0WinProb.toLocaleString(undefined, { style: 'percent', minimumFractionDigits: 1, maximumFractionDigits: 1 }),
+    p1WinProb.toLocaleString(undefined, { style: 'percent', minimumFractionDigits: 1, maximumFractionDigits: 1 })
+  ];
+  result.tieProb = tieProb.toLocaleString(undefined, {
     style: 'percent',
-    minimumFractionDigits: 2
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1
   });
-  const p1WinOdds = Number(odds[1] ?? 0).toLocaleString(undefined, {
-    style: 'percent',
-    minimumFractionDigits: 2
-  });
-  result.winOdds = [p0WinOdds, p1WinOdds];
+  result.handRank = fiveCardBestHands;
 
   return result;
 }
@@ -96,8 +96,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 +116,6 @@ function getHandCardsFromUniversal(universal, numPlayers) {
   });
 }
 
-
-
-
 function getUniversalState(environment, index) {
   const entry = environment?.info?.stateHistory?.[index];
   if (!entry) {
@@ -152,12 +147,13 @@ export const getPokerStateForStep = (environment, step) => {
 
   const parsedStateHistory = _parseStepHistoryData(
     stateInfo.universal,
-    stateInfo.universal?.current_player,
+    event.actingPlayer,
     numPlayers
   );
 
   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);
 
@@ -174,10 +170,12 @@ export const getPokerStateForStep = (environment, step) => {
         cards: [],
         currentBet: contributions[i] || 0,
         isDealer: stateInfo.outer?.dealer === i,
-        isTurn: stateInfo.universal?.current_player === i,
+        isTurn: event.actingPlayer === i,
         isLastActor: event.highlightPlayer === i,
         reward: rewards[0]?.[i] ?? null,
-        actionDisplayText: event.highlightPlayer === i ? event.actionText : ''
+        actionDisplayText: event.winner === i ? "Winner" : parsedStateHistory.playerActionStrings[i],
+        isWinner: event.winner === i,
+        handCount: 0,
       };
     });
 
@@ -192,6 +190,57 @@ export const getPokerStateForStep = (environment, step) => {
 
   const displayCommunity = event.hideCommunity ? [] : communityCards;
 
+  const hand_returns = stateInfo.outer?.hand_returns || [];
+  const cumulativeWinnings = Array(numPlayers).fill(0);
+  const previousHands = [];
+
+  for (let i = 0; i < hand_returns.length; i++) {
+    const handReturn = hand_returns[i];
+    if (!handReturn) continue;
+
+    let winner = -1;
+    let winAmount = 0;
+    if (handReturn[0] > handReturn[1]) {
+      winner = 0;
+      winAmount = handReturn[0];
+    } else if (handReturn[1] > handReturn[0]) {
+      winner = 1;
+      winAmount = handReturn[1];
+    }
+
+    if (winner !== -1) {
+      previousHands.push({
+        handNum: i + 1,
+        winnerIndex: winner,
+        winnerName: environment?.info?.TeamNames?.[winner] || `Player ${winner}`,
+        winnerThumbnail: environment?.info?.Agents?.[winner]?.ThumbnailUrl,
+        amount: winAmount
+      });
+    }
+
+    cumulativeWinnings[0] += handReturn[0] || 0;
+    cumulativeWinnings[1] += handReturn[1] || 0;
+  }
+
+  let leadingPlayer = -1;
+  let leadingWinnings = 0;
+  if (cumulativeWinnings[0] > cumulativeWinnings[1]) {
+    leadingPlayer = 0;
+    leadingWinnings = cumulativeWinnings[0];
+  } else if (cumulativeWinnings[1] > cumulativeWinnings[0]) {
+    leadingPlayer = 1;
+    leadingWinnings = cumulativeWinnings[1];
+  }
+
+  const leaderInfo =
+    leadingPlayer !== -1
+      ? {
+        name: environment?.info?.TeamNames?.[leadingPlayer] || `Player ${leadingPlayer}`,
+        thumbnail: environment?.info?.Agents?.[leadingPlayer]?.ThumbnailUrl,
+        winnings: leadingWinnings
+      }
+      : null;
+
   return {
     players,
     communityCards: displayCommunity,
@@ -199,9 +248,13 @@ export const getPokerStateForStep = (environment, step) => {
     isTerminal: false,
     rawObservation: stateInfo.universal,
     step,
-    winOdds: parsedStateHistory.winOdds,
-    fiveCardBestHands: [],
+    winProb: parsedStateHistory.winProb,
+    tieProb: parsedStateHistory.tieProb,
+    handRank: parsedStateHistory.handRank,
     currentPlayer: stateInfo.universal?.current_player ?? -1,
-    winner: -1
+    winner: -1,
+    handCount: event.hand,
+    previousHands,
+    leaderInfo
   };
 };

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,
+    legend: null
   };
 
   const css = `
@@ -133,14 +134,14 @@ export function renderer(options) {
     .player-info-area {
       color: white;
       width: auto;
-      min-width: 200px;
+      min-width: 280px;
       pointer-events: auto;
       display: flex;
       flex-direction: column;
       justify-content: center;
       align-items: center;
-      margin: 20px auto;
-      padding: 20px;
+      margin: 10px auto;
+      padding: 10px;
       background-color: rgba(32, 33, 36, 0.70);;
       border-radius: 16px;
       box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
@@ -162,7 +163,7 @@ export function renderer(options) {
       justify-content: center;
       gap: 16px;
       margin: 0 60px;
-      padding: 10px 0;
+      padding: 5px 0;
     }
     .player-thumbnail {
       width: 48px;
@@ -184,6 +185,20 @@ export function renderer(options) {
     .player-name.winner { color: #FFEB70; }
     .player-name.current-turn { color: #20BEFF; }
     .player-stack { font-size: 20px; font-weight: 600; color: #ffffff; display: flex; flex-direction: column; justify-content: center; align-items: center; text-align: center; }
+    .player-stats-container {
+      display: flex;
+      flex-direction: column;
+      justify-content: center;
+      align-items: center;
+      margin: 0 12px;
+    }
+    .player-hand-rank, .player-win-prob, .player-tie-prob {
+      font-size: 16px;
+      font-weight: 600;
+      color: #e0e0e0;
+      height: 20px;
+      align-self: flex-start;
+    }
     .player-cards-container { min-height: 80px; display: flex; justify-content: center; align-items:center;}
     .card {
       display: flex; flex-direction: column; justify-content: space-between; align-items: center;
@@ -242,7 +257,6 @@ export function renderer(options) {
       box-shadow: 0 1px 3px rgba(0,0,0,0.3); z-index: 15; pointer-events: auto;
       border: 2px solid black;
       outline: 2px solid #20BEFF;
-      left: 320px
     }
     .dealer-button.dealer-player0 { top: 170px; }
     .dealer-button.dealer-player1 { bottom: 170px; }
@@ -253,6 +267,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;
@@ -305,6 +325,70 @@ export function renderer(options) {
       font-weight: bold;
       white-space: nowrap;
     }
+    .legend {
+      position: absolute;
+      top: 0px;
+      right: 0px;
+      width: 280px;
+      background-color: rgba(32, 33, 36, 0.70);
+      border-radius: 8px;
+      color: white;
+      z-index: 100;
+      display: flex;
+      flex-direction: column;
+      max-height: 212px;
+    }
+    .legend-title {
+      padding: 10px;
+      font-weight: bold;
+      border-bottom: 1px solid #555;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+    }
+    .legend-leader-info {
+      display: flex;
+      align-items: center;
+    }
+    .legend-title-avatar {
+      width: 32px;
+      height: 32px;
+      border-radius: 50%;
+      margin-right: 8px;
+    }
+    .legend-body {
+      padding: 10px;
+      max-height: 200px;
+      overflow-y: auto;
+    }
+    .legend-table {
+      display: table;
+      width: 100%;
+    }
+    .legend-row {
+      display: table-row;
+    }
+    .legend-header .legend-cell {
+      font-weight: bold;
+    }
+    .legend-cell {
+      display: table-cell;
+      padding: 2px 5px;
+      vertical-align: middle;
+    }
+    .legend-cell:nth-child(1) { width: 20%; }
+    .legend-cell:nth-child(2) { width: 50%; }
+    .legend-cell:nth-child(3) { width: 30%; text-align: right; }
+    .legend-winner-cell {
+      display: flex;
+      align-items: center;
+    }
+    .legend-avatar {
+      width: 24px;
+      height: 24px;
+      border-radius: 50%;
+      margin-right: 5px;
+    }
   `;
 
   function _injectStyles(passedOptions) {
@@ -496,6 +580,11 @@ export function renderer(options) {
               <div class="player-card-area">
                 <div class="player-cards-container"></div>
               </div>
+              <div class="player-stats-container">
+                <div class="player-hand-rank"></div>
+                <div class="player-win-prob"></div>
+                <div class="player-tie-prob"></div>
+              </div>
               <div class="player-stack">
                 <span class="player-stack-value">0</span>
               </div>
@@ -515,14 +604,16 @@ export function renderer(options) {
     elements.dealerButton.style.display = 'none';
     elements.playersContainer.appendChild(elements.dealerButton);
 
-    elements.stepCounter = document.createElement('div');
-    elements.stepCounter.className = 'step-counter';
-    elements.stepCounter.textContent = 'Standby';
-    elements.gameLayout.appendChild(elements.stepCounter);
-    return true;
-  }
+    elements.legend = document.createElement('div');
+    elements.legend.className = 'legend';
+    elements.legend.innerHTML = `
+      <div class="legend-title"></div>
+      <div class="legend-body"></div>
+    `;
+    elements.gameLayout.appendChild(elements.legend);
 
-  // --- State Parsing ---
+    return true;
+  } // --- State Parsing ---
   function _parseKagglePokerState(options) {
     const { environment, step } = options;
 
@@ -531,7 +622,7 @@ export function renderer(options) {
       players: [],
       communityCards: [],
       pot: 0,
-      isTerminal: false,
+      isTerminal: false
     };
 
     // --- Step Validation ---
@@ -539,7 +630,6 @@ export function renderer(options) {
       return defaultStateUiData;
     }
 
-
     return getPokerStateForStep(environment, step);
   }
 
@@ -561,13 +651,123 @@ export function renderer(options) {
 
   function _renderPokerTableUI(data) {
     if (!elements.pokerTable || !data) return;
-    const { players, communityCards, pot, isTerminal, step } = data;
+    const {
+      players,
+      communityCards,
+      pot,
+      isTerminal,
+      handCount,
+      winProb,
+      tieProb,
+      handRank,
+      previousHands,
+      leaderInfo
+    } = data;
+
+    // Update legend
+    const legendTitle = elements.legend.querySelector('.legend-title');
+    const legendBody = elements.legend.querySelector('.legend-body');
+
+    legendTitle.innerHTML = ''; // Clear existing content
+
+    const handSpan = document.createElement('span');
+    handSpan.textContent = `Hand: ${handCount !== undefined && handCount !== null ? handCount + 1 : 'Standby'}`;
+    legendTitle.appendChild(handSpan);
+
+    if (leaderInfo) {
+      const leaderInfoDiv = document.createElement('div');
+      leaderInfoDiv.className = 'legend-leader-info';
+
+      if (leaderInfo.thumbnail) {
+        const leaderThumbnail = document.createElement('img');
+        leaderThumbnail.src = leaderInfo.thumbnail;
+        leaderThumbnail.className = 'legend-title-avatar';
+        leaderInfoDiv.appendChild(leaderThumbnail);
+      }
+
+      const leaderNameSpan = document.createElement('span');
+      const leaderName = leaderInfo.name.split(' ')[0];
+      leaderNameSpan.textContent = `${leaderName} is up ${leaderInfo.winnings}`;
+      leaderInfoDiv.appendChild(leaderNameSpan);
+      legendTitle.appendChild(leaderInfoDiv);
+    }
+
+    legendBody.innerHTML = ''; // Clear existing content
+
+    const table = document.createElement('div');
+    table.className = 'legend-table';
+
+    const headerRow = document.createElement('div');
+    headerRow.className = 'legend-row legend-header';
+
+    const handHeader = document.createElement('div');
+    handHeader.className = 'legend-cell';
+    handHeader.textContent = 'Hand';
+    headerRow.appendChild(handHeader);
+
+    const winnerHeader = document.createElement('div');
+    winnerHeader.className = 'legend-cell';
+    winnerHeader.textContent = 'Winner';
+    headerRow.appendChild(winnerHeader);
+
+    const amountHeader = document.createElement('div');
+    amountHeader.className = 'legend-cell';
+    amountHeader.textContent = 'Amount';
+    headerRow.appendChild(amountHeader);
+
+    table.appendChild(headerRow);
+
+    if (previousHands && previousHands.length > 0) {
+      previousHands
+        .slice()
+        .reverse()
+        .forEach((hand) => {
+          const row = document.createElement('div');
+          row.className = 'legend-row';
+
+          const handCell = document.createElement('div');
+          handCell.className = 'legend-cell';
+          handCell.textContent = hand.handNum;
+          row.appendChild(handCell);
+
+          const winnerCell = document.createElement('div');
+          winnerCell.className = 'legend-cell';
+          const winnerCellContainer = document.createElement('div');
+          winnerCellContainer.className = 'legend-winner-cell';
+
+          if (hand.winnerThumbnail) {
+            const winnerThumbnail = document.createElement('img');
+            winnerThumbnail.src = hand.winnerThumbnail;
+            winnerThumbnail.className = 'legend-avatar';
+            winnerCellContainer.appendChild(winnerThumbnail);
+          }
+
+          const winnerNameSpan = document.createElement('span');
+          winnerNameSpan.textContent = hand.winnerName.split(' ')[0];
+          winnerCellContainer.appendChild(winnerNameSpan);
+
+          winnerCell.appendChild(winnerCellContainer);
+          row.appendChild(winnerCell);
 
-    // Update step counter
-    if (elements.stepCounter && step !== undefined) {
-      elements.stepCounter.textContent = `Debug Step: ${step}`;
+          const amountCell = document.createElement('div');
+          amountCell.className = 'legend-cell';
+          amountCell.textContent = hand.amount;
+          row.appendChild(amountCell);
+
+          table.appendChild(row);
+        });
+    } else {
+      const emptyRow = document.createElement('div');
+      emptyRow.className = 'legend-row';
+      const emptyCell = document.createElement('div');
+      emptyCell.className = 'legend-cell';
+      emptyCell.setAttribute('colspan', '3');
+      emptyRow.appendChild(emptyCell);
+      table.appendChild(emptyRow);
     }
 
+    legendBody.appendChild(table);
+
     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 +780,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]));
@@ -676,6 +872,27 @@ export function renderer(options) {
         } else {
           betDisplay.style.display = 'none';
         }
+
+        const handRankElement = playerInfoArea.querySelector('.player-hand-rank');
+        if (handRankElement && handRank && handRank[index]) {
+          handRankElement.textContent = handRank[index];
+        } else if (handRankElement) {
+          handRankElement.textContent = '';
+        }
+
+        const winProbElement = playerInfoArea.querySelector('.player-win-prob');
+        if (winProbElement && winProb && winProb[index] && !isTerminal) {
+          winProbElement.textContent = `Win: ${winProb[index]}`;
+        } else if (winProbElement) {
+          winProbElement.textContent = '';
+        }
+
+        const tieProbElement = playerInfoArea.querySelector('.player-tie-prob');
+        if (tieProbElement && tieProb && !isTerminal) {
+          tieProbElement.textContent = `Tie: ${tieProb}`;
+        } else if (tieProbElement) {
+          tieProbElement.textContent = '';
+        }
       }
     });
 
@@ -683,10 +900,16 @@ export function renderer(options) {
     if (elements.dealerButton) {
       if (dealerPlayerIndex !== -1) {
         elements.dealerButton.style.display = 'block';
-        // Remove previous dealer class
         elements.dealerButton.classList.remove('dealer-player0', 'dealer-player1');
-        // Add new dealer class based on player index
         elements.dealerButton.classList.add(`dealer-player${dealerPlayerIndex}`);
+
+        const playerInfoArea = elements.playerInfoAreas[dealerPlayerIndex];
+        if (playerInfoArea) {
+          const boxRect = playerInfoArea.getBoundingClientRect();
+          const containerRect = elements.playersContainer.getBoundingClientRect();
+          const left = boxRect.left - containerRect.left - elements.dealerButton.offsetWidth - 20;
+          elements.dealerButton.style.left = `${left}px`;
+        }
       } else {
         elements.dealerButton.style.display = 'none';
       }
@@ -711,7 +934,6 @@ export function renderer(options) {
   const uiData = _parseKagglePokerState(options);
   _renderPokerTableUI(uiData, options);
 
-
   // Apply initial scale
   _applyScale(parent);
 

{kaggle_environments-1.23.10.dist-info → kaggle_environments-1.23.12.dist-info}/METADATA

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

{kaggle_environments-1.23.10.dist-info → kaggle_environments-1.23.12.dist-info}/RECORD

@@ -194,9 +194,12 @@ 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/scripts/print_first_steps.mjs,sha256=dveXJxSDRPS78s2nWo3pN-fektaVWSCZ4j8k6qInv_c,5613
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/scripts/print_replay.mjs,sha256=JvveM8NqRu_ujjwhRj9EbuoQhBdvmdVcLWgOWySqnU8,5879
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/scripts/print_steps_with_end_states.mjs,sha256=BQ7erkBJTEXmBcMqjUYmxr20ovc0GyRNhHktzXtWgqk,6590
 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=omKkYjciuJelgqlm-ce114YPwQhGa3tMs7N8qOzP8RI,26484
-kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js,sha256=f0jh-Fkpgfwbz9LrCSi0fx-twJnWWL63hnrMTx9SjsU,5491
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js,sha256=HXv1F3_C4ntrW4IIZ4BrMwAEKLJBbWzRohaETdmzg_A,33502
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js,sha256=4JfDFe4-NV8JrY20Zp_eNe-ks4fquGRlAq3NNhNu67s,7557
 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 +282,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.10.dist-info/entry_points.txt,sha256=h03sq76TdcHvXKcsre1Qm3lIni9dkWehu61xJqI-p8k,69
-kaggle_environments-1.23.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-1.23.10.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-kaggle_environments-1.23.10.dist-info/METADATA,sha256=ga_1pd5en1Ji1R7u0dT-2O3yW1Le4zqhFdBhKnzok2Q,917
-kaggle_environments-1.23.10.dist-info/RECORD,,
+kaggle_environments-1.23.12.dist-info/entry_points.txt,sha256=h03sq76TdcHvXKcsre1Qm3lIni9dkWehu61xJqI-p8k,69
+kaggle_environments-1.23.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kaggle_environments-1.23.12.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+kaggle_environments-1.23.12.dist-info/METADATA,sha256=DnCtDRHWmVXDwo27KBl8wgu7HV2U8iJEQqOeYb5ebko,917
+kaggle_environments-1.23.12.dist-info/RECORD,,