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

egse/shutter/thorlabs/sc10.yaml

@@ -1,52 +0,0 @@
-BaseClass:
-    egse.shutter.thorlabs.sc10_interface.Sc10Interface
-
-ProxyClass:
-    egse.shutter.thorlabs.sc10.Sc10Proxy
-
-ControlServer:
-    egse.shutter.thorlabs.sc10_cs
-
-Commands:
-
-    disconnect:
-        description:        Disconnect from the device.
-
-    connect:
-        description:        Connect to the device.
-
-    reconnect:
-        description:        Reconnect to the device.
-                            This command will force a disconnect and then try to re-connect to the controller.
-    is_connected:
-        description:        Check if the Thorlabs Hardware Controller is connected.
-
-    is_simulator:
-        description:        Ask if the control server is a simulator instead of the real controller class.
-        returns:            bool | True if the far end is a simulator instead of the real hardware
-
-    get_idn:
-        description:    Read the device ID string.
-        cmd:            "id?\r"
-        returns:        str | Model number and version revision
-
-    get_enable:
-        description:    Check if the device is enabled.
-        cmd:            "ens?\r"
-        returns:        bool | True if enabled
-
-    toggle_enable:
-        description:    Toggle the enable.
-        cmd:            "ens\r"
-
-    set_mode:
-        description:    Set the mode of operation. 1 - manual, 2 - auto, 3 - signal, 4 - repeat, 5 - external gate
-        args:
-            mode:       int | mode of operation
-        cmd:            "mode={mode}\r"
-
-    set_open_duration:
-        description:    Set shutter open time.
-        args:
-            duration:   int | time in ms [0 - 999999]
-        cmd:            "open={duration}\r"

egse/shutter/thorlabs/sc10_controller.py

@@ -1,81 +0,0 @@
-import logging
-
-from egse.serialdevice import SerialDevice
-from egse.command import Command
-from egse.settings import Settings
-from egse.shutter.thorlabs.sc10_interface import Sc10Interface
-
-logger = logging.getLogger(__name__)
-
-# Load the device settings from the global common-egse config file
-DEVICE_SETTINGS = Settings.load("Thorlabs SC10 Controller")
-
-# Load the device protocol
-DEVICE_PROTOCOL = Settings.load(filename='sc10.yaml')['Commands']
-
-
-class Sc10Controller(SerialDevice, Sc10Interface):
-
-    def __init__(self, port=None, baudrate=None, address=None):
-
-        # Load device configuration from the common-egse global config file
-        self._port     = DEVICE_SETTINGS.PORT if port is None else port
-        self._baudrate = DEVICE_SETTINGS.BAUDRATE if baudrate is None else baudrate
-
-        # Create a dict of Command objects for each function
-        self._commands = {}
-        for name, items in DEVICE_PROTOCOL.items():
-            if 'cmd' in items:
-                self._commands[name] = Command(name, items['cmd'])
-
-        # Initialize the parent class with the port and baudrate
-        super().__init__(port=self._port, baudrate=self._baudrate, terminator='\r', timeout=1)
-        self.connect()
-
-
-    def get_idn(self):
-        return self.query(self._commands['get_idn'].get_cmd_string())
-
-
-    def get_enable(self):
-        return self.query(self._commands['get_enable'].get_cmd_string()) == "1\r"
-
-
-    def toggle_enable(self):
-        return self.query(self._commands['toggle_enable'].get_cmd_string())
-
-
-    def set_mode(self, mode):
-        return self.query(self._commands['set_mode'].get_cmd_string(mode=mode))
-
-
-    def set_open_duration(self, duration):
-        return self.query(self._commands['set_open_duration'].get_cmd_string(duration=duration))
-
-
-    def query(self, command: str):
-        """ Override the parent class to do some error checking on the response. """
-
-        # The device first echos the command with a promt and then sends the response.
-        # To handle this, the device is read twice.
-        _ = super().query(command)
-        response = self.read()
-
-        if len(response) == 0:
-            raise ConnectionError(f"No reply from device")
-
-        return response
-
-
-def main():
-    logging.basicConfig()
-
-    dev = Sc10Controller()
-    print(dev.get_idn())
-    print(dev.get_enable())
-    dev.toggle_enable()
-    print(dev.get_enable())
-
-
-if __name__ == '__main__':
-    main()

egse/shutter/thorlabs/sc10_cs.py

