boneIO 0.11.0.dev5__tar.gz → 0.11.0.dev8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.11.0.dev5
+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.dev5 → boneio-0.11.0.dev8}/boneio/const.py

@@ -32,6 +32,8 @@ PCA = "pca"
 GPIO_MODE = "gpio_mode"
 ACTIONS = "actions"
 ACTION = "action"
+OUTPUT_OVER_MQTT = "output_over_mqtt"
+COVER_OVER_MQTT = "cover_over_mqtt"
 SWITCH = "switch"
 LIGHT = "light"
 BUTTON = "button"

{boneio-0.11.0.dev5 → boneio-0.11.0.dev8}/boneio/helper/config.py

@@ -3,6 +3,7 @@ Module to provide basic config options.
 """
 from __future__ import annotations
 
+import logging
 from _collections_abc import dict_values
 from typing import Union
 
@@ -18,6 +19,9 @@ from boneio.const import (
     SWITCH,
     VALVE,
 )
+from boneio.helper.util import sanitize_mqtt_topic
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class ConfigHelper:
@@ -28,9 +32,12 @@ class ConfigHelper:
         device_type: str = "boneIO Black",
         ha_discovery: bool = True,
         ha_discovery_prefix: str = HOMEASSISTANT,
+        network_info: dict = None,
+        is_web_active: bool = False,
     ):
         self._name = name
-        self._topic_prefix = topic_prefix if topic_prefix else name
+        sanitized_topic_prefix = sanitize_mqtt_topic(topic_prefix) if topic_prefix else sanitize_mqtt_topic(name)
+        self._topic_prefix = sanitized_topic_prefix
         self._ha_discovery = ha_discovery
         self._ha_discovery_prefix = ha_discovery_prefix
         self._device_type = device_type
@@ -46,6 +53,16 @@ class ConfigHelper:
             VALVE: {},
         }
         self.manager_ready: bool = False
+        self._network_info = network_info
+        self._is_web_active = is_web_active
+
+    @property
+    def network_info(self) -> dict:
+        return self._network_info
+
+    @property
+    def is_web_active(self) -> bool:
+        return self._is_web_active
 
     @property
     def topic_prefix(self) -> str:

{boneio-0.11.0.dev5 → boneio-0.11.0.dev8}/boneio/helper/filter.py

@@ -1,8 +1,9 @@
 """Filter class to adjust sensor values."""
 
 from __future__ import annotations
-from typing import Optional
+
 import logging
+from typing import Optional
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -13,7 +14,7 @@ FILTERS = {
     "multiply": lambda x, y: x * y if x else x,
     "filter_out": lambda x, y: None if x == y else x,
     "filter_out_greater": lambda x, y: None if x > y else x,
-    "filter_out_lower": lambda x, y: None if x < y else x,
+    "filter_out_lower": lambda x, y: None if x < y else x
 }
 
 

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

@@ -228,12 +228,12 @@ 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",
             "model": model,
-            "name": f"boneIO {name.upper()}",
+            "name": name,
             "sw_version": __version__,
         },
         "name": sensor_id,

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

@@ -235,6 +235,7 @@ def create_modbus_sensors(manager: Manager, message_bus: MessageBus, sensors, **
     for sensor in sensors:
         name = sensor.get(ID)
         id = name.replace(" ", "")
+        additional_data = sensor.get("data", {})
         try:
             modbus_sensors[id.lower()] = ModbusSensor(
                 address=sensor[ADDRESS],
@@ -247,6 +248,7 @@ def create_modbus_sensors(manager: Manager, message_bus: MessageBus, sensors, **
                     UPDATE_INTERVAL, TimePeriod(seconds=60)
                 ),
                 sensors_filters=sensor.get("sensors_filters", {}),
+                additional_data=additional_data,
                 **kwargs,
             )
         except FileNotFoundError as err:
@@ -361,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),
         }
@@ -389,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,
@@ -415,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.dev5 → boneio-0.11.0.dev8}/boneio/helper/util.py

@@ -19,7 +19,7 @@ def is_callback(func: Callable[..., Any]) -> bool:
 
 
 def strip_accents(s):
-
+    """Remove accents and spaces from a string."""
     return "".join(
         c
         for c in unicodedata.normalize("NFD", s)
@@ -27,6 +27,31 @@ def strip_accents(s):
     )
 
 
+def sanitize_mqtt_topic(name: str) -> str:
+    """
+    Sanitize a string to be used as an MQTT topic:
+    - Replace spaces with underscores
+    - Remove Polish diacritics
+    - Remove/replace forbidden characters (leave only a-z, A-Z, 0-9, '_', '-')
+    Args:
+        name (str): Input string
+    Returns:
+        str: Sanitized string
+    """
+    import re
+    from .logger import _LOGGER
+
+    original = name
+    # Zamień spacje na podkreślenia
+    name = name.replace(' ', '_')
+    # Usuń polskie znaki
+    name = strip_accents(name)
+    # Zostaw tylko dozwolone znaki
+    name = re.sub(r'[^a-zA-Z0-9_-]', '', name)
+    _LOGGER.debug(f"Sanitized MQTT topic: '{original}' -> '{name}'")
+    return name
+
+
 def open_json(path: str, model: str) -> dict:
     """Open json file."""
     file = f"{os.path.join(path)}/{model}.json"

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

@@ -430,6 +430,40 @@ class CustomValidator(Validator):
     def _normalize_coerce_actions_output(self, value):
         return str(value).upper()
 
+    def _normalize_coerce_length_to_meters(self, value) -> float:
+        """
+        Convert a length value to meters.
+        Accepts:
+        - Numeric values (int, float) - assumed to be in meters
+        - Strings with units: 'm', 'cm', 'mm'
+        Examples:
+        5 -> 5.0
+        '5m' -> 5.0
+        '500cm' -> 5.0
+        '2000mm' -> 2.0
+        """
+        if value is None:
+            return None
+        if isinstance(value, (int, float)):
+            return float(value)
+        value = str(value).strip().lower()
+        match = re.match(r"^([-+]?[0-9]*\.?[0-9]*)\s*(m|cm|mm)?$", value)
+        if not match:
+            raise ValueError(f"Invalid length value: {value}")
+        num = float(match.group(1))
+        unit = match.group(2) or "m"
+        if unit == "m":
+            multiplier = 1.0
+        elif unit == "cm":
+            multiplier = 0.01
+        elif unit == "mm":
+            multiplier = 0.001
+        else:
+            raise ValueError(f"Unknown unit for length value: {unit}")
+        result = num * multiplier
+        _LOGGER.debug(f"Parsed length value '{value}' as {result} m")
+        return result
+
     def _normalize_coerce_positive_time_period(self, value) -> TimePeriod:
         """Validate and transform time period with time unit and integer value."""
         if isinstance(value, int):
@@ -529,7 +563,6 @@ class CustomValidator(Validator):
             '2.5MW' -> 2500000.0
         Returns float (watts) or raises ValueError if invalid.
         """
