pyjevsim 1.0.0__py3-none-any.whl

pyjevsim/definition.py

@@ -0,0 +1,102 @@
+"""
+Author: Changbeom Choi (@cbchoi)
+Copyright (c) 2014-2020 Handong Global University
+Copyright (c) 2021-2024 Hanbat National University
+License: MIT.  The full license text is available at:
+https://github.com/eventsim/pyjevsim/blob/main/LICENSE
+
+This module contains definitions for pyjevsim's const and type. 
+"""
+from enum import Enum
+
+# Define an infinite value
+Infinite = float("inf")
+
+class AttributeType(Enum):
+    """Enum for attribute types."""
+    ASPECT = 1
+    RUNTIME = 2
+    UNKNOWN_TYPE = -1
+
+    @staticmethod
+    def resolve_type_from_str(name):
+        """Resolves an attribute type from a string.
+        
+        Args:
+            name (str): The name of the attribute type 
+        Returns:
+            AttributeType: The resolved attribute type 
+        """
+        
+        if "ASPECT" == name.upper():
+            return AttributeType.ASPECT
+        elif "RUNTIME" == name.upper():
+            return AttributeType.RUNTIME
+        else:
+            return AttributeType.UNKNOWN_TYPE
+
+    @staticmethod
+    def resolve_type_from_enum(enum):
+        """Resolves an attribute type to a string.
+        
+        Args:
+            enum (AttributeType): The attribute type enum 
+        Returns:
+            str: The name of the attribute type 
+        """
+        if enum == AttributeType.ASPECT:
+            return "ASPECT"
+        elif enum == AttributeType.RUNTIME:
+            return "RUNTIME"
+        else:
+            return "UNKNOWN"
+
+class SimulationMode(Enum):
+    """Enum for simulation modes."""
+    
+    SIMULATION_IDLE = (
+        0  # Simulation Engine is instantiated but simulation is not running
+    )
+    SIMULATION_RUNNING = 1  # Simulation Engine is instantiated, simulation is running 
+    SIMULATION_TERMINATED = (
+        2  # Simulation Engine is instantiated but simulation is terminated
+    )
+    SIMULATION_PAUSE = 3  # Simulation Engine is instantiated, simulation paused 
+    SIMULATION_UNKNOWN = -1  # Simulation Engine went to abnormal state
+
+
+class ModelType(Enum):
+    """Enum for model types."""
+    
+    BEHAVIORAL = 0 #BehaviorModel type : DEVS Atomic Model
+    STRUCTURAL = 1 #StructuralModel type : DEVS Coupled Model
+    UTILITY = 2 
+
+
+class ExecutionType(Enum):
+    """Enum for execution types."""
+
+    R_TIME = 0 #Real time
+    V_TIME = 1 #Virtual time
+    HLA_TIME = 2 #HLA/RTI-controlled time (externally driven)
+
+
+class SingletonType(object):
+    """A decorator for making a class a singleton."""
+    
+    def __call__(self, cls, *args, **kwargs):
+        """Creates or returns the singleton instance of the class.
+        
+        Args:
+            cls (type): The class to be instantiated
+            *args: Variable length argument list 
+            **kwargs: Arbitrary keyword arguments
+        
+        Returns:
+            object: The singleton instance of the class
+        """
+        try:
+            return cls.__instance
+        except AttributeError:
+            cls.__instance = super(SingletonType, cls).__call__(*args, **kwargs)
+            return cls.__instance

pyjevsim/executor.py

@@ -0,0 +1,27 @@
+"""
+Author: Changbeom Choi (@cbchoi)
+Copyright (c) 2014-2020 Handong Global University
+Copyright (c) 2021-2024 Hanbat National University
+License: MIT.  The full license text is available at:
+https://github.com/eventsim/pyjevsim/blob/main/LICENSE
+
+This module contains Executor, the parent class of all Executor Types. 
+"""
+
+class Executor:
+    """Base class for executors."""
+    def __init__(self, itime, dtime, ename, model, parent):
+        """
+        Args:
+            itime (float): Instance creation time
+            dtime (float): Destruction time
+            ename (str): Engine name
+        """
+        self.engine_name = ename
+        self._instance_t = itime
+        self._destruct_t = dtime
+        self.model = model
+        self.parent = parent
+
+    def __lt__(self, other):
+        return (self.request_time, self.get_obj_id()) < (other.request_time, other.get_obj_id())

pyjevsim/executor_factory.py

