gym-csle-stopping-game 0.9.24__py3-none-any.whl

gym_csle_stopping_game/__init__.py

@@ -0,0 +1,23 @@
+"""
+Register OpenAI Envs
+"""
+from . __version__ import __version__
+from gymnasium.envs.registration import register
+
+register(
+    id='csle-stopping-game-v1',
+    entry_point='gym_csle_stopping_game.envs.stopping_game_env:StoppingGameEnv',
+    kwargs={'config': None}
+)
+
+register(
+    id='csle-stopping-game-mdp-attacker-v1',
+    entry_point='gym_csle_stopping_game.envs.stopping_game_mdp_attacker_env:StoppingGameMdpAttackerEnv',
+    kwargs={'config': None}
+)
+
+register(
+    id='csle-stopping-game-pomdp-defender-v1',
+    entry_point='gym_csle_stopping_game.envs.stopping_game_pomdp_defender_env:StoppingGamePomdpDefenderEnv',
+    kwargs={'config': None}
+)

gym_csle_stopping_game/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.9.24'

gym_csle_stopping_game/constants/constants.py

@@ -0,0 +1,40 @@
+"""
+Constants for gym-csle-stopping-game
+"""
+
+
+class STATIC_DEFENDER_STRATEGIES:
+    """
+    String constants representing static defender strategies
+    """
+    RANDOM = "random"
+
+
+class STATIC_ATTACKER_STRATEGIES:
+    """
+    String constants representing static attacker strategies
+    """
+    RANDOM = "random"
+
+
+class ENV_METRICS:
+    """
+    String constants representing environment metrics
+    """
+    INTRUSION_LENGTH = "intrusion_length"
+    INTRUSION_START = "intrusion_start"
+    WEIGHTED_INTRUSION_PREDICTION_DISTANCE = "weighted_intrusion_prediction_distance"
+    START_POINT_CORRECT = "start_point_correct"
+    INTRUSION_END = "intrusion_end"
+    RETURN = "R"
+    TIME_HORIZON = "T"
+    STOP = "stop"
+    STOPS_REMAINING = "l"
+    STATE = "s"
+    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/dao/stopping_game_attacker_mdp_config.py

