cgse 2023.38.0__py3-none-any.whl → 2024.1.3__py3-none-any.whl

egse/serialdevice.py

@@ -1,190 +0,0 @@
-"""
-This module defines a generic base class for serial based device interface classes.
-"""
-
-import logging
-from serial import Serial, SerialTimeoutException, SerialException
-from threading import Lock
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceConnectionInterface
-
-
-logger = logging.getLogger(__name__)
-
-
-class SerialDevice(DeviceConnectionInterface):
-    """ Generic base class for serial based device interface classes.
-
-        This base class handles the serial connection.
-    """
-
-
-    def __init__(self, port=None, baudrate=9600, terminator='\r', timeout=5, encoding='ascii', errors='strict'):
-        self._port       = port
-        self._baudrate   = baudrate
-        self._terminator = terminator
-        self._encoding   = encoding
-        self._errors     = errors
-        self._timeout    = timeout
-        self._serial     = None
-        self._connected  = False
-        self._lock       = Lock()
-
-
-    @dynamic_interface
-    def get_idn(self):
-        """ Get the device ID string
-
-            Child classes must implement this function because it is required for `is_connected()`
-
-            Raises:
-                ConnectionError: when the connection failed.
-        """
-        raise NotImplementedError
-
-
-    def is_simulator(self):
-
-        return False
-
-
-    def connect(self):
-        """ Create the serial conection.
-
-            Raises a ConnectionError on failure.
-        """
-
-        # Sanity checks
-        if self._connected:
-            raise ConnectionError("Serial connection is already open")
-        if self._port in (None, ""):
-            raise ValueError("Serial port not initialized")
-        if self._baudrate in (None, 0):
-            raise ValueError("Baudrate not initialized")
-
-        # Create a new serial connection
-        try:
-            self._serial = Serial(port=self._port, baudrate=self._baudrate,
-                                  timeout=self._timeout, write_timeout=self._timeout)
-        except ValueError as e_value:
-            raise ConnectionError("Invalid parameters for serial connection") from e_value
-        except SerialException as e_serial:
-            raise ConnectionError("Failed to open serial device.") from e_serial
-
-        self._connected = True
-
-
-    def disconnect(self):
-        """ Disconnect from the serial connection.
-
-            Raises a ConnectionError on failure.
-        """
-
-        try:
-            if self._connected:
-                logger.debug(f"Disconnecting from {self._port}")
-                with self._lock:
-                    self._serial.close()
-                self._connected = False
-        except Exception as e_exc:
-            raise ConnectionError(f"Could not close serial connection to {self._port}") from e_exc
-
-
-    def reconnect(self):
-        """ Disconnect the serial connection if it is already connected and try to connect.
-        """
-
-        if self._connected:
-            self.disconnect()
-
-        self.connect()
-
-
-    def is_connected(self):
-        """ Check if the socket connection to the device is active.
-            This function assumes the child class implements the get_idn method.
-        """
-
-        if not self._connected:
-            return False
-
-        try:
-            response = self.get_idn()
-        except ConnectionError as err:
-            logger.error(f'While trying to talk to the device the following exception occured,',
-                         'exception={err}')
-            self.disconnect()
-            return False
-
-        return True
-
-    def send_command(self, command: str):
-        """
-        Send a single command to the device controller without waiting for a response.
-
-        Args:
-            command: an order command for the controller.
-
-        Raises:
-            ConnectionError when the command could not be sent due to a timeout or a communication
-            problem.
-        """
-
-        # print("send: ", repr(command))
-
-        try:
-            with self._lock:
-                self._serial.write(command.encode(encoding=self._encoding, errors=self._errors))
-
-        except SerialTimeoutException as e_timeout:
-            raise ConnectionError("Serial timeout error") from e_timeout
-
-
-    def read(self):
-        """
-        Read a response from the device until a termination character is encountered.
-
-        Returns:
-            Either a string returned by the controller (on success), or an error message (on
-            failure).
-
-        Raises:
-            ConnectionError when there was an I/O problem during communication with the
-            controller.
-        """
-
-        try:
-            with self._lock:
-                # Read the response
-                # NOTE: the serial module reads until it encounters the \n termination character
-                return_string = self._serial.read_until(self._terminator.encode(encoding=self._encoding, errors=self._errors), size=1024)
-                # print(f"recv: ", repr(return_string))
-
-            return return_string.decode(encoding=self._encoding, errors=self._errors)
-
-        except SerialTimeoutException as e_timeout:
-            raise ConnectionError("Serial timeout during query") from e_timeout
-
-
-    def query(self, command: str):
-        """
-        Send a single command to the device controller and block until a response from the
-        controller. This function can be overridden by the child class to implement device specific
-        sanity checks on the reponse.
-
-        Args:
-            command: is the command to be sent
-
-        Returns:
-            Either a string returned by the controller (on success), or an error message (on
-            failure).
-
-        Raises:
-            ConnectionError when there was an I/O problem during communication with the
-            controller.
-        """
-
-        # Attempt to send the command
-        self.send_command(command)
-        return self.read()

