boneio 1.4.0.dev3__tar.gz → 1.4.0.dev4__tar.gz

{boneio-1.4.0.dev3/boneio.egg-info → boneio-1.4.0.dev4}/PKG-INFO

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

{boneio-1.4.0.dev3 → boneio-1.4.0.dev4}/boneio/components/cover/cover.py

@@ -192,6 +192,12 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._movement_thread = None
         self._stop_event = threading.Event()
 
+        # Flag set by action executor to signal this call originates from a button action.
+        # Used by VenetianCover to conditionally skip tilt restore.
+        self._from_action: bool = False
+        # When True, tilt restore is explicitly requested by the action definition.
+        self._action_tilt_restore: bool = False
+
         self._event_bus.add_sigterm_listener(self.on_exit)
 
         with suppress(RuntimeError):

{boneio-1.4.0.dev3 → boneio-1.4.0.dev4}/boneio/components/cover/venetian.py

@@ -35,7 +35,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             actuator_activation_duration: Actuator activation time (unused).
             restored_state: Persisted position/tilt from disk.
             tilt_restore_after_close: If True, restore previous tilt
-                position after closing the cover.
+                position after closing the cover (UI/HA calls).
         """
         self._tilt_duration = tilt_duration.total_milliseconds  # Czas trwania ruchu lameli
         self._initial_tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
@@ -300,10 +300,17 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     def _save_tilt_for_restore(self) -> None:
         """Save current tilt position for later restoration.
 
-        Called before any closing movement when tilt_restore_after_close
-        is enabled. Clears saved value if tilt is already at 0%.
+        Called before any closing movement. Determines whether to save
+        based on the call source:
+        - UI/HA calls: uses tilt_restore_after_close setting
+        - Action calls: uses _action_tilt_restore flag (set by executor)
         """
-        if self._tilt_restore_after_close and self._tilt_position > 0:
+        if self._from_action:
+            should_restore = self._action_tilt_restore
+        else:
+            should_restore = self._tilt_restore_after_close
+
+        if should_restore and self._tilt_position > 0:
             self._tilt_before_close = self._tilt_position
             _LOGGER.debug(
                 "VenetianCover %s: saving tilt=%d%% before close",

{boneio-1.4.0.dev3 → boneio-1.4.0.dev4}/boneio/components/output/remote.py

@@ -10,15 +10,21 @@ The actual hardware control is delegated to the parent ``ESPHomeDeviceManager``
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from boneio.const import OFF, ON, SWITCH
-from boneio.core.events import EventBus
+from boneio.core.events import EventBus, async_track_point_in_time, utcnow
+from boneio.core.utils import callback
+from boneio.core.utils.timeperiod import TimePeriod, parse_time_to_seconds
 from boneio.models import OutputState
 from boneio.models.events import OutputEvent
 
+if TYPE_CHECKING:
+    from boneio.integration.interlock import SoftwareInterlockManager
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -60,6 +66,16 @@ class RemoteOutputBase:
         show_in_ha: bool = False,
         area: str | None = None,
         on_disconnect: str = "ignore",
+        interlock_manager: SoftwareInterlockManager | None = None,
+        interlock_groups: list[str] | None = None,
+        enforce_interlock: bool = False,
+        momentary_turn_on: TimePeriod | None = None,
+        momentary_turn_off: TimePeriod | None = None,
+        adjustable_duration: bool = False,
+        duration_default: float = 60.0,
+        duration_min: float = 1.0,
+        duration_max: float = 3600.0,
+        duration_unit: str = "s",
     ) -> None:
         self._id = id
         self._name = name
@@ -72,10 +88,32 @@ class RemoteOutputBase:
         self.area: str | None = area
         self._on_disconnect = on_disconnect
 
+        # Interlock support (shared with local BasicOutput instances)
+        self._interlock_manager: SoftwareInterlockManager | None = interlock_manager
+        self._interlock_groups: list[str] = interlock_groups or []
+        self._enforce_interlock: bool = enforce_interlock
+
+        # Momentary actions (auto-off / auto-on after duration)
+        self._momentary_turn_on: TimePeriod | None = momentary_turn_on
+        self._momentary_turn_off: TimePeriod | None = momentary_turn_off
+        self._momentary_action: Any = None
+
+        # Adjustable duration (HA number entity slider)
+        self._adjustable_duration_enabled: bool = adjustable_duration
+        self._duration_min: float = max(1.0, duration_min)
+        self._duration_max: float = max(self._duration_min, duration_max)
+        self._duration_default: float = duration_default
+        self._duration_unit: str = duration_unit
+        self._adjustable_duration: float = max(self._duration_min, min(self._duration_max, self._duration_default))
+        # If adjustable_duration is on, momentary_turn_on is managed by the slider
+        if self._adjustable_duration_enabled:
+            self._momentary_turn_on = None
+
         self._state: str = OFF
         self._last_timestamp: float = 0.0
         self._available: bool = False
         self._brightness: int | None = None  # 0-255, None if not a dimmable light
+        self._loop: asyncio.AbstractEventLoop | None = None
 
         # Reference to remote device manager — set by register_remote_outputs().
         # May be None at startup if ESPHome devices load in background.
@@ -186,6 +224,34 @@ class RemoteOutputBase:
                 self._id,
             )
 
+    # ------------------------------------------------------------------
+    # Interlock
+    # ------------------------------------------------------------------
+
+    def set_interlock(
+        self,
+        interlock_manager: SoftwareInterlockManager,
+        interlock_groups: list[str],
+    ) -> None:
+        """Set interlock manager and groups.
+
+        Args:
+            interlock_manager: Shared interlock manager instance.
+            interlock_groups: List of group names this output belongs to.
+        """
+        self._interlock_manager = interlock_manager
+        self._interlock_groups = interlock_groups
+
+    def check_interlock(self) -> bool:
+        """Check if this output can be turned on without violating interlocks.
+
+        Returns:
+            True if no interlock violation, False if blocked.
+        """
+        if self._interlock_manager is not None and self._interlock_groups:
+            return self._interlock_manager.can_turn_on(self, self._interlock_groups)
+        return True
+
     # ------------------------------------------------------------------
     # Core control methods (duck-type compatible with BasicOutput)
     # ------------------------------------------------------------------
@@ -193,12 +259,21 @@ class RemoteOutputBase:
     async def async_turn_on(self, timestamp: float | None = None) -> bool:
         """Turn on the remote output.
 