@@ -0,0 +1,77 @@
+"""
+Author: Changbeom Choi (@cbchoi)
+Copyright (c) 2014-2020 Handong Global University
+Copyright (c) 2021-2024 Hanbat National University
+License: MIT.  The full license text is available at:
+https://github.com/eventsim/pyjevsim/blob/main/LICENSE
+
+This module contains an ExecutorFactory that decorates an object of type Model into an Executor that is executable by a SysExecutor. 
+"""
+
+from .definition import ModelType
+from .behavior_executor import BehaviorExecutor
+
+class ExecutorFactory:
+    """Factory class to create different types of executors."""
+    
+    def __init__(self):
+        pass
+
+    def create_executor(self, global_time, ins_t, des_t, en_name, model, parent
+    ):
+        """Creates an executor based on the model type.
+
+        Args:
+            global_time (float): Global simulation time
+            ins_t (float): Instance creation time
+            des_t (float): Destruction time
+            en_name (str): Engine name
+            model(ModelType.BEHAVIORAL of ModelType.STRUCTURAL): The model to execute
+
+        Returns:
+            Executor: The created executor
+        """
+        if model.get_model_type() == ModelType.BEHAVIORAL:
+            return self.create_behavior_executor(
+                global_time, ins_t, des_t, en_name, model, parent
+            )
+        elif model.get_model_type() == ModelType.STRUCTURAL:
+            return self.create_structural_executor(
+                global_time, ins_t, des_t, en_name, model, parent
+            )
+        else:
+            return None
+
+    def create_behavior_executor(self, _, ins_t, des_t, en_name, model, parent):
+        """Create BehaviorModelexecutor
+
+        Args:
+            _ (float): Unused global time
+            ins_t (float): Instance creation time 
+            des_t (float): Destruction time
+            en_name (str): SysExecutor name 
+            model (BehaviorModel): Behavior model to execute
+
+        Returns:
+            BehaviorModelExecutor: The created BehaviorModelexecutor
+        """
+        return BehaviorExecutor(ins_t, des_t, en_name, model, parent)
+
+    def create_structural_executor(self, global_time, ins_t, des_t, en_name, model, parent):
+        """Create StructuralModelExecutor
+
+        Args:
+            global_time (float): Global simulation time
+            ins_t (float): Instance creation time 
+            des_t (float): Destruction time
+            en_name (str): SysExecutor name
+            model (StructuralModel): StructuralModel to execute
+
+        Returns:
+            StructuralModelExecutor: created StructuralModelExecutor 
+        """
+        from .structural_executor import StructuralExecutor
+        return StructuralExecutor(
+            global_time, ins_t, des_t, en_name, model, parent, self 
+        )
+    

pyjevsim/exgen.py

@@ -0,0 +1,116 @@
+relay_example = """from pyjevsim import BehaviorModel, SysExecutor, SysMessage, Infinite, ExecutionType
+import datetime
+
+class PEG(BehaviorModel):
+    def __init__(self, name):
+        BehaviorModel.__init__(self, name)
+        self.init_state("Wait")
+        self.insert_state("Wait", Infinite)
+        self.insert_state("Generate", 1)
+
+        self.insert_input_port("start")
+        self.insert_output_port("process")
+
+    def ext_trans(self, port, msg):
+        if port == "start":
+            print(f"[Gen][IN]: {datetime.datetime.now()}")
+            self._cur_state = "Generate"
+
+    def output(self, msg_deliver):
+        msg = SysMessage(self.get_name(), "process")
+        msg.insert(f"[Gen][OUT]: {datetime.datetime.now()}")
+        msg_deliver.insert_message(msg)
+
+    def int_trans(self):
+        if self._cur_state == "Generate":
+            self._cur_state = "Generate"
+
+class MsgRecv(BehaviorModel):
+    def __init__(self, name):
+        BehaviorModel.__init__(self, name)
+
+        self.init_state("Wait")
+        self.insert_state("Wait", Infinite)
+        self.insert_input_port("recv")
+
+    def ext_trans(self, port, msg):
+        if port == "recv":
+            print(f"[MsgRecv][IN]: {datetime.datetime.now()}")
+            data = msg.retrieve()
+            print(data[0])
+            self._cur_state = "Wait"
+
+    def output(self, msg_deliver):
+        pass
+
+    def int_trans(self):
+        if self._cur_state == "Wait":
+            self._cur_state = "Wait"
+
+# System Executor Initialization
+se = SysExecutor(1, ex_mode=ExecutionType.R_TIME)
+se.insert_input_port("start")
+gen = PEG("Gen")
+se.register_entity(gen)
+proc = MsgRecv("Proc")
+se.register_entity(proc)
+se.coupling_relation(None, "start", gen, "start")
+se.coupling_relation(gen, "process", proc, "recv")
+se.insert_external_event("start", None)
+se.simulate(5)
+"""
+
+periodic_example = """from pyjevsim import BehaviorModel, SysExecutor, Infinite, ExecutionType
+import datetime
+
+class PEx(BehaviorModel):
+    def __init__(self, name):
+        BehaviorModel.__init__(self, name)
+        self.init_state("Wait")
+        self.insert_state("Wait", Infinite)
+        self.insert_state("Generate", 1)
+
+        self.insert_input_port("start")
+
+    def ext_trans(self, port, msg):
+        if port == "start":
+            print(f"[Gen][IN]: {datetime.datetime.now()}")
+            self._cur_state = "Generate"
+
+    def output(self, msg_deliver):
+        print(f"[Gen][OUT]: {datetime.datetime.now()}")
+
+    def int_trans(self):
+        if self._cur_state == "Generate":
+            self._cur_state = "Generate"
+
+
+se = SysExecutor(1, ex_mode=ExecutionType.R_TIME)
+se.insert_input_port("start")
+gen = PEx("Gen")
+se.register_entity(gen)
+se.coupling_relation(None, "start", gen, "start")
+se.insert_external_event("start", None)
+se.simulate(5)
+"""
+
+usage = """
+Usage: python -m pyjevsim.exgen [example]
+
+types of example:
+   periodic:\t Prints event log periodically
+   relay: \t A model sends an output event and another model receives the event
+"""
+import sys
+if len(sys.argv) != 2:
+    print(usage)
+elif sys.argv[1] == "relay":
+    with open("example_relay.py", "w") as f:
+        f.write(relay_example)
+    print("Generated: example_relay.py")
+elif sys.argv[1] == "periodic":
+    with open("example_periodic.py", "w") as f:
+        f.write(periodic_example)
+    print("Generated: example_periodic.py")
+else:
+    print(usage)

