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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-framework
-Version: 0.10.25
+Version: 0.11.0
 Summary: Lightweight Adapter Framework (LEAF)
 License: Apache-2.0
 License-File: LICENSE
@@ -12,16 +12,14 @@ Classifier: Programming Language :: Python :: 3
 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.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: leafobject (>=0.0.14,<0.0.15)
 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)
 Requires-Dist: pyyaml (>=6.0.3,<6.1.0)
-Requires-Dist: redis (>=8.1.0,<8.2.0)
 Requires-Dist: requests (>=2.34.2,<2.35.0)
 Requires-Dist: watchdog (>=7.0.0,<7.1.0)
 Project-URL: Documentation, https://leaf-framework.org
@@ -54,7 +52,7 @@ LEAF checks PyPI for a newer release one hour after it starts, and weekly from t
 
 To check without waiting for the schedule, **click the version number** in the header. The result appears as a banner: green when this install is current, amber when a newer release exists, red when PyPI could not be reached.
 
-Set `LEAF_DISABLE_UPDATE_CHECK=1` to switch the check off entirely. Installs running from a source checkout are told about the new version but never overwritten -- update those with `git pull`. To update by hand:
+Set `LEAF_DISABLE_UPDATE_CHECK=1` to switch the check off entirely. Set `LEAF_DISABLE_ADAPTER_INSTALL=1` to stop the web interface from installing or uninstalling adapters, e.g. on a shared deployment whose adapters come from its image. Installs running from a source checkout are told about the new version but never overwritten -- update those with `git pull`. To update by hand:
 
 ```bash
 pip install --upgrade leaf-framework

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

@@ -24,7 +24,7 @@ LEAF checks PyPI for a newer release one hour after it starts, and weekly from t
 
 To check without waiting for the schedule, **click the version number** in the header. The result appears as a banner: green when this install is current, amber when a newer release exists, red when PyPI could not be reached.
 
-Set `LEAF_DISABLE_UPDATE_CHECK=1` to switch the check off entirely. Installs running from a source checkout are told about the new version but never overwritten -- update those with `git pull`. To update by hand:
+Set `LEAF_DISABLE_UPDATE_CHECK=1` to switch the check off entirely. Set `LEAF_DISABLE_ADAPTER_INSTALL=1` to stop the web interface from installing or uninstalling adapters, e.g. on a shared deployment whose adapters come from its image. Installs running from a source checkout are told about the new version but never overwritten -- update those with `git pull`. To update by hand:
 
 ```bash
 pip install --upgrade leaf-framework

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/adapters/control_spec.py

@@ -10,6 +10,7 @@ import os
 from typing import cast
 
 import yaml
+from leafobject import LeafPoint  # pyright: ignore[reportMissingTypeStubs]
 
 Control = dict[str, object]
 
@@ -122,3 +123,54 @@ def check_control(controls: list[Control], data: str) -> None:
             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")
