boneio 1.0.0.dev7__tar.gz → 1.0.0.dev8__tar.gz

{boneio-1.0.0.dev7/boneio.egg-info → boneio-1.0.0.dev8}/PKG-INFO

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

boneio-1.0.0.dev8/boneio/components/output/basic.py

@@ -0,0 +1,229 @@
+"""Basic Output module (formerly BasicRelay)."""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+
+from boneio.const import COVER, LIGHT, NONE, OFF, ON, RELAY, STATE, SWITCH
+from boneio.core.messaging import BasicMqtt
+from boneio.models.events import OutputEvent
+from boneio.core.events import EventBus, async_track_point_in_time, utcnow
+from boneio.integration.interlock import SoftwareInterlockManager
+from boneio.core.utils import callback
+from boneio.models import OutputState
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BasicOutput(BasicMqtt):
+    """Basic output class (relay, switch, light, PWM).
+    
+    Formerly known as BasicRelay. This class represents any controllable
+    output device in the BoneIO system.
+    """
+    
+    # Subclasses (e.g. MCPOutput) will override these
+    _pin_id: int = -1
+    _expander_id: str | None = None
+
+    def __init__(
+        self,
+        id: str,
+        event_bus: EventBus,
+        topic_prefix: str,
+        name: str | None = None,
+        output_type=SWITCH,
+        restored_state: bool = False,
+        topic_type: str = RELAY,
+        interlock_manager: SoftwareInterlockManager | None = None,
+        interlock_groups: list[str] = [],
+        **kwargs,
+    ) -> None:
+        """Initialize Basic output."""
+        self._momentary_turn_on = kwargs.pop("momentary_turn_on", None)
+        self._momentary_turn_off = kwargs.pop("momentary_turn_off", None)
+        super().__init__(id=id, name=name or id, topic_type=topic_type, topic_prefix=topic_prefix, **kwargs)
+        self._output_type: str = output_type
+        self._event_bus: EventBus = event_bus
+        self._interlock_manager: SoftwareInterlockManager | None = interlock_manager
+        self._interlock_groups: list[str] = interlock_groups
+        if output_type == COVER:
+            self._momentary_turn_on = None
+            self._momentary_turn_off = None
+        self._state = ON if restored_state else OFF
+        self._momentary_action = None
+        self._last_timestamp = 0.0
+        self._loop = asyncio.get_running_loop()
+        
+        # HA area/room assignment (set by OutputManager)
+        self.area: str | None = None
+
+    def set_interlock(self, interlock_manager: SoftwareInterlockManager, interlock_groups: list[str]):
+        """Set interlock manager and groups."""
+        self._interlock_manager = interlock_manager
+        self._interlock_groups = interlock_groups
+
+    @property
+    def is_mcp_type(self) -> bool:
+        """Check if relay is mcp type."""
+        return False
+
+    @property
+    def output_type(self) -> str:
+        """HA type."""
+        return self._output_type
+
+    @property
+    def is_light(self) -> bool:
+        """Check if HA type is light"""
+        return self._output_type == LIGHT
+
+    @property
+    def id(self) -> str:
+        """Id of the relay.
+        Has to be trimmed out of spaces because of MQTT handling in HA."""
+        return self._id or str(self._pin_id) or ""
+
+    @property
+    def name(self) -> str:
+        """Not trimmed id."""
+        return self._name or str(self._pin_id) or ""
+    
+    @property
+    def pin_id(self) -> str | None:
+        """Pin ID as string for OutputState model."""
+        return str(self._pin_id) if self._pin_id is not None else None
+
+    @property
+    def state(self) -> str:
+        """Is relay active."""
+        return self._state
+    
+
+    @property
+    def last_timestamp(self) -> float:
+        return self._last_timestamp
+
+    def payload(self) -> dict[str, str | float | int | None]:
+        """Return payload for MQTT message.
+        
+        Returns:
+            Dictionary with state information for MQTT publishing.
+        """
+        return {STATE: self.state}
+
+    async def async_send_state(self, optimized_value: str | None = None) -> None:
+        """Send state to Mqtt on action asynchronously."""
+        if optimized_value:
+            state = optimized_value
+        else:
+            state = ON if self.is_active else OFF
+        self._state = state
+        if self.output_type not in (COVER, NONE):
+            self._message_bus.send_message(
+                topic=self._send_topic,
+                payload={STATE: state},
+                retain=True,
+            )
+        if optimized_value:
+            return
+        self._last_timestamp = time.time()
+        output_state = OutputState(
+            id=self.id,
+            name=self.name,
+            state=state,
+            type=self.output_type,
+            pin=self.pin_id,
+            timestamp=self.last_timestamp,
+            expander_id=self.expander_id,
+            area=self.area,
+            interlock_groups=self._interlock_groups,
+        )
+        
+        output_event = OutputEvent(
+            entity_id=self.id,
+            state=output_state,
+        )
+        self._event_bus.trigger_event(output_event)
+        
+
+    def check_interlock(self) -> bool:
+        if self._interlock_manager is not None and self._interlock_groups:
+            return self._interlock_manager.can_turn_on(self, self._interlock_groups)
+        return True
+
+    async def async_turn_on(self, timestamp=None) -> None:
+        """Turn on the relay asynchronously."""
+        can_turn_on = self.check_interlock()
+        if can_turn_on:
+            await self._loop.run_in_executor(None, self.turn_on, timestamp)
+        else:
+            _LOGGER.warning(f"Interlock active: cannot turn on {self.id}.")
+            #Workaround for HA is sendind state ON/OFF without physically changing the relay.
+            asyncio.create_task(self.async_send_state(optimized_value=ON))
+            await asyncio.sleep(0.01)
+        asyncio.create_task(self.async_send_state())
+        
+
+    async def async_turn_off(self, timestamp=None) -> None:
+        """Turn off the relay asynchronously."""
+        await self._loop.run_in_executor(None, self.turn_off, timestamp)
+        await self.async_send_state()
+
+
+    async def async_toggle(self, timestamp=None) -> None:
+        """Toggle relay."""
+        now = time.time()
+        _LOGGER.debug("Toggle relay %s, state: %s, at %s.", self.name, self.state, now)
+        if self.state == ON:
+            await self.async_turn_off(timestamp=timestamp)
+        else:
+            await self.async_turn_on(timestamp=timestamp)
+
+    def turn_on(self, timestamp=None) -> None:
+        """Call turn on action."""
+        raise NotImplementedError
+    
+    def turn_off(self, timestamp=None) -> None:
+        """Call turn off action."""
+        raise NotImplementedError
+
+    def set_brightness(self, value: int) -> None:
+        """Set brightness (only supported on PWM outputs like PCA9685)."""
+        _LOGGER.warning("set_brightness not supported for %s output type", self.output_type)
+
+    def _execute_momentary_turn(self, momentary_type: str) -> None:
+        """Execute momentary action."""
+        if self._momentary_action:
+            _LOGGER.debug("Cancelling momentary action for %s", self.name)
+            self._momentary_action()
+        (action, delayed_action) = (
+            (self.async_turn_off, self._momentary_turn_on)
+            if momentary_type == ON
+            else (self.async_turn_on, self._momentary_turn_off)
+        )
+        if delayed_action:
+            _LOGGER.debug("Applying momentary action for %s in %s", self.name, delayed_action.as_timedelta)
+            self._momentary_action = async_track_point_in_time(
+                loop=self._loop,
+                job=self._momentary_callback,
+                point_in_time=utcnow() + delayed_action.as_timedelta,
+                action=action,
+            )
+
+    @callback
+    async def _momentary_callback(self, timestamp, action):
+        _LOGGER.info("Momentary callback at %s for output %s", timestamp, self.name)
+        await action(timestamp=timestamp)
+        self._momentary_action = None
+
+    @property
+    def is_active(self) -> bool:
+        """Is active check."""
+        raise NotImplementedError
+
+    @property
+    def expander_id(self) -> str | None:
+        """Retrieve parent Expander ID (set by subclasses like MCPOutput)."""
+        return self._expander_id

