boneIO 1.2.0.dev6__tar.gz → 1.2.0.dev8__tar.gz

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

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

{boneio-1.2.0.dev6 → boneio-1.2.0.dev8}/boneio/components/input/detectors.py

@@ -470,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(
@@ -479,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(

{boneio-1.2.0.dev6 → boneio-1.2.0.dev8}/boneio/core/manager/manager.py

@@ -440,7 +440,12 @@ class Manager:
                     parsed_action[key] = action_definition[key]
             if action_definition.get("repeat"):
                 parsed_action["repeat"] = True
-                parsed_action["repeat_interval"] = action_definition.get("repeat_interval", 1000)
+                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:
@@ -552,6 +557,22 @@ class Manager:
                             "output_id": output_id,
                             "action_output": action_output,
                         }
+                        # 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
+                        # Convert transition TimePeriod to float seconds
+                        if "transition" in parsed_action:
+                            t_val = parsed_action["transition"]
+                            if hasattr(t_val, "total_in_seconds"):
+                                parsed_action["transition"] = t_val.total_in_seconds
+                            elif not isinstance(t_val, (int, float)):
+                                parsed_action["transition"] = 0.0
                         _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
@@ -724,19 +745,53 @@ 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"),
-                )
+                
+                # Clamp transition to repeat_interval to avoid overlapping animations
+                transition_val = action_definition.get("transition")
+                if transition_val and action_definition.get("repeat"):
+                    repeat_interval = action_definition.get("repeat_interval")
+                    if repeat_interval:
+                        ri_seconds = repeat_interval.total_in_seconds if hasattr(repeat_interval, "total_in_seconds") else repeat_interval / 1000.0
+                        if transition_val > ri_seconds:
+                            _LOGGER.debug(
+                                "Clamping transition %.3fs to repeat_interval %.3fs",
+                                transition_val, ri_seconds,
+                            )
+                            transition_val = ri_seconds
+                    action_definition = {**action_definition, "transition": transition_val}
+                
+                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)

{boneio-1.2.0.dev6 → boneio-1.2.0.dev8}/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.dev6 → boneio-1.2.0.dev8}/boneio/core/manager/update.py

@@ -6,13 +6,18 @@ and publishes the update status to Home Assistant via MQTT.
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
+import os
+import subprocess
+from collections.abc import Callable
 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__
+from boneio.webui.services.logs import is_running_as_service
 
 if TYPE_CHECKING:
     from boneio.core.manager import Manager
@@ -52,6 +57,7 @@ class UpdateManager(AsyncUpdater):
         self._last_check_result: dict | None = None
         self._last_published_state: str | None = None
         self._ha_discovery_sent: bool = False
+        self._update_running: bool = False
         
         # Initialize AsyncUpdater (starts periodic task)
         super().__init__(manager=manager, update_interval=update_interval)
