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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-framework
-Version: 0.11.0
+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.0 → leaf_framework-0.12.0}/leaf/adapters/control_spec.py

@@ -140,7 +140,9 @@ def _field_value(value: object) -> int | float | str:
     return json.dumps(value)
 
 
-def result_record(data: str, source: str, error: Exception | None = None) -> dict[str, object]:
+def result_record(
+    data: str, source: str, error: Exception | None = None, instance_tags: dict[str, str] | None = None
+) -> dict[str, object]:
     """
     A control message as the LeafPoint LEAF publishes on <control topic>/result, so that what was
     sent to the equipment is stored with the measurements.
@@ -159,6 +161,10 @@ def result_record(data: str, source: str, error: Exception | None = None) -> dic
     tags: dict[str, str] = {}
     for key, value in _part(point, "tags").items():
         tags[key] = str(value)
+    # The instance's organisation and department, where the message didn't set them
+    if instance_tags is not None:
+        for key, value in instance_tags.items():
+            _ = tags.setdefault(key, value)
     fields: dict[str, int | float | str] = {}
     for key, value in _part(point, "fields").items():
         fields[key] = _field_value(value)

{leaf_framework-0.11.0 → 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.0 → 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.0 → leaf_framework-0.12.0}/leaf/adapters/equipment_adapter.py

@@ -293,7 +293,13 @@ 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:
-            _ = self._output.transmit(f"{topic}/result", result_record(data, source, error))
+            # 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.0 → leaf_framework-0.12.0}/leaf/modules/input_modules/ble_watcher.py

@@ -21,7 +21,6 @@ logger = get_logger(__name__, log_file="input_module.log")
 FIRST_RECONNECT_DELAY = 1
 RECONNECT_RATE = 2
 MAX_RECONNECT_DELAY = 60
-MAX_RECONNECT_COUNT = 12
 
 
 class BLEEventWatcher(EventWatcher):
@@ -232,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.0 → 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.0 → 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.0 → 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.0 → leaf_framework-0.12.0}/leaf/modules/input_modules/mqtt_external_event_watcher.py

@@ -241,22 +241,3 @@ class MQTTExternalEventWatcher(ExternalEventWatcher):
             bool: True if the client is connected, False otherwise.
         """
         return self.client.is_connected()
-
-    def _handle_return_code(self, return_code: int) -> ClientUnreachableError | None:
-        """
-        Handle MQTT return codes.
-
-        Args:
-            return_code (int): The return code to handle.
-
-        Returns:
-            Optional[ClientUnreachableError]: An error if one occurred, None otherwise.
-        """
-        if return_code == mqtt.MQTT_ERR_SUCCESS:
-            return None
-        message = {
-            mqtt.MQTT_ERR_NO_CONN: "Can't connect to broker",
-            mqtt.MQTT_ERR_QUEUE_SIZE: "Message queue size limit reached",
-        }.get(return_code, f"Unknown error with return code {return_code}")
-
-        return ClientUnreachableError(message, output_module=self, severity=SeverityLevel.INFO)

{leaf_framework-0.11.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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,14 +36,14 @@ 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
+        self._tag_mismatches: set[tuple[str, str]] = set()
         # Guards against a second measurement running concurrently with one still
         # draining (e.g. a generator-based interpreter that streams for a long time,
         # or forever). Without this, an overlapping event (e.g. FileWatcher's
@@ -146,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:
@@ -217,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.
@@ -231,45 +230,102 @@ class MeasurePhase(PhaseModule):
             list[tuple]: A list of (action, result) tuples.
         """
         if isinstance(result, dict):
-            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
-            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:
-                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, 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
+        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
+            elif str(current) != value and (key, str(current)) not in self._tag_mismatches:
+                # Kept as the adapter set it; warned once so every measurement doesn't repeat it
+                self._tag_mismatches.add((key, str(current)))
+                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:
         """
         Resolve the measurement label used for the topic's last segment.

{leaf_framework-0.11.0 → 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.0 → 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.0 → 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.0 → 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.0 → leaf_framework-0.12.0}/leaf/register/metadata.py

@@ -1,6 +1,6 @@
 import json
 import os
-from typing import Any
+from typing import Any, cast
 
 import yaml  # type: ignore
 
@@ -60,6 +60,15 @@ class MetadataManager:
             return self._instance_data
         return self._instance_data.get(key)
 
+    def instance_tags(self) -> dict[str, str]:
+        """The organisation and department tags every point of this instance carries."""
+        tags: dict[str, str] = {}
+        for key in ("organisation", "department"):
+            value = cast(object, self._instance_data.get(key))  # pyright: ignore[reportUnknownMemberType]
+            if value:
+                tags[key] = str(value)
+        return tags
+
     def get_instance_id(self) -> str:
         """Convenience accessor for 'instance_id' in equipment."""
         return self._instance_data.get("instance_id", "")
@@ -108,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:
@@ -120,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):
@@ -131,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:
     """
@@ -147,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.0 → 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.0 → leaf_framework-0.12.0}/leaf/registry/discovery.py

@@ -16,8 +16,7 @@ from leaf.utility.logger.logger_utils import get_logger
 root_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..")
 adapter_dir = os.path.join(root_dir, "adapters")
 core_adapter_dir = os.path.join(adapter_dir, "core_adapters")
-functional_adapter_dir = os.path.join(adapter_dir, "functional_adapters")
-default_equipment_locations = [core_adapter_dir, functional_adapter_dir]
+default_equipment_locations = [core_adapter_dir]
 
 output_module_dir = os.path.join(root_dir, "modules", "output_modules")
 input_module_dir = os.path.join(root_dir, "modules", "input_modules")

{leaf_framework-0.11.0 → leaf_framework-0.12.0}/leaf/registry/registry.py

@@ -56,13 +56,6 @@ def get_external_input(code: str) -> type[ExternalEventWatcher]:
     return cls
 
 
-def all_registered(plugin_type: PluginType) -> dict[str, type[Any]]:
-    """
-    Return all registered classes of a given plugin type.
-    """
-    return dict(_registry[plugin_type])
-
-
 def discover_from_config(config: dict[str, Any], external_path: str = None) -> None:
     """
     Discover and register only the plugins referenced in the given configuration.

{leaf_framework-0.11.0 → leaf_framework-0.12.0}/leaf/start.py

@@ -111,7 +111,7 @@ def parse_args(args: list[str] | None = None) -> argparse.Namespace:
         "--port",
         type=int,
         default=4242,
-        help="Port to run the NiceGUI interface on. Default is 8080.",
+        help="Port to run the NiceGUI interface on. Default is 4242.",
     )
 
     parser.add_argument(