{boneio-1.0.0.dev7 → boneio-1.0.0.dev8}/boneio/components/sensor/__init__.py

@@ -5,7 +5,9 @@ hardware drivers with business logic.
 """
 
 from boneio.components.sensor.system import SerialNumberSensor
+from boneio.components.sensor.virtual_energy import VirtualEnergySensor
 
 __all__ = [
     "SerialNumberSensor",
+    "VirtualEnergySensor",
 ]

boneio-1.0.0.dev8/boneio/components/sensor/virtual_energy.py

@@ -0,0 +1,292 @@
+"""Virtual Energy Sensor module.
+
+Creates virtual power/energy or water flow sensors linked to outputs.
+When the linked output is ON, the sensor calculates consumption based on
+configured power_usage or flow_rate.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from typing import TYPE_CHECKING
+
+from boneio.const import ON
+from boneio.models import SensorState
+from boneio.models.events import SensorEvent
+
+if TYPE_CHECKING:
+    from boneio.core.messaging.basic import MessageBus
+    from boneio.core.events.bus import EventBus
+    from boneio.components.output.basic import BasicOutput
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class VirtualEnergySensor:
+    """Virtual energy/water sensor linked to an output.
+    
+    Tracks energy consumption (Wh) or water consumption (L) based on
+    configured power_usage (W) or flow_rate (L/h) when the linked output is ON.
+    
+    Args:
+        id: Unique sensor identifier
+        name: Display name for Home Assistant
+        output: The output to track
+        message_bus: MessageBus for MQTT communication
+        loop: Event loop
+        topic_prefix: MQTT topic prefix
+        sensor_type: 'power' or 'water'
+        power_usage: Power consumption in Watts (for sensor_type='power')
+        flow_rate: Flow rate in L/h (for sensor_type='water')
+        area: Optional area ID for HA sub-device
+    """
+
+    def __init__(
+        self,
+        id: str,
+        name: str,
+        output: BasicOutput,
+        message_bus: MessageBus,
+        event_bus: "EventBus",
+        loop: asyncio.AbstractEventLoop,
+        topic_prefix: str,
+        sensor_type: str,
+        power_usage: float | None = None,
+        flow_rate: float | None = None,
+        area: str | None = None,
+    ):
+        self._id = id
+        self._name = name
+        self._output = output
+        self._loop = loop or asyncio.get_running_loop()
+        self._message_bus = message_bus
+        self._event_bus = event_bus
+        self._topic_prefix = topic_prefix
+        self._sensor_type = sensor_type
+        self._power_usage = power_usage
+        self._flow_rate = flow_rate
+        self._area = area
+        
+        self._virtual_sensors_task = None
+        
+        # Counters
+        self._energy_consumed_Wh = 0.0
+        self._water_consumed_L = 0.0
+        self._last_on_timestamp = time.time() if self._output.state == ON else None
+        
+        # MQTT topic for this sensor
+        self._sensor_topic = f"{topic_prefix}/energy/{id}"
+        
+        # Subscribe to restore state from MQTT
+        self._subscribe_restore_state()
+        
+        _LOGGER.info(
+            "Initialized VirtualEnergySensor: id=%s, name=%s, output=%s, type=%s",
+            id, name, output.id, sensor_type
+        )
+
+    @property
+    def id(self) -> str:
+        """Get sensor ID."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Get sensor name."""
+        return self._name
+
+    @property
+    def output_id(self) -> str:
+        """Get linked output ID."""
+        return self._output.id
+
+    @property
+    def sensor_type(self) -> str:
+        """Get sensor type ('power' or 'water')."""
+        return self._sensor_type
+
+    @property
+    def area(self) -> str | None:
+        """Get area ID."""
+        return self._area
+
+    @property
+    def power_usage(self) -> float | None:
+        """Get power usage in Watts."""
+        return self._power_usage
+
+    @property
+    def flow_rate(self) -> float | None:
+        """Get flow rate in L/h."""
+        return self._flow_rate
+
+    @property
+    def last_on_timestamp(self) -> float | None:
+        """Get timestamp when output was last turned ON."""
+        return self._last_on_timestamp
+
+    def start_tracking(self):
+        """Start tracking consumption (called when output turns ON)."""
+        self._last_on_timestamp = time.time()
+        if self._virtual_sensors_task is not None and not self._virtual_sensors_task.done():
+            return  # Already running
+        self._virtual_sensors_task = self._loop.create_task(self._tracking_loop())
+        _LOGGER.debug("Started tracking for virtual sensor %s", self._id)
+
+    def stop_tracking(self):
+        """Stop tracking consumption (called when output turns OFF)."""
+        # Update one last time before stopping
+        self._update_consumption()
+        self._last_on_timestamp = None
+        
+        if self._virtual_sensors_task is not None:
+            self._virtual_sensors_task.cancel()
+            self._virtual_sensors_task = None
+        
+        # Send final state
+        self._send_state()
+        _LOGGER.debug("Stopped tracking for virtual sensor %s", self._id)
+
+    async def _tracking_loop(self):
+        """Periodically update and send state every 30 seconds while output is ON."""
+        try:
+            while self._output.state == ON:
+                self._update_consumption()
+                self._send_state()
+                await asyncio.sleep(30)
+        except asyncio.CancelledError:
+            pass
+
+    def _update_consumption(self):
+        """Update consumption counters based on elapsed time."""
+        now = time.time()
+        if self._output.state == ON and self._last_on_timestamp is not None:
+            elapsed = now - self._last_on_timestamp
+            
+            if self._sensor_type == "power" and self._power_usage is not None:
+                self._energy_consumed_Wh += (self._power_usage * elapsed) / 3600.0
+                _LOGGER.debug(
+                    "Energy updated for %s: %.4f Wh",
+                    self._id, self._energy_consumed_Wh
+                )
+            elif self._sensor_type == "water" and self._flow_rate is not None:
+                self._water_consumed_L += (self._flow_rate * elapsed) / 3600.0
+                _LOGGER.debug(
+                    "Water updated for %s: %.4f L",
+                    self._id, self._water_consumed_L
+                )
+            
+            self._last_on_timestamp = now
+
+    def _subscribe_restore_state(self):
+        """Subscribe to retained MQTT topic to restore state on startup."""
+        async def on_message(_topic, payload):
+            try:
+                data = json.loads(payload)
+                if isinstance(data, dict):
+                    if "energy" in data:
+                        self._energy_consumed_Wh = float(data["energy"])
+                        _LOGGER.info(
+                            "Restored energy state for %s: %.4f Wh",
+                            self._id, self._energy_consumed_Wh
+                        )
+                    if "water" in data:
+                        self._water_consumed_L = float(data["water"])
+                        _LOGGER.info(
+                            "Restored water state for %s: %.4f L",
+                            self._id, self._water_consumed_L
+                        )
+            except Exception as e:
+                _LOGGER.warning("Failed to restore state for %s: %s", self._id, e)
+            finally:
+                await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
+        
+        if self._message_bus is not None:
+            asyncio.create_task(
+                self._message_bus.subscribe_and_listen(self._sensor_topic, on_message)
+            )
+
+    def get_current_power(self) -> float:
+        """Get current power usage in W (0 if output is OFF)."""
+        if self._sensor_type != "power":
+            return 0.0
+        return (self._power_usage or 0.0) if self._output.state == ON else 0.0
+
+    def get_total_energy(self) -> float:
+        """Get total energy consumed in Wh."""
+        return round(self._energy_consumed_Wh, 3)
+
+    def get_current_flow_rate(self) -> float:
+        """Get current flow rate in L/h (0 if output is OFF)."""
+        if self._sensor_type != "water":
+            return 0.0
+        return (self._flow_rate or 0.0) if self._output.state == ON else 0.0
+
+    def get_total_water(self) -> float:
+        """Get total water consumed in L."""
+        return round(self._water_consumed_L, 3)
+
+    def _send_state(self):
+        """Send current state to MQTT and EventBus (for WebSocket/frontend)."""
+        payload = {}
+        timestamp = int(time.time())
+        
+        if self._sensor_type == "power":
+            payload["power"] = self.get_current_power()
+            payload["energy"] = self.get_total_energy()
+            
+            # Send SensorEvents to frontend via EventBus
+            self._event_bus.trigger_event(SensorEvent(
+                entity_id=f"{self._id}_power",
+                state=SensorState(
+                    id=f"{self._id}_power",
+                    name=f"{self._name} Power",
+                    state=self.get_current_power(),
+                    unit="W",
+                    timestamp=timestamp,
+                )
+            ))
+            self._event_bus.trigger_event(SensorEvent(
+                entity_id=f"{self._id}_energy",
+                state=SensorState(
+                    id=f"{self._id}_energy",
+                    name=f"{self._name} Energy",
+                    state=self.get_total_energy(),
+                    unit="Wh",
+                    timestamp=timestamp,
+                )
+            ))
+        elif self._sensor_type == "water":
+            payload["volume_flow_rate"] = self.get_current_flow_rate()
+            payload["water"] = self.get_total_water()
+            
+            # Send SensorEvents to frontend via EventBus
+            self._event_bus.trigger_event(SensorEvent(
+                entity_id=f"{self._id}_flow",
+                state=SensorState(
+                    id=f"{self._id}_flow",
+                    name=f"{self._name} Flow Rate",
+                    state=self.get_current_flow_rate(),
+                    unit="L/h",
+                    timestamp=timestamp,
+                )
+            ))
+            self._event_bus.trigger_event(SensorEvent(
+                entity_id=f"{self._id}_water",
+                state=SensorState(
+                    id=f"{self._id}_water",
+                    name=f"{self._name} Water",
+                    state=self.get_total_water(),
+                    unit="L",
+                    timestamp=timestamp,
+                )
+            ))
+        
+        self._message_bus.send_message(
+            topic=self._sensor_topic,
+            payload=payload,
+            retain=True,
+        )
+        _LOGGER.debug("Sent state for %s: %s", self._id, payload)

