boneIO 0.11.0.dev5__tar.gz → 0.11.0.dev6__tar.gz

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

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

@@ -233,7 +233,7 @@ def modbus_sensor_availabilty_message(
             "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.dev6}/boneio/helper/loader.py

@@ -235,6 +235,8 @@ 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(
                 address=sensor[ADDRESS],
@@ -247,6 +249,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:

{boneio-0.11.0.dev5 → boneio-0.11.0.dev6}/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.dev6}/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)):

{boneio-0.11.0.dev5 → boneio-0.11.0.dev6}/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()
 
@@ -722,19 +721,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 +752,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 +786,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 +1002,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.dev6}/boneio/modbus/liquid-sensor.json

@@ -33,5 +33,16 @@
         }
       ]
     }
+  ],
+  "additional_sensors": [
+    {
+      "name": "Measurement Volume",
+      "source": "measurement_value",
+      "unit_of_measurement": "l",
+      "device_class": "volume_storage",
+      "state_class": "measurement",
+      "formula": "width * length * X * 10",
+      "config_keys": ["width", "length"]
+    }
   ]
 }

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

@@ -28,7 +28,7 @@ from boneio.helper.util import open_json
 from boneio.models import SensorState
 
 from .client import VALUE_TYPES, Modbus
-from .single_sensor import SingleSensor
+from .single_sensor import SingleAdditionalSensor, SingleSensor
 from .utils import CONVERT_METHODS, REGISTERS_BASE
 
 _LOGGER = logging.getLogger(__name__)
@@ -49,6 +49,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
         config_helper: ConfigHelper,
         event_bus: EventBus,
         id: str = DefaultName,
+        additional_data: dict = {},
         **kwargs,
     ):
         """Initialize Modbus sensor class."""
@@ -69,6 +70,11 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
             k.lower(): v for k, v in sensors_filters.items()
         }
         self._modbus_sensors: List[Dict[str, SingleSensor]] = []
+        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]
             self._modbus_sensors.append({})
@@ -98,6 +104,45 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
                 self._modbus_sensors[index][
                     single_sensor.decoded_name
                 ] = single_sensor
+
+        # Additional sensors
+        if "additional_sensors" in self._db:
+            for additional in self._db["additional_sensors"]:
+                config_keys = additional.get("config_keys", [])
+                if not self._additional_data:
+                    continue
+                if not all(k in self._additional_data for k in config_keys):
+                    continue
+                source_sensor = None
+                for sensors in self._modbus_sensors:
+                    for s in sensors.values():
+                        if s.decoded_name == additional["source"].replace("_", ""):
+                            source_sensor = s
+                            break
+                if not source_sensor:
+                    _LOGGER.warning("Source sensor '%s' for additional sensor '%s' not found.", additional["source"], additional["name"])
+                    continue
+                single_sensor = SingleAdditionalSensor(
+                    name=additional["name"],
+                    parent={NAME: self._name, ID: self._id, MODEL: self._model},
+                    register_address=-1,
+                    base_address=base,
+                    unit_of_measurement=additional.get("unit_of_measurement", "m3"),
+                    state_class=additional.get("state_class", "measurement"),
+                    device_class=additional.get("device_class", "volume"),
+                    value_type=None,
+                    return_type=None,
+                    filters=[],
+                    message_bus=self._message_bus,
+                    config_helper=self._config_helper,
+                    ha_filter=additional.get("ha_filter", "round(2)"),
+                    formula=additional.get("formula", ""),
+                    context_config = { k: v for k,v in self._additional_data.items() if k in config_keys },
+                )
+                self._additional_sensors.append({single_sensor.decoded_name: single_sensor})
+                if source_sensor.decoded_name not in self._additional_sensors_by_source_name:
+                    self._additional_sensors_by_source_name[source_sensor.decoded_name] = []
+                self._additional_sensors_by_source_name[source_sensor.decoded_name].append(single_sensor)
         _LOGGER.info(
             "Available single sensors for %s: %s",
             self._name,
@@ -109,6 +154,18 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
                 ]
             ),
         )
