cgse 2024.7.0__py3-none-any.whl → 2025.0.2__py3-none-any.whl

egse/search.py

@@ -1,182 +0,0 @@
-"""
-The search module defines some generic search functions.
-
-This code is taken from the book:
-
-    Classic Computer Science Problems in Python, David Kopec, 2019.
-"""
-from __future__ import annotations
-
-from collections import deque
-from typing import TypeVar, Iterable, Sequence, Generic, List, \
-    Callable, Set, Deque, Dict, Any, Optional
-from typing_extensions import Protocol
-from heapq import heappush, heappop
-
-T = TypeVar('T')
-
-
-def linear_contains(iterable: Iterable[T], key: T) -> bool:
-    for item in iterable:
-        if item == key:
-            return True
-    return False
-
-
-# Note that Protocol is used here to define the Comparable type with structural
-# sub-typing. A Comparable type implements the comparison operators.
-# Protocol is defined in PEP-544 [https://www.python.org/dev/peps/pep-0544/]
-
-C = TypeVar('C', bound='Comparable')
-
-
-class Comparable(Protocol):
-    def __eq__(self, other: Any) -> bool:
-        ...
-
-    def __lt__(self: C, other: C) -> bool:
-        ...
-
-    def __gt__(self: C, other: C) -> bool:
-        return (not self < other) and self != other
-
-    def __le__(self: C, other: C) -> bool:
-        return self < other or self == other
-
-    def __ge__(self: C, other: C) -> bool:
-        return not self < other
-
-
-def binary_contains(sequence: Sequence[C], key: C) -> bool:
-    low: int = 0
-    high: int = len(sequence) - 1
-    while low <= high:  # while there is still a search space
-        mid: int = (low + high) // 2
-        if sequence[mid] < key:
-            low = mid + 1
-        elif sequence[mid] > key:
-            high = mid - 1
-        else:
-            return True
-    return False
-
-
-class Stack(Generic[T]):
-    def __init__(self) -> None:
-        self._container: List[T] = []
-
-    @property
-    def empty(self) -> bool:
-        return not self._container
-
-    def push(self, item: T) -> None:
-        self._container.append(item)
-
-    def pop(self) -> T:
-        return self._container.pop()  # LIFO
-
-    def __repr__(self) -> str:
-        return repr(self._container)
-
-
-class Node(Generic[T]):
-    def __init__(self, state: T, parent: Optional[Node], cost: float = 0.0, heuristic: float = 0.0) -> None:
-        self.state: T = state
-        self.parent: Optional[Node] = parent
-        self.cost: float = cost
-        self.heuristic: float = heuristic
-
-    def __lt__(self, other: Node) -> bool:
-        return (self.cost + self.heuristic) < (other.cost + other.heuristic)
-
-
-def depth_first_search(initial: T, goal_test: Callable[[T], bool], successors: Callable[[T], List[T]]) -> Optional[Node[T]]:
-    """
-    The depth-first search (DFS) algorithm goes as deeply as it can before backtracking to its
-    last decision point if it reaches a dead end.
-
-    Args:
-        initial: starting point for the search
-        goal_test: function that defines if the goal is reached or not
-        successors: function that returns all possible states that can be visited next
-
-    Returns:
-        the Node encapsulating the goal state if successful, otherwise None.
-    """
-    frontier: Stack[Node[T]] = Stack()
-    frontier.push(Node(initial, None))
-    explored: Set[T] = set(initial)
-
-    while not frontier.empty:
-        current_node: Node[T] = frontier.pop()
-        current_state: T = current_node.state
-
-        if goal_test(current_state):
-            return current_node
-
-        for child in successors(current_state):
-            if child in explored:
-                continue
-            explored.add(child)
-            frontier.push(Node(child, current_node))
-
-    return None  # we went through everything and never found goal
-
-
-def node_to_path(node: Node[T]) -> List[T]:
-    """
-    Returns the path that was followed from a starting state to reach a goal.
-
-    Args:
-        node:
-
-    Returns:
-        a list of states that were visited to reach the final goal.
-    """
-    path: List[T] = [node.state]
-
-    while node.parent is not None:
-        node = node.parent
-        path.append(node.state)
-    path.reverse()
-    return path
-
-
-class Queue(Generic[T]):
-    def __init__(self) -> None:
-        self._container: Deque[T] = deque()
-
-    @property
-    def empty(self) -> bool:
-        return not self._container
-
-    def push(self, item: T) -> None:
-        self._container.append(item)
-
-    def pop(self) -> T:
-        return self._container.popleft()
-
-    def __repr__(self) -> str:
-        return repr(self._container)
-
-
-def breadth_first_search(initial: T, goal_test: Callable[[T], bool], successors: Callable[[T], List[T]]) -> Optional[Node[T]]:
-    frontier: Queue[Node[T]] = Queue()
-    frontier.push(Node(initial, None))
-    explored: Set[T] = set(initial)
-
-    while not frontier.empty:
-        current_node: Node[T] = frontier.pop()
-        current_state: T = current_node.state
-
-        if goal_test(current_state):
-            return current_node
-
-        for child in successors(current_state):
-            if child in explored:
-                continue
-            explored.add(child)
-            frontier.push(Node(child, current_node))
-
-    return None  # we went through everything and never found goal
-

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,247 +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())
-
-    def handle_add_listener(self, listener: dict):
-        LOGGER.debug(f"Add listener to {self.control_server.__class__.__name__}: {listener}")
-        try:
-            self.control_server.listeners.add_listener(listener)
-            LOGGER.info(f"Registered listener: {listener['name']} with proxy {listener['proxy']}")
-            self.send(("ACK",))
-        except ValueError as exc:
-            self.send(("NACK", exc))  # Why not send back a failure object?
-
-    def handle_remove_listener(self, listener: dict):
-        LOGGER.debug(f"Remove listener from {self.control_server.__class__.__name__}: {listener}")
-        try:
-            self.control_server.listeners.remove_listener(listener)
-            LOGGER.info(f"Removed listener: {listener['name']}")
-            self.send(("ACK",))
-        except ValueError as exc:
-            self.send(("NACK", exc))  # Why not send back a failure object?
-
-    def handle_get_listener_names(self):
-        LOGGER.debug(f"Get names of registered listener from {self.control_server.__class__.__name__}")
-        try:
-            names = self.control_server.listeners.get_listener_names()
-            self.send((names,))
-        except ValueError as exc:
-            self.send(("", exc))  # Why not sent back a Failure object?
-
-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):
-        ...
-    @dynamic_interface
-    def add_listener(self, listener: dict):
-        ...
-    @dynamic_interface
-    def remove_listener(self, listener: dict):
-        ...
-    @dynamic_interface
-    def get_listener_names(self, listener: dict):
-        ...
-
-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,68 +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
-
-    add_listener:
-        description:    Adds a Listener process to be notified on special events.
-        cmd:            '{listener}'
-        device_method:  None
-        response:       handle_add_listener
-
-    remove_listener:
-        description:    Remove a Listener process.
-        cmd:            '{listener}'
-        device_method:  None
-        response:       handle_remove_listener
-
-    get_listener_names:
-        description:    Get the names of the registered Listener processes.
-        device_method:  None
-        response:       handle_get_listener_names