kaggle-environments 1.17.2__py2.py3-none-any.whl → 1.17.5__py2.py3-none-any.whl

kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker.js

@@ -0,0 +1,431 @@
+function renderer(options) {
+    // --- Existing Elements and Style Injection (Unchanged) ---
+    const elements = {
+        pokerTableContainer: null,
+        pokerTable: null,
+        communityCardsContainer: null,
+        potDisplay: null,
+        playerPods: [],
+        dealerButton: null,
+        diagnosticHeader: null,
+        gameMessageArea: null,
+    };
+
+    function _injectStyles(passedOptions) {
+        if (typeof document === 'undefined' || window.__poker_styles_injected) {
+            return;
+        }
+        const style = document.createElement('style');
+        style.textContent = `
+        .poker-renderer-host {
+            width: 100%; height: 100%; display: flex; align-items: center; justify-content: center;
+            font-family: 'Inter', sans-serif; background-color: #2d3748; color: #fff;
+            overflow: hidden; padding: 1rem; box-sizing: border-box;
+        }
+        .poker-table-container { width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; }
+        .poker-table {
+            width: clamp(400px, 85vw, 850px); height: clamp(220px, 48vw, 450px);
+            background-color: #006400; border-radius: 225px; position: relative;
+            border: 12px solid #5c3a21; box-shadow: 0 0 25px rgba(0,0,0,0.6);
+            display: flex; align-items: center; justify-content: center;
+        }
+        .player-pod {
+            background-color: rgba(0, 0, 0, 0.75); border: 1px solid #4a5568; border-radius: 0.75rem;
+            padding: 0.6rem 0.8rem; color: white; text-align: center; position: absolute;
+            min-width: 120px; max-width: 160px; box-shadow: 0 3px 12px rgba(0,0,0,0.35);
+            transform: translateX(-50%); display: flex; flex-direction: column; justify-content: space-between;
+            min-height: 130px;
+        }
+        .player-name { font-weight: 600; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 100%; margin-bottom: 0.25rem; font-size: 0.9rem;}
+        .player-stack { font-size: 0.8rem; color: #facc15; margin-bottom: 0.25rem; }
+        .player-cards-container { margin: 0.25rem 0; min-height: 70px; display: flex; justify-content: center; align-items:center;}
+        .player-status { font-size: 0.75rem; color: #9ca3af; min-height: 1.1em; margin-top: 0.25rem; }
+        .card {
+            display: inline-flex; flex-direction: column; justify-content: center; align-items: center;
+            width: 48px; height: 68px; border: 1px solid #999; border-radius: 0.375rem; margin: 0 3px;
+            background-color: white; color: black; font-weight: bold; text-align: center; overflow: hidden; position: relative;
+        }
+        .card-rank { font-size: 1.8rem; line-height: 1; display: block; margin-top: 2px; }
+        .card-suit { font-size: 1.5rem; line-height: 1; display: block; }
+        .card-red .card-suit { color: #c0392b; } .card-black .card-suit { color: #1a202c; }
+        .card-back {
+            background-color: #2b6cb0;
+            background-image: linear-gradient(45deg, rgba(255,255,255,0.1) 25%, transparent 25%, transparent 75%, rgba(255,255,255,0.1) 75%, rgba(255,255,255,0.1)),
+                                linear-gradient(-45deg, rgba(255,255,255,0.1) 25%, transparent 25%, transparent 75%, rgba(255,255,255,0.1) 75%, rgba(255,255,255,0.1));
+            background-size: 10px 10px; border: 2px solid #63b3ed;
+        }
+        .card-back .card-rank, .card-back .card-suit { display: none; }
+        .community-cards-area { text-align: center; z-index: 10; position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); }
+        .community-cards-container { min-height: 75px; display: flex; justify-content: center; align-items:center; margin-bottom: 0.5rem; }
+        .community-cards-container .card { width: 52px; height: 72px; }
+        .community-cards-container .card-rank { font-size: 2rem; } .community-cards-container .card-suit { font-size: 1.7rem; }
+        .pot-display { font-size: 1.1rem; font-weight: bold; color: #facc15; }
+        .bet-display {
+            display: inline-block; min-width: 55px; padding: 4px 8px; border-radius: 12px;
+            background-color: #1a202c; color: #f1c40f; font-size: 0.8rem; line-height: 1.4;
+            text-align: center; margin-top: 4px; border: 1.5px solid #f1c40f; box-shadow: 0 1px 3px rgba(0,0,0,0.2);
+        }
+        .blind-indicator { font-size: 0.7rem; color: #a0aec0; margin-top: 3px; }
+        .dealer-button {
+            width: 36px; height: 36px; background-color: #f0f0f0; color: #333; border-radius: 50%;
+            text-align: center; line-height: 36px; font-weight: bold; font-size: 1rem; position: absolute;
+            border: 2px solid #888; box-shadow: 0 1px 3px rgba(0,0,0,0.3); z-index: 5;
+        }
+        .pos-player0-sb { bottom: -55px; left: 50%; }
+        .pos-player1-bb { top: -55px; left: 50%; }
+        .dealer-sb { bottom: -15px; left: calc(50% + 95px); transform: translateX(-50%); }
+        .current-player-turn-highlight { border: 2px solid #f1c40f !important; box-shadow: 0 0 15px #f1c40f, 0 3px 12px rgba(0,0,0,0.35) !important; }
+        #game-message-area { position: absolute; top: 10px; left: 50%; transform: translateX(-50%); background-color: rgba(0,0,0,0.6); padding: 5px 10px; border-radius: 5px; font-size: 0.9rem; z-index: 20;}
+
+        @media (max-width: 768px) {
+            .poker-table { width: clamp(350px, 90vw, 700px); height: clamp(180px, 48vw, 350px); border-radius: 175px; }
+            .pos-player0-sb { bottom: -50px; } .pos-player1-bb { top: -50px; }
+            .dealer-sb { left: calc(50% + 85px); bottom: -12px; }
+            .player-pod { min-width: 110px; max-width: 150px; padding: 0.5rem 0.7rem; min-height: 120px; }
+            .card { width: 44px; height: 62px; } .card-rank { font-size: 1.6rem; } .card-suit { font-size: 1.3rem; }
+            .community-cards-container .card { width: 48px; height: 68px; }
+            .community-cards-container .card-rank { font-size: 1.8rem;} .community-cards-container .card-suit { font-size: 1.5rem;}
+        }
+        @media (max-width: 600px) {
+            .poker-table { width: clamp(300px, 90vw, 500px); height: clamp(160px, 50vw, 250px); border-radius: 125px; }
+            .player-pod { min-width: 100px; max-width: 140px; padding: 0.4rem 0.5rem; font-size: 0.85rem; min-height: 110px;}
+            .player-name { font-size: 0.85rem;} .player-stack { font-size: 0.75rem; }
+            .card { width: 40px; height: 58px; margin: 0 2px; } .card-rank { font-size: 1.4rem; } .card-suit { font-size: 1.2rem; }
+            .community-cards-container .card { width: 42px; height: 60px; }
+            .community-cards-container .card-rank { font-size: 1.5rem;} .community-cards-container .card-suit { font-size: 1.3rem;}
+            .bet-display { font-size: 0.75rem; } .pos-player0-sb { bottom: -45px; } .pos-player1-bb { top: -45px; }
+            .dealer-button { width: 32px; height: 32px; line-height: 32px; font-size: 0.9rem;}
+            .dealer-sb { bottom: -8px; left: calc(50% + 75px); }
+        }
+        @media (max-width: 400px) {
+            .poker-table { width: clamp(280px, 95vw, 380px); height: clamp(150px, 55vw, 200px); border-radius: 100px; border-width: 8px; }
+            .player-pod { min-width: 90px; max-width: 120px; padding: 0.3rem 0.4rem; min-height: 100px;}
+            .player-name { font-size: 0.8rem;} .player-stack { font-size: 0.7rem; }
+            .card { width: 36px; height: 52px; margin: 0 1px; } .card-rank { font-size: 1.2rem; } .card-suit { font-size: 1rem; }
+            .community-cards-container .card { width: 38px; height: 55px; }
+            .community-cards-container .card-rank { font-size: 1.3rem;} .community-cards-container .card-suit { font-size: 1.1rem;}
+            .dealer-button { width: 28px; height: 28px; line-height: 28px; font-size: 0.8rem;}
+            .pos-player0-sb { bottom: -40px; } .pos-player1-bb { top: -40px; }
+            .dealer-sb { bottom: -5px; left: calc(50% + 65px); }
+        }
+        `;
+        const parentForStyles = passedOptions && passedOptions.parent ? passedOptions.parent.ownerDocument.head : document.head;
+        if (parentForStyles && !parentForStyles.querySelector('style[data-poker-renderer-styles]')) {
+            style.setAttribute('data-poker-renderer-styles', 'true');
+            parentForStyles.appendChild(style);
+        }
+        window.__poker_styles_injected = true;
+    }
+
+    function acpcCardToDisplay(acpcCard) {
+        if (!acpcCard || acpcCard.length < 2) return { rank: '?', suitSymbol: '', original: acpcCard };
+        const rankChar = acpcCard[0].toUpperCase();
+        const suitChar = acpcCard[1].toLowerCase();
+        const rankMap = { 'T': '10', 'J': 'J', 'Q': 'Q', 'K': 'K', 'A': 'A' };
+        const suitMap = { 's': '♠', 'h': '♥', 'd': '♦', 'c': '♣' };
+        const rank = rankMap[rankChar] || rankChar;
+        const suitSymbol = suitMap[suitChar] || '';
+        return { rank, suitSymbol, original: acpcCard };
+    }
+
+    function createCardElement(cardStr, isHidden = false) {
+        const cardDiv = document.createElement('div');
+        cardDiv.classList.add('card');
+        if (isHidden || !cardStr || cardStr === '?' || cardStr === "??") {
+            cardDiv.classList.add('card-back');
+        } else {
+            const { rank, suitSymbol } = acpcCardToDisplay(cardStr);
+            const rankSpan = document.createElement('span');
+            rankSpan.classList.add('card-rank');
+            rankSpan.textContent = rank;
+            cardDiv.appendChild(rankSpan);
+            const suitSpan = document.createElement('span');
+            suitSpan.classList.add('card-suit');
+            suitSpan.textContent = suitSymbol;
+            cardDiv.appendChild(suitSpan);
+            if (suitSymbol === '♥' || suitSymbol === '♦') cardDiv.classList.add('card-red');
+            else if (suitSymbol === '♠' || suitSymbol === '♣') cardDiv.classList.add('card-black');
+        }
+        return cardDiv;
+    }
+
+    function _ensurePokerTableElements(parentElement, passedOptions) {
+        if (!parentElement) return false;
+        parentElement.innerHTML = '';
+        parentElement.classList.add('poker-renderer-host');
+
+        elements.diagnosticHeader = document.createElement('h1');
+        elements.diagnosticHeader.id = 'poker-renderer-diagnostic-header';
+        elements.diagnosticHeader.textContent = "Poker Table Initialized (Live Data)";
+        elements.diagnosticHeader.style.cssText = "color: lime; background-color: black; padding: 5px; font-size: 12px; position: absolute; top: 0px; left: 0px; z-index: 10001; display: none;"; // Hidden by default
+        parentElement.appendChild(elements.diagnosticHeader);
+
+        elements.gameMessageArea = document.createElement('div');
+        elements.gameMessageArea.id = 'game-message-area';
+        parentElement.appendChild(elements.gameMessageArea);
+
+        elements.pokerTableContainer = document.createElement('div');
+        elements.pokerTableContainer.className = 'poker-table-container';
+        parentElement.appendChild(elements.pokerTableContainer);
+
+        elements.pokerTable = document.createElement('div');
+        elements.pokerTable.className = 'poker-table';
+        elements.pokerTableContainer.appendChild(elements.pokerTable);
+
+        const communityArea = document.createElement('div');
+        communityArea.className = 'community-cards-area';
+        elements.pokerTable.appendChild(communityArea);
+
+        elements.communityCardsContainer = document.createElement('div');
+        elements.communityCardsContainer.className = 'community-cards-container';
+        communityArea.appendChild(elements.communityCardsContainer);
+
+        elements.potDisplay = document.createElement('div');
+        elements.potDisplay.className = 'pot-display';
+        communityArea.appendChild(elements.potDisplay);
+
+        elements.playerPods = [];
+        for (let i = 0; i < 2; i++) {
+            const playerPod = document.createElement('div');
+            playerPod.className = `player-pod ${i === 0 ? 'pos-player0-sb' : 'pos-player1-bb'}`;
+            playerPod.innerHTML = `
+                <div class="player-name">Player ${i}</div>
+                <div class="player-stack">$0.00</div>
+                <div class="player-cards-container"></div>
+                <div class="bet-display" style="display:none;">$0.00</div>
+                <div class="player-status">(${i === 0 ? 'SB' : 'BB'})</div>
+            `;
+            elements.pokerTable.appendChild(playerPod);
+            elements.playerPods.push(playerPod);
+        }
+
+        elements.dealerButton = document.createElement('div');
+        elements.dealerButton.className = 'dealer-button dealer-sb';
+        elements.dealerButton.textContent = 'D';
+        elements.dealerButton.style.display = 'none';
+        elements.pokerTable.appendChild(elements.dealerButton);
+        return true;
+    }
+
+
+    // --- REVISED PARSING LOGIC ---
+    function _parseKagglePokerState(options) {
+        const { environment, step } = options;
+        const numPlayers = 2; // Assuming 2 players based on logs
+
+        // --- Default State ---
+        const defaultUIData = {
+            players: Array(numPlayers).fill(null).map((_, i) => ({
+                id: `player${i}`,
+                name: `Player ${i}`,
+                stack: 0,
+                cards: [], // Will be filled with nulls or cards
+                currentBet: 0,
+                position: i === 0 ? "SB" : "BB",
+                isDealer: i === 0,
+                isTurn: false,
+                status: "Waiting...",
+                reward: null
+            })),
+            communityCards: [],
+            pot: 0,
+            isTerminal: false,
+            gameMessage: "Initializing...",
+            rawObservation: null, // For debugging
+        };
+
+        // --- Step Validation ---
+        if (!environment || !environment.steps || !environment.steps[step]) {
+            return defaultUIData;
+        }
+        const currentStepAgents = environment.steps[step];
+        if (!currentStepAgents || currentStepAgents.length < numPlayers) {
+            defaultUIData.gameMessage = "Waiting for agent data...";
+            return defaultUIData;
+        }
+
+        // --- Observation Extraction & Merging ---
+        let obsP0 = null, obsP1 = null;
+        try {
+            obsP0 = JSON.parse(currentStepAgents[0].observation.observation_string);
+            obsP1 = JSON.parse(currentStepAgents[1].observation.observation_string);
+        } catch (e) {
+            defaultUIData.gameMessage = "Error parsing observation JSON.";
+            return defaultUIData;
+        }
+
+        if (!obsP0) {
+            defaultUIData.gameMessage = "Waiting for valid game state...";
+            return defaultUIData;
+        }
+
+        // --- Combine observations into a single, reliable state object ---
+        const combinedState = { ...obsP0 }; // Start with Player 0's data
+        // Player hands are split across observations. We need to merge them.
+        combinedState.player_hands = [
+             // Take the real hand from P0's obs
+            obsP0.player_hands[0].length > 0 ? obsP0.player_hands[0] : [],
+            // Take the real hand from P1's obs
+            obsP1.player_hands[1].length > 0 ? obsP1.player_hands[1] : []
+        ];
+
+        defaultUIData.rawObservation = combinedState;
+
+        // --- Populate UI Data from Combined State ---
+        const {
+            pot_size,
+            player_contributions,
+            starting_stacks,
+            player_hands,
+            board_cards,
+            current_player,
+            betting_history,
+        } = combinedState;
+
+        const isTerminal = current_player === "terminal";
+        defaultUIData.isTerminal = isTerminal;
+        defaultUIData.pot = pot_size || 0;
+        defaultUIData.communityCards = board_cards || [];
+
+
+        // --- Update Player Pods ---
+        for (let i = 0; i < numPlayers; i++) {
+            const pData = defaultUIData.players[i];
+            const contribution = player_contributions ? player_contributions[i] : 0;
+            const startStack = starting_stacks ? starting_stacks[i] : 0;
+
+            pData.currentBet = contribution;
+            pData.stack = startStack - contribution;
+            pData.cards = (player_hands[i] || []).map(c => c === "??" ? null : c);
+            pData.isTurn = String(i) === String(current_player);
+            pData.status = pData.position; // Default status
+
+            if (isTerminal) {
+                 const reward = environment.rewards ? environment.rewards[i] : null;
+                 pData.reward = reward;
+                 if (reward > 0) pData.status = "Winner!";
+                 else if (reward < 0) pData.status = "Loser";
+                 else pData.status = "Game Over";
+            } else if (pData.isTurn) {
+                pData.status = "Thinking...";
+            } else if (pData.stack === 0 && pData.currentBet > 0) {
+                pData.status = "All-in";
+            }
+        }
+        
+        // Handle folded player status
+        if (!isTerminal && betting_history && betting_history.includes('f')) {
+            // A simple fold check: the player who didn't make the last action and isn't the current player might have folded.
+            // This is a simplification. A more robust parser would track the betting sequence.
+            const lastAction = betting_history.slice(-1);
+            if (lastAction === 'f') {
+                // Find who is NOT the current player
+                const nonCurrentPlayerIndex = current_player === '0' ? 1 : 0;
+                // If they are not all-in, they folded.
+                if (defaultUIData.players[nonCurrentPlayerIndex].status !== 'All-in') {
+                    defaultUIData.players[nonCurrentPlayerIndex].status = "Folded";
+                }
+            }
+        }
+
+
+        // --- Set Game Message ---
+        if (isTerminal) {
+            const winnerIndex = environment.rewards ? environment.rewards.findIndex(r => r > 0) : -1;
+            if (winnerIndex !== -1) {
+                defaultUIData.gameMessage = `Player ${winnerIndex} wins!`;
+            } else {
+                 defaultUIData.gameMessage = "Game Over.";
+            }
+        } else if (current_player === "chance") {
+             defaultUIData.gameMessage = `Dealing...`;
+        } else {
+            defaultUIData.gameMessage = `Player ${current_player}'s turn.`;
+        }
+
+        return defaultUIData;
+    }
+
+
+    // --- RENDERER UI LOGIC (Unchanged) ---
+    function _renderPokerTableUI(data, passedOptions) {
+        if (!elements.pokerTable || !data) return;
+        const { players, communityCards, pot, isTerminal, gameMessage } = data;
+
+        if (elements.diagnosticHeader && data.rawObservation) {
+            // Optional: Show diagnostics for debugging
+            // elements.diagnosticHeader.textContent = `[${passedOptions.step}] P_TURN:${data.rawObservation.current_player} POT:${data.pot}`;
+            // elements.diagnosticHeader.style.display = 'block';
+        }
+        if (elements.gameMessageArea) {
+            elements.gameMessageArea.textContent = gameMessage;
+        }
+
+        elements.communityCardsContainer.innerHTML = '';
+        if (communityCards && communityCards.length > 0) {
+            communityCards.forEach(cardStr => {
+                elements.communityCardsContainer.appendChild(createCardElement(cardStr));
+            });
+        }
+
+        elements.potDisplay.textContent = `Pot: $${pot}`;
+
+        players.forEach((playerData, index) => {
+            const playerPod = elements.playerPods[index];
+            if (!playerPod) return;
+
+            playerPod.querySelector('.player-name').textContent = playerData.name;
+            playerPod.querySelector('.player-stack').textContent = `$${playerData.stack}`;
+
+            const playerCardsContainer = playerPod.querySelector('.player-cards-container');
+            playerCardsContainer.innerHTML = '';
+
+            // In heads-up, we show both hands at the end.
+            const showCards = isTerminal || (playerData.cards && !playerData.cards.includes(null));
+
+            (playerData.cards || [null, null]).forEach(cardStr => {
+                playerCardsContainer.appendChild(createCardElement(cardStr, !showCards && cardStr !== null));
+            });
+
+            const betDisplay = playerPod.querySelector('.bet-display');
+            if (playerData.currentBet > 0) {
+                betDisplay.textContent = `$${playerData.currentBet}`;
+                betDisplay.style.display = 'inline-block';
+            } else {
+                betDisplay.style.display = 'none';
+            }
+
+            playerPod.querySelector('.player-status').textContent = playerData.status;
+
+            if (playerData.isTurn && !isTerminal) {
+                playerPod.classList.add('current-player-turn-highlight');
+            } else {
+                playerPod.classList.remove('current-player-turn-highlight');
+            }
+        });
+
+        const dealerPlayer = players.find(p => p.isDealer);
+        if (elements.dealerButton) {
+            elements.dealerButton.style.display = dealerPlayer ? 'block' : 'none';
+        }
+    }
+
+    // --- MAIN EXECUTION LOGIC ---
+    const { parent } = options;
+    if (!parent) {
+        console.error("Renderer: Parent element not provided.");
+        return;
+    }
+
+    _injectStyles(options);
+
+    if (!_ensurePokerTableElements(parent, options)) {
+        console.error("Renderer: Failed to ensure poker table elements.");
+        parent.innerHTML = '<p style="color:red;">Error: Could not create poker table structure.</p>';
+        return;
+    }
+
+    // Use the revised parsing logic
+    const uiData = _parseKagglePokerState(options);
+    _renderPokerTableUI(uiData, options);
+}

kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker_proxy.py

@@ -0,0 +1,159 @@
+"""Change Universal Poker state and action string representations."""
+
+import json
+import re
+from typing import Any
+
+from ... import proxy
+import pyspiel
+
+
+class UniversalPokerState(proxy.State):
+  """Universal Poker state proxy."""
+
+  def _player_string(self, player: int) -> str:
+    if player == pyspiel.PlayerId.CHANCE:
+      return "chance"
+    elif player == pyspiel.PlayerId.TERMINAL:
+      return "terminal"
+    if player < 0:
+      return pyspiel.PlayerId(player).name.lower()
+    else:
+      return str(player)
+
+  def _state_dict(self) -> dict[str, Any]:
+    params = self.get_game().get_parameters()
+    blinds = params["blind"].strip().split()
+    blinds = [int(blind) for blind in blinds]
+    assert len(blinds) == self.num_players()
+    starting_stacks = params["stack"].strip().split()
+    starting_stacks = [int(stack) for stack in starting_stacks]
+    assert len(starting_stacks) == self.num_players()
+    state_str = self.to_string()
+    state_lines = state_str.split("\n")
+    player_hands = []
+    for i in range(self.num_players()):
+      for line in state_lines:
+        if line.startswith(f"P{i} Cards:"):
+          hand = line.split(":")[1].strip()
+          player_hands.append([hand[i:i+2] for i in range(0, len(hand), 2)])
+    assert len(player_hands) == self.num_players()
+    board_cards = None
+    for line in state_lines:
+      if line.startswith("BoardCards"):
+        board_cards_str = line.removeprefix("BoardCards").strip()
+        board_cards = [
+            board_cards_str[i:i+2] for i in range(0, len(board_cards_str), 2)
+        ]
+    assert board_cards is not None
+    pattern = r"P\d+:\s*(\d+)"
+    player_contributions = []
+    for line in state_lines:
+      if line.startswith("Spent:"):
+        matches = re.findall(pattern, line)
+        player_contributions = [int(match) for match in matches]
+    assert len(player_contributions) == self.num_players()
+    acpc_state = None
+    betting_history = None
+    for line in state_lines:
+      if line.startswith("ACPC State:"):
+        acpc_state = line.split("ACPC State:")[1].strip()
+        betting_history = acpc_state.split(":")[2]
+    assert acpc_state is not None
+    assert betting_history is not None
+
+    state_dict = {}
+    state_dict["acpc_state"] = acpc_state
+    state_dict["current_player"] = self._player_string(self.current_player())
+    state_dict["blinds"] = blinds
+    state_dict["betting_history"] = betting_history
+    state_dict["player_contributions"] = player_contributions
+    state_dict["pot_size"] = sum(player_contributions)
+    state_dict["starting_stacks"] = starting_stacks
+    state_dict["player_hands"] = player_hands
+    state_dict["board_cards"] = board_cards
+    return state_dict
+
+  def to_json(self) -> str:
+    return json.dumps(self._state_dict())
+
+  def _action_to_string(self, player: int, action: int) -> str:
+    if player == pyspiel.PlayerId.CHANCE:
+      return f"deal {action}"  # TODO(jhtschultz): Add card.
+    if action == 0:
+      return "fold"
+    elif action == 1:
+      if 0 in self.legal_actions():
+        return "call"
+      else:
+        return "check"
+    else:
+      return f"raise{action}"
+
+  def action_to_json(self, action: int) -> str:
+    action_str = self._action_to_string(self.current_player(), action)
+    return json.dumps({"action": action_str})
+
+  def observation_dict(self, player: int) -> dict[str, Any]:
+    state_dict = self._state_dict()
+    for i in range(self.num_players()):
+      if i == player:
+        continue
+      state_dict["player_hands"][i] = ["??", "??"]
+    del state_dict["acpc_state"]
+    return state_dict
+
+  def observation_json(self, player: int) -> str:
+    return json.dumps(self.observation_dict(player))
+
+  def observation_string(self, player: int) -> str:
+    return self.observation_json(player)
+
+  def __str__(self):
+    return self.to_json()
+
+
+def _strip_empty_kwargs(input_string):
+  try:
+    open_paren_index = input_string.index('(')
+    close_paren_index = input_string.rindex(')')
+  except ValueError:
+    return input_string
+
+  function_name = input_string[:open_paren_index]
+  args_string = input_string[open_paren_index + 1:close_paren_index]
+  args_list = args_string.split(',')
+  non_empty_args = []
+  for arg in args_list:
+    parts = arg.split('=', 1)
+    if len(parts) > 1 and parts[1]:
+      non_empty_args.append(arg)
+    elif len(parts) == 1 and parts[0]:
+       non_empty_args.append(arg)
+  new_args_string = ','.join(non_empty_args)
+  return f"{function_name}({new_args_string})"
+
+
+class UniversalPokerGame(proxy.Game):
+  """Universal Poker game proxy."""
+
+  def __init__(self, params: Any | None = None):
+    params = params or {}
+    wrapped = pyspiel.load_game("universal_poker", params)
+    super().__init__(
+        wrapped,
+        short_name="universal_poker_proxy",
+        long_name="Universal Poker (proxy)",
+    )
+
+  def __str__(self):
+    s = _strip_empty_kwargs(self.__wrapped__.__str__())
+    return s.split("(")[0] + "_proxy(" + s.split("(")[1]
+
+  def new_initial_state(self, *args) -> UniversalPokerState:
+    return UniversalPokerState(
+        self.__wrapped__.new_initial_state(*args),
+        game=self,
+    )
+
+pyspiel.register_game(UniversalPokerGame().get_type(), UniversalPokerGame)