+        Checks interlock before sending the ON command. If another output
+        in the same interlock group is already ON, the request is rejected.
+        After successful ON, schedules momentary auto-OFF if configured.
+
         Args:
             timestamp: Optional timestamp for state tracking.
 
         Returns:
-            True if the output was turned on, False on failure.
+            True if the output was turned on, False if blocked or failed.
         """
+        can_turn_on = self.check_interlock()
+        if not can_turn_on:
+            _LOGGER.warning("Interlock active: cannot turn on remote output '%s'", self._id)
+            return False
+
         if not self._resolve_device_manager():
             _LOGGER.error("Remote output '%s' has no device manager, cannot turn on", self._id)
             return False
@@ -211,6 +286,7 @@ class RemoteOutputBase:
             self._state = ON
             self._last_timestamp = timestamp or time.time()
             self._emit_state_event()
+            self._execute_momentary_turn(ON)
             _LOGGER.debug("Remote output '%s' turned ON", self._id)
         else:
             _LOGGER.warning("Failed to turn ON remote output '%s'", self._id)
@@ -219,6 +295,8 @@ class RemoteOutputBase:
     async def async_turn_off(self, timestamp: float | None = None) -> None:
         """Turn off the remote output.
 
+        After successful OFF, schedules momentary auto-ON if configured.
+
         Args:
             timestamp: Optional timestamp for state tracking.
         """
@@ -234,6 +312,7 @@ class RemoteOutputBase:
             self._state = OFF
             self._last_timestamp = timestamp or time.time()
             self._emit_state_event()
+            self._execute_momentary_turn(OFF)
             _LOGGER.debug("Remote output '%s' turned OFF", self._id)
         else:
             _LOGGER.warning("Failed to turn OFF remote output '%s'", self._id)
@@ -259,6 +338,10 @@ class RemoteOutputBase:
         Called by ESPHomeDeviceManager when it receives a state update
         for this output's entity.
 
+        If ``enforce_interlock`` is enabled and the output was turned ON
+        externally while violating an interlock, boneIO will immediately
+        send a turn-off command.
+
         Args:
             new_state: ``True`` if the output is now ON.
             brightness: Optional brightness value (0-255) for dimmable lights.
@@ -281,6 +364,15 @@ class RemoteOutputBase:
             self._brightness,
         )
 
+        # Enforce interlock: if turned ON externally and violating interlock,
+        # immediately send OFF command to the remote device.
+        if new_state and self._enforce_interlock and not self.check_interlock():
+            _LOGGER.warning(
+                "Remote output '%s' turned ON externally, violating interlock — forcing OFF",
+                self._id,
+            )
+            asyncio.ensure_future(self._enforce_interlock_off())
+
     async def async_set_brightness(self, brightness: int, timestamp: float | None = None) -> None:
         """Set brightness on the remote light output.
 