{boneio-1.0.0.dev7 → boneio-1.0.0.dev8}/boneio/const.py

@@ -166,6 +166,7 @@ cover_actions = {
 }
 
 INA219 = "ina219"
+VIRTUAL_ENERGY_SENSOR = "virtual_energy_sensor"
 PINS = {
     # Based on boneio/boards/0.8/input.yaml
     "P8_37": {"chip": 1, "line": 14},

{boneio-1.0.0.dev7 → boneio-1.0.0.dev8}/boneio/core/config/config_helper.py

@@ -38,6 +38,7 @@ class ConfigHelper:
         network_info: dict = {},
         is_web_active: bool = False,
         web_port: int = 8090,
+        nginx_proxy_port: int | None = None,
         config_file_path: str | None = None,
     ):
         self._name = name
@@ -47,6 +48,7 @@ class ConfigHelper:
         self._ha_discovery_prefix = ha_discovery_prefix
         self._device_type = device_type
         self._web_port = web_port
+        self._nginx_proxy_port = nginx_proxy_port
         self._fetch_old_discovery = None
         self._autodiscovery_messages = {
             SWITCH: {},
@@ -113,6 +115,16 @@ class ConfigHelper:
     def web_port(self) -> int:
         return self._web_port
 
+    @property
+    def nginx_proxy_port(self) -> int | None:
+        """Get nginx proxy port if configured."""
+        return self._nginx_proxy_port
+
+    @property
+    def ha_configuration_port(self) -> int:
+        """Get port for HA discovery URL. Uses nginx_proxy_port if set, otherwise web_port."""
+        return self._nginx_proxy_port if self._nginx_proxy_port else self._web_port
+
     @property
     def topic_prefix(self) -> str:
         return self._topic_prefix

{boneio-1.0.0.dev7 → boneio-1.0.0.dev8}/boneio/core/config/yaml_util.py

@@ -892,6 +892,21 @@ def update_config_section(config_file: str, section: str, data: dict | list) ->
     
     _LOGGER.info(f"Updating section '{section}' with data: {data}")
     
+    # Special handling for mcp23017 - convert hex strings to integers
+    # This ensures YAML writes them as integers which are then read back as hex
+    if section == 'mcp23017' and isinstance(data, list):
+        for entry in data:
+            if isinstance(entry, dict) and 'address' in entry:
+                addr = entry['address']
+                if isinstance(addr, str):
+                    if addr.startswith('0x') or addr.startswith('0X'):
+                        entry['address'] = int(addr, 16)
+                    else:
+                        try:
+                            entry['address'] = int(addr, 10)
+                        except ValueError:
+                            pass  # Keep as string if conversion fails
+    
     # Strip default values to keep YAML clean
     cleaned_data = strip_default_values(data, {}, section)
     _LOGGER.info(f"Cleaned data (defaults removed): {cleaned_data}")

{boneio-1.0.0.dev7 → boneio-1.0.0.dev8}/boneio/core/manager/inputs.py

@@ -422,8 +422,6 @@ class InputManager:
         - Removing deleted inputs (from internal state and HA Discovery)
         - Adding inputs that use already-registered GPIO pins (e.g., moving from event to binary_sensor)
         """
-        import asyncio
-        
         _LOGGER.info("Reloading input configuration")
         
         # Get new config
@@ -491,9 +489,42 @@ class InputManager:
         # - Add new inputs if their GPIO pin is already registered
         self._configure_inputs(reload_config=True)
         
-        # Signal WebSocket handlers to re-send all input states to clients
-        from boneio.models.events import InputsReloadedEvent
-        self._manager._event_bus.trigger_event(InputsReloadedEvent())
+        # Broadcast all input states to WebSocket clients
+        # Global listeners will receive these events for all inputs (including new ones)
+        self._broadcast_all_input_states()
+    
+    def _broadcast_all_input_states(self) -> None:
+        """Broadcast current state of all inputs via WebSocket.
+        
+        This is called after reload to ensure frontend receives
+        the updated input list immediately.
+        """
+        import time
+        from boneio.models import InputState
+        from boneio.models.events import InputEvent
+        
+        timestamp = time.time()
+        
+        for input_ in self._inputs.values():
+            try:
+                input_state = InputState(
+                    name=input_.name,
+                    state=input_.last_state,
+                    type=input_.input_type,
+                    pin=input_.pin,
+                    timestamp=timestamp,
+                    boneio_input=input_.boneio_input,
+                    area=input_.area
+                )
+                event = InputEvent(
+                    entity_id=input_.id,
+                    state=input_state,
+                    click_type=None,
+                    duration=None
+                )
+                self._manager._event_bus.trigger_event(event)
+            except Exception as e:
+                _LOGGER.debug("Error broadcasting input state %s: %s", input_.id, e)
     
     def _remove_input_ha_discovery(self, input_id: str, old_area: str | None = None) -> None:
         """Remove HA Discovery entries for an input.
@@ -591,7 +622,6 @@ class InputManager:
         # Get the input instance and retrieve actions for this click type
         input_instance = self._inputs.get(event.entity_id)
         if not input_instance:
-            print(self._inputs)
             _LOGGER.warning("Input %s not found for event handling", event.entity_id)
             return