gym-csle-stopping-game 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

gym_csle_stopping_game/__version__.py

@@ -1 +1 @@
-__version__ = '0.6.1'
+__version__ = '0.6.3'

gym_csle_stopping_game/envs/stopping_game_env.py

@@ -7,24 +7,10 @@ import math
 import csle_common.constants.constants as constants
 from csle_common.dao.simulation_config.base_env import BaseEnv
 from csle_common.dao.simulation_config.simulation_trace import SimulationTrace
-from csle_common.dao.training.policy import Policy
-from csle_common.dao.emulation_config.emulation_env_state import EmulationEnvState
-from csle_common.dao.emulation_config.emulation_env_config import EmulationEnvConfig
-from csle_common.dao.simulation_config.simulation_env_config import SimulationEnvConfig
-from csle_common.dao.emulation_config.emulation_simulation_trace import EmulationSimulationTrace
-from csle_common.dao.emulation_action.attacker.emulation_attacker_stopping_actions \
-    import EmulationAttackerStoppingActions
-from csle_common.dao.emulation_action.attacker.emulation_attacker_action import EmulationAttackerAction
-from csle_common.dao.emulation_action.defender.emulation_defender_stopping_actions \
-    import EmulationDefenderStoppingActions
-from csle_common.metastore.metastore_facade import MetastoreFacade
-from csle_common.logging.log import Logger
-from csle_system_identification.emulator import Emulator
 from gym_csle_stopping_game.util.stopping_game_util import StoppingGameUtil
 from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
 from gym_csle_stopping_game.dao.stopping_game_state import StoppingGameState
 import gym_csle_stopping_game.constants.constants as env_constants
-from csle_common.dao.emulation_config.emulation_trace import EmulationTrace
 
 
 class StoppingGameEnv(BaseEnv):
@@ -42,7 +28,6 @@ class StoppingGameEnv(BaseEnv):
 
         # Initialize environment state
         self.state = StoppingGameState(b1=self.config.b1, L=self.config.L)
-
         # Setup spaces
         self.attacker_observation_space = self.config.attacker_observation_space()
         self.defender_observation_space = self.config.defender_observation_space()
@@ -73,7 +58,7 @@ class StoppingGameEnv(BaseEnv):
         a1, a2_profile = action_profile
         pi2, a2 = a2_profile
         assert pi2.shape[0] == len(self.config.S)
-        assert pi2.shape[1] == len(self.config.A1)
+        assert pi2.shape[1] == len(self.config.A2)
         done = False
         info: Dict[str, Any] = {}
 
@@ -84,8 +69,7 @@ class StoppingGameEnv(BaseEnv):
         else:
             # Compute r, s', b',o'
             r = self.config.R[self.state.l - 1][a1][a2][self.state.s]
