keithley-tempcontrol 0.16.10__tar.gz → 0.16.11__tar.gz

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keithley-tempcontrol
-Version: 0.16.10
+Version: 0.16.11
 Summary: Keithley Temperature Control for CGSE
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "keithley-tempcontrol"
-version = "0.16.10"
+version = "0.16.11"
 description = "Keithley Temperature Control for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/src/egse/tempcontrol/keithley/daq6510.py

@@ -1,33 +1,40 @@
 import logging
 import re
 from pathlib import Path
-from typing import Dict, Union
+from typing import Dict
 from typing import List
 from typing import Tuple
 
+from egse.connect import get_endpoint
 from egse.decorators import dynamic_interface
 from egse.device import DeviceConnectionState
 from egse.device import DeviceInterface
 from egse.log import logger
-from egse.mixin import DynamicCommandMixin, CommandType
+from egse.mixin import CommandType
+from egse.mixin import DynamicCommandMixin
 from egse.mixin import add_lf
 from egse.mixin import dynamic_command
 from egse.proxy import Proxy
 from egse.settings import Settings
 from egse.tempcontrol.keithley.daq6510_dev import DAQ6510
-from egse.zmq_ser import connect_address
-
 
 HERE = Path(__file__).parent
 
-CTRL_SETTINGS = Settings.load("Keithley Control Server")
-FW_SETTINGS = Settings.load("Keithley DAQ6510")
-DEVICE_SETTINGS = Settings.load(location=HERE, filename="daq6510.yaml")
+cs_settings = Settings.load("Keithley Control Server")
+dev_settings = Settings.load("Keithley DAQ6510")
 
+PROTOCOL = cs_settings.get("PROTOCOL", "tcp")
+HOSTNAME = cs_settings.get("HOSTNAME", "localhost")
+COMMANDING_PORT = cs_settings.get("COMMANDING_PORT", 0)
+TIMEOUT = cs_settings.get("TIMEOUT")
+SERVICE_TYPE = cs_settings.get("SERVICE_TYPE", "daq6510")
 
 DEFAULT_BUFFER_1 = "defbuffer1"
 DEFAULT_BUFFER_2 = "defbuffer2"
 
+DEV_HOST = dev_settings.get("HOSTNAME")
+DEV_PORT = dev_settings.get("PORT")
+
 
 class DAQ6510Interface(DeviceInterface):
     """
@@ -35,7 +42,7 @@ class DAQ6510Interface(DeviceInterface):
     """
 
     @dynamic_interface
-    def send_command(self, command: str, response: bool) -> Union[None, str]:
+    def send_command(self, command: str, response: bool) -> str | None:
         """Sends the given SCPI command to the device.
 
         The valid commands are described in the DAQ6510 Reference Manual [DAQ6510-901-01 Rev. B / September 2019].
@@ -219,12 +226,12 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
     through an Ethernet interface.
     """
 
-    def __init__(self, hostname: str = FW_SETTINGS.HOSTNAME, port: int = FW_SETTINGS.PORT):
+    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT):
         """Opens a TCP/IP socket connection with the Keithley DAQ6510 Hardware.
 
         Args:
-            hostname (str): IP address or fully qualified hostname of the Hexapod hardware controller. The default is
-                            defined in the ``settings.yaml`` configuration file.
+            hostname (str): IP address or fully qualified hostname of the DAQ6510 hardware controller.
+                The default is defined in the ``settings.yaml`` configuration file.
             port (int): IP port number to connect to, by default set in the ``settings.yaml`` configuration file.
 
         Raises:
@@ -277,7 +284,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         return self.daq.is_connected()
 
-    def send_command(self, command: str, response: bool) -> Union[None, str]:
+    def send_command(self, command: str, response: bool) -> str | None:
         """Sends an SCPI command to the device.
 
         The valid commands are described in the DAQ6510 Reference Manual [DAQ6510-901-01 Rev. B / September 2019].
@@ -292,7 +299,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         return self.daq.trans(command) if response else self.daq.write(command)
 
