symetrie-hexapod 0.17.3__py3-none-any.whl

egse/hexapod/symetrie/zonda_ui.py

@@ -0,0 +1,434 @@
+"""
+A Graphical User Interface for monitoring and commanding the Symétrie ZONDA Hexapod.
+
+Start the GUI from your terminal as follows:
+
+    zonda_ui [--type proxy|direct|simulator]
+
+This GUI is based on the SYM_positioning application from Symétrie. The intent
+is to provide operators a user interface which is platform independent, but
+familiar.
+
+The application is completely written in Python/Qt5 and can therefore run on any
+platform that supports Python and Qt5.
+
+"""
+
+import argparse
+import logging
+import multiprocessing
+from pathlib import Path
+
+import sys
+import threading
+from typing import List
+
+multiprocessing.current_process().name = "zonda_ui"
+
+import pyqtgraph as pg
+from PyQt5.QtCore import QDateTime, QLockFile
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QIcon
+from PyQt5.QtWidgets import QApplication, QMessageBox
+from PyQt5.QtWidgets import QFrame
+from PyQt5.QtWidgets import QGroupBox
+from PyQt5.QtWidgets import QHBoxLayout
+from PyQt5.QtWidgets import QLabel
+from PyQt5.QtWidgets import QLineEdit
+from PyQt5.QtWidgets import QVBoxLayout
+from PyQt5.QtWidgets import QWidget
+from prometheus_client import start_http_server
+
+from egse.gui import show_warning_message
+from egse.gui.led import Indic
+from egse.gui.states import States
+from egse.gui.stripchart import StripChart
+from egse.hexapod.symetrie.hexapod_ui import ActuatorStates
+from egse.hexapod.symetrie.hexapod_ui import HexapodUIController
+from egse.hexapod.symetrie.hexapod_ui import HexapodUIModel
+from egse.hexapod.symetrie.hexapod_ui import HexapodUIView
+from egse.hexapod.symetrie.zonda import ZondaController
+from egse.hexapod.symetrie.zonda import ZondaProxy
+from egse.hexapod.symetrie.zonda import ZondaSimulator
+from egse.process import ProcessStatus
+from egse.resource import get_resource
+from egse.settings import Settings
+from egse.system import do_every
+
+MODULE_LOGGER = logging.getLogger(__name__)
+
+# Status LEDs define the number of status leds (length of the list), the description and the
+# default color when the LED is on.
+
+STATUS_LEDS = [
+    ["Error", Indic.RED],  # bit 0
+    ["System Initialized", Indic.GREEN],  # bit 1
+    ["Control On", Indic.GREEN],  # bit 2
+    ["In Position", Indic.GREEN],  # bit 3
+    ["Motion Task Running", Indic.GREEN],  # bit 4
+    ["Home Task Running", Indic.GREEN],  # bit 5
+    ["Home Complete", Indic.GREEN],  # bit 6
+    ["Home Virtual", Indic.GREEN],  # bit 7
+    ["Phase Found", Indic.GREEN],  # bit 8
+    ["Brake on", Indic.GREEN],  # bit 9
+    ["Motion Restricted", Indic.RED],  # bit 10
+    ["Power on Encoders", Indic.GREEN],  # bit 11
+    ["Power on Limit switches", Indic.GREEN],  # bit 12
+    ["Power on Drives", Indic.GREEN],  # bit 13
+    ["Emergency Stop", Indic.RED],  # bit 14
+]
+
+# The index of the Control LED
+
+CONTROL_ONOFF = 2
+
+ACTUATOR_STATE_LABELS = [
+    "Error: ",
+    "Control On: ",
+    "In Position: ",
+    "Motion Task Running: ",
+    "Home task running: ",
+    "Home complete: ",
+    "Phase found: ",
+    "Brake on: ",
+    "Home HW input: ",
+    "Negative HW limit switch: ",
+    "Positive HW limit switch: ",
+    "SW limit reached: ",
+    "Following Error: ",
+    "Drive fault: ",
+    "Encoder error: ",
+]
+
+SPECIFIC_POSITIONS = ["Position ZERO", "Position RETRACTED"]
+
+
+class TemperatureLog(QWidget):
+    """This Widget allows to view the temperature value of all six actuators."""
+
+    def __init__(self, temp: List[str] = None):
+        super().__init__()
+
+        self.stripchart = None
+
+        self.temperatures = temp
+
+        # Switch to using white background and black foreground for pyqtgraph stripcharts
+
+        pg.setConfigOption("background", "w")
+        pg.setConfigOption("foreground", "k")
+
+        vbox = QVBoxLayout()
+        vbox.addWidget(QLabel("Temperature values in C"))
+        vbox.setAlignment(Qt.AlignTop | Qt.AlignLeft)
+
+        self.create_temperature_stripchart_widget = self.create_temperature_stripchart()
+        vbox.addWidget(self.create_temperature_stripchart_widget)
+
+        self.create_temperature_box_widget = self.create_temperature_box()
+        vbox.addWidget(self.create_temperature_box_widget)
+
+        self.setLayout(vbox)
+
+    def create_temperature_box(self):
+        vbox = QVBoxLayout()
+        vbox.setSpacing(0)
+
+        for box in range(6):
+            wbox = QHBoxLayout()
+            wbox.setSpacing(0)
+            wbox.addWidget(QLabel(f"Temp.{box + 1}: "))
+            wbox.setSpacing(0)
+            editbox = QLineEdit()
+            editbox.setReadOnly(True)
+            editbox.setFixedSize(80, 20)
+            wbox.setSpacing(0)
+            wbox.addWidget(editbox)
+            wbox.setSpacing(0)
+            vbox.addLayout(wbox)
+            vbox.setSpacing(0)
+
+        create_temperature_box = QGroupBox()
+        create_temperature_box.setLayout(vbox)
+
+        return create_temperature_box
+
+    def create_temperature_stripchart(self):
+        self.stripchart = StripChart(labels={"left": ("measure", "C"), "bottom": ("Time", "d hh:mm:ss")})
+        self.stripchart.setInterval(60 * 60 * 12)  # 12h of data
+        self.stripchart.set_yrange(0, 40)
+
+        vbox = QVBoxLayout()
+        vbox.addStretch(1)
+        vbox.addWidget(self.stripchart)
+
+        create_temperature_stripchart = QGroupBox()
+        create_temperature_stripchart.setLayout(vbox)
+
+        return create_temperature_stripchart
+
+
+class ZondaUIView(HexapodUIView):
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("Hexapod ZONDA Controller")
+
+        self.actuator_states = ActuatorStates(labels=ACTUATOR_STATE_LABELS)
+
+        self.temperature_log = TemperatureLog()
+
+        self.temperature_values = self.temperature_log.create_temperature_box_widget
+        self.temperature_values = self.temperature_values.findChildren(QLineEdit)
+        for temp in range(len(self.temperature_values)):
+            self.temperature_values[temp].setText("0.00")
+
+        self.temperature_stripchart = self.temperature_log.create_temperature_stripchart_widget
+        self.temperature_stripchart = self.temperature_stripchart.findChildren(StripChart)
+        self.temperature_stripchart = self.temperature_stripchart[0]
+
+        self.init_gui()
+
+    def init_gui(self):
+        # The main frame in which all the other frames are located, the outer Application frame
+
+        app_frame = QFrame()
+        app_frame.setObjectName("AppFrame")
+
+        # The left part which shows the states and positions
+
+        status_frame = QFrame()
+        status_frame.setObjectName("StatusFrame")
+
+        # The right part which has tabs that allow settings, movements, maintenance etc.
+
+        tabs_frame = QFrame()
+        tabs_frame.setObjectName("TabsFrame")
+
+        # The states of the Hexapod (contains all the leds)
+
+        states_frame = QFrame()
+        states_frame.setObjectName("StatesFrame")
+
+        # The user, machine positions and actuator lengths
+
+        positions_frame = QFrame()
+        positions_frame.setObjectName("PositionsFrame")
+
+        hbox = QHBoxLayout()
+        vbox_left = QVBoxLayout()
+        vbox_right = QVBoxLayout()
+
+        self.create_toolbar()
+        self.create_status_bar()
+
+        self.states = States(STATUS_LEDS)
+
+        user_positions_widget = self.create_user_position_widget()
+        mach_positions_widget = self.create_machine_position_widget()
+        actuator_length_widget = self.create_actuator_length_widget()
+
+        vbox_right.addWidget(user_positions_widget)
+        vbox_right.addWidget(mach_positions_widget)
+        vbox_right.addWidget(actuator_length_widget)
+
+        positions_frame.setLayout(vbox_right)
+
+        vbox_left.addWidget(self.states)
+
+        states_frame.setLayout(vbox_left)
+
+        hbox.addWidget(states_frame)
+        hbox.addWidget(positions_frame)
+
+        status_frame.setLayout(hbox)
+
+        tabbed_widget = self.create_tabbed_widget()
+
+        hbox = QHBoxLayout()
+        hbox.addWidget(tabbed_widget)
+        tabs_frame.setLayout(hbox)
+
+        hbox = QHBoxLayout()
+        hbox.addWidget(status_frame)
+        hbox.addWidget(tabs_frame)
+
+        app_frame.setLayout(hbox)
+
+        self.setCentralWidget(app_frame)
+
+    def update_status_bar(self, message=None, mode=None, timeout=2000):
+        if message:
+            self.statusBar().showMessage(message, msecs=timeout)
+        if mode:
+            self.mode_label.setStyleSheet(f"border: 0; color: {'red' if 'Simulator' in mode else 'black'};")
+
+            self.mode_label.setText(f"mode: {mode}")
+        self.statusBar().repaint()
+
+    def updatePositions(self, userPositions, machinePositions, actuatorLengths):
+        if userPositions is None:
+            MODULE_LOGGER.warning("no userPositions passed into updatePositions(), returning.")
+            return
+
+        for upos in range(len(self.user_positions)):
+            try:
+                self.user_positions[upos][1].setText(f"{userPositions[upos]:10.4f}")
+            except IndexError:
+                MODULE_LOGGER.error(f"IndexError in user_positions, upos = {upos}")
+
+        if machinePositions is None:
+            MODULE_LOGGER.warning("no machinePositions passed into updatePositions(), returning.")
+            return
+
+        for mpos in range(len(self.mach_positions)):
+            self.mach_positions[mpos][1].setText(f"{machinePositions[mpos]:10.4f}")
+
+        if actuatorLengths is None:
+            MODULE_LOGGER.warning("no actuatorLengths passed into updatePositions(), returning.")
+            return
+
+        for idx, alen in enumerate(self.actuator_lengths):
+            alen[1].setText(f"{actuatorLengths[idx]:10.4f}")
+
+    def updateStates(self, states):
+        if states is None:
+            return
+
+        self.updateControlButton(states[CONTROL_ONOFF])
+        self.states.set_states(states)
+
+    def updateControlButton(self, flag):
+        self.control.set_selected(on=flag)
+
+    def updateTemperature(self, temp):
+        if temp is None:
+            MODULE_LOGGER.warning("no temperature passed into updateTemperature(), returning.")
+            return
+        else:
+            # TODO: How to add the 6 temperature values to the stripchart?
+            value = temp[0]
+            self.temperature_stripchart.update(QDateTime.currentMSecsSinceEpoch(), value)
+            for t in range(len(self.temperature_values)):
+                self.temperature_values[t].setText(f"{temp[t]:10.4f}")
+
+
+class ZondaUIModel(HexapodUIModel):
+    def __init__(self, connection_type):
+        if connection_type == "proxy":
+            device = ZondaProxy()
+        elif connection_type == "direct":
+            device = ZondaController()
+            device.connect()
+        elif connection_type == "simulator":
+            device = ZondaSimulator()
+        else:
+            raise ValueError(f"Unknown type of Hexapod implementation passed into the model: {connection_type}")
+
+        super().__init__(connection_type, device)
+
+        if device is not None:
+            MODULE_LOGGER.debug(f"Hexapod initialized as {device.__class__.__name__}")
+
+    def get_speed(self):
+        speed_settings = self.device.get_speed()
+        return speed_settings["vt"], speed_settings["vr"]
+
+    def get_temperature(self):
+        temp = self.device.get_temperature()
+        return temp
+
+
+class ZondaUIController(HexapodUIController):
+    def __init__(self, model: ZondaUIModel, view: ZondaUIView):
+        super().__init__(model, view)
+
+    def update_values(self):
+        super().update_values()
+
+        # Add here any updates to ZONDA specific widgets
+
+        temp = self.model.get_temperature()
+        self.view.updateTemperature(temp)
+
+
+def parse_arguments():
+    """
+    Prepare the arguments that are specific for this application.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--type",
+        dest="type",
+        action="store",
+        choices={"proxy", "simulator", "direct"},
+        help="Specify Hexapod implementation you want to connect to.",
+        default="proxy",
+    )
+    parser.add_argument(
+        "--profile",
+        default=False,
+        action="store_true",
+        help="Enable info logging messages with method profile information.",
+    )
+    return parser.parse_args()
+
+
+def main():
+    lock_file = QLockFile(str(Path("~/zonda_ui.app.lock").expanduser()))
+
+    styles_location = get_resource(":/styles/default.qss")
+    app_logo = get_resource(":/icons/logo-zonda.svg")
+
+    args = list(sys.argv)
+    args[1:1] = ["-stylesheet", str(styles_location)]
+    app = QApplication(args)
+    app.setWindowIcon(QIcon(str(app_logo)))
+
+    if lock_file.tryLock(100):
+        process_status = ProcessStatus()
+
+        timer_thread = threading.Thread(target=do_every, args=(10, process_status.update))
+        timer_thread.daemon = True
+        timer_thread.start()
+
+        args = parse_arguments()
+
+        if args.profile:
+            Settings.set_profiling(True)
+
+        if args.type == "proxy":
+            proxy = ZondaProxy()
+            if not proxy.ping():
+                description = "Could not connect to Hexapod Control Server"
+                info_text = (
+                    "The GUI will start, but the connection button will show a disconnected state. "
+                    "Please check if the Control Server is running and start the server if needed. "
+                    "Otherwise, check if the correct HOSTNAME for the control server is set in the "
+                    "Settings.yaml "
+                    "configuration file."
+                )
+
+                show_warning_message(description, info_text)
+
+        view = ZondaUIView()
+        model = ZondaUIModel(args.type)
+        ZondaUIController(model, view)
+
+        view.show()
+
+        return app.exec_()
+    else:
+        error_message = QMessageBox()
+        error_message.setIcon(QMessageBox.Warning)
+        error_message.setWindowTitle("Error")
+        error_message.setText("The Zonda GUI application is already running!")
+        error_message.setStandardButtons(QMessageBox.Ok)
+
+        return error_message.exec()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
+
+    sys.exit(main())

symetrie_hexapod/cgse_explore.py

@@ -0,0 +1,19 @@
+__all__ = [
+    "show_processes",
+]
+
+import re
+
+from egse.process import ProcessInfo
+from egse.process import get_processes
+
+
+def show_processes():
+    """Returns of list of ProcessInfo data classes for matching processes from this package."""
+
+    def filter_procs(pi: ProcessInfo):
+        pattern = r"(joran|puna|zonda)_(ui|cs|sim)"
+
+        return re.search(pattern, pi.command)
+
+    return get_processes(filter_procs)

symetrie_hexapod/cgse_services.py

@@ -0,0 +1,162 @@
+import subprocess
+import sys
+import textwrap
+from typing import Annotated
+
+import rich
+import typer
+
+from egse.system import all_logging_disabled
+from egse.system import redirect_output_to_log
+
+puna = typer.Typer(name="puna", help="PUNA Positioning Hexapod, Symétrie")
+
+zonda = typer.Typer(name="zonda", help="ZONDA Positioning Hexapod, Symétrie")
+
+joran = typer.Typer(name="joran", help="JORAN Positioning Hexapod, Symétrie")
+
+
+def start_hexapod_cs_process(device_name, device_id, simulator):
+    """Generic function to start the hexapod control server in the background."""
+
+    rich.print(f"Starting the {device_name} hexapod control server for {device_id} – {simulator = }")
+
+    out = redirect_output_to_log(f".{device_name.lower()}_cs.{device_id.lower()}.start.log")
+
+    cmd = [sys.executable, "-m", f"egse.hexapod.symetrie.{device_name.lower()}_cs", "start", device_id]
+    if simulator:
+        cmd.append("--simulator")
+
+    subprocess.Popen(cmd, stdout=out, stderr=out, stdin=subprocess.DEVNULL, close_fds=True)
+
+
+def stop_hexapod_cs_process(device_name, device_id):
+    """Generic function to stop the hexapod control server in the background."""
+
+    rich.print(f"Terminating hexapod {device_name} control server for {device_id}...")
+
+    out = redirect_output_to_log(f".{device_name.lower()}_cs.{device_id.lower()}.stop.log")
+
+    cmd = [sys.executable, "-m", f"egse.hexapod.symetrie.{device_name.lower()}_cs", "stop", device_id]
+
+    subprocess.Popen(cmd, stdout=out, stderr=out, stdin=subprocess.DEVNULL, close_fds=True)
+
+
+# ---------- PUNA Commands ---------------------------------------------------------------------------------------------
+
+
+@puna.command(name="start")
+def start_puna(
+    device_id: Annotated[str, typer.Argument(help="the device identifier, identifies the hardware controller")],
+    simulator: Annotated[
+        bool, typer.Option("--simulator", "--sim", help="use a device simulator as the backend")
+    ] = False,
+):
+    """
+    Start the PUNA hexapod control server. The control server is always started in the background.
+    """
+    start_hexapod_cs_process("PUNA", device_id, simulator)
+
+
+@puna.command(name="stop")
+def stop_puna(
+    device_id: Annotated[str, typer.Argument(help="the device identifier, identifies the hardware controller")],
+):
+    """Stop the PUNA hexapod control server."""
+
+    stop_hexapod_cs_process("PUNA", device_id)
+
+
+@puna.command(name="status")
+def status_puna(device_id: str):
+    """Print status information on the PUNA hexapod control server."""
+
+    with all_logging_disabled():
+        from egse.hexapod.symetrie import puna_cs
+
+        puna_cs.status(device_id)
+
+
+@puna.command(name="start-sim")
+def start_puna_sim(device_id: str):
+    """Start the PUNA Hexapod Simulator (the device simulator)."""
+
+    rich.print(
+        textwrap.dedent(
+            f"""\
+            [orange3]The PUNA simulator is in development, for now use the `--sim` option when starting the control 
+            server.[/]
+            
+            The `--sim` option will use a Controller clas that doesn't send commands to the device, but simulates
+            the requests by performing actions on the reference frames defined in the hexapod. This means you are 
+            not exercising the actual device commanding, but the net result or outcome is the same.
+            
+            usage: cgse puna start --sim {device_id}
+            """
+        )
+    )
+    return
+
+    rich.print("Starting service PUNA Simulator")
+
+    out = redirect_output_to_log(f".puna_sim.{device_id.lower()}.start.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.hexapod.symetrie.puna_sim", "start", device_id],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
+
+@puna.command(name="stop-sim")
+def stop_puna_sim(device_id: str):
+    """Stop the PUNA Hexapod Simulator."""
+    rich.print("Terminating the PUNA simulator.")
+
+    out = redirect_output_to_log(f".puna_sim.{device_id.lower()}.stop.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.hexapod.symetrie.puna_sim", "stop", device_id],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
+
+# ---------- ZONDA Commands --------------------------------------------------------------------------------------------
+
+
+@zonda.command(name="start")
+def start_zonda(
+    device_id: Annotated[str, typer.Argument(help="the device identifier, identifies the hardware controller")],
+    simulator: Annotated[
+        bool, typer.Option("--simulator", "--sim", help="use a device simulator as the backend")
+    ] = False,
+):
+    """
+    Start the ZONDA hexapod control server. The control server is always started in the background.
+    """
+
+    start_hexapod_cs_process("ZONDA", device_id, simulator)
+
+
+@zonda.command(name="stop")
+def stop_zonda(
+    device_id: Annotated[str, typer.Argument(help="the device identifier, identifies the hardware controller")],
+):
+    """Stop the ZONDA hexapod control server."""
+
+    stop_hexapod_cs_process("ZONDA", device_id)
+
+
+@zonda.command(name="status")
+def status_zonda(device_id: str):
+    """Print status information on the ZONDA hexapod control server."""
+
+    with all_logging_disabled():
+        from egse.hexapod.symetrie import zonda_cs
+
+        zonda_cs.status(device_id)

symetrie_hexapod/settings.yaml

@@ -0,0 +1,15 @@
+PACKAGES:
+    SYMETRIE_HEXAPOD: Device driver for the Symétrie Hexapods PUNA, ZONDA, and JORAN
+
+PUNA Alpha+ Controller:
+    user_name: provide username in local settings
+    password: provide password in local settings
+
+Hexapod Control Server:
+    SERVICE_TYPE:                puna
+    PROTOCOL:                     tcp
+    HOSTNAME:               localhost          # The hostname that client shall connect to, e.g. on the same machine
+    COMMANDING_PORT:                0          # The port on which the controller listens to commands - REQ-REP
+    MONITORING_PORT:                0          # The port on which the controller sends periodic status information of the device - PUB-SUB
+    SERVICE_PORT:                   0          # The port on which the controller listens for configuration and administration - REQ-REP
+    METRICS_PORT:                   0          # The HTTP port where Prometheus will connect to for retrieving metrics

symetrie_hexapod-0.17.3.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: symetrie-hexapod
+Version: 0.17.3
+Summary: Symetrie Hexapod implementation for CGSE
+Author: IvS KU Leuven
+Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>
+License-Expression: MIT
+Keywords: CGSE,Common-EGSE,hardware testing,software framework
+Requires-Python: >=3.10
+Requires-Dist: cgse-common
+Requires-Dist: cgse-coordinates
+Requires-Dist: cgse-core
+Requires-Dist: cgse-gui
+Requires-Dist: cgse-tools
+Requires-Dist: invoke
+Requires-Dist: paramiko
+Requires-Dist: pyqt5>=5.15.11
+Requires-Dist: pyqtgraph
+Description-Content-Type: text/markdown
+
+# Drivers for the Symétrie Hexapods

symetrie_hexapod-0.17.3.dist-info/RECORD

@@ -0,0 +1,33 @@
+egse/hexapod/__init__.py,sha256=a-pdJ5j5XcLPaiz-zLIjfyJjFFUnbl_sOdasMp0UwEI,918
+egse/hexapod/symetrie/__init__.py,sha256=TzNC_EIL5wQTyVYFXh8N5sVSjQHdA8fY1NdDtT2ZtUE,6621
+egse/hexapod/symetrie/alpha.py,sha256=cEuNtOd5BPW4zSo4HpKyCsvcDj_YBjZHhPcBa4UXnxw,33277
+egse/hexapod/symetrie/dynalpha.py,sha256=HuDopBZygBaAPb5CGl9jmeTa-pN23EBiIIlx_IjPrMA,55145
+egse/hexapod/symetrie/hexapod.py,sha256=YZggPY2xJrD-jOzNWz8EutUs6hS0qFLW02h42Ol5q3w,19023
+egse/hexapod/symetrie/hexapod_ui.py,sha256=nOk8FR_-4FYuwlhyqGPFPORAVDX4aNS2QWa00iZCacs,52752
+egse/hexapod/symetrie/joran.py,sha256=dilr0kl8aLivK8HOeb3sDAA_F5HsMEtmekflc91PoBE,8556
+egse/hexapod/symetrie/joran.yaml,sha256=p97aPO3JnNJqCyz6Md8Odkj3lX0m5ODhtdqwbAsUpuo,2669
+egse/hexapod/symetrie/joran_cs.py,sha256=MB_sNpD0WpXLs219OfsSD7RaMPt8QaVIqX2zeWqNaVU,5365
+egse/hexapod/symetrie/joran_protocol.py,sha256=E4GX0uE7evXANChN0R3akTKP_ipjAw-Ecc2NlUDrfF0,4444
+egse/hexapod/symetrie/joran_ui.py,sha256=b8IjBPSpkHOr8kpoKYIhfiYYnKVjlVx-IRwjFpno7L8,14162
+egse/hexapod/symetrie/pmac.py,sha256=8I6UzDUZjT2MtlI4ImZB68Mz6nFEHVJAu1YpvGd2iVw,30266
+egse/hexapod/symetrie/pmac_regex.py,sha256=hS5wzrdT5FzQEYYDS5suur3yoIZKxBX7cRri2sGPOoE,2593
+egse/hexapod/symetrie/puna.py,sha256=99hhOgrDjVFW-Kr8nw2UVL6WXPQ_0MPNlfc8Ge5Letc,22727
+egse/hexapod/symetrie/puna.yaml,sha256=u_oEgIfuxt6ebWoZaADtO4cFpSVuUgMjG0G7y1_Nc0w,8534
+egse/hexapod/symetrie/puna_cs.py,sha256=4Se4RAYYrw_2QKW2q03h3rMyTcBQPr7hN5Lyt3tmJNw,8048
+egse/hexapod/symetrie/puna_protocol.py,sha256=6EgKpmQQZXLyqelWVxQGZUrAjABwSkhEYsgGizxCsSs,5010
+egse/hexapod/symetrie/puna_ui.py,sha256=GaeBRhBobHVgB9vDoygqsp7LbDXbNFh9RgEXCfqgHwg,13524
+egse/hexapod/symetrie/punaplus.py,sha256=4O2uRi6rah_qRnHfuzoCsyc2fzkvSUxiDkRos47y2Mk,3428
+egse/hexapod/symetrie/zonda.py,sha256=jgPQh6ajt_LUI8Co0vyxwrgnZ5oG3szNPu3eqanohWM,29509
+egse/hexapod/symetrie/zonda.yaml,sha256=MC4kQ9k1USAUZOgDS1-Yi331LYq53JSRIDQh4VZXUNw,18737
+egse/hexapod/symetrie/zonda_cs.py,sha256=5DVyo_iKhhHbG8VDnaaWMQ3VuNPXuHirIvuQZX3q4oQ,8054
+egse/hexapod/symetrie/zonda_devif.py,sha256=F2cRW3zoBZc8lOfAa9cYkiCcp3sXTE7Ar2ypNfuXEas,14798
+egse/hexapod/symetrie/zonda_protocol.py,sha256=fdR110zt0IWI1U7usZu7aajmGPvJoHjXZVGaY3NOu-s,4750
+egse/hexapod/symetrie/zonda_ui.py,sha256=IYqymUL_sSmIgeJf8jY_pocsyfi36XzJeZCaMChhWaQ,14140
+symetrie_hexapod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+symetrie_hexapod/cgse_explore.py,sha256=0Pnz4fwbTQBRHoliF_dIJclK-7AaHmDRsAvsOuzDoGg,423
+symetrie_hexapod/cgse_services.py,sha256=krF8Lk1uTNiRdZIxuaWtEDt8Q1cxpXOd0qgT9yefbOE,5350
+symetrie_hexapod/settings.yaml,sha256=7tz8INhWSXV7bPTLYkS_06fYuMeeRiKRLuIW1_LnpX8,946
+symetrie_hexapod-0.17.3.dist-info/METADATA,sha256=ecIW_u33cUX1mWPR5UbPzmeYyj_b4r4hPTlUoRJzyR8,650
+symetrie_hexapod-0.17.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+symetrie_hexapod-0.17.3.dist-info/entry_points.txt,sha256=e_AmaY0OtfoHHnxDS2M0dbkZmPY38juEp42ZTwQtQkY,664
+symetrie_hexapod-0.17.3.dist-info/RECORD,,

symetrie_hexapod-0.17.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any