pyjevsim 1.0.0__py3-none-any.whl

pyjevsim/__init__.py

@@ -0,0 +1,41 @@
+"""
+ Author: Changbeom Choi (@cbchoi)
+ Copyright (c) 2014-2020 Handong Global University
+ Copyright (c) 2014-2020 Hanbat National University
+ License: MIT.  The full license text is available at:
+  - https://github.com/eventsim/pyjevsim/blob/main/LICENSE
+"""
+__author__ = "me@cbchoi.info"
+__all__ = [
+    "behavior_model",
+    "behavior_executor",
+    "core_model",
+    "default_message_catcher",
+    "definition",
+    "executor_factory",
+    "executor",
+    "structural_model",
+    "structural_executor",
+    "executor_factory",
+    "system_executor",
+    "system_message",
+    "system_object",
+    "termination_manager",
+    "snapshot_manager"
+]
+
+from .definition import (
+    AttributeType,
+    Infinite,
+    ModelType,
+    ExecutionType,
+    SimulationMode,
+    SingletonType,
+)
+
+from .system_executor import SysExecutor
+from .system_message import SysMessage
+from .behavior_model import BehaviorModel
+from .structural_model import StructuralModel
+from .snapshot_manager import SnapshotManager
+from .restore_handler import RestoreHandler

pyjevsim/atomic_model.py

@@ -0,0 +1,39 @@
+"""
+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 a BehaivorModel object that allows you to implement the Discrete Event System Specification AtomicModel. 
+"""
+
+from abc import abstractmethod
+from collections import OrderedDict
+
+from .behavior_model import BehaviorModel
+from .definition import ModelType
+
+class AtomicModel(BehaviorModel):
+	def __init__(self, _name=""):
+		super().__init__(_name)
+
+	@abstractmethod
+	def ext_trans(self, port, msg):
+		"""Defines the external transition, to be implemented by subclasses"""
+		pass
+
+	@abstractmethod
+	def int_trans(self):
+		"""Defines the internal transition, to be implemented by subclasses"""
+		pass
+
+	@abstractmethod
+	def output(self, msg_deliver):
+		"""Defines the output function, to be implemented by subclasses"""
+		pass
+
+	@abstractmethod
+	def time_advance(self):
+		"""Defines the output function, to be implemented by subclasses"""
+		return -1

pyjevsim/behavior_executor.py