@@ -0,0 +1,86 @@
+from typing import Dict, Any
+from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
+from csle_common.dao.simulation_config.simulation_env_input_config import SimulationEnvInputConfig
+from csle_common.dao.training.policy import Policy
+from csle_common.dao.training.random_policy import RandomPolicy
+from csle_common.dao.training.multi_threshold_stopping_policy import MultiThresholdStoppingPolicy
+from csle_common.dao.training.ppo_policy import PPOPolicy
+
+
+class StoppingGameAttackerMdpConfig(SimulationEnvInputConfig):
+    """
+    DTO class representing the configuration of the MDP environnment of the attacker
+    when facing a static defender policy
+    """
+
+    def __init__(self, env_name: str, stopping_game_config: StoppingGameConfig, defender_strategy: Policy,
+                 stopping_game_name: str = "csle-stopping-game-v1"):
+        """
+        Initializes the DTO
+
+        :param env_name: the environment name
+        :param stopping_game_config: the underlying stopping game config
+        :param defender_strategy: the static defender strategy name
+        :param stopping_game_name: the underlying stopping game name
+        """
+        super().__init__()
+        self.env_name = env_name
+        self.stopping_game_config = stopping_game_config
+        self.defender_strategy = defender_strategy
+        self.stopping_game_name = stopping_game_name
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "StoppingGameAttackerMdpConfig":
+        """
+        Converts a dict representation to an instance
+
+        :param d: the dict to convert
+        :return: the created instance
+        """
+        try:
+            defender_strategy = MultiThresholdStoppingPolicy.from_dict(d["defender_strategy"])
+        except Exception:
+            try:
+                defender_strategy = RandomPolicy.from_dict(d["defender_strategy"])
+            except Exception:
+                defender_strategy = PPOPolicy.from_dict(d["defender_strategy"])
+        obj = StoppingGameAttackerMdpConfig(
+            stopping_game_config=StoppingGameConfig.from_dict(d["stopping_game_config"]),
+            defender_strategy=defender_strategy,
+            stopping_game_name=d["stopping_game_name"], env_name=d["env_name"]
+        )
+        return obj
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts the object to a dict representation
+
+        :return: a dict representation of the object
+        """
+        d: Dict[str, Any] = {}
+        d["stopping_game_config"] = self.stopping_game_config.to_dict()
+        d["defender_strategy"] = self.defender_strategy.to_dict()
+        d["stopping_game_name"] = self.stopping_game_name
+        d["env_name"] = self.env_name
+        return d
+
+    def __str__(self):
+        """
+        :return: a string representation of the object
+        """
+        return f"stopping_game_config: {self.stopping_game_config}, defender_strategy:{self.defender_strategy}, " \
+               f"stopping_game_name:{self.stopping_game_name}, env_name: {self.env_name}"
+
+    @staticmethod
+    def from_json_file(json_file_path: str) -> "StoppingGameAttackerMdpConfig":
+        """
+        Reads a json file and converts it to a DTO
+
+        :param json_file_path: the json file path
+        :return: the converted DTO
+        """
+        import io
+        import json
+        with io.open(json_file_path, 'r') as f:
+            json_str = f.read()
+        return StoppingGameAttackerMdpConfig.from_dict(json.loads(json_str))

gym_csle_stopping_game/dao/stopping_game_config.py

@@ -0,0 +1,165 @@
+from typing import Dict, Any
+import gymnasium as gym
+import numpy as np
+import numpy.typing as npt
+from csle_common.dao.simulation_config.simulation_env_input_config import SimulationEnvInputConfig
+
+
+class StoppingGameConfig(SimulationEnvInputConfig):
+    """
+    DTO class containing the configuration of the stopping game
+    """
+
+    def __init__(self, env_name: str,
+                 T: npt.NDArray[Any], O: npt.NDArray[np.int32], Z: npt.NDArray[Any],
+                 R: npt.NDArray[Any], S: npt.NDArray[np.int32], A1: npt.NDArray[np.int32],
+                 A2: npt.NDArray[np.int32], L: int, R_INT: int, R_COST: int, R_SLA: int, R_ST: int,
+                 b1: npt.NDArray[np.float64],
+                 save_dir: str, checkpoint_traces_freq: int, gamma: float = 1, compute_beliefs: bool = True,
+                 save_trace: bool = True) -> None:
+        """
+        Initializes the DTO
+
+        :param env_name: the name of the environment
+        :param T: the transition tensor
+        :param O: the observation space
+        :param Z: the observation tensor
+        :param R: the reward function
+        :param S: the state space
+        :param A1: the action space of the defender
+        :param A2: the action space of the attacker
+        :param L: the maximum number of stops of the defender
+        :param R_INT: the R_INT constant for the reward function
+        :param R_COST: the R_COST constant for the reward function
+        :param R_SLA: the R_SLA constant for the reward function
+        :param R_ST: the R_ST constant for the reward function
+        :param b1: the initial belief
+        :param save_dir: the directory to save artefacts produced by the environment
+        :param checkpoint_traces_freq: how frequently to checkpoint traces to disk
+        :param gamma: the discount factor
+        :param compute_beliefs: boolean flag indicating whether beliefs should be computed or not
+        :param save_trace: boolean flag indicating whether traces should be saved
+        """
+        super().__init__()
+        self.T = T
+        self.O = O
+        self.Z = Z
+        self.R = R
+        self.S = S
+        self.L = L
+        self.R_INT = R_INT
+        self.R_COST = R_COST
+        self.R_SLA = R_SLA
+        self.R_ST = R_ST
+        self.A1 = A1
+        self.A2 = A2
+        self.b1 = b1
+        self.save_dir = save_dir
+        self.env_name = env_name
+        self.checkpoint_traces_freq = checkpoint_traces_freq
+        self.gamma = gamma
+        self.compute_beliefs = compute_beliefs
+        self.save_trace = save_trace
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts the object to a dict representation
+
+        :return: a dict representation of the object
+        """
+        d: Dict[str, Any] = {}
+        d["T"] = list(self.T.tolist())
+        d["O"] = list(self.O.tolist())
+        d["Z"] = list(self.Z.tolist())
+        d["R"] = list(self.R.tolist())
+        d["S"] = list(self.S.tolist())
+        d["L"] = self.L
+        d["R_INT"] = self.R_INT
+        d["R_COST"] = self.R_COST
+        d["R_SLA"] = self.R_SLA
+        d["R_ST"] = self.R_ST
+        d["A1"] = list(self.A1.tolist())
+        d["A2"] = list(self.A2.tolist())
+        d["b1"] = list(self.b1.tolist())
+        d["save_dir"] = self.save_dir
+        d["env_name"] = self.env_name
+        d["checkpoint_traces_freq"] = self.checkpoint_traces_freq
+        d["gamma"] = self.gamma
+        d["compute_beliefs"] = self.compute_beliefs
+        d["save_trace"] = self.save_trace
+        return d
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "StoppingGameConfig":
+        """
+        Converts a dict representation to an instance
+
+        :param d: the dict to convert
+        :return: the created instance
+        """
+        compute_beliefs = False
+        if "compute_beliefs" in d:
+            compute_beliefs = d["compute_beliefs"]
+        save_trace = False
+        if "save_trace" in d:
+            save_trace = d["save_trace"]
+        obj = StoppingGameConfig(
+            T=np.array(d["T"]), O=np.array(d["O"]), Z=np.array(d["Z"]), R=np.array(d["R"]), S=np.array(d["S"]),
+            A1=np.array(d["A1"]), A2=np.array(d["A2"]), L=d["L"], R_INT=d["R_INT"],
+            R_COST=d["R_COST"], R_SLA=d["R_SLA"], R_ST=d["R_ST"], b1=np.array(d["b1"]), save_dir=d["save_dir"],
+            env_name=d["env_name"], checkpoint_traces_freq=d["checkpoint_traces_freq"], gamma=d["gamma"],
+            compute_beliefs=compute_beliefs, save_trace=save_trace
+        )
+        return obj
+
+    def __str__(self) -> str:
+        """
+        :return: a string representation of the object
+        """
+        return f"T:{self.T}, O:{self.O}, Z:{self.Z}, R:{self.R}, S:{self.S}, A1:{self.A1}, A2:{self.A2}, L:{self.L}, " \
+               f"R_INT:{self.R_INT}, R_COST:{self.R_COST}, R_SLA:{self.R_SLA}, R_ST:{self.R_ST}, b1:{self.b1}, " \
+               f"save_dir: {self.save_dir}, env_name: {self.env_name}, " \
+               f"checkpoint_traces_freq: {self.checkpoint_traces_freq}, gamma: {self.gamma}, " \
+               f"compute_beliefs: {self.compute_beliefs}, save_trace: {self.save_trace}"
+
+    def attacker_observation_space(self) -> gym.spaces.Box:
+        """
+        :return: the attacker's observation space
+        """
+        return gym.spaces.Box(low=np.array([np.float64(0), np.float64(0), np.float64(0)]),
+                              high=np.array([np.float64(self.L), np.float64(1), np.float64(2)]),
+                              dtype=np.float64, shape=(3,))
+
+    def defender_observation_space(self) -> gym.spaces.Box:
+        """
+        :return: the defender's observation space
+        """
+        return gym.spaces.Box(low=np.array([np.float64(0), np.float64(0)]),
+                              high=np.array([np.float64(self.L), np.float64(1)]),
+                              dtype=np.float64, shape=(2,))
+
+    def attacker_action_space(self) -> gym.spaces.Discrete:
+        """
+        :return: the attacker's action space
+        """
+        return gym.spaces.Discrete(len(self.A2))
+
+    def defender_action_space(self) -> gym.spaces.Discrete:
+        """
+        :return: the defender's action space
+        """
+        return gym.spaces.Discrete(len(self.A1))
+
+    @staticmethod
+    def from_json_file(json_file_path: str) -> "StoppingGameConfig":
+        """
+        Reads a json file and converts it to a DTO
+
+        :param json_file_path: the json file path
+        :return: the converted DTO
+        """
+        import io
+        import json
+        with io.open(json_file_path, 'r') as f:
+            json_str = f.read()
+        return StoppingGameConfig.from_dict(json.loads(json_str))

