parser_example.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "40aa55bd-7514-4c6b-b9ca-a480becb28f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "import re\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "74162dc6-3236-43c2-a1da-cbdd286a6519",
   "metadata": {},
   "outputs": [],
   "source": [
    "hands = \"\"\"STATE:0:r241f:8h4c|6c5h:-100|100:act1_2pn_2016|hugh_2pn_2016\n",
    "STATE:1:r223f:6h9c|Jc8h:-100|100:hugh_2pn_2016|act1_2pn_2016\n",
    "STATE:2:r241r675c/cr1629c/cc/r2606c:QcAc|TsAs/JsTh7d/Qh/Td:-2606|2606:act1_2pn_2016|hugh_2pn_2016\n",
    "STATE:3:cc/r241c/r581f:2dQh|6d3s/Jc4h2c/Tc:241|-241:hugh_2pn_2016|act1_2pn_2016\n",
    "STATE:4:r241r809c/cr1953c/cr4714f:8cTc|9sAd/3cAc3s/Js:-1953|1953:act1_2pn_2016|hugh_2pn_2016\n",
    "STATE:5:r273f:9d4c|JdTd:-100|100:hugh_2pn_2016|act1_2pn_2016\n",
    "STATE:6:r241r675c/cr1629c/cc/cc:9c9s|7s7d/AcAhKh/5c/Qc:1629|-1629:act1_2pn_2016|hugh_2pn_2016\n",
    "STATE:7:r273f:4d3d|KdQh:-100|100:hugh_2pn_2016|act1_2pn_2016\n",
    "STATE:8:r241f:7c5s|6h6s:-100|100:act1_2pn_2016|hugh_2pn_2016\"\"\"\n",
    "\n",
    "proposed_regex = \"STATE:\\d:(\\w*\\/?\\w*\\/?\\w*\\/?\\w*):(\\w{4})\\|(\\w{4})(\\/?\\w*\\/?\\w*\\/?\\w*)?:(-?\\d*)\\|(-?\\d*):([^|]*)\\|(.*)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f0233bad",
   "metadata": {},
   "outputs": [],
   "source": [
    "m = re.findall(proposed_regex, \"lol\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f8537b34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f7f6c180",
   "metadata": {},
   "outputs": [],
   "source": [
    "regex_example = map(lambda hand: re.findall(proposed_regex, hand), hands.split(\"\\n\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b08f2b04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x7fc9286d58d0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reminder that \"map\" is lazily evaluated\n",
    "regex_example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "60ec7281",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[('r241f',\n",
       "   '8h4c',\n",
       "   '6c5h',\n",
       "   '',\n",
       "   '-100',\n",
       "   '100',\n",
       "   'act1_2pn_2016',\n",
       "   'hugh_2pn_2016')],\n",
       " [('r223f',\n",
       "   '6h9c',\n",
       "   'Jc8h',\n",
       "   '',\n",
       "   '-100',\n",
       "   '100',\n",
       "   'hugh_2pn_2016',\n",
       "   'act1_2pn_2016')],\n",
       " [('r241r675c/cr1629c/cc/r2606c',\n",
       "   'QcAc',\n",
       "   'TsAs',\n",
       "   '/JsTh7d/Qh/Td',\n",
       "   '-2606',\n",
       "   '2606',\n",
       "   'act1_2pn_2016',\n",
       "   'hugh_2pn_2016')],\n",
       " [('cc/r241c/r581f',\n",
       "   '2dQh',\n",
       "   '6d3s',\n",
       "   '/Jc4h2c/Tc',\n",
       "   '241',\n",
       "   '-241',\n",
       "   'hugh_2pn_2016',\n",
       "   'act1_2pn_2016')],\n",
       " [('r241r809c/cr1953c/cr4714f',\n",
       "   '8cTc',\n",
       "   '9sAd',\n",
       "   '/3cAc3s/Js',\n",
       "   '-1953',\n",
       "   '1953',\n",
       "   'act1_2pn_2016',\n",
       "   'hugh_2pn_2016')],\n",
       " [('r273f',\n",
       "   '9d4c',\n",
       "   'JdTd',\n",
       "   '',\n",
       "   '-100',\n",
       "   '100',\n",
       "   'hugh_2pn_2016',\n",
       "   'act1_2pn_2016')],\n",
       " [('r241r675c/cr1629c/cc/cc',\n",
       "   '9c9s',\n",
       "   '7s7d',\n",
       "   '/AcAhKh/5c/Qc',\n",
       "   '1629',\n",
       "   '-1629',\n",
       "   'act1_2pn_2016',\n",
       "   'hugh_2pn_2016')],\n",
       " [('r273f',\n",
       "   '4d3d',\n",
       "   'KdQh',\n",
       "   '',\n",
       "   '-100',\n",
       "   '100',\n",
       "   'hugh_2pn_2016',\n",
       "   'act1_2pn_2016')],\n",
       " [('r241f',\n",
       "   '7c5s',\n",
       "   '6h6s',\n",
       "   '',\n",
       "   '-100',\n",
       "   '100',\n",
       "   'act1_2pn_2016',\n",
       "   'hugh_2pn_2016')]]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list() is eagerly evaluated\n",
    "list(regex_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c03d7e3d-7e21-4690-a1ff-a1259e79cb1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "matches = map(lambda hand: re.findall(proposed_regex, hand), hands.split(\"\\n\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9f2827d9-5e28-443a-8d7a-d3e6e188b419",
   "metadata": {},
   "outputs": [],
   "source": [
    "CALL = \"CALL\"\n",
    "CHECK = \"CHECK\"\n",
    "FOLD = \"FOLD\"\n",
    "RAISE = \"RAISE\"\n",
    "\n",
    "action_mappings = {\"c\": [\"CHECK\", \"CALL\"], \"f\": \"FOLD\", \"r\": \"RAISE\"}\n",
    "\n",
    "def parse_player_actions(actions, player_a, player_b):\n",
    "    by_round = actions.split(\"/\")\n",
    "\n",
    "    # r241r675c\n",
    "    # r, 2, 4, 1, r, 6, 7, 5, c\n",
    "    def reducer(agg, element):\n",
    "        prev_token, player_a_actions, player_b_actions, chips, current_player = agg\n",
    "        if len(prev_token) == 0:\n",
    "            action = action_mappings[element]\n",
    "            if isinstance(action, list):\n",
    "                return (CHECK, [(CHECK, 0)] + player_a_actions, player_b_actions, chips, player_b)\n",
    "            if action == FOLD:\n",
    "                raise Exception(\"A bot should never open fold!\")\n",
    "            # We need to build up the chips in the raise action over multiple iterations\n",
    "            return (RAISE, player_a_actions, player_b_actions, chips, player_a) # R<chipamount>; R123 => R, 1, 2, 3, \n",
    "\n",
    "        # We have a chip amount instead of an action. ie: still collecting the total raise/call size\n",
    "        if element not in action_mappings.keys():\n",
    "            return (prev_token, player_a_actions, player_b_actions, chips + element, current_player)\n",
    "\n",
    "        # We have a new action for a new player\n",
    "        action = action_mappings[element]\n",
    "\n",
    "        if prev_token == CHECK:\n",
    "            if isinstance(action, list):\n",
    "                # Can only go check-check when player a+b each take 1 action\n",
    "                return (CHECK, player_a_actions, [(CHECK, 0)] + player_b_actions, chips, player_a)\n",
    "            if action == FOLD:\n",
    "                raise Exception(\"A bot should never fold when checked to!\")\n",
    "            return (RAISE, player_a_actions, player_b_actions, chips, current_player)\n",
    "\n",
    "        #Iter 5:(RAISE, [], [], \"241\", player_a) - cur: r\n",
    "        if prev_token == RAISE:\n",
    "            # Previously collected chips need to be converted into a proper player action now\n",
    "            num_chips = int(chips)\n",
    "            full_chip_based_action = [(prev_token, num_chips)]\n",
    "            new_chip_tracker = \"\"\n",
    "\n",
    "            # Can only call after raise\n",
    "            if isinstance(action, list):\n",
    "                # Note: Same player stays current_player because we are recording two actions\n",
    "                # 1: The accumlated raise, 2: The response\n",
    "                if current_player == player_a:\n",
    "                    return (CALL, full_chip_based_action + player_a_actions, [(CALL, num_chips)] + player_b_actions, new_chip_tracker, player_a)\n",
    "                else:\n",
    "                    return (CALL, [(CALL, num_chips)] + player_a_actions, full_chip_based_action + player_b_actions, new_chip_tracker, player_b)\n",
    "\n",
    "            if action == FOLD:\n",
    "                full_action = [(action, 0)]\n",
    "                if current_player == player_a:\n",
    "                    return (action, full_chip_based_action + player_a_actions, full_action + player_b_actions, new_chip_tracker, player_a)\n",
    "                else:\n",
    "                    return (action, full_action + player_a_actions, full_chip_based_action + player_b_actions, new_chip_tracker, player_a)\n",
    "\n",
    "            #Iter 5:(RAISE, [], [], \"241\", player_a) - cur: r\n",
    "            if action == RAISE:\n",
    "                if current_player == player_a:\n",
    "                    return (action, full_chip_based_action + player_a_actions, player_b_actions, new_chip_tracker, player_b)\n",
    "                else:\n",
    "                    return (action, player_a_actions, full_chip_based_action + player_b_actions, new_chip_tracker, player_a)\n",
    "\n",
    "        # prev_token can't be equal to call because iteration would already have stopped\n",
    "        raise Exception(\"This code should be unreachable\")\n",
    "\n",
    "    rounds = [functools.reduce(reducer, round, [\"\", [], [], \"\", player_a]) for round in by_round]\n",
    "    # Todo: Reverse the action lists for each player\n",
    "    #   Note: Actually, order doesn't matter if we're just stamping in the matrix.\n",
    "    # Todo: Should also export who player A and B is as columns. They drop them before training\n",
    "    #   This allows us to potentially train player based models later with no need to refactor this code\n",
    "    return rounds\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "28e514f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[('FOLD', [('RAISE', 241)], [('FOLD', 0)], '', 'act1_2pn_2016')],\n",
       " [('FOLD', [('RAISE', 223)], [('FOLD', 0)], '', 'hugh_2pn_2016')],\n",
       " [('CALL',\n",
       "   [('CALL', 675), ('RAISE', 241)],\n",
       "   [('RAISE', 675)],\n",
       "   '',\n",
       "   'hugh_2pn_2016'),\n",
       "  ('CALL',\n",
       "   [('CALL', 1629), ('CHECK', 0)],\n",
       "   [('RAISE', 1629)],\n",
       "   '',\n",
       "   'hugh_2pn_2016'),\n",
       "  ('CHECK', [('CHECK', 0)], [('CHECK', 0)], '', 'act1_2pn_2016'),\n",
       "  ('CALL', [('RAISE', 2606)], [('CALL', 2606)], '', 'act1_2pn_2016')],\n",
       " [('CHECK', [('CHECK', 0)], [('CHECK', 0)], '', 'hugh_2pn_2016'),\n",
       "  ('CALL', [('RAISE', 241)], [('CALL', 241)], '', 'hugh_2pn_2016'),\n",
       "  ('FOLD', [('RAISE', 581)], [('FOLD', 0)], '', 'hugh_2pn_2016')],\n",
       " [('CALL',\n",
       "   [('CALL', 809), ('RAISE', 241)],\n",
       "   [('RAISE', 809)],\n",
       "   '',\n",
       "   'hugh_2pn_2016'),\n",
       "  ('CALL',\n",
       "   [('CALL', 1953), ('CHECK', 0)],\n",
       "   [('RAISE', 1953)],\n",
       "   '',\n",
       "   'hugh_2pn_2016'),\n",
       "  ('FOLD',\n",
       "   [('FOLD', 0), ('CHECK', 0)],\n",
       "   [('RAISE', 4714)],\n",
       "   '',\n",
       "   'act1_2pn_2016')],\n",
       " [('FOLD', [('RAISE', 273)], [('FOLD', 0)], '', 'hugh_2pn_2016')],\n",
       " [('CALL',\n",
       "   [('CALL', 675), ('RAISE', 241)],\n",
       "   [('RAISE', 675)],\n",
       "   '',\n",
       "   'hugh_2pn_2016'),\n",
       "  ('CALL',\n",
       "   [('CALL', 1629), ('CHECK', 0)],\n",
       "   [('RAISE', 1629)],\n",
       "   '',\n",
       "   'hugh_2pn_2016'),\n",
       "  ('CHECK', [('CHECK', 0)], [('CHECK', 0)], '', 'act1_2pn_2016'),\n",
       "  ('CHECK', [('CHECK', 0)], [('CHECK', 0)], '', 'act1_2pn_2016')],\n",
       " [('FOLD', [('RAISE', 273)], [('FOLD', 0)], '', 'hugh_2pn_2016')],\n",
       " [('FOLD', [('RAISE', 241)], [('FOLD', 0)], '', 'act1_2pn_2016')]]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matches = list(map(lambda hand: re.findall(proposed_regex, hand), hands.split(\"\\n\")))\n",
    "parsed = [parse_player_actions(row[0][0], row[0][-2], row[0][-1]) for row in matches]\n",
    "parsed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2cc6d20e",
   "metadata": {},
   "outputs": [],
   "source": [
    "rank_mappings = {'A': 0, 'K': 1, 'Q': 2, 'J': 3, 'T': 4, '9': 5, '8': 6, '7': 7, '6': 8, '5': 9, '4': 10, '3': 11, '2': 12}\n",
    "suit_mappings = {'c': 0, 'd': 1, 'h': 2, 's': 3}\n",
    "\n",
    "def vector_location(hand):\n",
    "    return np.array([suit_mappings[hand[1]], rank_mappings[hand[0]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "50dff27d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 0])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_location(\"As\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8d262554",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['JsTh7d', 'Qh', 'Td']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_cards = matches[2][0][3].split(\"/\")[1:]\n",
    "all_cards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8a3c6878",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Js', 'Th', '7d', 'Qh', 'Td']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joined = \"\".join(all_cards)\n",
    "[\n",
    "    joined[i: i + 2] for i in range(0, len(joined), 2)\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cbb224a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TODO ***\n",
    "def card_location_demo():\n",
    "    deck = np.zeros((4,13))\n",
    "    # Need handling for variable length streets. A simple / split doesn't work\n",
    "    card_locations = [vector_location(hand) for hand in matches[2][0][3].split('/')[1:] + [matches[2][0][1]]]\n",
    "    # Is there a faster vectorized way? Probably doesn't matter atm\n",
    "    for card_location in card_locations:\n",
    "        deck[card_location[0], card_location[1]] = 1\n",
    "    return deck\n",
    "\n",
    "card_location_demo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "92696d34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_hands = card_location_demo()\n",
    "b_hands = card_location_demo()\n",
    "\n",
    "np.vstack((a_hands, b_hands))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0c071b1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "action_to_int_mappings = {CHECK: 0, CALL: 1, RAISE: 2, FOLD: 3}\n",
    "full_action_to_int = lambda full_action: action_to_int_mappings[full_action[0]]\n",
    "\n",
    "def street_int_actions(full_actions_by_street):\n",
    "    return [\n",
    "        [\n",
    "            list(map(full_action_to_int, player_actions))\n",
    "            for player_actions in street_actions\n",
    "        ]\n",
    "        for street_actions in full_actions_by_street\n",
    "    ]\n",
    "\n",
    "def player_actions_to_matrix(player_actions):\n",
    "    action_matrix = np.zeros((4,4))\n",
    "    for idx, actions in enumerate(player_actions):\n",
    "        action_matrix[idx, actions] = 1\n",
    "    return action_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f4545462",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('CALL', [('CALL', 675), ('RAISE', 241)], [('RAISE', 675)], '', 'hugh_2pn_2016'), ('CALL', [('CALL', 1629), ('CHECK', 0)], [('RAISE', 1629)], '', 'hugh_2pn_2016'), ('CHECK', [('CHECK', 0)], [('CHECK', 0)], '', 'act1_2pn_2016'), ('CALL', [('RAISE', 2606)], [('CALL', 2606)], '', 'act1_2pn_2016')]\n",
      "[[[('CALL', 675), ('RAISE', 241)], [('RAISE', 675)]], [[('CALL', 1629), ('CHECK', 0)], [('RAISE', 1629)]], [[('CHECK', 0)], [('CHECK', 0)]], [[('RAISE', 2606)], [('CALL', 2606)]]]\n",
      "[[1, 2], [1, 0], [0], [2]] [[2], [2], [0], [1]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 1., 0.],\n",
       "       [1., 1., 0., 0.],\n",
       "       [1., 0., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "street_full_actions = list(map(lambda street: [street[1], street[2]], parsed[2]))\n",
    "\n",
    "_street_int_actions = street_int_actions(street_full_actions)\n",
    "player_a_actions = [round_actions[0] for round_actions in _street_int_actions]\n",
    "player_b_actions = [round_actions[1] for round_actions in _street_int_actions]\n",
    "\n",
    "print(parsed[2])\n",
    "print(street_full_actions)\n",
    "print(player_a_actions, player_b_actions)\n",
    "\n",
    "np.vstack(\n",
    "    (\n",
    "        player_actions_to_matrix(player_a_actions),\n",
    "        player_actions_to_matrix(player_b_actions)\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d8d06070",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Chip counts associated with actions\n",
    "# 8x20, subdivided buckets\n",
    "\n",
    "# 19 Bins because we need the 0 bucket to have special behavior\n",
    "# ie: We need Bin 1 to be 0 and Bin 2 to be 1\n",
    "num_bins=19\n",
    "\"\"\"\n",
    "Note: Some interesting experiements can be had if we decide to bucket differently\n",
    "We could also visualize the distribution of sizes across the dataset to inform choice\n",
    "May need to normalize across datasets for valid comparison\n",
    "\"\"\"\n",
    "max_value=10000 # Max I saw in first 10 was 1k\n",
    "bins = np.linspace(1, max_value, num_bins)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "This portion of the code is involved with mapping each player's actions to chip buckets\n",
    "Examples of a `full_action`:\n",
    " [('CALL', 809), ('RAISE', 241)],\n",
    "   [('RAISE', 809)],\n",
    "\"\"\"\n",
    "\n",
    "# Gives us bin indexes\n",
    "def action_to_bucket(full_action):\n",
    "    action_name = full_action[0]\n",
    "    if action_name == CALL or action_name == RAISE:\n",
    "        # Normally we would subtract one here to make the bin 0 indexed\n",
    "        # but, as per comment above, we want these bins 1 indexed\n",
    "        return np.digitize(full_action[1], bins)\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def street_chip_buckets(full_actions_by_street):\n",
    "    return [\n",
    "        [\n",
    "            list(map(action_to_bucket, player_actions))\n",
    "            for player_actions in street_actions\n",
    "        ]\n",
    "        for street_actions in full_actions_by_street\n",
    "    ]\n",
    "\n",
    "def chip_buckets_to_matrix(chip_buckets):\n",
    "    chip_matrix = np.zeros((8, 20))\n",
    "    for street_idx, buckets in enumerate(chip_buckets):\n",
    "        start_idx = street_idx * 2\n",
    "        end_idx = start_idx + 1\n",
    "        chip_matrix[start_idx, buckets[0]] = 1\n",
    "        chip_matrix[end_idx, buckets[1]] = 1\n",
    "    return chip_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3be09976",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[2, 1], [2]], [[3, 0], [3]], [[0], [0]], [[5], [5]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.],\n",
       "       [1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "        0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "street_full_actions = map(lambda street: [street[1], street[2]], parsed[2])\n",
    "scb = street_chip_buckets(street_full_actions)\n",
    "print(scb)\n",
    "chip_buckets_to_matrix(scb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "groupproject",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}