@@ -0,0 +1,126 @@
+"""
+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 a BehaviorExecutor, an object for executing a BehaviorModel.
+"""
+
+from .definition import Infinite
+from .executor import Executor
+
+class BehaviorExecutor(Executor):
+    """
+    A decorated form of the BehaviorModel, ready to be executed by the SysExecutor.
+    Manages the simulation time of the BehaviorModel and the information in the SysExecutor.
+
+    Args:
+        itime (int or Infinite): Time of instance creation
+        dtime (int or Infinite): Time of instance destruction
+        ename (str): SysExecutor name
+        behavior_model (ModelType.BEHAVIORAL): Behavior Model
+    """
+    def __init__(self, itime=Infinite, dtime=Infinite, ename="default", behavior_model=None, parent=None):
+        super().__init__(itime, dtime, ename, behavior_model, parent)
+
+        self._next_event_t = 0  # Next event time
+        self._cur_state = ""  # Current state of the behavior executor
+        self.request_time = float("inf")  # Request time initialized to infinity
+
+        self.behavior_model = behavior_model #Behavior Model
+        self._cancel_reschedule_f = False #cancel reschedule flag
+
+    def set_global_time(self, gtime):
+        """Sets the global time for the executor and behavior model"""
+        self.global_time = gtime
+        self.behavior_model.set_global_time(gtime)
+        
+    def get_core_model(self):
+        """Returns the core behavior model"""
+        return self.behavior_model
+
+    def __str__(self):
+        """Returns a string representation of the executor"""
+        return f"[N]:{self.get_name()}, [S]:{self._cur_state}"
+
+    def get_name(self):
+        """Returns the name of the behavior model"""
+        return self.behavior_model.get_name()
+
+    def get_engine_name(self):
+        """Returns the name of the engine"""
+        return self.engine_name
+
+    def set_engine_name(self, engine_name):
+        """Sets the name of the engine"""
+        self.engine_name = engine_name
+
+    def get_create_time(self):
+        """Returns the instance creation time"""
+        return self._instance_t
+
+    def get_destruct_time(self):
+        """Returns the destruction time"""
+        return self._destruct_t
+
+    def get_obj_id(self):
+        """Returns the object ID of the behavior model"""
+        return self.behavior_model.get_obj_id()
+
+    # State management
+    def get_cur_state(self):
+        """Returns the current state of the executor"""
+        return self._cur_state
+
+    def init_state(self, state):
+        """Initializes the state of the executor"""
+        self._cur_state = state
+
+    # External Transition
+    def ext_trans(self, port, msg):
+        """Handles external transition based on port and message"""
+        if self.behavior_model.get_cancel_flag():
+            self._cancel_reschedule_f = True
+
+        self.behavior_model.ext_trans(port, msg)
+
+    # Internal Transition
+    def int_trans(self):
+        """Handles internal transition"""
+        self.behavior_model.int_trans()
+
+    # Output Function
+    def output(self, msg_deliver):
+        """Executes the output function of the behavior model"""
+        return self.behavior_model.output(msg_deliver)
+
+    # Time Advance Function
+    def time_advance(self):
+        """Returns the time advance value for the current state"""
+        if self.behavior_model._cur_state in self.behavior_model._states:
+            return self.behavior_model._states[self.behavior_model._cur_state]
+
+        return -1
+
+    def set_req_time(self, global_time):
+        """Sets the request time based on the global time and time advance"""
+        self.set_global_time(global_time)
+        if self.time_advance() == Infinite:
+            self._next_event_t = Infinite
+            self.request_time = Infinite
+        else:
+            if self._cancel_reschedule_f:
+                self.request_time = min(self._next_event_t, global_time + self.time_advance())
+            else:
+                self.request_time = global_time + self.time_advance()
+
+    def get_req_time(self):
+        """Returns the request time and resets the cancel flag if necessary"""
+        if self._cancel_reschedule_f:
+            self._cancel_reschedule_f = False
+            self.behavior_model.reset_cancel_flag()
+        self._next_event_t = self.request_time
+        return self.request_time
+    

pyjevsim/behavior_model.py