egse/services.py

@@ -1,212 +0,0 @@
-"""
-This module provides the services to the control servers.
-
-Each control server has a services protocol which provides commands that will
-be executed on the control server instead of the device controller. This is
-typically used to access control server specific settings like monitoring frequency,
-logging levels, or to quit the control server in a controlled way.
-
-"""
-
-import inspect
-import logging
-
-from egse.command import ClientServerCommand
-from egse.control import ControlServer
-from egse.decorators import dynamic_interface
-from egse.protocol import CommandProtocol
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.zmq_ser import bind_address
-from egse.zmq_ser import connect_address
-
-LOGGER = logging.getLogger(__name__)
-
-SERVICE_SETTINGS = Settings.load(filename="services.yaml")
-
-
-class ServiceCommand(ClientServerCommand):
-    pass
-
-
-class ServiceProtocol(CommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        self.load_commands(SERVICE_SETTINGS.Commands, ServiceCommand, ServiceProtocol)
-
-    def get_bind_address(self):
-        return bind_address(self.control_server.get_communication_protocol(), self.control_server.get_service_port())
-
-    def get_status(self):
-        return super().get_status()
-
-    def handle_set_monitoring_frequency(self, freq: float):
-        """
-        Sets the monitoring frequency (Hz) to the given freq value. This is only approximate since the frequency is
-        converted into a delay time and the actual execution of the status function is subject to the load on the
-        server and the overhead of the timing.
-
-        Args:
-            freq: frequency of execution (Hz)
-
-        Returns:
-            Sends back the selected delay time in milliseconds.
-        """
-        delay = self.control_server.set_delay(1.0 / freq)
-
-        LOGGER.debug(f"Set monitoring frequency to {freq}Hz, ± every {delay:.0f}ms.")
-
-        self.send(delay)
-
-    def handle_set_hk_frequency(self, freq: float):
-        """
-        Sets the housekeeping frequency (Hz) to the given freq value. This is only approximate since the frequency is
-        converted into a delay time and the actual execution of the `housekeeping` function is subject to the load on
-        the server and the overhead of the timing.
-
-        Args:
-            freq: frequency of execution (Hz)
-
-        Returns:
-            Sends back the selected delay time in milliseconds.
-        """
-        delay = self.control_server.set_hk_delay(1.0 / freq)
-
-        LOGGER.debug(f"Set housekeeping frequency to {freq}Hz, ± every {delay:.0f}ms.")
-
-        self.send(delay)
-
-    def handle_set_logging_level(self, *args, **kwargs):
-        """
-        Set the logging level for the logger with the given name.
-
-        When 'all' is given for the name of the logger, the level of all loggers for which the name
-        starts with 'egse' will be changed to `level`.
-
-        Args:
-            name (str): the name of an existing Logger
-            level (int): the logging level
-
-        Returns:
-            Sends back an info message on what level was set.
-        """
-        if args:
-            name = args[0]
-            level = int(args[1])
-        else:
-            name = kwargs['name']
-            level = int(kwargs['level'])
-
-        if name == 'all':
-            for logger in [logging.getLogger(logger_name)
-                           for logger_name in logging.root.manager.loggerDict
-                           if logger_name.startswith('egse')]:
-                logger.setLevel(level)
-            msg = f"Logging level set to {level} for ALL 'egse' loggers"
-        elif name in logging.root.manager.loggerDict:
-            logger = logging.getLogger(name)
-            logger.setLevel(level)
-            msg = f"Logging level for {name} set to {level}."
-        else:
-            msg = f"Logger with name '{name}' doesn't exist at the server side."
-
-        # self.control_server.set_logging_level(level)
-        logging.debug(msg)
-        self.send(msg)
-
-    def handle_quit(self):
-        LOGGER.info(f"Sending interrupt to {self.control_server.__class__.__name__}.")
-        self.control_server.quit()
-        self.send(f"Sent interrupt to {self.control_server.__class__.__name__}.")
-
-    def handle_get_process_status(self):
-        LOGGER.debug(f"Asking for process status of {self.control_server.__class__.__name__}.")
-        self.send(self.get_status())
-
-    def handle_get_cs_module(self):
-        """
-        Returns the module in which the control server has been implemented.
-        """
-        LOGGER.debug(f"Asking for module of {self.control_server.__class__.__name__}.")
-        self.send(inspect.getmodule(self.control_server).__spec__.name)
-
-    def handle_get_average_execution_times(self):
-        LOGGER.debug(f"Asking for average execution times of {self.control_server.__class__.__name__} functions.")
-        self.send(self.control_server.get_average_execution_times())
-
-    def handle_get_storage_mnemonic(self):
-        LOGGER.debug(f"Asking for the storage menmonic of {self.control_server.__class__.__name__}.")
-        self.send(self.control_server.get_storage_mnemonic())
-
-class ServiceInterface:
-    @dynamic_interface
-    def set_monitoring_frequency(self, freq: float):
-        ...
-    @dynamic_interface
-    def set_hk_frequency(self, freq: float):
-        ...
-    @dynamic_interface
-    def set_logging_level(self, name: str, level: int):
-        ...
-    @dynamic_interface
-    def quit_server(self):
-        ...
-    @dynamic_interface
-    def get_process_status(self):
-        ...
-    @dynamic_interface
-    def get_cs_module(self):
-        ...
-    @dynamic_interface
-    def get_average_execution_times(self):
-        ...
-    @dynamic_interface
-    def get_storage_mnemonic(self):
-        ...
-
-class ServiceProxy(Proxy, ServiceInterface):
-    """
-    A ServiceProxy is a simple class that forwards service commands to a control server.
-    """
-
-    def __init__(self, ctrl_settings=None, *, protocol=None, hostname=None, port=None):
-        """
-        A ServiceProxy can be configured from the specific control server settings, or additional
-        arguments `protocol`, `hostname` and `port` can be passed.
-
-        The additional arguments always overwrite the values loaded from ctrl_settings. Either ctrl_settings or
-        hostname and port must be provided, protocol is optional and defaults to 'tcp'.
-
-        Args:
-            ctrl_settings: an AttributeDict with HOSTNAME, PORT and PROTOCOL attributes
-            protocol: the transport protocol [default: tcp]
-            hostname: the IP addrress of the control server
-            port: the port on which the control server is listening for service commands
-        """
-        _protocol = _hostname = _port = None
-        if ctrl_settings:
-            _protocol = ctrl_settings.PROTOCOL
-            _hostname = ctrl_settings.HOSTNAME
-            _port = ctrl_settings.SERVICE_PORT
-
-        # the protocol argument is overwriting the standard crtl_settings
-
-        if protocol:
-            _protocol = protocol
-
-        # if still _protocol is not set, neither by ctrl_settings, nor by the protocol argument, use a default
-
-        if _protocol is None:
-            _protocol = 'tcp'
-
-        if hostname:
-            _hostname = hostname
-        if port:
-            _port = port
-
-        if _hostname is None or _port is None:
-            raise ValueError("Expected ctrl-settings or hostname and port as arguments")
-
-        super().__init__(connect_address(_protocol, _hostname, _port))

egse/services.yaml

@@ -1,51 +0,0 @@
-
-ProxyClass:
-    egse.services.ServiceProxy
-
-ClassDescription:
-    The Service Proxy class is used to send control commands to any of the control servers.
-
-Commands:
-
-    set_monitoring_frequency:
-        description:   Sets the monitoring frequency (Hz) to the given freq value.
-        cmd:           '{freq}'
-        device_method: None
-        response:      handle_set_monitoring_frequency
-
-    set_hk_frequency:
-        description:    Sets the housekeeping frequency (Hz) to the given freq value.
-        cmd:           '{freq}'
-        device_method: None
-        response:      handle_set_hk_frequency
-
-    set_logging_level:
-        description:   Set the logging level for the logger with the given name.
-        cmd:           '{name} {level}'
-        device_method: None
-        response:      handle_set_logging_level
-
-    quit_server:
-        description:   Send an interrupt to the control server. The server will close all connections and exit.
-        device_method: None
-        response:      handle_quit
-
-    get_process_status:
-        description:   Ask for the process status of the control server.
-        device_method: None
-        response:      handle_get_process_status
-
-    get_cs_module:
-        description:   Returns the module in which the control server has been implemented.
-        device_method: None
-        response:      handle_get_cs_module
-
-    get_average_execution_times:
-        description:    Returns a dictionary with the average execution times of the get_housekeeping and get_status methods
-        device_method:  None
-        response:       handle_get_average_execution_times
-
-    get_storage_mnemonic:
-        description:    Returns the mnemonic that is part of the filename where the housekeeping data are stored.
-        device_method:  None
-        response:       handle_get_storage_mnemonic