@@ -386,9 +478,138 @@ class RemoteOutputBase:
             area=self.area,
             remote=True,
             brightness=self._brightness,
+            interlock_groups=self._interlock_groups,
         )
         self._event_bus.trigger_event(OutputEvent(entity_id=self._id, state=output_state))
 
+    # ------------------------------------------------------------------
+    # Momentary actions (auto-off / auto-on after delay)
+    # ------------------------------------------------------------------
+
+    def _execute_momentary_turn(self, momentary_type: str) -> None:
+        """Schedule momentary action (auto-off after ON, or auto-on after OFF).
+
+        If adjustable_duration is enabled and this is a turn-ON action,
+        the slider value is used instead of the static momentary_turn_on.
+
+        Args:
+            momentary_type: ON or OFF.
+        """
+        if self._loop is None:
+            try:
+                self._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                return
+
+        if self._momentary_action:
+            _LOGGER.debug("Cancelling momentary action for %s", self._name)
+            self._momentary_action()
+
+        if momentary_type == ON:
+            action = self.async_turn_off
+            if self._adjustable_duration_enabled:
+                delayed_action = TimePeriod(seconds=self._adjustable_duration)
+            else:
+                delayed_action = self._momentary_turn_on
+        else:
+            action = self.async_turn_on
+            delayed_action = self._momentary_turn_off
+
+        if delayed_action:
+            _LOGGER.debug(
+                "Scheduling momentary action for %s in %s",
+                self._name,
+                delayed_action.as_timedelta,
+            )
+            self._momentary_action = async_track_point_in_time(
+                loop=self._loop,
+                job=self._momentary_callback,
+                point_in_time=utcnow() + delayed_action.as_timedelta,
+                action=action,
+            )
+
+    @callback
+    async def _momentary_callback(self, timestamp: float, action: Any) -> None:
+        """Execute the scheduled momentary turn-on or turn-off."""
+        _LOGGER.info("Momentary callback at %s for remote output %s", timestamp, self._name)
+        await action(timestamp=timestamp)
+        self._momentary_action = None
+
+    # -- Adjustable duration -------------------------------------------------
+
+    @property
+    def adjustable_duration_enabled(self) -> bool:
+        """Whether this output has an adjustable duration (HA number entity)."""
+        return self._adjustable_duration_enabled
+
+    @property
+    def adjustable_duration(self) -> float:
+        """Current adjustable duration value in seconds."""
+        return self._adjustable_duration
+
+    @property
+    def duration_min(self) -> float:
+        """Minimum duration in seconds for HA slider."""
+        return self._duration_min
+
+    @property
+    def duration_max(self) -> float:
+        """Maximum duration in seconds for HA slider."""
+        return self._duration_max
+
+    @property
+    def duration_unit(self) -> str:
+        """Unit of measurement for HA number entity ('s' or 'min')."""
+        return self._duration_unit
+
+    def set_adjustable_duration(self, seconds: float) -> None:
+        """Set the adjustable duration value.
+
+        Clamps to [duration_min, duration_max].
+
+        Args:
+            seconds: New duration in seconds.
+        """
+        self._adjustable_duration = max(self._duration_min, min(self._duration_max, seconds))
+        _LOGGER.debug(
+            "Remote output '%s' adjustable duration set to %.1fs",
+            self.id,
+            self._adjustable_duration,
+        )
+
+    def restore_adjustable_duration(self, seconds: float) -> None:
+        """Restore persisted duration value.
+
+        Args:
+            seconds: Persisted duration value.
+        """
+        self._adjustable_duration = max(self._duration_min, min(self._duration_max, seconds))
+
+    async def _enforce_interlock_off(self) -> None:
+        """Send OFF command to remote device after interlock violation.
+
+        Called when the remote device reports ON state that violates an
+        active interlock group. Small delay allows the state to settle.
+        """
+        await asyncio.sleep(0.1)  # Allow state to settle
+        if not self._resolve_device_manager():
+            _LOGGER.error(
+                "Cannot enforce interlock OFF on '%s': no device manager",
+                self._id,
+            )
+            return
+        success = await self._device_manager.control_output(
+            output_id=self._output_id,
+            action="OFF",
+        )
+        if success:
+            _LOGGER.info("Interlock enforced: remote output '%s' turned OFF", self._id)
+        else:
+            _LOGGER.error(
+                "Failed to enforce interlock OFF on remote output '%s'",
+                self._id,
+            )
+
     # ------------------------------------------------------------------
     # Properties (duck-type compatible with BasicOutput)
     # ------------------------------------------------------------------

