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

egse/proxy.py

@@ -1,531 +0,0 @@
-"""
-The Proxy module provides the base class for the Proxy objects for each device
-controller.
-
-The module also provides the connection state interface and classes for
-maintaining the state of the Proxy connection to the control server.
-"""
-import logging
-import pickle
-import types
-from types import MethodType
-
-import zmq
-
-from egse.control import Failure
-from egse.decorators import dynamic_interface
-from egse.mixin import DynamicClientCommandMixin
-from egse.system import AttributeDict
-from egse.zmq_ser import split_address
-
-
-def set_docstring(func, cmd):
-    """Decorator to set the docstring of the command on the dynamic method / function."""
-
-    def wrap_func(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    wrap_func.__doc__ = cmd.__doc__
-    wrap_func.__name__ = f"{cmd.get_name()}"
-    return wrap_func
-
-
-REQUEST_TIMEOUT = 6250
-REQUEST_RETRIES = 0
-
-
-class ControlServerConnectionInterface:
-    """This interface defines the connection commands for control servers.
-
-    This interface shall be implemented by the Proxy class and guarantees that connection commands
-    do not interfere with the commands defined in the `DeviceConnectionInterface` (which will be
-    loaded from the control server).
-    """
-
-    def __enter__(self):
-        self.connect_cs()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.disconnect_cs()
-
-    @dynamic_interface
-    def connect_cs(self):
-        """Connect to the control server.
-
-        Raises:
-            ConnectionError: when the connection can not be established.
-        """
-        raise NotImplementedError
-
-    @dynamic_interface
-    def reconnect_cs(self):
-        """Reconnect the control server after it has been disconnected.
-
-        Raises:
-            ConnectionError: when the connection can not be established.
-        """
-        raise NotImplementedError
-
-    @dynamic_interface
-    def disconnect_cs(self):
-        """Disconnect from the control server.
-
-        Raises:
-            ConnectionError: when the connection can not be closed.
-        """
-        raise NotImplementedError
-
-    @dynamic_interface
-    def reset_cs_connection(self):
-        """Resets the connection to the control server."""
-        raise NotImplementedError
-
-    @dynamic_interface
-    def is_cs_connected(self) -> bool:
-        """Check if the control server is connected.
-
-        Returns:
-            True if the device is connected and responds to a command, False otherwise.
-        """
-        raise NotImplementedError
-
-
-class BaseProxy(ControlServerConnectionInterface):
-    def __init__(self, endpoint, timeout: int = REQUEST_TIMEOUT):
-        """
-        The `timeout` argument specifies the number of milliseconds to wait for a reply from the
-        control server.
-        """
-
-        self._logger = logging.getLogger(self.__class__.__name__)
-
-        self._ctx = zmq.Context.instance()
-        self._poller = zmq.Poller()
-        self._socket = None
-        self._endpoint = endpoint
-        self._timeout = timeout
-
-        self.connect_cs()
-
-    def __enter__(self):
-        if not self.ping():
-            raise ConnectionError(f"Proxy is not connected to endpoint ({self._endpoint}) when entering the context.")
-
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if not self._socket.closed:
-            self.disconnect_cs()
-
-    def connect_cs(self):
-        self._logger.log(0, f"Trying to connect {self.__class__.__name__} to {self._endpoint}")
-
-        self._socket = self._ctx.socket(zmq.REQ)
-        self._socket.connect(self._endpoint)
-        self._poller.register(self._socket, zmq.POLLIN)
-
-    def disconnect_cs(self):
-        self._socket.setsockopt(zmq.LINGER, 0)
-        self._socket.close()
-        self._poller.unregister(self._socket)
-
-    def reconnect_cs(self):
-        self._logger.log(20, f"Trying to reconnect {self.__class__.__name__} to {self._endpoint}")
-
-        if not self._socket.closed:
-            self._socket.close(linger=0)
-
-        self._socket = self._ctx.socket(zmq.REQ)
-        self._socket.connect(self._endpoint)
-        self._poller.register(self._socket, zmq.POLLIN)
-
-    def reset_cs_connection(self):
-        self._logger.log(
-            10, f"Trying to reset the connection from {self.__class__.__name__} to {self._endpoint}"
-        )
-
-        self.disconnect_cs()
-        self.connect_cs()
-
-    def is_cs_connected(self) -> bool:
-        return self.ping()
-
-    def send(self, data, retries: int = REQUEST_RETRIES, timeout: int = None):
-        """
-        Sends a command to the control server and waits for a response.
-
-        When not connected to the control server or when a timeout occurs, the
-        ``send()`` command retries a number of times to send the command.
-
-        The number of retries is hardcoded and currently set to '2', the request
-        timeout is set to 2.5 seconds.
-
-        The command data will be pickled before sending. Make sure the ``data``
-        argument can be dumped by pickle.
-
-        Args:
-            data (str): the command that is sent to the control server, usually a
-                string, but that is not enforced.
-            timeout (int): the time to wait for a reply [in milliseconds]
-            retries (int): the number of time we should retry to send the message
-
-        Returns:
-            response: the response from the control server or ``None`` when there was
-                a problem or a timeout.
-        """
-        timeout = timeout or self._timeout
-
-        pickle_string = pickle.dumps(data)
-
-        retries_left = retries
-
-        # When we enter this method, we assume the Proxy has been connected. It
-        # might be the server is not responding, but that is handled by the
-        # algorithm below where we have a number of retries to receive the response
-        # of the sent command. Remember that we are using ZeroMQ where the connect
-        # method returns gracefully even when no server is available.
-
-        if self._socket.closed:
-            self.reconnect_cs()
-
-        self._logger.log(0, f"Sending '{data}'")
-        self._socket.send(pickle_string)
-
-        while True:
-            socks = dict(self._poller.poll(timeout))
-
-            if self._socket in socks and socks[self._socket] == zmq.POLLIN:
-                pickle_string = self._socket.recv()
-                if not pickle_string:
-                    break
-                response = pickle.loads(pickle_string)
-                self._logger.log(0, f"Receiving response: {response}")
-                return response
-            else:
-                # timeout - server unavailable
-
-                # We should disconnect here because socket is possibly confused.
-                # Close the socket and remove from the poller.
-
-                self.disconnect_cs()
-
-                if retries_left == 0:
-                    self._logger.critical("Control Server seems to be off-line, abandoning")
-                    return None
-                retries_left -= 1
-
-                self._logger.log(logging.CRITICAL, f"Reconnecting {self.__class__.__name__}, {retries_left=}")
-
-                self.reconnect_cs()
-
-                # Now try to send the request again
-
-                self._socket.send(pickle_string)
-
-    def ping(self):
-        return_code = self.send("Ping", retries=0, timeout=1000)
-        self._logger.log(0, f"Check if control server is available: Ping - {return_code}")
-        return return_code == "Pong"
-
-    def get_endpoint(self):
-        """ Returns the endpoint."""
-        return self._endpoint
-
-    def get_monitoring_port(self) -> int:
-        """ Returns the monitoring port. """
-        return self.send("get_monitoring_port")
-
-    def get_commanding_port(self) -> int:
-        """ Returns the commanding port."""
-        return self.send("get_commanding_port")
-
-    def get_service_port(self) -> int:
-        """ Returns the service port. """
-        return self.send("get_service_port")
-
-    def get_ip_address(self) -> int:
-        """ Returns the hostname of the control server."""
-        return self.send("get_ip_address")
-
-    def get_service_proxy(self):
-        """Return a ServiceProxy for the control server of this proxy object."""
-        from egse.services import ServiceProxy  # prevent circular import problem
-
-        transport, address, _ = split_address(self._endpoint)
-
-        port = self.send("get_service_port")
-
-        return ServiceProxy(
-            AttributeDict({"PROTOCOL": transport, "HOSTNAME": address, "SERVICE_PORT": port})
-        )
-
-
-class DynamicProxy(BaseProxy, DynamicClientCommandMixin):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-
-# TODO (rik): remove all methods from Proxy that are also define in the BaseProxy
-
-class Proxy(BaseProxy, ControlServerConnectionInterface):
-    """
-    A Proxy object will forward CommandExecutions to the connected control server
-    and wait for a response. When the Proxy can not connect to its control server
-    during initialization, a ConnectionError will be raised.
-    """
-
-    def __init__(self, endpoint, timeout: int = REQUEST_TIMEOUT):
-        """
-        During initialization, the Proxy will connect to the control server and send a
-        handshaking `Ping` command. When that succeeds the Proxy will request and load the
-        available commands from the control server. When the connection with the control server
-        fails, no commands are loaded and the Proxy is left in a 'disconnected' state. The caller
-        can fix the problem with the control server and call `connect_cs()`, followed by a call to
-        `load_commands()`.
-
-        The `timeout` argument specifies the number of milliseconds
-        """
-
-        super().__init__(endpoint, timeout)
-
-        self._commands = {}
-
-        if self.ping():
-            self.load_commands()
-        else:
-            self._logger.warning(
-                f"{self.__class__.__name__} could not connect to its control server at {endpoint}. "
-                f"No commands have been loaded."
-            )
-
-    def __enter__(self):
-        if not self.ping():
-            raise ConnectionError("Proxy is not connected when entering the context.")
-
-        # The following check is here because a CS might have come alive between the __init__
-        # and __enter__ calls, and while the ping() will reconnect, the Proxy will have no
-        # commands loaded.
-
-        if not self.has_commands():
-            self.load_commands()
-
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if not self._socket.closed:
-            self.disconnect_cs()
-
-    def connect_cs(self):
-        self._logger.log(0, f"Trying to connect {self.__class__.__name__} to {self._endpoint}")
-
-        self._socket = self._ctx.socket(zmq.REQ)
-        self._socket.connect(self._endpoint)
-        self._poller.register(self._socket, zmq.POLLIN)
-
-    def disconnect_cs(self):
-        self._socket.setsockopt(zmq.LINGER, 0)
-        self._socket.close()
-        self._poller.unregister(self._socket)
-
-    def reconnect_cs(self):
-        self._logger.log(20, f"Trying to reconnect {self.__class__.__name__} to {self._endpoint}")
-
-        if not self._socket.closed:
-            self._socket.close(linger=0)
-
-        self._socket = self._ctx.socket(zmq.REQ)
-        self._socket.connect(self._endpoint)
-        self._poller.register(self._socket, zmq.POLLIN)
-
-    def reset_cs_connection(self):
-        self._logger.log(
-            10, f"Trying to reset the connection from {self.__class__.__name__} to {self._endpoint}"
-        )
-
-        self.disconnect_cs()
-        self.connect_cs()
-
-    def is_cs_connected(self) -> bool:
-        return self.ping()
-
-    def send(self, data, retries: int = REQUEST_RETRIES, timeout: int = None):
-        """
-        Sends a command to the control server and waits for a response.
-
-        When not connected to the control server or when a timeout occurs, the
-        ``send()`` command retries a number of times to send the command.
-
-        The number of retries is hardcoded and currently set to '2', the request
-        timeout is set to 2.5 seconds.
-
-        The command data will be pickled before sending. Make sure the ``data``
-        argument can be dumped by pickle.
-
-        Args:
-            data (str): the command that is sent to the control server, usually a
-                string, but that is not enforced.
-            timeout (int): the time to wait for a reply [in milliseconds]
-            retries (int): the number of time we should retry to send the message
-
-        Returns:
-            response: the response from the control server or ``None`` when there was
-                a problem or a timeout.
-        """
-        timeout = timeout or self._timeout
-
-        pickle_string = pickle.dumps(data)
-
-        retries_left = retries
-
-        # When we enter this method, we assume the Proxy has been connected. It
-        # might be the server is not responding, but that is handled by the
-        # algorithm below where we have a number of retries to receive the response
-        # of the sent command. Remember that we are using ZeroMQ where the connect
-        # method returns gracefully even when no server is available.
-
-        if self._socket.closed:
-            self.reconnect_cs()
-
-        self._logger.log(0, f"Sending '{data}'")
-        self._socket.send(pickle_string)
-
-        while True:
-            socks = dict(self._poller.poll(timeout))
-
-            if self._socket in socks and socks[self._socket] == zmq.POLLIN:
-                pickle_string = self._socket.recv()
-                if not pickle_string:
-                    break
-                response = pickle.loads(pickle_string)
-                self._logger.log(0, f"Receiving response: {response}")
-                return response
-            else:
-                # timeout - server unavailable
-
-                # We should disconnect here because socket is possibly confused.
-                # Close the socket and remove from the poller.
-
-                self.disconnect_cs()
-
-                if retries_left == 0:
-                    self._logger.critical(f"Control Server seems to be off-line, abandoning ({data})")
-                    from egse.control import Failure
-                    return Failure(f"Control Server seems to be off-line, abandoning ({data})")
-                retries_left -= 1
-
-                self._logger.log(logging.CRITICAL, f"Reconnecting {self.__class__.__name__}, {retries_left=}")
-
-                self.reconnect_cs()
-
-                # Now try to send the request again
-
-                self._socket.send(pickle_string)
-
-    def _request_commands(self):
-        response = self.send("send_commands")
-        if isinstance(response, Failure):
-            raise response
-        self._commands = response
-
-    def _add_commands(self):
-        for key in self._commands:
-            if hasattr(self, key):
-                attribute = getattr(self, key)
-                if isinstance(attribute, types.MethodType) and not hasattr(
-                    attribute, "__dynamic_interface"
-                ):
-                    self._logger.warning(
-                        f"{self.__class__.__name__} already has an attribute '{key}', "
-                        f"not overwriting."
-                    )
-                    continue
-            command = self._commands[key]
-            new_method = MethodType(command.client_call, self)
-            new_method = set_docstring(new_method, command)
-            setattr(self, key, new_method)
-
-    def get_service_proxy(self):
-        """Return a ServiceProxy for the control server of this proxy object."""
-        from egse.services import ServiceProxy  # prevent circular import problem
-
-        transport, address, _ = split_address(self._endpoint)
-
-        port = self.send("get_service_port")
-
-        return ServiceProxy(
-            AttributeDict({"PROTOCOL": transport, "HOSTNAME": address, "SERVICE_PORT": port})
-        )
-
-    def load_commands(self):
-        """
-        Requests all available commands from the control server and adds them to
-        the Proxy public interface, i.e. each command will become a method for
-        this Proxy.
-
-        A warning will be issued when a command will overwrite an existing method
-        of the Proxy class. The original method will not be overwritten and the
-        behavior of the Proxy command will not be what is expected.
-        """
-        # bind the client_call method from each Command to this Proxy object
-        if self.is_cs_connected():
-            try:
-                self._request_commands()
-            except Failure as exc:
-                self._logger.warning(f"Failed to request commands for {self.__class__.__name__}: {exc}")
-                return False
-            else:
-                self._add_commands()
-                return True
-        else:
-            self._logger.warning(f"{self.__class__.__name__} is not connected, try to reconnect.")
-            return False
-
-    def get_commands(self):
-        """
-        Returns a list of command names that can be send to the device or the
-        control server.
-
-        The commands are defined in the YAML settings file of the device.
-        Special commands are available for the ServiceProxy which configure and
-        control the control servers.
-        """
-        return list(self._commands.keys())
-
-    def has_commands(self):
-        """Return `True` if commands have been loaded."""
-        return bool(self._commands)
-
-    def ping(self):
-        return_code = self.send("Ping", retries=0, timeout=1000)
-        self._logger.log(0, f"Check if control server is available: Ping - {return_code}")
-        return return_code == "Pong"
-
-    def get_endpoint(self):
-        """ Returns the endpoint.
-
-        Returns:
-            - Endpoint.
-        """
-
-        return self._endpoint
-
-    def get_monitoring_port(self) -> int:
-        """ Returns the monitoring port. """
-
-        return self.send("get_monitoring_port")
-
-    def get_commanding_port(self) -> int:
-        """ Returns the commanding port."""
-
-        return self.send("get_commanding_port")
-
-    def get_service_port(self) -> int:
-        """ Returns the service port. """
-
-        return self.send("get_service_port")
-
-    def get_ip_address(self) -> int:
-        """ Returns the hostname of the control server."""
-
-        return self.send("get_ip_address")

egse/randomwalk.py

@@ -1,140 +0,0 @@
-"""
-This module implements a random walk that can be used in simulators for devices like temperature sensors or power meter.
-"""
-from __future__ import annotations
-
-import random
-import sys
-from typing import Optional
-
-
-# Re-implement based on:
-#
-# 1. https://isquared.digital/blog/2020-04-12-random-walk/
-# 2. https://isquared.digital/blog/2020-04-16-brownian-motion/
-# 3. https://isquared.digital/blog/2020-05-01-drifted-brownian-motion/
-
-class RandomWalk:
-    """
-    This class implements a random walk.
-
-    The RandomWalk is an iterator which can be used in a for loop:
-
-    ```Python
-    import matplotlib.pyplot as plt
-    values = [value for value in RandomWalk(start=15.0, boundary=(-100, 25), scale=0.01, count=10000)]
-    plt.plot(values)
-    plt.show()
-    ```
-
-    The code above will create a plot like below, where 10000 values are plot in a random walk between -100 and 25,
-    starting at 15:
-
-    ![Random Walk example](../../img/screenshot-randomwalk.png)
-
-    When you need a random walk that will return values infinitely, set count = 0.
-
-    By default, the returned values will represent a random walk between -1.0 and 1.0 in a step of 1.0.
-    """
-    def __init__(self, start: float = 0.0, boundary: tuple = (-1.0, 1.0), threshold: tuple | float = 0.5,
-                 scale: float = 1.0, count: int = 1000, seed: Optional[int] = None):
-        """
-
-        Args:
-            start: the start value for the random walk [default = 0.0]
-            boundary: the lower and upper boundaries [default = (-1.0, 1.0)]
-            threshold: the probability to move up or down [default = 0.5]
-            scale: scale the step size [default = 1.0]
-            count: the number of iterations, when <= 0 count will be basically infinite [default = 1000]
-            seed: seed for the initialization of the random generator [default = None]
-        """
-        self._threshold_up = threshold[1] if isinstance(threshold, tuple) else threshold
-        self._threshold_down = threshold[0] if isinstance(threshold, tuple) else threshold
-        self._boundary = boundary
-        self._min_value, self._max_value = boundary
-        self._count = count if count > 0 else sys.maxsize
-        self._start = start
-        self._last = start
-        self._scale = scale
-        self._seed = seed
-        self._random = random.Random()
-
-        if seed is not None:
-            self._random.seed(seed)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        if self._count > 0:
-            probability = self._random.random()
-            if probability > self._threshold_up:
-                value = self._last + self._scale
-                value = min(value, self._max_value)
-            elif probability < self._threshold_down:
-                value = self._last - self._scale
-                value = max(value, self._min_value)
-            else:
-                value = self._last
-            self._last = value
-            self._count -= 1
-            return value
-        raise StopIteration
-
-
-if __name__ == "__main__":
-
-    # https://towardsdatascience.com/generating-synthetic-time-series-data-with-random-walks-8701bb9a56a8
-
-    import matplotlib.pyplot as plt
-
-    # Random Walk, each time a different seed by default
-
-    y1 = RandomWalk(start=50.0, boundary=(0, 100), threshold=(0.25, 0.70), scale=1, count=1000)
-    # y2 = RandomWalk(start=50.0, boundary=(0, 100), threshold=0.49, scale=0.05, count=100000, seed=0)
-    # y3 = RandomWalk(start=50.0, boundary=(0, 100), threshold=0.48, scale=0.01, count=100000, seed=0)
-    # plt.plot(list(zip(y1, y2, y3)))
-    plt.plot(list(y1))
-    plt.show()
-
-    y1 = RandomWalk(start=50.0, boundary=(0, 100), threshold=0.5, scale=0.2, count=100000, seed=0)
-    y2 = RandomWalk(start=50.0, boundary=(0, 100), threshold=0.51, scale=0.2, count=100000, seed=0)
-    y3 = RandomWalk(start=50.0, boundary=(0, 100), threshold=0.52, scale=0.2, count=100000, seed=0)
-    plt.plot(list(zip(y1, y2, y3)))
-    plt.show()
-
-    y1 = RandomWalk(start=75.0, boundary=(0, 100), threshold=0.5, scale=0.2, count=100000, seed=0)
-    y2 = RandomWalk(start=50.0, boundary=(0, 100), threshold=0.5, scale=0.2, count=100000, seed=0)
-    y3 = RandomWalk(start=25.0, boundary=(0, 100), threshold=0.5, scale=0.2, count=100000, seed=0)
-    plt.plot(list(zip(y1, y2, y3)))
-    plt.show()
-
-    # Three random walks, two of them are fixed and reproducible
-
-    rng1 = RandomWalk(start=15.0, boundary=(-20, 25), scale=0.8, count=10000, seed=1)
-    rng2 = RandomWalk(start=15.0, boundary=(-20, 25), scale=0.5, count=10000, seed=1)
-    rng3 = RandomWalk(start=15.0, boundary=(-20, 25), scale=0.3, count=10000, seed=1)
-
-    values = list(zip(rng1, rng2, rng3))
-    plt.plot(values)
-    plt.ylim(-20, 25)
-    plt.show()
-
-    # Example 1:
-
-    rw = RandomWalk(start=25.0, boundary=(-100, 100), scale=0.2, count=0, seed=42)
-    values = [next(rw) for _ in range(1000000)]
-    plt.plot(values)
-    plt.show()
-
-    # Example 2: should give the same output as example 1
-
-    plt.plot(
-        list(RandomWalk(start=25.0, boundary=(-100, 100), scale=0.2, count=1000000, seed=42,))
-    )
-    plt.show()
-
-    # Example 3:
-
-    for i, value in enumerate(RandomWalk(start=25.0, boundary=(-100, 100), threshold=0.5, scale=2, count=20)):
-        print(f"{i}, {value}")