-    def read_buffer(self, start: int, end: int, buffer_name: str = DEFAULT_BUFFER_1, elements: List[str] = None):
+    def read_buffer(self, start: int, end: int, buffer_name: str = DEFAULT_BUFFER_1, elements: list[str] = None):
         """Reads specific data elements (measurements) from the given buffer.
 
         Elements that can be specified to read out:
@@ -566,10 +573,10 @@ class DAQ6510Proxy(Proxy, DAQ6510Interface):
 
     def __init__(
         self,
-        protocol: str = CTRL_SETTINGS.PROTOCOL,
-        hostname: str = CTRL_SETTINGS.HOSTNAME,
-        port: int = CTRL_SETTINGS.COMMANDING_PORT,
-        timeout: float = CTRL_SETTINGS.TIMEOUT,  # Timeout [s]: > scan count * interval + (one scan duration)
+        protocol: str = PROTOCOL,
+        hostname: str = HOSTNAME,
+        port: int = COMMANDING_PORT,
+        timeout: float = TIMEOUT,  # Timeout [s]: > scan count * interval + (one scan duration)
     ):
         """Initialisation of a DAQ6510Proxy.
 
@@ -581,7 +588,9 @@ class DAQ6510Proxy(Proxy, DAQ6510Interface):
             timeout (float): Timeout by which to establish the connection [s]
         """
 
-        super().__init__(connect_address(protocol, hostname, port), timeout=timeout)
+        endpoint = get_endpoint(SERVICE_TYPE, protocol, hostname, port)
+
+        super().__init__(endpoint, timeout=timeout)
 
 
 def create_channel_list(*args) -> str:

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/src/egse/tempcontrol/keithley/daq6510_adev.py

@@ -11,17 +11,18 @@ from egse.log import logger
 from egse.scpi import AsyncSCPIInterface
 from egse.settings import Settings
 
-settings = Settings.load("Keithley DAQ6510")
+dev_settings = Settings.load("Keithley DAQ6510")
 
-DAQ_DEV_PORT = settings.get("PORT")
-DAQ_DEV_NAME = "DAQ6510"
-DAQ_DEV_ID_VALIDATION = "DAQ6510"
+DEV_HOST = dev_settings.get("HOSTNAME")
+DEV_PORT = dev_settings.get("PORT")
+DEVICE_NAME = dev_settings.get("DEVICE_NAME", "DAQ6510")
+DEV_ID_VALIDATION = "DAQ6510"
 
 
 class DAQ6510(AsyncSCPIInterface):
     """Keithley DAQ6510 specific implementation."""
 
-    def __init__(self, hostname: str, port: int = DAQ_DEV_PORT, settings: Optional[Dict[str, Any]] = None):
+    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT, settings: Optional[Dict[str, Any]] = None):
         """Initialize a Keithley DAQ6510 interface.
 
         Args:
@@ -30,11 +31,11 @@ class DAQ6510(AsyncSCPIInterface):
             settings: Additional device settings
         """
         super().__init__(
-            device_name=DAQ_DEV_NAME,
+            device_name=DEVICE_NAME,
             hostname=hostname,
             port=port,
             settings=settings,
-            id_validation=DAQ_DEV_ID_VALIDATION,  # String that must appear in IDN? response
+            id_validation=DEV_ID_VALIDATION,  # String that must appear in IDN? response
         )
 
         self._measurement_lock = asyncio.Lock()

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/src/egse/tempcontrol/keithley/daq6510_cs.py

@@ -1,23 +1,29 @@
-import logging
 import multiprocessing
 import sys
 
 import rich
 import typer
 import zmq
-from prometheus_client import start_http_server
 
+from egse.connect import get_endpoint
 from egse.control import ControlServer
 from egse.control import is_control_server_active
 from egse.log import logger
+from egse.logger import remote_logging
+from egse.registry.client import RegistryClient
 from egse.settings import Settings
 from egse.storage import store_housekeeping_information
 from egse.tempcontrol.keithley.daq6510 import DAQ6510Proxy
 from egse.tempcontrol.keithley.daq6510_protocol import DAQ6510Protocol
 from egse.zmq_ser import connect_address
 
+cs_settings = Settings.load("Keithley Control Server")
 
-CTRL_SETTINGS = Settings.load("Keithley Control Server")
+PROTOCOL = cs_settings.get("PROTOCOL", "tcp")
+HOSTNAME = cs_settings.get("HOSTNAME", "localhost")
+COMMANDING_PORT = cs_settings.get("COMMANDING_PORT", 0)
+STORAGE_MNEMONIC = cs_settings.get("STORAGE_MNEMONIC", "DAQ6510")
+SERVICE_TYPE = cs_settings.get("SERVICE_TYPE", "daq6510")
 
 
 def is_daq6510_cs_active(timeout: float = 0.5) -> bool:
@@ -29,7 +35,14 @@ def is_daq6510_cs_active(timeout: float = 0.5) -> bool:
     Returns:  True if the Control Server is running and replied with the expected answer; False otherwise.
     """
 
