boneIO 1.2.0.dev5__tar.gz → 1.2.0.dev7__tar.gz

{boneio-1.2.0.dev5/boneio.egg-info → boneio-1.2.0.dev7}/PKG-INFO

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

{boneio-1.2.0.dev5 → boneio-1.2.0.dev7}/boneio/components/input/detectors.py

@@ -46,6 +46,7 @@ class ClickState:
     # Long hold periodic events
     long_hold_periodic_timer: asyncio.TimerHandle | None = None
     executed_long_actions: set[int] = field(default_factory=set)  # Track which long actions already executed
+    last_repeat_times: dict[int, float] = field(default_factory=dict)  # Track last execution time per repeat action index
 
 
 @dataclass
@@ -361,6 +362,7 @@ class MultiClickDetector:
         
         # Reset executed actions for new long press
         self._state.executed_long_actions = set()
+        self._state.last_repeat_times = {}
         
         duration = self._loop.time() - self._state.last_press_ts
         
@@ -468,7 +470,7 @@ class MultiClickDetector:
         elif event.event_type is event.Type.RISING_EDGE:
             # Button released (RISING_EDGE on BeagleBone with pull-up)
             
-            # Software debounce
+            # Software debounce (release-vs-release)
             if self._state.last_release_ts and (timestamp_s - self._state.last_release_ts) < self._debounce_seconds:
                 delta_ms = (timestamp_s - self._state.last_release_ts) * 1000
                 _LOGGER.debug(
@@ -477,8 +479,20 @@ class MultiClickDetector:
                     delta_ms,
                 )
                 return
+            
+            # Cross-debounce: ignore release too close to press (bounce on rising edge)
+            if self._state.last_press_ts and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds:
+                delta_ms = (timestamp_s - self._state.last_press_ts) * 1000
+                _LOGGER.debug(
+                    "Ignoring bounced release on %s (%.3f ms since press, debounce %.3f ms)",
+                    self._name,
+                    delta_ms,
+                    self._debounce_seconds * 1000,
+                )
+                return
 
-            _LOGGER.debug("RELEASED: %s (%s)", self._name, self._pin)
+            press_duration_ms = (timestamp_s - self._state.last_press_ts) * 1000 if self._state.last_press_ts else 0
+            _LOGGER.debug("RELEASED: %s (%s) after %.1f ms", self._name, self._pin, press_duration_ms)
             self._state.last_release_ts = timestamp_s
             
             _LOGGER.debug(
@@ -511,6 +525,7 @@ class MultiClickDetector:
                 # need to give it time to start and read executed_long_actions.
                 def reset_executed_actions():
                     self._state.executed_long_actions = set()
+                    self._state.last_repeat_times = {}
                     _LOGGER.debug("Reset executed_long_actions for %s", self._name)
                 self._loop.call_later(0.05, reset_executed_actions)
             

{boneio-1.2.0.dev5 → boneio-1.2.0.dev7}/boneio/core/cloud/data/init-certs-cloud.sh

@@ -113,7 +113,6 @@ ${CLOUD_BLOCK}
 
 # HTTPS with self-signed certificate (catch-all for hostname and IP access)
 https:// {
-        # Wlaczenie on_demand dla wewnetrznego wystawcy pozwala na dynamiczne generowanie certyfikatow dla IP
         tls internal {
                 on_demand
         }

{boneio-1.2.0.dev5 → boneio-1.2.0.dev7}/boneio/core/manager/inputs.py

@@ -697,14 +697,24 @@ class InputManager:
         
         # Execute actions with duration threshold support
         if actions and event.click_type == LONG:
-            # Get executed_actions from detector state
+            # Get executed_actions and repeat times from detector state
             detector = getattr(input_instance, '_detector', None)
             executed_actions = getattr(detector._state, 'executed_long_actions', set()) if detector else set()
+            last_repeat_times = getattr(detector._state, 'last_repeat_times', {}) if detector else {}
             
-            # Lazy evaluation: Check if there are any actions with duration thresholds
-            # or any actions without thresholds that haven't been executed yet
+            # Lazy evaluation: Check if there are any pending actions
+            duration_ms = (event.duration or 0) * 1000
             has_pending_actions = False
             for idx, action in enumerate(actions):
+                is_repeat = action.get("repeat", False)
+                if is_repeat:
+                    # Repeat actions are always potentially pending (throttled in execute_actions)
+                    repeat_interval_ms = action.get("repeat_interval", 1000)
+                    last_time = last_repeat_times.get(idx, 0.0)
+                    if last_time == 0 or (duration_ms - last_time) >= repeat_interval_ms:
+                        has_pending_actions = True
+                        break
+                    continue
                 if idx in executed_actions:
                     continue  # Already executed
                 min_dur = action.get("min_duration")
@@ -730,11 +740,13 @@ class InputManager:
                     actions=actions,
                     duration=event.duration,
                     executed_actions=executed_actions,
+                    last_repeat_times=last_repeat_times,
                 )
                 
                 # Update detector state
                 if detector:
                     detector._state.executed_long_actions = new_executed
