kaggle-environments 1.23.10__tar.gz → 1.23.12__tar.gz

kaggle_environments-1.23.12/.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.10 → kaggle_environments-1.23.12}/PKG-INFO

@@ -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.12/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-1.23.12/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-1.23.12/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);
+});