boneIO 1.1.0.dev2__py3-none-any.whl → 1.1.0.dev4__py3-none-any.whl

boneio/core/config/config_helper.py

@@ -45,6 +45,7 @@ class ConfigHelper:
         config_file_path: str | None = None,
         send_boneio_autodiscovery: bool = True,
         receive_boneio_autodiscovery: bool = True,
+        update_channel: str = "stable",
     ):
         self._name = name
         
@@ -63,6 +64,7 @@ class ConfigHelper:
         self._ha_discovery_prefix = ha_discovery_prefix
         self._send_boneio_autodiscovery = send_boneio_autodiscovery
         self._receive_boneio_autodiscovery = receive_boneio_autodiscovery
+        self._update_channel = update_channel
         self._device_type = device_type
         self._web_port = web_port
         self._proxy_port = proxy_port
@@ -79,6 +81,7 @@ class ConfigHelper:
             TEXT_SENSOR: {},
             SELECT: {},
             NUMERIC: {},
+            "update": {}
         }
         self.manager_ready: bool = False
         self._network_info = network_info
@@ -181,6 +184,11 @@ class ConfigHelper:
         """Check if BoneIO autodiscovery receiving is enabled."""
         return self._receive_boneio_autodiscovery
 
+    @property
+    def update_channel(self) -> str:
+        """Get update channel (stable or dev)."""
+        return self._update_channel
+
     @property
     def device_type(self) -> str:
         return self._device_type

boneio/core/manager/inputs.py

@@ -687,6 +687,14 @@ class InputManager:
         # Send event to MQTT for Home Assistant
         self._publish_input_event_to_mqtt(input_instance, event)
         
+        # If publish_only is set, skip action execution (used for initial state sync)
+        if event.publish_only:
+            _LOGGER.debug(
+                "Skipping action execution for %s (publish_only=True)",
+                event.entity_id
+            )
+            return
+        
         # Execute actions with duration threshold support
         if actions and event.click_type == LONG:
             # Get executed_actions from detector state

boneio/core/manager/manager.py

@@ -39,6 +39,7 @@ from boneio.core.manager.modbus import ModbusManager
 from boneio.core.manager.outputs import OutputManager
 from boneio.core.manager.sensors import SensorManager
 from boneio.core.manager.remote import RemoteDeviceManager
+from boneio.core.manager.update import UpdateManager
 from boneio.core.discovery import BlackDiscoveryPublisher
 from boneio.core.messaging import MessageBus
 from boneio.core.state import StateManager
@@ -204,6 +205,11 @@ class Manager:
             message_bus=message_bus,
         )
         
+        # 9. UpdateManager (checks for software updates and publishes to HA)
+        self.update_manager = UpdateManager(
+            manager=self,
+        )
+        
         # Configure virtual energy sensors (must be after outputs are initialized)
         self.sensors.configure_virtual_energy_sensors()
         
@@ -323,6 +329,7 @@ class Manager:
         await self.sensors.send_ha_autodiscovery()
         await self.modbus.send_ha_autodiscovery()
         await self.display.send_ha_autodiscovery()
+        await self.update_manager.send_ha_autodiscovery()
 
     def send_ha_autodiscovery(
         self,
@@ -380,6 +387,9 @@ class Manager:
             availability_msg_func = ha_cover_availabilty_message
         elif ha_type == BUTTON:
             availability_msg_func = ha_button_availabilty_message
+        elif ha_type == "update":
+            from boneio.integration.homeassistant import ha_update_availability_message
+            availability_msg_func = ha_update_availability_message
         
         # Use availability_msg_func from kwargs if provided (for sensors)
         if 'availability_msg_func' in kwargs:
@@ -400,6 +410,16 @@ class Manager:
             )
             self.send_message(topic=topic, payload=payload, retain=True)
 