+                    detector._state.last_repeat_times = last_repeat_times
         elif actions:
             # Non-long events - execute all actions normally
             await self._manager.execute_actions(actions=actions)

{boneio-1.2.0.dev5 → boneio-1.2.0.dev7}/boneio/core/manager/manager.py

@@ -433,6 +433,20 @@ class Manager:
         from boneio.const import TOPIC, REMOTE_OUTPUT, REMOTE_COVER
         from boneio.core.utils import strip_accents
         
+        def _copy_long_press_meta(parsed_action: dict, action_definition: dict) -> None:
+            """Copy long press meta fields (duration thresholds, repeat) to parsed action."""
+            for key in ("min_duration", "max_duration"):
+                if action_definition.get(key) is not None:
+                    parsed_action[key] = action_definition[key]
+            if action_definition.get("repeat"):
+                parsed_action["repeat"] = True
+                ri = action_definition.get("repeat_interval", 1000)
+                # TimePeriod object from schema validation -> convert to ms
+                if hasattr(ri, "total_milliseconds"):
+                    parsed_action["repeat_interval"] = ri.total_milliseconds
+                else:
+                    parsed_action["repeat_interval"] = ri
+        
         parsed_actions = {}
         for click_type in actions:
             if click_type not in parsed_actions:
@@ -455,11 +469,7 @@ class Manager:
                                 "pin": stripped_entity_id,
                                 "action_to_execute": action_to_execute,
                             }
-                            # Copy duration thresholds for long press actions
-                            if action_definition.get("min_duration") is not None:
-                                parsed_action["min_duration"] = action_definition["min_duration"]
-                            if action_definition.get("max_duration") is not None:
-                                parsed_action["max_duration"] = action_definition["max_duration"]
+                            _copy_long_press_meta(parsed_action, action_definition)
                             _LOGGER.debug(
                                 "Parsed OUTPUT action for %s: output=%s, action=%s, min_dur=%s, max_dur=%s",
                                 pin, stripped_entity_id, action_to_execute,
@@ -486,11 +496,7 @@ class Manager:
                                 "action_to_execute": action_to_execute,
                                 "extra_data": extra_data,
                             }
-                            # Copy duration thresholds for long press actions
-                            if action_definition.get("min_duration") is not None:
-                                parsed_action["min_duration"] = action_definition["min_duration"]
-                            if action_definition.get("max_duration") is not None:
-                                parsed_action["max_duration"] = action_definition["max_duration"]
+                            _copy_long_press_meta(parsed_action, action_definition)
                             parsed_actions[click_type].append(parsed_action)
                             continue
                     _LOGGER.warning("Device %s for action not found. Omitting.", entity_id)
@@ -504,11 +510,7 @@ class Manager:
                             "action_mqtt_msg": action_mqtt_msg,
                             "action_topic": action_topic,
                         }
-                        # Copy duration thresholds for long press actions
-                        if action_definition.get("min_duration") is not None:
-                            parsed_action["min_duration"] = action_definition["min_duration"]
-                        if action_definition.get("max_duration") is not None:
-                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("MQTT action missing topic or message for %s", pin)
@@ -523,11 +525,7 @@ class Manager:
                             "boneio_id": boneio_id,
                             "action_output": action_output,
                         }