-    endpoint = connect_address(CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT)
+    if COMMANDING_PORT == 0:
+        with RegistryClient() as client:
+            endpoint = client.get_endpoint(SERVICE_TYPE)
+            if endpoint is None:
+                logger.debug(f"No endpoint for {SERVICE_TYPE}")
+                return False
+    else:
+        endpoint = connect_address(PROTOCOL, HOSTNAME, COMMANDING_PORT)
 
     return is_control_server_active(endpoint, timeout)
 
@@ -63,13 +76,15 @@ class DAQ6510ControlServer(ControlServer):
 
         self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
 
+        self.register_service(service_type=cs_settings.SERVICE_TYPE)
+
     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.
         """
 
-        return CTRL_SETTINGS.PROTOCOL
+        return cs_settings.PROTOCOL
 
     def get_commanding_port(self) -> int:
         """Returns the commanding port used by the Control Server.
@@ -77,7 +92,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Commanding port used by the Control Server, as specified in the settings.
         """
 
-        return CTRL_SETTINGS.COMMANDING_PORT
+        return cs_settings.COMMANDING_PORT
 
     def get_service_port(self):
         """Returns the service port used by the Control Server.
@@ -85,7 +100,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Service port used by the Control Server, as specified in the settings.
         """
 
-        return CTRL_SETTINGS.SERVICE_PORT
+        return cs_settings.SERVICE_PORT
 
     def get_monitoring_port(self):
         """Returns the monitoring port used by the Control Server.
@@ -93,7 +108,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Monitoring port used by the Control Server, as specified in the settings.
         """
 
-        return CTRL_SETTINGS.MONITORING_PORT
+        return cs_settings.MONITORING_PORT
 
     def get_storage_mnemonic(self):
         """Returns the storage mnemonics used by the Control Server.