{boneio-1.4.0.dev3 → boneio-1.4.0.dev4}/boneio/core/manager/manager.py

@@ -169,6 +169,10 @@ class Manager:
         # Used by the delay/delay_cancel_on action system (e.g. motion sensors)
         self._pending_delayed_actions: dict[str, list[asyncio.Task]] = {}
 
+        # Pending remote tilt restores: key = "device_id:cover_id" -> asyncio.Task
+        # Background tasks that wait for ESPHome cover IDLE then restore tilt
+        self._pending_tilt_restores: dict[str, asyncio.Task] = {}
+
         # Startup status tracking
         self._startup_status: str = "initializing"
         self._startup_complete: bool = False
@@ -1043,8 +1047,16 @@ class Manager:
                 cover.name if hasattr(cover, "name") else entity_id,
                 time.time() - start_time,
             )
-            _f = getattr(cover, action_to_execute)
-            await _f(**filtered_data)
+            # Signal to cover that this call originates from an action.
+            # If restore_tilt is set in the action definition, enable tilt restore.
+            cover._from_action = True
+            cover._action_tilt_restore = bool(action_definition.get("restore_tilt", False))
+            try:
+                _f = getattr(cover, action_to_execute)
+                await _f(**filtered_data)
+            finally:
+                cover._from_action = False
+                cover._action_tilt_restore = False
 
         elif action == OUTPUT_OVER_MQTT:
             boneio_id = action_definition.get("boneio_id")
@@ -1127,6 +1139,21 @@ class Manager:
             assert entity_id and remote_device_id  # guaranteed by guard above
             action_cover = action_definition.get("action_cover", "TOGGLE")
             extra_data = action_definition.get("extra_data", {})
+            restore_tilt = action_definition.get("restore_tilt", False)
+
+            # Save tilt before executing action (ESPHome only)
+            saved_tilt_pct: int | None = None
+            if restore_tilt:
+                cover_state = self.remote_devices.get_cover_state(
+                    remote_device_id, entity_id
+                )
+                if cover_state and cover_state.get("tilt") is not None:
+                    saved_tilt_pct = int(round(cover_state["tilt"] * 100))
+                    _LOGGER.debug(
+                        "Remote cover %s/%s: saving tilt=%d%% for restore",
+                        remote_device_id, entity_id, saved_tilt_pct,
+                    )
+
             await self.remote_devices.control_cover(
                 device_id=remote_device_id,
                 cover_id=entity_id,
@@ -1134,6 +1161,19 @@ class Manager:
                 **extra_data,
             )
 