-                        # Copy duration thresholds for long press actions
-                        if action_definition.get("min_duration") is not None:
-                            parsed_action["min_duration"] = action_definition["min_duration"]
-                        if action_definition.get("max_duration") is not None:
-                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("OUTPUT_OVER_MQTT action missing data for %s", pin)
@@ -542,11 +540,7 @@ class Manager:
                             "boneio_id": boneio_id,
                             "action_cover": action_cover,
                         }
-                        # Copy duration thresholds for long press actions
-                        if action_definition.get("min_duration") is not None:
-                            parsed_action["min_duration"] = action_definition["min_duration"]
-                        if action_definition.get("max_duration") is not None:
-                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("COVER_OVER_MQTT action missing data for %s", pin)
@@ -563,11 +557,16 @@ class Manager:
                             "output_id": output_id,
                             "action_output": action_output,
                         }
-                        # Copy duration thresholds for long press actions
-                        if action_definition.get("min_duration") is not None:
-                            parsed_action["min_duration"] = action_definition["min_duration"]
-                        if action_definition.get("max_duration") is not None:
-                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        # Copy optional light/WLED parameters
+                        for opt_key in (
+                            "brightness", "color_temp", "rgb", "transition",
+                            "effect", "palette", "effect_speed", "effect_intensity",
+                            "colors", "presets",
+                        ):
+                            val = action_definition.get(opt_key)
+                            if val is not None:
+                                parsed_action[opt_key] = val
+                        _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("REMOTE_OUTPUT action missing remote_device or output_id for %s", pin)
@@ -586,11 +585,7 @@ class Manager:
                             "action_cover": action_cover,
                             "extra_data": extra_data,
                         }
-                        # Copy duration thresholds for long press actions
-                        if action_definition.get("min_duration") is not None:
-                            parsed_action["min_duration"] = action_definition["min_duration"]
-                        if action_definition.get("max_duration") is not None:
-                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("REMOTE_COVER action missing remote_device or cover_id for %s", pin)
@@ -602,6 +597,7 @@ class Manager:
         actions: list,
         duration: float | None = None,
         executed_actions: set[int] | None = None,
+        last_repeat_times: dict[int, float] | None = None,
     ) -> set[int]:
         """Execute list of actions.
         
@@ -609,20 +605,26 @@ class Manager:
             actions: List of actions to execute
             duration: Current duration in seconds (for long press threshold checking)
             executed_actions: Set of action indices already executed (for long press)
+            last_repeat_times: Dict mapping action index to last execution duration_ms (for repeat throttling)
         
         Returns:
             Set of action indices that were executed
         """
         if executed_actions is None:
             executed_actions = set()
+        if last_repeat_times is None:
+            last_repeat_times = {}
         
         duration_ms = (duration or 0) * 1000  # Convert to ms
         
         start_time = time.time()
         
         for idx, action_definition in enumerate(actions):
-            # Skip if already executed
-            if idx in executed_actions:
+            is_repeat = action_definition.get("repeat", False)
+            repeat_interval_ms = action_definition.get("repeat_interval", 1000)
+            
+            # Skip if already executed (unless it's a repeat action)
+            if idx in executed_actions and not is_repeat:
                 _LOGGER.debug("Action %d already executed, skipping", idx)
                 continue
             
@@ -631,8 +633,8 @@ class Manager:
             max_dur = action_definition.get("max_duration")  # ms
             
             _LOGGER.debug(
-                "Checking action %d: min_dur=%s, max_dur=%s, duration_ms=%.1f, executed=%s",
-                idx, min_dur, max_dur, duration_ms, executed_actions
+                "Checking action %d: min_dur=%s, max_dur=%s, duration_ms=%.1f, repeat=%s, executed=%s",
+                idx, min_dur, max_dur, duration_ms, is_repeat, executed_actions
             )
             
             if min_dur is not None or max_dur is not None:
@@ -645,12 +647,26 @@ class Manager:
                     continue  # Duration too long
                 _LOGGER.debug("Action %d: duration %.1fms in range [%s, %s), executing", idx, duration_ms, min_dur, max_dur)
             else:
-                # Action without thresholds - execute only once (on first long event)
-                # Check if THIS specific action was already executed, not just any action
-                if idx in executed_actions:
-                    _LOGGER.debug("Action %d: no thresholds, already executed, skipping", idx)
-                    continue
-                _LOGGER.debug("Action %d: no thresholds, not yet executed, executing", idx)
+                if is_repeat:
+                    # Repeat action - check interval throttling
+                    now_ms = duration_ms
+                    last_time = last_repeat_times.get(idx, 0.0)
+                    if last_time > 0 and (now_ms - last_time) < repeat_interval_ms:
+                        _LOGGER.debug(
+                            "Action %d: repeat throttled (%.1fms since last, interval=%dms)",
+                            idx, now_ms - last_time, repeat_interval_ms
+                        )
+                        continue
+                    _LOGGER.debug(
+                        "Action %d: repeat action, interval ok (%.1fms since last, interval=%dms)",
+                        idx, now_ms - last_time, repeat_interval_ms
+                    )
+                else:
+                    # Action without thresholds - execute only once (on first long event)
+                    if idx in executed_actions:
+                        _LOGGER.debug("Action %d: no thresholds, already executed, skipping", idx)
+                        continue
+                    _LOGGER.debug("Action %d: no thresholds, not yet executed, executing", idx)
             action = action_definition.get("action")
             
             if action == MQTT:
@@ -722,19 +738,39 @@ class Manager:
                 remote_device_id = action_definition.get("remote_device")
                 output_id = action_definition.get("output_id")
                 action_output = action_definition.get("action_output", "TOGGLE")
-                await self.remote_devices.control_output(
-                    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"),
-                )
+                
+                if action_output == "CYCLE_COLOR":
+                    await self.remote_devices.cycle_color(
+                        device_id=remote_device_id,
+                        output_id=output_id,
+                        colors=action_definition.get("colors", []),
+                        action_idx=idx,
+                        transition=action_definition.get("transition"),
+                    )
+                
+                elif action_output == "CYCLE_PRESET":
+                    await self.remote_devices.cycle_preset(
+                        device_id=remote_device_id,
+                        output_id=output_id,
+                        presets=action_definition.get("presets", []),
+                        action_idx=idx,
+                        transition=action_definition.get("transition"),
+                    )
+                
+                else:
+                    await self.remote_devices.control_output(
+                        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:
                 # Control cover on remote device (BoneIO MQTT or ESPHome API)
@@ -750,6 +786,9 @@ class Manager:
                 )
             
             # Mark action as executed
+            if is_repeat:
+                # For repeat actions, track timing instead of marking as permanently executed
+                last_repeat_times[idx] = duration_ms
             executed_actions.add(idx)
         
         return executed_actions

{boneio-1.2.0.dev5 → boneio-1.2.0.dev7}/boneio/core/manager/remote.py

@@ -64,6 +64,9 @@ class RemoteDeviceManager:
         self._autodiscovered_devices: dict[str, MQTTRemoteDevice] = {}
         # Track devices that manage this boneIO (received via discovery/managed_by topic)
         self._managed_by_devices: dict[str, dict[str, Any]] = {}
+        # Cycle state for CYCLE_COLOR and CYCLE_PRESET actions
+        # Key: "device_id:output_id:type:action_idx", Value: current index
+        self._cycle_state: dict[str, int] = {}
         
         if remote_devices_config:
             self._configure_devices(remote_devices_config)
@@ -335,14 +338,18 @@ class RemoteDeviceManager:
         """Stop all persistent connections.
         
         This should be called during application shutdown.
+        Closes ESPHome connections and WLED aiohttp sessions.
         """
         for device_id, device in self._devices.items():
