keithley-tempcontrol 0.17.3__py3-none-any.whl → 0.18.1__py3-none-any.whl

egse/tempcontrol/keithley/daq6510_protocol.py

@@ -1,62 +1,70 @@
 import logging
+from pathlib import Path
 
 from egse.control import ControlServer
 from egse.device import DeviceTimeoutError
-from egse.hk import read_conversion_dict
-from egse.metrics import define_metrics
+from egse.hk import convert_hk_names, read_conversion_dict
 from egse.protocol import CommandProtocol
+from egse.log import logger
 from egse.settings import Settings
 from egse.setup import load_setup
-from egse.synoptics import SynopticsManagerProxy
 from egse.system import format_datetime
-from egse.tempcontrol.keithley.daq6510 import DAQ6510Controller
-from egse.tempcontrol.keithley.daq6510 import DAQ6510Interface
-from egse.tempcontrol.keithley.daq6510 import DAQ6510Simulator
+from egse.tempcontrol.keithley.daq6510 import DAQ6510Controller, DAQ6510Interface
 from egse.tempcontrol.keithley.daq6510_dev import DAQ6510Command
 from egse.zmq_ser import bind_address
 
-COMMAND_SETTINGS = Settings.load(filename="daq6510.yaml")
+HERE = Path(__file__).parent
 
-MODULE_LOGGER = logging.getLogger(__name__)
+COMMAND_SETTINGS = Settings.load(location=HERE, filename="daq6510.yaml")
 
 
 class DAQ6510Protocol(CommandProtocol):
     def __init__(self, control_server: ControlServer):
-        """Initialisation of a new Protocol for DAQ6510 Management.
+        """Initialization of a new Protocol for DAQ6510 Management.
 
         Args:
             control_server: Control Server for which to send out status and monitoring information
         """
 
-        super().__init__()
-        self.control_server = control_server
+        super().__init__(control_server)
 
-        if Settings.simulation_mode():
-            self.daq = DAQ6510Simulator()
-        else:
-            self.daq = DAQ6510Controller()
+        self.daq = DAQ6510Controller()
 
         try:
             self.daq.connect()
         except (ConnectionError, DeviceTimeoutError):
-            MODULE_LOGGER.warning("Couldn't establish a connection to the DAQ6510, check the log messages.")
+            logger.warning("Couldn't establish a connection to the DAQ6510, check the log messages.")
+
+        try:
+            self.hk_conversion_table = read_conversion_dict(
+                self.get_control_server().get_storage_mnemonic(), use_site=False
+            )
+        except Exception as exc:
+            logger.warning(f"Failed to read housekeeping conversion dictionary: {exc}")
+            self.hk_conversion_table = None
 
         self.load_commands(COMMAND_SETTINGS.Commands, DAQ6510Command, DAQ6510Interface)
         self.build_device_method_lookup_table(self.daq)
 
         setup = load_setup()
-        self.channels = setup.gse.DAQ6510.channels
+        self.channels = setup.gse.DAQ6510.channels  # type: ignore[attr-defined]
 
-        self.hk_conversion_table = read_conversion_dict(self.control_server.get_storage_mnemonic(), setup=setup)
+    def get_device(self) -> DAQ6510Controller:
+        """
+        Returns the DAQ6510Controller device.
 
-        self.synoptics = SynopticsManagerProxy()
-        self.metrics = define_metrics(origin="DAS-DAQ6510", use_site=True, setup=setup)
+        Returns:
+            The DAQ6510Controller device.
+        """
 
-    def get_bind_address(self) -> str:
-        """Returns a string with the bind address, the endpoint, for accepting connections and bind a socket to.
+        return self.daq
 
+    def get_bind_address(self) -> str:
+        """
+        Returns a string with the bind address, the endpoint, for accepting connections and bind a socket to.
 
-        Returns: String with the protocol and port to bind a socket to.
+        Returns:
+            String with the protocol and port to bind a socket to.
         """
 
         return bind_address(
@@ -65,33 +73,30 @@ class DAQ6510Protocol(CommandProtocol):
         )
 
     def get_status(self) -> dict:
