cgse-common 2025.0.8.dev3__py3-none-any.whl → 2025.0.9__py3-none-any.whl

{cgse_common-2025.0.8.dev3.dist-info → cgse_common-2025.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse-common
-Version: 2025.0.8.dev3
+Version: 2025.0.9
 Summary: Software framework to support hardware testing
 Author: IVS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{cgse_common-2025.0.8.dev3.dist-info → cgse_common-2025.0.9.dist-info}/RECORD

@@ -4,26 +4,26 @@ egse/bits.py,sha256=1DPcC5R-8w-KLfbr2WLx-4Ezfwm6jpRMz-E5QfQ_YKw,11138
 egse/calibration.py,sha256=DZ-LgEwamTWDukMqTr2JLCPt3M1lw6W0SfpHQfG7cXg,8989
 egse/command.py,sha256=su35PU_0Bru1Es4up1lJFps9FTQpJ7xcxl9Y4w8suxA,22880
 egse/config.py,sha256=Ib1Ddt0wFwRrioBvMs7Md-wgEEPdK3eaXCt0H7HJEow,14888
-egse/control.py,sha256=cH0EA5mqaS3nQc35x1Sa0o2iM2Q4_hsrak6GOdcRMMU,12793
+egse/control.py,sha256=Z4aeYfZkzdULMWFgPilAR9AlZu5I0vAUizCPSdINJaY,16567
 egse/decorators.py,sha256=YDoFNn7Fe-voKX2iui85POciXuLs0P5rW1TNtxpejUM,13629
-egse/device.py,sha256=SIMROwB9YdNdFowTcZp1HW_el8LWVWDJ5tDUxs58YuY,8500
+egse/device.py,sha256=sc4cx-xOXjmewVZuXSSzROv1gqP8BqUycojiEmqV6ck,8501
 egse/env.py,sha256=IzT_DYTHKlqtXDR8fWI9n7xj7KnL58UE6_mZUCdQMss,28279
 egse/exceptions.py,sha256=Tc1xqUrWxV6SXxc9xB9viK_O-GVa_SpzqZUVEhZkwzA,1801
 egse/hk.py,sha256=5WMOGlx043XmEPj7ML1TkDzA8ZaTYLD-i5OcNUxE268,31163
 egse/metrics.py,sha256=cZKMEe3OTT2uomj7vXjEl54JD0CStfEC4nCgS6U5YSM,3794
-egse/mixin.py,sha256=J3yu5lPnm0grJqIm5LiacBUCZujJsdcKBNRaOQcMnNo,17345
+egse/mixin.py,sha256=E7GvuAYAr-KGjCOsYojIcicdmcHoETwBcCeVjP5EkMc,17471
 egse/monitoring.py,sha256=-pwXqPoiNKzQYKQSpKddFlaPkCTJZYdxvG1d2MBN3l0,3033
 egse/observer.py,sha256=6faaLHqgpOQs_oEvdBygQ5HF7mGneKJEfyQEFUFA5VY,1069
 egse/obsid.py,sha256=-HPuHApZrr3Nj1J2-qqnIiE814C-gm4FSHdM2afKdRY,5883
 egse/persistence.py,sha256=Lx6LMJ1-dh8N43XF7tTM6RwD0sSETiGQ9DNqug-G-zQ,2160
 egse/plugin.py,sha256=Vuy4WkymGEt-_fibUIoVxdF1pcCS3FaXwtiYhUIdjcE,4820
 egse/process.py,sha256=mQ2ojeL_9oE_QkMJlQDPd1290z0j2mOrGXrlrWtOtzI,16615
-egse/protocol.py,sha256=G1HTU7xfS4xE1Oi1diDOTWQUTkPLyuooawWCOY6p-b0,23828
+egse/protocol.py,sha256=dQVQ8U0AitjvkOxJRrJJ7dvYAn0vxOfi5IL6gxmCyeQ,23837
 egse/proxy.py,sha256=pMKdnF62SXm0quLoKfgvK9GFkH2mLMB5fWNrZenfqQQ,18100
 egse/reload.py,sha256=rDT0bC6RFeRhW38wSgFcxr30h8FvaKkoGp_OE-AwBB4,4388
 egse/resource.py,sha256=VoB7BVrQULT_SJ1XioDzB59-uH47nUcN-KNVLvFxiFE,15163
 egse/response.py,sha256=WFtWftovrmmn92NW4mhJjibMtCWteZmAzNuPLVsV-lg,2716
-egse/services.py,sha256=FV6BUEotkooGALq1EzypZjHg0BDRJixSghp3ak7o_z8,7712
+egse/services.py,sha256=nobKsApRxBIg7Vxy67MJWH2qT47mJfDOaxMIpc0n7fg,7716
 egse/services.yaml,sha256=p8QBF56zLI21iJ9skt65VlNz4rIqRoFfBTZxOIUZCZ4,1853
 egse/settings.py,sha256=lmIfg3lwIuHrI8JL5qfiAaXHjblC87_W0c2mjbj-vRA,15562
 egse/settings.yaml,sha256=mz9O2QqmiptezsMvxJRLhnC1ROwIHENX0nbnhMaXUpE,190
@@ -32,7 +32,7 @@ egse/state.py,sha256=ekcCZu_DZKkKYn-5iWG7ij7Aif2WYMNVs5h3cia-cVc,5352
 egse/system.py,sha256=KCXz8eH3PNwLaB7ww3OCkK_tQoaTYhh2FEwX1mvN8RQ,48996
 egse/version.py,sha256=-EMuiSn2eEp8QJX6csmBEu1m2yGqlXHJj2Hj49w6a2k,6217
 egse/zmq_ser.py,sha256=2-nwVUBWZ3vvosKNmlWobHJrIJA2HlM3V5a63Gz2JY0,1819
-cgse_common-2025.0.8.dev3.dist-info/METADATA,sha256=0i907msDC2Sa7vvRsmPeYLvJUTdxyA2F1lf_x4JQWks,2579
-cgse_common-2025.0.8.dev3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cgse_common-2025.0.8.dev3.dist-info/entry_points.txt,sha256=MtsCYBzfuc3afzsjbdGJ-TZRSS8rhof5fI9w86_nGkQ,91
-cgse_common-2025.0.8.dev3.dist-info/RECORD,,
+cgse_common-2025.0.9.dist-info/METADATA,sha256=Vi5NH0UJeeVC0eeJufawREAoIdl50PgjqvGsJYUwusU,2574
+cgse_common-2025.0.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cgse_common-2025.0.9.dist-info/entry_points.txt,sha256=MtsCYBzfuc3afzsjbdGJ-TZRSS8rhof5fI9w86_nGkQ,91
+cgse_common-2025.0.9.dist-info/RECORD,,

egse/control.py

@@ -1,10 +1,12 @@
 """
-This module defines the abstract class for any control server and some convenience functions.
+This module defines the abstract class for any Control Server and some convenience functions.
 """
+
 import abc
 import logging
 import pickle
 import threading
+from typing import Union
 
 import zmq
 
@@ -30,16 +32,18 @@ PROCESS_SETTINGS = Settings.load("PROCESS")
 
 
 def is_control_server_active(endpoint: str = None, timeout: float = 0.5) -> bool:
-    """
-    Check if the control server is running. This function sends a *Ping* message to the
-    control server and expects a *Pong* answer back within the timeout period.
+    """ Checks if the Control Server is running.
+
+    This function sends a *Ping* message to the Control Server and expects a *Pong* answer back within the timeout
+    period.
 
     Args:
-        endpoint (str): the endpoint to connect to, i.e. <protocol>://<address>:<port>
-        timeout (float): timeout when waiting for a reply [seconds, default=0.5]
-    Returns:
-        True if the Control Server is running and replied with the expected answer.
+        endpoint (str): Endpoint to connect to, i.e. <protocol>://<address>:<port>
+        timeout (float): Timeout when waiting for a reply [s, default=0.5]
+
+    Returns: True if the Control Server is running and replied with the expected answer; False otherwise.
     """
+
     ctx = zmq.Context.instance()
 
     return_code = False
@@ -50,6 +54,7 @@ def is_control_server_active(endpoint: str = None, timeout: float = 0.5) -> bool
         data = pickle.dumps("Ping")
         socket.send(data)
         rlist, _, _ = zmq.select([socket], [], [], timeout=timeout)
+
         if socket in rlist:
             data = socket.recv()
             response = pickle.loads(data)
@@ -62,20 +67,22 @@ def is_control_server_active(endpoint: str = None, timeout: float = 0.5) -> bool
 
 
 class ControlServer(metaclass=abc.ABCMeta):
-    """
-    The base class for all device control servers and for the Storage Manager and Configuration
-    Manager. A Control Server reads commands from a ZeroMQ socket and executes these commands by
-    calling the `execute()` method of the commanding protocol class.
+    """ Base class for all device control servers and for the Storage Manager and Configuration Manager.
+
+    A Control Server reads commands from a ZeroMQ socket and executes these commands by calling the `execute()` method
+    of the commanding protocol class.
 
     The sub-class shall define the following:
 
-    * Define the device protocol class -> `self.device_protocol`
-    * Bind the command socket to the device protocol -> `self.dev_ctrl_cmd_sock`
-    * Register the command socket in the poll set -> `self.poller`
+        - Define the device protocol class -> `self.device_protocol`
+        - Bind the command socket to the device protocol -> `self.dev_ctrl_cmd_sock`
+        - Register the command socket in the poll set -> `self.poller`
 
     """
 
     def __init__(self):
+        """ Initialisation of a new Control Server."""
+
         from egse.monitoring import MonitoringProtocol
         from egse.services import ServiceProtocol
 
@@ -86,15 +93,14 @@ class ControlServer(metaclass=abc.ABCMeta):
         self._timer_thread.daemon = True
         self._timer_thread.start()
 
-        # The logger will be overwritten by the sub-class, if not, then we use this logger
-        # with the name of the sub-class. That will help us to identify which sub-class did not
-        # overwrite the logger attribute.
+        # The logger will be overwritten by the sub-class, if not, we use this logger with the name of the sub-class.
+        # That will help us to identify which sub-class did not overwrite the logger attribute.
 
         self.logger = logging.getLogger(get_full_classname(self))
 
         self.interrupted = False
-        self.delay = 1000  # delay between publish status information [milliseconds]
-        self.hk_delay = 1000  # delay between saving housekeeping information [milliseconds]
+        self.mon_delay = 1000   # Delay between publish status information [ms]
+        self.hk_delay = 1000    # Delay between saving housekeeping information [ms]
 
         self.zcontext = zmq.Context.instance()
         self.poller = zmq.Poller()
@@ -103,118 +109,206 @@ class ControlServer(metaclass=abc.ABCMeta):
         self.service_protocol = ServiceProtocol(self)
         self.monitoring_protocol = MonitoringProtocol(self)
 
-        # Setup the control server waiting for service requests
+        # Set up the Control Server waiting for service requests
 
         self.dev_ctrl_service_sock = self.zcontext.socket(zmq.REP)
         self.service_protocol.bind(self.dev_ctrl_service_sock)
 
-        # Setup the control server for sending monitoring info
+        # Set up the Control Server for sending monitoring info
 
         self.dev_ctrl_mon_sock = self.zcontext.socket(zmq.PUB)
         self.monitoring_protocol.bind(self.dev_ctrl_mon_sock)
 
-        # Setup the control server waiting for device commands.
+        # Set up the Control Server waiting for device commands.
         # The device protocol shall bind the socket in the sub-class
 
         self.dev_ctrl_cmd_sock = self.zcontext.socket(zmq.REP)
 
-        # Initialize the poll set
+        # Initialise the poll set
 
         self.poller.register(self.dev_ctrl_service_sock, zmq.POLLIN)
         self.poller.register(self.dev_ctrl_mon_sock, zmq.POLLIN)
 
     @abc.abstractmethod
-    def get_communication_protocol(self):
+    def get_communication_protocol(self) -> str:
+        """ Returns the communication protocol used by the Control Server.
+
+        Returns: Communication protocol used by the Control Server, as specified in the settings.
+        """
+
         pass
 
     @abc.abstractmethod
-    def get_commanding_port(self):
+    def get_commanding_port(self) -> int:
+        """ Returns the commanding port used by the Control Server.
+
+        Returns: Commanding port used by the Control Server, as specified in the settings.
+        """
+
         pass
 
     @abc.abstractmethod
-    def get_service_port(self):
+    def get_service_port(self) -> int:
+        """ Returns the service port used by the Control Server.
+
+        Returns: Service port used by the Control Server, as specified in the settings.
+        """
+
         pass
 
     @abc.abstractmethod
-    def get_monitoring_port(self):
+    def get_monitoring_port(self) -> int:
+        """ Returns the monitoring port used by the Control Server.
+
+        Returns: Monitoring port used by the Control Server, as specified in the settings.
+        """
+
         pass
 
-    def get_ip_address(self):
+    def get_ip_address(self) -> str:
+
         return get_host_ip()
 
-    def get_storage_mnemonic(self):
+    def get_storage_mnemonic(self) -> str:
+        """ Returns the storage mnemonics used by the Control Server.
+
+        This is a string that will appear in the filename with the housekeeping information of the device, as a way of
+        identifying the device.  If this is not implemented in the sub-class, then the class name will be used.
+
+        Returns: Storage mnemonics used by the Control Server, as specified in the settings.
+        """
+
         return self.__class__.__name__
 
-    def get_process_status(self):
+    def get_process_status(self) -> dict:
+        """ Returns the process status of the Control Server.
+
+        Returns: Dictionary with the process status of the Control Server.
+        """
+
         return self._process_status.as_dict()
 
-    def get_average_execution_times(self):
-        return get_average_execution_times()
+    def get_average_execution_times(self) -> dict:
+        """ Returns the average execution times of all functions that have been monitored by this process.
 
-    def set_delay(self, seconds: float) -> float:
+        Returns: Dictionary with the average execution times of all functions that have been monitored by this process.
+                 The dictionary keys are the function names, and the values are the average execution times in ms.
         """
-        Sets the delay time for monitoring. The delay time is the time between two successive executions of the
-        `get_status()` function of the device protocol.
 
-        It might happen that the delay time that is set is longer than what you requested. That is the case when
-        the execution of the `get_status()` function takes longer than the requested delay time. That should
-        prevent the server from blocking when a too short delay time is requested.
+        return get_average_execution_times()
+
+    def set_mon_delay(self, seconds: float) -> float:
+        """ Sets the delay time for monitoring.
+
+        The delay time is the time between two successive executions of the `get_status()` function of the device
+        protocol.
+
+        It might happen that the delay time that is set is longer than what you requested. That is the case when the
+        execution of the `get_status()` function takes longer than the requested delay time. That should prevent the
+        server from blocking when a too short delay time is requested.
 
         Args:
-            seconds: the number of seconds between the monitoring calls.
-        Returns:
-            The delay that was set in milliseconds.
+            seconds (float): Number of seconds between the monitoring calls
+
+        Returns: Delay that was set [ms].
         """
+
         execution_time = get_average_execution_time(self.device_protocol.get_status)
-        self.delay = max(seconds * 1000, (execution_time + 0.2) * 1000)
-        return self.delay
+        self.mon_delay = max(seconds * 1000, (execution_time + 0.2) * 1000)
 
-    def set_hk_delay(self, seconds) -> float:
-        """
-        Sets the delay time for housekeeping. The delay time is the time between two successive executions of the
-        `get_housekeeping()` function of the device protocol.
+        return self.mon_delay
+
+    def set_hk_delay(self, seconds: float) -> float:
+        """ Sets the delay time for housekeeping.
 
-        It might happen that the delay time that is set is longer than what you requested. That is the case when
-        the execution of the `get_housekeeping()` function takes longer than the requested delay time. That should
-        prevent the server from blocking when a too short delay time is requested.
+        The delay time is the time between two successive executions of the `get_housekeeping()` function of the device
+        protocol.
+
+        It might happen that the delay time that is set is longer than what you requested. That is the case when the
+        execution of the `get_housekeeping()` function takes longer than the requested delay time. That should prevent
+        the server from blocking when a too short delay time is requested.
 
         Args:
-            seconds: the number of seconds between the housekeeping calls.
-        Returns:
-            The delay that was set in milliseconds.
+            seconds (float): Number of seconds between the housekeeping calls
+
+        Returns: Delay that was set [ms].
         """
+
         execution_time = get_average_execution_time(self.device_protocol.get_housekeeping)
         self.hk_delay = max(seconds * 1000, (execution_time + 0.2) * 1000)
+
         return self.hk_delay
 
-    def set_logging_level(self, level):
+    def set_logging_level(self, level: Union[int, str]) -> None:
+        """ Sets the logging level to the given level.
+
+        Allowed logging levels are:
+            - "CRITICAL" or 50
+            - "FATAL" or CRITICAL
+            - "ERROR" or 40
+            - "WARNING" or 30
+            - "WARN" or WARNING
+            - "INFO" or 20
+            - "DEBUG" or 10
+            - "NOTSET" or 0
+
+        Args:
+            level (int | str): Logging level to use, specified as either a string or an integer
+        """
+
         self.logger.setLevel(level=level)
 
-    def quit(self):
+    def quit(self) -> None:
+        """ Interrupts the Control Server."""
+
         self.interrupted = True
 
-    def before_serve(self):
+    def before_serve(self) -> None:
+        """ Steps to take before the Control Server is activated."""
+
         pass
 
-    def after_serve(self):
+    def after_serve(self) -> None:
+        """ Steps to take after the Control Server has been deactivated."""
+
         pass
 
-    def is_storage_manager_active(self):
-        """
-        This method needs to be implemented by the subclass if you need to store information.
+    def is_storage_manager_active(self) -> bool:
+        """ Checks if the Storage Manager is active.
+
+        This method has to be implemented by the sub-class if you need to store information.
 
-        Note: you might want to set a specific timeout when checking for the Storage Manager.
+        Note: You might want to set a specific timeout when checking for the Storage Manager.
 
-        Note: If this method returns True, the following methods shall also be implemented by the subclass:
+        Note: If this method returns True, the following methods shall also be implemented by the sub-class:
 
-        * register_to_storage_manager()
-        * unregister_from_storage_manager()
-        * store_housekeeping_information()
+            - register_to_storage_manager()
+            - unregister_from_storage_manager()
+            - store_housekeeping_information()
 
+        Returns: True if the Storage Manager is active; False otherwise.
         """
+
         return False
 
-    def serve(self):
+    def serve(self) -> None:
+        """ Activation of the Control Server.
+
+        This comprises the following steps:
+
+            - Executing the `before_serve` method;
+            - Checking if the Storage Manager is active and registering the Control Server to it;
+            - Start listening  for keyboard interrupts;
+            - Start accepting (listening to) commands;
+            - Start sending out monitoring information;
+            - Start sending out housekeeping information;
+            - Start listening for quit commands;
+            - After a quit command has been received:
+                - Unregister from the Storage Manager;
+                - Execute the `after_serve` method;
+                - Close all sockets;
+                - Clean up all threads.
+        """
 
         self.before_serve()
 
@@ -239,8 +333,7 @@ class ControlServer(metaclass=abc.ABCMeta):
             except KeyboardInterrupt:
                 self.logger.warning("Keyboard interrupt caught!")
                 self.logger.warning(
-                    "The ControlServer can not be interrupted with CTRL-C, "
-                    "send a quit command to the server."
+                    "The ControlServer can not be interrupted with CTRL-C, send a quit command to the server instead."
                 )
                 continue
 
@@ -250,17 +343,19 @@ class ControlServer(metaclass=abc.ABCMeta):
             if self.dev_ctrl_service_sock in socks:
                 self.service_protocol.execute()
 
-            # Now handle the periodic sending out of status information. A dictionary with the
-            # status or HK info is sent out periodically based on the DELAY time that is in the
-            # YAML config file.
+            # Handle sending out monitoring information periodically, based on the MON_DELAY time that is specified in
+            # the YAML configuration file for the device
 
-            if time_in_ms() - last_time >= self.delay:
+            if time_in_ms() - last_time >= self.mon_delay:
                 last_time = time_in_ms()
                 # self.logger.debug("Sending status to monitoring processes.")
                 self.monitoring_protocol.send_status(
                     save_average_execution_time(self.device_protocol.get_status)
                 )
 
+            # Handle sending out housekeeping information periodically, based on the HK_DELAY time that is specified in
+            # the YAML configuration file for the device
+
             if time_in_ms() - last_time_hk >= self.hk_delay:
                 last_time_hk = time_in_ms()
                 if storage_manager:
@@ -275,14 +370,12 @@ class ControlServer(metaclass=abc.ABCMeta):
                 )
                 break
 