-            if isinstance(device, ESPHomeRemoteDevice):
-                try:
+            try:
+                if isinstance(device, ESPHomeRemoteDevice):
                     await device.disconnect()
                     _LOGGER.info("Stopped connection for ESPHome device '%s'", device_id)
-                except Exception as e:
-                    _LOGGER.error("Failed to stop connection for ESPHome device '%s': %s", device_id, e)
+                elif isinstance(device, WLEDRemoteDevice):
+                    await device.close()
+                    _LOGGER.info("Closed session for WLED device '%s'", device_id)
+            except Exception as e:
+                _LOGGER.error("Failed to stop connection for device '%s': %s", device_id, e)
     
     def get_device(self, device_id: str) -> RemoteDevice | None:
         """Get remote device by ID.
@@ -372,7 +379,7 @@ class RemoteDeviceManager:
         color_temp: int | None = None,
         rgb: list[int] | tuple[int, int, int] | None = None,
         transition: float | None = None,
-        effect: int | None = None,
+        effect: int | str | None = None,
         palette: int | None = None,
         effect_speed: int | None = None,
         effect_intensity: int | None = None,
@@ -391,7 +398,7 @@ class RemoteDeviceManager:
             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
+            effect: Effect name (str for ESPHome) or effect ID (int for WLED)
             palette: WLED color palette ID
             effect_speed: WLED effect speed (0-255)
             effect_intensity: WLED effect intensity (0-255)
@@ -413,6 +420,8 @@ class RemoteDeviceManager:
                 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]))
+                # For ESPHome, effect must be a string
+                esphome_effect = str(effect) if effect is not None else None
                 return await device.control_light(
                     light_id=output_id,
                     action=action,
@@ -420,6 +429,7 @@ class RemoteDeviceManager:
                     color_temp=color_temp,
                     rgb=rgb_tuple,
                     transition=transition if transition is not None else 0.0,
+                    effect=esphome_effect,
                 )
             # Otherwise treat as switch
             _LOGGER.debug("Controlling ESPHome switch '%s' on device '%s'", output_id, device_id)
@@ -456,6 +466,96 @@ class RemoteDeviceManager:
             message_bus=self._message_bus,
         )
     
+    async def cycle_color(
+        self,
+        device_id: str,
+        output_id: str,
+        colors: list[list[int]],
+        action_idx: int = 0,
+        transition: float | None = None,
+    ) -> bool:
+        """Cycle through a list of RGB colors on a remote device light.
+        
+        Each call advances to the next color in the list, wrapping around.
+        
+        Args:
+            device_id: ID of the remote device
+            output_id: ID of the light to control
+            colors: List of RGB colors, each as [R, G, B] (0-255)
+            action_idx: Action index for unique cycle state tracking
+            transition: Transition time in seconds
+            
+        Returns:
+            True if command was sent successfully
+        """
+        if not colors:
+            _LOGGER.warning("CYCLE_COLOR: no colors defined for %s:%s", device_id, output_id)
+            return False
+        
+        cycle_key = f"{device_id}:{output_id}:color:{action_idx}"
+        cycle_idx = self._cycle_state.get(cycle_key, 0) % len(colors)
+        rgb = colors[cycle_idx]
+        self._cycle_state[cycle_key] = cycle_idx + 1
+        
+        _LOGGER.debug(
+            "CYCLE_COLOR: %s:%s -> color %d/%d = %s",
+            device_id, output_id, cycle_idx + 1, len(colors), rgb
+        )
+        
+        return await self.control_output(
+            device_id=device_id,
+            output_id=output_id,
+            action="ON",
+            rgb=rgb,
+            transition=transition,
+        )
+    
+    async def cycle_preset(
+        self,
+        device_id: str,
+        output_id: str,
+        presets: list[str | int],
+        action_idx: int = 0,
+        transition: float | None = None,
+    ) -> bool:
+        """Cycle through a list of effects/presets on a remote device light.
+        
+        Each call advances to the next preset in the list, wrapping around.
+        For ESPHome: presets are effect name strings.
+        For WLED: presets are effect IDs (integers).
+        
+        Args:
+            device_id: ID of the remote device
+            output_id: ID of the light to control
+            presets: List of effect names (str) or effect IDs (int)
+            action_idx: Action index for unique cycle state tracking
+            transition: Transition time in seconds
+            
+        Returns:
+            True if command was sent successfully
+        """
+        if not presets:
+            _LOGGER.warning("CYCLE_PRESET: no presets defined for %s:%s", device_id, output_id)
+            return False
+        
+        cycle_key = f"{device_id}:{output_id}:preset:{action_idx}"
+        cycle_idx = self._cycle_state.get(cycle_key, 0) % len(presets)
+        preset = presets[cycle_idx]
+        self._cycle_state[cycle_key] = cycle_idx + 1
+        
+        _LOGGER.debug(
+            "CYCLE_PRESET: %s:%s -> preset %d/%d = %s",
+            device_id, output_id, cycle_idx + 1, len(presets), preset
+        )
+        
+        return await self.control_output(
+            device_id=device_id,
+            output_id=output_id,
+            action="ON",
+            effect=preset,
+            transition=transition,
+        )
+    
     async def control_cover(
         self,
         device_id: str,

{boneio-1.2.0.dev5 → boneio-1.2.0.dev7}/boneio/core/remote/esphome.py

@@ -505,6 +505,9 @@ class ESPHomeRemoteDevice(RemoteDevice):
                         if (mode & LightColorCapability.RGB) and (mode & LightColorCapability.WHITE):
                             supports_rgbw = True
                     
+                    # Get effects list from LightInfo
+                    effects_list = list(getattr(entity, 'effects', []))
+                    
                     light_data = {
                         "id": entity.object_id,
                         "name": entity.name,
@@ -515,6 +518,7 @@ class ESPHomeRemoteDevice(RemoteDevice):
                         "supports_rgbw": supports_rgbw,
                         "min_mireds": getattr(entity, 'min_mireds', None),
                         "max_mireds": getattr(entity, 'max_mireds', None),
+                        "effects": effects_list,
                     }
                     
                     result["lights"].append(light_data)
@@ -625,6 +629,7 @@ class ESPHomeRemoteDevice(RemoteDevice):
         color_temp: int | None = None,
         rgb: tuple[int, int, int] | None = None,
         transition: float = 0.0,
+        effect: str | None = None,
     ) -> bool:
         """Control a light on the ESPHome device.
         
