graph-games-proto 0.3.1917__py3-none-any.whl → 0.3.1919__py3-none-any.whl

graph_games_proto/fns.py

@@ -1942,9 +1942,7 @@ class StateKernal(PClass):
     player_idxs = field(type=list)  # List[int]
     history = field(type=list)  # List[PublicAction]
     player_scores = field(type=list)  # List[PlayerScore]
-    uuid2edge = field(type=dict)  # Dict[str, BiEdge]
     idx2path = field(type=list)  # List[Path2]
-    uuid2segment = field(type=dict)  # Dict[str, Segment]
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     edgeuuid2idx = field(type=dict)  # Dict[str, int]
     carduuid2card = field(type=dict)  # Dict[str, Card]
@@ -1959,9 +1957,7 @@ class StateKernal(PClass):
             "player_idxs": self.player_idxs,
             "history": [action.__todict__() for action in self.history],
             "player_scores": [score.__todict__() for score in self.player_scores],
-            "uuid2edge": {k: v.__todict() for k, v in self.uuid2edge.items()},
             "idx2path": [v.__todict__() for v in self.idx2path],
-            "uuid2segment": {k: v.__todict__() for k, v in self.uuid2segment.items()},
             "pieceuuid2piece": {k: v.__todict__() for k, v in self.pieceuuid2piece.items()},
             "edgeuuid2idx": self.edgeuuid2idx,
             "carduuid2card": {k: v.__todict__() for k, v in self.carduuid2card.items()},
@@ -1978,30 +1974,23 @@ class StateKernal(PClass):
             player_idxs=d["player_idxs"],
             history=[PublicAction.__fromdict__(action) for action in d["history"]],
             player_scores=[PlayerScore.__fromdict__(score) for score in d["player_scores"]],
-            uuid2edge={k: BiEdge.__fromdict(v) for k, v in d["uuid2edge"].items()},
             idx2path=[Path2.__fromdict(v) for v in d["idx2path"]],
-            uuid2segment={k: Segment2.__fromdict(v) for k, v in d["uuid2segment"].items()},
             pieceuuid2piece={k: Piece.__fromdict(v) for k, v in d["pieceuuid2piece"].items()},
             edgeuuid2idx=d["edgeuuid2idx"],
             carduuid2card={k: Card.__fromdict(v) for k, v in d["carduuid2card"].items()},
         )
 
 
-def init_state_kernal(**kwargs):
+def init_state_kernel(**kwargs):
     game_config = kwargs.get('game_config')
     fig = game_config.fig
     board_config = fig.board_config
     edges = kwargs.get('edges', [])
-    uuid2edge = {}
     idx2path = []
-    uuid2segment = {}
     edgeuuid2idx = {edge.uuid: idx for idx, edge in enumerate(edges)}
     for edge in edges:
-        uuid2edge[edge.uuid] = edge
         for path in edge.paths:
             idx2path.append(path)
-            for segment in path.segments:
-                uuid2segment[segment.uuid] = segment
     pieceuuid2piece = {}
     for piece_template in board_config.piece_templates:
         if piece_template.has_player:
@@ -2025,9 +2014,7 @@ def init_state_kernal(**kwargs):
         player_idxs=kwargs.get('player_idxs'),
         history=kwargs.get('history'),
         player_scores=kwargs.get('player_scores'),
-        uuid2edge=uuid2edge,
         idx2path=idx2path,
-        uuid2segment=uuid2segment,
         edgeuuid2idx=edgeuuid2idx,
         carduuid2card=carduuid2card,
         pieceuuid2piece=pieceuuid2piece,
@@ -2035,12 +2022,9 @@ def init_state_kernal(**kwargs):
 
 
 class State(PClass):
-    kernal = field(type=StateKernal)
-    uuid2edge = field(type=dict)  # Dict[str, BiEdge]
+    kernel = field(type=StateKernal)
     idx2path = field(type=list)  # List[Path2]
-    uuid2segment = field(type=dict)  # Dict[str, Segment]
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
-    carduuid2card = field(type=dict)  # Dict[str, Card]
     bonus_statuses = field(type=list)  # List[BonusStatus]
     bonusuuid2bonusidx = field(type=dict)  # Dict[str, int]
     carduuid2deckidx = field(type=dict)  # Dict[str, int]
