graph-games-proto 0.3.2083__py3-none-any.whl → 0.3.2096__py3-none-any.whl

graph_games_proto/fns.py

@@ -982,6 +982,38 @@ class GameConfig(PClass):
             fig=Fig.__fromdict__(d["fig"]),
             seed=d["seed"]
         )
+    
+
+class PublicGameConfig(PClass):
+    uuid = field(type=str)
+    started_at = field(type=str)
+    num_players = field(type=int)
+    fig = field(type=Fig)
+    def __todict__(self):
+        return {
+            "uuid": self.uuid,
+            "started_at": self.started_at,
+            "num_players": self.num_players,
+            "fig": self.fig.__todict__(),
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return PublicGameConfig(
+            uuid=d["uuid"],
+            started_at=d["started_at"],
+            num_players=d["num_players"],
+            fig=Fig.__fromdict__(d["fig"]),
+        )
+
+
+@dispatch(GameConfig)
+def getpublicgameconfig(game_config):
+    return PublicGameConfig(
+        uuid=game_config.uuid,
+        started_at=game_config.started_at,
+        num_players=game_config.num_players,
+        fig=game_config.fig,
+    )
 
 
 class ActionDrawUnit:
@@ -1195,7 +1227,7 @@ class LegalActionKeep(PClass):
         num_cards = len(card_uuids_matching_deck)
         actual_min = 0 if legal_action.keep.min is None else legal_action.keep.min
         actual_max = num_cards if legal_action.keep.max is None else min(legal_action.keep.max, num_cards)
-        rand_num_chosen = state.rng.randint(actual_min, actual_max)
+        rand_num_chosen = state.kernel.rng.randint(actual_min, actual_max)
         card_uuids = card_uuids_matching_deck[0:rand_num_chosen]
         return Action2(
             submitted_at=submitted_at,
@@ -1236,7 +1268,7 @@ class LegalActionDiscard(PClass):
         num_cards = len(card_uuids_matching_deck)
         actual_min = 0 if legal_action.discard.min is None else legal_action.discard.min
         actual_max = num_cards if legal_action.discard.max is None else min(legal_action.discard.max, num_cards)
-        rand_num_chosen = state.rng.randint(actual_min, actual_max)
+        rand_num_chosen = state.kernel.rng.randint(actual_min, actual_max)
         card_uuids = card_uuids_matching_deck[0:rand_num_chosen]
         return Action2(
             submitted_at=submitted_at,
@@ -1809,13 +1841,11 @@ def init_segment_record(segment: Segment2) -> SegmentRecord:
 
 
 class Path2(PClass):
-    uuid = field(type=str)
     idx = field(type=int)
     edge_uuid = field(type=str)
     segments = field(type=list)  # List[Segment]
     def __todict__(self):
         return {
-            "uuid": self.uuid,
             "idx": self.idx,
             "edge_uuid": self.edge_uuid,
             "segments": [segment.__todict__() for segment in self.segments],
@@ -1823,7 +1853,6 @@ class Path2(PClass):
     @staticmethod
     def __fromdict__(d):
         return Path2(
-            uuid=d["uuid"],
             idx=d["idx"],
             edge_uuid=d["edge_uuid"],
             segments=[Segment2.__fromdict__(segment) for segment in d["segments"]],
@@ -1831,13 +1860,11 @@ class Path2(PClass):
 
 
 class PathRecord(PClass):
-    uuid = field(type=str)
     idx = field(type=int)
     edge_uuid = field(type=str)
     segment_uuids = field(type=list)  # List[str]
     def __todict__(self):
         return {
-            "uuid": self.uuid,
             "idx": self.idx,
             "edge_uuid": self.edge_uuid,
             "segment_uuids": self.segment_uuids,
@@ -1845,7 +1872,6 @@ class PathRecord(PClass):
     @staticmethod
     def __fromdict__(d):
         return PathRecord(
-            uuid=d["uuid"],
             idx=d["idx"],
             edge_uuid=d["edge_uuid"],
             segment_uuids=d["segment_uuids"],
@@ -1854,7 +1880,6 @@ class PathRecord(PClass):
 
 def init_path_record(path: Path2) -> PathRecord:
     return PathRecord(
-        uuid=path.uuid,
         idx=path.idx,
         edge_uuid=path.edge_uuid,
         segment_uuids=[segment.uuid for segment in path.segments],
@@ -2052,10 +2077,8 @@ class BonusStatus(PClass):
 
 
 class StateKernel(PClass):
+    game_config = field(type=GameConfig)
     rng = field(type=random.Random)
-    fig = field(type=Fig)
-    num_players = field(type=int)
-    started_at = field(type=str)
 
     uuid2edgerecord = field(type=dict)  # Dict[str, BiEdgeRecord]
     uuid2segmentrecord = field(type=dict)  # Dict[str, SegmentRecord]
@@ -2083,10 +2106,8 @@ class StateKernel(PClass):
     player_graphs_3 = field(type=list)  # List[PlayerGraph]
     def __todict__(self):
         return {
+            "game_config": self.game_config.__todict__(),
             "rng": rng2json(self.rng),
-            "fig": self.fig.__todict__(),
-            "num_players": self.num_players,
-            "started_at": self.started_at,
             "edges": [edge.__todict__() for edge in self.edges],
             "nodes": [node.__todict__() for node in self.nodes],
             "regions": [region.__todict__() for region in self.regions],
@@ -2114,10 +2135,8 @@ class StateKernel(PClass):
     @staticmethod
     def __fromdict__(d):
         return StateKernel(
+            game_config=GameConfig.__fromdict__(d["game_config"]),
             rng=json2rng(d["rng"]),
-            fig=Fig.__fromdict__(d["fig"]),
-            num_players=d["num_players"],
-            started_at=d["started_at"],
             edges=[BiEdge.__fromdict__(edge) for edge in d["edges"]],
             nodes=[Node.__fromdict__(n) for n in d["nodes"]],
             regions=[Region.__fromdict__(r) for r in d["regions"]],
@@ -2144,12 +2163,11 @@ class StateKernel(PClass):
         )
 
 
-def init_state_kernel(fig, num_players, started_at, **kwargs):
-    board_config = fig.board_config
-    rng = kwargs.get('rng')
+def init_state_kernel(game_config, **kwargs):
+    board_config = game_config.fig.board_config
     nodes = kwargs.get('nodes', get_nodes(board_config))
     nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(nodes)}
-    edges = get_edges(rng, board_config, nodeuuid2idx)
+    edges = get_edges(board_config, nodeuuid2idx)
     segments = kwargs.get('segments', get_segments(board_config))
     goals = board_config.goals
     regions = kwargs.get('regions', [])
@@ -2162,7 +2180,7 @@ def init_state_kernel(fig, num_players, started_at, **kwargs):
     pieceuuid2piece = {}
     for piece_template in board_config.piece_templates:
         if piece_template.has_player:
-            for player_idx in range(num_players):
+            for player_idx in range(game_config.num_players):
                 pieces = generate_pieces(piece_template, player_idx)
                 for piece in pieces:
                     pieceuuid2piece[piece.uuid] = piece
@@ -2178,7 +2196,7 @@ def init_state_kernel(fig, num_players, started_at, **kwargs):
     starting_piles = []
     for piece_template in board_config.piece_templates:
         if piece_template.has_player:
-            for player_idx in range(num_players):
+            for player_idx in range(game_config.num_players):
                 pieces = generate_pieces(piece_template, player_idx)
                 pile = Pile(
                     player_idx=player_idx,
@@ -2187,8 +2205,6 @@ def init_state_kernel(fig, num_players, started_at, **kwargs):
                 )
                 starting_piles.append(pile)
 
-    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
-    edges = get_edges(rng, board_config, nodeuuid2idx)
     edgetuple2uuid = {}
     for edge in edges:
         node_1_idx = nodeuuid2idx[edge.node_1_uuid]
@@ -2199,9 +2215,8 @@ def init_state_kernel(fig, num_players, started_at, **kwargs):
     bonuses = board_config.bonuses
     bonusuuid2bonusidx = {bonus.uuid: idx for idx, bonus in enumerate(bonuses)}
     
-    player_graphs_3 = calc_player_graphs3(nodes, edges, pieceuuid2piece, num_players)
+    player_graphs_3 = calc_player_graphs3(nodes, edges, pieceuuid2piece, game_config.num_players)
 
-    
     uuid2segmentrecord = {segment.uuid: init_segment_record(segment) for segment in segments}
     uuid2edgerecord = {edge.uuid: init_biedge_record(edge) for edge in edges}
 
@@ -2219,19 +2234,17 @@ def init_state_kernel(fig, num_players, started_at, **kwargs):
         starting_decks.append(deck_obj)
 
     default_players = [
-        Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(num_players)
+        Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)
     ]
 
     return StateKernel(
+        game_config=game_config,
+        rng=getrng(game_config.seed),
         decks=kwargs.get('decks', starting_decks),
         piles=kwargs.get('piles', starting_piles),
         players=kwargs.get('players', default_players),
-        player_idxs=kwargs.get('player_idxs', list(range(num_players))),
+        player_idxs=kwargs.get('player_idxs', list(range(game_config.num_players))),
         history=kwargs.get('history', []),
-        fig=fig,
-        num_players=num_players,
-        started_at=started_at,
-        rng=rng,
         edges=edges,
         nodes=nodes,
         regions=regions,
@@ -2513,6 +2526,7 @@ class RemainingAllottedTime(PClass):
 
 
 class PublicState(PClass):
+    game_config = field(type=PublicGameConfig)
     deadlines = field(type=list)  # List[RemainingAllottedTime|None]
     game_started_at = field(type=str)
     allotted_times = field(type=list)
@@ -2537,6 +2551,7 @@ class PublicState(PClass):
     terminal = field(type=bool)
     def __todict__(self):
         return {
+            "game_config": self.game_config.__todict__(),
             "deadlines": [deadline.__todict__() if deadline else None for deadline in self.deadlines],
             "game_started_at": self.game_started_at,
             "allotted_times": [allotted_time.__todict__() if allotted_time else None for allotted_time in self.allotted_times], # List[AllottedTime|None]
@@ -2563,6 +2578,7 @@ class PublicState(PClass):
     @staticmethod
     def __fromdict__(d):
         return PublicState(
+            game_config=PublicGameConfig.__fromdict__(d["game_config"]),
             deadlines=[RemainingAllottedTime.__fromdict__(x) for x in d["deadlines"]],
             game_started_at=d["game_started_at"],
             allotted_times=[AllottedTime.__fromdict__(x) if x else None for x in d["allotted_times"]], # List[AllottedTime|None]
@@ -2653,7 +2669,7 @@ def get_segments(board_config):
     return segments
 
 
-def get_edges(rng, board_config, nodeuuid2idx):
+def get_edges(board_config, nodeuuid2idx):
     edges = []
     
 
@@ -2669,7 +2685,6 @@ def get_edges(rng, board_config, nodeuuid2idx):
                 Segment2(uuid=s.uuid, unit_uuid=s.unit_uuid, pieces=[]) for s in matching_board_path.path.segments
             ]
             path = Path2(
-                uuid=str(generate_uuid_with_rng(rng)), 
                 idx=path_idx, 
                 edge_uuid=link.uuid,
                 segments=segments,
@@ -2741,17 +2756,12 @@ def getsettingvalue(f, setting_name):
 
 @dispatch(State, str)
 def getsettingvalue(s, setting_name):
-    return getsettingvalue(s.kernel.fig, setting_name)
+    return getsettingvalue(s.kernel.game_config.fig, setting_name)
 
 
 @dispatch(GameConfig)
 def getinitialstate(game_config):
-    kernel = init_state_kernel(
-        game_config.fig,
-        game_config.num_players,
-        game_config.started_at,
-        rng=getrng(game_config.seed),
-    )
+    kernel = init_state_kernel(game_config)
     kernel = run_kernel_hooks(kernel, INITIALIZATION_HOOKS, True)
     return init_memoized_state(kernel)
 
@@ -2777,7 +2787,7 @@ def memoize_state(state):
 def calc_bonus_statuses3(kernel):
     bonus_statuses = [
         calc_bonus_status3(kernel, bonus)
-        for bonus in kernel.fig.board_config.bonuses
+        for bonus in kernel.game_config.fig.board_config.bonuses
     ]
     bonus_statuses = [bs for bs in bonus_statuses if bs is not None]
     return bonus_statuses
@@ -2853,7 +2863,7 @@ def score_public_items3(state, player_idx):
                         )
     for bonus_status in state.bonus_statuses_3:
         bonus_idx = state.kernel.bonusuuid2bonusidx.get(bonus_status.bonus_uuid)
-        bonus = state.kernel.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
+        bonus = state.kernel.game_config.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
         if bonus:
             if player_idx in bonus_status.winners:
                 items.append(
@@ -2889,7 +2899,7 @@ def score_public_items(state, player_idx):
                         )
     for bonus_status in state.bonus_statuses:
         bonus_idx = state.kernel.bonusuuid2bonusidx.get(bonus_status.bonus_uuid)
-        bonus = state.kernel.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
+        bonus = state.kernel.game_config.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
         if bonus:
             if player_idx in bonus_status.winners:
                 items.append(
@@ -3052,7 +3062,7 @@ def get_bonus_status_longest_trail3(kernel, bonus):
     winners = []
     player_longest_trail_lens = []
 
-    for player_idx in range(kernel.num_players):
+    for player_idx in range(kernel.game_config.num_players):
         trail_length = get_longest_path_length3(kernel, player_idx)
         player_longest_trail_lens.append(trail_length)
         if trail_length > longest_trail:
@@ -3084,7 +3094,7 @@ def get_bonus_status_longest_trail(state, bonus):
     winners = []
     player_longest_trail_lens = []
 
-    for player_idx in range(state.kernel.num_players):
+    for player_idx in range(state.kernel.game_config.num_players):
         trail_length = get_longest_path_length(state, player_idx)
         player_longest_trail_lens.append(trail_length)
         if trail_length > longest_trail:
@@ -3114,7 +3124,7 @@ def get_bonus_status_longest_trail(state, bonus):
 def handle_bonus_statuses(state):
     bonus_statuses = [
         calc_bonus_status(state, bonus)
-        for bonus in state.kernel.fig.board_config.bonuses
+        for bonus in state.kernel.game_config.fig.board_config.bonuses
     ]
     # Remove all None bonus statuses
     bonus_statuses = [bs for bs in bonus_statuses if bs is not None]
@@ -3477,7 +3487,7 @@ def find_player_with_longest_path(kernel):
     longest_path_player_idx = None
     longest_path_length = 0
 
-    for player_idx in range(kernel.num_players):
+    for player_idx in range(kernel.game_config.num_players):
         path_length = get_longest_path_length(kernel, player_idx)
         if path_length > longest_path_length:
             longest_path_length = path_length
@@ -3706,7 +3716,7 @@ def calc_player_graph3(nodes, edges, pieceuuid2piece, player_idx):
 def calc_player_graphs(state):
     return [
         calc_player_graph(state, player_idx) 
-        for player_idx in range(state.kernel.num_players)
+        for player_idx in range(state.kernel.game_config.num_players)
     ]
 
 
@@ -4050,7 +4060,7 @@ def is_path_open_to_player(state_kernel, path_idx, player_idx):
     player_idxs_on_edge = get_player_idxs_on_edge(state_kernel, edge_record)
 
     # Check if edge is too crowded for the number of players
-    if state_kernel.num_players <= 3:
+    if state_kernel.game_config.num_players <= 3:
         if len(player_idxs_on_edge) > 0:
             return False
         
@@ -4523,7 +4533,7 @@ def getpublictoplay(s):
 def get_max_allotted_times(s):
     return [
         get_player_max_allotted_time(s, player_idx) 
-        for player_idx in range(s.kernel.num_players)
+        for player_idx in range(s.kernel.game_config.num_players)
     ]
 
 
@@ -4549,7 +4559,7 @@ def get_deadline(s, max_allotted_time):
     since_action_idx = max_allotted_time.since_action_idx
     if since_action_idx == -1:
         allotted_since = datetime.strptime(
-            s.kernel.started_at, 
+            s.kernel.game_config.started_at, 
             "%Y-%m-%d %H:%M:%S"
         )
     else:
@@ -4568,7 +4578,7 @@ def get_deadline(s, max_allotted_time):
 @dispatch(State)
 def get_deadlines(s):
     if isterminal(s):
-        return [None for _ in range(s.kernel.num_players)]
+        return [None for _ in range(s.kernel.game_config.num_players)]
     return [
         get_deadline(s, max_allotted_time)
         for max_allotted_time in get_max_allotted_times(s)
@@ -4630,9 +4640,16 @@ def imagine_decks(public_state, private_state):
 
 
 def imagine_state(public_state, private_state):
+    public_game_config = public_state.game_config
+
     imagined_kernel = init_state_kernel(
-        fig=public_state.fig,
-        rng=random.Random(),
+        GameConfig(
+            seed=random.randint(0, 2**31 - 1),
+            uuid=public_game_config.uuid,
+            num_players=public_game_config.num_players,
+            fig=public_game_config.fig,
+            started_at=public_game_config.started_at,
+        ),
         edges=public_state.edges,
         nodes=public_state.nodes,
         piles=public_state.piles,
@@ -4672,7 +4689,6 @@ def getpublicstate(s):
                 )
             paths.append(
                 Path2(
-                    uuid=path_record.uuid,
                     edge_uuid=path_record.edge_uuid,
                     segments=segments,
                     idx=path_record.idx
@@ -4697,8 +4713,9 @@ def getpublicstate(s):
 
 
     return PublicState(
+        game_config=getpublicgameconfig(s.kernel.game_config),
         deadlines=get_deadlines(s),
-        game_started_at=s.kernel.started_at,
+        game_started_at=s.kernel.game_config.started_at,
         allotted_times=get_max_allotted_times(s),
         all_pieces=list(s.kernel.pieceuuid2piece.values()),
         to_play_2=getpublictoplay(s),
@@ -4736,10 +4753,10 @@ def getpublicdeck(s, d):
 
 @dispatch(State, Player)
 def getpublicplayer(s, p):
-    deck_counts = [0 for _ in s.kernel.fig.board_config.deks]
+    deck_counts = [0 for _ in s.kernel.game_config.fig.board_config.deks]
     for card in p.cards:
         deck_counts[s.kernel.carduuid2card[card].deck_idx] += 1
-    piece_template_counts = [0 for _ in s.kernel.fig.board_config.piece_templates]
+    piece_template_counts = [0 for _ in s.kernel.game_config.fig.board_config.piece_templates]
     for piece_uuid in p.pieces:
         piece_template_counts[s.kernel.pieceuuid2piece[piece_uuid].piece_template_idx] += 1
     return PublicPlayer(
@@ -4783,10 +4800,10 @@ def getpublicscore(s, player_idx):
         path_lens = getplayerpathlens(s, player_idx)
         if not path_lens:
             return 0
-        addends.append(sum(s.kernel.fig.path_scores[len] for len in path_lens))
+        addends.append(sum(s.kernel.game_config.fig.path_scores[len] for len in path_lens))
     
     if getsettingvalue(s, 'cluster_scoring'):
-        clusters = s.kernel.fig.board_config.clusters
+        clusters = s.kernel.game_config.fig.board_config.clusters
         uuid2cluster = {x.uuid: x for x in clusters}
         completed_clusters = s.player_hands[player_idx].completed_clusters
         cluster_scores = [uuid2cluster[cluster_uuid].score for cluster_uuid in completed_clusters]
@@ -4809,7 +4826,7 @@ def getplayerpathlens(s, player_idx):
 # Implementing the following Julia function:
 # getpathlens(s::State) = length.(getfield.(getfield.(s.fig.board_config.board_paths, :path), :segments))
 def getpathlens(s):
-    return [len(p.path.segments) for p in s.kernel.fig.board_config.board_paths]
+    return [len(p.path.segments) for p in s.kernel.game_config.fig.board_config.board_paths]
 
 # Implementing the following Julia function:
 # function getplayerpathidxs(s::State, player_idx::Int)
@@ -4849,7 +4866,7 @@ def getactiontype(action_name):
 
 
 # Function implements the following Julia function:
-# getlastplayeridxplus1(s) = mod1(getlastaction(s).player_idx + 1, s.kernel.num_players)
+# getlastplayeridxplus1(s) = mod1(getlastaction(s).player_idx + 1, s.kernel.game_config.num_players)
 def getlastplayeridxplus1(s):
     pass
 
@@ -5022,7 +5039,7 @@ def combinations(a, n=None):
 def getpotentialpathidxs(s, player_num):
     num_pieces = s.player_hands[player_num-1].num_pieces
     return list(
-        set(getpathidxs(s.kernel.fig, num_pieces)) - set(getunavailablepathidxs(s, player_num))
+        set(getpathidxs(s.kernel.game_config.fig, num_pieces)) - set(getunavailablepathidxs(s, player_num))
     )
     # return list(set(getpathidxs(s.fig, num_pieces)) - set(getunavailablepaths(s, player_num)))
 
@@ -5086,16 +5103,16 @@ def getunavailablepathidxs(s, player_idx):
     link2paths = {}
     path2link = {}
 
-    for board_path in s.kernel.fig.board_config.board_paths:
+    for board_path in s.kernel.game_config.fig.board_config.board_paths:
         link_idx = board_path.link_num - 1
         if link_idx not in link2paths:
             link2paths[link_idx] = []
         link2paths[link_idx].append(board_path.num-1)
         path2link[board_path.num-1] = link_idx
 
-    multipath_links = [(board_link.num-1) for board_link in getmultipathlinks(s.kernel.fig)]
+    multipath_links = [(board_link.num-1) for board_link in getmultipathlinks(s.kernel.game_config.fig)]
 
-    if s.kernel.num_players < 4:
+    if s.kernel.game_config.num_players < 4:
         blocking_hands = s.player_hands
     else:
         blocking_hands = [s.player_hands[player_idx]]
@@ -5601,7 +5618,7 @@ def getqproxy0(ps, a, td):
             return rewards
         v_proxies = [
             getvproxy0(getprivatestate(next_s, i))
-            for i in range(next_s.kernel.num_players)
+            for i in range(next_s.kernel.game_config.num_players)
         ]
         q_proxies = [
             r + v_proxies[i]

{graph_games_proto-0.3.2083.dist-info → graph_games_proto-0.3.2096.dist-info}/METADATA

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

{graph_games_proto-0.3.2083.dist-info → graph_games_proto-0.3.2096.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=slh5o58-rqAxEznKOvrkh4L0F6VLlHEnuValIVOXGlA,198791
+graph_games_proto/fns.py,sha256=Ni2ywvhv9562Hi1_pQie5P4aEtqLORss3yxaF-b24L8,199711
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.2083.dist-info/METADATA,sha256=EMIRl_Ci0n9s0m0pVHz4TiJcp4ODBQjCsi3otnaoPms,188
-graph_games_proto-0.3.2083.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.2083.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.2083.dist-info/RECORD,,
+graph_games_proto-0.3.2096.dist-info/METADATA,sha256=RsItWXIDMFkMIN2peGo0mTJo6zq6UpjN64X5kChH3qE,188
+graph_games_proto-0.3.2096.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.2096.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.2096.dist-info/RECORD,,