gym-csle-stopping-game 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

gym_csle_stopping_game/__version__.py

@@ -1 +1 @@
-__version__ = '0.7.2'
+__version__ = '0.7.4'

gym_csle_stopping_game/constants/constants.py

@@ -34,6 +34,7 @@ class ENV_METRICS:
     DEFENDER_ACTION = "a1"
     ATTACKER_ACTION = "a2"
     OBSERVATION = "o"
+    BELIEF = "b"
     TIME_STEP = "t"
     AVERAGE_DEFENDER_BASELINE_STOP_ON_FIRST_ALERT_RETURN = "average_defender_baseline_stop_on_first_alert_return"
     AVERAGE_UPPER_BOUND_RETURN = "average_upper_bound_return"

gym_csle_stopping_game/util/stopping_game_util.py

@@ -1,8 +1,10 @@
-from typing import Any
+from typing import Any, Tuple
+import itertools
 import numpy as np
 import numpy.typing as npt
 from scipy.stats import betabinom
 from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
+from csle_common.dao.training.policy import Policy
 
 
 class StoppingGameUtil:
@@ -90,7 +92,7 @@ class StoppingGameUtil:
         return np.array(R_l)
 
     @staticmethod
-    def transition_tensor(L: int, p: float) -> npt.NDArray[Any]:
+    def transition_tensor(L: int) -> npt.NDArray[Any]:
         """
         Gets the transition tensor
 
@@ -105,15 +107,15 @@ class StoppingGameUtil:
                     [
                         # Attacker continues
                         [
-                            [1, 0, 0],  # No intrusion
-                            [0, 1 - 1 / (2 * l), 1 / (2 * l)],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [1.0, 0.0, 0.0],  # No intrusion
+                            [0.0, 1.0, 0.0],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ],
                         # Attacker stops
                         [
-                            [0, 1, 0],  # No intrusion
-                            [0, 0, 1],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [0.0, 1.0, 0.0],  # No intrusion
+                            [0.0, 0.0, 1.0],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ]
                     ],
 
@@ -121,15 +123,15 @@ class StoppingGameUtil:
                     [
                         # Attacker continues
                         [
-                            [0, 0, 1],  # No intrusion
-                            [0, 0, 1],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [0.0, 0.0, 1.0],  # No intrusion
+                            [0.0, 0.0, 1.0],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ],
                         # Attacker stops
                         [
-                            [0, 0, 1],  # No Intrusion
-                            [0, 0, 1],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [0.0, 0.0, 1.0],  # No Intrusion
+                            [0.0, 0.0, 1.0],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ]
                     ]
                 ]
@@ -139,15 +141,15 @@ class StoppingGameUtil:
                     [
                         # Attacker continues
                         [
-                            [1, 0, 0],  # No intrusion
-                            [0, 1 - 1 / (2 * l), 1 / (2 * l)],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [1.0, 0.0, 0.0],  # No intrusion
+                            [0.0, 1.0 - 1.0 / (2.0 * l), 1.0 / (2.0 * l)],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ],
                         # Attacker stops
                         [
-                            [0, 1, 0],  # No intrusion
-                            [0, 0, 1],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [0.0, 1.0, 0.0],  # No intrusion
+                            [0.0, 0.0, 1.0],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ]
                     ],
 
@@ -155,15 +157,15 @@ class StoppingGameUtil:
                     [
                         # Attacker continues
                         [
-                            [1, 0, 0],  # No intrusion
-                            [0, 1 - 1 / (2 * l), 1 / (2 * l)],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [1.0, 0.0, 0.0],  # No intrusion
+                            [0.0, 1.0 - 1.0 / (2.0 * l), 1.0 / (2.0 * l)],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ],
                         # Attacker stops
                         [
-                            [0, 1, 0],  # No Intrusion
-                            [0, 0, 1],  # Intrusion
-                            [0, 0, 1]  # Terminal
+                            [0.0, 1.0, 0.0],  # No Intrusion
+                            [0.0, 0.0, 1.0],  # Intrusion
+                            [0.0, 0.0, 1.0]  # Terminal
                         ]
                     ]
                 ]
@@ -386,3 +388,311 @@ class StoppingGameUtil:
                         r = config.R[0][a1][0][s]
                         file_str = file_str + f"R: {a1} : {s} : {s_prime} : {o} {r:.80f}\n"
         return file_str
+
+    @staticmethod
+    def reduce_T_attacker(T: npt.NDArray[np.float_], strategy: Policy) -> npt.NDArray[np.float_]:
+        """
+        Reduces the transition tensor based on a given attacker strategy
+
+        :param T: the tensor to reduce
+        :param strategy: the strategy to use for the reduction
+        :return: the reduced tensor (|A1|x|S|x|S|)
+        """
+        if len(T.shape) == 5:
+            T = T[0]
+        reduced_T = np.zeros((T.shape[0], T.shape[2], T.shape[3]))
+        for i in range(T.shape[0]):
+            for j in range(T.shape[2]):
+                for k in range(T.shape[3]):
+                    reduced_T[i][j][k] = T[i][0][j][k] * strategy.probability(j, 0) + T[i][1][j][
+                        k] * strategy.probability(j, 1)
+                    # if j == 0:
+                    #     reduced_T[i][j][k] = T[i][0][j][k] * strategy.probability(j, 0) + T[i][1][j][
+                    #         k] * strategy.probability(j, 1)
+                    # else:
+                    #     reduced_T[i][j][k] = (T[i][0][j][k] * (1 - strategy.probability(j, 0)) + T[i][1][j][k] *
+                    #                           strategy.probability(j, 1))
+        return reduced_T
+
+    @staticmethod
+    def reduce_R_attacker(R: npt.NDArray[np.float_], strategy: Policy) -> npt.NDArray[np.float_]:
+        """
+        Reduces the reward tensor based on a given attacker strategy
+
+        :param R: the reward tensor to reduce
+        :param strategy: the strategy to use for the reduction
+        :return: the reduced reward tensor (|A1|x|S|)
+        """
+        if len(R.shape) == 4:
+            R = R[0]
+        reduced_R = np.zeros((R.shape[0], R.shape[2]))
+        for i in range(R.shape[0]):
+            for j in range(R.shape[2]):
+                reduced_R[i][j] = (R[i][0][j] * strategy.probability(j, 0) + R[i][1][j] *
+                                   strategy.probability(j, 1))
+        return reduced_R
+
+    @staticmethod
+    def reduce_Z_attacker(Z: npt.NDArray[np.float_], strategy: Policy) -> npt.NDArray[np.float_]:
+        """
+        Reduces the observation tensor based on a given attacker strategy
+
+        :param Z: the observation tensor to reduce
+        :param strategy: the strategy to use for the reduction
+        :return: the reduced observation tensor (|A1|x|S|x|O|)
+        """
+        reduced_Z = np.zeros((Z.shape[0], Z.shape[2], Z.shape[3]))
+        for i in range(Z.shape[0]):
+            for j in range(Z.shape[2]):
+                for k in range(Z.shape[3]):
+                    reduced_Z[i][j][k] = Z[i][0][j][k] * strategy.probability(j, 0) + Z[i][1][j][
+                        k] * strategy.probability(j, 1)
+        return reduced_Z
+
+    @staticmethod
+    def reduce_T_defender(T: npt.NDArray[np.float_], strategy: Policy) -> npt.NDArray[np.float_]:
+        """
+        Reduces the transition tensor based on a given defender strategy
+
+        :param T: the tensor to reduce
+        :param strategy: the strategy to use for the reduction
+        :return: the reduced tensor (|A2|x|S|x|S|)
+        """
+        if len(T.shape) == 5:
+            T = T[0]
+        reduced_T = np.zeros((T.shape[1], T.shape[2], T.shape[3]))
+        for i in range(T.shape[1]):
+            for j in range(T.shape[2]):
+                for k in range(T.shape[3]):
+                    reduced_T[i][j][k] = (T[0][i][j][k] * strategy.probability(j, 0) + T[1][i][j][k]
+                                          * strategy.probability(j, 1))
+        return reduced_T
+
+    @staticmethod
+    def reduce_R_defender(R: npt.NDArray[np.float_], strategy: Policy) -> npt.NDArray[np.float_]:
+        """
+        Reduces the reward tensor based on a given defender strategy
+
+        :param R: the reward tensor to reduce
+        :param strategy: the strategy to use for the reduction
+        :return: the reduced reward tensor (|A2|x|S|)
+        """
+        if len(R.shape) == 4:
+            R = R[0]
+        reduced_R = np.zeros((R.shape[1], R.shape[2]))
+        for i in range(R.shape[1]):
+            for j in range(R.shape[2]):
+                reduced_R[i][j] = (R[0][i][j] * strategy.probability(j, 0) + R[1][i][j] *
+                                   strategy.probability(j, 1))
+        return reduced_R
+
+    @staticmethod
+    def aggregate_belief_mdp_defender(aggregation_resolution: int, T: npt.NDArray[np.float_],
+                                      R: npt.NDArray[np.float_], Z: npt.NDArray[np.float_],
+                                      S: npt.NDArray[np.int_], A: npt.NDArray[np.int_], O: npt.NDArray[np.int_]) \
+            -> Tuple[npt.NDArray[np.float_], npt.NDArray[np.int_], npt.NDArray[np.float_], npt.NDArray[np.float_]]:
+        """
+        Generates an aggregate belief MDP from a given POMDP specification and aggregation resolution
+
+        :param aggregation_resolution: the belief aggregation resolution
+        :param T: the transition tensor of the POMDP
+        :param R: the reward tensor of the POMDP
+        :param Z: the observation tensor of the POMDP
+        :param S: the state space of the POMDP
+        :param A: the action space of the POMDP
+        :param O: the observation space of the POMDP
+        :return: the state space, action space, transition operator, and belief operator of the belief MDP
+        """
+        aggregate_belief_space = StoppingGameUtil.generate_aggregate_belief_space(
+            n=aggregation_resolution, belief_space_dimension=len(S))
+        belief_T = StoppingGameUtil.generate_aggregate_belief_transition_operator(
+            aggregate_belief_space=aggregate_belief_space, S=S, A=A, O=O, T=T, Z=Z)
+        belief_R = StoppingGameUtil.generate_aggregate_belief_reward_tensor(
+            aggregate_belief_space=aggregate_belief_space, S=S, A=A, R=R)
+        return aggregate_belief_space, A, belief_T, belief_R
+
+    @staticmethod
+    def generate_aggregate_belief_space(n: int, belief_space_dimension: int) -> npt.NDArray[np.float_]:
+        """
+        Generate an aggregate belief space B_n.
+
+        :param n: the aggregation resolution
+        :param belief_space_dimension: the belief space dimension
+        :return: the aggregate belief space
+        """
+
+        # Generate all combinations of integer allocations k_i such that sum(k_i) = n
+        combinations = [k for k in itertools.product(range(n + 1), repeat=belief_space_dimension) if sum(k) == n]
+
+        # Convert integer allocations to belief points by dividing each k_i by n
+        belief_points = [list(k_i / n for k_i in k) for k in combinations]
+
+        # Remove all beliefs that violate the stopping dynamics
+        belief_points = list(filter(lambda x: x[-1] == 1.0 or x[-1] == 0.0, belief_points))
+
+        return np.array(belief_points)
+
+    @staticmethod
+    def generate_aggregate_belief_reward_tensor(
+            aggregate_belief_space: npt.NDArray[np.float_], S: npt.NDArray[np.int_], A: npt.NDArray[np.int_],
+            R: npt.NDArray[np.float_]) -> npt.NDArray[np.float_]:
+        """
+        Generates an aggregate reward tensor for the aggregate belief MDP
+
+        :param aggregate_belief_space: the aggregate belief space
+        :param S: the state space of the POMDP
+        :param A: the action space of the POMDP
+        :param R: the reward tensor of the POMDP
+        :return: the reward tensor of the aggregate belief MDP
+        """
+        belief_R = np.zeros((len(A), len(aggregate_belief_space)))
+        belief_space_list = aggregate_belief_space.tolist()
+        for a in A:
+            for b in aggregate_belief_space:
+                expected_reward = 0
+                for s in S:
+                    expected_reward += R[a][s] * b[s]
+                belief_R[a][belief_space_list.index(b.tolist())] = expected_reward
+        return belief_R
+
+    @staticmethod
+    def generate_aggregate_belief_transition_operator(
+            aggregate_belief_space: npt.NDArray[np.float_], S: npt.NDArray[np.int_], A: npt.NDArray[np.int_],
+            O: npt.NDArray[np.int_], T: npt.NDArray[np.float_], Z: npt.NDArray[np.float_]) -> npt.NDArray[np.float_]:
+        """
+        Generates an aggregate belief space transition operator
+
+        :param aggregate_belief_space: the aggregate belief space
+        :param O: the observation space of the POMDP
+        :param S: the state space of the POMDP
+        :param A: the action space of the POMDP
+        :param T: the transition operator of the POMDP
+        :param Z: the observation tensor of the POMDP
+        :return: the aggregate belief space operator
+        """
+        belief_space_list = aggregate_belief_space.tolist()
+        belief_T = np.zeros((len(A), len(aggregate_belief_space), len(aggregate_belief_space)))
+        for a in A:
+            for b1 in aggregate_belief_space:
+                for b2 in aggregate_belief_space:
+                    belief_T[a][belief_space_list.index(b1.tolist())][belief_space_list.index(b2.tolist())] \
+                        = StoppingGameUtil.aggregate_belief_transition_probability(
+                        b1=b1, b2=b2, a=a, S=S, O=O, T=T, Z=Z, aggregate_belief_space=aggregate_belief_space, A=A)
+        return belief_T
+
+    @staticmethod
+    def aggregate_belief_transition_probability(b1: npt.NDArray[np.float_], b2: npt.NDArray[np.float_], a: int,
+                                                S: npt.NDArray[np.int_], O: npt.NDArray[np.int_],
+                                                A: npt.NDArray[np.int_],
+                                                T: npt.NDArray[np.float_], Z: npt.NDArray[np.float_],
+                                                aggregate_belief_space: npt.NDArray[np.float_]) -> float:
+        """
+        Calculates the probability of transitioning from belief b1 to belief b2 when taking action a
+
+        :param b1: the source belief
+        :param b2: the target belief
+        :param a: the action
+        :param S: the state space of the POMDP
+        :param O: the observation space of the POMDP
+        :param A: the action space of the POMDP
+        :param T: the transition operator
+        :param Z: the observation tensor
+        :param aggregate_belief_space: the aggregate belief space
+        :return: the probability P(b2 | b1, a)
+        """
+        prob = 0
+        for o in O:
+            if sum([Z[a][s_prime][o] * b1[s] * T[a][s][s_prime] for s in S for s_prime in S]) == 0:
+                continue
+            b_prime = StoppingGameUtil.pomdp_next_belief(
+                o=o, a=a, b=b1, states=S, observations=O, observation_tensor=Z, transition_tensor=T)
+            nearest_neighbor = StoppingGameUtil.find_nearest_neighbor_belief(belief_space=aggregate_belief_space,
+                                                                             target_belief=b_prime)
+            if np.array_equal(nearest_neighbor, b2):
+                for s in S:
+                    for s_prime in S:
+                        prob += Z[a][s_prime][o] * b1[s] * T[a][s][s_prime]
+        return prob
+
+    @staticmethod
+    def pomdp_next_belief(o: int, a: int, b: npt.NDArray[np.float64], states: npt.NDArray[np.int_],
+                          observations: npt.NDArray[np.int_], observation_tensor: npt.NDArray[np.float_],
+                          transition_tensor: npt.NDArray[np.float_]) \
+            -> npt.NDArray[np.float64]:
+        """
+        Computes the next belief of the POMDP using a Bayesian filter
+
+        :param o: the latest observation
+        :param a: the latest action of player 1
+        :param b: the current belief
+        :param states: the list of states
+        :param observations: the list of observations
+        :param observation_tensor: the observation tensor
+        :param transition_tensor: the transition tensor
+        :return: the new belief
+        """
+        b_prime = [0.0] * len(states)
+        for s_prime in states:
+            b_prime[s_prime] = StoppingGameUtil.pomdp_bayes_filter(
+                s_prime=s_prime, o=o, a=a, b=b, states=states, observations=observations,
+                transition_tensor=transition_tensor, observation_tensor=observation_tensor)
+        if round(sum(b_prime), 2) != 1:
+            print(f"error, b_prime:{b_prime}, o:{o}, a:{a}, b:{b}")
+        assert round(sum(b_prime), 2) == 1
+        return np.array(b_prime)
+
+    @staticmethod
+    def pomdp_bayes_filter(s_prime: int, o: int, a: int, b: npt.NDArray[np.float64], states: npt.NDArray[np.int_],
+                           observations: npt.NDArray[np.int_], observation_tensor: npt.NDArray[np.float_],
+                           transition_tensor: npt.NDArray[np.float_]) -> float:
+        """
+        A Bayesian filter to compute b[s_prime] of the POMDP
+
+        :param s_prime: the state to compute the belief for
+        :param o: the latest observation
+        :param a: the latest action
+        :param b: the current belief
+        :param states: the list of states
+        :param observations: the list of observations
+        :param observation_tensor: the observation tensor
+        :param transition_tensor: the transition tensor of the POMDP
+        :return: b[s_prime]
+        """
+        norm = 0.0
+        for s in states:
+            for s_prime_1 in states:
+                prob_1 = observation_tensor[a][s_prime_1][o]
+                norm += b[s] * prob_1 * transition_tensor[a][s][s_prime_1]
+        if norm == 0.0:
+            print(f"zero norm, a: {a}, b: {b}, o: {o}")
+            return 0.0
+        temp = 0.0
+
+        for s in states:
+            temp += observation_tensor[a][s_prime][o] * transition_tensor[a][s][s_prime] * b[s]
+        b_prime_s_prime = temp / norm
+        if round(b_prime_s_prime, 2) > 1:
+            print(f"b_prime_s_prime >= 1: {b_prime_s_prime}, a1:{a}, s_prime:{s_prime}")
+        assert round(b_prime_s_prime, 2) <= 1
+        if s_prime == 2 and o != observations[-1]:
+            assert round(b_prime_s_prime, 2) <= 0.01
+        return b_prime_s_prime
+
+    @staticmethod
+    def find_nearest_neighbor_belief(belief_space: npt.NDArray[np.float_], target_belief: npt.NDArray[np.float_]) \
+            -> npt.NDArray[np.float_]:
+        """
+        Finds the nearest neighbor (in the Euclidean sense) of a given belief in a certain belief space
+
+        :param belief_space: the belief to search from
+        :param target_belief: the belief to find the nearest neighbor of
+        :return: the nearest neighbor belief from the belief space
+        """
+
+        # Compute Euclidean distances between the target belief and all points in the belief space
+        distances = np.linalg.norm(belief_space - target_belief, axis=1)
+
+        # Find the index of the minimum distance (break ties consistently by choosing the smallest index)
+        nearest_index = int(np.argmin(distances))
+
+        return np.array(belief_space[nearest_index])

{gym_csle_stopping_game-0.7.2.dist-info → gym_csle_stopping_game-0.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym-csle-stopping-game
-Version: 0.7.2
+Version: 0.7.4
 Summary: OpenAI gym reinforcement learning environment of a Dynkin (Optimal stopping) game in CSLE
 Author: Kim Hammar
 Author-email: hammar.kim@gmail.com
@@ -204,11 +204,11 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: gymnasium>=0.27.1
-Requires-Dist: csle-base>=0.7.2
-Requires-Dist: csle-common>=0.7.2
-Requires-Dist: csle-attacker>=0.7.2
-Requires-Dist: csle-defender>=0.7.2
-Requires-Dist: csle-collector>=0.7.2
+Requires-Dist: csle-base>=0.7.4
+Requires-Dist: csle-common>=0.7.4
+Requires-Dist: csle-attacker>=0.7.4
+Requires-Dist: csle-defender>=0.7.4
+Requires-Dist: csle-collector>=0.7.4
 Provides-Extra: test
 Requires-Dist: pytest>=6.0; extra == "test"
 Requires-Dist: pytest-cov>=2.0; extra == "test"

{gym_csle_stopping_game-0.7.2.dist-info → gym_csle_stopping_game-0.7.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
 gym_csle_stopping_game/__init__.py,sha256=ooy6TjxvBi1sZMEX3_mVlvfskqI5GqwITWzI882tfk0,657
-gym_csle_stopping_game/__version__.py,sha256=0eAFjnFVSWI6_301EfFzaXJIiwNScF9GpeINoCLd-XM,22
+gym_csle_stopping_game/__version__.py,sha256=lBlBxbnftiADKPpC3XRA3jUPjRsVclCd3P95aQ33p_g,22
 gym_csle_stopping_game/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gym_csle_stopping_game/constants/constants.py,sha256=eIoD9eXifZ73kP-lSlvG-IXCpe4n6D-_aDygx0zOr5U,1030
+gym_csle_stopping_game/constants/constants.py,sha256=u8QPVgn51LHpV1BY6jqLN0N1eYPzA8bb87AsorPLApU,1047
 gym_csle_stopping_game/dao/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gym_csle_stopping_game/dao/stopping_game_attacker_mdp_config.py,sha256=kmtrVa2CCVbi5xfd6uPWqMvhGmP8ccrtn1e_VmVvH7k,3494
 gym_csle_stopping_game/dao/stopping_game_config.py,sha256=r77noSBWbP1AeBFiBVmiDeEn58SkBcHGklJStzAEEkE,6641
@@ -12,8 +12,8 @@ gym_csle_stopping_game/envs/stopping_game_env.py,sha256=J9h73alytskNgHxa7LHM83R1
 gym_csle_stopping_game/envs/stopping_game_mdp_attacker_env.py,sha256=UoSDY2U8x3AmOqiquwnAzolsya6bM2vVsAkW7i8ljWk,10878
 gym_csle_stopping_game/envs/stopping_game_pomdp_defender_env.py,sha256=cyC2OuJA41aqE84KA9-oJRWsKLIqzekh8A8zyf6Qo5I,8766
 gym_csle_stopping_game/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gym_csle_stopping_game/util/stopping_game_util.py,sha256=IlgdrQCVjkt4ta2T18Hws3b9vxJFlcywsPgWWmN06H4,13629
-gym_csle_stopping_game-0.7.2.dist-info/METADATA,sha256=XseEpDonN-rwyFUNlzefFfCenxtKjRrozCaMQBhISuY,27252
-gym_csle_stopping_game-0.7.2.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-gym_csle_stopping_game-0.7.2.dist-info/top_level.txt,sha256=3DBHkAEI00nq0aXZlJUkXJrLiwkcJCfaFoYcaOzEZUU,23
-gym_csle_stopping_game-0.7.2.dist-info/RECORD,,
+gym_csle_stopping_game/util/stopping_game_util.py,sha256=sLmXNHrv_HG1kebLHvY8iLRjuJp-2oks9Z6jsdE4gnU,28609
+gym_csle_stopping_game-0.7.4.dist-info/METADATA,sha256=cL-96STBmmQUzEWGoUW-zqXg05-Uuf198DPnEL6y68Q,27252
+gym_csle_stopping_game-0.7.4.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+gym_csle_stopping_game-0.7.4.dist-info/top_level.txt,sha256=3DBHkAEI00nq0aXZlJUkXJrLiwkcJCfaFoYcaOzEZUU,23
+gym_csle_stopping_game-0.7.4.dist-info/RECORD,,