+    async def _handle_update_install_command(self, topic: str, payload: str) -> None:
+        """Handle update install command from Home Assistant.
+        
+        Args:
+            topic: MQTT topic
+            payload: MQTT payload (should be "INSTALL")
+        """
+        _LOGGER.info("Received update install command: %s", payload)
+        await self.update_manager.handle_install_command(payload)
+
     def parse_actions(self, pin: str, actions: dict) -> dict:
         """Parse actions configuration.
         
@@ -698,7 +718,7 @@ class Manager:
                 )
             
             elif action == REMOTE_OUTPUT:
-                # Control output on remote device
+                # Control output on remote device (supports ESPHome lights with brightness/color and WLED effects)
                 remote_device_id = action_definition.get("remote_device")
                 output_id = action_definition.get("output_id")
                 action_output = action_definition.get("action_output", "TOGGLE")
@@ -706,6 +726,14 @@ class Manager:
                     device_id=remote_device_id,
                     output_id=output_id,
                     action=action_output,
+                    brightness=action_definition.get("brightness"),
+                    color_temp=action_definition.get("color_temp"),
+                    rgb=action_definition.get("rgb"),
+                    transition=action_definition.get("transition"),
+                    effect=action_definition.get("effect"),
+                    palette=action_definition.get("palette"),
+                    effect_speed=action_definition.get("effect_speed"),
+                    effect_intensity=action_definition.get("effect_intensity"),
                 )
             
             elif action == REMOTE_COVER:
@@ -740,16 +768,17 @@ class Manager:
         configure_logger(log_config, debug=0)
         _LOGGER.info("Logger configuration reloaded successfully")
 
-    def _reload_remote_devices(self) -> None:
+    async def _reload_remote_devices(self) -> None:
         """Reload remote devices configuration from config file.
         
         This allows hot-reloading of remote devices without restarting the application.
+        Handles ESPHome connections properly (stops old, starts new).
         """
         config = self._config_helper.get_config()
         remote_devices_config = config.get("remote_devices", [])
         
         _LOGGER.info("Reloading remote devices configuration")
-        self.remote_devices.reload(remote_devices_config)
+        await self.remote_devices.reload(remote_devices_config)
         _LOGGER.info("Remote devices configuration reloaded successfully")
     
     async def publish_discovery(self) -> None:

boneio/core/manager/remote.py

@@ -18,6 +18,7 @@ from boneio.core.remote.base import (
 )
 from boneio.core.remote.mqtt import MQTTRemoteDevice
 from boneio.core.remote.esphome import ESPHomeRemoteDevice, ESPHOME_API_AVAILABLE
+from boneio.core.remote.wled import WLEDRemoteDevice
 
 if TYPE_CHECKING:
     from boneio.core.messaging import MessageBus
@@ -176,6 +177,8 @@ class RemoteDeviceManager:
             return None
         elif protocol == RemoteDeviceProtocol.ESPHOME_API:
             return self._create_esphome_device(device_id, name, config)
+        elif protocol == RemoteDeviceProtocol.WLED:
+            return self._create_wled_device(device_id, name, config)
         else:
             _LOGGER.error("Unsupported protocol '%s' for device '%s'", protocol, device_id)
             return None
@@ -259,6 +262,40 @@ class RemoteDeviceManager:
             covers=covers,
         )
     
+    def _create_wled_device(
+        self,
+        device_id: str,
+        name: str,
+        config: dict[str, Any],
+    ) -> WLEDRemoteDevice | None:
+        """Create WLED remote device.
+        
+        Args:
+            device_id: Device ID
+            name: Device name
+            config: Full device configuration
+            
+        Returns:
+            WLEDRemoteDevice instance or None if creation failed
+        """
+        wled_config = config.get("wled", {})
+        host = wled_config.get("host")
+        
+        if not host:
+            _LOGGER.error("WLED device '%s' missing 'host' in wled config", device_id)
+            return None
+        
+        port = wled_config.get("port", 80)
+        segments = wled_config.get("segments", [])
+        
+        return WLEDRemoteDevice(
+            id=device_id,
+            name=name,
+            host=host,
+            port=port,
+            segments=segments,
+        )
+    
     async def start_all_connections(self, delay_seconds: float = 10.0) -> None:
         """Start persistent connections for all ESPHome devices.
         