@@ -2067,12 +2051,9 @@ class State(PClass):
     winners = field(type=list)  # List[int]
     def __todict__(self):
         return {
-            "kernal": self.kernal.__todict__(),
-            "uuid2edge": {k: v.__todict__() for k, v in self.uuid2edge.items()},
+            "kernel": self.kernel.__todict__(),
             "idx2path": [v.__todict__() for v in self.idx2path],
-            "uuid2segment": {k: v.__todict__() for k, v in self.uuid2segment.items()},
             "pieceuuid2piece": {k: v.__todict__() for k, v in self.pieceuuid2piece.items()},
-            "carduuid2card": {k: v.__todict__() for k, v in self.carduuid2card.items()},
             "bonus_statuses": [status.__todict__() for status in self.bonus_statuses],
             "bonusuuid2bonusidx": self.bonusuuid2bonusidx,
             "carduuid2deckidx": self.carduuid2deckidx,
@@ -2101,12 +2082,9 @@ class State(PClass):
     @staticmethod
     def __fromdict__(d):
         return State(
-            kernal=StateKernal.__fromdict__(d["kernal"]),
-            uuid2edge={k: BiEdge.__fromdict__(v) for k, v in d["uuid2edge"].items()},
+            kernel=StateKernal.__fromdict__(d["kernel"]),
             idx2path=[Path2.__fromdict__(v) for v in d["idx2path"]],
-            uuid2segment={k: Segment2.__fromdict__(v) for k, v in d["uuid2segment"].items()},
             pieceuuid2piece={k: Piece.__fromdict__(v) for k, v in d["pieceuuid2piece"].items()},
-            carduuid2card={k: Card.__fromdict__(v) for k, v in d["carduuid2card"].items()},
             bonus_statuses=[BonusStatus.__fromdict__(x) for x in d["bonus_statuses"]],
             bonusuuid2bonusidx=d["bonusuuid2bonusidx"],
             carduuid2deckidx=d["carduuid2deckidx"],
@@ -2610,13 +2588,11 @@ def getinitialstate(game_config):
                 )
                 piles.append(pile)
 
-    carduuid2card = {}
     carduuid2deckidx = {}
     decks = []
     for dek in board_config.deks:
         cards = generate_cards(dek)
         for card in cards:
-            carduuid2card[card.uuid] = card
             carduuid2deckidx[card.uuid] = dek.idx
         deck_obj = Deck(
             uuid=dek.uuid,
@@ -2638,17 +2614,11 @@ def getinitialstate(game_config):
         edge_tuple = (min(node_1_idx, node_2_idx), max(node_1_idx, node_2_idx))
         edgetuple2uuid[edge_tuple] = edge.uuid
 
-
-    uuid2edge = {}
     idx2path = []
-    uuid2segment = {}
     
     for edge in edges:
-        uuid2edge[edge.uuid] = edge
         for path in edge.paths:
             idx2path.append(path)
-            for segment in path.segments:
-                uuid2segment[segment.uuid] = segment
 
     bonuses = game_config.fig.board_config.bonuses
     bonusuuid2bonusidx = {bonus.uuid: idx for idx, bonus in enumerate(bonuses)}
@@ -2669,11 +2639,8 @@ def getinitialstate(game_config):
     ]
 
     state = State(
-        uuid2edge=uuid2edge,
         idx2path=idx2path,
-        uuid2segment=uuid2segment,
         pieceuuid2piece=pieceuuid2piece,
-        carduuid2card=carduuid2card,
         bonus_statuses=bonus_statuses,
         bonusuuid2bonusidx=bonusuuid2bonusidx,
         carduuid2deckidx=carduuid2deckidx,
@@ -2711,7 +2678,7 @@ def getinitialstate(game_config):
 
     state = run_state_hooks(state, INITIALIZATION_HOOKS, True)
     
-    kernal = init_state_kernal(
+    kernel = init_state_kernel(
         rng=rng,
         game_config=state.game_config,
         edges=state.edges,
@@ -2723,8 +2690,8 @@ def getinitialstate(game_config):
         player_scores=state.player_scores,
     )
 
-    state = state.set(kernal=kernal)
-    state = state.set(legal_actions_3=calc_legal_actions3(kernal))
+    state = state.set(kernel=kernel)
+    state = state.set(legal_actions_3=calc_legal_actions3(kernel))
 
     return state
 
@@ -3098,7 +3065,7 @@ def get_follow_up_draw_legal_actions(game, action):
             
             for card_uuid in game.decks[0].faceup_spots:
                 if card_uuid:
-                    if not game.carduuid2card[card_uuid].is_wild:
+                    if not game.kernel.carduuid2card[card_uuid].is_wild:
                         to_return.append(
                             LegalAction(
                                 player_idx=legal_action.player_idx,
@@ -3141,7 +3108,7 @@ def append_follow_up_draw_legal_actions(game, action):
             
             for card_uuid in game.decks[0].faceup_spots:
                 if card_uuid:
-                    if not game.carduuid2card[card_uuid].is_wild:
+                    if not game.kernel.carduuid2card[card_uuid].is_wild:
                         game = append_to_legal_actions(
                             game,
                             LegalAction(
@@ -3165,7 +3132,7 @@ def get_num_faceup_wilds(game, deck_idx):
     non_empty_spots = [spot for spot in deck.faceup_spots if spot]
     if not non_empty_spots:
         return 0
-    return sum(1 for card_uuid in non_empty_spots if game.carduuid2card[card_uuid].is_wild)
+    return sum(1 for card_uuid in non_empty_spots if game.kernel.carduuid2card[card_uuid].is_wild)
 
 
 def ensure_faceup_spots_valid(game):
@@ -3211,7 +3178,7 @@ def handle_faceup_draw_action(game, action):
     game = replenish_faceup_spot_if_needed(game, faceup_draw.deck_idx, spot_idx)
 
     # Prevent an extra draw if last draw was a face-wild-draw
-    if not game.carduuid2card[drawn_card].is_wild:
+    if not game.kernel.carduuid2card[drawn_card].is_wild:
         # TODO: extract this out to user-defined function/hook
         game = append_follow_up_draw_legal_actions(game, action)
 
@@ -3343,7 +3310,7 @@ def handle_move_longest_path_card(game, action):
             player_with_card = find_player_with_longest_path_card(game)
             if player_with_card:
                 # Find the index of the card from the player's cards, then pop it
-                card_idx = next((i for i, card_uuid in enumerate(player_with_card.cards) if game.carduuid2card[card_uuid].deck_idx == 2), None)
+                card_idx = next((i for i, card_uuid in enumerate(player_with_card.cards) if game.kernel.carduuid2card[card_uuid].deck_idx == 2), None)
                 if card_idx is not None:
                     longest_path_card = player_with_card.cards.pop(card_idx)
 
@@ -3359,7 +3326,7 @@ def handle_move_longest_path_card(game, action):
 
 def find_player_with_longest_path_card(game):
     for player in game.players:
-        if any(game.carduuid2card[card_uuid].deck_idx == 2 for card_uuid in player.cards):
+        if any(game.kernel.carduuid2card[card_uuid].deck_idx == 2 for card_uuid in player.cards):
             return player
     return None
 
@@ -3401,7 +3368,7 @@ def handle_move_pieces_to_path_action(game, action):
             # Remove the card from player's cards
             card_uuid = player.cards.pop(card_idx)
             # add to discard
-            game.decks[game.carduuid2card[card_uuid].deck_idx].discard.append(card_uuid)
+            game.decks[game.kernel.carduuid2card[card_uuid].deck_idx].discard.append(card_uuid)
 
     game = recycle_decks_if_needed(game)
     game = replenish_decks_if_needed(game)
@@ -3910,7 +3877,7 @@ HOOK_NAMESPACE = {
 
 def get_wild_unit_uuids(game):
     wild_unit_uuids = []
-    for card in game.carduuid2card.values():
+    for card in game.kernel.carduuid2card.values():
         if card.is_wild:
             wild_unit_uuids.append(card.resource_uuid)
     return wild_unit_uuids
@@ -3924,7 +3891,7 @@ def match_strict_wild(game, fulfillment, cards, segments):
 
     for segment in segments:
         if segment.unit_uuid and segment.unit_uuid in wild_unit_uuids:
-            first_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
+            first_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.kernel.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
             if first_matching_idx is not None:
                 new_fulfillment.append(new_cards.pop(first_matching_idx))
             else:
@@ -3942,8 +3909,8 @@ def match_non_wild_non_empty(game, fulfillment, cards, segments, log=False):
     new_segments = []
 
     for segment in segments:
-        first_strict_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
-        first_wild_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.carduuid2card[card_uuid].resource_uuid in wild_unit_uuids), None)
+        first_strict_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.kernel.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
+        first_wild_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.kernel.carduuid2card[card_uuid].resource_uuid in wild_unit_uuids), None)
         first_matching_idx = first_strict_matching_idx if first_strict_matching_idx is not None else first_wild_matching_idx
         if first_matching_idx is not None:
             new_fulfillment.append(new_cards.pop(first_matching_idx))
@@ -3982,14 +3949,14 @@ def match_empty(game, fulfillment, cards, segments):
 
 
 def get_uniform_sets(game, cards, min_length):
-    wilds = [card_uuid for card_uuid in cards if game.carduuid2card[card_uuid].is_wild]
-    non_wilds = [card_uuid for card_uuid in cards if not game.carduuid2card[card_uuid].is_wild]
+    wilds = [card_uuid for card_uuid in cards if game.kernel.carduuid2card[card_uuid].is_wild]
+    non_wilds = [card_uuid for card_uuid in cards if not game.kernel.carduuid2card[card_uuid].is_wild]
     # print("********************* cards: ", cards)
     # print("********************* wilds: ", wilds)
     # print("********************* non_wilds: ", non_wilds)
     unit_uuid_2_cards = {}
     for card_uuid in non_wilds:
-        card = game.carduuid2card[card_uuid]
+        card = game.kernel.carduuid2card[card_uuid]
         if card.resource_uuid not in unit_uuid_2_cards:
             unit_uuid_2_cards[card.resource_uuid] = []
         unit_uuid_2_cards[card.resource_uuid].append(card_uuid)
@@ -4038,7 +4005,7 @@ def get_sample_actionclaimpath(game, player_idx, path_idx):
 
 def get_sample_path_fulfillment(game, player_idx, path_idx):
     path = game.idx2path[path_idx]
-    remaining_card_uuids = [card_uuid for card_uuid in game.players[player_idx].cards if game.carduuid2card[card_uuid].deck_idx == 0]
+    remaining_card_uuids = [card_uuid for card_uuid in game.players[player_idx].cards if game.kernel.carduuid2card[card_uuid].deck_idx == 0]
     remaining_pieces = [
         piece_uuid 
         for piece_uuid in game.players[player_idx].pieces 
@@ -4178,19 +4145,19 @@ def isactionlegal2(s, a):
     return run_accept_action_hooks(s, a, ACCEPT_ACTION_HOOKS, False)
 
 
-def calc_legal_actions3(state_kernal):
-    history = state_kernal.history
+def calc_legal_actions3(state_kernel):
+    history = state_kernel.history
     last_action = history[-1] if len(history) > 0 else None
 
     if last_action is None or last_action.legal_action.name == "INITIAL-GOAL-KEEP":
 
         yet_to_make_initial_move = [
-            player for player in state_kernal.players if len(player.discard_tray) > 0
+            player for player in state_kernel.players if len(player.discard_tray) > 0
         ]
         
         if len(yet_to_make_initial_move) == 0:
             # All players have made their initial move, proceed to the first player's turn
-            return get_default_legal_actions(state_kernal, state_kernal.player_idxs[0])
+            return get_default_legal_actions(state_kernel, state_kernel.player_idxs[0])
 
         return [
             LegalAction(
@@ -4209,27 +4176,27 @@ def calc_legal_actions3(state_kernal):
     
     elif last_action.legal_action.faceup_draw:
         faceup_draw = last_action.legal_action.faceup_draw
-        if not state_kernal.carduuid2card[faceup_draw.card_uuid].is_wild:
-            legal_actions = get_follow_up_draw_legal_actions(state_kernal, last_action)
+        if not state_kernel.carduuid2card[faceup_draw.card_uuid].is_wild:
+            legal_actions = get_follow_up_draw_legal_actions(state_kernel, last_action)
             if legal_actions:
                 return legal_actions
     
     elif last_action.legal_action.draw:
         if last_action.legal_action.draw.quantity == 1:
-            legal_actions = get_follow_up_draw_legal_actions(state_kernal, last_action)
+            legal_actions = get_follow_up_draw_legal_actions(state_kernel, last_action)
             if legal_actions:
                 return legal_actions
     
     elif last_action.legal_action.draw_discard:
         draw_discard = last_action.legal_action.draw_discard
-        player = state_kernal.players[last_action.legal_action.player_idx]
+        player = state_kernel.players[last_action.legal_action.player_idx]
         return [
             LegalAction(
                 player_idx=player.idx,
                 name="GOAL-KEEP",
                 instruction="Your move. Please select the routes you want to keep.",
                 allotted_seconds=INITIAL_ALLOTTED_SECONDS,
-                allotted_since_action_idx=(len(state_kernal.history) - 1),
+                allotted_since_action_idx=(len(state_kernel.history) - 1),
                 keep=LegalActionKeep(
                     deck_idx=draw_discard.deck_idx,
                     min=draw_discard.min,
@@ -4238,38 +4205,36 @@ def calc_legal_actions3(state_kernal):
             )
         ]
     
-    next_player_idx = get_next_player_shuffled_idx(state_kernal, last_action)
-    return get_default_legal_actions(state_kernal, state_kernal.player_idxs[next_player_idx])
+    next_player_idx = get_next_player_shuffled_idx(state_kernel, last_action)
+    return get_default_legal_actions(state_kernel, state_kernel.player_idxs[next_player_idx])
 
 
-def get_next_player_shuffled_idx(state_kernal, last_action):
+def get_next_player_shuffled_idx(state_kernel, last_action):
     last_player_idx = last_action.legal_action.player_idx
-    last_player_shuffled_idx = state_kernal.player_idxs.index(last_player_idx)
-    next_player_shuffled_idx = (last_player_shuffled_idx + 1) % len(state_kernal.player_idxs)
+    last_player_shuffled_idx = state_kernel.player_idxs.index(last_player_idx)
+    next_player_shuffled_idx = (last_player_shuffled_idx + 1) % len(state_kernel.player_idxs)
     return next_player_shuffled_idx
 
 
-def init_state(kernal):
+def init_state(kernel):
     state = State(
-        rng=kernal.rng,
-        game_config=kernal.game_config,
-        edges=kernal.edges,
-        decks=kernal.decks,
-        piles=kernal.piles,
-        players=kernal.players,
-        player_idxs=kernal.player_idxs,
-        history=kernal.history,
-        player_scores=kernal.player_scores,
+        rng=kernel.rng,
+        game_config=kernel.game_config,
+        edges=kernel.edges,
+        decks=kernel.decks,
+        piles=kernel.piles,
+        players=kernel.players,
+        player_idxs=kernel.player_idxs,
+        history=kernel.history,
+        player_scores=kernel.player_scores,
         legal_actions_3=[],
         is_terminal=False,
-        uuid2edge=kernal.uuid2edge,
-        idx2path=kernal.idx2path,
-        uuid2segment=kernal.uuid2segment,
-        pieceuuid2piece=kernal.pieceuuid2piece,
-        edgeuuid2idx=kernal.edgeuuid2idx,
-        carduuid2card=kernal.carduuid2card,
+        idx2path=kernel.idx2path,
+        pieceuuid2piece=kernel.pieceuuid2piece,
+        edgeuuid2idx=kernel.edgeuuid2idx,
+        carduuid2card=kernel.carduuid2card,
     )
-    state = state.set(legal_actions_3=calc_legal_actions3(kernal))
+    state = state.set(legal_actions_3=calc_legal_actions3(kernel))
     return state
 
 
@@ -4282,7 +4247,7 @@ def getnextstate2(s, a, log=False):
     s = run_state_hooks(s, HANDLE_SCORING_HOOKS, log)
     s = run_state_hooks(s, HANDLE_TERMINAL_HOOKS, log)
 
-    state_kernal = init_state_kernal(
+    state_kernel = init_state_kernel(
         rng=s.rng,
         game_config=s.game_config,
         edges=s.edges,
@@ -4293,7 +4258,7 @@ def getnextstate2(s, a, log=False):
         history=s.history,
         player_scores=s.player_scores,
     )
-    s = s.set(legal_actions_3=calc_legal_actions3(state_kernal))
+    s = s.set(legal_actions_3=calc_legal_actions3(state_kernel))
 
     return s
 
@@ -4435,7 +4400,7 @@ def imagine_decks(public_state, private_state):
 
 
 def imagine_state(public_state, private_state):
-    kernal = init_state_kernal(
+    kernel = init_state_kernel(
         rng=random.Random(),
         game_config=public_state.game_config,
         player_idxs=public_state.player_idxs,
@@ -4446,7 +4411,7 @@ def imagine_state(public_state, private_state):
         history=imagine_history(public_state, private_state),
         player_scores=imagine_player_scores(public_state, private_state),
     )
-    imagined_state = init_state(kernal)
+    imagined_state = init_state(kernel)
     return imagined_state
 
 
@@ -5599,12 +5564,12 @@ HANDLE_TERMINAL_HOOKS = [
     ),
 ]
 
-def get_default_legal_actions(state_kernal, player_idx):
+def get_default_legal_actions(state_kernel, player_idx):
     allotted_seconds = DEFAULT_ALLOTTED_SECONDS
-    allotted_since_action_idx = len(state_kernal.history) - 1
+    allotted_since_action_idx = len(state_kernel.history) - 1
     legal_actions = []
 
-    if len(state_kernal.decks[1].facedown_stack) >= 1:
+    if len(state_kernel.decks[1].facedown_stack) >= 1:
         legal_actions.append(
             LegalAction(
                 player_idx=player_idx,
@@ -5620,7 +5585,7 @@ def get_default_legal_actions(state_kernal, player_idx):
             )
         )
 
-    if len(state_kernal.decks[0].facedown_stack) >= 1:
+    if len(state_kernel.decks[0].facedown_stack) >= 1:
         legal_actions.append(
             LegalAction(
                 auto_preferred=True,
@@ -5636,7 +5601,7 @@ def get_default_legal_actions(state_kernal, player_idx):
             )
         )
 
-    if len(state_kernal.decks[0].facedown_stack) >= 2:
+    if len(state_kernel.decks[0].facedown_stack) >= 2:
         legal_actions.append(
             LegalAction(
                 player_idx=player_idx,
@@ -5651,7 +5616,7 @@ def get_default_legal_actions(state_kernal, player_idx):
             )
         )
 
-    for card_uuid in state_kernal.decks[0].faceup_spots:
+    for card_uuid in state_kernel.decks[0].faceup_spots:
         if card_uuid:
             legal_actions.append(
                 LegalAction(
@@ -5667,7 +5632,7 @@ def get_default_legal_actions(state_kernal, player_idx):
                 )
             )
 
-    for legal_action in get_legal_actions_for_paths(state_kernal, player_idx):
+    for legal_action in get_legal_actions_for_paths(state_kernel, player_idx):
         legal_actions.append(legal_action)
     
     return legal_actions

{graph_games_proto-0.3.1917.dist-info → graph_games_proto-0.3.1919.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph_games_proto
-Version: 0.3.1917
+Version: 0.3.1919
 Requires-Dist: multipledispatch==1.0.0
 Requires-Dist: pyrsistent==0.20.0
 Requires-Dist: numpy==2.2.4

{graph_games_proto-0.3.1917.dist-info → graph_games_proto-0.3.1919.dist-info}/RECORD

@@ -1,9 +1,9 @@
 graph_games_proto/__init__.py,sha256=_EVQR-51XehfH45XZlba1WPdx3omS3Gm1nTwrgGyn2Q,667
 graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
-graph_games_proto/fns.py,sha256=yH7roM_wtAdsgFfeQA8wahPykXQrdCoySKm3f8U5Diw,193316
+graph_games_proto/fns.py,sha256=W9NSec9UZD-ChyDnis0obBz4d-1ckBGJzdCeSKpEu9M,191615
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1917.dist-info/METADATA,sha256=Nzsbrk3Z0TxOO5hmViO9MlS4_Lw-kTunuJoJiB3N9FU,188
-graph_games_proto-0.3.1917.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1917.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1917.dist-info/RECORD,,
+graph_games_proto-0.3.1919.dist-info/METADATA,sha256=73zemgEdGj4B_AXQf-VpDmV-JkWw5uA1PhDUAvwA__U,188
+graph_games_proto-0.3.1919.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1919.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1919.dist-info/RECORD,,