dls-plc-tools 1.0.0b1__py3-none-any.whl

dls_plc_tools/__init__.py

@@ -0,0 +1,11 @@
+"""Top level API.
+
+.. data:: __version__
+    :type: str
+
+    Version number as calculated by https://github.com/pypa/setuptools_scm
+"""
+
+from ._version import __version__
+
+__all__ = ["__version__"]

dls_plc_tools/__main__.py

@@ -0,0 +1,24 @@
+"""Interface for ``python -m dls_plc_tools``."""
+
+from argparse import ArgumentParser
+from collections.abc import Sequence
+
+from . import __version__
+
+__all__ = ["main"]
+
+
+def main(args: Sequence[str] | None = None) -> None:
+    """Argument parser for the CLI."""
+    parser = ArgumentParser()
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=__version__,
+    )
+    parser.parse_args(args)
+
+
+if __name__ == "__main__":
+    main()

dls_plc_tools/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0b1'
+__version_tuple__ = version_tuple = (1, 0, 0, 'b1')
+
+__commit_id__ = commit_id = None

dls_plc_tools/gui.py

@@ -0,0 +1,433 @@
+"""Qt GUI for browsing and live-watching Omron NX PLC tags over EtherNet/IP.
+
+Read-only: every PLC interaction is an explicit-messaging read, the same
+mechanism the EPICS ether_ip driver uses.
+
+Usage: dls-read-plc-gui [ip-address]
+"""
+
+import argparse
+import re
+import sys
+
+from aphyt import omron
+from aphyt.cip.cip import CIPException
+from aphyt.cip.cip_datatypes import CIPArray, CIPStructure
+from openpyxl import Workbook
+from PySide6.QtCore import QObject, Qt, QThread, QTimer, Signal, Slot
+from PySide6.QtGui import QBrush, QColor
+from PySide6.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QDoubleSpinBox,
+    QFileDialog,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QMainWindow,
+    QPushButton,
+    QSplitter,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from dls_plc_tools.interrogate import INFO_TAGS, USED_MARKER_MEMBER, dims_str
+
+CHANGED_BRUSH = QBrush(QColor("#ffd54f"))  # amber for values that just changed
+
+
+def _sheet_name(name):
+    """Excel sheet names: max 31 chars, no []:*?/\\ characters."""
+    return re.sub(r"[\[\]:*?/\\]", "_", name)[:31]
+
+
+def _cell(value):
+    """Coerce a CIP value into something openpyxl can store."""
+    return value if isinstance(value, int | float | str | bool) else str(value)
+
+
+def _fit_columns(sheet, pad=2, cap=60):
+    """Size each column to its longest cell (openpyxl has no auto-fit)."""
+    for column in sheet.columns:
+        longest = max(len(str(c.value)) for c in column if c.value is not None)
+        sheet.column_dimensions[column[0].column_letter].width = min(longest + pad, cap)
+
+
+class PlcWorker(QObject):
+    """Owns the aphyt connection; lives in a QThread so reads never block the UI."""
+
+    connected = Signal(str)
+    tags_ready = Signal(list)
+    struct_ready = Signal(str, object, object)  # name, {member: values}, {member: type}
+    exported = Signal(str)
+    failed = Signal(str)
+
+    def __init__(self):
+        super().__init__()
+        self._eip = None
+
+    @Slot(str)
+    def connect_plc(self, ip):
+        try:
+            self.disconnect_plc()
+            eip = omron.NSeries()
+            eip.connect_explicit(ip, connection_timeout=5.0)
+            eip.register_session()
+            self._eip = eip
+            info = [ip]
+            for tag in INFO_TAGS:
+                try:
+                    info.append(f"{tag}={eip.read_variable(tag)}")
+                except CIPException:
+                    pass
+            self.connected.emit("   ".join(info))
+        except Exception as e:
+            self.failed.emit(f"connect: {e}")
+
+    @Slot()
+    def disconnect_plc(self):
+        if self._eip is not None:
+            try:
+                self._eip.close_explicit()
+            except Exception:
+                pass
+            self._eip = None
+
+    @Slot()
+    def list_tags(self):
+        if self._eip is None:
+            self.failed.emit("not connected")
+            return
+        try:
+            self._eip.update_variable_dictionary()
+            user = self._eip.connected_cip_dispatcher.user_variables
+            rows = []
+            for name, dtype in sorted(user.items()):
+                if isinstance(dtype, CIPStructure):
+                    rows.append((name, dtype.variable_type_name))
+                else:
+                    rows.append((name, type(dtype).__name__))
+            self.tags_ready.emit(rows)
+        except Exception as e:
+            self.failed.emit(f"list tags: {e}")
+
+    @Slot(str)
+    def read_struct(self, name):
+        if self._eip is None:
+            self.failed.emit("not connected")
+            return
+        try:
+            result = self._eip.read_variable(name)
+            columns = {}
+            types = {}
+            if isinstance(result, CIPStructure):
+                for member, value in result.members.items():
+                    if isinstance(value, CIPArray):
+                        columns[member] = value.value()
+                        element = type(value.local_cip_data_type_object).__name__
+                        types[member] = f"ARRAY[{dims_str(value)}] OF {element}"
+                    else:
+                        columns[member] = [value.value()]
+                        types[member] = type(value).__name__
+            elif isinstance(result, CIPArray):
+                element = type(result.local_cip_data_type_object).__name__
+                columns[name] = result.value()
+                types[name] = f"ARRAY[{dims_str(result)}] OF {element}"
+            else:  # scalar tag: one-cell table
+                columns[name] = [result]
+                types[name] = type(result).__name__
+            self.struct_ready.emit(name, columns, types)
+        except Exception as e:
+            self.failed.emit(f"read {name}: {e}")
+
+    @Slot(str)
+    def export_structs(self, path):
+        """Dump every published structure to an Excel workbook, one sheet per
+        structure: rows are members, columns are instance indices."""
+        if self._eip is None:
+            self.failed.emit("not connected")
+            return
+        try:
+            self._eip.update_variable_dictionary()
+            user = self._eip.connected_cip_dispatcher.user_variables
+            structs = sorted(n for n, d in user.items() if isinstance(d, CIPStructure))
+            workbook = Workbook()
+            default_sheet = workbook.active
+            if default_sheet is not None:
+                workbook.remove(default_sheet)
+            for name in structs:
+                result = self._eip.read_variable(name)
+                if not isinstance(result, CIPStructure):
+                    continue
+                rows = {}
+                width = 1
+                for member, value in result.members.items():
+                    if isinstance(value, CIPArray):
+                        rows[member] = value.value()
+                    else:
+                        rows[member] = [value.value()]
+                    width = max(width, len(rows[member]))
+                sheet = workbook.create_sheet(_sheet_name(name))
+                sheet.append([name] + list(range(width)))
+                for member, values in rows.items():
+                    sheet.append([member] + [_cell(v) for v in values])
+                sheet.freeze_panes = "B2"
+                _fit_columns(sheet)
+            workbook.save(path)
+            self.exported.emit(f"exported {len(structs)} structures to {path}")
+        except Exception as e:
+            self.failed.emit(f"export: {e}")
+
+
+class MainWindow(QMainWindow):
+    request_connect = Signal(str)
+    request_tags = Signal()
+    request_struct = Signal(str)
+    request_export = Signal(str)
+    request_disconnect = Signal()
+
+    def __init__(self, ip=None):
+        super().__init__()
+        self.setWindowTitle("DLS PLC tools")
+        self.resize(1100, 650)
+        self._waiting = False
+        self._current_struct = None
+        self._previous = {}
+
+        self._worker = PlcWorker()
+        self._thread = QThread(self)
+        self._worker.moveToThread(self._thread)
+        self.request_connect.connect(self._worker.connect_plc)
+        self.request_tags.connect(self._worker.list_tags)
+        self.request_struct.connect(self._worker.read_struct)
+        self.request_export.connect(self._worker.export_structs)
+        self.request_disconnect.connect(self._worker.disconnect_plc)
+        self._worker.connected.connect(self._on_connected)
+        self._worker.tags_ready.connect(self._on_tags)
+        self._worker.struct_ready.connect(self._on_struct)
+        self._worker.exported.connect(self._on_exported)
+        self._worker.failed.connect(self._on_failed)
+        self._thread.start()
+
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._poll)
+
+        # Top bar: connection
+        self.ip_edit = QLineEdit(ip or "")
+        self.ip_edit.setPlaceholderText("e.g. 172.23.241.21")
+        self.ip_edit.setMaximumWidth(160)
+        self.connect_btn = QPushButton("Connect")
+        self.info_label = QLabel("not connected")
+        top = QHBoxLayout()
+        top.addWidget(QLabel("IP address:"))
+        top.addWidget(self.ip_edit)
+        top.addWidget(self.connect_btn)
+        top.addWidget(self.info_label, stretch=1)
+
+        # Left: tag browser
+        self.scan_btn = QPushButton("Scan tags (slow)")
+        self.export_btn = QPushButton("Export structures (Excel)")
+        self.tag_list = QListWidget()
+        left_box = QVBoxLayout()
+        left_box.addWidget(self.scan_btn)
+        left_box.addWidget(self.export_btn)
+        left_box.addWidget(self.tag_list)
+        left = QWidget()
+        left.setLayout(left_box)
+
+        # Right: live structure table
+        self.struct_edit = QLineEdit()
+        self.struct_edit.setPlaceholderText("tag to watch, e.g. Seq or PLC_Status")
+        self.watch_btn = QPushButton("Watch")
+        self.filter_edit = QLineEdit()
+        self.filter_edit.setPlaceholderText("filter members, e.g. Desc,State")
+        self.used_only = QCheckBox(f"in-use rows only ({USED_MARKER_MEMBER})")
+        self.used_only.setChecked(True)
+        self.interval = QDoubleSpinBox()
+        self.interval.setRange(0.5, 60.0)
+        self.interval.setValue(2.0)
+        self.interval.setSuffix(" s")
+        self.live = QCheckBox("live")
+        self.live.setChecked(True)
+        controls = QHBoxLayout()
+        controls.addWidget(self.struct_edit)
+        controls.addWidget(self.watch_btn)
+        controls.addWidget(self.filter_edit)
+        controls.addWidget(self.used_only)
+        controls.addWidget(QLabel("every"))
+        controls.addWidget(self.interval)
+        controls.addWidget(self.live)
+        self.table = QTableWidget()
+        self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        right_box = QVBoxLayout()
+        right_box.addLayout(controls)
+        right_box.addWidget(self.table)
+        right = QWidget()
+        right.setLayout(right_box)
+
+        splitter = QSplitter()
+        splitter.addWidget(left)
+        splitter.addWidget(right)
+        splitter.setStretchFactor(1, 3)
+
+        central_box = QVBoxLayout()
+        central_box.addLayout(top)
+        central_box.addWidget(splitter, stretch=1)
+        central = QWidget()
+        central.setLayout(central_box)
+        self.setCentralWidget(central)
+
+        self.connect_btn.clicked.connect(self._connect_clicked)
+        self.ip_edit.returnPressed.connect(self._connect_clicked)
+        self.scan_btn.clicked.connect(self._scan_clicked)
+        self.export_btn.clicked.connect(self._export_clicked)
+        self.tag_list.itemDoubleClicked.connect(self._tag_activated)
+        self.watch_btn.clicked.connect(self._watch_clicked)
+        self.struct_edit.returnPressed.connect(self._watch_clicked)
+        self.interval.valueChanged.connect(self._interval_changed)
+        self.live.toggled.connect(self._live_toggled)
+
+    # --- user actions -------------------------------------------------
+
+    def _connect_clicked(self):
+        ip = self.ip_edit.text().strip()
+        if ip:
+            self.info_label.setText(f"connecting to {ip}...")
+            self.request_connect.emit(ip)
+
+    def _scan_clicked(self):
+        self.statusBar().showMessage("scanning tags (walks whole dictionary)...")
+        self.request_tags.emit()
+
+    def _tag_activated(self, item):
+        self.struct_edit.setText(item.data(Qt.ItemDataRole.UserRole))
+        self._watch_clicked()
+
+    def _export_clicked(self):
+        path, _ = QFileDialog.getSaveFileName(
+            self, "Export structures", "plc_structs.xlsx", "Excel files (*.xlsx)"
+        )
+        if path:
+            self.statusBar().showMessage(
+                "exporting (scans all tags, then reads every structure)..."
+            )
+            self.request_export.emit(path)
+
+    def _watch_clicked(self):
+        name = self.struct_edit.text().strip()
+        if not name:
+            return
+        self._current_struct = name
+        self._previous = {}
+        self.table.setRowCount(0)
+        self.table.setColumnCount(0)
+        self._poll(force=True)
+        self._interval_changed()
+
+    def _interval_changed(self):
+        self._timer.start(int(self.interval.value() * 1000))
+
+    def _live_toggled(self, checked):
+        if checked:
+            self._interval_changed()
+        else:
+            self._timer.stop()
+
+    def _poll(self, force=False):
+        if (
+            self._current_struct
+            and not self._waiting
+            and (force or self.live.isChecked())
+        ):
+            self._waiting = True
+            self.request_struct.emit(self._current_struct)
+
+    # --- worker results -----------------------------------------------
+
+    def _on_connected(self, info):
+        self.info_label.setText(info)
+        self.statusBar().showMessage("connected", 3000)
+
+    def _on_exported(self, message):
+        self.statusBar().showMessage(message, 10000)
+
+    def _on_failed(self, message):
+        self._waiting = False
+        self.statusBar().showMessage(message)
+
+    def _on_tags(self, rows):
+        self.tag_list.clear()
+        for name, type_name in rows:
+            item = QListWidgetItem(f"{name}  —  {type_name}")
+            item.setData(Qt.ItemDataRole.UserRole, name)
+            self.tag_list.addItem(item)
+        self.statusBar().showMessage(f"{len(rows)} user tags", 5000)
+
+    def _on_struct(self, name, columns, types):
+        self._waiting = False
+        if name != self._current_struct:
+            return
+
+        wanted = [
+            w.strip().lower() for w in self.filter_edit.text().split(",") if w.strip()
+        ]
+        members = [
+            m for m in columns if not wanted or any(w in m.lower() for w in wanted)
+        ]
+        labels = columns.get(USED_MARKER_MEMBER)
+        if self.used_only.isChecked() and labels:
+            rows = [i for i, v in enumerate(labels) if str(v).strip()]
+        else:
+            rows = list(range(max((len(v) for v in columns.values()), default=0)))
+
+        self.table.setColumnCount(len(members))
+        self.table.setRowCount(len(rows))
+        self.table.setHorizontalHeaderLabels(members)
+        for col, member in enumerate(members):
+            header = self.table.horizontalHeaderItem(col)
+            if header is not None:
+                header.setToolTip(types.get(member, ""))
+        self.table.setVerticalHeaderLabels([str(i) for i in rows])
+
+        previous = self._previous
+        current = {}
+        for col, member in enumerate(members):
+            values = columns[member]
+            for row, idx in enumerate(rows):
+                text = str(values[idx]).strip() if idx < len(values) else "n/a"
+                current[(member, idx)] = text
+                item = QTableWidgetItem(text)
+                if previous.get((member, idx), text) != text:
+                    item.setBackground(CHANGED_BRUSH)
+                self.table.setItem(row, col, item)
+        self._previous = current
+        self.statusBar().showMessage(f"{name}: updated", 1500)
+
+    # --- shutdown -------------------------------------------------------
+
+    def closeEvent(self, event):  # noqa: N802 - Qt override
+        self._timer.stop()
+        self.request_disconnect.emit()
+        self._thread.quit()
+        self._thread.wait(3000)
+        super().closeEvent(event)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Qt GUI for browsing Omron NX PLC tags over EtherNet/IP"
+    )
+    parser.add_argument("ip", nargs="?", help="PLC IP address to pre-fill")
+    args = parser.parse_args()
+    app = QApplication(sys.argv)
+    window = MainWindow(args.ip)
+    window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