@@ -332,19 +369,32 @@ class RemoteDeviceManager:
         output_id: str,
         action: str,
         brightness: int | None = None,
+        color_temp: int | None = None,
+        rgb: list[int] | tuple[int, int, int] | None = None,
         transition: float | None = None,
+        effect: int | None = None,
+        palette: int | None = None,
+        effect_speed: int | None = None,
+        effect_intensity: int | None = None,
     ) -> bool:
-        """Control output on remote device (BoneIO MQTT or ESPHome API).
+        """Control output on remote device (BoneIO MQTT, ESPHome API, or WLED).
         
         Automatically detects device protocol and routes to appropriate method.
         For ESPHome devices, output_id can be a switch or light entity.
+        For WLED devices, output_id can be "main" or segment ID.
         
         Args:
             device_id: ID of the remote device
             output_id: ID of the output/switch/light to control
             action: Action to perform (ON, OFF, TOGGLE, BRIGHTNESS_UP, BRIGHTNESS_DOWN, SET_BRIGHTNESS)
-            brightness: Brightness level (0-255) - only for ESPHome lights
-            transition: Transition time in seconds - only for ESPHome lights
+            brightness: Brightness level (0-255) - for ESPHome/WLED lights
+            color_temp: Color temperature in mireds - only for ESPHome lights
+            rgb: RGB color as [R, G, B] list or tuple (0-255 each) - for ESPHome/WLED lights
+            transition: Transition time in seconds - for ESPHome/WLED lights
+            effect: WLED effect ID
+            palette: WLED color palette ID
+            effect_speed: WLED effect speed (0-255)
+            effect_intensity: WLED effect intensity (0-255)
             
         Returns:
             True if command was sent successfully
@@ -359,10 +409,16 @@ class RemoteDeviceManager:
             # Check if output_id is a light
             if device.has_light(output_id):
                 _LOGGER.debug("Controlling ESPHome light '%s' on device '%s'", output_id, device_id)
+                # Convert rgb list to tuple[int, int, int] if needed
+                rgb_tuple: tuple[int, int, int] | None = None
+                if rgb and len(rgb) >= 3:
+                    rgb_tuple = (int(rgb[0]), int(rgb[1]), int(rgb[2]))
                 return await device.control_light(
                     light_id=output_id,
                     action=action,
                     brightness=brightness,
+                    color_temp=color_temp,
+                    rgb=rgb_tuple,
                     transition=transition if transition is not None else 0.0,
                 )
             # Otherwise treat as switch
@@ -372,6 +428,27 @@ class RemoteDeviceManager:
                 action=action,
             )
         
+        # For WLED devices, use HTTP JSON API
+        if isinstance(device, WLEDRemoteDevice):
+            _LOGGER.debug("Controlling WLED '%s' segment '%s' on device '%s'", output_id, action, device_id)
+            # Parse segment_id - "main" means whole device, otherwise it's segment ID
+            segment_id = None if output_id == "main" else int(output_id)
+            # Convert rgb list to tuple if needed
+            wled_rgb: tuple[int, int, int] | None = None
+            if rgb and len(rgb) >= 3:
+                wled_rgb = (int(rgb[0]), int(rgb[1]), int(rgb[2]))
+            return await device.control_light(
+                segment_id=segment_id,
+                action=action,
+                brightness=brightness,
+                rgb=wled_rgb,
+                transition=transition if transition is not None else 0.0,
+                effect=effect,
+                palette=palette,
+                effect_speed=effect_speed,
+                effect_intensity=effect_intensity,
+            )
+        
         # For MQTT devices, use standard control_output
         return await device.control_output(
             output_id=output_id,
@@ -420,20 +497,52 @@ class RemoteDeviceManager:
             **kwargs,
         )
     