pyjevsim/message_deliverer.py

@@ -0,0 +1,44 @@
+from .definition import *
+from .system_message import SysMessage
+
+class MessageDeliverer:
+    def __init__(self):
+        self.data_list = []
+
+    def insert_message(self, msg):
+        """
+        Inserts a message into the data list.
+       
+        Args:
+            msg: Message object to be inserted.
+        """
+        self.data_list.append(msg) #SysMessage type
+
+        #self.data_list.sort(key=lambda m: m.get_scheduled_time())
+
+    def has_contents(self):
+        """
+        Checks if the data list contains any messages.
+
+        Returns:
+            bool: True if the list is not empty, otherwise False.
+        """
+        return len(self.data_list) > 0
+
+    def get_contents(self):
+        """
+        Retrieves the list of messages.
+
+        Returns:
+            list: The list of Message objects.
+        """
+        return self.data_list
+
+    def get_first_event_time(self):
+        """
+        Retrieves the scheduled time of the first message in the list.
+
+        Returns:
+            float: Scheduled time of the first message or Infinity if the list is empty.
+        """
+        return float("inf") if not self.data_list else self.data_list[0].get_scheduled_time()

pyjevsim/restore_handler.py

@@ -0,0 +1,116 @@
+"""
+Author: Changbeom Choi (@cbchoi)
+Copyright (c) 2014-2020 Handong Global University
+Copyright (c) 2021-2024 Hanbat National University
+License: MIT.  The full license text is available at:
+https://github.com/eventsim/pyjevsim/blob/main/LICENSE
+
+"""
+from dill import load, loads
+from .definition import ModelType, ExecutionType
+import json
+import ast
+from .system_executor import SysExecutor
+
+class RestoreHandler():
+    """ Restore a snapshotted model or project.
+    """
+    def __init__(self, t_resol=1, ex_mode=ExecutionType.V_TIME, name="project", path="./snapshot"):
+        """
+        Initializes the RestoreHandler with time resolution, execution mode, name, and path.
+
+        Args:
+            t_resol (float): Time resolution
+            ex_mode (R_TIME or V_TIME): Execution mode(Real time or Virtual time)
+            name (str): Name of SysExecutor
+            path (str, optional): Path to load snapshots
+        """
+        self.path = f"{path}/{name}"
+        self.sim_name = name
+        self.engine = SysExecutor(t_resol, name, ex_mode, snapshot_manager=None)
+        self.model_map = {}
+        pass
+        
+    def restore_engine(self):
+        """
+        Sets up SysExecutor with the relation map and model map.
+        """
+        with open(f"{self.path}/relation_map.json", "r") as f:
+            relation = json.load(f)   
+        relation = {ast.literal_eval(key): ast.literal_eval(value) for key, value in relation.items()}
+
+        model_list = {}
+        with open(f"{self.path}/model_map.json", "r") as f:
+            model_list = json.load(f)  
+        model_list = model_list["model_name"]
+
+        self.load_models(model_list)
+        self.relations(relation)
+
+    def load_models(self, model_list):
+        """
+        Loads models from files and registers them with SysExecutor.
+        
+        Args:
+            model_list (list): List of model names
+        """
+        for model_name in model_list:
+            with open(f"{self.path}/{model_name}.simx", "rb") as f:
+                model = load(f)
+            
+            self.model_map[model_name] = model["data"]
+            self.engine.register_entity(model["data"])
+
+    def relations(self, relation_map):
+        """
+        Sets up coupling relations in SysExecutor.
+        
+        Args:
+            relation_map (dict): The relation map / 관계 맵
+        """
+        for key, value in relation_map.items():
+            if key[0] in self.model_map.keys():
+                output_model = self.model_map[key[0]]
+            else:
+                output_model = self.engine
+            for model in value:
+                if model[0]:
+                    input_model = self.model_map[model[0]]
+                else:
+                    input_model = self.engine
+                self.engine.coupling_relation(output_model, key[1], input_model, model[1])
+
+    def get_engine(self):
+        """Returns the SysExecutor.
+
+        Returns:
+            Restored SysExecutor
+        """
+        self.restore_engine()
+        return self.engine
+    
+    def load_snapshot(self, name, shotmodel):
+        """Loads BehaviorModel.
+        
+        Args:
+            name (str): The name of Model
+            shotmodel (bytes): Binary data of the model snapshot
+        
+        Returns:
+            object(BehaivorModel): The loaded model
+        
+        Raises:
+            Exception: If the model type is not ModelType.BEHAVIORAL
+        """
+        model_info = loads(shotmodel)
+        
+        if model_info["type"] != ModelType.BEHAVIORAL and model_info["type"] != ModelType.STRUCTURAL :
+            raise Exception(f"{model_info['name']} is not of Model type")
+        
+        model = model_info["data"]
+                    
+        if name is not None:
+            model.set_name(name)
+            
+        return model
+    