-            self.state.s = StoppingGameUtil.sample_next_state(l=self.state.l, a1=a1, a2=a2,
-                                                              T=self.config.T,
+            self.state.s = StoppingGameUtil.sample_next_state(l=self.state.l, a1=a1, a2=a2, T=self.config.T,
                                                               S=self.config.S, s=self.state.s)
             o = StoppingGameUtil.sample_next_observation(Z=self.config.Z,
                                                          O=self.config.O, s_prime=self.state.s)
@@ -246,95 +230,6 @@ class StoppingGameEnv(BaseEnv):
         info[env_constants.ENV_METRICS.TIME_STEP] = self.state.t
         return (defender_obs, attacker_obs), info
 
-    @staticmethod
-    def emulation_evaluation(env: "StoppingGameEnv", n_episodes: int, intrusion_seq: List[EmulationAttackerAction],
-                             defender_policy: Policy,
-                             attacker_policy: Policy,
-                             emulation_env_config: EmulationEnvConfig,
-                             simulation_env_config: SimulationEnvConfig
-                             ) -> List[EmulationSimulationTrace]:
-        """
-        Utility function for evaluating a strategy profile in the emulation environment
-
-        :param env: the environment to use for evaluation
-        :param n_episodes: the number of evaluation episodes
-        :param intrusion_seq: the intrusion sequence for the evaluation (sequence of attacker actions)
-        :param defender_policy: the defender policy for the evaluation
-        :param attacker_policy: the attacker policy for the evaluation
-        :param emulation_env_config: configuration of the emulation environment for the evaluation
-        :param simulation_env_config: configuration of the simulation environment for the evaluation
-        :return: traces with the evaluation results
-        """
-        logger = Logger.__call__().get_logger()
-        traces = []
-        s = EmulationEnvState(emulation_env_config=emulation_env_config)
-        s.initialize_defender_machines()
-        for i in range(n_episodes):
-            done = False
-            defender_obs_space = simulation_env_config.joint_observation_space_config.observation_spaces[0]
-            b = env.state.b1
-            o, _ = env.reset()
-            (d_obs, a_obs) = o
-            t = 0
-            s.reset()
-            emulation_trace = EmulationTrace(initial_attacker_observation_state=s.attacker_obs_state,
-                                             initial_defender_observation_state=s.defender_obs_state,
-                                             emulation_name=emulation_env_config.name)
-            simulation_trace = SimulationTrace(simulation_env=env.config.env_name)
-            while not done:
-                a1 = defender_policy.action(d_obs)
-                a2 = attacker_policy.action(a_obs)
-                o, r, done, info, _ = env.step((a1, a2))
-                (d_obs, a_obs) = o
-                r_1, r_2 = r
-                logger.debug(f"a1:{a1}, a2:{a2}, d_obs:{d_obs}, a_obs:{a_obs}, r:{r}, done:{done}, info: {info}")
-                if a1 == 0:
-                    defender_action = EmulationDefenderStoppingActions.CONTINUE(index=-1)
-                else:
-                    defender_action = EmulationDefenderStoppingActions.CONTINUE(index=-1)
-                if env.state.s == 1:
-                    if t >= len(intrusion_seq):
-                        t = 0
-                    attacker_action = intrusion_seq[t]
-                else:
-                    attacker_action = EmulationAttackerStoppingActions.CONTINUE(index=-1)
-                emulation_trace, s = Emulator.run_actions(
-                    s=s,
-                    emulation_env_config=emulation_env_config, attacker_action=attacker_action,
-                    defender_action=defender_action, trace=emulation_trace,
-                    sleep_time=emulation_env_config.kafka_config.time_step_len_seconds)
-                o_components = [s.defender_obs_state.snort_ids_alert_counters.severe_alerts,
-                                s.defender_obs_state.snort_ids_alert_counters.warning_alerts,
-                                s.defender_obs_state.aggregated_host_metrics.num_failed_login_attempts]
-                o_components_str = ",".join(list(map(lambda x: str(x), o_components)))
-                logger.debug(f"o_components:{o_components}")
-                logger.debug(f"observation_id_to_observation_vector_inv:"
-                             f"{defender_obs_space.observation_id_to_observation_vector_inv}")
-                logger.debug(f"observation_id_to_observation_vector_inv:"
-                             f"{o_components_str in defender_obs_space.observation_id_to_observation_vector_inv}")
-                emulation_o = 0
-                if o_components_str in defender_obs_space.observation_id_to_observation_vector_inv:
-                    emulation_o = defender_obs_space.observation_id_to_observation_vector_inv[o_components_str]
-                logger.debug(f"o:{emulation_o}")
-                b = StoppingGameUtil.next_belief(o=emulation_o, a1=a1, b=b, pi2=a2, config=env.config,
-                                                 l=env.state.l, a2=a2)
-                d_obs[1] = b[1]
-                a_obs[1] = b[1]
-                logger.debug(f"b:{b}")
-                simulation_trace.defender_rewards.append(r_1)
-                simulation_trace.attacker_rewards.append(r_2)
-                simulation_trace.attacker_actions.append(a2)
-                simulation_trace.defender_actions.append(a1)
-                simulation_trace.infos.append(info)
-                simulation_trace.states.append(s)
-                simulation_trace.beliefs.append(b[1])
-                simulation_trace.infrastructure_metrics.append(emulation_o)
-
-            em_sim_trace = EmulationSimulationTrace(emulation_trace=emulation_trace, simulation_trace=simulation_trace)
-            MetastoreFacade.save_emulation_simulation_trace(em_sim_trace)
-            traces.append(em_sim_trace)
-        return traces
-
     def render(self, mode: str = 'human'):
         """
         Renders the environment.  Supported rendering modes: (1) human; and (2) rgb_array
@@ -437,6 +332,8 @@ class StoppingGameEnv(BaseEnv):
         :param l: the number of stops remaining
         :return: the observation
         """
+        if not history:
+            raise ValueError("History must not be empty")
         return [history[-1]]
 
     def generate_random_particles(self, o: int, num_particles: int) -> List[int]:

gym_csle_stopping_game/envs/stopping_game_pomdp_defender_env.py

@@ -4,12 +4,7 @@ import numpy.typing as npt
 from csle_common.dao.simulation_config.base_env import BaseEnv
 from gym_csle_stopping_game.dao.stopping_game_defender_pomdp_config import StoppingGameDefenderPomdpConfig
 from csle_common.dao.simulation_config.simulation_trace import SimulationTrace
-from csle_common.dao.training.policy import Policy
-from csle_common.dao.emulation_config.emulation_env_config import EmulationEnvConfig
-from csle_common.dao.simulation_config.simulation_env_config import SimulationEnvConfig
-from csle_common.dao.emulation_config.emulation_simulation_trace import EmulationSimulationTrace
 from csle_common.dao.emulation_config.emulation_trace import EmulationTrace
-from csle_common.dao.emulation_action.attacker.emulation_attacker_action import EmulationAttackerAction
 from gym_csle_stopping_game.envs.stopping_game_env import StoppingGameEnv
 from gym_csle_stopping_game.util.stopping_game_util import StoppingGameUtil
 
@@ -103,28 +98,6 @@ class StoppingGamePomdpDefenderEnv(BaseEnv):
         defender_obs = o[0]
         return defender_obs, r[0], d, info
 
-    @staticmethod
-    def emulation_evaluation(env: "StoppingGamePomdpDefenderEnv",
-                             n_episodes: int, intrusion_seq: List[EmulationAttackerAction],
-                             defender_policy: Policy,
-                             emulation_env_config: EmulationEnvConfig, simulation_env_config: SimulationEnvConfig) \
-            -> List[EmulationSimulationTrace]:
-        """
-        Utility function for evaluating policies in the emulation environment
-
-        :param env: the environment to use for evaluation
-        :param n_episodes: the number of episodes to use for evaluation
-        :param intrusion_seq: the sequence of intrusion actions to use for evaluation
-        :param defender_policy: the defender policy to use for evaluation
-        :param emulation_env_config: the configuration of the emulation environment to use for evaluation
-        :param simulation_env_config: the configuration of the simulation environment to use for evaluation
-        :return: traces with the evaluation results
-        """
-        return StoppingGameEnv.emulation_evaluation(
-            env=env.stopping_game_env, n_episodes=n_episodes, intrusion_seq=intrusion_seq,
-            defender_policy=defender_policy, attacker_policy=env.static_attacker_strategy,
-            emulation_env_config=emulation_env_config, simulation_env_config=simulation_env_config)
-
     def is_defense_action_legal(self, defense_action_id: int) -> bool:
         """
         Checks whether a defender action in the environment is legal or not

{gym_csle_stopping_game-0.6.1.dist-info → gym_csle_stopping_game-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym-csle-stopping-game
-Version: 0.6.1
+Version: 0.6.3
 Summary: OpenAI gym reinforcement learning environment of a Dynkin (Optimal stopping) game in CSLE
 Author: Kim Hammar
 Author-email: hammar.kim@gmail.com
@@ -15,11 +15,11 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.8
 Requires-Dist: gymnasium >=0.27.1
-Requires-Dist: csle-base >=0.6.1
-Requires-Dist: csle-common >=0.6.1
-Requires-Dist: csle-attacker >=0.6.1
-Requires-Dist: csle-defender >=0.6.1
-Requires-Dist: csle-collector >=0.6.1
+Requires-Dist: csle-base >=0.6.3
+Requires-Dist: csle-common >=0.6.3
+Requires-Dist: csle-attacker >=0.6.3
+Requires-Dist: csle-defender >=0.6.3
+Requires-Dist: csle-collector >=0.6.3
 Provides-Extra: testing
 Requires-Dist: pytest >=6.0 ; extra == 'testing'
 Requires-Dist: pytest-cov >=2.0 ; extra == 'testing'

{gym_csle_stopping_game-0.6.1.dist-info → gym_csle_stopping_game-0.6.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 gym_csle_stopping_game/__init__.py,sha256=ooy6TjxvBi1sZMEX3_mVlvfskqI5GqwITWzI882tfk0,657
-gym_csle_stopping_game/__version__.py,sha256=gd3s3RotD0_KL90Tua-YkOr60Jm2C2_wvlEhAT08068,22
+gym_csle_stopping_game/__version__.py,sha256=0ICX8PeSmWoiPyIEViMxRYkvCjQE1KvQPJp9o52KRjw,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/dao/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -8,12 +8,12 @@ gym_csle_stopping_game/dao/stopping_game_config.py,sha256=0_CtrFod1NkZ5eqlwIq68I
 gym_csle_stopping_game/dao/stopping_game_defender_pomdp_config.py,sha256=3FfNi2-R6n1LqjA644EVq-v7wtp6sqyEkEdBN90-2n0,3753
 gym_csle_stopping_game/dao/stopping_game_state.py,sha256=v9jEG7-reOQTkSyTZH64jCZ8IyixXFEIk4HIcmhBHiw,2828
 gym_csle_stopping_game/envs/__init__.py,sha256=SQHaqXI0_2HYsC8i9swXEHDFcXKEYpb8GRP9l_S0Sw8,74
-gym_csle_stopping_game/envs/stopping_game_env.py,sha256=g3Pxu-zzgBKFLIQioxenzqyV8gLwB3JJP3mOul6-oq4,22753
+gym_csle_stopping_game/envs/stopping_game_env.py,sha256=J9h73alytskNgHxa7LHM83R1PUNIALDoy0PCItA4P9k,16403
 gym_csle_stopping_game/envs/stopping_game_mdp_attacker_env.py,sha256=bgoddSXUT-TkDN5T8jJljsul4CRYiPRW7VMmtM7QrwU,10877
-gym_csle_stopping_game/envs/stopping_game_pomdp_defender_env.py,sha256=sX680Blqqw69NcXTOypBE97LyR9jLZAumBie5iSjPGc,10580
+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=s3a5jkUlbh_2K6ALz5riE1w9gfdosf4N3yvrNMBxHUg,11363
-gym_csle_stopping_game-0.6.1.dist-info/METADATA,sha256=74argq-Wvchtc2bvAZxh3IYnM_QMlKgBi3WMwMQOOYA,2162
-gym_csle_stopping_game-0.6.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-gym_csle_stopping_game-0.6.1.dist-info/top_level.txt,sha256=3DBHkAEI00nq0aXZlJUkXJrLiwkcJCfaFoYcaOzEZUU,23
-gym_csle_stopping_game-0.6.1.dist-info/RECORD,,
+gym_csle_stopping_game-0.6.3.dist-info/METADATA,sha256=5j9Qu1NsKZodVZRT970CeQ_BIOvc2DNeFENLMb404LQ,2162
+gym_csle_stopping_game-0.6.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+gym_csle_stopping_game-0.6.3.dist-info/top_level.txt,sha256=3DBHkAEI00nq0aXZlJUkXJrLiwkcJCfaFoYcaOzEZUU,23
+gym_csle_stopping_game-0.6.3.dist-info/RECORD,,