-    def reload(self, remote_devices_config: list[dict[str, Any]] | None = None) -> None:
+    async def reload(self, remote_devices_config: list[dict[str, Any]] | None = None) -> None:
         """Reload remote devices from config.
         
+        Stops existing ESPHome connections, reconfigures devices,
+        and starts new ESPHome connections.
+        
         Args:
             remote_devices_config: New list of remote device configurations
         """
         _LOGGER.info("Reloading remote devices configuration")
+        
+        # Stop existing ESPHome connections first
+        await self.stop_all_connections()
+        
         self._devices.clear()
         
         if remote_devices_config:
             self._configure_devices(remote_devices_config)
         
+        # Start ESPHome connections immediately (no delay for reload)
+        await self._start_esphome_connections_immediate()
+        
         _LOGGER.info("Reloaded %d remote devices", len(self._devices))
     
+    async def _start_esphome_connections_immediate(self) -> None:
+        """Start ESPHome connections immediately without delay.
+        
+        Used during reload when we want connections to start right away.
+        """
+        esphome_devices = [
+            (device_id, device) 
+            for device_id, device in self._devices.items() 
+            if isinstance(device, ESPHomeRemoteDevice)
+        ]
+        
+        if not esphome_devices:
+            return
+        
+        _LOGGER.info("Starting %d ESPHome connection(s)...", len(esphome_devices))
+        for device_id, device in esphome_devices:
+            try:
+                await device.start_connection()
+                _LOGGER.info("Started connection for ESPHome device '%s'", device_id)
+            except Exception as e:
+                _LOGGER.error("Failed to start connection for ESPHome device '%s': %s", device_id, e)
+    
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary representation.
         

boneio/core/manager/update.py