-            # Some device protocol subclasses might start a number of threads or processes to
-            # support the commanding. Check if these threads/processes are still alive and
-            # terminate gracefully if they are not.
+            # Some device protocol sub-classes might start a number of threads or processes to support the commanding.
+            # Check if these threads/processes are still alive and terminate gracefully if they are not.
 
             if not self.device_protocol.is_alive():
                 self.logger.error(
-                    "Some Thread or sub-process that was started by Protocol has "
-                    "died, terminating..."
+                    "Some Thread or sub-process that was started by Protocol has died, terminating..."
                 )
                 break
 
@@ -300,11 +393,11 @@ class ControlServer(metaclass=abc.ABCMeta):
 
         self.zcontext.term()
 
-    def store_housekeeping_information(self, data: dict):
-        """
-        Send housekeeping information to the Storage manager.
+    def store_housekeeping_information(self, data: dict) -> None:
+        """ Sends housekeeping information to the Storage Manager.
 
-        Subclasses need to overwrite this method if they want the device housekeeping information to be saved.
+        This method has to be overwritten by the sub-classes if they want the device housekeeping information to be
+        saved.
 
         Args:
             data (dict): a dictionary containing parameter name and value of all device housekeeping. There is also
@@ -312,16 +405,21 @@ class ControlServer(metaclass=abc.ABCMeta):
         """
         pass
 
-    def register_to_storage_manager(self):
-        """
-        Register this ControlServer to the Storage Manager so the housekeeping information of the device can be saved.
+    def register_to_storage_manager(self) -> None:
+        """ Registers this Control Server to the Storage Manager.
+
+        By doing so, the housekeeping information of the device will be sent to the Storage Manager, which will store
+        the information in a dedicated CSV file.
+
+        This method has to be overwritten by the sub-classes if they have housekeeping information that must be stored.
+
+        Subclasses need to overwrite this method if they have housekeeping information to be stored.
 
-        Subclasses need to overwrite this method if they have housekeeping information to be stored. The following
-        information is required for the registration:
+        The following   information is required for the registration:
 
-        * origin: can be retrieved from `self.get_storage_mnemonic()`
-        * persistence_class: one of the TYPES in egse.storage.persistence
-        * prep: depending on the type of the persistence class (see respective documentation)
+            - origin: Storage mnemonic, which can be retrieved from `self.get_storage_mnemonic()`
+            - persistence_class: Persistence layer (one of the TYPES in egse.storage.persistence)
+            - prep: depending on the type of the persistence class (see respective documentation)
 
         The `egse.storage` module provides a convenience method that can be called from the method in the subclass:
 
@@ -331,18 +429,20 @@ class ControlServer(metaclass=abc.ABCMeta):
         """
         pass
 
