leaf-framework 0.4.0__tar.gz → 0.5.0__tar.gz

{leaf_framework-0.4.0 → leaf_framework-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-framework
-Version: 0.4.0
+Version: 0.5.0
 Summary: Lightweight Adapter Framework (LEAF)
 License: Apache-2.0
 License-File: LICENSE

{leaf_framework-0.4.0 → leaf_framework-0.5.0}/leaf/modules/input_modules/file_watcher.py

@@ -77,6 +77,7 @@ class FileWatcher(FileSystemEventHandler, EventWatcher):
         use_polling: bool = True,
         polling_interval: float = 1.0,
         skip_existing: bool = False,
+        recursive: bool = False,
     ) -> None:
         """
         Initialise FileWatcher.
@@ -121,6 +122,7 @@ class FileWatcher(FileSystemEventHandler, EventWatcher):
         self._use_polling = use_polling
         self._polling_interval = polling_interval
         self._skip_existing = skip_existing
+        self._recursive = recursive
 
         self._last_created: dict = {}  # Track creation time per file path
         self._last_modified: dict = {}  # Track modification time per file path
@@ -154,7 +156,7 @@ class FileWatcher(FileSystemEventHandler, EventWatcher):
                 logger.debug("Using native filesystem observer")
             for path in self._paths:
                 logger.debug(f"Watching path: {path}")
-                self._observer.schedule(self, path, recursive=False)
+                self._observer.schedule(self, path, recursive=self._recursive)
             if not self._observer.is_alive():
                 logger.debug("Starting observer thread...")
                 self._observer.start()

{leaf_framework-0.4.0 → leaf_framework-0.5.0}/leaf/modules/input_modules/modbus_watcher.py

@@ -26,9 +26,15 @@ class ModbusWatcher(ExternalEventWatcher):
 
     Each entry in `registers` may contain:
         name    (str):   Key used in the output payload.
-        address (int):   Modbus holding register address. Accepts either 4xxxx notation
-                         (e.g. 40301, offset subtracted automatically) or 0-based protocol
-                         address (e.g. 300).
+        address (int):   Modbus register address. Accepts 4xxxx notation for holding
+                         registers (e.g. 40301, offset subtracted automatically), 3xxxx
+                         notation for input registers (e.g. 30009, offset subtracted
+                         automatically), or a 0-based protocol address (e.g. 300).
+        register_type (str): "holding" (default) or "input". Only needed when `address`
+                         is a 0-based protocol address, since that notation does not
+                         indicate which register bank to read from. Ignored when
+                         `address` is given in 3xxxx/4xxxx notation, which determines
+                         the register bank automatically.
         count   (int):   Number of consecutive registers to read (default 1).
         scale   (float): Multiply the raw value by this factor (default 1.0).
                          Applied only when count == 1.
@@ -53,6 +59,9 @@ class ModbusWatcher(ExternalEventWatcher):
             - name: last_ir_ts
               address: 42002
               count: 2
+            - name: h2_flow_rate
+              address: 30009
+              scale: 0.1
     """
 
     def __init__(
@@ -121,8 +130,20 @@ class ModbusWatcher(ExternalEventWatcher):
                 continue
 
             raw_address = int(address)
-            protocol_address = raw_address - 40001 if raw_address >= 40001 else raw_address
-            result = self._client.read_holding_registers(
+            if raw_address >= 40001:
+                protocol_address = raw_address - 40001
+                register_type = "holding"
+            elif raw_address >= 30001:
+                protocol_address = raw_address - 30001
+                register_type = "input"
+            else:
+                protocol_address = raw_address
+                register_type = reg.get("register_type", "holding")
+
+            read_fn = (
+                self._client.read_input_registers if register_type == "input" else self._client.read_holding_registers
+            )
+            result = read_fn(
                 address=protocol_address,
                 count=count,
                 device_id=self._device_id,

{leaf_framework-0.4.0 → leaf_framework-0.5.0}/leaf/modules/output_modules/mqtt.py

@@ -8,7 +8,7 @@ import paho.mqtt.client as mqtt
 from paho.mqtt.enums import CallbackAPIVersion
 
 from leaf.error_handler.error_holder import ErrorHolder
-from leaf.error_handler.exceptions import AdapterBuildError, ClientUnreachableError, SeverityLevel
+from leaf.error_handler.exceptions import AdapterBuildError, ClientUnreachableError, LEAFError, SeverityLevel
 from leaf.modules.output_modules.output_module import OutputModule
 from leaf.utility.logger.logger_utils import get_logger
 
@@ -491,8 +491,14 @@ class MQTT(OutputModule):
                     "timestamp": time.time(),
                     "datetime": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime()),
                 }
-            logger.info(f"Publishing heartbeat to '{self._heartbeat_topic}': {payload}")
-            self.transmit(self._heartbeat_topic, payload)
+            logger.debug(f"Publishing heartbeat to '{self._heartbeat_topic}': {payload}")
+            try:
+                self.transmit(self._heartbeat_topic, payload)
+            except LEAFError as e:
+                # Must not propagate - an unhandled exception here (e.g. the broker
+                # connection not being fully up yet) would silently kill this daemon
+                # thread and stop all future heartbeats.
+                logger.debug(f"Heartbeat publish failed, will retry next interval: {e}")
             if self._heartbeat_stop.wait(self._heartbeat_interval):
                 break
 

{leaf_framework-0.4.0 → leaf_framework-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "leaf-framework"
-version = "0.4.0"
+version = "0.5.0"
 description = "Lightweight Adapter Framework (LEAF)"
 authors = [
     "Matthew Crowther <nmc215@ncl.ac.uk>",