@@ -312,10 +318,16 @@ class UpdateManager(AsyncUpdater):
         """
         return self._last_check_result
 
+    @property
+    def update_running(self) -> bool:
+        """Whether an update is currently in progress."""
+        return self._update_running
+
     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.
+        Performs pip install of the latest version and restarts the service.
         
         Args:
             payload: MQTT payload (should be "INSTALL")
@@ -326,6 +338,14 @@ class UpdateManager(AsyncUpdater):
         
         _LOGGER.info("Received install command from Home Assistant")
         
+        if not is_running_as_service():
+            _LOGGER.warning("Update via MQTT is only available when running as a service")
+            return
+        
+        if self._update_running:
+            _LOGGER.warning("Update already in progress, ignoring install command")
+            return
+        
         # Check if update is available
         if not self._last_check_result:
             _LOGGER.warning("No update check result available, checking now...")
@@ -335,15 +355,257 @@ class UpdateManager(AsyncUpdater):
             _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
+        target_version = self._last_check_result.get("latest_version")
+        
+        # Run update in background task to not block MQTT
+        asyncio.create_task(
+            self.perform_update(target_version=target_version)
+        )
+
+    async def perform_update(
+        self,
+        target_version: str | None = None,
+        on_progress: Callable[[int, str, str | None], None] | None = None,
+    ) -> None:
+        """Perform the actual update: pip install + restart.
+        
+        This is the single update algorithm used by both MQTT (HA) and WebUI.
+        
+        Handles pre-release versions by adding --pre flag.
+        Retries up to 3 times with 30s delay if pip install fails
+        (PyPI index may not have the version available immediately).
+        
+        Args:
+            target_version: Version to install, or None for latest.
+            on_progress: Optional callback(progress_pct, step, log_msg).
+                         Called at each stage so the caller can track progress.
+                         If None, only MQTT progress is published.
+        """
+        if self._update_running:
+            _LOGGER.warning("Update already in progress")
+            return
+        
+        self._update_running = True
+        current_version = __version__
         _LOGGER.info(
-            "Update installation should be triggered via WebUI or API endpoint /api/update"
+            "Starting update from %s to %s",
+            current_version, target_version or "latest"
+        )
+        
+        async def _report(progress: int, step: str, log_msg: str | None = None) -> None:
+            """Report progress to both MQTT and optional callback."""
+            await self._publish_update_progress(
+                current_version=current_version,
+                target_version=target_version,
+                progress=progress,
+            )
+            if on_progress:
+                on_progress(progress, step, log_msg)
+        
+        try:
+            await _report(5, "Finding virtual environment...")
+            
+            # Find virtual environment
+            possible_venv_paths = [
+                os.path.expanduser("~/boneio/venv"),
+                os.path.expanduser("~/venv"),
+                "/opt/boneio/venv",
+            ]
+            
+            pip_path = None
+            venv_path = None
+            for path in possible_venv_paths:
+                pip_candidate = os.path.join(path, "bin", "pip")
+                if os.path.exists(pip_candidate):
+                    venv_path = path
+                    pip_path = pip_candidate
+                    _LOGGER.info("Found venv pip at %s", pip_path)
+                    break
+            
+            if not pip_path:
+                _LOGGER.error("Virtual environment not found, cannot update")
+                await _report(0, "Failed", "Could not find virtual environment")
+                return
+            
+            await _report(10, "Virtual environment found", f"Using venv at {venv_path}")
+            await _report(15, "Preparing update...", f"Current version: {current_version}")
+            await _report(30, "Upgrading pip...")
+            
+            # Upgrade pip first
+            pip_upgrade = subprocess.run(
+                [pip_path, "install", "--upgrade", "pip"],
+                capture_output=True, text=True, timeout=120
+            )
+            
+            if pip_upgrade.returncode == 0:
+                await _report(40, "Pip upgraded", "pip upgraded successfully")
+            else:
+                await _report(40, "Pip upgrade skipped", "pip upgrade failed, continuing...")
+            
+            # Build pip install command
+            pip_cmd = [pip_path, "install", "--upgrade"]
+            
+            # Add --pre flag for pre-release versions (dev, alpha, beta, rc)
+            needs_pre = False
+            if target_version and self._is_prerelease_version(target_version):
+                needs_pre = True
+            elif not target_version and self._is_prerelease_version(current_version):
+                needs_pre = True
+            
+            if needs_pre:
+                pip_cmd.append("--pre")
+                await _report(42, "Using --pre flag", "Pre-release version detected")
+            
+            if target_version:
+                pip_package = f"boneio=={target_version}"
+            else:
+                pip_package = "boneio"
+            
+            pip_cmd.append(pip_package)
+            
+            await _report(45, f"Downloading and installing {pip_package}...")
+            
+            # Retry logic: PyPI may not have the version available immediately
+            max_retries = 3
+            retry_delay = 30  # seconds
+            result = None
+            
+            for attempt in range(1, max_retries + 1):
+                await _report(
+                    45 + (attempt - 1) * 10,
+                    f"Installing (attempt {attempt}/{max_retries})...",
+                    f"Running: {' '.join(pip_cmd)}"
+                )
+                
+                result = subprocess.run(
+                    pip_cmd,
+                    capture_output=True, text=True, timeout=300
+                )
+                
+                if result.returncode == 0:
+                    break
+                
+                _LOGGER.warning(
+                    "pip install attempt %d/%d failed: %s",
+                    attempt, max_retries, result.stderr.strip()
+                )
+                
+                if attempt < max_retries:
+                    await _report(
+                        45 + attempt * 10,
+                        f"Retrying in {retry_delay}s...",
+                        f"Attempt {attempt} failed, PyPI index may not be ready"
+                    )
+                    await asyncio.sleep(retry_delay)
+            
+            if not result or result.returncode != 0:
+                error_msg = result.stderr.strip() if result else "Unknown error"
+                _LOGGER.error(
+                    "pip install failed after %d attempts: %s",
+                    max_retries, error_msg
+                )
+                await _report(0, "Update failed", error_msg)
+                return
+            
+            await _report(80, "BoneIO updated", "Package installed successfully")
+            await _report(85, "Verifying installation...")
+            
+            # Verify installed version
+            version_result = subprocess.run(
+                [pip_path, "show", "boneio"],
+                capture_output=True, text=True
+            )
+            new_version = current_version
+            if version_result.returncode == 0:
+                for line in version_result.stdout.split('\n'):
+                    if line.startswith('Version:'):
+                        new_version = line.split(':')[1].strip()
+                        break
+            
+            _LOGGER.info(
+                "Update successful: %s -> %s. Restarting in 2 seconds...",
+                current_version, new_version
+            )
+            
+            await _report(90, "Installation verified", f"Updated from {current_version} to {new_version}")
+            await _report(95, "Finalizing...")
+            
+            # Publish final success state (no longer in progress)
+            current_version = new_version  # update for final MQTT publish
+            await self._publish_update_progress(
+                current_version=new_version,
+                target_version=None,
+                progress=0,
+            )
+            if on_progress:
+                on_progress(100, "Update complete!", f"Restarting service in 2 seconds...")
+            
+            await asyncio.sleep(2)
+            
+            _LOGGER.info("Restarting BoneIO service after update...")
+            os._exit(0)
+            
+        except subprocess.TimeoutExpired:
+            _LOGGER.error("Update process timed out")
+            await _report(0, "Timeout", "Update process timed out")
+        except Exception as e:
+            _LOGGER.error("Error during update: %s", e, exc_info=True)
+            await _report(0, "Error", f"Unexpected error: {e}")
+        finally:
+            self._update_running = False
+
+    @staticmethod
+    def _is_prerelease_version(version_str: str) -> bool:
+        """Check if version string is a pre-release (dev, alpha, beta, rc).
+        
+        Args:
+            version_str: Version string to check
+            
+        Returns:
+            True if version is a pre-release
+        """
+        ver_lower = version_str.lower()
+        return any(x in ver_lower for x in ['dev', 'alpha', 'beta', 'rc'])
+
+    async def _publish_update_progress(
+        self,
+        current_version: str,
+        target_version: str | None,
+        progress: int,
+    ) -> None:
+        """Publish update progress state to MQTT for HA.
+        
+        HA update entity supports in_progress as:
+        - false/0: not updating
+        - true: updating (indeterminate)
+        - int 1-100: updating with progress percentage
+        
+        Args:
+            current_version: Currently installed version
+            target_version: Version being installed (None if not updating)
+            progress: Update progress percentage (0 = not updating, 1-100 = in progress)
+        """
+        # HA interprets 0/false as "not updating", 1-100 as "updating with progress"
+        in_progress_value: int | bool = progress if progress > 0 else False
+        
+        state_payload = {
+            "installed_version": current_version,
+            "latest_version": target_version or current_version,
+            "title": "boneIO Black Firmware",
+            "release_url": self._last_check_result.get("release_url", "") if self._last_check_result else "",
+            "release_summary": self._last_check_result.get("release_notes", "") if self._last_check_result else "",
+            "entity_picture": "http://boneio.eu/logo_fb_circle.png",
+            "in_progress": in_progress_value,
+        }
+        
+        topic_prefix = self._manager._config_helper.topic_prefix
+        self._manager.send_message(
+            topic=f"{topic_prefix}/update/state",
+            payload=json.dumps(state_payload),
+            retain=True,
         )
         
-        # TODO: Consider adding direct integration with update logic
-        # For now, users should use the WebUI to trigger updates
+        _LOGGER.debug("Published update progress: %d%%", progress)
 
     async def send_ha_autodiscovery(self) -> None:
         """Send Home Assistant autodiscovery for Update entity."""

{boneio-1.2.0.dev6 → boneio-1.2.0.dev8}/boneio/core/messaging/mqtt.py

@@ -144,6 +144,9 @@ class MQTTClient(MessageBus):
     @override
     async def subscribe_and_listen(self, topic: str, callback: Callable[[str, str], Awaitable[None]]) -> None:
         self._mqtt_energy_listeners[topic] = callback
+        # Subscribe immediately if already connected
+        if self._connection_established:
+            await self.subscribe(topics=[topic])
 
     @override
     async def unsubscribe_and_stop_listen(self, topic: str) -> None:
@@ -327,12 +330,11 @@ class MQTTClient(MessageBus):
                             topic=topic, payload=None, retain=True
                         )
                     break
-            if message.topic.matches(f"{self._config_helper.topic_prefix}/energy/#"):
-                callback_start = False
-                for topic, listener_callback in self._mqtt_energy_listeners.items():
-                    if message.topic.matches(topic):
-                        await listener_callback(str(message.topic), payload)
-                        break
+            for topic, listener_callback in self._mqtt_energy_listeners.items():
+                if message.topic.matches(topic):
+                    callback_start = False
+                    await listener_callback(str(message.topic), payload)
+                    break
             if callback_start:
                 _LOGGER.debug(
                     "Received message topic: %s, payload: %s",