@@ -635,6 +640,7 @@ class ESPHomeRemoteDevice(RemoteDevice):
             color_temp: Color temperature in mireds
             rgb: RGB color tuple (0-255 each)
             transition: Transition time in seconds
+            effect: Effect name string (e.g. "Rainbow", "Strobe")
             
         Returns:
             True if command was sent successfully
@@ -669,6 +675,8 @@ class ESPHomeRemoteDevice(RemoteDevice):
                     cmd_kwargs["color_temperature"] = color_temp
                 if rgb is not None:
                     cmd_kwargs["rgb"] = tuple(c / 255.0 for c in rgb)
+                if effect is not None:
+                    cmd_kwargs["effect"] = effect
                 self._client.light_command(light_key, **cmd_kwargs)
                 
             elif action_upper == "TOGGLE":

{boneio-1.2.0.dev5 → boneio-1.2.0.dev7}/boneio/core/remote/wled.py

@@ -135,6 +135,13 @@ class WLEDRemoteDevice(RemoteDevice):
                 return seg
         return None
     
+    async def close(self) -> None:
+        """Close aiohttp session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+            _LOGGER.debug("Closed aiohttp session for WLED '%s'", self._name)
+    
     async def _get_session(self) -> aiohttp.ClientSession:
         """Get or create aiohttp session."""
         if self._session is None or self._session.closed:
@@ -425,12 +432,6 @@ class WLEDRemoteDevice(RemoteDevice):
             _LOGGER.error("WLED discovery unexpected error for %s: %s", self._host, e)
             return {"error": str(e)}
     
-    async def close(self) -> None:
-        """Close HTTP session."""
-        if self._session and not self._session.closed:
-            await self._session.close()
-            self._session = None
-    
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary representation.