+        if self._additional_sensors:
+            _LOGGER.info(
+                "Available additional sensors for %s: %s",
+                self._name,
+                ", ".join(
+                    [
+                        s.name
+                        for sensors in self._additional_sensors
+                        for s in sensors.values()
+                    ]
+                ),
+            )
         self._event_bus = event_bus
         self._event_bus.add_haonline_listener(target=self.set_payload_offline)
         try:
@@ -134,6 +191,9 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
         for sensors in self._modbus_sensors:
             for sensor in sensors.values():
                 sensor.send_ha_discovery()
+        for sensors in self._additional_sensors:
+            for sensor in sensors.values():
+                sensor.send_ha_discovery()
         return datetime.now()
 
     async def check_availability(self) -> None:
@@ -167,6 +227,15 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
                     self._id,
                 )
 
+    def _evaluate_formula(self, formula: str, context: dict) -> float:
+        """
+        Evaluate the formula for additional sensor using provided context.
+        Allowed names: X (value from source sensor), config (dict with config values)
+        """
+        code = compile(formula, "<string>", "eval")
+        return eval(code, {"__builtins__": {}}, context)
+    
+
     async def async_update(self, timestamp: float) -> Optional[float]:
         """Fetch state periodically and send to MQTT."""
         update_interval = self._update_interval.total_in_seconds
@@ -238,6 +307,16 @@ class ModbusSensor(BasicMqtt, AsyncUpdater, Filter):
                         )
                         decoded_value = None
                 sensor.set_value(value=decoded_value, timestamp=timestamp)
+                if self._additional_sensors and sensor.get_value() is not None:
+                    if sensor.decoded_name in self._additional_sensors_by_source_name:
+                        for additional_sensor in self._additional_sensors_by_source_name[sensor.decoded_name]:
+                            context = {
+                                "X": sensor.get_value(),
+                                **additional_sensor.context
+                            }
+                            value = self._evaluate_formula(additional_sensor.formula, context)
+                            additional_sensor.set_value(value=value, timestamp=timestamp)
+                            output[additional_sensor.decoded_name] = additional_sensor.state
                 output[sensor.decoded_name] = sensor.state
                 await self._event_bus.async_trigger_event(
                     event_type=MODBUS_SENSOR,

{boneio-0.11.0.dev5 → boneio-0.11.0.dev6}/boneio/modbus/single_sensor.py

@@ -158,3 +158,53 @@ class SingleSensor(Filter):
     @property
     def last_timestamp(self) -> float:
         return self._timestamp
+
+
+class SingleAdditionalSensor(SingleSensor):
+    def __init__(
+        self,
+        name: str,
+        parent: dict,
+        register_address: int,
+        base_address: int,
+        unit_of_measurement: str,
+        state_class: str,
+        device_class: str,
+        value_type: str,
+        return_type: str,
+        filters: list,
+        message_bus: MessageBus,
+        formula: str,
+        context_config: dict,
+        config_helper: ConfigHelper,
+        user_filters: Optional[list] = [],
+        ha_filter: str = "round(2)",
+    ) -> None:
+        super().__init__(
+            name=name,
+            parent=parent,
+            register_address=register_address,
+            base_address=base_address,
+            unit_of_measurement=unit_of_measurement,
+            state_class=state_class,
+            device_class=device_class,
+            value_type=value_type,
+            return_type=return_type,
+            filters=filters,
+            message_bus=message_bus,
+            config_helper=config_helper,
+            user_filters=user_filters,
+            ha_filter=ha_filter,
+        )
+        self._formula = formula
+        self._context_config = context_config
+
+    @property
+    def formula(self) -> str:
+        return self._formula
+
+    @property
+    def context(self) -> dict:
+        return self._context_config
+
+