pyjevsim/snapshot_condition.py

@@ -0,0 +1,101 @@
+"""
+Author: Changbeom Choi (@cbchoi)
+Copyright (c) 2014-2020 Handong Global University
+Copyright (c) 2021-2024 Hanbat National University
+License: MIT.  The full license text is available at:
+https://github.com/eventsim/pyjevsim/blob/main/LICENSE
+"""
+from abc import abstractmethod, abstractstaticmethod
+
+class SnapshotCondition:
+    """A class for filling in the snapshot condition of a model.
+    Users inherit from SnapshotCondition to fill in the model snapshot condition.
+    Snapshot conditions can be placed before or after functions in the behavior model.  
+    """
+    @abstractstaticmethod
+    def create_executor(behavior_executor) :
+        """
+        This method is an abstractstatic method.
+        Specify the SnapshotCondition you created as the return value of this method.
+        
+        Args:
+            behavior_executor (BehaviorExecutor): Set the BehaviorExecutor of the BehaviorModel you want to snapshot.
+        Returns:
+            SnapshotCondition : Returns the SnapshotCondition as configured by the user.
+        """
+        return SnapshotCondition(behavior_executor)
+    
+    def __init__(self, behavior_executor):
+        """
+        Args:
+            behavior_executor (BehaviorExecutor): Set the BehaviorExecutor of the BehaviorModel you want to snapshot.
+        """
+        self.behavior_executor = behavior_executor
+        
+    @abstractmethod
+    def snapshot_time_condition(self, global_time):
+        """Abstract method for snapshot time condition.
+        
+        Args:
+            global_time (float): The global time / simulation time
+        """
+        return False
+
+    @abstractmethod
+    def snapshot_pre_condition_ext(self, port, msg, cur_state):
+        """Abstract method for pre-condition of external transition snapshot.
+
+        Args:
+            port (str): The port name
+            msg (SysMessage): The message
+            cur_state (str): The current state
+        """
+        return False
+
+    @abstractmethod
+    def snapshot_post_condition_ext(self, port, msg, cur_state):
+        """Abstract method for post-condition of external transition snapshot.
+
+        Args:
+            port (str): The port name
+            msg (SysMessage): The message
+            cur_state (str): The current state
+        """
+        return False
+
+    @abstractmethod
+    def snapshot_pre_condition_int(self, cur_state):
+        """Abstract method for pre-condition of internal transition snapshot.
+
+        Args:
+            cur_state (str): The current state
+        """
+        return False
+
+    @abstractmethod
+    def snapshot_post_condition_int(self, cur_state):
+        """Abstract method for post-condition of internal transition snapshot.
+        
+        Args:
+            cur_state (str): The current state
+        """
+        return False
+
+    @abstractmethod
+    def snapshot_pre_condition_out(self, cur_state):
+        """Abstract method for pre-condition of output snapshot.
+        
+        Args:
+            cur_state (str): The current state
+        """
+        return False
+
+    @abstractmethod
+    def snapshot_post_condition_out(self, msg, cur_state):
+        """Abstract method for post-condition of output snapshot.
+        
+        Args:
+            msg (SysMessage): The message
+            cur_state (str): The current state
+        """
+        return False