-        """Returns a dictionary with status information for the Control Server and the DAQ6510.
+        """
+        Returns a dictionary with status information for the Control Server and the DAQ6510.
 
-        Returns: Dictionary with status information for the Control Server and the DAQ6510.
+        Returns:
+            Dictionary with status information for the Control Server and the DAQ6510.
         """
 
         return super().get_status()
 
     def get_housekeeping(self) -> dict:
-        """Returns a dictionary with housekeeping information about the DAQ6510.
+        """
+        Returns a dictionary with housekeeping information about the DAQ6510.
 
-        Returns: Dictionary with housekeeping information about the DAQ6510.
+        Returns:
+            Dictionary with housekeeping information about the DAQ6510.
         """
 
         hk_dict = dict()
         hk_dict["timestamp"] = format_datetime()
 
-        # # TODO I guess we have to do something along those lines
-        # # (We'll have to increase the HK delay, cfr. Agilents)
-        # measurement = self.daq.perform_measurement(channel_list=self.channels)
-        # temperatures = convert_hk_names(measurement, self.hk_conversion_table)
-        # hk_dict.update(temperatures)
-        #
-        # self.synoptics.store_th_synoptics(hk_dict)
-        #
-        # for key, value in hk_dict.items():
-        #     if key != "timestamp":
-        #         self.metrics[key].set(value)
+        # logger.warning("DAQ6510Protocol.get_housekeeping() not implemented yet.")
+
+        if self.hk_conversion_table:
+            return convert_hk_names(hk_dict, self.hk_conversion_table)
 
         return hk_dict
 

egse/tempcontrol/keithley/daq6510_sim.py

@@ -1,21 +1,32 @@
-from __future__ import annotations
-
 import contextlib
 import datetime
-import logging
 import re
 import socket
 import time
+from functools import partial
+from typing import Annotated
 
 import typer
+
+from egse.env import bool_env
+from egse.log import logging
 from egse.settings import Settings
 from egse.system import SignalCatcher
 
-logger = logging.getLogger("daq6510-sim")
+logger = logging.getLogger("egse.daq6510-sim")
 
+VERSION = "0.1.0"
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
 HOST = "localhost"
 DAQ_SETTINGS = Settings.load("Keithley DAQ6510")
 
+READ_TIMEOUT = 2.0
+"""The timeout set on the connection socket, applicable when reading from the socket with `recv`."""
+CONNECTION_TIMEOUT = 2.0
+"""The timeout set on the socket before accepting a connection."""
+
+SEPARATOR = b"\n"
+SEPARATOR_STR = SEPARATOR.decode()
 
 device_time = datetime.datetime.now(datetime.timezone.utc)
 reference_time = device_time
@@ -23,8 +34,8 @@ reference_time = device_time
 
 app = typer.Typer(help="DAQ6510 Simulator")
 
-error_msg: str | None = None
-"""Global error message, always contains the last error. Reset in the inner loop of run_simulator."""
+error_msg: str = ""
+"""Global error message, always contains the last error. Reset to an empty string in the inner loop of run_simulator."""
 
 
 def create_datetime(year, month, day, hour, minute, second):
@@ -62,8 +73,14 @@ def reset():
     logger.info("RESET")
 
 
+def log(level: int, msg: str):
+    logger.log(level, msg)
+
+
 COMMAND_ACTIONS_RESPONSES = {
-    "*IDN?": (None, "KEITHLEY INSTRUMENTS, MODEL DAQ6510, SIMULATOR"),
+    "*IDN?": (None, f"KEITHLEY INSTRUMENTS,DAQ6510,SIMULATOR,{VERSION}"),
+    "*ACTION-RESPONSE?": (partial(log, logging.INFO, "Requested action with response."), get_time),
+    "*ACTION-NO-RESPONSE": (partial(log, logging.INFO, "Requested action without response."), None),
 }
 
 # Check the regex at https://regex101.com