dls_plc_tools/interrogate.py

@@ -0,0 +1,241 @@
+"""
+Summarise the structure tags published by an Omron NX PLC over EtherNet/IP.
+
+With only an IP address, walks the PLC's tag dictionary and summarises every
+published structure it finds. See --help for tag listing, member detail and
+live value watching.
+"""
+
+import argparse
+import time
+from collections import Counter
+
+from aphyt import omron
+from aphyt.cip.cip import CIPException
+from aphyt.cip.cip_datatypes import CIPArray, CIPStructure
+
+# Tags printed as a header for every mode.
+INFO_TAGS = ["PLC_Name", "PLC_Status", "Epics_Num_dev"]
+
+# Structure member whose non-empty entries mark instances actually in use.
+USED_MARKER_MEMBER = "Desc"
+
+# Default columns for --detail; override per-run with --members.
+WATCH_MEMBERS = ["Desc", "State", "Status", "Status_String", "ILK_Status"]
+
+MAX_CELL_WIDTH = 24
+CHANGED = "\x1b[1;33m"  # bold yellow
+RESET = "\x1b[0m"
+CLEAR = "\x1b[H\x1b[2J"
+
+
+def dims_str(member):
+    return ", ".join(
+        f"{s}..{s + n - 1}"
+        for s, n in zip(
+            member.start_array_elements, member.number_of_elements, strict=True
+        )
+    )
+
+
+def summarise_struct(name, struct):
+    print(f"\n{name}: {struct.variable_type_name}")
+
+    arrays = {m: v for m, v in struct.members.items() if isinstance(v, CIPArray)}
+    scalars = [m for m in struct.members if m not in arrays]
+
+    for dims, count in Counter(dims_str(v) for v in arrays.values()).most_common():
+        print(f"  {count} array members of ARRAY[{dims}]")
+    if scalars:
+        print(f"  scalar members: {', '.join(scalars)}")
+
+    marker = arrays.get(USED_MARKER_MEMBER)
+    if marker is not None:
+        try:
+            start = marker.start_array_elements[0]
+            used = [i + start for i, v in enumerate(marker.value()) if str(v).strip()]
+            print(
+                f"  instances in use ({USED_MARKER_MEMBER} non-empty): "
+                f"{len(used)} -> {used}"
+            )
+        except Exception as e:
+            print(f"  (could not decode {USED_MARKER_MEMBER}: {e})")
+
+
+def list_all_tags(eip):
+    """Walk the PLC's full tag dictionary and print every published user tag."""
+    eip.update_variable_dictionary()
+    user_variables = eip.connected_cip_dispatcher.user_variables
+    for name, dtype in sorted(user_variables.items()):
+        if isinstance(dtype, CIPStructure):
+            print(f"  {name}  {dtype.variable_type_name}")
+        else:
+            print(f"  {name}  {type(dtype).__name__}")
+    system_count = len(eip.connected_cip_dispatcher.system_variables)
+    print(f"\n{len(user_variables)} user tags ({system_count} system tags not shown)")
+
+
+def member_values(struct_instance, member):
+    """Return a member's contents as a list, or None if it is missing."""
+    value = struct_instance.members.get(member)
+    if value is None:
+        return None
+    if isinstance(value, CIPArray):
+        return value.value()
+    return [value.value()]  # scalar member: single-row column
+
+
+def show_struct(eip, struct):
+    """Print every member of a structure with its type and array bounds."""
+    result = eip.read_variable(struct)
+    if not isinstance(result, CIPStructure):
+        print(f"{struct} is a {type(result).__name__}, not a structure")
+        return
+    print(f"\n{struct}: {result.variable_type_name}")
+    for name, member in result.members.items():
+        if isinstance(member, CIPArray):
+            element = type(member.local_cip_data_type_object).__name__
+            print(f"  {name}  ARRAY[{dims_str(member)}] OF {element}")
+        else:
+            print(f"  {name}  {type(member).__name__}")
+
+
+def watch_struct(eip, ip, struct, members, interval):
+    """Poll a structure and redraw a live table of the selected members.
+
+    Reads the whole structure in one request sequence per refresh (read-only
+    explicit messaging, the same mechanism the EPICS ether_ip driver uses),
+    then picks the displayed members out client-side.
+    """
+    rows = None
+    previous = {}
+    while True:
+        result = eip.read_variable(struct)
+        if not isinstance(result, CIPStructure):
+            print(f"{struct} is a {type(result).__name__}, not a structure")
+            return
+        if all(m not in result.members for m in members):
+            print(f"none of [{', '.join(members)}] exist in {struct}")
+            print(f"pick some of its members with -m: {', '.join(result.members)}")
+            return
+        columns = {m: member_values(result, m) for m in members}
+
+        if rows is None:
+            labels = member_values(result, USED_MARKER_MEMBER)
+            if labels:
+                rows = [i for i, v in enumerate(labels) if str(v).strip()]
+            else:  # no marker member: show every index of the first column
+                first = next(v for v in columns.values() if v is not None)
+                rows = list(range(len(first)))
+
+        cells = {}
+        widths = {}
+        for member, values in columns.items():
+            widths[member] = len(member)
+            for idx in rows:
+                if values is None or idx >= len(values):
+                    text = "n/a"
+                else:
+                    text = str(values[idx]).strip()[:MAX_CELL_WIDTH]
+                changed = previous.get((member, idx), text) != text
+                previous[(member, idx)] = text
+                cells[(member, idx)] = (text, changed)
+                widths[member] = max(widths[member], len(text))
+
+        lines = [
+            f"{struct} @ {ip}  {time.strftime('%H:%M:%S')}  "
+            f"(every {interval}s, read-only)  Ctrl-C to stop",
+            "",
+            "  idx  " + "  ".join(m.ljust(widths[m]) for m in members),
+        ]
+        for idx in rows:
+            line = f"  {idx:>3}  "
+            for member in members:
+                text, changed = cells[(member, idx)]
+                padded = text.ljust(widths[member])
+                if changed:
+                    padded = f"{CHANGED}{padded}{RESET}"
+                line += padded + "  "
+            lines.append(line.rstrip())
+
+        print(CLEAR + "\n".join(lines), flush=True)
+        time.sleep(interval)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("ip", help="PLC IP address")
+    parser.add_argument(
+        "-l",
+        "--list",
+        action="store_true",
+        help="list every published user tag and its type "
+        "(slow: walks the whole tag dictionary)",
+    )
+    parser.add_argument(
+        "-d",
+        "--detail",
+        metavar="STRUCT",
+        help="live-updating table of one structure's values, e.g. -d Seq",
+    )
+    parser.add_argument(
+        "-s",
+        "--show",
+        metavar="STRUCT",
+        help="show one structure's members with types and array bounds, e.g. -s PID",
+    )
+    parser.add_argument(
+        "-m",
+        "--members",
+        help="comma-separated members to show with --detail "
+        f"(default: {','.join(WATCH_MEMBERS)})",
+    )
+    parser.add_argument(
+        "--interval",
+        type=float,
+        default=2.0,
+        help="refresh period in seconds for --detail (default: 2.0, min: 0.5)",
+    )
+    args = parser.parse_args()
+
+    with omron.NSeries(args.ip) as eip:
+        print(f"PLC at {args.ip}")
+        for tag in INFO_TAGS:
+            try:
+                print(f"  {tag} = {eip.read_variable(tag)}")
+            except CIPException:
+                print(f"  {tag}: not published")
+
+        if args.list:
+            list_all_tags(eip)
+            return
+
+        if args.show:
+            try:
+                show_struct(eip, args.show)
+            except CIPException:
+                print(f"{args.show}: not published on this PLC")
+            return
+
+        if args.detail:
+            members = args.members.split(",") if args.members else WATCH_MEMBERS
+            interval = max(args.interval, 0.5)
+            watch_struct(eip, args.ip, args.detail, members, interval)
+            return
+
+        # Default mode: discover structure tags from the dictionary walk,
+        # then read each one to summarise it.
+        eip.update_variable_dictionary()
+        user_variables = eip.connected_cip_dispatcher.user_variables
+        structs = sorted(
+            name
+            for name, dtype in user_variables.items()
+            if isinstance(dtype, CIPStructure)
+        )
+        print(f"\n{len(structs)} structure tags: {', '.join(structs)}")
+        for name in structs:
+            summarise_struct(name, eip.read_variable(name))
+
+
+if __name__ == "__main__":
+    main()

