boneio 1.1.0.dev2__tar.gz → 1.1.0.dev4__tar.gz

{boneio-1.1.0.dev2/boneio.egg-info → boneio-1.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.1.0.dev2
+Version: 1.1.0.dev4
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: smbus2==0.4.3
 Requires-Dist: aiomqtt==2.4.0
+Requires-Dist: aiohttp==3.13.3
 Requires-Dist: Cerberus==1.3.7
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: luma-core==2.5.1

{boneio-1.1.0.dev2 → boneio-1.1.0.dev4}/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-1.1.0.dev2 → boneio-1.1.0.dev4}/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-1.1.0.dev2 → boneio-1.1.0.dev4}/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-1.1.0.dev2 → boneio-1.1.0.dev4}/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.