leaf-framework 0.11.1__tar.gz → 0.12.0__tar.gz

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-framework
-Version: 0.11.1
+Version: 0.12.0
 Summary: Lightweight Adapter Framework (LEAF)
 License: Apache-2.0
 License-File: LICENSE
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: cairosvg (>=2.9.1,<3.0.0)
 Requires-Dist: dateparser (>=1.4.3,<1.5.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: leafobject (>=0.0.14,<0.0.15)
+Requires-Dist: leafobject (>=0.1.0,<0.2.0)
 Requires-Dist: nicegui (>=3.18.0,<3.19.0)
 Requires-Dist: paho-mqtt (>=2.1.0,<2.2.0)
 Requires-Dist: pillow (>=13.0.0,<14.0.0)

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/adapters/core_adapters/continuous_experiment_adapter.py

@@ -87,6 +87,6 @@ class ContinuousExperimentAdapter(EquipmentAdapter):
         Injects a synthetic start message via the control process
         to initialise any start-specific logic or output.
         """
-        start_topic = self._metadata_manager.experiment.start
+        start_topic = self._metadata_manager.start
         self._control_process.process_input(start_topic, {})
         super().start()

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/adapters/core_adapters/streaming_adapter.py

@@ -159,9 +159,9 @@ class StreamingAdapter(EquipmentAdapter):
         is active for a filename, further non-start/stop events for it are
         no-ops; the running stream() call handles tailing on its own.
         """
-        if topic() == self._metadata_manager.experiment.start():
+        if topic() == self._metadata_manager.start():
             self._launch_stream(data)
-        elif topic() == self._metadata_manager.experiment.stop():
+        elif topic() == self._metadata_manager.stop():
             self._stop_stream(data)
         else:
             with self._streams_guard:

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/adapters/equipment_adapter.py

@@ -293,7 +293,12 @@ class EquipmentAdapter(ABC):
         """Publish what happened to a control message on <control topic>/result, so it is stored with the data."""
         # Never let the record break the command it describes
         try:
-            record = result_record(data, source, error, self._metadata_manager.instance_tags())
+            # A control acts on the instance itself, so that is its entity unless the message names one
+            instance_tags = {
+                **self._metadata_manager.instance_tags(),
+                "entity": self._metadata_manager.get_instance_id(),
+            }
+            record = result_record(data, source, error, instance_tags)
             _ = self._output.transmit(f"{topic}/result", record)
         except Exception as e:
             self._logger.warning(f"Could not publish the control record for {topic}: {e}")

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/input_modules/ble_watcher.py

@@ -231,7 +231,7 @@ class BLEEventWatcher(EventWatcher):
 
         # Dispatch to callbacks using the measurement event
         if self._metadata_manager:
-            self._dispatch_callback(self._metadata_manager.experiment.measurement, event_data)
+            self._dispatch_callback(self._metadata_manager.measurement, event_data)
         else:
             # Fallback: call callbacks directly with "measurement" event
             for callback in self._callbacks:

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/input_modules/file_watcher.py

@@ -131,9 +131,9 @@ class FileWatcher(FileSystemEventHandler, EventWatcher):
         self._pending_timers: dict = {}  # Track pending trailing timers per file path
 
         self._term_map = {
-            self.on_created: metadata_manager.experiment.start,
-            self.on_modified: metadata_manager.experiment.measurement,
-            self.on_deleted: metadata_manager.experiment.stop,
+            self.on_created: metadata_manager.start,
+            self.on_modified: metadata_manager.measurement,
+            self.on_deleted: metadata_manager.stop,
         }
 
     def start(self) -> None:

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/input_modules/lads_watcher.py

@@ -100,7 +100,7 @@ class LADSWatcher(EventWatcher):
         self.logger.debug(f"LADS datachange_notification: node={nodeid}, value={val}")
         info = self._variables.get(nodeid, {})
         self._dispatch_callback(
-            self._metadata_manager.experiment.measurement,
+            self._metadata_manager.measurement,
             {
                 "functional_unit": info.get("functional_unit"),
                 "node": node.nodeid.Identifier,
@@ -321,7 +321,7 @@ class LADSWatcher(EventWatcher):
                 self.logger.info(f"Subscribed to: {info['functional_unit']}/{info['browse_name']} ({nodeid})")
                 # Send a dummy value to trigger the callback
                 self._dispatch_callback(
-                    self._metadata_manager.experiment.measurement,
+                    self._metadata_manager.measurement,
                     {
                         "functional_unit": info["functional_unit"],
                         "node": node.nodeid.Identifier,

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/input_modules/modbus_watcher.py

@@ -170,7 +170,7 @@ class ModbusWatcher(ExternalEventWatcher):
 
     def _emit(self, data: dict[str, Any]) -> None:
         if self._metadata_manager:
-            self._dispatch_callback(self._metadata_manager.experiment.measurement, data)
+            self._dispatch_callback(self._metadata_manager.measurement, data)
         else:
             for callback in self._callbacks:
                 try:

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/input_modules/mqtt_watcher.py

@@ -92,9 +92,9 @@ class MQTTEventWatcher(EventWatcher):
 
         # topic -> list of events
         self._topic_event_map: dict[str, list[str]] = {}
-        self._register_topics(start_topics, metadata_manager.experiment.start)
-        self._register_topics(measurement_topics, metadata_manager.experiment.measurement)
-        self._register_topics(stop_topics, metadata_manager.experiment.stop)
+        self._register_topics(start_topics, metadata_manager.start)
+        self._register_topics(measurement_topics, metadata_manager.measurement)
+        self._register_topics(stop_topics, metadata_manager.stop)
         self._register_topics(error_topics, metadata_manager.error)
 
         # Set when on_connect fires so start() can block until subscriptions are active

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/input_modules/opc_watcher.py

@@ -77,7 +77,7 @@ class OPCWatcher(EventWatcher):
     def datachange_notification(self, node: Node, val: int | str | float, data: DataChangeNotification) -> None:
         self.logger.debug(f"OPC datachange_notification: node={node.nodeid.Identifier}, value={val}")
         self._dispatch_callback(
-            self._metadata_manager.experiment.measurement,
+            self._metadata_manager.measurement,
             {
                 "node": node.nodeid.Identifier,
                 "value": val,
@@ -233,7 +233,7 @@ class OPCWatcher(EventWatcher):
                 self.logger.info(f"Subscribed to: {node.nodeid.to_string()}")
                 # Send a dummy value to trigger the callback
                 self._dispatch_callback(
-                    self._metadata_manager.experiment.measurement,
+                    self._metadata_manager.measurement,
                     {
                         "node": node.nodeid.Identifier,
                         "value": node.get_value(),

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/input_modules/polling_watcher.py

@@ -1,5 +1,4 @@
 import threading
-import time
 from abc import abstractmethod
 from collections.abc import Callable
 from typing import Any
@@ -40,10 +39,12 @@ class PollingWatcher(EventWatcher):
 
         self._interval: int = interval
         self._thread: threading.Thread | None = None
+        # Set by stop() so the poll loop wakes at once instead of finishing a full interval.
+        self._stop_event: threading.Event = threading.Event()
         self._term_map = {
-            self.start_message: metadata_manager.experiment.start,
-            self.stop_message: metadata_manager.experiment.stop,
-            self.measurement_message: metadata_manager.experiment.measurement,
+            self.start_message: metadata_manager.start,
+            self.stop_message: metadata_manager.stop,
+            self.measurement_message: metadata_manager.measurement,
         }
 
     def start_message(self, data: Any) -> None:
@@ -99,7 +100,7 @@ class PollingWatcher(EventWatcher):
                     # reporting data.
                     pass
 
-            time.sleep(self._interval)
+            _ = self._stop_event.wait(self._interval)
 
     def start(self) -> None:
         """
@@ -112,6 +113,7 @@ class PollingWatcher(EventWatcher):
             return
 
         self._running = True
+        self._stop_event.clear()
         self._thread = threading.Thread(target=self._poll, daemon=True)
         self._thread.start()
 
@@ -127,6 +129,7 @@ class PollingWatcher(EventWatcher):
             return
 
         self._running = False
+        self._stop_event.set()
         if self._thread:
             self._thread.join()
         logger.info("PollingWatcher stopped.")

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/output_modules/topic_store.py

@@ -46,13 +46,12 @@ class TopicStore:
             sample = _point_sample(point)
             if sample is None:
                 continue
-            key = history_key(topic, point)
             with self._history_lock:
-                history = self._history.setdefault(key, deque(maxlen=HISTORY_LENGTH))
+                history = self._history.setdefault(topic, deque(maxlen=HISTORY_LENGTH))
                 history.append(sample)
 
     def get_history(self) -> dict[str, list[tuple[float, float]]]:
-        """(timestamp, value) pairs per history key (see history_key), oldest first."""
+        """(timestamp, value) pairs per topic, oldest first."""
         with self._history_lock:
             return {topic: list(points) for topic, points in self._history.items()}
 
@@ -83,20 +82,6 @@ class TopicStore:
         return self._store
 
 
-# Separates the topic from the point's entity tag in a history key
-ENTITY_SEPARATOR = "#"
-
-
-def history_key(topic: str, point: object) -> str:
-    """Topic plus the point's "entity" tag, since one topic can carry several entities (e.g. the wells of a plate)."""
-    tags = cast(dict[str, object], point).get("tags")
-    if isinstance(tags, dict):
-        entity = cast(dict[str, object], tags).get("entity")
-        if isinstance(entity, str) and entity:
-            return f"{topic}{ENTITY_SEPARATOR}{entity}"
-    return topic
-
-
 def _point_sample(point: object) -> tuple[float, float] | None:
     """(timestamp, value) of a LeafPoint JSON dict with a numeric fields.value, or None."""
     if not isinstance(point, dict):

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/phase_modules/measure.py

@@ -1,4 +1,5 @@
 import inspect
+import re
 import threading
 import time
 from typing import TYPE_CHECKING, Any, cast
@@ -35,11 +36,10 @@ class MeasurePhase(PhaseModule):
             maximum_message_size (Optional[int]): The maximum number of measurements in a single message.
             error_holder (Optional[ErrorHolder]): Optional, an error holder to manage phase errors.
         """
-        term_builder = (
-            metadata_manager.experiment.measurement
-            if metadata_manager is not None
-            else "metadata_manager.experiment.measurement"
-        )
+        if metadata_manager is not None:
+            term_builder = metadata_manager.measurement
+        else:
+            term_builder = "metadata_manager.measurement"
 
         super().__init__(term_builder, metadata_manager=metadata_manager, error_holder=error_holder)
         self._maximum_message_size: int = maximum_message_size
@@ -147,10 +147,10 @@ class MeasurePhase(PhaseModule):
             finally:
                 self._measurement_lock.release()
         else:
-            experiment_id = kwargs.get("experiment_id", "unknown")
             measurement = kwargs.get("measurement", "unknown")
+            entity = kwargs.get("entity", self._instance_entity())
 
-            action = self._term_builder(experiment_id=experiment_id, measurement=measurement)
+            action = self._term_builder(entity=entity, measurement=measurement)
             return [(action, data)]
 
     def stream(self, output: "OutputModule", filename: Any) -> None:
@@ -218,11 +218,9 @@ class MeasurePhase(PhaseModule):
         """
         Formulate one or more (topic, data) messages for a measurement result.
 
-        A list/set of points can mix several distinct measurement types
-        (e.g. pH, temperature, oxygen) in the same batch. Since the topic
-        encodes a single measurement type, each distinct type present in
-        the batch is split out into its own message rather than all being
-        published under whichever type happened to come first.
+        A list/set of points can mix several measurement types (e.g. pH,
+        temperature) and entities (e.g. reactors) in one batch. The topic
+        encodes one of each, so every distinct pair gets its own message.
 
         Args:
             experiment_id (str): The ID of the experiment.
@@ -232,56 +230,58 @@ class MeasurePhase(PhaseModule):
             list[tuple]: A list of (action, result) tuples.
         """
         if isinstance(result, dict):
-            self._add_instance_tags(cast(object, result))
-            measurement = self._resolve_measurement(result)
-            action = self._term_builder(experiment_id=experiment_id, measurement=measurement)
-            return [(action, result)]
+            self._add_instance_tags(cast(object, result), experiment_id)
+            return [(self._topic_of(result), result)]
 
         payload = cast(object, result)
-        point_json = point_json_of(payload)
+        try:
+            point_json = point_json_of(self._with_entity(payload))
+        except ValueError as ex:
+            # A LeafPoint that fails validation, e.g. one without an entity tag
+            self._handle_exception(InterpreterError(str(ex)))
+            return []
         if point_json is not None:
             result = point_json
-            self._add_instance_tags(cast(object, result))
-            measurement = self._resolve_measurement(result)
-            action = self._term_builder(experiment_id=experiment_id, measurement=measurement)
-            return [(action, result)]
+            self._add_instance_tags(cast(object, result), experiment_id)
+            return [(self._topic_of(result), result)]
 
         if isinstance(result, list):
             converted = []
             for item in cast(list[object], result):
-                point_json = point_json_of(item)
+                try:
+                    point_json = point_json_of(self._with_entity(item))
+                except ValueError as ex:
+                    # Only the invalid point is dropped, the rest of the batch is still sent
+                    self._handle_exception(InterpreterError(str(ex)))
+                    continue
                 if point_json is not None:
                     converted.append(point_json)
                 else:
                     converted.append(item)
 
+            # One message per topic, so per metric and entity
             groups: dict[str, list] = {}
             for item in converted:
-                self._add_instance_tags(cast(object, item))
-                if isinstance(item, dict):
-                    key = self._resolve_measurement(item)
-                else:
-                    key = "unknown"
-                groups.setdefault(key, []).append(item)
-
-            messages = []
-            for key, group in groups.items():
-                action = self._term_builder(experiment_id=experiment_id, measurement=key)
-                messages.append((action, group))
-            return messages
+                self._add_instance_tags(cast(object, item), experiment_id)
+                groups.setdefault(self._topic_of(item), []).append(item)
+            return list(groups.items())
 
         excp = AdapterLogicError(f"Unknown measurement data type: {type(result)}")
         self._handle_exception(excp)
         return []
 
-    def _add_instance_tags(self, item: object) -> None:
-        """Tag a point with its instance's organisation and department, unless the adapter already did."""
+    def _add_instance_tags(self, item: object, experiment_id: str | None = None) -> None:
+        """Tag a point with its instance's organisation, department, experiment id and entity, unless the adapter already did."""
         if self._metadata_manager is None or not isinstance(item, dict) or "fields" not in item:
             return
         tags = cast(dict[str, object], item).setdefault("tags", {})
         if not isinstance(tags, dict):
             return
-        for key, value in self._metadata_manager.instance_tags().items():
+        expected = self._metadata_manager.instance_tags()
+        # These defaults mean the adapter never set an experiment id
+        if experiment_id and experiment_id not in ("undefined", "invalid_id"):
+            expected["experiment_id"] = experiment_id
+        for key, value in expected.items():
             current = cast(dict[str, object], tags).get(key)
             if current is None:
                 tags[key] = value
@@ -291,6 +291,40 @@ class MeasurePhase(PhaseModule):
                 logger.warning(
                     f"Tag {key}={current!r} differs from the configured {key} {value!r}; keeping {current!r}"
                 )
+        # Every point has an entity; one inside the instance (e.g. a reactor) differs from it by design, so no warning
+        if not tags.get("entity"):
+            tags["entity"] = self._instance_entity()
+
+    def _with_entity(self, item: object) -> object:
+        """Name the instance as the entity of a LeafPoint that names none."""
+        # Before to_json(), which rejects a point without an entity
+        tags: object = getattr(item, "tags", None)
+        if not isinstance(tags, dict):
+            return item
+        point_tags = cast(dict[str, object], tags)
+        if not point_tags.get("entity"):
+            point_tags["entity"] = self._instance_entity()
+        return item
+
+    def _topic_of(self, item: object) -> str:
+        """Measurement topic of a point: .../measurement/<entity>/<metric>."""
+        if not isinstance(item, dict):
+            return self._term_builder(entity=self._instance_entity(), measurement="unknown")
+        return self._term_builder(entity=self._resolve_entity(item), measurement=self._resolve_measurement(item))
+
+    def _instance_entity(self) -> str:
+        """Entity of a point that names none: the instance itself."""
+        if self._metadata_manager is None:
+            return "unknown"
+        return self._metadata_manager.get_instance_id() or "unknown"
+
+    def _resolve_entity(self, item: dict[str, Any]) -> str:
+        """The point's "entity" tag, else the instance."""
+        tags = item.get("tags")
+        if not isinstance(tags, dict) or not tags.get("entity"):
+            return self._instance_entity()
+        # Level separators and wildcards would break the topic
+        return re.sub(r"[/+#]", "_", str(tags["entity"]))
 
     def _resolve_measurement(self, item: dict) -> str:
         """

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/phase_modules/start.py

@@ -25,7 +25,7 @@ class StartPhase(ControlPhase):
             metadata_manager (MetadataManager): Manages metadata associated with the phase.
             error_holder (Optional[ErrorHolder]): Optional, an error holder to manage phase errors.
         """
-        term_builder = metadata_manager.experiment.start
+        term_builder = metadata_manager.start
         super().__init__(term_builder, metadata_manager=metadata_manager, error_holder=error_holder)
 
     def update(self, data: Any) -> list:
@@ -48,5 +48,5 @@ class StartPhase(ControlPhase):
 
         data = super().update(data)
         data += [(self._metadata_manager.running(), True)]
-        data += [(self._metadata_manager.experiment.stop(), None)]
+        data += [(self._metadata_manager.stop(), None)]
         return data

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/phase_modules/stop.py

@@ -25,7 +25,7 @@ class StopPhase(ControlPhase):
             metadata_manager (MetadataManager): Manages metadata associated with the phase.
             error_holder (Optional[ErrorHolder]): Optional, an error holder to manage phase errors.
         """
-        term_builder = metadata_manager.experiment.stop
+        term_builder = metadata_manager.stop
         super().__init__(term_builder, metadata_manager=metadata_manager, error_holder=error_holder)
 
     def update(self, data: Any) -> list:
@@ -47,5 +47,5 @@ class StopPhase(ControlPhase):
                 self._handle_exception(leaf_exp)
         data = super().update(data)
         data += [(self._metadata_manager.running(), False)]
-        data += [(self._metadata_manager.experiment.start(), None)]
+        data += [(self._metadata_manager.start(), None)]
         return data

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/modules/process_modules/upload_module.py

@@ -43,7 +43,7 @@ class UploadProcess(DiscreteProcess):
             topic (str): The topic to activate a specific phase.
             data (dict): The data to be processed by the phase.
         """
-        if topic() != self._metadata_manager.experiment.start():
+        if topic() != self._metadata_manager.start():
             assert topic() == self._metadata_manager.details()
             return super().process_input(topic, data)
 
@@ -52,11 +52,11 @@ class UploadProcess(DiscreteProcess):
         time.sleep(1)
 
         # Measurements
-        measure_builder = self._metadata_manager.experiment.measurement
+        measure_builder = self._metadata_manager.measurement
         super().process_input(measure_builder, data)
         time.sleep(1)
 
         # Stop
-        stop_builder = self._metadata_manager.experiment.stop
+        stop_builder = self._metadata_manager.stop
         super().process_input(stop_builder, data)
         time.sleep(1)

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/register/equipment_actions.yaml

@@ -4,7 +4,8 @@ heartbeat: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/heartbe
 error: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/error
 control: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/control
 control_result: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/control/result
-experiment:
-  start: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/experiment/start
-  stop: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/experiment/stop
-  measurement: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/experiment/<experiment_id>/measurement/<measurement>
+# A run (experiment, batch, upload) starts and stops on the instance itself; its id is a point tag
+start: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/start
+stop: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/stop
+# The entity is what a point is about: the instance itself, or something inside it such as a reactor
+measurement: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/measurement/<entity>/<measurement>

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/register/metadata.py

@@ -117,8 +117,8 @@ class MetadataManager:
 
     def __getattr__(self, name: str) -> Any:
         """
-        If the user does 'metadata_manager.experiment.start()', we look up
-        'experiment.start' in the TopicUtility's root group, and wrap it to
+        If the user does 'metadata_manager.start()', we look up
+        'start' in the TopicUtility's root group, and wrap it to
         auto-fill placeholders with equipment metadata.
         """
         try:
@@ -129,10 +129,7 @@ class MetadataManager:
         if callable(sub):
 
             def _wrapper(**overrides) -> str:
-                data = self.get_equipment_data().copy()
-                data.update(self.get_instance_data())
-                placeholders = {**data, **overrides}
-                return sub(**placeholders)
+                return cast(str, sub(**self._placeholders(overrides)))
 
             return _wrapper
         if isinstance(sub, _TemplateGroup):
@@ -140,6 +137,15 @@ class MetadataManager:
 
         return sub
 
+    def _placeholders(self, overrides: dict[str, Any]) -> dict[str, Any]:
+        """Template placeholders from the equipment and instance data, then the caller's overrides."""
+        data = self.get_equipment_data().copy()
+        data.update(self.get_instance_data())
+        # A point that names no entity is about the instance itself
+        if data.get("instance_id"):
+            data.setdefault("entity", data["instance_id"])
+        return {**data, **overrides}
+
 
 class _ManagerGroup:
     """
@@ -156,10 +162,7 @@ class _ManagerGroup:
         if callable(sub):
 
             def _wrapper(**overrides) -> str:
-                data = self._manager.get_equipment_data().copy()
-                data.update(self._manager.get_instance_data())
-                placeholders = {**data, **overrides}
-                return sub(**placeholders)
+                return cast(str, sub(**self._manager._placeholders(overrides)))  # pyright: ignore[reportPrivateUsage]
 
             return _wrapper
         if isinstance(sub, _TemplateGroup):

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/register/topic_utilities.py

@@ -68,7 +68,7 @@ class TopicUtility:
         self._collect_templates(self._raw_dict)
         self.root = _TemplateGroup(self._raw_dict, self)
 
-    def __getattr__(self, name: str):
+    def __getattr__(self, name: str) -> Any:
         """
         Handle dynamic attribute access:
         - If it's a required field from the YAML, return its name.

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/ui/tabs/control.py

@@ -190,16 +190,22 @@ def controllable_instances() -> list[EquipmentAdapter]:
 
 def _instance_card(adapter: EquipmentAdapter) -> None:
     metadata = adapter.metadata_manager
-    with ui.card().classes("leaf-card w-full mb-4"):
-        _ = ui.label(f"{metadata.get_instance_id()} ({metadata.get_equipment_data('adapter_id')})").classes(
-            "text-lg font-semibold text-heading"
-        )
+    title = f"{metadata.get_instance_id()} ({metadata.get_equipment_data('adapter_id')})"
+    # Foldable, so an instance with many controls can be tucked away
+    with (
+        ui.card().classes("leaf-card w-full mb-4"),
+        ui.expansion(title, caption=f"{len(adapter.controls)} controls", value=True)
+        .classes("w-full")
+        .props('header-class="text-lg font-semibold text-heading"'),
+    ):
         if not adapter.controls:
             _ = ui.label(
                 "This adapter declares no controls in its device.json; send LeafPoints on the control topic instead."
             ).classes("text-body-secondary")
-        for control in adapter.controls:
-            _control_row(adapter, control)
+        # Two columns on wide screens, one on narrow ones
+        with ui.element("div").classes("grid grid-cols-1 lg:grid-cols-2 gap-x-8 w-full"):
+            for control in adapter.controls:
+                _control_row(adapter, control)
 
 
 def create_control_tab(control_tab: ui.tab) -> None:

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/leaf/ui/tabs/monitoring.py

@@ -3,7 +3,6 @@ from typing import Any, cast
 from nicegui import ui
 
 from leaf.modules.output_modules.output_module import OutputModule
-from leaf.modules.output_modules.topic_store import ENTITY_SEPARATOR
 
 
 def _store_to_tree_nodes(store: dict, parent_path: str = "") -> list[dict[str, Any]]:
@@ -25,9 +24,8 @@ def _store_to_tree_nodes(store: dict, parent_path: str = "") -> list[dict[str, A
 
 
 def metric_name(key: str) -> str:
-    """Last topic segment of a history key, e.g. "T" for ".../reactor1/T#well A1"."""
-    topic = key.split(ENTITY_SEPARATOR, 1)[0]
-    return topic.rsplit("/", 1)[-1]
+    """Last topic segment, e.g. "T" for ".../reactor1/measurement/well_A1/T"."""
+    return key.rsplit("/", 1)[-1]
 
 
 def format_value(value: float) -> str:
@@ -40,40 +38,42 @@ def full_label(key: str) -> str:
     return key.split("/", 1)[-1]
 
 
+def measurement_levels(key: str) -> list[str]:
+    """[instance, entity, metric] of a .../<instance_id>/measurement/<entity>/<metric> topic, else [].
+
+    The entity is left out when it only names the instance again, as for a single device.
+    """
+    parts = key.split("/")
+    if len(parts) < 4 or parts[-3] != "measurement":
+        return []
+    instance, entity, metric = parts[-4], parts[-2], parts[-1]
+    if entity == instance:
+        return [instance, metric]
+    return [instance, entity, metric]
+
+
 def instance_name(key: str) -> str:
-    """Instance ID of a measurement topic, which ends in <instance_id>/experiment/<experiment_id>/measurement/<metric>; else ""."""
-    parts = key.partition(ENTITY_SEPARATOR)[0].split("/")
-    if len(parts) < 5 or parts[-2] != "measurement" or parts[-4] != "experiment":
-        return ""
-    return parts[-5]
+    """Instance ID of a measurement topic, else ""."""
+    levels = measurement_levels(key)
+    if levels:
+        return levels[0]
+    return ""
 
 
-def series_label(key: str, all_keys: list[str]) -> str:
-    """ "<instance_id> · <entity> · <metric>" for a measurement topic, else the full label.
+def series_label(key: str) -> str:
+    """ "<instance_id> · <entity> · <metric>" for a measurement topic, else the full label."""
+    levels = measurement_levels(key)
+    if levels:
+        return " · ".join(levels)
+    return full_label(key)
 
-    The entity only shows when several entities share the topic (e.g. wells of a plate); a single
-    entity per topic usually just names the instance again (leaf-example tags every point "bioreactor 1").
-    """
-    topic, _, entity = key.partition(ENTITY_SEPARATOR)
-    instance = instance_name(key)
-    if not instance:
-        return full_label(key)
-    # Instance stays in: entity names repeat across instances
-    names = [instance]
-    shared = [other for other in all_keys if other.partition(ENTITY_SEPARATOR)[0] == topic]
-    if entity and len(shared) > 1:
-        names.append(entity)
-    names.append(metric_name(topic))
-    return " · ".join(names)
-
-
-def tile_label(key: str, all_keys: list[str]) -> str:
+
+def tile_label(key: str) -> str:
     """Series label without the instance, which the tile's group box already names."""
-    instance = instance_name(key)
-    label = series_label(key, all_keys)
-    if instance:
-        return label.removeprefix(f"{instance} · ")
-    return label
+    levels = measurement_levels(key)
+    if levels:
+        return " · ".join(levels[1:])
+    return full_label(key)
 
 
 # ECharts' default palette, assigned per metric rather than per selected line
@@ -92,7 +92,7 @@ def chart_series(history: dict[str, list[tuple[float, float]]], topics: list[str
         points = [[timestamp * 1000, value] for timestamp, value in history.get(topic, [])]
         series.append(
             {
-                "name": series_label(topic, list(history)),
+                "name": series_label(topic),
                 "type": "line",
                 "showSymbol": False,
                 "color": metric_color(topic, list(history)),
@@ -136,6 +136,8 @@ def create_monitoring_tab(monitor_tab: ui.tab) -> None:
                 tiles = ui.row().classes("w-full gap-3")
                 tile_groups: dict[str, ui.row] = {}
                 tile_values: dict[str, ui.label] = {}
+                tile_expansions: dict[str, ui.expansion] = {}
+                tile_count: dict[str, int] = {}
 
                 # Metrics with different scales do not share an axis well, so the user picks which to plot
                 with ui.row().classes("w-full items-center no-wrap"):
@@ -179,19 +181,28 @@ def create_monitoring_tab(monitor_tab: ui.tab) -> None:
                         if topic not in tile_values:
                             instance = instance_name(topic)
                             if instance not in tile_groups:
-                                with tiles, ui.card().props("flat bordered").classes("p-3 gap-2"):
-                                    _ = ui.label(instance or "Other").classes("text-sm font-medium")
-                                    tile_groups[instance] = ui.row().classes("gap-3")
+                                # Foldable, so an instance with many metrics can be tucked away
+                                with (
+                                    tiles,
+                                    ui.card().props("flat bordered").classes("p-0"),
+                                    ui.expansion(instance or "Other", value=True).props(
+                                        'dense header-class="text-sm font-medium"'
+                                    ) as group,
+                                ):
+                                    tile_groups[instance] = ui.row().classes("gap-3 p-3 pt-0")
+                                tile_expansions[instance] = group
+                            tile_count[instance] = tile_count.get(instance, 0) + 1
+                            _ = tile_expansions[instance].props(f'caption="{tile_count[instance]} metrics"')
                             stripe = f"border-left: 4px solid {metric_color(topic, topics)}"
                             with (
                                 tile_groups[instance],
                                 ui.card().classes("p-3 min-w-32").style(stripe).tooltip(full_label(topic)),
                             ):
-                                _ = ui.label(tile_label(topic, topics)).classes("text-xs text-body-secondary")
+                                _ = ui.label(tile_label(topic)).classes("text-xs text-body-secondary")
                                 tile_values[topic] = ui.label().classes("text-2xl font-bold text-heading")
                         _ = tile_values[topic].set_text(format_value(history[topic][-1][1]))
                     # NiceGUI leaves the options type unparametrised
-                    _ = metric_select.set_options({topic: series_label(topic, topics) for topic in topics})  # pyright: ignore[reportUnknownMemberType]
+                    _ = metric_select.set_options({topic: series_label(topic) for topic in topics})  # pyright: ignore[reportUnknownMemberType]
                     selected = cast(list[str], metric_select.value or [])
                     if not selected and topics and not picked_default:
                         selected = [topics[0]]

{leaf_framework-0.11.1 → leaf_framework-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "leaf-framework"
-version = "0.11.1"
+version = "0.12.0"
 description = "Lightweight Adapter Framework (LEAF)"
 authors = [
     "Matthew Crowther <nmc215@ncl.ac.uk>",
@@ -33,7 +33,7 @@ requests = "~2.34.2"
 watchdog = "~7.0.0"
 cairosvg = "^2.9.1"
 pillow = "^13.0.0"
-leafobject = "^0.0.14"
+leafobject = "^0.1.0"
 
 [tool.poetry.scripts]
 leaf = "leaf.start:main"