boneIO 0.11.0.dev4__tar.gz → 0.11.0.dev5__tar.gz

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

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

{boneio-0.11.0.dev4 → boneio-0.11.0.dev5}/boneio/cover/cover.py

@@ -202,14 +202,14 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             return
         _LOGGER.info("Opening cover %s.", self._id)
         await self.run_cover(current_operation=OPENING)
-        self._send_message(topic=f"{self._send_topic}/state", payload=OPENING)
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=OPENING)
 
     async def close(self) -> None:
         if self._position <= 0:
             return
         _LOGGER.info("Closing cover %s.", self._id)
         await self.run_cover(current_operation=CLOSING)
-        self._send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
 
     async def set_cover_position(self, position: int) -> None:
         if not 0 <= position <= 100:
@@ -281,8 +281,8 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             **json_position
         )
         await self._event_bus.async_trigger_event(event_type="cover", entity_id=self.id, event=event)
-        self._send_message(topic=f"{self._send_topic}/state", payload=state)
-        self._send_message(topic=f"{self._send_topic}/pos", payload=json_position)
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state)
+        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json_position)
 
     async def send_state_and_save(self, json_position: PositionDict):
         await self.send_state(self.state, json_position)

{boneio-0.11.0.dev4 → boneio-0.11.0.dev5}/boneio/cover/previous.py

@@ -150,11 +150,11 @@ class PreviousCover(BasicMqtt):
 
     def send_state(self) -> None:
         """Send state of cover to mqtt."""
-        self._send_message(
+        self._message_bus.send_message(
             topic=f"{self._send_topic}/state", payload=self.state
         )
         pos = round(self._position, 0)
-        self._send_message(topic=f"{self._send_topic}/pos", payload={ "position": str(pos) })
+        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload={ "position": str(pos) })
         self._state_save(value={"position": pos})
 
     def _stop_cover(self, on_exit=False) -> None:
@@ -201,7 +201,7 @@ class PreviousCover(BasicMqtt):
                 rounded_pos = 100
             elif rounded_pos < 0:
                 rounded_pos = 0
-        self._send_message(topic=f"{self._send_topic}/pos", payload={"position": str(rounded_pos)})
+        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload={"position": str(rounded_pos)})
         asyncio.create_task(self.async_send_state())
         if rounded_pos == self._set_position or (
             self._set_position is None
@@ -224,7 +224,7 @@ class PreviousCover(BasicMqtt):
         _LOGGER.info("Closing cover %s.", self._id)
 
         self._requested_closing = True
-        self._send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
         await self.run_cover(
             current_operation=CLOSING,
         )
@@ -239,7 +239,7 @@ class PreviousCover(BasicMqtt):
         _LOGGER.info("Opening cover %s.", self._id)
 
         self._requested_closing = False
-        self._send_message(topic=f"{self._send_topic}/state", payload=OPENING)
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=OPENING)
         await self.run_cover(
             current_operation=OPENING,
         )
@@ -261,7 +261,7 @@ class PreviousCover(BasicMqtt):
             set_position,
             current_operation,
         )