gym_csle_stopping_game/dao/stopping_game_defender_pomdp_config.py

@@ -0,0 +1,92 @@
+from typing import Dict, Any
+from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
+from csle_common.dao.simulation_config.simulation_env_input_config import SimulationEnvInputConfig
+from csle_common.dao.training.policy import Policy
+from csle_common.dao.training.random_policy import RandomPolicy
+from csle_common.dao.training.multi_threshold_stopping_policy import MultiThresholdStoppingPolicy
+from csle_common.dao.training.ppo_policy import PPOPolicy
+from csle_common.dao.training.tabular_policy import TabularPolicy
+
+
+class StoppingGameDefenderPomdpConfig(SimulationEnvInputConfig):
+    """
+    DTO class representing the configuration of the POMDP environnment of the defender
+    when facing a static attacker policy
+    """
+
+    def __init__(self, env_name: str, stopping_game_config: StoppingGameConfig, attacker_strategy: Policy,
+                 stopping_game_name: str = "csle-stopping-game-v1"):
+        """
+        Initializes the DTO
+
+        :param env_name: the environment name
+        :param stopping_game_config: The underlying stopping game config
+        :param attacker_strategy: the attacker's strategy name
+        :param stopping_game_name: the name of the underlying stopping game
+        """
+        super().__init__()
+        self.env_name = env_name
+        self.stopping_game_config = stopping_game_config
+        self.attacker_strategy = attacker_strategy
+        self.stopping_game_name = stopping_game_name
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "StoppingGameDefenderPomdpConfig":
+        """
+        Converts a dict representation to an instance
+
+        :param d: the dict to convert
+        :return: the created instance
+        """
+        try:
+            attacker_strategy = MultiThresholdStoppingPolicy.from_dict(d["attacker_strategy"])
+        except Exception:
+            try:
+                attacker_strategy = RandomPolicy.from_dict(d["attacker_strategy"])
+            except Exception:
+                try:
+                    attacker_strategy = PPOPolicy.from_dict(d["attacker_strategy"])
+                except Exception:
+                    attacker_strategy = TabularPolicy.from_dict(d["attacker_strategy"])
+
+        obj = StoppingGameDefenderPomdpConfig(
+            stopping_game_config=StoppingGameConfig.from_dict(d["stopping_game_config"]),
+            attacker_strategy=attacker_strategy, stopping_game_name=d["stopping_game_name"],
+            env_name=d["env_name"]
+        )
+        return obj
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts the object to a dict representation
+        
+        :return: a dict representation of the object
+        """
+        d: Dict[str, Any] = {}
+        d["stopping_game_config"] = self.stopping_game_config.to_dict()
+        d["attacker_strategy"] = self.attacker_strategy.to_dict()
+        d["stopping_game_name"] = self.stopping_game_name
+        d["env_name"] = self.env_name
+        return d
+
+    def __str__(self):
+        """
+        :return:  a string representation of the object
+        """
+        return f"stopping_game_config: {self.stopping_game_config}, " \
+               f"attacker_strategy: {self.attacker_strategy}, stopping_game_name: {self.stopping_game_name}," \
+               f"env_name: {self.env_name}"
+
+    @staticmethod
+    def from_json_file(json_file_path: str) -> "StoppingGameDefenderPomdpConfig":
+        """
+        Reads a json file and converts it to a DTO
+
+        :param json_file_path: the json file path
+        :return: the converted DTO
+        """
+        import io
+        import json
+        with io.open(json_file_path, 'r') as f:
+            json_str = f.read()
+        return StoppingGameDefenderPomdpConfig.from_dict(json.loads(json_str))

gym_csle_stopping_game/dao/stopping_game_state.py

@@ -0,0 +1,98 @@
+from typing import Dict, Any
+import numpy as np
+import numpy.typing as npt
+from gym_csle_stopping_game.util.stopping_game_util import StoppingGameUtil
+from csle_base.json_serializable import JSONSerializable
+
+
+class StoppingGameState(JSONSerializable):
+    """
+    Represents the state of the optimal stopping game
+    """
+
+    def __init__(self, b1: npt.NDArray[np.float64], L: int) -> None:
+        """
+        Intializes the state
+
+        :param b1: the initial belief
+        :param L: the maximum number of stop actions of the defender
+        """
+        self.L = L
+        self.b1 = b1
+        self.b = self.b1.copy()
+        self.l = self.L
+        self.s = StoppingGameUtil.sample_initial_state(b1=self.b1)
+        self.t = 1
+
+    def reset(self) -> None:
+        """
+        Resets the state
+
+        :return: None
+        """
+        self.l = self.L
+        self.t = 1
+        self.s = StoppingGameUtil.sample_initial_state(b1=self.b1)
+        self.b = self.b1.copy()
+
+    def attacker_observation(self) -> npt.NDArray[Any]:
+        """
+        :return: the attacker's observation
+        """
+        return np.array([np.float64(self.l), np.float64(self.b[1]), np.float64(self.s)])
+
+    def defender_observation(self) -> npt.NDArray[Any]:
+        """
+        :return: the defender's observation
+        """
+        return np.array([np.float64(self.l), np.float64(self.b[1])])
+
+    def __str__(self) -> str:
+        """
+        :return: a string representation of the objectn
+        """
+        return f"s:{self.s}, L:{self.L}, l: {self.l}, b:{self.b}, b1:{self.b1}, t:{self.t}"
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "StoppingGameState":
+        """
+        Converts a dict representation to an instance
+
+        :param d: the dict to convert
+        :return: the created instance
+        """
+        obj = StoppingGameState(b1=np.array(d["b1"]), L=d["L"])
+        obj.t = d["t"]
+        obj.l = d["l"]
+        obj.s = d["s"]
+        obj.b = np.array(d["b"])
+        return obj
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts the object to a dict representation
+        
+        :return: a dict representation of the object
+        """
+        d: Dict[str, Any] = {}
+        d["L"] = self.L
+        d["b1"] = list(self.b1)
+        d["b"] = list(self.b)
+        d["l"] = self.l
+        d["s"] = self.s
+        d["t"] = self.t
+        return d
+
+    @staticmethod
+    def from_json_file(json_file_path: str) -> "StoppingGameState":
+        """
+        Reads a json file and converts it to a DTO
+
+        :param json_file_path: the json file path
+        :return: the converted DTO
+        """
+        import io
+        import json
+        with io.open(json_file_path, 'r') as f:
+            json_str = f.read()
+        return StoppingGameState.from_dict(json.loads(json_str))

gym_csle_stopping_game/envs/__init__.py

@@ -0,0 +1 @@
+from gym_csle_stopping_game.envs.stopping_game_env import StoppingGameEnv