@@ -105,10 +120,7 @@ class DAQ6510ControlServer(ControlServer):
                  settings, "DAQ6510" will be used.
         """
 
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except AttributeError:
-            return "DAQ6510"
+        return STORAGE_MNEMONIC
 
     def is_storage_manager_active(self):
         from egse.storage import is_storage_manager_active
@@ -142,8 +154,6 @@ class DAQ6510ControlServer(ControlServer):
     def before_serve(self):
         """Steps to take before the Control Server is activated."""
 
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
 
 app = typer.Typer(name="daq6510_cs")
 
@@ -154,18 +164,19 @@ def start():
 
     multiprocessing.current_process().name = "daq6510_cs (start)"
 
-    try:
-        control_server = DAQ6510ControlServer()
-        control_server.serve()
-    except KeyboardInterrupt:
-        logger.debug("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        logger.debug("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-    except Exception:
-        msg = "Cannot start the DAQ6510 Control Server"
-        logger.exception(msg)
-        rich.print(f"[red]{msg}.")
+    with remote_logging():
+        try:
+            control_server = DAQ6510ControlServer()
+            control_server.serve()
+        except KeyboardInterrupt:
+            logger.debug("Shutdown requested...exiting")
+        except SystemExit as exit_code:
+            logger.debug("System Exit with code {}.".format(exit_code))
+            sys.exit(exit_code.code)
+        except Exception:
+            msg = "Cannot start the DAQ6510 Control Server"
+            logger.exception(msg)
+            rich.print(f"[red]{msg}.")
 
     return 0
 
@@ -199,11 +210,7 @@ def status():
 
     multiprocessing.current_process().name = "daq6510_cs (status)"
 
-    protocol = CTRL_SETTINGS.PROTOCOL
-    hostname = CTRL_SETTINGS.HOSTNAME
-    port = CTRL_SETTINGS.COMMANDING_PORT
-
-    endpoint = connect_address(protocol, hostname, port)
+    endpoint = get_endpoint(SERVICE_TYPE, PROTOCOL, HOSTNAME, COMMANDING_PORT)
 
     if is_control_server_active(endpoint):
         rich.print("DAQ6510 CS: [green]active")
@@ -218,6 +225,4 @@ def status():
 
 
 if __name__ == "__main__":
-    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
     sys.exit(app())

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/src/egse/tempcontrol/keithley/daq6510_dev.py

@@ -16,9 +16,12 @@ from egse.settings import Settings
 
 IDENTIFICATION_QUERY = "*IDN?"
 
-DEVICE_SETTINGS = Settings.load("Keithley DAQ6510")
-DEVICE_NAME = "DAQ6510"
-READ_TIMEOUT = DEVICE_SETTINGS.TIMEOUT  # [s], can be smaller than timeout (for DAQ6510Proxy) (e.g. 1s)
+dev_settings = Settings.load("Keithley DAQ6510")
+
+DEVICE_NAME = dev_settings.get("DEVICE_NAME", "DAQ6510")
+DEV_HOST = dev_settings.get("HOSTNAME")
+DEV_PORT = dev_settings.get("PORT")
+READ_TIMEOUT = dev_settings.get("TIMEOUT")  # [s], can be smaller than timeout (for DAQ6510Proxy) (e.g. 1s)
 
 
 class DAQ6510Command(ClientServerCommand):
@@ -39,7 +42,7 @@ class DAQ6510Command(ClientServerCommand):
 class DAQ6510(DeviceInterface, DeviceTransport):
     """Defines the low-level interface to the Keithley DAQ6510 Controller."""
 
-    def __init__(self, hostname: str = None, port: int = None):
+    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT):
         """Initialisation of an Ethernet interface for the DAQ6510.
 
         Args:
@@ -50,9 +53,8 @@ class DAQ6510(DeviceInterface, DeviceTransport):
         super().__init__()
 
         self.device_name = DEVICE_NAME
-
-        self.hostname = DEVICE_SETTINGS.HOSTNAME if hostname is None else hostname
-        self.port = DEVICE_SETTINGS.PORT if port is None else port
+        self.hostname = hostname
+        self.port = port
         self._sock = None
 
         self._is_connection_open = False

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/src/keithley_tempcontrol/cgse_services.py

@@ -17,7 +17,7 @@ def start_daq6510():
     """Start the daq6510 service."""
     rich.print("Starting service daq6510")
 
-    out = redirect_output_to_log(".daq6510_cs.start.log")
+    out = redirect_output_to_log("daq6510_cs.start.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "start"],
@@ -33,7 +33,7 @@ def stop_daq6510():
     """Stop the daq6510 service."""
     rich.print("Terminating service daq6510")
 
-    out = redirect_output_to_log(".daq6510_cs.stop.log")
+    out = redirect_output_to_log("daq6510_cs.stop.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "stop"],
@@ -67,7 +67,7 @@ def start_daq6510_sim():
     """Start the DAQ6510 Simulator."""
     rich.print("Starting service DAQ6510 Simulator")
 
-    out = redirect_output_to_log(".daq6510_sim.start.log")
+    out = redirect_output_to_log("daq6510_sim.start.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "start"],
@@ -83,7 +83,7 @@ def stop_daq6510_sim():
     """Stop the DAQ6510 Simulator."""
     rich.print("Terminating the DAQ6510 simulator.")
 
-    out = redirect_output_to_log(".daq6510_sim.stop.log")
+    out = redirect_output_to_log("daq6510_sim.stop.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "stop"],

{keithley_tempcontrol-0.16.10 → keithley_tempcontrol-0.16.11}/src/keithley_tempcontrol/settings.yaml

@@ -3,6 +3,8 @@ PACKAGES:
 
 
 Keithley DAQ6510:
+    
+    DEVICE_NAME:              DAQ6510
     HOSTNAME:                 unknown
     PORT:                        5025
     MAC_ADDRESS:    08:00:11:24:0C:7A