boneIO 0.11.0.dev6__tar.gz → 0.11.0.dev8__tar.gz

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.11.0.dev6
+Version: 0.11.0.dev8
 Summary: Python App for BoneIO
 License: GNU General Public License v3.0
 Author-email: Paweł Szafer <pszafer@gmail.com>

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/helper/ha_discovery.py

@@ -228,7 +228,7 @@ def modbus_sensor_availabilty_message(
 ):
     """Create Modbus Sensor availability topic for HA."""
     return {
-        "availability": [{"topic": f"{topic}/{id}{STATE}"}],
+        "availability": [{"topic": f"{topic}/{id}/{STATE}"}],
         "device": {
             "identifiers": [id],
             "manufacturer": "boneIO",

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/helper/loader.py

@@ -235,7 +235,6 @@ def create_modbus_sensors(manager: Manager, message_bus: MessageBus, sensors, **
     for sensor in sensors:
         name = sensor.get(ID)
         id = name.replace(" ", "")
-        print("name to check", name)
         additional_data = sensor.get("data", {})
         try:
             modbus_sensors[id.lower()] = ModbusSensor(
@@ -364,8 +363,8 @@ def configure_relay(
             "output_type": output_type,
         }
     elif output_kind == GPIO:
-        if GPIO not in manager.grouped_outputs:
-            manager.grouped_outputs[GPIO] = {}
+        if GPIO not in manager.grouped_outputs_by_expander:
+            manager.grouped_outputs_by_expander[GPIO] = {}
         extra_args = {
             "pin": config.pop(PIN),
         }
@@ -392,8 +391,8 @@ def configure_relay(
         **extra_args,
     )
     manager._interlock_manager.register(relay, interlock_groups)
-    manager.grouped_outputs[expander_id][relay_id] = relay
-    if relay.virtual_power_usage is not None:
+    manager.grouped_outputs_by_expander[expander_id][relay_id] = relay
+    if relay.is_virtual_power:
         manager.send_ha_autodiscovery(
             id=f"{relay_id}_virtual_power",
             relay_id=relay_id,
@@ -418,6 +417,31 @@ def configure_relay(
             state_class="total_increasing",
             value_template="{{ value_json.energy }}"
         )
+    if relay.is_virtual_volume_flow_rate:
+        manager.send_ha_autodiscovery(
+            id=f"{relay_id}_virtual_volume_flow_rate",
+            relay_id=relay_id,
+            name=f"{name} Virtual Volume Flow Rate",
+            ha_type="sensor",
+            device_type="energy",
+            availability_msg_func=ha_virtual_energy_sensor_discovery_message,
+            unit_of_measurement="L/h",
+            device_class="volume_flow_rate",
+            state_class="measurement",
+            value_template="{{ value_json.volume_flow_rate }}"
+        )
+        manager.send_ha_autodiscovery(
+            id=f"{relay_id}_virtual_consumption",
+            relay_id=relay_id,
+            name=f"{name} Virtual consumption",
+            ha_type="sensor",
+            device_type="energy",
+            availability_msg_func=ha_virtual_energy_sensor_discovery_message,
+            unit_of_measurement="L",
+            device_class="water",
+            state_class="total_increasing",
+            value_template="{{ value_json.water }}"
+        )
     return relay
 
 

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/helper/yaml_util.py

@@ -618,6 +618,44 @@ class CustomValidator(Validator):
         _LOGGER.debug(f"Parsed power value '{value}' as {result} W")
         return result
 
+    def _normalize_coerce_volume_flow_rate_to_lph(self, value):
+        """
+        Parse a volume flow rate value and return it in liters per minute (L/min).
+        Accepts:
+        - Numeric values (int, float)
+        - Strings with units: 'L/min', 'L/h', etc.
+        Example:
+            9 -> 9.0
+            '9L/min' -> 9.0
+            '1L/h' -> 1000.0
+        Returns float (L/h) or raises ValueError if invalid.
+        """
+        if value is None:
+            return None
+        if isinstance(value, (int, float)):
+            return float(value)
+        if not isinstance(value, str):
+            raise ValueError(f"Unsupported type for volume flow rate value: {type(value)}")
+        value = value.strip().replace(' ', '').lower()
+        pattern = r"^([-+]?[0-9]*\.?[0-9]+)\s*([a-zA-Z/]*)$"
+        match = re.match(pattern, value)
+        if not match:
+            _LOGGER.warning(f"Could not parse volume flow rate value: {value}")
+            raise ValueError(f"Could not parse volume flow rate value: {value}")
+        num, unit = match.groups()
+        num = float(num)
+        multiplier = 1.0
+        if unit in ('lph', 'l/h', ''):
+            multiplier = 1.0
+        elif unit in ('lpm', 'l/min'):
+            multiplier = 60.0
+        else:
+            _LOGGER.warning(f"Unknown unit for volume flow rate value: {unit}")
+            raise ValueError(f"Unknown unit for volume flow rate value: {unit}")
+        result = num * multiplier
+        _LOGGER.debug(f"Parsed volume flow rate value '{value}' as {result} L/h")
+        return result
+
 
 
 def load_config_from_string(config_str: str) -> dict:

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/manager.py

@@ -176,13 +176,13 @@ class Manager:
             dallas=dallas, ds2482=ds2482, sensors=sensors.get(ONEWIRE)
         )
 
-        self.grouped_outputs = create_expander(
+        self.grouped_outputs_by_expander = create_expander(
             expander_dict=self._mcp,
             expander_config=mcp23017,
             exp_type=MCP,
             i2cbusio=self._i2cbusio,
         )
-        self.grouped_outputs.update(
+        self.grouped_outputs_by_expander.update(
             create_expander(
                 expander_dict=self._pcf,
                 expander_config=pcf8575,
@@ -190,7 +190,7 @@ class Manager:
                 i2cbusio=self._i2cbusio,
             )
         )
-        self.grouped_outputs.update(
+        self.grouped_outputs_by_expander.update(
             create_expander(
                 expander_dict=self._pca,
                 expander_config=pca9685,
@@ -205,6 +205,7 @@ class Manager:
             _name = _config.pop(ID)
             restore_state = _config.pop(RESTORE_STATE, False)
             _id = strip_accents(_name)
+            _LOGGER.debug("Configuring relay: %s", _id)
             out = configure_relay(  # grouped_output updated here.
                 manager=self,
                 message_bus=message_bus,
@@ -236,7 +237,8 @@ class Manager:
                 )
             self._loop.create_task(self._delayed_send_state(out))
 
-        self._configure_covers()
+        if self._outputs:
+            self._configure_covers()
 
         self._outputs_group = output_group
         self._configure_output_group()
@@ -261,7 +263,7 @@ class Manager:
                 manager=self,
                 event_bus=self._event_bus,
                 enabled_screens=self._screens,
-                output=self.grouped_outputs,
+                output=self.grouped_outputs_by_expander,
                 inputs=self._inputs,
                 temp_sensor=(self._temp_sensors[0] if self._temp_sensors else None),
                 ina219=(self._ina219_sensors[0] if self._ina219_sensors else None),
@@ -271,7 +273,7 @@ class Manager:
                 self._oled = Oled(
                     host_data=self._host_data,
                     screen_order=self._screens,
-                    grouped_outputs=list(self.grouped_outputs),
+                    grouped_outputs_by_expander=list(self.grouped_outputs_by_expander),
                     sleep_timeout=oled.get("screensaver_timeout", 60),
                     event_bus=self._event_bus,
                 )

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/message_bus/mqtt.py

@@ -128,6 +128,7 @@ class MQTTClient(MessageBus):
             params["properties"] = properties
 
         # e.g. subscribe([("my/topic", SubscribeOptions(qos=0), ("another/topic", SubscribeOptions(qos=2)])
+        _LOGGER.debug("Subscribing to %s", args)
         await self.asyncio_client.subscribe(
             topic=args, **params, timeout=timeout
         )
@@ -250,9 +251,8 @@ class MQTTClient(MessageBus):
             cancel_task = asyncio.create_task(wait_for_cancel())
             tasks.add(cancel_task)
 
-            await self.subscribe(topics=self._topics)
-            await self.subscribe(topics=list(self._mqtt_energy_listeners.keys()))
-            await self.subscribe(topics=self._discovery_topics)
+            topics = self._topics + list(self._mqtt_energy_listeners.keys()) + self._discovery_topics
+            await self.subscribe(topics=topics)
 
             # Wait for everything to complete (or fail due to, e.g., network errors).
             await asyncio.gather(*tasks)

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/modbus/client.py

@@ -138,28 +138,27 @@ class Modbus:
 
     async def async_close(self) -> None:
         """Disconnect client."""
-        async with self._lock:
-            if self._client:
-                try:
-                    # Run close in the executor
-                    await self._loop.run_in_executor(self._executor, self._client.close)
-                except asyncio.CancelledError:
-                    _LOGGER.warning("modbus communication closed")
-                    pass
-                except ModbusException as exception_error:
-                    _LOGGER.error(exception_error)
-                finally:
-                    del self._client
-                    self._client = None
-                    self._executor.shutdown(wait=False)
-                    _LOGGER.warning("modbus communication closed")
+        if self._client:
+            try:
+                # Run close in the executor
+                await self._loop.run_in_executor(self._executor, self._client.close)
+            except asyncio.CancelledError:
+                _LOGGER.warning("modbus communication closed")
+                pass
+            except ModbusException as exception_error:
+                _LOGGER.error(exception_error)
+            finally:
+                del self._client
+                self._client = None
+                self._executor.shutdown(wait=False)
+                _LOGGER.warning("modbus communication closed")
 
     def _pymodbus_connect(self) -> bool:
         """Connect client."""
         try:
             return self._client.connect()  # type: ignore[union-attr]
         except ModbusException as exception_error:
-            _LOGGER.error(exception_error)
+            _LOGGER.error(f"No connection to Modbus: {exception_error}")
             return False
 
     async def read_and_decode(
@@ -181,6 +180,58 @@ class Modbus:
         )
         return decoded_value
 
+    def read_registers_blocking(self, unit: int | str, address: int, count: int = 2, method: str = "input") -> ModbusResponse:
+        start_time = time.perf_counter()
+        result = None
+        kwargs = {"unit": unit, "count": count} if unit else {}
+        read_method = self._read_methods[method]
+        
+        try:
+            # Run connection in the executor
+            connected = self._pymodbus_connect()
+            if not connected:
+                _LOGGER.error("Can't connect to Modbus.")
+                return None
+
+            _LOGGER.debug(
+                "Reading %s registers from %s with method %s from device %s.",
+                count,
+                address,
+                method,
+                unit,
+            )
+
+            # Run the read operation in the executor
+            result: ReadInputRegistersResponse = read_method(address, **kwargs)
+
+            if not hasattr(result, REGISTERS):
+                _LOGGER.error("No result from read: %s", str(result))
+                result = None
+
+        except ValueError as exception_error:
+            _LOGGER.error("Error reading registers: %s", exception_error)
+            pass
+        except (ModbusException, struct.error) as exception_error:
+            _LOGGER.error("Error reading registers: %s", exception_error)
+            pass
+        except asyncio.TimeoutError:
+            _LOGGER.error("Timeout reading registers from device %s", unit)
+            pass
+        except asyncio.CancelledError as err:
+            _LOGGER.error("Operation cancelled reading registers from device %s with error %s", unit, err)
+            pass
+        except Exception as e:
+            _LOGGER.error(f"Unexpected error reading registers: {type(e).__name__} - {e}")
+            pass
+        finally:
+            end_time = time.perf_counter()
+            _LOGGER.debug(
+                "Read completed in %.3f seconds: %s",
+                end_time - start_time,
+                result.registers if hasattr(result, REGISTERS) else None,
+            )
+            return result
+
     async def read_registers(
         self,
         unit: int | str,  # device address
@@ -190,56 +241,8 @@ class Modbus:
     ) -> ModbusResponse:
         """Call async pymodbus."""
         async with self._lock:
-            start_time = time.perf_counter()
-            result = None
+            return await self._loop.run_in_executor(self._executor, self.read_registers_blocking, unit, address, count, method)
             
-            try:
-                # Run connection in the executor
-                connected = self._pymodbus_connect()
-                if not connected:
-                    _LOGGER.error("Can't connect to Modbus.")
-                    return None
-
-                kwargs = {"unit": unit, "count": count} if unit else {}
-                read_method = self._read_methods[method]
-                _LOGGER.debug(
-                    "Reading %s registers from %s with method %s from device %s.",
-                    count,
-                    address,
-                    method,
-                    unit,
-                )
-
-                # Run the read operation in the executor
-                result: ReadInputRegistersResponse = await self._loop.run_in_executor(
-                    self._executor,
-                    lambda: read_method(address, **kwargs)
-                )
-
-                if not hasattr(result, REGISTERS):
-                    _LOGGER.error("No result from read: %s", str(result))
-                    result = None
-
-            except (ModbusException, struct.error) as exception_error:
-                _LOGGER.error("Error reading registers: %s", exception_error)
-                pass
-            except asyncio.TimeoutError:
-                _LOGGER.error("Timeout reading registers from device %s", unit)
-                pass
-            except asyncio.CancelledError as err:
-                _LOGGER.error("Operation cancelled reading registers from device %s with error %s", unit, err)
-                pass
-            except Exception as e:
-                _LOGGER.error(f"Unexpected error reading registers: {type(e).__name__} - {e}")
-                pass
-            finally:
-                end_time = time.perf_counter()
-                _LOGGER.debug(
-                    "Read completed in %.3f seconds: %s",
-                    end_time - start_time,
-                    result.registers if hasattr(result, REGISTERS) else None,
-                )
-                return result
 
     def decode_value(self, payload, value_type):
         _payload_type = VALUE_TYPES[value_type]

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/modbus/sensor.py

@@ -73,7 +73,6 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
         self._additional_sensors: List[Dict[str, SingleAdditionalSensor]] = []
         self._additional_sensors_by_source_name: Dict[str, List[SingleAdditionalSensor]] = {}
         self._additional_data = additional_data
-        print("aaa", additional_data)
         # Standard sensors
         for index, data in enumerate(self._db[REGISTERS_BASE]):
             base = data[BASE]
@@ -253,7 +252,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
                 )
                 self._payload_online = ONLINE
                 self._message_bus.send_message(
-                    topic=f"{self._config_helper.topic_prefix}/{self._id}{STATE}",
+                    topic=f"{self._config_helper.topic_prefix}/{self._id}/{STATE}",
                     payload=self._payload_online,
                 )
             if not values:
@@ -264,7 +263,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
                     # Let's assume device is offline.
                     self.set_payload_offline()
                     self._message_bus.send_message(
-                        topic=f"{self._config_helper.topic_prefix}/{self._id}{STATE}",
+                        topic=f"{self._config_helper.topic_prefix}/{self._id}/{STATE}",
                         payload=self._payload_online,
                     )
                     self._discovery_sent = False
@@ -329,6 +328,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
                         timestamp=sensor.last_timestamp,
                     ),
                 )
+                
             self._timestamp = timestamp
             self._message_bus.send_message(
                 topic=f"{self._send_topic}/{data[BASE]}",

{boneio-0.11.0.dev6 → boneio-0.11.0.dev8}/boneio/oled.py

@@ -54,7 +54,7 @@ class Oled:
     def __init__(
         self,
         host_data: HostData,
-        grouped_outputs: List[str],
+        grouped_outputs_by_expander: List[str],
         sleep_timeout: TimePeriod,
         screen_order: List[str],
         event_bus: EventBus
@@ -62,19 +62,19 @@ class Oled:
         """Initialize OLED screen."""
         self._loop = asyncio.get_running_loop()
         self._event_bus = event_bus
-        self._grouped_outputs = None
+        self.grouped_outputs_by_expander = None
         self._input_groups = []
         self._host_data = host_data
 
         def configure_outputs() -> None:
             try:
                 _ind_screen = screen_order.index("outputs")
-                if not grouped_outputs:
+                if not grouped_outputs_by_expander:
                     _LOGGER.debug("No outputs configured. Omitting in screen.")
                     return
                 screen_order.pop(_ind_screen)
-                screen_order[_ind_screen:_ind_screen] = grouped_outputs
-                self._grouped_outputs = grouped_outputs
+                screen_order[_ind_screen:_ind_screen] = grouped_outputs_by_expander
+                self.grouped_outputs_by_expander = grouped_outputs_by_expander
             except ValueError:
                 pass
 
@@ -216,8 +216,8 @@ class Oled:
             else:
                 with canvas(self._device) as draw:
                     if (
-                        self._grouped_outputs
-                        and self._current_screen in self._grouped_outputs
+                        self.grouped_outputs_by_expander
+                        and self._current_screen in self.grouped_outputs_by_expander
                     ):
                         self._draw_output(data, draw)
                         for id in data.keys():
@@ -245,7 +245,7 @@ class Oled:
             )
 
     async def _output_callback(self, event: OutputState):
-        if self._grouped_outputs and self._current_screen in self._grouped_outputs:
+        if self.grouped_outputs_by_expander and self._current_screen in self.grouped_outputs_by_expander:
             self.handle_data_update(type=self._current_screen)
 
     async def _standard_callback(self, event: SensorState):