@@ -0,0 +1,260 @@
+"""
+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 a BehaivorModel object that allows you to implement the Discrete Event System Specification AtomicModel. 
+"""
+
+from abc import abstractmethod
+from collections import OrderedDict
+
+from .core_model import CoreModel
+from .definition import ModelType
+
+class BehaviorModel(CoreModel):
+    """BehaviorModel template to inherit when constructing a new Model.
+
+    Args:
+        _name (str): Unique model name
+    """   
+    def __init__(self, _name=""):
+
+        super().__init__(_name, ModelType.BEHAVIORAL)
+        self._states = {}
+
+        # External transition map
+        self.external_transition_map_tuple = {} 
+        self.external_transition_map_state = {}
+        
+        # Internal transition map
+        self.internal_transition_map_tuple = {}
+        self.internal_transition_map_state = {}
+
+
+        self._cancel_reschedule_f = False
+        self._cur_state = ""
+        self.global_time = 0
+
+    def insert_state(self, name, deadline="inf"):
+        """
+        Insert "state" into the BehaviorModel
+        
+        Args:
+            name (str): State name
+            deadline (str or Infinite): Time until the state is active. Defaults to Infinite.
+        """
+        self._states[name] = float(deadline)
+
+    def update_state(self, name, deadline="inf"):
+        """
+        Updates an existing state in the BehaviorModel
+        
+        Args:
+            name (str): state name to update
+            deadline (str or Infinite): Time until the state is active. Defaults to Infinite.
+        """
+        self._states[name] = float(deadline)
+
+    def cancel_rescheduling(self):
+        """Canceled scheduling"""
+        self._cancel_reschedule_f = True
+        
+        
+    def init_state(self, state):
+        """
+        Sets the initial state
+        
+        Args:
+            state (str): Initial state name
+        """
+        self._cur_state = state
+
+    def set_global_time(self, gtime):
+        """
+        Set gloabl time
+        
+        Args:
+            gtime (float): Global time
+        """
+        self.global_time = gtime 
+        pass
+    
+    @abstractmethod
+    def ext_trans(self, port, msg):
+        """Defines the external transition, to be implemented by subclasses"""
+        pass
+
+    @abstractmethod
+    def int_trans(self):
+        """Defines the internal transition, to be implemented by subclasses"""
+        pass
+
+    @abstractmethod
+    def output(self, msg_deliver):
+        """Defines the output function, to be implemented by subclasses"""
+        pass
+
+    def get_cancel_flag(self):
+        """Returns the cancel reschedule flag"""
+        return self._cancel_reschedule_f
+
+    def reset_cancel_flag(self):
+        """Resets the cancel reschedule flag to False"""
+        self._cancel_reschedule_f = False
+
+    def retrieve_states(self):
+        """Returns the states dictionary"""
+        return self._states
+
+    def find_state(self, name):
+        """Checks if a state exists
+        
+        Args:
+            name (str): State name
+        
+        Returns:
+            bool: True if state exists, False otherwise
+        """
+        return name in self._states
+
+    def insert_external_transition(self, pre_state, event, post_state):
+        """Inserts an external transition
+        
+        Args:
+            pre_state (str): Previous state
+            event (str): Event causing the transition
+            post_state (str): Next state
+        """
+        self.external_transition_map_tuple[(pre_state, event)] = post_state
+        if pre_state in self.external_transition_map_state:
+            self.external_transition_map_state[pre_state].append((event, post_state))
+        else:
+            self.external_transition_map_state[pre_state] = [(event, post_state)]
+
+    def retrieve_external_transition(self, pre_state):
+        """Retrieves external transitions for a given state
+        
+        Args:
+            pre_state (str): Previous state
+        
+        Returns:
+            list: List of external transitions
+        """
+        return self.external_transition_map_state[pre_state]
+
+    def retrieve_next_external_state(self, pre_state, event):
+        """Retrieves the next state for a given external transition
+        
+        Args:
+            pre_state (str): Previous state
+            event (str): Event causing the transition
+        
+        Returns:
+            str: Next state
+        """
+        return self.external_transition_map_tuple[(pre_state, event)]
+
+    def find_external_transition(self, pre_state):
+        """Checks if there are external transitions for a given state
+        
+        Args:
+            pre_state (str): Previous state
+        
+        Returns:
+            bool: True if transitions exist, False otherwise
+        """
+        return pre_state in self.external_transition_map_state
+
+    def insert_internal_transition(self, pre_state, event, post_state):
+        """Inserts an internal transition
+        
+        Args:
+            pre_state (str): Previous state
+            event (str): Event causing the transition
+            post_state (str): Next state
+        """
+        self.internal_transition_map_tuple[(pre_state, event)] = post_state
+        if pre_state in self.internal_transition_map_state:
+            self.internal_transition_map_state[pre_state].append((event, post_state))
+        else:
+            self.internal_transition_map_state[pre_state] = [(event, post_state)]
+
+    def retrieve_internal_transition(self, pre_state):
+        """Retrieves internal transitions for a given state
+        
+        Args:
+            pre_state (str): Previous state
+        
+        Returns:
+            list: List of internal transitions
+        """
+        return self.internal_transition_map_state[pre_state]
+
+    def retrieve_next_internal_state(self, pre_state, event):
+        """Retrieves the next state for a given internal transition
+        
+        Args:
+            pre_state (str): Previous state
+            event (str): Event causing the transition
+        
+        Returns:
+            str: Next state
+        """
+        return self.internal_transition_map_tuple[(pre_state, event)]
+
+    def find_internal_transition(self, pre_state):
+        """Checks if there are internal transitions for a given state
+        
+        Args:
+            pre_state (str): Previous state
+        
+        Returns:
+            bool: True if transitions exist, False otherwise
+        """
+        return pre_state in self.internal_transition_map_state
+
+    def serialize(self):
+        """Serializes the behavior model to a JSON object
+        
+        Returns:
+            OrderedDict: Serialized JSON object
+        """
+        json_obj = OrderedDict()
+        json_obj["name"] = self._name
+        json_obj["states"] = self._states
+        json_obj["input_ports"] = self.retrieve_input_ports()
+        json_obj["output_ports"] = self.retrieve_output_ports()
+        json_obj["external_trans"] = self.external_transition_map_state
+        json_obj["internal_trans"] = self.internal_transition_map_state
+        return json_obj
+
+    def deserialize(self, json):
+        """Deserializes the behavior model from a JSON object
+        
+        Args:
+            json (dict): JSON object containing the model data
+        """
+        self._name = json["name"]
+        for key, value in json["states"].items():
+            self.insert_state(key, value)
+
+        # Handle input ports
+        for port in json["input_ports"]:
+            self.insert_input_port(port)
+
+        # Handle output ports
+        for port in json["output_ports"]:
+            self.insert_output_port(port)
+
+        # Handle external transitions
+        for key, value in json["external_trans"].items():
+            for ns in value:
+                self.insert_external_transition(key, ns[0], ns[1])
+
+        # Handle internal transitions
+        for key, value in json["internal_trans"].items():
+            for ns in value:
+                self.insert_internal_transition(key, ns[0], ns[1])