@@ -79,65 +96,105 @@ COMMAND_PATTERNS_ACTIONS_RESPONSES = {
 
 
 def write(conn, response: str):
-    response = f"{response}\n".encode()
-    logger.debug(f"write: {response = }")
-    conn.sendall(response)
+    response_b = f"{response}{SEPARATOR_STR}".encode()
+    if VERBOSE_DEBUG:
+        logger.debug(f"write: {response_b = }")
+    conn.sendall(response_b)
+
+
+# Keep a receive buffer per connection
+_recv_buffers: dict[int, bytes] = {}
 
 
 def read(conn) -> str:
     """
-    Reads one command string from the socket, i.e. until a linefeed ('\n') is received.
-
-    Returns:
-        The command string with the linefeed stripped off.
+    Read bytes from `conn` until a `SEPARATOR` is found (or connection closed / timeout).
+    Returns the first chunk (separator stripped). Any bytes after the separator are kept
+    in a per-connection buffer for the next call.
     """
-
-    n_total = 0
-    buf_size = 1024 * 4
-    command_string = bytes()
+    fileno = conn.fileno()
+    buf = _recv_buffers.get(fileno, b"")
 
     try:
-        for _ in range(100):
-            data = conn.recv(buf_size)
-            n = len(data)
-            n_total += n
-            command_string += data
-            # if data.endswith(b'\n'):
-            if n < buf_size:
-                break
+        while True:
+            # If we already have a full line in the buffer, split and return it.
+            if SEPARATOR in buf:
+                line, rest = buf.split(SEPARATOR, 1)
+                _recv_buffers[fileno] = rest
+                logger.info(f"read: {line=}")
+                return line.decode().rstrip()
+
+            # Read more data
+            data = conn.recv(1024 * 4)
+            if not data:
+                # Connection closed by peer; return whatever we have (may be empty)
+                _recv_buffers.pop(fileno, None)
+                logger.info(f"read (connection closed): {buf=}")
+                return buf.decode().rstrip()
+            buf += data
+            _recv_buffers[fileno] = buf
+
     except socket.timeout:
-        # This timeout is caught at the caller, where the timeout is set.
+        # If we have accumulated data without a separator, return it (partial read),
+        # otherwise propagate the timeout so caller can handle/suppress it.
+        if buf:
+            _recv_buffers[fileno] = buf
+            logger.info(f"read (timeout, partial): {buf=}")
+            return buf.decode().rstrip()
         raise
 
-    logger.info(f"read: {command_string=}")
-
-    return command_string.decode().rstrip()
-
 
-def process_command(command_string: str) -> str:
+def process_command(command_string: str) -> str | None:
+    """Process the given command string and return a response."""
     global COMMAND_ACTIONS_RESPONSES
     global COMMAND_PATTERNS_ACTIONS_RESPONSES
     global error_msg
 
-    # LOGGER.debug(f"{command_string=}")
+    if VERBOSE_DEBUG:
+        logger.debug(f"{command_string=}")
 
     try:
         action, response = COMMAND_ACTIONS_RESPONSES[command_string]
-        action and action()
-        if error_msg:
-            return error_msg
+        if VERBOSE_DEBUG:
+            logger.debug(f"{action=}, {response=}")
+
+        if action:
+            action()
+
+        if response:
+            if error_msg:
+                return error_msg
+            else:
+                return response() if callable(response) else response
         else:
-            return response if isinstance(response, str) else response()
+            if error_msg:
+                logger.error(f"Error occurred during process command: {error_msg}")
+            return None
     except KeyError:
         # try to match with a value
         for key, value in COMMAND_PATTERNS_ACTIONS_RESPONSES.items():
             if match := re.match(key, command_string, flags=re.IGNORECASE):
-                # LOGGER.debug(f"{match=}, {match.groups()}")
+                if VERBOSE_DEBUG:
+                    logger.debug(f"{match=}, {match.groups()}")
                 action, response = value
-                # LOGGER.debug(f"{action=}, {response=}")
-                action and action(*match.groups())
-                return error_msg or (response if isinstance(response, str) or response is None else response())
-        return f"ERROR: unknown command string: {command_string}"
+                if VERBOSE_DEBUG:
+                    logger.debug(f"{action=}, {response=}")
+
+                if action:
+                    action(*match.groups())
+
+                if response:
+                    if error_msg:
+                        return error_msg
+                    else:
+                        return response() if callable(response) else response
+                else:
+                    if error_msg:
+                        logger.error(f"Error occurred during process command: {error_msg}")
+                    return None
+
+        logger.error(f"ERROR: unknown command string: {command_string}")
+        return None
 
 
 def run_simulator():
@@ -150,7 +207,7 @@ def run_simulator():
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         s.bind((HOST, DAQ_SETTINGS.PORT))
         s.listen()
-        s.settimeout(2.0)
+        s.settimeout(CONNECTION_TIMEOUT)
         while True:
             while True:
                 with contextlib.suppress(socket.timeout):
@@ -160,14 +217,18 @@ def run_simulator():
                     return
             with conn:
                 logger.info(f"Accepted connection from {addr}")
-                write(conn, "This is PLATO DAQ6510 X.X.sim")
-                conn.settimeout(2.0)
+                # write(conn, "This is PLATO DAQ6510 X.X.sim")  # The DAQ6510 doesn't send a string after connection
+                conn.settimeout(READ_TIMEOUT)
                 try:
                     while True:
                         error_msg = ""
                         with contextlib.suppress(socket.timeout):
                             data = read(conn)
-                            logger.info(f"{data = }")
+                            if VERBOSE_DEBUG:
+                                logger.debug(f"{data = }")
+                            if not data:
+                                logger.info("Client closed connection, accepting new connection...")
+                                break
                             if data.strip() == "STOP":
                                 logger.info("Client requested to terminate...")
                                 s.close()
@@ -176,9 +237,6 @@ def run_simulator():
                                 response = process_command(cmd.strip())
                                 if response is not None:
                                     write(conn, response)
-                            if not data:
-                                logger.info("Client closed connection, accepting new connection...")
-                                break
                         if killer.term_signal_received:
                             logger.info("Terminating...")
                             s.close()
@@ -196,20 +254,20 @@ def run_simulator():
                     logger.info(f"{exc.__class__.__name__} caught: {exc.args}")
 
 
-def send_request(cmd: str, type_: str = "query"):
-    from egse.tempcontrol.keithley.daq6510_dev import DAQ6510EthernetInterface
+def send_request(cmd: str, cmd_type: str = "query") -> str | None:
+    from egse.tempcontrol.keithley.daq6510_dev import DAQ6510
 
     response = None
 
-    daq_dev = DAQ6510EthernetInterface(hostname="localhost", port=5025)
+    daq_dev = DAQ6510(hostname="localhost", port=5025)
     daq_dev.connect()
 
-    if type_.lower().strip() == "query":
+    if cmd_type.lower().strip() == "query":
         response = daq_dev.query(cmd)
-    elif type_.lower().strip() == "write":
+    elif cmd_type.lower().strip() == "write":
         daq_dev.write(cmd)
     else:
-        logger.info(f"Unknown type {type_} for send_request.")
+        logger.info(f"Unknown command type {cmd_type} for send_request.")
 
     daq_dev.disconnect()
 
@@ -234,15 +292,14 @@ def stop():
 
 
 @app.command()
-def command(type_: str, cmd: str):
-    response = send_request(cmd, type_)
+def command(
+    cmd: str,
+    cmd_type: Annotated[str, typer.Argument(help="either 'write', 'query'")] = "query",
+):
+    """Send an SCPI command directly to the simulator. The response will be in the log info."""
+    response = send_request(cmd, cmd_type)
     logger.info(f"{response}")
 
 
 if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.DEBUG,
-        format="%(asctime)s  %(threadName)-12s %(levelname)-8s %(name)-12s %(module)-20s %(message)s",
-    )
-
     app()

keithley_tempcontrol/cgse_services.py

@@ -2,14 +2,13 @@
 #
 import subprocess
 import sys
-from pathlib import Path
 
 import rich
 import typer
 
-daq6510 = typer.Typer(
-    name="daq6510", help="DAQ6510 Data Acquisition Unit, Keithley, temperature monitoring", no_args_is_help=True
-)
+from egse.system import redirect_output_to_log
+
+daq6510 = typer.Typer(name="daq6510", help="DAQ6510 Data Acquisition Unit, Keithley, temperature monitoring")
 
 
 @daq6510.command(name="start")
@@ -17,19 +16,39 @@ def start_daq6510():
     """Start the daq6510 service."""
     rich.print("Starting service daq6510")
 
+    out = redirect_output_to_log("daq6510_cs.start.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "start"],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
 
 @daq6510.command(name="stop")
 def stop_daq6510():
     """Stop the daq6510 service."""
     rich.print("Terminating service daq6510")
 
+    out = redirect_output_to_log("daq6510_cs.stop.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "stop"],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
 
 @daq6510.command(name="status")
 def status_daq6510():
     """Print status information on the daq6510 service."""
 
     proc = subprocess.Popen(
-        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "status"],
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "status"],
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         stdin=subprocess.DEVNULL,
@@ -47,7 +66,7 @@ def start_daq6510_sim():
     """Start the DAQ6510 Simulator."""
     rich.print("Starting service DAQ6510 Simulator")
 
-    out = open(Path("~/.daq6510_sim.start.out").expanduser(), "w")
+    out = redirect_output_to_log("daq6510_sim.start.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "start"],
@@ -63,7 +82,7 @@ def stop_daq6510_sim():
     """Stop the DAQ6510 Simulator."""
     rich.print("Terminating the DAQ6510 simulator.")
 
-    out = open(Path("~/.daq6510_sim.stop.out").expanduser(), "w")
+    out = redirect_output_to_log("daq6510_sim.stop.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "stop"],
@@ -74,5 +93,37 @@ def stop_daq6510_sim():
     )
 
 
+@daq6510.command(name="start-mon")
+def start_daq6510_mon():
+    """Start the daq6510 monitoring service."""
+    rich.print("Starting monitoring service daq6510_mon")
+
+    out = redirect_output_to_log("daq6510_mon.start.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_mon", "start"],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
+
+@daq6510.command(name="stop-mon")
+def stop_daq6510_mon():
+    """Stop the daq6510 monitoring service."""
+    rich.print("Stopping monitoring service daq6510_mon")
+
+    out = redirect_output_to_log("daq6510_mon.stop.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_mon", "stop"],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
+
 if __name__ == "__main__":
     daq6510()

{keithley_tempcontrol-0.17.3.dist-info → keithley_tempcontrol-0.18.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keithley-tempcontrol
-Version: 0.17.3
+Version: 0.18.1
 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.18.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+egse/tempcontrol/keithley/__init__.py,sha256=IasaUltrExCB6CgWl_ZscX51ssVq3Fn_-9V_P-gtV9I,120
+egse/tempcontrol/keithley/daq6510.py,sha256=2ImQrL185T_hsG4Yvw5bqd5_FJ-gJnfAfgZxH-OG0yc,20629
+egse/tempcontrol/keithley/daq6510.yaml,sha256=dHHVNyUpOQpdrZpnxPbT6slsl-8Gbnhifj4Q8QOfOYg,4400
+egse/tempcontrol/keithley/daq6510_adev.py,sha256=wIE-vyDZK9OrT9fio-FWSKEzmTGNQCFh2meiLBinsmY,2586
+egse/tempcontrol/keithley/daq6510_amon.py,sha256=cUgA_ARcEMHzf-_41-c-13KVReAipFCBa6dwiZn-lYE,21330
+egse/tempcontrol/keithley/daq6510_cs.py,sha256=gfq0pnTlmVSrMPRnbYJLslNquFPpCO80Ynb0ZBC5YuU,8441
+egse/tempcontrol/keithley/daq6510_dev.py,sha256=3LMPxmlcuQ3nFy-XTOUnyDOGhWMHLEJGxj0wxK9OT-Q,5212
+egse/tempcontrol/keithley/daq6510_mon.py,sha256=a5a5ke9j2kjsWWnHhelHkzXP0EaO4MeuRNR7LcsSx6k,11113
+egse/tempcontrol/keithley/daq6510_protocol.py,sha256=xBAo7Rd_C4Ts-Tt21EtweEadXKnOtfs-GgnLtugSTsQ,3428
+egse/tempcontrol/keithley/daq6510_sim.py,sha256=Jstq00LcNzji8fVWMxmLpRExDC-Y8zeCJL1Gl5OcD_I,9979
+keithley_tempcontrol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keithley_tempcontrol/cgse_explore.py,sha256=y_FkFxJW0vdqGNp9yTU0ELBKxby74-ev3fTuf99Vl1s,400
+keithley_tempcontrol/cgse_services.py,sha256=LUk_Gk8RCzyRVzvmEkO0Dtz1dwfWpBN0VVCpRY9OFXg,3333
+keithley_tempcontrol/settings.yaml,sha256=wbrgSZQAdqFl6AxiLJIN36UsdiVHQCzdsgi7Hs7dv7o,1467
+keithley_tempcontrol-0.18.1.dist-info/METADATA,sha256=otqtIXT5UpVDLpa-jZ66j-B0TTxXbi2l4_hgoQNeSAc,962
+keithley_tempcontrol-0.18.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+keithley_tempcontrol-0.18.1.dist-info/entry_points.txt,sha256=eo5NMMjip3sejDbn3uZvm9kgZt_EYcepuhaCu_mixic,547
+keithley_tempcontrol-0.18.1.dist-info/RECORD,,

{keithley_tempcontrol-0.17.3.dist-info → keithley_tempcontrol-0.18.1.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 daq6510_cs = egse.tempcontrol.keithley.daq6510_cs:app
+daq6510_mon = egse.tempcontrol.keithley.daq6510_mon:app
 daq6510_sim = egse.tempcontrol.keithley.daq6510_sim:app
 
 [gui_scripts]

keithley_tempcontrol-0.17.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-egse/tempcontrol/keithley/__init__.py,sha256=QMm0vy6OMqzWmJZ1K6IwKSOpgYeCmUdbcRhv75LH9ZY,130
-egse/tempcontrol/keithley/daq6510.py,sha256=QA3K0xJ_-bsY6D4jzOyeDHz1uYSrgf8Z8O-9RynCB5E,24711
-egse/tempcontrol/keithley/daq6510.yaml,sha256=dHHVNyUpOQpdrZpnxPbT6slsl-8Gbnhifj4Q8QOfOYg,4400
-egse/tempcontrol/keithley/daq6510_adev.py,sha256=kodJGonsy_whr15XbVC5CA94mMqm1036FGK0DXmZtxo,3482
-egse/tempcontrol/keithley/daq6510_cs.py,sha256=YVmUtEkGZ0ZKQ7BtvloL_da_fSy_rVr0EB1V2SjLdq0,6089
-egse/tempcontrol/keithley/daq6510_dev.py,sha256=ZjzDU3x7XYRLRoNK9lcqE-t32XDMt0IHW26GO87xt98,10780
-egse/tempcontrol/keithley/daq6510_mon.py,sha256=uox4IaHKwC_hXDQpj4sGEnZyK-dKXjqQdZ2yiaCbt_c,19103
-egse/tempcontrol/keithley/daq6510_protocol.py,sha256=fdcJxsOFYaEDVIY4XzLVC4PSIAL20gKj8os8f0nsSh4,3655
-egse/tempcontrol/keithley/daq6510_sim.py,sha256=GHC7NY2NZ5fm20AjMx7glSGWY1OOynndHUnCPcs5MZM,7568
-keithley_tempcontrol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-keithley_tempcontrol/cgse_explore.py,sha256=y_FkFxJW0vdqGNp9yTU0ELBKxby74-ev3fTuf99Vl1s,400
-keithley_tempcontrol/cgse_services.py,sha256=H62jEzwRQMvKjkefFw9mSQTYRnT8ga_-SdJ26gPaUE8,1960
-keithley_tempcontrol/settings.yaml,sha256=wbrgSZQAdqFl6AxiLJIN36UsdiVHQCzdsgi7Hs7dv7o,1467
-keithley_tempcontrol-0.17.3.dist-info/METADATA,sha256=JhlNFJaYoCoFBeh8A3boUq3XSNPLxJs72_0NrW7BgcY,962
-keithley_tempcontrol-0.17.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-keithley_tempcontrol-0.17.3.dist-info/entry_points.txt,sha256=_0j2BwcwPi4LlRrhvEWfp9GO9KT8WhCkJe2gFgMzOPs,491
-keithley_tempcontrol-0.17.3.dist-info/RECORD,,