leaf-framework 0.10.22__tar.gz → 0.10.25__tar.gz

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-framework
-Version: 0.10.22
+Version: 0.10.25
 Summary: Lightweight Adapter Framework (LEAF)
 License: Apache-2.0
 License-File: LICENSE
@@ -13,17 +13,17 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: aioredis (>=2.0.1,<2.1.0)
-Requires-Dist: cairosvg (>=2.8.2,<3.0.0)
-Requires-Dist: dateparser (>=1.3.0,<1.4.0)
+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: influxobject (>=0.0.13)
-Requires-Dist: nicegui (>=3.16.0,<3.17.0)
+Requires-Dist: nicegui (>=3.18.0,<3.19.0)
 Requires-Dist: paho-mqtt (>=2.1.0,<2.2.0)
-Requires-Dist: pillow (>=12.1.1,<13.0.0)
+Requires-Dist: pillow (>=13.0.0,<14.0.0)
 Requires-Dist: pyyaml (>=6.0.3,<6.1.0)
-Requires-Dist: redis (>=7.2.0,<7.3.0)
+Requires-Dist: redis (>=8.1.0,<8.2.0)
 Requires-Dist: requests (>=2.34.2,<2.35.0)
-Requires-Dist: watchdog (>=6.0.0,<6.1.0)
+Requires-Dist: watchdog (>=7.0.0,<7.1.0)
 Project-URL: Documentation, https://leaf-framework.org
 Project-URL: Repository, https://gitlab.com/leaf-framework/leaf
 Description-Content-Type: text/markdown
@@ -44,6 +44,10 @@ leaf
 
 LEAF automatically shows a **desktop control panel** on desktop systems, making it easy to see if the application is running and where to access it.
 
+## Password for the web interface
+
+The web interface is open by default. When it runs where others can reach it (a Kubernetes pod with an ingress, a shared server), set `LEAF_UI_PASSWORD`: every page then asks for that password once, on a login form password managers can fill, and keeps the browser logged in for 30 days. Changing the password logs every browser out. It sends the password over the wire, so serve the interface over HTTPS.
+
 ## Updating
 
 LEAF checks PyPI for a newer release one hour after it starts, and weekly from then on -- never at startup, so a restart simply re-arms the one-hour delay. When a newer version exists, an **update badge** appears next to the version number in the web interface header; clicking it offers to install the update and restart LEAF.

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/README.md

@@ -14,6 +14,10 @@ leaf
 
 LEAF automatically shows a **desktop control panel** on desktop systems, making it easy to see if the application is running and where to access it.
 
+## Password for the web interface
+
+The web interface is open by default. When it runs where others can reach it (a Kubernetes pod with an ingress, a shared server), set `LEAF_UI_PASSWORD`: every page then asks for that password once, on a login form password managers can fill, and keeps the browser logged in for 30 days. Changing the password logs every browser out. It sends the password over the wire, so serve the interface over HTTPS.
+
 ## Updating
 
 LEAF checks PyPI for a newer release one hour after it starts, and weekly from then on -- never at startup, so a restart simply re-arms the one-hour delay. When a newer version exists, an **update badge** appears next to the version number in the web interface header; clicking it offers to install the update and restart LEAF.

leaf_framework-0.10.25/leaf/adapters/control_spec.py