@@ -0,0 +1,341 @@
+"""Update manager for checking and publishing software updates to Home Assistant.
+
+This module manages periodic checking of software updates from GitHub
+and publishes the update status to Home Assistant via MQTT.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING
+
+from boneio.core.utils.async_updater import AsyncUpdater
+from boneio.core.utils.timeperiod import TimePeriod
+from boneio.version import __version__
+
+if TYPE_CHECKING:
+    from boneio.core.manager import Manager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class UpdateManager(AsyncUpdater):
+    """Manages software update checking and MQTT publishing.
+    
+    This manager:
+    - Checks for updates from GitHub periodically (default: 4 hours)
+    - Caches results to avoid rate limiting
+    - Publishes update state to MQTT for Home Assistant
+    - Supports on-demand update checks from frontend
+    """
+
+    def __init__(
+        self,
+        manager: Manager,
+        update_interval: TimePeriod | None = None,
+    ):
+        """Initialize UpdateManager.
+        
+        Args:
+            manager: Parent Manager instance
+            update_interval: Time between update checks (default: 4 hours)
+        """
+        self.id = "update_manager"
+        self._manager = manager
+        
+        # Update check interval (default: 4 hours)
+        if update_interval is None:
+            update_interval = TimePeriod(hours=4)
+        
+        # Cache for update info to avoid excessive GitHub API calls
+        self._last_check_result: dict | None = None
+        self._last_published_state: str | None = None
+        self._ha_discovery_sent: bool = False
+        
+        # Initialize AsyncUpdater (starts periodic task)
+        super().__init__(manager=manager, update_interval=update_interval)
+        
+        _LOGGER.info(
+            "UpdateManager initialized (check interval: %s)",
+            update_interval
+        )
+
+    async def async_update(self, timestamp: float) -> float | None:
+        """Perform periodic update check.
+        
+        Args:
+            timestamp: Current timestamp
+            
+        Returns:
+            Optional custom update interval in seconds
+        """
+        # Send HA discovery on first update (MQTT is connected by then)
+        if not self._ha_discovery_sent:
+            await self.send_ha_autodiscovery()
+            self._ha_discovery_sent = True
+        
+        _LOGGER.debug("Checking for software updates...")
+        
+        try:
+            # Check for updates from GitHub
+            update_info = await self._check_update_from_github()
+            
+            if update_info and update_info.get("status") == "success":
+                # Publish state to MQTT
+                await self._publish_state_to_mqtt(update_info)
+            else:
+                _LOGGER.warning(
+                    "Update check failed: %s",
+                    update_info.get("message", "Unknown error") if update_info else "No response"
+                )
+        except Exception as e:
+            _LOGGER.error("Error during update check: %s", e, exc_info=True)
+        
+        # Return None to use default interval
+        return None
+
+    async def _check_update_from_github(self) -> dict | None:
+        """Check for updates from GitHub releases.
+        
+        This method reuses the logic from /api/check_update endpoint.
+        
+        Returns:
+            Update information dict or None on error
+        """
+        current_version = __version__
+        
+        try:
+            import requests
+        except ImportError:
+            _LOGGER.error("Package 'requests' is not installed")
+            return {
+                "status": "error",
+                "message": "Package 'requests' is not installed",
+                "current_version": current_version
+            }
+        
+        try:
+            from packaging import version
+        except ImportError:
+            _LOGGER.error("Package 'packaging' is not installed")
+            return {
+                "status": "error",
+                "message": "Package 'packaging' is not installed",
+                "current_version": current_version
+            }
+        
+        try:
+            repo = "boneIO-eu/app_black"
+            api_url = f'https://api.github.com/repos/{repo}/releases'
+            response = requests.get(api_url, timeout=10)
+            
+            if response.status_code != 200:
+                return {
+                    "status": "error",
+                    "message": f"GitHub API error: {response.status_code}",
+                    "current_version": current_version
+                }
+            
+            releases = response.json()
+            
+            if not releases:
+                return {
+                    "status": "error",
+                    "message": "No releases found on GitHub",
+                    "current_version": current_version
+                }
+            
+            # Find latest stable and prerelease versions
+            latest_stable = None
+            latest_prerelease = None
+            
+            for release in releases:
+                tag = release['tag_name']
+                ver_str = tag[1:] if tag.startswith('v') else tag
+                
+                # Skip v0.x versions (Debian 10, incompatible)
+                if tag.startswith("v0."):
+                    continue
+                
+                is_prerelease = release.get('prerelease', False)
+                
+                if not is_prerelease:
+                    ver_lower = ver_str.lower()
+                    is_prerelease = any(x in ver_lower for x in ['dev', 'alpha', 'beta', 'rc'])
+                
+                ver_info = {
+                    "version": ver_str,
+                    "is_prerelease": is_prerelease,
+                    "release_url": release['html_url'],
+                    "published_at": release['published_at'],
+                    "release_notes": release.get('body', '')[:255],  # Max 255 chars for HA
+                }
+                
+                if not is_prerelease and latest_stable is None:
+                    latest_stable = ver_info
+                if is_prerelease and latest_prerelease is None:
+                    latest_prerelease = ver_info
+                
+                # Stop after finding both
+                if latest_stable and latest_prerelease:
+                    break
+            
+            # Determine which version to recommend based on update_channel setting
+            update_channel = self._manager._config_helper.update_channel
+            
+            if update_channel == "dev":
+                # Dev channel: prefer prerelease, fallback to stable
+                recommended = latest_prerelease or latest_stable
+            else:
+                # Stable channel (default): only stable releases
+                recommended = latest_stable
+            
+            if not recommended:
+                return {
+                    "status": "error",
+                    "message": "No suitable release found",
+                    "current_version": current_version
+                }
+            
+            # Check if update is available
+            is_update_available = False
+            try:
+                current_parsed = version.parse(current_version)
+                recommended_parsed = version.parse(recommended["version"])
+                is_update_available = recommended_parsed > current_parsed
+            except Exception as e:
+                _LOGGER.warning("Error parsing versions: %s", e)
+            
+            result = {
+                "status": "success",
+                "current_version": current_version,
+                "latest_version": recommended["version"],
+                "update_available": is_update_available,
+                "release_url": recommended["release_url"],
+                "release_notes": recommended.get("release_notes", ""),
+                "is_prerelease": recommended["is_prerelease"],
+            }
+            
+            # Cache result
+            self._last_check_result = result
+            
+            return result
+            
+        except Exception as e:
+            _LOGGER.error("Error checking for updates: %s", e, exc_info=True)
+            return {
+                "status": "error",
+                "message": f"Error: {str(e)}",
+                "current_version": current_version
+            }
+
+    async def _publish_state_to_mqtt(self, update_info: dict) -> None:
+        """Publish update state to MQTT for Home Assistant.
+        
+        Args:
+            update_info: Update information from GitHub check
+        """
+        if update_info.get("status") != "success":
+            return
+        
+        current_version = update_info.get("current_version", __version__)
+        latest_version = update_info.get("latest_version", current_version)
+        
+        # Build state payload (JSON format for HA Update entity)
+        state_payload = {
+            "installed_version": current_version,
+            "latest_version": latest_version,
+            "title": "boneIO Black Firmware",
+            "release_url": update_info.get("release_url", ""),
+            "release_summary": update_info.get("release_notes", "")[:255],  # HA limit
+        }
+        
+        # Add entity_picture (boneIO logo from HA brands)
+        state_payload["entity_picture"] = "http://boneio.eu/logo_fb_circle.png"
+        
+        # Convert to JSON
+        payload_json = json.dumps(state_payload)
+        
+        # Only publish if state changed (avoid unnecessary MQTT traffic)
+        if payload_json == self._last_published_state:
+            _LOGGER.debug("Update state unchanged, skipping MQTT publish")
+            return
+        
+        # Publish to MQTT
+        topic_prefix = self._manager._config_helper.topic_prefix
+        state_topic = f"{topic_prefix}/update/state"
+        
+        self._manager.send_message(
+            topic=state_topic,
+            payload=payload_json,
+            retain=True,
+        )
+        
+        self._last_published_state = payload_json
+        
+        _LOGGER.info(
+            "Published update state to MQTT: %s -> %s (update available: %s)",
+            current_version,
+            latest_version,
+            update_info.get("update_available", False)
+        )
+
+    def get_last_check_result(self) -> dict | None:
+        """Get the last update check result.
+        
+        Returns:
+            Last check result dict or None if no check performed yet
+        """
+        return self._last_check_result
+
+    async def handle_install_command(self, payload: str) -> None:
+        """Handle install command from Home Assistant.
+        
+        This is called when HA sends a message to the command topic.
+        
+        Args:
+            payload: MQTT payload (should be "INSTALL")
+        """
+        if payload != "INSTALL":
+            _LOGGER.warning("Invalid install command payload: %s", payload)
+            return
+        
+        _LOGGER.info("Received install command from Home Assistant")
+        
+        # Check if update is available
+        if not self._last_check_result:
+            _LOGGER.warning("No update check result available, checking now...")
+            await self.async_update(timestamp=0)
+        
+        if not self._last_check_result or not self._last_check_result.get("update_available"):
+            _LOGGER.warning("No update available to install")
+            return
+        
+        # Trigger update via existing update endpoint
+        # Note: This requires the update API to be accessible
+        # The actual installation is handled by /api/update endpoint
+        _LOGGER.info(
+            "Update installation should be triggered via WebUI or API endpoint /api/update"
+        )
+        
+        # TODO: Consider adding direct integration with update logic
+        # For now, users should use the WebUI to trigger updates
+
+    async def send_ha_autodiscovery(self) -> None:
+        """Send Home Assistant autodiscovery for Update entity."""
+        _LOGGER.debug("Sending HA autodiscovery for Update entity")
+        
+        self._manager.send_ha_autodiscovery(
+            id="firmware",
+            name="Update",
+            ha_type="update",
+        )
+        
+        # Subscribe to command topic for install commands
+        command_topic = f"{self._manager._topic_prefix}/update/install"
+        await self._manager._message_bus.subscribe_and_listen(
+            topic=command_topic,
+            callback=self._manager._handle_update_install_command
+        )
+        _LOGGER.info("Subscribed to update command topic: %s", command_topic)