pyjevsim/core_model.py

@@ -0,0 +1,103 @@
+"""
+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 CoreModel, the parent class of all Model Types. 
+"""
+from .system_object import SystemObject
+
+class CoreModel(SystemObject):
+    """
+    All forms of Models in Pyjevsim have a CoreModel as their foundation. 
+    CoreModel class serves as a base model with basic functionalities for input and output ports.
+    """
+    def __init__(self, _name, _type):
+        """
+        Args:
+            _name (str): Model name
+            _type (ModelType.BEHAVIORAL or ModelType.STRUCTURAL or ModelType.UTILITY): Model type
+        """
+        super().__init__()
+        # Model Type
+        self.model_type = _type
+        self._name = _name
+
+        # Input Ports Declaration
+        self.external_input_ports = []
+        # Output Ports Declaration
+        self.external_output_ports = []
+
+    def set_name(self, _name):
+        """
+        Sets the name of the model.
+        
+        Args:
+            _name (str): New name of the model
+        """
+        self._name = _name
+
+    def get_name(self):
+        """
+        Returns the name of the model.
+        
+        Returns:
+            str: Name of the model
+        """
+        return self._name
+
+    def get_model_type(self):
+        """
+        Returns the type of the model.
+        
+        Returns:
+            (ModelType.BEHAVIORAL or ModelType.STRUCTURAL or ModelType.UTILITY) : Type of the model 
+        """
+        return self.model_type
+
+    def insert_input_port(self, port):
+        """Inserts an input port to the model.
+        
+        Args:
+            port (str): Name of the input port
+        """
+        self.external_input_ports.append(port)
+
+    def retrieve_input_ports(self):
+        """
+        Retrieves all input ports of the model.
+        
+        Returns:
+            list: List of input ports
+        """
+        return self.external_input_ports
+
+    def insert_output_port(self, port):
+        """
+        Inserts an output port to the model.
+        
+        Args:
+            port (str): Name of the output port
+        """
+        self.external_output_ports.append(port)
+
+    def retrieve_output_ports(self):
+        """
+        Retrieves all output ports of the model.
+        
+        Returns:
+            list: List of output ports
+        """
+        return self.external_output_ports
+
+    def model_snapshot(self):
+        """
+        Snapshot the information of the running model.
+        
+        Returns:
+            dict: Dictionary containing model type, model name, and model data
+        """
+        model_info = {"type": self.model_type, "name": self._name, "data": self}
+        return model_info

pyjevsim/default_message_catcher.py

@@ -0,0 +1,42 @@
+"""
+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 a default model, DefaultMessageCatcher, for catching uncaught messages. 
+"""
+
+from .behavior_model import BehaviorModel
+from .definition import *
+
+class DefaultMessageCatcher(BehaviorModel):
+    """
+    A default model for catching uncaught messages.
+    Receiving and not processing uncaught messages.
+    """
+
+    def __init__(self, _name):
+        super().__init__(_name)
+
+        self.init_state("IDLE")  # Set initial state to 'IDLE'
+        self.insert_state("IDLE", Infinite)  # Insert 'IDLE' state with infinite duration
+        self.insert_input_port("uncaught")  # Insert 'uncaught' input port
+
+    def ext_trans(self, port, msg):
+        """
+        Received an uncaught message.
+        
+        Args:
+            port (str): The port name
+            msg (SysMessage): The incoming message
+        """
+        data = msg.retrieve()  # Retrieve message
+
+    def int_trans(self):
+        return
+
+    def output(self, msg_deliver):
+        return msg_deliver
+