-    def unregister_from_storage_manager(self):
-        """
-        Unregister this ControlServer from the Storage manager.
+    def unregister_from_storage_manager(self) -> None:
+        """ Unregisters the Control Server from the Storage Manager.
 
-        Subclasses need to overwrite this method. The following information is required for the registration:
+        This method has to be overwritten by the sub-classes.
 
-        * origin: can be retrieved from `self.get_storage_mnemonic()`
+        The following information is required for the registration:
 
-        The `egse.storage` module provides a convenience method that can be called from the method in the subclass:
+            - origin: Storage mnemonic, which can be retrieved from `self.get_storage_mnemonic()`
+
+        The `egse.storage` module provides a convenience method that can be called from the method in the sub-class:
 
             >>> from egse.storage import unregister_from_storage_manager  # noqa
 
         Note: the `egse.storage` module might not be available, it is provided by the `cgse-core` package.
         """
+
         pass

egse/device.py

@@ -152,6 +152,7 @@ class DeviceConnectionInterface(DeviceConnectionObservable):
         Raises:
             ConnectionError: when the connection can not be opened.
         """
+
         raise NotImplementedError
 
     @dynamic_interface
@@ -187,13 +188,13 @@ class DeviceInterface(DeviceConnectionInterface):
 
     @dynamic_interface
     def is_simulator(self) -> bool:
-        """Ask if the device class is a Simulator instead of the real Controller.
+        """ Checks whether the device is a simulator rather than a real hardware controller.
 
         This can be useful for testing purposes or when doing actual movement simulations.
 
-        Returns:
-            True if the Device is a Simulator, False if the Device is connected to real hardware.
+        Returns: True if the Device is a Simulator; False if the Device is connected to real hardware.
         """
+
         raise NotImplementedError
 
 

egse/mixin.py

@@ -28,6 +28,7 @@ __all__ = [
     "add_cr_lf",
     "dynamic_command",
     "DynamicCommandMixin",
+    "CommandType"
 ]
 
 # ----- Mixin for dynamic commanding ---------------------------------------------------------------
@@ -108,6 +109,13 @@ def expand_kwargs(kwargs: Dict):
     return " ".join(f"{k}={v}" for k, v in kwargs.items())
 
 
+class CommandType(str, enum.Enum):
+
+    READ = "read"
+    WRITE = "write"
+    TRANSACTION = "transaction"
+
+
 def dynamic_command(
         *,
         cmd_type: str,  # required keyword-only argument

egse/protocol.py

@@ -163,7 +163,7 @@ class BaseCommandProtocol(DeviceConnectionObserver):
         """
         status = {
             "timestamp": format_datetime(),
-            "delay": self.__control_server.delay,
+            "delay": self.__control_server.mon_delay,
         }
         status.update(self.__control_server.get_process_status())
         return status
@@ -386,7 +386,7 @@ class CommandProtocol(DeviceConnectionObserver, metaclass=abc.ABCMeta):
 
     def quit(self):
         """
-        This method can be overridden by a sub-class to cleanup and stop threads that it
+        This method can be overridden by a sub-class to clean up and stop threads that it
         started.
         """
 
@@ -444,7 +444,7 @@ class CommandProtocol(DeviceConnectionObserver, metaclass=abc.ABCMeta):
         """
         status = {
             "timestamp": format_datetime(),
-            "delay": self.control_server.delay,
+            "delay": self.control_server.mon_delay,
         }
         status.update(self.control_server.get_process_status())
         return status

egse/services.py

@@ -57,7 +57,7 @@ class ServiceProtocol(CommandProtocol):
         Returns:
             Sends back the selected delay time in milliseconds.
         """
-        delay = self.control_server.set_delay(1.0 / freq)
+        delay = self.control_server.set_mon_delay(1.0 / freq)
 
         LOGGER.debug(f"Set monitoring frequency to {freq}Hz, ± every {delay:.0f}ms.")