-        self._send_message(
+        self._message_bus.send_message(
             topic=f"{self._send_topic}/state", payload=current_operation
         )
         await self.run_cover(

{boneio-0.11.0.dev4 → boneio-0.11.0.dev5}/boneio/group/output.py

@@ -78,6 +78,6 @@ class OutputGroup(BasicRelay):
 
     async def async_send_state(self) -> None:
         """Send state to Mqtt on action."""
-        self._send_message(
+        self._message_bus.send_message(
             topic=self._send_topic, payload=self.payload(), retain=True
         )

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

@@ -26,6 +26,7 @@ def ha_availabilty_message(
     id: str,
     name: str,
     topic: str = "boneIO",
+    device_name: str = "boneIO",
     device_type: str = INPUT,
     model: str = "boneIO Relay Board",
     web_url: str | None = None,
@@ -42,16 +43,36 @@ def ha_availabilty_message(
             "identifiers": [topic],
             "manufacturer": "boneIO",
             "model": model,
-            "name": f"boneIO {topic}",
+            "name": device_name,
             "sw_version": __version__,
             **web_url
         },
         "name": name,
         "state_topic": f"{topic}/{device_type}/{id}",
         "unique_id": f"{topic}{device_type}{id}",
+        # "object_id": f"{topic}{device_type}{id}",
         **kwargs,
     }
 
+def ha_virtual_energy_sensor_discovery_message(
+    topic: str,
+    relay_id: str,
+    **kwargs
+) -> dict[str, str]:
+    """
+    Generate MQTT autodiscovery messages for Home Assistant for virtual power and energy sensors.
+    Returns two dicts:
+     - sensor.<id>_power: current power in W
+     - sensor.<id>_energy: total energy in Wh
+    """
+    # Power sensor discovery
+    msg = ha_availabilty_message(
+        state_topic=f"{topic}/energy/{relay_id}",
+        topic=topic,
+        **kwargs,
+    )
+    return msg
+
 
 def ha_light_availabilty_message(id: str, topic: str = "boneIO", device_type: str = RELAY, **kwargs):
     """Create LIGHT availability topic for HA."""
@@ -124,10 +145,9 @@ def ha_adc_sensor_availabilty_message(**kwargs):
     return msg
 
 
-def ha_sensor_availabilty_message(unit_of_measurement: str = None, **kwargs):
-    msg = ha_availabilty_message(device_type=SENSOR, **kwargs)
-    if not unit_of_measurement:
-        return msg
+def ha_sensor_availabilty_message(device_type: str = SENSOR, **kwargs):
+    msg = ha_availabilty_message(device_type=device_type, **kwargs)
+    return msg
 
 
 def ha_binary_sensor_availabilty_message(id: str, name: str, device_class: str, topic: str = "boneIO", model: str = "boneIO Relay Board", **kwargs):

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

@@ -61,6 +61,7 @@ from boneio.helper.ha_discovery import (
     ha_cover_availabilty_message,
     ha_cover_with_tilt_availabilty_message,
     ha_sensor_availabilty_message,
+    ha_virtual_energy_sensor_discovery_message,
 )
 from boneio.helper.onewire import (
     DS2482,
@@ -72,6 +73,7 @@ from boneio.helper.onewire import (
 from boneio.helper.pcf8575 import PCF8575
 from boneio.helper.timeperiod import TimePeriod
 from boneio.input import GpioEventButtonNew, GpioEventButtonOld
+from boneio.message_bus.basic import MessageBus
 from boneio.sensor import (
     DallasSensorDS2482,
     GpioInputBinarySensorNew,
@@ -92,7 +94,7 @@ from boneio.sensor import GpioADCSensor, initialize_adc
 _LOGGER = logging.getLogger(__name__)
 
 
-def create_adc(manager: Manager, topic_prefix: str, adc_list: list = []):
+def create_adc(manager: Manager, message_bus: MessageBus, topic_prefix: str, adc_list: list = []):
     """Create ADC sensor."""
 
     initialize_adc()
@@ -108,7 +110,7 @@ def create_adc(manager: Manager, topic_prefix: str, adc_list: list = []):
                 pin=pin,
                 name=name,
                 manager=manager,
-                send_message=manager.send_message,
+                message_bus=message_bus,
                 topic_prefix=topic_prefix,
                 update_interval=gpio.get(
                     UPDATE_INTERVAL, TimePeriod(seconds=60)
@@ -129,6 +131,7 @@ def create_adc(manager: Manager, topic_prefix: str, adc_list: list = []):
 
 def create_temp_sensor(
     manager: Manager,
+    message_bus: MessageBus,
     topic_prefix: str,
     sensor_type: str,
     i2cbusio: I2C,
@@ -152,7 +155,7 @@ def create_temp_sensor(
             i2c=i2cbusio,
             address=config[ADDRESS],
             manager=manager,
-            send_message=manager.send_message,
+            message_bus=message_bus,
             topic_prefix=topic_prefix,
             update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
             filters=config.get(FILTERS, []),
@@ -173,6 +176,7 @@ def create_temp_sensor(
 
 def create_serial_number_sensor(
     manager: Manager,
+    message_bus: MessageBus,
     topic_prefix: str,
 ):
     """Create Serial number sensor in manager."""
@@ -180,7 +184,7 @@ def create_serial_number_sensor(
         id="serial_number",
         name="Serial number",
         manager=manager,
-        send_message=manager.send_message,
+        message_bus=message_bus,
         topic_prefix=topic_prefix,
     )
     manager.send_ha_autodiscovery(
@@ -223,7 +227,7 @@ def create_expander(
     return grouped_outputs
 
 
-def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> dict:
+def create_modbus_sensors(manager: Manager, message_bus: MessageBus, sensors, **kwargs) -> dict:
     """Create Modbus sensor for each device."""
     from boneio.modbus.sensor import ModbusSensor
 
@@ -238,7 +242,7 @@ def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> dict:
                 name=name,
                 manager=manager,
                 model=sensor[MODEL],
-                send_message=manager.send_message,
+                message_bus=message_bus,
                 update_interval=sensor.get(
                     UPDATE_INTERVAL, TimePeriod(seconds=60)
                 ),
@@ -276,7 +280,7 @@ def output_chooser(output_kind: str, config):
 
 
 def configure_output_group(
-    manager: Manager,
+    message_bus: MessageBus,
     topic_prefix: str,
     config: dict,
     **kwargs,
@@ -285,7 +289,7 @@ def configure_output_group(
     _id = config.pop(ID)
 
     output = OutputGroup(
-        send_message=manager.send_message,
+        message_bus=message_bus,
         topic_prefix=topic_prefix,
         id=_id,
         callback=lambda: None,
@@ -297,6 +301,7 @@ def configure_output_group(
 
 def configure_relay(
     manager: Manager,
+    message_bus: MessageBus,
     state_manager: StateManager,
     topic_prefix: str,
     relay_id: str,
@@ -367,19 +372,12 @@ def configure_relay(
         )
         return
 
-    # # Create async callback wrapper
-    # async def relay_callback_wrapper(event: OutputState):
-    #     await relay_callback(
-    #         expander_id=expander_id,
-    #         event=event,
-    #         restore_state=False if output_type == NONE else restore_state,
-    #     )
     interlock_groups = config.get("interlock_group", [])
     if isinstance(interlock_groups, str):
         interlock_groups = [interlock_groups]
 
     relay = getattr(output, "OutputClass")(
-        send_message=manager.send_message,
+        message_bus=message_bus,
         topic_prefix=topic_prefix,
         id=relay_id,
         restored_state=restored_state,
@@ -389,10 +387,34 @@ def configure_relay(
         **config,
         **kwargs,
         **extra_args,
-        # callback=relay_callback_wrapper,
     )
     manager._interlock_manager.register(relay, interlock_groups)
     manager.grouped_outputs[expander_id][relay_id] = relay
+    if relay.virtual_power_usage is not None:
+        manager.send_ha_autodiscovery(
+            id=f"{relay_id}_virtual_power",
+            relay_id=relay_id,
+            name=f"{name} Virtual Power",
+            ha_type="sensor",
+            device_type="energy",
+            availability_msg_func=ha_virtual_energy_sensor_discovery_message,
+            unit_of_measurement="W",
+            device_class="power",
+            state_class="measurement",
+            value_template="{{ value_json.power }}"
+        )
+        manager.send_ha_autodiscovery(
+            id=f"{relay_id}_virtual_energy",
+            relay_id=relay_id,
+            name=f"{name} Virtual Energy",
+            ha_type="sensor",
+            device_type="energy",
+            availability_msg_func=ha_virtual_energy_sensor_discovery_message,
+            unit_of_measurement="Wh",
+            device_class="energy",
+            state_class="total_increasing",
+            value_template="{{ value_json.energy }}"
+        )
     return relay
 
 
@@ -493,7 +515,7 @@ def configure_binary_sensor(
 
 
 def configure_cover(
-    manager: Manager,
+    message_bus: MessageBus,
     cover_id: str,
     state_manager: StateManager,
     send_ha_autodiscovery: Callable,
@@ -522,7 +544,7 @@ def configure_cover(
         cover = VenetianCover(
             id=cover_id,
             state_save=state_save,
-            send_message=manager.send_message,
+            message_bus=message_bus,
             restored_state=restored_state,
             tilt_duration=tilt_duration,
             actuator_activation_duration=config.get("actuator_activation_duration", TimePeriod(milliseconds=0)),
@@ -539,7 +561,7 @@ def configure_cover(
         cover = TimeBasedCover(
             id=cover_id,
             state_save=state_save,
-            send_message=manager.send_message,
+            message_bus=message_bus,
             restored_state=restored_state,
             **kwargs,
         )
@@ -554,7 +576,7 @@ def configure_cover(
         cover = PreviousCover(
             id=cover_id,
             state_save=state_save,
-            send_message=manager.send_message,
+            message_bus=message_bus,
             restored_state=restored_state,
             **kwargs,
         )
@@ -604,6 +626,7 @@ def find_onewire_devices(
 
 def create_dallas_sensor(
     manager: Manager,
+    message_bus: MessageBus,
     address: OneWireAddress,
     config: dict,
     **kwargs,
@@ -614,11 +637,11 @@ def create_dallas_sensor(
     cls = DallasSensorDS2482 if bus else DallasSensorW1
     sensor = cls(
         manager=manager,
+        message_bus=message_bus,
         address=address,
         id=id,
         name=name,
         update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
-        send_message=manager.send_message,
         filters=config.get(FILTERS, []),
         **kwargs,
     )
@@ -635,6 +658,7 @@ def create_dallas_sensor(
 
 def create_ina219_sensor(
     manager: Manager,
+    message_bus: MessageBus,
     topic_prefix: str,
     config: dict = {},
 ):
@@ -649,7 +673,7 @@ def create_ina219_sensor(
             address=address,
             sensors=config.get("sensors", []),
             manager=manager,
-            send_message=manager.send_message,
+            message_bus=message_bus,
             topic_prefix=topic_prefix,
             update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
         )

{boneio-0.11.0.dev4 → boneio-0.11.0.dev5}/boneio/helper/mqtt.py

@@ -2,9 +2,8 @@
 
 from __future__ import annotations
 
-
-from typing import Callable, Union, Optional
 from boneio.helper.util import strip_accents
+from boneio.message_bus.basic import MessageBus
 
 
 class BasicMqtt:
@@ -15,16 +14,14 @@ class BasicMqtt:
         id: str,
         topic_prefix: str,
         name: str,
-        send_message: Callable[
-            [str, Union[str, int, dict, None], Optional[bool]], None
-        ],
+        message_bus: MessageBus,
         topic_type: str,
         **kwargs,
     ):
         """Initialize module."""
         self._id = id.replace(" ", "")
         self._name = name
-        self._send_message = send_message
+        self._message_bus = message_bus
         topic_id = strip_accents(self.id)
         self._send_topic = f"{topic_prefix}/{topic_type}/{topic_id}"
 

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

@@ -513,6 +513,79 @@ class CustomValidator(Validator):
     def _normalize_coerce_actions_output(self, value):
         return str(value).upper()
 
+    def _normalize_coerce_power_value_to_watts(self, value):
+        """
+        Parse a power or energy value and return it in watts (W).
+        Accepts:
+        - Numeric values (int, float)
+        - Strings with units: 'W', 'kW', 'kWh', 'MW', 'mW', etc.
+        - For 'kWh' (kilowatt-hour), returns equivalent average power in W (1kWh = 1000W for 1h)
+        - For 'kW', 'MW', etc., converts to W
+        Example:
+            9 -> 9.0
+            '9W' -> 9.0
+            '1kW' -> 1000.0
+            '1kWh' -> 1000.0
+            '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)):
+            return float(value)
+        if not isinstance(value, str):
+            raise ValueError(f"Unsupported type for power value: {type(value)}")
+        value = value.strip().replace(' ', '').lower()
+        pattern = r"^([-+]?[0-9]*\.?[0-9]+)([a-z]*)$"
+        match = re.match(pattern, value)
+        if not match:
+            _LOGGER.warning(f"Could not parse power value: {value}")
+            raise ValueError(f"Could not parse power value: {value}")
+        num, unit = match.groups()
+        num = float(num)
+        multiplier = 1.0
+        if unit in ('w', ''):
+            multiplier = 1.0
+        elif unit == 'kw':
+            multiplier = 1000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'gw':
+            multiplier = 1_000_000_000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'kwh':
+            # 1 kWh = 1000 W (for 1h). For config, treat as 1000W average.
+            multiplier = 1000.0
+        elif unit == 'mwh':
+            multiplier = 1_000_000.0
+        elif unit == 'gwh':
+            multiplier = 1_000_000_000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'wh':
+            multiplier = 1.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        elif unit == 'mw':
+            multiplier = 1_000_000.0
+        else:
+            _LOGGER.warning(f"Unknown unit for power value: {unit}")
+            raise ValueError(f"Unknown unit for power value: {unit}")
+        result = num * multiplier
+        _LOGGER.debug(f"Parsed power value '{value}' as {result} W")
+        return result
+
+
 
 def load_config_from_string(config_str: str) -> dict:
     """Load config from string."""
@@ -549,3 +622,5 @@ def load_config_from_file(config_file: str):
         _LOGGER.warning("Missing yaml file. %s", config_file)
         return None
     return load_config_from_string(config_yaml)
+
+