@@ -0,0 +1,124 @@
+"""
+The controls an adapter declares in its device.json, narrowed by an instance's control_limits.
+
+Every control message, from MQTT or the UI, is checked against them before the controller sees it,
+so the limits hold however the message arrives. An adapter that declares no controls is not checked.
+"""
+
+import json
+import os
+from typing import cast
+
+import yaml
+
+Control = dict[str, object]
+
+
+def read_controls(adapter_dir: str) -> list[Control]:
+    """The "controls" list from device.json (or device.yaml) in an adapter's package, or []."""
+    for name in ("device.json", "device.yaml"):
+        path = os.path.join(adapter_dir, name)
+        if not os.path.exists(path):
+            continue
+        with open(path) as f:
+            if name.endswith(".json"):
+                device = cast(object, json.load(f))
+            else:
+                device = cast(object, yaml.safe_load(f))
+        if not isinstance(device, dict):
+            return []
+        controls = cast(dict[str, object], device).get("controls")
+        if not isinstance(controls, list):
+            return []
+        return [cast(Control, c) for c in cast(list[object], controls) if isinstance(c, dict)]
+    return []
+
+
+def as_number(value: object) -> float | None:
+    """value as a float, or None when it is not a number (bools are not numbers here)."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    return float(value)
+
+
+def _narrow(control: Control, limit: object) -> Control:
+    """The control with the instance's min/max, which may only tighten the adapter's own range."""
+    metric = control["metric"]
+    if control.get("type") != "number" or not isinstance(limit, dict):
+        raise ValueError(f"control_limits for {metric} need a number control and min/max keys")
+    narrowed = dict(control)
+    for key, value in cast(dict[str, object], limit).items():
+        bound = as_number(value)
+        if key not in ("min", "max") or bound is None:
+            raise ValueError(f"control_limits for {metric}: {key} must be min or max with a number")
+        adapter_bound = as_number(control.get(key))
+        if adapter_bound is not None and (
+            (key == "min" and bound < adapter_bound) or (key == "max" and bound > adapter_bound)
+        ):
+            raise ValueError(
+                f"control_limits for {metric}: {key} {bound} is outside the adapter's {key} {adapter_bound}"
+            )
+        narrowed[key] = bound
+    return narrowed
+
+
+def apply_limits(controls: list[Control], limits: dict[str, object]) -> list[Control]:
+    """Controls with an instance's control_limits applied; ValueError for limits that do not fit."""
+    known = {str(c.get("metric")) for c in controls}
+    unknown = sorted(set(limits) - known)
+    if unknown:
+        raise ValueError(f"control_limits for undeclared controls: {', '.join(unknown)}")
+    result: list[Control] = []
+    for control in controls:
+        metric = str(control.get("metric"))
+        if metric in limits:
+            result.append(_narrow(control, limits[metric]))
+        else:
+            result.append(control)
+    return result
+
+
+def _check_number(control: Control, value: object) -> None:
+    number = as_number(value)
+    if number is None:
+        raise ValueError(f"{control['metric']} needs a number, got {value!r}")
+    low = as_number(control.get("min"))
+    high = as_number(control.get("max"))
+    if low is not None and number < low:
+        raise ValueError(f"{control['metric']} = {number} is below its minimum {low}")
+    if high is not None and number > high:
+        raise ValueError(f"{control['metric']} = {number} is above its maximum {high}")
+
+
+def _metric_and_value(data: str) -> tuple[object, object]:
+    """tags.metric and fields.value of a LeafPoint control message."""
+    point = cast(object, json.loads(data))
+    if not isinstance(point, dict):
+        raise ValueError("a control message must be a LeafPoint JSON object")
+    point_dict = cast(dict[str, object], point)
+    tags = point_dict.get("tags")
+    fields = point_dict.get("fields")
+    if not isinstance(tags, dict) or not isinstance(fields, dict):
+        raise ValueError("a control message needs tags and fields")
+    return cast(dict[str, object], tags).get("metric"), cast(dict[str, object], fields).get("value")
+
+
+def check_control(controls: list[Control], data: str) -> None:
+    """Raise ValueError unless the LeafPoint in data sets a declared metric to an allowed value."""
+    if not controls:
+        return
+    metric, value = _metric_and_value(data)
+    control = next((c for c in controls if c.get("metric") == metric), None)
+    if control is None:
+        raise ValueError(f"{metric!r} is not a declared control")
+    if value is not None and value == control.get("reset"):
+        return
+    kind = control.get("type")
+    if kind == "number":
+        _check_number(control, value)
+    elif kind == "choice":
+        options = control.get("options")
+        if not isinstance(options, list) or value not in cast(list[object], options):
+            raise ValueError(f"{metric} cannot be set to {value!r}")
+    elif not isinstance(value, str) or not value:
+        raise ValueError(f"{metric} needs a text value")

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/leaf/adapters/equipment_adapter.py

@@ -4,6 +4,7 @@ from abc import ABC, abstractmethod
 from threading import Event
 from typing import Any
 
+from leaf.adapters.control_spec import Control, check_control
 from leaf.error_handler import exceptions
 from leaf.error_handler.error_holder import ErrorHolder
 from leaf.error_handler.exceptions import LEAFError
@@ -119,6 +120,29 @@ class AbstractInterpreter(ABC):
             raise exception
 
 
+class AbstractController(ABC):
+    """
+    Base class for an adapter's controller.py.
+
+    When an instance is configured with ``control: true``, LEAF subscribes to
+    <root>/<organisation>/<department>/<adapter_id>/<instance_id>/control and
+    hands every message to control(). ``self.adapter`` is the running adapter.
+    """
+
+    def __init__(self) -> None:
+        self.adapter: EquipmentAdapter | None = None
+
+    @abstractmethod
+    def control(self, topic: str, data: str) -> None:
+        """
+        Act on a control message.
+
+        Args:
+            topic (str): The control topic the message arrived on.
+            data (str): Raw message payload.
+        """
+
+
 class EquipmentAdapter(ABC):
     """
     Base class for all equipment adapters.
@@ -201,6 +225,69 @@ class EquipmentAdapter(ABC):
             self._external_process.set_interpreter(interpreter)
             self._external_watcher.add_callback(self._external_process.process_input)
 
+        self._controller: AbstractController | None = None
+        self._controls: list[Control] = []
+
+    def set_controller(self, controller: AbstractController, controls: list[Control] | None = None) -> None:
+        """
+        Attach a controller; its control() runs for each message on the instance's control topic.
+
+        Messages are first checked against controls (from device.json, with the instance's limits).
+        """
+        controller.adapter = self
+        self._controller = controller
+        self._controls = controls or []
+
+    @property
+    def controls(self) -> list[Control]:
+        """The declared controls with this instance's limits, as used to check control messages."""
+        return self._controls
+
+    def _on_control(self, topic: str, data: str) -> None:
+        # Runs on the MQTT network thread, so never let an exception escape.
+        if self._controller is None:
+            return
+        try:
+            self._logger.info(f"Control message on {topic}: {data}")
+            check_control(self._controls, data)
+            self._controller.control(topic, data)
+        except Exception as e:
+            # The error holder reports it later; log it now so the sender can see why nothing happened
+            self._logger.warning(f"Control message on {topic} rejected: {e}")
+            self._handle_exception(exceptions.AdapterLogicError(f"Controller failed: {e}"))
+
+    def has_controller(self) -> bool:
+        """True when the instance runs with control: true and a controller is attached."""
+        return self._controller is not None
+
+    @property
+    def metadata_manager(self) -> MetadataManager:
+        """Instance and equipment metadata, e.g. to tag control points sent from the UI."""
+        return self._metadata_manager
+
+    def send_control(self, data: str) -> None:
+        """
+        Hand a control message from inside LEAF (the UI) to the controller, as if it came in on the control topic.
+
+        Errors are reported like those of messages from MQTT, and also propagate so the caller can show them.
+        """
+        if self._controller is None:
+            raise exceptions.AdapterLogicError("this instance has no controller; set control: true")
+        # Topic builders are generated at runtime, so the checker sees them as Any
+        topic = str(self._metadata_manager.control())  # pyright: ignore[reportAny]
+        self._logger.info(f"Control message from the UI on {topic}: {data}")
+        try:
+            check_control(self._controls, data)
+            self._controller.control(topic, data)
+        except Exception as e:
+            # Reported like a control message from MQTT, so it also reaches the error topic
+            self._handle_exception(exceptions.AdapterLogicError(f"Controller failed: {e}"))
+            raise
+
+    def _subscribe_control(self) -> None:
+        if self._controller is not None:
+            self._output.subscribe(self._metadata_manager.control(), self._on_control)
+
     def is_running(self) -> bool:
         """
         Check if the adapter is actively running.
@@ -233,6 +320,7 @@ class EquipmentAdapter(ABC):
             if self._external_watcher:
                 self._external_watcher.start()
             self._output.on_adapter_ready(self._metadata_manager)
+            self._subscribe_control()
 
             self._stop_event.clear()
             # Expose adapter on all channels.
@@ -316,6 +404,8 @@ class EquipmentAdapter(ABC):
         """
         self._stop_event.set()
         self._output.on_adapter_stop(self._metadata_manager)
+        if self._controller is not None:
+            self._output.unsubscribe(self._metadata_manager.control())
         if self._watcher.is_running():
             self._watcher.stop()
 
@@ -348,7 +438,8 @@ class EquipmentAdapter(ABC):
                 return self.stop()
 
             error_json = error.to_json()
-            for process in self._processes:
+            # Every process publishes to the instance's one error topic, so one of them is enough
+            for process in self._processes[:1]:
                 process.transmit_error(error_json)
                 time.sleep(0.1)
 

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/leaf/modules/input_modules/http_watcher.py

@@ -41,19 +41,22 @@ class URLState:
         Returns:
             Optional[dict]: Parsed JSON if the response is new; else None.
         """
-        if response.headers.get("ETag") == self.etag:
+        etag = response.headers.get("ETag")
+        last_modified = response.headers.get("Last-Modified")
+        # Only a header the server sent can say "unchanged"; two missing ones are not a match
+        if etag is not None and etag == self.etag:
             return None
-        if response.headers.get("Last-Modified") == self.last_modified:
+        if last_modified is not None and last_modified == self.last_modified:
             return None
 
         current_data = response.json()
 
-        if self.etag is None and self.last_modified is None:
+        if etag is None and last_modified is None:
             if current_data == self.previous_data:
                 return None
 
-        self.etag = response.headers.get("ETag")
-        self.last_modified = response.headers.get("Last-Modified")
+        self.etag = etag
+        self.last_modified = last_modified
         self.previous_data = current_data
 
         return current_data

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/leaf/modules/output_modules/keydb.py

@@ -2,7 +2,6 @@ import json
 from typing import Any
 
 import redis
-from redis.typing import ResponseT
 
 from leaf.error_handler.error_holder import ErrorHolder
 from leaf.error_handler.exceptions import ClientUnreachableError, SeverityLevel
@@ -153,7 +152,9 @@ class KEYDB(OutputModule):
         if topics:
             logger.info(f"Found existing keys in KeyDB: {topics}")
             for topic in topics:
-                topic = topic.decode("utf-8")
+                # Keys are bytes unless the client decodes responses
+                if isinstance(topic, bytes):
+                    topic = topic.decode("utf-8")
                 self.pop(topic)
         else:
             logger.debug("No existing keys found in KeyDB.")
@@ -203,13 +204,14 @@ class KEYDB(OutputModule):
                     return key, json.loads(result.decode("utf-8"))
                 return None
 
-            random_key: ResponseT = self._client.randomkey()
-            if not random_key:
+            raw_key = self._client.randomkey()
+            if not raw_key:
                 logger.info("No keys available in KeyDB.")
                 return None
-            if isinstance(random_key, bytes):
+            random_key = str(raw_key)
+            if isinstance(raw_key, bytes):
                 # Decode bytes to string if necessary
-                random_key = random_key.decode("utf-8")
+                random_key = raw_key.decode("utf-8")
 
             logger.info(f"Popping from key '{random_key}' in KeyDB.")
             result = self._client.lpop(random_key)

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/leaf/modules/output_modules/mqtt.py

@@ -2,8 +2,9 @@ import json
 import re
 import threading
 import time
+from collections.abc import Callable
 from socket import gaierror
-from typing import Any, Literal
+from typing import Any, Literal, cast
 
 import paho.mqtt.client as mqtt
 from paho.mqtt.enums import CallbackAPIVersion
@@ -102,6 +103,8 @@ class MQTT(OutputModule):
         self.messages: dict[str, list[str]] = {}
         self.sending_success: dict[str, bool] = {}
         self._sanitized_topic_warned: set[str] = set()
+        # Topics with a callback; kept so they are resubscribed after a reconnect (clean session).
+        self._subscriptions: dict[str, Callable[[str, str], None]] = {}
         # paho's connect() returns once the socket is open and the CONNECT
         # packet is sent, but the broker's CONNACK (which is what actually
         # flips is_connected() to True) is only processed once loop_start()'s
@@ -257,6 +260,8 @@ class MQTT(OutputModule):
                 return self.fallback(topic, data)
         if data == "":
             data = {}
+        # The topic store keeps the dict, which the Monitoring plot reads points from
+        message = cast(object, data)
         if isinstance(data, (dict, list)):
             data = json.dumps(data)
 
@@ -299,7 +304,7 @@ class MQTT(OutputModule):
         # Reset global failure counter only after successful transmission AND fallback processing
         OutputModule.reset_failure_count()
 
-        self.store_latest(topic, data)
+        self.store_latest(topic, message)
 
         # Transmit to parallel outputs (best-effort, failures don't affect primary result)
         self.transmit_to_parallels(topic, data)
@@ -365,6 +370,8 @@ class MQTT(OutputModule):
             self._handle_exception(ClientUnreachableError(f"Connection refused: {message}", output_module=self))
             return
 
+        for topic in list(self._subscriptions):
+            self.client.subscribe(topic)
         self._connected_event.set()
 
     def on_connect_fail(
@@ -453,6 +460,9 @@ class MQTT(OutputModule):
         if topic not in self.messages:
             self.messages[topic] = []
         self.messages[topic].append(payload)
+        callback = self._subscriptions.get(topic)
+        if callback is not None:
+            callback(topic, payload)
 
     def reset_messages(self) -> None:
         """
@@ -460,17 +470,20 @@ class MQTT(OutputModule):
         """
         self.messages = {}
 
-    def subscribe(self, topic: str) -> str:
+    def subscribe(self, topic: str, callback: Callable[[str, str], None] | None = None) -> str:
         """
         Subscribe to a topic on the MQTT broker.
 
         Args:
             topic (str): The topic to subscribe to.
+            callback (Optional[Callable]): Called with (topic, payload) for each message on this exact topic.
 
         Returns:
             str: The subscribed topic.
         """
         logger.info(f"Subscribing to {topic}")
+        if callback is not None:
+            self._subscriptions[topic] = callback
         self.client.subscribe(topic)
         return topic
 
@@ -485,6 +498,7 @@ class MQTT(OutputModule):
             str: The unsubscribed topic.
         """
         logger.info(f"Unsubscribing from {topic}")
+        self._subscriptions.pop(topic, None)
         self.client.unsubscribe(topic)
         return topic
 

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/leaf/modules/output_modules/output_module.py

@@ -1,5 +1,6 @@
 import time
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from typing import Any, Optional
 
 from leaf.error_handler.error_holder import ErrorHolder
@@ -119,15 +120,27 @@ class OutputModule(ABC):
         if self._fallback is not None:
             self._fallback.flush(topic)
 
-    def subscribe(self, topic: str) -> None:
+    def subscribe(self, topic: str, callback: Callable[[str, str], None] | None = None) -> None:
         """
         Listen on the specified topic if supported by the module.
 
         Args:
             topic (str): Topic to subscribe to.
+            callback (Optional[Callable]): Called with (topic, payload) for each message, if supported.
         """
         if self._fallback is not None:
-            self._fallback.subscribe(topic)
+            self._fallback.subscribe(topic, callback)
+
+    def unsubscribe(self, topic: str) -> str | None:
+        """
+        Stop listening on the specified topic if supported by the module.
+
+        Args:
+            topic (str): Topic to unsubscribe from.
+        """
+        if self._fallback is not None:
+            return self._fallback.unsubscribe(topic)
+        return None
 
     def fallback(self, topic: str, data: str | dict[Any, Any] | None = None) -> bool:
         """

leaf_framework-0.10.25/leaf/modules/output_modules/topic_store.py

@@ -0,0 +1,114 @@
+import threading
+import time
+from collections import deque
+from typing import Any, cast
+
+# Points kept per topic (one metric each) for the Monitoring plot; in memory, so it starts empty after a restart
+HISTORY_LENGTH = 1000
+
+
+class TopicStore:
+    """
+    A lightweight nested-dict wrapper that stores the latest message
+    per hierarchical topic. Topics are split on '/' and stored at
+    the leaf node using a '_value' sentinel key.
+
+    Example:
+        store.set("unlock/proj1/dev1/temp", {"value": 23.5})
+        # Internal: {"unlock": {"proj1": {"dev1": {"temp": {"_value": {"value": 23.5}}}}}}
+    """
+
+    def __init__(self) -> None:
+        self._store: dict = {}
+        self._history: dict[str, deque[tuple[float, float]]] = {}
+        # Adapters write from their own threads while the UI reads
+        self._history_lock: threading.Lock = threading.Lock()
+
+    def set(self, topic: str, message: Any) -> None:
+        """Split topic by '/' and store message at the deepest level."""
+        parts = [p for p in topic.split("/") if p]
+        node = self._store
+        for part in parts:
+            if part not in node or not isinstance(node[part], dict):
+                node[part] = {}
+            node = node[part]
+        node["_value"] = message
+        payload = cast(object, message)
+        self._record_history(topic, payload)
+
+    def _record_history(self, topic: str, message: object) -> None:
+        """Keep the numeric "value" field of point messages (a point dict or a list of them)."""
+        if isinstance(message, list):
+            points = cast(list[object], message)
+        else:
+            points = [message]
+        for point in points:
+            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.append(sample)
+
+    def get_history(self) -> dict[str, list[tuple[float, float]]]:
+        """(timestamp, value) pairs per history key (see history_key), oldest first."""
+        with self._history_lock:
+            return {topic: list(points) for topic, points in self._history.items()}
+
+    def get(self, topic: str) -> Any:
+        """Retrieve the latest message for a topic, or None."""
+        parts = [p for p in topic.split("/") if p]
+        node = self._store
+        for part in parts:
+            if not isinstance(node, dict) or part not in node:
+                return None
+            node = node[part]
+        if isinstance(node, dict):
+            return node.get("_value")
+        return None
+
+    def get_subtree(self, topic: str) -> dict | None:
+        """Get the full nested dict under a topic prefix."""
+        parts = [p for p in topic.split("/") if p]
+        node = self._store
+        for part in parts:
+            if not isinstance(node, dict) or part not in node:
+                return None
+            node = node[part]
+        return node if isinstance(node, dict) else None
+
+    def get_all(self) -> dict:
+        """Return the full nested store."""
+        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/InfluxPoint JSON dict with a numeric fields.value, or None."""
+    if not isinstance(point, dict):
+        return None
+    point_dict = cast(dict[str, object], point)
+    fields = point_dict.get("fields")
+    if not isinstance(fields, dict):
+        return None
+    value = cast(dict[str, object], fields).get("value")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    timestamp = point_dict.get("timestamp")
+    if isinstance(timestamp, bool) or not isinstance(timestamp, (int, float)):
+        timestamp = time.time()
+    return (float(timestamp), float(value))

{leaf_framework-0.10.22 → leaf_framework-0.10.25}/leaf/modules/phase_modules/measure.py

@@ -1,9 +1,7 @@
 import inspect
 import threading
 import time
-from typing import TYPE_CHECKING, Any
-
-from influxobject import InfluxPoint
+from typing import TYPE_CHECKING, Any, cast
 
 from leaf.error_handler.error_holder import ErrorHolder
 from leaf.error_handler.exceptions import AdapterLogicError, InterpreterError
@@ -237,17 +235,20 @@ class MeasurePhase(PhaseModule):
             action = self._term_builder(experiment_id=experiment_id, measurement=measurement)
             return [(action, result)]
 
-        if isinstance(result, InfluxPoint):
-            result = result.to_json()
+        payload = cast(object, result)
+        point_json = point_json_of(payload)
+        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)]
 
         if isinstance(result, list):
             converted = []
-            for item in result:
-                if isinstance(item, InfluxPoint):
-                    converted.append(item.to_json())
+            for item in cast(list[object], result):
+                point_json = point_json_of(item)
+                if point_json is not None:
+                    converted.append(point_json)
                 else:
                     converted.append(item)
 
@@ -287,3 +288,13 @@ class MeasurePhase(PhaseModule):
             return item["measurement"]
 
         return "unknown"
+
+
+def point_json_of(item: object) -> dict[str, object] | None:
+    """JSON of an InfluxPoint or leafobject LeafPoint, recognised by to_json() so LEAF need not depend on leafobject."""
+    if isinstance(item, dict):
+        return None
+    to_json: object = getattr(item, "to_json", None)
+    if not callable(to_json):
+        return None
+    return cast(dict[str, object], to_json())