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

boneio/core/manager/manager.py

@@ -698,7 +698,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 +706,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 +748,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/remote/__init__.py

@@ -3,6 +3,7 @@
 Supports multiple protocols:
 - MQTT: Standard MQTT communication (boneIO Black, ESPHome, etc.)
 - ESPHome API: Native ESPHome API via TCP/IP
+- WLED: WLED HTTP JSON API for LED strips
 - CAN: CAN bus communication (future)
 - Loxone: Loxone Miniserver integration (future)
 """
@@ -16,6 +17,11 @@ from boneio.core.remote.esphome import (
     ESPHOME_API_AVAILABLE,
     ZEROCONF_AVAILABLE,
 )
+from boneio.core.remote.wled import (
+    WLEDRemoteDevice,
+    scan_wled_devices,
+    discover_wled_info,
+)
 
 __all__ = [
     "RemoteDevice",
@@ -26,4 +32,7 @@ __all__ = [
     "scan_esphome_devices",
     "ESPHOME_API_AVAILABLE",
     "ZEROCONF_AVAILABLE",
+    "WLEDRemoteDevice",
+    "scan_wled_devices",
+    "discover_wled_info",
 ]

boneio/core/remote/base.py

@@ -25,6 +25,7 @@ class RemoteDeviceProtocol(str, Enum):
     LOXONE = "loxone"
     ESPHOME_UDP = "esphome_udp"
     ESPHOME_API = "esphome_api"
+    WLED = "wled"
 
 
 class RemoteDeviceType(str, Enum):
@@ -33,6 +34,7 @@ class RemoteDeviceType(str, Enum):
     BONEIO_BLACK = "boneio_black"
     ESPHOME = "esphome"
     LOXONE_MINISERVER = "loxone_miniserver"
+    WLED = "wled"
     GENERIC = "generic"