-        import re
         if value is None:
             return None
         if isinstance(value, (int, float)):
@@ -585,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.dev5 → boneio-0.11.0.dev8}/boneio/manager.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from collections import deque
-from typing import Callable, Coroutine, List, Optional, Set
+from typing import Callable, Coroutine, List, Optional, Set, Tuple
 
 from board import SCL, SDA
 from busio import I2C
@@ -15,6 +15,7 @@ from boneio.const import (
     BUTTON,
     CLOSE,
     COVER,
+    COVER_OVER_MQTT,
     DALLAS,
     DS2482,
     EVENT_ENTITY,
@@ -30,12 +31,12 @@ from boneio.const import (
     MODBUS,
     MQTT,
     NONE,
-    OFF,
     ON,
     ONEWIRE,
     ONLINE,
     OPEN,
     OUTPUT,
+    OUTPUT_OVER_MQTT,
     PCA,
     PCF,
     PIN,
@@ -45,7 +46,6 @@ from boneio.const import (
     STATE,
     STOP,
     SWITCH,
-    TOGGLE,
     TOPIC,
     UART,
     UARTS,
@@ -88,6 +88,7 @@ from boneio.helper.yaml_util import load_config_from_file
 from boneio.message_bus import MessageBus
 from boneio.modbus.client import Modbus
 from boneio.models import OutputState
+from boneio.relay.basic import BasicRelay
 from boneio.sensor.temp import TempSensor
 
 _LOGGER = logging.getLogger(__name__)
@@ -126,7 +127,6 @@ class Manager:
         cover: list = [],
         web_active: bool = False,
         web_port: int = 8090,
-        network_state: Optional[dict] = None,
     ) -> None:
         """Initialize the manager."""
         _LOGGER.info("Initializing manager module.")
@@ -140,7 +140,6 @@ class Manager:
         self._event_bus = event_bus
         self._is_web_on = web_active
         self._web_bind_port = web_port
-        self._network_info = network_state
 
         self._message_bus: MessageBus = message_bus
 
@@ -153,7 +152,7 @@ class Manager:
         self._mcp = {}
         self._pcf = {}
         self._pca = {}
-        self._outputs = {}
+        self._outputs: dict[str, BasicRelay] = {}
         self._configured_output_groups = {}
         self._interlock_manager = SoftwareInterlockManager()
 
@@ -177,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,
@@ -191,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,
@@ -206,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,
@@ -237,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()
@@ -262,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),
@@ -272,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,
                 )
@@ -722,19 +723,21 @@ class Manager:
         """Get PCF by it's id."""
         return self._pcf
 
-    def get_output_and_action(self, device_id, action, action_output, action_cover):
+    def get_output_and_action(
+        self, entity_id: str, action: str, action_output: str, action_cover: str
+    ) -> Tuple[BasicRelay, str]:
         """Get output device and its action based on configuration."""
         if action == OUTPUT:
             return (
                 self._outputs.get(
-                    strip_accents(device_id),
-                    self._configured_output_groups.get(device_id),
+                    strip_accents(entity_id),
+                    self._configured_output_groups.get(entity_id),
                 ),
                 relay_actions.get(action_output),
             )
         else:
             return (
-                self._covers.get(strip_accents(device_id)),
+                self._covers.get(strip_accents(entity_id)),
                 cover_actions.get(action_cover),
             )
 