@@ -1,108 +0,0 @@
-import click
-import logging
-import sys
-
-import zmq
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.shutter.thorlabs.sc10 import Sc10Protocol, Sc10Proxy
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Thorlabs SC10 Control Server")
-
-
-class Sc10ControlServer(ControlServer):
-    """
-    Sc10ControlServer - Command and monitor the Sc10 pressure sensor.
-    This class works as a command and monitoring server to control the device remotely.
-    The sever binds to the following ZeroMQ sockets:
-    * a REP socket that can be used as a command server. Any client can connect and
-      send a command to the Lamp controller.
-    * a PUB socket that serves as a monitoring server. It will send out Lamp status
-      information to all the connected clients every DELAY seconds.
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = Sc10Protocol(self)
-
-        self.logger.debug(f"Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}")
-
-        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
-
-        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
-
-    def get_communication_protocol(self):
-        return CTRL_SETTINGS.PROTOCOL
-
-    def get_commanding_port(self):
-        return CTRL_SETTINGS.COMMANDING_PORT
-
-    def get_service_port(self):
-        return CTRL_SETTINGS.SERVICE_PORT
-
-    def get_monitoring_port(self):
-        return CTRL_SETTINGS.MONITORING_PORT
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except AttributeError:
-            return "SC10"
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the SC10 Simulator as the backend.")
-def start(simulator):
-    """Start the SC10 Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        controller = Sc10ControlServer()
-        controller.serve()
-
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-
-    except SystemExit as exit_code:
-        print("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-
-    except Exception:
-
-        logger.exception("Cannot start the IGM402 Control Server")
-        # The above line does exactly the same as the traceback, but on the logger
-        # import traceback
-        # traceback.print_exc(file=sys.stdout)
-
-    return 0
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Control Server."""
-
-    with Sc10Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/shutter/thorlabs/sc10_interface.py

@@ -1,25 +0,0 @@
-from egse.device import DeviceInterface
-from egse.decorators import dynamic_interface
-
-
-class Sc10Interface(DeviceInterface):
-
-    @dynamic_interface
-    def get_idn(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def get_enable(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def toggle_enable(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_mode(self, mode):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_open_duration(self, duration):
-        return NotImplemented

egse/shutter/thorlabs/sc10_simulator.py

@@ -1,30 +0,0 @@
-from egse.simulator import Simulator
-from egse.shutter.thorlabs.sc10_interface import Sc10Interface
-
-class Sc10Simulator(Sc10Interface, Simulator):
-
-    def __init__(self):
-        super().__init__()
-        self._is_enable = False
-
-
-    def is_simulator(self):
-        return True
-
-    def get_idn(self):
-        return NotImplemented
-
-    def get_enable(self):
-        return self._is_enable
-
-    def toggle_enable(self):
-        if(self._is_enable):
-            self._is_enable = False
-        else:
-            self._is_enable = True
-            
-    def set_mode(self, mode):
-        return NotImplemented
-
-    def set_open_duration(self, duration):
-        return NotImplemented

egse/simulator.py

@@ -1,41 +0,0 @@
-"""
-This module is a mix-in for device simulator classes.
-All non device specific things are handled in this class.
-"""
-
-from egse.device import DeviceInterface
-
-
-class Simulator(DeviceInterface):
-
-    def __init__(self):
-        self._connected = False
-
-
-    def connect(self):
-        """ Connect to the device controller. """
-        self._connected = True
-
-
-    def disconnect(self):
-        """ Disconnect from the device controller. """
-        self._connected = False
-
-
-    def reconnect(self):
-        """ Reconnect the device controller. """
-        self._connected = True
-
-
-    def is_connected(self):
-        """ Check if the device is connected.
-
-            True if the device is connected and responds to a command, False otherwise.
-        """
-        return self._connected
-
-
-    def is_simulator(self):
-        """ Ask if the device class is a Simulator instead of the real Controller. """
-
-        return True

egse/slack.py

@@ -1,61 +0,0 @@
-"""
-This module provides functionality to send notifications to Slack.
-"""
-
-import json
-import logging
-import threading
-
-import requests
-
-from egse.settings import Settings
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-SETTINGS = Settings.load("Slack Notifications")
-
-
-def _threaded_message(slack_msg: str):
-
-    response = requests.post(
-        SETTINGS.WEBHOOK, data=json.dumps(slack_msg), headers={'Content-Type': 'application/json'})
-    if response.status_code != 200:
-        MODULE_LOGGER.error(
-            f"Request to slack returned an error {response.status_code}, "
-            f"the response is: {response.text}"
-        )
-    else:
-        MODULE_LOGGER.warning(f"Message send successfully to Slack: {slack_msg=}")
-
-
-def send_message(msg: str):
-
-    slack_msg = {"text": msg}
-
-    thread = threading.Thread(target=_threaded_message, args=(slack_msg, ))
-    thread.start()
-    # no need to join the thread, it will be finished in about 500ms, but waiting for it
-    # might be too long in some circumstances.
-    # thread.join(timeout=1.0)
-
-
-def send_alert(msg: str):
-    slack_msg = {
-        "blocks": [
-            {
-                "type": "section",
-                "text": {
-                    "type": "mrkdwn",
-                    "text": f"*Alert*: {msg}",
-                },
-                "accessory": {
-                    "type": "image",
-                    "image_url": "https://owncloud.ster.kuleuven.be/index.php/s/bAXKHzEGNeG2FkB/preview",
-                    "alt_text": "IMPORTANT"
-                },
-            },
-        ]
-    }
-
-    thread = threading.Thread(target=_threaded_message, args=(slack_msg, ))
-    thread.start()

egse/socketdevice.py

@@ -1,218 +0,0 @@
-"""
-This module defines a generic base class for ethernet socket based device interface classes.
-"""
-
-import logging
-import socket
-import time
-from threading import Lock
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceConnectionInterface
-
-
-logger = logging.getLogger(__name__)
-
-
-class SocketDevice(DeviceConnectionInterface):
-    """ Generic base class for socket based device interface classes.
-
-        This base class handles the socket connection.
-    """
-
-
-    def __init__(self, hostname=None, port=None, timeout=5):
-        self._hostname  = hostname
-        self._port      = port
-        self._timeout   = timeout
-        self._sock      = 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):
-        """ Connect the ethernet socket.
-
-            Raises a ConnectionError on failure.
-        """
-
-        # Sanity checks
-        if self._connected:
-            raise ConnectionError("Socket is already open")
-        if self._hostname in (None, ""):
-            raise ValueError("Hostname not initialized")
-        if self._port in (None, 0):
-            raise ValueError("Port number not initialized")
-
-        # Create a new socket instance
-        try:
-            self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            self._sock.setblocking(1)
-            self._sock.settimeout(self._timeout)
-        except socket.error as e_socket:
-            raise ConnectionError("Failed to create socket.") from e_socket
-
-        # Attempt to establish a connection to the remote host
-        try:
-            logger.debug(f'Connecting a socket to host "{self._hostname}" using port {self._port}')
-            with self._lock:
-                self._sock.connect((self._hostname, self._port))
-        except ConnectionRefusedError as e_cr:
-            raise ConnectionError(f"Connection refused to {self._hostname}") from e_cr
-        except socket.gaierror as e_gai:
-            raise ConnectionError(f"Socket address info error for {self._hostname}") from e_gai
-        except socket.herror as e_h:
-            raise ConnectionError(f"Socket host address error for {self._hostname}") from e_h
-        except socket.timeout as e_timeout:
-            raise ConnectionError(f"Socket timeout error for {self._hostname}") from e_timeout
-        except OSError as ose:
-            raise ConnectionError(f"OSError caught ({ose}).") from ose
-
-        self._connected = True
-
-
-    def disconnect(self):
-        """ Disconnect from the Ethernet connection.
-
-            Raises a ConnectionError on failure.
-        """
-
-        try:
-            if self._connected:
-                logger.debug(f"Disconnecting from {self._hostname}")
-                with self._lock:
-                    self._sock.close()
-                self._connected = False
-        except Exception as e_exc:
-            raise ConnectionError(f"Could not close socket to {self._hostname}") from e_exc
-
-
-    def reconnect(self):
-        """ Disconnect the device socket 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.
-        """
-
-        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._sock.sendall(command.encode())
-
-        except socket.timeout as e_timeout:
-            raise ConnectionError("Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as an I/O error
-            raise ConnectionError("Socket communication error.") from e_socket
-
-
-    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.
-        """
-
-        try:
-            with self._lock:
-
-                raw_command = command.encode()
-                # print('send:', repr(raw_command))
-
-                # Attempt to send the complete command
-                self._sock.sendall(raw_command)
-
-                # wait for, read and return the response the device
-                return_string = self.wait_for_response()
-
-                # print('recv:', repr(return_string))
-
-            return return_string.decode()
-
-        except socket.timeout as e_timeout:
-            logger.error(e_timeout)
-            raise ConnectionError("Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as an I/O error
-            raise ConnectionError("Socket communication error.") from e_socket
-
-
-    def wait_for_response(self):
-        n_total = 0
-        buf_size = 2048
-
-        try:
-            for idx in range(100):
-                time.sleep(0.001)  # Give the device time to fill the buffer
-                data = self._sock.recv(buf_size)
-                n = len(data)
-                n_total += n
-                if n < buf_size:
-                    break
-
-        except socket.timeout as e_timeout:
-            raise ConnectionError("Socket timeout error") from e_timeout
-
-        #logger.debug(f"Total number of bytes received is {n_total}, idx={idx}")
-
-        return data