+
+
+def _part(point: dict[str, object], key: str) -> dict[str, object]:
+    """A copy of point[key] when it is a dict, else an empty dict."""
+    part = point.get(key)
+    if isinstance(part, dict):
+        return dict(cast(dict[str, object], part))
+    return {}
+
+
+def _field_value(value: object) -> int | float | str:
+    """value as a LeafPoint field allows it: a number or text, anything else as its JSON."""
+    if isinstance(value, (int, float, str)):
+        return value
+    return json.dumps(value)
+
+
+def result_record(data: str, source: str, error: Exception | 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.
+
+    source ("ui" or "mqtt"), status ("applied" or "rejected") and a rejection's "error" are tags,
+    for consumers to filter on. Built as a leafobject LeafPoint, so tags are text and there is
+    always a field: a message without fields keeps its raw text in "message".
+    """
+    point: dict[str, object] = {}
+    try:
+        parsed = cast(object, json.loads(data))
+        if isinstance(parsed, dict):
+            point = cast(dict[str, object], parsed)
+    except ValueError:
+        pass
+    tags: dict[str, str] = {}
+    for key, value in _part(point, "tags").items():
+        tags[key] = str(value)
+    fields: dict[str, int | float | str] = {}
+    for key, value in _part(point, "fields").items():
+        fields[key] = _field_value(value)
+    tags["source"] = source
+    tags["status"] = "applied"
+    if error is not None:
+        tags["status"] = "rejected"
+        tags["error"] = str(error)
+    if not fields:
+        fields["message"] = data
+    record = LeafPoint()
+    record.set_measurement(str(point.get("measurement", "control")))
+    record.set_tags(tags)
+    record.set_fields(fields)
+    return {**record.to_json()}

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

@@ -4,7 +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.adapters.control_spec import Control, check_control, result_record
 from leaf.error_handler import exceptions
 from leaf.error_handler.error_holder import ErrorHolder
 from leaf.error_handler.exceptions import LEAFError
@@ -254,7 +254,10 @@ class EquipmentAdapter(ABC):
         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._report_control(topic, data, "mqtt", e)
             self._handle_exception(exceptions.AdapterLogicError(f"Controller failed: {e}"))
+            return
+        self._report_control(topic, data, "mqtt")
 
     def has_controller(self) -> bool:
         """True when the instance runs with control: true and a controller is attached."""
@@ -281,8 +284,18 @@ class EquipmentAdapter(ABC):
             self._controller.control(topic, data)
         except Exception as e:
             # Reported like a control message from MQTT, so it also reaches the error topic
+            self._report_control(topic, data, "ui", e)
             self._handle_exception(exceptions.AdapterLogicError(f"Controller failed: {e}"))
             raise
+        self._report_control(topic, data, "ui")
+
+    def _report_control(self, topic: str, data: str, source: str, error: Exception | None = None) -> None:
+        """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))
+        except Exception as e:
+            self._logger.warning(f"Could not publish the control record for {topic}: {e}")
 
     def _subscribe_control(self) -> None:
         if self._controller is not None:

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/config/configuration.yaml

@@ -26,24 +26,16 @@ OUTPUTS:
 #   protocol: v3   #OPTIONAL expects "v3" "v5"
 #   transport: tcp #OPTIONAL expects "tcp", "websockets", "unix"
 #   tls: False     #OPTIONAL expects True, False
-#   fallback: SQL  #OPTIONAL expects "SQL", "KEYDB", "FILE"
+#   fallback: FILE #OPTIONAL expects "SQL", "FILE"
 
 # SQL output requires 'filename' of database 
 # and optionally an alternative 'fallback' output
 #  - plugin: SQL
 #    filename: messages.db
-#    fallback: KEYDB #OPTIONAL expects "MQTT", "KEYDB", "FILE"
-
-# KEYDB output requires 'host', 'port', 'db'
-# and optionally an alternative 'fallback' output
-#  - plugin: KEYDB
-#    host: localhost
-#    port: 6379
-#    db: 0
-#    fallback: FILE #OPTIONAL expects "MQTT", "SQL", "FILE"
+#    fallback: FILE #OPTIONAL expects "MQTT", "FILE"
 
 # FILE output requires 'filename'
 # and optionally an alternative 'fallback' output
 #  - plugin: FILE
 #    filename: local.json
-#    fallback: FILE #OPTIONAL expects "MQTT", "SQL", "KEYDB"
+#    fallback: SQL #OPTIONAL expects "MQTT", "SQL"

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/data/marketplace.yaml

@@ -3,7 +3,7 @@
 
 - adapter_id: Table
   image: "./images/table.png"
-  description: "File conversion module to parse tabular data from various file formats into InfluxObject messages."
+  description: "File conversion module to parse tabular data from various file formats into LeafPoint messages."
   equipment_data:
     version: "1.0"
     manufacturer: LEAF
@@ -233,6 +233,10 @@
     application: Monitoring
   # requirements:
   repo_url: https://git.wur.nl/leaf/adapters/leaf-ramsmart.git
+  # Private repository: installed with a username and token handed out per user. One deploy
+  # token (read_repository, with an expiry) per person, named after them; lost → revoke and reissue.
+  access: restricted
+  request_access: mailto:access@leaf-framework.org?subject=Access%20to%20LEAF-RAMSMART
   name: LEAF-RAMSMART
 - adapter_id: BluetoothScanner
   image: icon:bi-bluetooth

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

@@ -527,7 +527,7 @@ class MQTT(OutputModule):
         Retrieve and remove a stored message from the fallback.
 
         MQTT does not buffer messages locally, so this delegates to the fallback
-        module (e.g., KeyDB or FILE) to retrieve buffered messages.
+        module (e.g., SQL or FILE) to retrieve buffered messages.
 
         Args:
             key (Optional[str]): A key for which to pop data. Defaults to None.

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/modules/output_modules/topic_store.py

@@ -98,7 +98,7 @@ def history_key(topic: str, point: object) -> str:
 
 
 def _point_sample(point: object) -> tuple[float, float] | None:
-    """(timestamp, value) of a LeafPoint/InfluxPoint JSON dict with a numeric fields.value, or None."""
+    """(timestamp, value) of a LeafPoint JSON dict with a numeric fields.value, or None."""
     if not isinstance(point, dict):
         return None
     point_dict = cast(dict[str, object], point)

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

@@ -291,7 +291,7 @@ class MeasurePhase(PhaseModule):
 
 
 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."""
+    """JSON of a leafobject LeafPoint (or anything else with to_json()), else None."""
     if isinstance(item, dict):
         return None
     to_json: object = getattr(item, "to_json", None)

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/register/equipment_actions.yaml

@@ -3,6 +3,7 @@ running: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/running
 heartbeat: <root>/<organisation>/<department>/<adapter_id>/<instance_id>/heartbeat
 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

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/ui/markdown/configuration_help.md

@@ -15,10 +15,12 @@ EQUIPMENT_INSTANCES:
 Configure data destinations:
 ```yaml
 OUTPUTS:
-  - plugin: KEYDB
-    host: localhost
-    port: 6379
+  - plugin: MQTT
+    broker: localhost
+    port: 1883
     fallback: FILE
+  - plugin: FILE
+    filename: fallback.json
 ```
 
 #### Available Adapters

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/ui/markdown/documentation_main.md

@@ -41,13 +41,10 @@ OUTPUTS:
   - plugin: MQTT
     broker: localhost
     port: 1883
-    fallback: KEYDB
-
-  - plugin: KEYDB
-    host: localhost
-    port: 6379
-    db: 0
     fallback: FILE
+
+  - plugin: FILE
+    filename: fallback.json
 ```
 
 ###### Available Adapters

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/ui/tabs/adapters.py

@@ -1,5 +1,6 @@
 """LEAF Adapters tab."""
 
+from collections.abc import Mapping
 from pathlib import Path
 
 import httpx
@@ -8,7 +9,7 @@ from nicegui import ui
 
 from leaf.registry.discovery import get_all_adapter_codes
 from leaf.ui.constants import CARD_CLASSES, CARD_WIDTH_CLASS, MARKETPLACE_URL
-from leaf.ui.utils import install_adapter, uninstall_adapter
+from leaf.ui.utils import adapter_install_disabled, install_adapter, uninstall_adapter
 from leaf.utility.logger.logger_utils import get_logger
 
 logger = get_logger(__name__, log_file="input_module.log")
@@ -160,6 +161,59 @@ def load_bundled_marketplace() -> list | None:
     return None
 
 
+# install_adapter/uninstall_adapter refuse too; these only leave out buttons that would not work
+def _install_button(adapter: Mapping[str, object]) -> None:
+    """The marketplace card's Install button, unless adapter installs are disabled."""
+    if adapter_install_disabled():
+        return
+    if adapter.get("access") == "restricted":
+        _ = ui.button("Install with token", icon="lock", on_click=lambda: _token_dialog(adapter)).classes(
+            "btn-secondary w-full rounded-lg transition-colors"
+        )
+        return
+    _ = ui.button("Install", icon="download", on_click=lambda: install_adapter(dict(adapter))).classes(
+        "btn-secondary w-full rounded-lg transition-colors"
+    )
+
+
+def _token_dialog(adapter: Mapping[str, object]) -> None:
+    """Asks for the access token of a restricted adapter, which is only installable with one."""
+    name = str(adapter.get("name") or adapter.get("adapter_id"))
+    with ui.dialog() as dialog, ui.card().classes("w-96"):
+        _ = ui.label(f"{name} is available on request").classes("text-h6")
+        _ = ui.label("Enter the username and token you received, e.g. a GitLab deploy token.").classes("text-body")
+        username = ui.input("Username")
+        token = ui.input("Token", password=True, password_toggle_button=True)
+        request = adapter.get("request_access")
+        if request:
+            _ = ui.link("Request access", str(request), new_tab=True)
+
+        async def install() -> None:
+            _ = dialog.close()
+            await install_adapter(dict(adapter), (str(username.value), str(token.value)))
+
+        with ui.row().classes("w-full justify-end"):
+            _ = ui.button("Cancel", on_click=dialog.close).classes("btn-tertiary")
+            _ = ui.button("Install", icon="download", on_click=install).classes("btn-secondary")
+    _ = dialog.open()
+
+
+def _uninstall_button(adapter: Mapping[str, object]) -> None:
+    """The installed adapter card's Uninstall button, unless adapter installs are disabled."""
+    if adapter_install_disabled():
+        return
+    _ = ui.button("Uninstall", icon="delete", on_click=lambda: uninstall_adapter(dict(adapter))).classes(
+        "btn-tertiary w-full rounded-lg transition-colors"
+    )
+
+
+def _install_disabled_note() -> None:
+    """Says why the marketplace has no Install buttons."""
+    if not adapter_install_disabled():
+        return
+    _ = ui.label("Installing and uninstalling adapters is disabled on this LEAF.").classes("text-body mb-4")
+
+
 def build_adapters_content(container: ui.column) -> None:
     """
     Build the adapters content (installed and marketplace).
@@ -228,12 +282,7 @@ def build_adapters_content(container: ui.column) -> None:
                         ui.label(installed_adapter["code"]).classes("text-lg font-bold text-heading mb-1")
                         ui.label(installed_adapter["name"]).classes("text-sm text-body mb-3")
 
-                        def make_uninstall_handler(adapter):
-                            return lambda: uninstall_adapter(adapter)
-
-                        ui.button(
-                            "Uninstall", icon="delete", on_click=make_uninstall_handler(installed_adapter)
-                        ).classes("btn-tertiary w-full rounded-lg transition-colors")
+                        _uninstall_button(installed_adapter)
         else:
             with ui.card().classes("bg-info-card border border-default p-4 mb-8"):
                 with ui.row().classes("items-center"):
@@ -246,6 +295,7 @@ def build_adapters_content(container: ui.column) -> None:
         with ui.row().classes("items-center mb-4"):
             ui.icon("store", size="1.5rem").classes("text-icon")
             ui.label("Adapter Marketplace").classes("text-xl font-semibold text-subheading ml-2")
+        _install_disabled_note()
 
         # Container for marketplace adapters
         marketplace_container = ui.column().classes("w-full")
@@ -350,12 +400,7 @@ def build_adapters_content(container: ui.column) -> None:
                                     ui.label(adapter["adapter_id"]).classes("text-lg font-bold text-heading mb-1")
                                     ui.label(adapter.get("name", "No description")).classes("text-sm text-body mb-3")
 
-                                    def make_install_handler(adptr):
-                                        return lambda: install_adapter(adptr)
-
-                                    ui.button(
-                                        "Install", icon="download", on_click=make_install_handler(adapter)
-                                    ).classes("btn-secondary w-full rounded-lg transition-colors")
+                                    _install_button(adapter)
             except Exception as e:
                 logger.error(f"Failed to load marketplace: {e}", exc_info=True)
                 # Remove loading indicator

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/leaf/ui/utils.py

@@ -2,9 +2,11 @@
 
 import asyncio
 import logging
+import os
 import subprocess
 import sys
 from typing import Any
+from urllib.parse import quote, urlsplit, urlunsplit
 
 from nicegui import ui
 
@@ -59,16 +61,49 @@ def _run_pip(*args: str) -> subprocess.CompletedProcess[str]:
     )
 
 
-async def install_adapter(adapter: dict[Any, Any]) -> None:
+# Set (1/true/yes) where the adapters are fixed, e.g. a shared deployment whose adapters come from its image
+ADAPTER_INSTALL_DISABLE_ENV = "LEAF_DISABLE_ADAPTER_INSTALL"
+
+
+def adapter_install_disabled() -> bool:
+    """True when installing and uninstalling adapters from the web interface is switched off."""
+    return os.environ.get(ADAPTER_INSTALL_DISABLE_ENV, "").strip().lower() in ("1", "true", "yes")
+
+
+def _refused(action: str) -> bool:
+    """Tell the user and return True when adapter installs are switched off, so pip never runs."""
+    if not adapter_install_disabled():
+        return False
+    logger.warning(f"{action} adapters is disabled via {ADAPTER_INSTALL_DISABLE_ENV}")
+    ui.notify(f"{action} adapters is disabled on this LEAF", type="warning", position="top", timeout=5000)
+    return True
+
+
+def with_credentials(repository: str, username: str, token: str) -> str:
+    """repository with username and token in it, for pip to clone a private (restricted) adapter."""
+    parts = urlsplit(repository)
+    host = parts.hostname or ""
+    if parts.port:
+        host = f"{host}:{parts.port}"
+    return urlunsplit(parts._replace(netloc=f"{quote(username, safe='')}:{quote(token, safe='')}@{host}"))
+
+
+async def install_adapter(adapter: dict[Any, Any], credentials: tuple[str, str] | None = None) -> None:
     """
     Install a LEAF adapter from a Git repository.
 
     Args:
         adapter: Dictionary containing adapter metadata including 'repo_url' and 'name'
+        credentials: Username and token for a restricted adapter's private repository; never logged
     """
+    if _refused("Installing"):
+        return
     adapter_name = adapter.get("name") or adapter.get("adapter_id", "adapter")
     logger.info(f"Installing {adapter_name}...")
     repository = adapter["repo_url"]
+    if credentials is not None:
+        # pip masks the token in its own output; LEAF never logs this URL
+        repository = with_credentials(repository, *credentials)  # pyright: ignore[reportAny]
 
     # Show "installing" notification
     ui.notify(f"Installing {adapter_name}... This may take a moment.", type="info", position="top", timeout=3000)
@@ -119,6 +154,8 @@ async def uninstall_adapter(installed_adapter: dict[Any, Any]) -> None:
     Args:
         installed_adapter: Dictionary containing adapter metadata with 'name' field
     """
+    if _refused("Uninstalling"):
+        return
     package_name = installed_adapter.get("name")
 
     if not package_name:

{leaf_framework-0.10.25 → leaf_framework-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "leaf-framework"
-version = "0.10.25"
+version = "0.11.0"
 description = "Lightweight Adapter Framework (LEAF)"
 authors = [
     "Matthew Crowther <nmc215@ncl.ac.uk>",
@@ -23,19 +23,17 @@ include = [
 
 
 [tool.poetry.dependencies]
-aioredis = "~2.0.1"
 dateparser = "~1.4.3"
 httpx = "~0.28.1"
-influxobject = ">=0.0.13"  # 0.0.13 adds InfluxPoint.set_organisation/get_organisation, used by leaf-example
 nicegui = "~3.18.0"
 paho-mqtt = "~2.1.0"
 pyyaml = "~6.0.3"
 python = ">=3.12,<3.15"
-redis = "~8.1.0"
 requests = "~2.34.2"
 watchdog = "~7.0.0"
 cairosvg = "^2.9.1"
 pillow = "^13.0.0"
+leafobject = "^0.0.14"
 
 [tool.poetry.scripts]
 leaf = "leaf.start:main"

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

@@ -1,243 +0,0 @@
-import json
-from typing import Any
-
-import redis
-
-from leaf.error_handler.error_holder import ErrorHolder
-from leaf.error_handler.exceptions import ClientUnreachableError, SeverityLevel
-from leaf.modules.output_modules.output_module import OutputModule
-from leaf.utility.logger.logger_utils import get_logger
-
-logger = get_logger(__name__, log_file="output_module.log")
-
-
-class KEYDB(OutputModule):
-    """
-    An output module for interacting with a KeyDB (Redis-compatible)
-    server. This class provides methods to connect to KeyDB, transmit
-    data, retrieve data, and handle errors consistently. If connection
-    or transmission fails, a fallback module can be used if provided.
-    """
-
-    def __init__(
-        self,
-        host: str,
-        port: int = 6379,
-        db: int = 0,
-        fallback: OutputModule | None = None,
-        error_holder: ErrorHolder | None = None,
-        name: str | None = None,
-    ) -> None:
-        """
-        Initialize the KEYDB adapter with KeyDB connection details and
-        optional fallback.
-
-        Args:
-            host (str): The KeyDB server hostname or IP address.
-            port (int): The port for KeyDB connection (default is 6379).
-            db (int): The database number to connect to (default is 0).
-            fallback (Optional[OutputModule]): Fallback module to use
-                     if KeyDB operations fail.
-            error_holder (Optional[ErrorHolder]): Optional error holder
-                         for tracking errors.
-        """
-        super().__init__(fallback=fallback, error_holder=error_holder, name=name)
-        if not self._name:
-            self._name = f"KEYDB({host}:{port})"
-        self.host: str = host
-        self.port: int = port
-        self.db: int = db
-        self._client: redis.StrictRedis | None = None
-        self.connect()
-
-    def _handle_redis_error(self, exception: redis.RedisError) -> None:
-        """
-        Handle Redis-related errors by logging
-        them and invoking the error handler.
-
-        Args:
-            exception (redis.RedisError): The Redis exception that occurred.
-        """
-        if isinstance(exception, redis.AuthenticationError):
-            message = f"Authentication failed for KeyDB at {self.host}:{self.port}"
-            severity = SeverityLevel.CRITICAL
-        elif isinstance(exception, redis.ConnectionError):
-            if "Network is unreachable" in str(exception):
-                message = f"Network unreachable for KeyDB at {self.host}:{self.port}"
-                severity = SeverityLevel.ERROR
-            elif "Connection refused" in str(exception):
-                message = f"Connection refused for KeyDB at {self.host}:{self.port}"
-                severity = SeverityLevel.WARNING
-            else:
-                message = f"Failed to connect to KeyDB at {self.host}:{self.port}: {str(exception)}"
-                severity = SeverityLevel.CRITICAL
-        elif isinstance(exception, redis.TimeoutError):
-            message = f"Connection to KeyDB at {self.host}:{self.port} timed out."
-            severity = SeverityLevel.ERROR
-        else:
-            message = f"Redis error for KeyDB: {str(exception)}"
-            severity = SeverityLevel.WARNING
-
-        self._handle_exception(ClientUnreachableError(message, output_module=self, severity=severity))
-
-    def connect(self) -> None:
-        """
-        Establish a connection to the KeyDB server.
-
-        Logs success or handles connection errors by
-        invoking the error handler.
-        """
-        try:
-            self._client = redis.StrictRedis(host=self.host, port=self.port, db=self.db)
-            logger.info(f"Connected to KeyDB server at {self.host}:{self.port}, DB: {self.db}")
-        except redis.RedisError as e:
-            self._handle_redis_error(e)
-
-    def transmit(self, topic: str, data: Any | None = None) -> bool:
-        """
-        Transmit data to the KeyDB server by appending it to the existing
-        value for the given key. The value for each key is always stored
-        as a list, even if it contains only one element.
-
-        Args:
-            topic (str): The key name under which the data will be stored.
-            data (Optional[Any]): The data to append to the list in KeyDB.
-
-        Returns:
-            bool: True if the data was successfully transmitted,
-                False if a fallback was used.
-        """
-        if data is None:
-            logger.warning("No data provided to transmit.")
-            return False
-        elif isinstance(data, (dict, list, tuple, int, float, bool)):
-            data = json.dumps(data)
-        elif isinstance(data, str):
-            try:
-                # Validate JSON, then normalize as JSON string
-                parsed = json.loads(data)
-                data = json.dumps(parsed)
-            except json.JSONDecodeError:
-                logger.error(f"Invalid JSON string: {data}")
-                return False
-        else:
-            logger.error(f"Unsupported data type: {type(data).__name__}")
-            return False
-
-        if self._client is None:
-            return self.fallback(topic, data)
-
-        try:
-            self._client.lpush(topic, data)
-            logger.info(f"Pushed data to key '{topic}' in KeyDB {self._client} with {self._client.llen(topic)} rows.")
-            # Reset global failure counter on successful transmission
-            OutputModule.reset_failure_count()
-            self.store_latest(topic, data)
-            # Transmit to parallel outputs (best-effort)
-            self.transmit_to_parallels(topic, data)
-            return True
-        except redis.RedisError as e:
-            self._handle_redis_error(e)
-            return self.fallback(topic, data)
-
-    def is_connected(self) -> bool:
-        """
-        Check if the connection to KeyDB is established.
-
-        Returns:
-            bool: True if connected, False otherwise.
-        """
-        # TODO Have a thread running to check for content and if present process it to the registered MQTT output module if alive
-        topics = self._client.keys()
-        if topics:
-            logger.info(f"Found existing keys in KeyDB: {topics}")
-            for topic in topics:
-                # 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.")
-        return self._client is not None
-
-    def disconnect(self) -> None:
-        """
-        Disconnect from the KeyDB server by
-        setting the client to None.
-
-        Logs the disconnection status.
-        """
-        if self._client is not None:
-            self._client = None
-            logger.info("Disconnected from KeyDB.")
-        else:
-            logger.info("Already disconnected from KeyDB.")
-
-    def pop(self, key: str | None = None) -> tuple[str, Any] | None:
-        """
-        Retrieve and remove a record from KeyDB.
-        If a specific key is provided, retrieve and remove all values under
-        that key. If no key is provided, retrieve and remove one element from
-        a random key's list. The key is removed when the last element is taken.
-
-        Args:
-            key (Optional[str]): The key of the record to retrieve and remove.
-                                If None, a random record is retrieved and removed.
-
-        Returns:
-            Optional[tuple[str, Any]]: A tuple of the key and the retrieved value,
-                                    or None if the key does not exist or the
-                                    database is empty.
-        """
-        if self._client is None:
-            logger.warning("Attempted to pop from a disconnected KeyDB client.")
-            return None
-
-        try:
-            if key is not None:
-                result = self._client.lpop(key)
-                if result:
-                    # Content is already popped
-                    # If the list is empty after popping, delete the key
-                    if self._client.llen(key) == 0:
-                        self._client.delete(key)
-                    return key, json.loads(result.decode("utf-8"))
-                return None
-
-            raw_key = self._client.randomkey()
-            if not raw_key:
-                logger.info("No keys available in KeyDB.")
-                return None
-            random_key = str(raw_key)
-            if isinstance(raw_key, bytes):
-                # Decode bytes to string if necessary
-                random_key = raw_key.decode("utf-8")
-
-            logger.info(f"Popping from key '{random_key}' in KeyDB.")
-            result = self._client.lpop(random_key)
-
-            if not result:
-                return None
-
-            result = json.loads(result.decode("utf-8"))
-            if result:
-                # Check if the list is empty after popping
-                if self._client.llen(random_key) == 0:
-                    logger.info(f"Key '{random_key}' is empty after popping.")
-                    self._client.delete(random_key)
-                logger.info(f"Popped key '{random_key}' from KeyDB.")
-                return random_key, result
-            # if isinstance(result, list):
-            #     popped_value = result.pop(0)
-            #     if result:
-            #         self._client.set(random_key, json.dumps(result))
-            #     else:
-            #         self._client.delete(random_key)
-            #     return random_key, popped_value
-
-            logger.error(f"Unexpected value type for key '{random_key}'. Deleting key.")
-            self._client.delete(random_key)
-            return None
-        except redis.RedisError as e:
-            self._handle_redis_error(e)
-            return None