@@ -751,6 +754,32 @@ class Manager:
         actions = gpio.get_actions_of_click(click_type=x)
         topic = f"{self._config_helper.topic_prefix}/{gpio.input_type}/{gpio.pin}"
 
+        async def invoke_action_on_output(
+            entity_id: str, action_output: str, action: str, action_cover: str
+        ):
+            output, action_to_execute = self.get_output_and_action(
+                entity_id=entity_id,
+                action=action,
+                action_output=action_output,
+                action_cover=action_cover,
+            )
+            if output and action_to_execute:
+                _LOGGER.debug(
+                    "Executing action %s for output %s", action_to_execute, output.name
+                )
+                _f = getattr(output, action_to_execute)
+                if _f:
+                    await _f(**extra_data)
+            else:
+                if not action_to_execute:
+                    _LOGGER.warning(
+                        "Action doesn't exists %s, %s, %s. Check spelling",
+                        action_definition,
+                        actions,
+                    )
+                if not output:
+                    _LOGGER.warning("Device %s for action not found", entity_id)
+
         def generate_payload():
             if gpio.input_type == INPUT:
                 if duration:
@@ -759,48 +788,47 @@ class Manager:
             return x
 
         for action_definition in actions:
-            device_id = action_definition.get("pin")
+            entity_id = action_definition.get("pin")
             action = action_definition.get("action")
             action_output = action_definition.get("action_output")
             action_cover = action_definition.get("action_cover")
+            extra_data = action_definition.get("data", {})
             if action == MQTT:
                 action_topic = action_definition.get(TOPIC)
                 action_payload = action_definition.get("action_mqtt_msg")
-                action_boneio = action_definition.get("action_mqtt_boneio")
-                action_output = action_definition.get("action_output")
-                pin = action_definition.get("pin")
-                if action_boneio and pin and action_output in (TOGGLE, ON, OFF):
-                    self.send_message(
-                        topic=f"{action_boneio}/cmd/relay{pin}",
-                        payload=action_output,
-                        retain=False,
-                    )
                 if action_topic and action_payload:
                     self.send_message(
                         topic=action_topic, payload=action_payload, retain=False
                     )
                 continue
-            extra_data = action_definition.get("data", {})
-            output, action = self.get_output_and_action(
-                device_id=device_id,
-                action=action,
-                action_output=action_output,
-                action_cover=action_cover,
-            )
-            if output and action:
-                _LOGGER.debug("Executing action %s for output %s", action, output.name)
-                _f = getattr(output, action)
-                if _f:
-                    await _f(**extra_data)
-            else:
-                if not action:
-                    _LOGGER.warning(
-                        "Action doesn't exists %s, %s, %s. Check spelling",
-                        action_definition,
-                        actions,
+            elif action == OUTPUT or action == COVER:
+                await invoke_action_on_output(
+                    entity_id=entity_id,
+                    action_output=action_output,
+                    action=action,
+                    action_cover=action_cover,
+                )
+            elif action == OUTPUT_OVER_MQTT:
+                boneio_id = action_definition.get("boneio_id")
+                if relay_actions.get(action_output.upper()):
+                    self.send_message(
+                        topic=f"{boneio_id}/cmd/relay/{entity_id}/set",
+                        payload=action_output,
+                        retain=False,
                     )
-                if not output:
-                    _LOGGER.warning("Device %s for action not found", device_id)
+                else:
+                    _LOGGER.warning("Desired action %s does not exists", action_output)
+            elif action == COVER_OVER_MQTT:
+                boneio_id = action_definition.get("boneio_id")
+                if cover_actions.get(action_cover.upper()):
+                    self.send_message(
+                        topic=f"{boneio_id}/cmd/cover/{entity_id}/set",
+                        payload=action_cover,
+                        retain=False,
+                    )
+                else:
+                    _LOGGER.warning("Desired action %s does not exists", action_cover)
+
         payload = generate_payload()
         _LOGGER.debug("Sending message %s for input %s", payload, topic)
         self.send_message(topic=topic, payload=payload, retain=False)
@@ -976,13 +1004,12 @@ class Manager:
         if not self._config_helper.ha_discovery:
             return
         topic_prefix = topic_prefix or self._config_helper.topic_prefix
-        if self._host_data:
-            web_url = self._host_data.web_url
-        else:
-            if self._network_info and IP in self._network_info:
-                web_url = f"http://{self._network_info[IP]}:{self._web_bind_port}"
-            else:
-                web_url = None
+        web_url = None
+        if self._config_helper.is_web_active:
+            if self._host_data:
+                web_url = self._host_data.web_url
+            elif self._config_helper.network_info and IP in self._config_helper.network_info:
+                web_url = f"http://{self._config_helper.network_info[IP]}:{self._web_bind_port}"
         payload = availability_msg_func(
             topic=topic_prefix,
             id=id,

{boneio-0.11.0.dev5 → 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)