kaggle_environments/envs/open_spiel/games/universal_poker/universal_poker_proxy_test.py

@@ -0,0 +1,49 @@
+"""Test for proxied Universal Poker game."""
+
+import json
+import random
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import pyspiel
+from . import universal_poker_proxy as universal_poker
+
+
+class UniversalPokerTest(parameterized.TestCase):
+
+  def test_game_is_registered(self):
+    game = pyspiel.load_game('universal_poker_proxy')
+    self.assertIsInstance(game, universal_poker.UniversalPokerGame)
+
+  def test_game_parameters(self):
+    game = pyspiel.load_game("universal_poker_proxy(betting=nolimit,numPlayers=2,stack=20000 20000,numRounds=4,blind=50 100,firstPlayer=2 1 1 1,numSuits=4,numRanks=13,numHoleCards=2,numBoardCards=0 3 1 1,bettingAbstraction=fullgame)")
+    game_params = game.get_parameters()
+    self.assertEqual(
+        game_params,
+        {
+            'betting': 'nolimit',
+            'bettingAbstraction': 'fullgame',
+            'blind': '50 100',
+            'boardCards': '',
+            'firstPlayer': '2 1 1 1',
+            'handReaches': '',
+            'maxRaises': '',
+            'numBoardCards': '0 3 1 1',
+            'numHoleCards': 2,
+            'numPlayers': 2,
+            'numRanks': 13,
+            'numRounds': 4,
+            'numSuits': 4,
+            'potSize': 0,
+            'raiseSize': '100 100',
+            'stack': '20000 20000',
+        }
+    )
+
+  def test_random_sim(self):
+    game = universal_poker.UniversalPokerGame()
+    pyspiel.random_sim_test(game, num_sims=10, serialize=False, verbose=False)
+
+
+if __name__ == '__main__':
+  absltest.main()

kaggle_environments/envs/open_spiel/html_playthrough_generator.py

@@ -0,0 +1,30 @@
+import os
+import random
+from kaggle_environments import make
+import pyspiel
+
+open_spiel_game_name = "connect_four"
+game = pyspiel.load_game(open_spiel_game_name)
+game_type = game.get_type()
+environment_name = f"open_spiel_{game_type.short_name}"
+agents_to_run = ["random"] * game.num_players()
+replay_width = 500
+replay_height = 450
+debug_mode = True
+env = make(environment_name, debug=debug_mode)
+
+print(f"Running game with agents: {agents_to_run}...")
+env.run(agents_to_run)
+print("Game finished.")
+
+print("Generating HTML replay...")
+html_replay = env.render(mode="html", width=replay_width, height=replay_height)
+
+output_html_file = f"kaggle_environments/envs/open_spiel/{environment_name}_game_replay.html"
+print(f"Saving replay to: '{output_html_file}'")
+with open(output_html_file, "w", encoding="utf-8") as f:
+  f.write(html_replay)
+
+print("-" * 20)
+print(f"Successfully generated replay: {os.path.abspath(output_html_file)}")
+print("-" * 20)