boneIO 1.0.0.dev6__tar.gz → 1.0.0.dev8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.0.0.dev6
+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.dev6 → boneio-1.0.0.dev8}/boneio/components/cover/previous.py

@@ -340,5 +340,15 @@ class PreviousCover(BasicMqtt):
         return "previous"
     
     def update_config_times(self, config: dict) -> None:
-        self._open_duration = config.get("open_duration", self._open_duration)
-        self._close_duration = config.get("close_duration", self._close_duration)
+        """Update cover timing configuration.
+        
+        Args:
+            config: Dictionary with timing values as TimePeriod objects.
+                   Keys: open_time, close_time
+        """
+        if "open_time" in config:
+            self._open_time = config["open_time"]
+            self._open = RelayHelper(relay=self._open.relay, time=config["open_time"])
+        if "close_time" in config:
+            self._close_time = config["close_time"]
+            self._close = RelayHelper(relay=self._close.relay, time=config["close_time"])

{boneio-1.0.0.dev6 → boneio-1.0.0.dev8}/boneio/components/cover/time_based.py

@@ -111,6 +111,14 @@ class TimeBasedCover(BaseCover):
         return "time"
 
     def update_config_times(self, config: dict) -> None:
-        self._open_duration = config.get("open_duration", self._open_duration)
-        self._close_duration = config.get("close_duration", self._close_duration)
+        """Update cover timing configuration.
+        
+        Args:
+            config: Dictionary with timing values as TimePeriod objects.
+                   Keys: open_time, close_time
+        """
+        if "open_time" in config:
+            self._open_time = config["open_time"].total_milliseconds
+        if "close_time" in config:
+            self._close_time = config["close_time"].total_milliseconds
     

{boneio-1.0.0.dev6 → boneio-1.0.0.dev8}/boneio/components/cover/venetian.py

@@ -260,12 +260,18 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         await self.set_tilt(tilt_position=0)
 
     def update_config_times(self, config: dict) -> None:
-        self._open_duration = config.get("open_duration", self._open_duration)
-        self._close_duration = config.get("close_duration", self._close_duration)
-        self._actuator_activation_duration = config.get(
-            "actuator_activation_duration", self._actuator_activation_duration
-        )
-        self._tilt_duration = config.get("tilt_duration", self._tilt_duration)
+        """Update cover timing configuration.
+        
+        Args:
+            config: Dictionary with timing values as TimePeriod objects.
+                   Keys: open_time, close_time, tilt_duration
+        """
+        if "open_time" in config:
+            self._open_time = config["open_time"].total_milliseconds
+        if "close_time" in config:
+            self._close_time = config["close_time"].total_milliseconds
+        if "tilt_duration" in config and config["tilt_duration"]:
+            self._tilt_duration = config["tilt_duration"].total_milliseconds
 
     async def run_cover(
         self,

{boneio-1.0.0.dev6 → boneio-1.0.0.dev8}/boneio/components/group/output_group.py

@@ -86,20 +86,26 @@ class OutputGroup(BasicOutput):
     async def async_turn_on(self, timestamp=None) -> None:
         """Turn on all members in the group.
         
+        Executes turn_on sequentially to prevent I2C bus contention
+        when multiple outputs are on the same GPIO expander.
+        
         Args:
             timestamp: Optional timestamp for the operation
         """
         for x in self._group_members:
-            self._loop.create_task(x.async_turn_on(timestamp=timestamp))
+            await x.async_turn_on(timestamp=timestamp)
 
     async def async_turn_off(self, timestamp=None) -> None:
         """Turn off all members in the group.
         
+        Executes turn_off sequentially to prevent I2C bus contention
+        when multiple outputs are on the same GPIO expander.
+        
         Args:
             timestamp: Optional timestamp for the operation
         """
         for x in self._group_members:
-            self._loop.create_task(x.async_turn_off(timestamp=timestamp))
+            await x.async_turn_off(timestamp=timestamp)
 
     @property
     def is_active(self) -> bool:

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.dev6 → 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.dev6 → 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.dev6 → 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