dls_plc_tools-1.0.0b1.dist-info/METADATA

@@ -0,0 +1,309 @@
+Metadata-Version: 2.4
+Name: dls-plc-tools
+Version: 1.0.0b1
+Summary: A collection of tools to facilitate EPICS commissioning of PLC based systems
+Author-email: Lee Hudson <lee.hudson@diamond.ac.uk>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "{}"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright {yyyy} {name of copyright owner}
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
+Project-URL: GitHub, https://github.com/DiamondLightSource/dls-plc-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aphyt
+Requires-Dist: PySide6-Essentials<6.10
+Requires-Dist: openpyxl
+Dynamic: license-file
+
+[![CI](https://github.com/DiamondLightSource/dls-plc-tools/actions/workflows/ci.yml/badge.svg)](https://github.com/DiamondLightSource/dls-plc-tools/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/DiamondLightSource/dls-plc-tools/branch/main/graph/badge.svg)](https://codecov.io/gh/DiamondLightSource/dls-plc-tools)
+[![PyPI](https://img.shields.io/pypi/v/dls-plc-tools.svg)](https://pypi.org/project/dls-plc-tools)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+# dls_plc_tools
+
+Tools for interrogating Omron NX PLCs over EtherNet/IP, to support EPICS
+commissioning of PLC-based vacuum systems at Diamond Light Source.
+
+They let you browse the tags a PLC publishes, inspect the layout of its
+structures, and watch values update live — without a Sysmac Studio licence or
+physical access to the controller. Everything is **read-only explicit
+messaging**: the same mechanism the EPICS `ether_ip` driver uses, serviced in
+the controller's spare time, so it is safe to run against production PLCs.
+
+There are two front-ends over the [`aphyt`](https://pypi.org/project/aphyt/)
+library: a command-line tool (`dls-read-plc`) and a PySide6 desktop GUI
+(`dls-read-plc-gui`).
+
+What            | Where
+:---:           | :---:
+Source          | <https://github.com/DiamondLightSource/dls-plc-tools>
+PyPI            | `pip install dls-plc-tools`
+Docker          | `docker run ghcr.io/diamondlightsource/dls-plc-tools:latest`
+Releases        | <https://github.com/DiamondLightSource/dls-plc-tools/releases>
+
+## Command-line tool
+
+With just an IP address, `dls-read-plc` discovers every published
+structure tag on the PLC and summarises each one — its member layout and how
+many instances are actually in use:
+
+```
+dls-read-plc 172.23.x.x
+```
+
+Other modes:
+
+```
+dls-read-plc 172.23.x.x -l              # list every published tag and its type
+dls-read-plc 172.23.x.x -s Seq          # show one structure's members and array bounds
+dls-read-plc 172.23.x.x -d Seq          # live-updating table of a structure's values
+dls-read-plc 172.23.x.x -d Seq -m Desc,State,Status   # choose which members to watch
+```
+
+`--detail`/`-d` redraws a table every 2 seconds (floor 0.5 s, set with
+`--interval`), highlighting cells that have changed. Press Ctrl-C to stop. See
+`dls-read-plc --help` for the full option list.
+
+## GUI
+
+```
+dls-read-plc-gui 172.23.x.x
+```
+
+`dls-read-plc-gui` gives you a browsable list of the PLC's published tags, a live
+table of a selected structure's values (changed cells flash amber), and an
+export of the discovered structure layouts to an Excel spreadsheet. The IP
+address argument is optional — you can also enter it in the window.
+
+## Installation
+
+```
+pip install dls-plc-tools
+```
+
+Or, for development, using [uv](https://docs.astral.sh/uv/):
+
+```
+git clone https://github.com/DiamondLightSource/dls-plc-tools.git
+cd dls-plc-tools
+uv sync
+uv run dls-read-plc <ip>
+```
+
+## Notes
+
+- These tools only ever **read**. They never write to the controller, never
+  start a keep-alive poll, and keep at most one request in flight. Poll rates
+  default to ~2 s and are floored at 0.5 s.
+- Tags are visible over EtherNet/IP only if they are globals with **Network
+  Publish** set in Sysmac Studio, plus the controller's `_`-prefixed system
+  variables. Enumeration uses Omron's Tag Name Server object (CIP class 0x6A).
+- DLS structures are structure-of-arrays: `Seq.Interfc[1]` is instance 1, with
+  index 0 reserved as padding. A non-empty `Desc` entry marks an instance that
+  is actually in use.

dls_plc_tools-1.0.0b1.dist-info/RECORD

@@ -0,0 +1,13 @@
+dls_plc_tools/__init__.py,sha256=Ksms_WJF8LTkbm38gEpm1jBpGqcQ8NGvmb2ZJlOE1j8,198
+dls_plc_tools/__main__.py,sha256=ukbWFuT5ZuGM0fx6Cgruti5CulUB-MJpYfL-zayiMmQ,483
+dls_plc_tools/_version.py,sha256=g-APWZSn1knLVTjqPp_TMtEX7rVFXNkdsvigOIU8Mnc,528
+dls_plc_tools/gui.py,sha256=FiIFT9UO-5JINvY09ZdNt1Lzw-gW-qdUOMIhslGUfUU,15710
+dls_plc_tools/interrogate.py,sha256=J0X_36aP_b2whq_ka-M2A8_bR_dQucigBM26JOChOYg,8513
+dls_plc_tools-1.0.0b1.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+dls_plc_tools-1.0.0b1.dist-info/METADATA,sha256=QcLWxSPiTaDn6WF6IWHX-CQGATYy2d5Y-TBwK_rvMuw,17333
+dls_plc_tools-1.0.0b1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+dls_plc_tools-1.0.0b1.dist-info/entry_points.txt,sha256=OMcu__WHPbzJh-PXksHSToQu7M5qXeJ-oz1VYKGo8UE,150
+dls_plc_tools-1.0.0b1.dist-info/scm_file_list.json,sha256=_bs-ON96jexSdl1R1hCbYe1dBpL6doVnfkw9cYaqqNE,1134
+dls_plc_tools-1.0.0b1.dist-info/scm_version.json,sha256=-Xphms0fOmuSKFBEiKvbaJwiTYXm7AaBCcZveogqCe0,162
+dls_plc_tools-1.0.0b1.dist-info/top_level.txt,sha256=PhodyMhs7VIKly5c5d45712Dl1kRHWa6VW7Df0FlSk0,14
+dls_plc_tools-1.0.0b1.dist-info/RECORD,,

dls_plc_tools-1.0.0b1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dls_plc_tools-1.0.0b1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+dls-plc-tools = dls_plc_tools.__main__:main
+dls-read-plc = dls_plc_tools.interrogate:main
+dls-read-plc-gui = dls_plc_tools.gui:main

dls_plc_tools-1.0.0b1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

dls_plc_tools-1.0.0b1.dist-info/scm_file_list.json

@@ -0,0 +1,41 @@
+{
+  "files": [
+    ".pre-commit-config.yaml",
+    "README.md",
+    "uv.lock",
+    "Dockerfile",
+    ".python-version",
+    "LICENSE",
+    "pyproject.toml",
+    "catalog-info.yaml",
+    "renovate.json",
+    "CLAUDE.md",
+    ".gitleaks.toml",
+    ".gitignore",
+    ".copier-answers.yml",
+    ".devcontainer/devcontainer.json",
+    ".vscode/tasks.json",
+    ".vscode/launch.json",
+    ".vscode/settings.json",
+    ".vscode/extensions.json",
+    "src/dls_plc_tools/__init__.py",
+    "src/dls_plc_tools/interrogate.py",
+    "src/dls_plc_tools/gui.py",
+    "src/dls_plc_tools/__main__.py",
+    "tests/conftest.py",
+    "tests/test_cli.py",
+    ".github/CONTRIBUTING.md",
+    ".github/PULL_REQUEST_TEMPLATE/pull_request_template.md",
+    ".github/pages/index.html",
+    ".github/pages/make_switcher.py",
+    ".github/ISSUE_TEMPLATE/bug_report.md",
+    ".github/ISSUE_TEMPLATE/issue.md",
+    ".github/workflows/_pypi.yml",
+    ".github/workflows/_container.yml",
+    ".github/workflows/_release.yml",
+    ".github/workflows/_test.yml",
+    ".github/workflows/ci.yml",
+    ".github/workflows/_tox.yml",
+    ".github/workflows/_dist.yml"
+  ]
+}

dls_plc_tools-1.0.0b1.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.0b1",
+  "distance": 0,
+  "node": "g34a248c31e01933ceaf4a5c47fc4ec74bfd70470",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-13"
+}

dls_plc_tools-1.0.0b1.dist-info/top_level.txt

@@ -0,0 +1 @@
+dls_plc_tools