+            # Schedule background tilt restore after movement completes
+            if saved_tilt_pct is not None and saved_tilt_pct > 0:
+                task_key = f"{remote_device_id}:{entity_id}"
+                # Cancel any previous pending restore for the same cover
+                old_task = self._pending_tilt_restores.get(task_key)
+                if old_task and not old_task.done():
+                    old_task.cancel()
+                self._pending_tilt_restores[task_key] = asyncio.create_task(
+                    self._restore_remote_tilt(
+                        remote_device_id, entity_id, saved_tilt_pct
+                    )
+                )
+
     async def _run_delayed_action(
         self, input_id: str, action_definition: dict, delay_seconds: float
     ) -> None:
@@ -1203,6 +1243,58 @@ class Manager:
             )
         return cancelled
 
+    async def _restore_remote_tilt(
+        self, device_id: str, cover_id: str, tilt_pct: int
+    ) -> None:
+        """Restore tilt position on a remote ESPHome cover after movement.
+
+        Waits for the cover to reach IDLE state, then sends a set_tilt
+        command to restore the previously saved tilt position.
+
+        Args:
+            device_id: Remote device ID
+            cover_id: Cover entity ID on the remote device
+            tilt_pct: Tilt position to restore (0-100)
+        """
+        task_key = f"{device_id}:{cover_id}"
+        try:
+            _LOGGER.debug(
+                "Waiting for remote cover %s/%s to reach IDLE before restoring tilt=%d%%",
+                device_id, cover_id, tilt_pct,
+            )
+            # Wait for cover to stop moving (up to 120s)
+            if not await self.remote_devices.wait_for_cover_idle(device_id, cover_id):
+                _LOGGER.warning(
+                    "Remote cover %s/%s did not reach IDLE, skipping tilt restore",
+                    device_id, cover_id,
+                )
+                return
+
+            # Small settle delay to avoid command overlap
+            await asyncio.sleep(0.5)
+
+            _LOGGER.info(
+                "Restoring tilt=%d%% on remote cover %s/%s",
+                tilt_pct, device_id, cover_id,
+            )
+            await self.remote_devices.control_cover(
+                device_id=device_id,
+                cover_id=cover_id,
+                action="TILT",
+                tilt_position=tilt_pct,
+            )
+        except asyncio.CancelledError:
+            _LOGGER.debug(
+                "Remote tilt restore cancelled for %s/%s (new action triggered?)",
+                device_id, cover_id,
+            )
+        except Exception:
+            _LOGGER.exception(
+                "Failed to restore tilt on remote cover %s/%s", device_id, cover_id
+            )
+        finally:
+            self._pending_tilt_restores.pop(task_key, None)
+
     def _reload_logger(self) -> None:
         """Reload logger configuration from config file.
 
@@ -1300,6 +1392,25 @@ class Manager:
             area = out_cfg.get("area")
             on_disconnect = str(out_cfg.get("on_disconnect", "ignore"))
 
+            # Interlock configuration
+            interlock_groups = out_cfg.get("interlock_group", [])
+            if isinstance(interlock_groups, str):
+                interlock_groups = [interlock_groups]
+            enforce_interlock = bool(out_cfg.get("enforce_interlock", False))
+
+            # Momentary actions
+            momentary_turn_on = out_cfg.get("momentary_turn_on")
+            momentary_turn_off = out_cfg.get("momentary_turn_off")
+
+            # Adjustable duration
+            adjustable_duration_enabled = bool(out_cfg.get("adjustable_duration", False))
+            from boneio.core.utils.timeperiod import parse_time_to_seconds
+
+            dur_default = parse_time_to_seconds(out_cfg.get("duration_default"), 60.0)
+            dur_min = max(1.0, parse_time_to_seconds(out_cfg.get("duration_min"), 1.0))
+            dur_max = max(dur_min, parse_time_to_seconds(out_cfg.get("duration_max"), 3600.0))
+            dur_unit = str(out_cfg.get("duration_unit", "s"))
+
             # Check for duplicates
             if self.outputs.get_output(entity_id) is not None:
                 _LOGGER.warning(
@@ -1319,8 +1430,22 @@ class Manager:
                 show_in_ha=show_in_ha,
                 area=area,
                 on_disconnect=on_disconnect,
+                interlock_manager=self.outputs._interlock_manager,
+                interlock_groups=interlock_groups,
+                enforce_interlock=enforce_interlock,
+                momentary_turn_on=momentary_turn_on,
+                momentary_turn_off=momentary_turn_off,
+                adjustable_duration=adjustable_duration_enabled,
+                duration_default=dur_default,
+                duration_min=dur_min,
+                duration_max=dur_max,
+                duration_unit=dur_unit,
             )
 
+            # Register in shared interlock manager
+            if interlock_groups:
+                self.outputs._interlock_manager.register(remote_output, interlock_groups)
+
             # Set the device manager reference if the device is already loaded.
             # ESPHome devices may not be in _devices yet (loaded in background),
             # so _device_manager may remain None — resolved lazily in
@@ -1342,11 +1467,12 @@ class Manager:
             # Register in OutputManager so it's available everywhere
             self.outputs._outputs[entity_id] = remote_output  # type: ignore[assignment]
             _LOGGER.info(
-                "Registered remote output: id='%s' device='%s' output='%s' type='%s'",
+                "Registered remote output: id='%s' device='%s' output='%s' type='%s' interlock=%s",
                 entity_id,
                 device_id,
                 output_id,
                 output_type,
+                interlock_groups or "none",
             )
 
         _LOGGER.info(

{boneio-1.4.0.dev3 → boneio-1.4.0.dev4}/boneio/core/manager/remote.py

@@ -609,6 +609,64 @@ class RemoteDeviceManager:
             **kwargs,
         )
 
+    def get_cover_state(self, device_id: str, cover_id: str) -> dict[str, Any] | None:
+        """Get current cover state from an ESPHome remote device.
+
+        Returns the cached state dict containing position, tilt,
+        current_operation, and last_known_operation.
+
+        Args:
+            device_id: ID of the remote device
+            cover_id: ID of the cover
+
+        Returns:
+            State dictionary or None if device/cover not found or not ESPHome
+        """
+        device = self.get_device(device_id)
+        if not device or device.protocol != RemoteDeviceProtocol.ESPHOME_API:
+            return None
+        return cast(Any, device)._cover_states.get(cover_id)
+
+    async def wait_for_cover_idle(
+        self,
+        device_id: str,
+        cover_id: str,
+        timeout: float = 120.0,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        """Wait for an ESPHome cover to reach IDLE state.
+
+        Polls the cached cover state until current_operation becomes 0 (IDLE)
+        or the timeout expires.
+
+        Args:
+            device_id: ID of the remote device
+            cover_id: ID of the cover to monitor
+            timeout: Maximum time to wait in seconds (default: 120s)
+            poll_interval: Time between polls in seconds (default: 0.5s)
+
+        Returns:
+            True if cover reached IDLE, False on timeout
+        """
+        device = self.get_device(device_id)
+        if not device or device.protocol != RemoteDeviceProtocol.ESPHOME_API:
+            return False
+
+        esphome = cast(Any, device)
+        start = asyncio.get_event_loop().time()
+
+        while asyncio.get_event_loop().time() - start < timeout:
+            state = esphome._cover_states.get(cover_id, {})
+            if state.get("current_operation", 0) == 0:
+                return True
+            await asyncio.sleep(poll_interval)
+
+        _LOGGER.warning(
+            "Timeout (%.0fs) waiting for cover '%s' on device '%s' to reach IDLE",
+            timeout, cover_id, device_id,
+        )
+        return False
+
     async def reload(self, remote_devices_config: list[dict[str, Any]] | None = None) -> None:
         """Reload remote devices from config.
 

{boneio-1.4.0.dev3 → boneio-1.4.0.dev4}/boneio/schema/actions.yaml

@@ -69,6 +69,17 @@ schema:
             Position threshold for SMART_TOGGLE action.
             If cover position is at or below this value, it will always open.
             Above this value, normal toggle behavior applies.
+  restore_tilt:
+    type: boolean
+    required: False
+    default: false
+    meta:
+      label: Restore Tilt After Movement
+      description: |
+        When true, the previous tilt angle is saved before executing this cover action
+        and restored after the movement finishes. Only applies to venetian covers.
+        Example: pressing a button to close the blinds to 50% and then restoring
+        the slat angle to the previous value.
   action_output:
     type: string
     required_if: