boneIO 1.2.0.dev20__tar.gz → 1.2.0.dev23__tar.gz

{boneio-1.2.0.dev20/boneio.egg-info → boneio-1.2.0.dev23}/PKG-INFO

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

boneio-1.2.0.dev23/boneio/components/cover/__init__.py

@@ -0,0 +1,5 @@
+"""Cover classes."""
+from .time_based import TimeBasedCover
+from .venetian import VenetianCover
+
+__all__ = ["TimeBasedCover", "VenetianCover"]

{boneio-1.2.0.dev20 → boneio-1.2.0.dev23}/boneio/components/cover/cover.py

@@ -16,11 +16,11 @@ from boneio.const import (
     OPEN,
     OPENING,
 )
-from boneio.core.events import EventBus, async_track_point_in_time, utcnow
+from boneio.core.events import EventBus
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
 from boneio.models import CoverState, PositionDict
-from boneio.components.output import MCPOutput
+from boneio.components.output import BasicOutput
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
@@ -30,8 +30,8 @@ class BaseCoverABC(ABC):
 
     @abstractmethod
     def __init__(self, id: str,
-        open_relay: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,
@@ -147,8 +147,8 @@ class BaseVenetianCoverABC:
 
 class BaseCover(BaseCoverABC, BasicMqtt):
     def __init__(self, id: str,
-        open_relay: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,
@@ -284,6 +284,29 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         else:
             await self.close()
 
+    async def smart_toggle(self, always_open_till: int = 50) -> None:
+        """Smart toggle with position threshold.
+
+        If cover is moving → stop.
+        If position <= always_open_till → open (to 100%).
+        If position > always_open_till → normal toggle (based on last_operation).
+
+        Args:
+            always_open_till: Position threshold (0-100%). Below or equal this
+                value the cover will always open. Above it, normal toggle applies.
+        """
+        _LOGGER.debug(
+            "Smart toggle cover %s (position=%d%%, threshold=%d%%)",
+            self._id, self._position, always_open_till,
+        )
+        if self._current_operation != IDLE:
+            await self.stop()
+        elif self._position <= always_open_till:
+            await self.open()
+        elif self._last_operation == CLOSING:
+            await self.open()
+        else:
+            await self.close()
 
     @property
     def state(self) -> str:

{boneio-1.2.0.dev20 → boneio-1.2.0.dev23}/boneio/components/cover/time_based.py

@@ -10,7 +10,7 @@ from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.components.cover.cover import BaseCover
 from boneio.core.events import EventBus
 from boneio.core.utils import TimePeriod
-from boneio.components.output import MCPOutput
+from boneio.components.output import BasicOutput
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_RESTORED_STATE = {"position": 100}
@@ -19,8 +19,8 @@ class TimeBasedCover(BaseCover):
     """Time-based cover algorithm similar to ESPHome."""
     def __init__(
         self,
-        open_relay: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,

{boneio-1.2.0.dev20 → boneio-1.2.0.dev23}/boneio/const.py

@@ -181,6 +181,7 @@ cover_actions = {
     "STOP": "stop",
     "TOGGLE_OPEN": "toggle_open",
     "TOGGLE_CLOSE": "toggle_close",
+    "SMART_TOGGLE": "smart_toggle",
     "TILT": "set_tilt",
     'TILT_OPEN': 'tilt_open',
     'TILT_CLOSE': 'tilt_close',

{boneio-1.2.0.dev20 → boneio-1.2.0.dev23}/boneio/core/manager/covers.py

@@ -2,7 +2,6 @@
 
 This module manages all cover devices including:
 - Time-based covers
-- Previous-state covers
 - Venetian blinds
 - Cover actions and callbacks
 """
@@ -21,14 +20,14 @@ from boneio.integration import ha_cover_availabilty_message
 from boneio.integration.homeassistant import ha_cover_with_tilt_availabilty_message
 
 if TYPE_CHECKING:
-    from boneio.components.cover import PreviousCover, TimeBasedCover, VenetianCover
+    from boneio.components.cover import TimeBasedCover, VenetianCover
     from boneio.core.manager import Manager
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class CoverManager:
-    """Manages all covers (time-based, previous-state, venetian).
+    """Manages all covers (time-based, venetian).
     
     This manager handles:
     - Cover configuration and initialization
@@ -49,7 +48,7 @@ class CoverManager:
     ):
         """Initialize cover manager."""
         self._manager = manager
-        self._covers: dict[str, PreviousCover | TimeBasedCover | VenetianCover] = {}
+        self._covers: dict[str, TimeBasedCover | VenetianCover] = {}
         self._config_covers = cover_config
         
         # Configure covers if outputs exist
@@ -73,6 +72,28 @@ class CoverManager:
             config = self._manager._config_helper.reload_config()
             self._config_covers = config.get(COVER, [])
             self._manager._config_helper.clear_autodiscovery_type(ha_type=COVER)
+
+            # Remove covers that are no longer in config
+            new_ids = set()
+            for _cfg in self._config_covers:
+                if _cfg.get(ID):
+                    new_ids.add(strip_accents(_cfg[ID]))
+                else:
+                    _open = str(_cfg.get("open_relay", ""))
+                    _close = str(_cfg.get("close_relay", ""))
+                    new_ids.add(f"cover_{_open}_{_close}".lower().replace(" ", "_"))
+
+            removed_ids = [cid for cid in self._covers if cid not in new_ids]
+            for cid in removed_ids:
+                _LOGGER.info("Cover %s removed from config, cleaning up", cid)
+                cover = self._covers.pop(cid)
+                # Stop cover movement if running
+                try:
+                    asyncio.ensure_future(cover.stop())
+                except Exception:
+                    pass
+                # Remove HA autodiscovery
+                self._remove_cover_ha_discovery(cid)
         
         for _config in self._config_covers:
             # Get relay outputs for cover
@@ -110,11 +131,11 @@ class CoverManager:
                 # Update existing cover or create new one
                 if _id in self._covers:
                     _cover = self._covers[_id]
-                    new_platform = _config.get("platform", "previous")
+                    new_platform = _config.get("platform", "time_based")
                     
                     # Check if platform (cover type) changed - need to recreate cover
                     current_kind = _cover.kind
-                    new_kind = "venetian" if new_platform == "venetian" else ("time" if new_platform == "time_based" else "previous")
+                    new_kind = "venetian" if new_platform == "venetian" else "time"
                     
                     if current_kind != new_kind:
                         # Platform changed - remove old cover and create new one
@@ -127,7 +148,16 @@ class CoverManager:
                         # Remove old cover from dict (will be recreated below)
                         del self._covers[_id]
                     else:
-                        # Same platform - just update times and autodiscovery
+                        # Same platform - update relays, times and autodiscovery
+                        old_open = getattr(_cover._open_relay, 'id', None)
+                        old_close = getattr(_cover._close_relay, 'id', None)
+                        if old_open != open_relay_id or old_close != close_relay_id:
+                            _LOGGER.info(
+                                "Cover %s relays changed: open %s->%s, close %s->%s",
+                                _id, old_open, open_relay_id, old_close, close_relay_id
+                            )
+                        _cover._open_relay = open_relay
+                        _cover._close_relay = close_relay
                         _cover.update_config_times(_config)
                         # Re-send HA autodiscovery with potentially new area
                         if _config.get(SHOW_HA, True):
@@ -170,7 +200,7 @@ class CoverManager:
         cover_name: str,
         config: dict,
         tilt_duration: TimePeriod | None,
-    ) -> PreviousCover | TimeBasedCover | VenetianCover:
+    ) -> TimeBasedCover | VenetianCover:
         """Configure a cover instance.
         
         Args:
@@ -185,7 +215,7 @@ class CoverManager:
         Raises:
             CoverConfigurationException: If cover configuration is invalid
         """
-        from boneio.components.cover import PreviousCover, TimeBasedCover, VenetianCover
+        from boneio.components.cover import TimeBasedCover, VenetianCover
         
         platform = config.get("platform", "time_based")
         
@@ -241,8 +271,11 @@ class CoverManager:
                 **{k: v for k, v in config.items() if k not in ("id", "platform", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
             )
             availability_msg_func = ha_cover_availabilty_message
-        elif platform == "previous":
-            _LOGGER.debug("Configuring previous cover %s", cover_id)
+        else:
+            _LOGGER.warning(
+                "Unknown cover platform '%s' for %s, falling back to time_based",
+                platform, cover_id
+            )
             restored_state = self._manager._state_manager.get(
                 attr_type=COVER, attr=cover_id, default_value={"position": 100}
             )
@@ -250,7 +283,7 @@ class CoverManager:
                 restored_state = {"position": restored_state}
             elif isinstance(restored_state, str):
                 restored_state = {"position": 100}
-            cover = PreviousCover(
+            cover = TimeBasedCover(
                 id=cover_id,
                 name=cover_name,
                 state_save=state_save,
@@ -298,7 +331,7 @@ class CoverManager:
             # Remove from internal cache
             self._manager._config_helper.remove_autodiscovery_msg(ha_type, topic)
 
-    def get_cover(self, id: str) -> PreviousCover | TimeBasedCover | VenetianCover | None:
+    def get_cover(self, id: str) -> TimeBasedCover | VenetianCover | None:
         """Get cover by ID.
         
         Args:
@@ -309,7 +342,7 @@ class CoverManager:
         """
         return self._covers.get(id)
 
-    def get_all_covers(self) -> dict[str, PreviousCover | TimeBasedCover | VenetianCover]:
+    def get_all_covers(self) -> dict[str, TimeBasedCover | VenetianCover]:
         """Get all covers.
         
         Returns:
@@ -391,20 +424,10 @@ class CoverManager:
         
         This is called after reload to ensure frontend receives
         the state of all covers, including newly created ones.
-        
-        Handles both PreviousCover (send_state with no args) and BaseCover 
-        (send_state with state and json_position args) implementations.
         """
-        from boneio.components.cover import PreviousCover, TimeBasedCover, VenetianCover
-        
         for cover in self._covers.values():
             try:
-                if isinstance(cover, PreviousCover):
-                    # PreviousCover.send_state() takes no arguments
-                    cover.send_state()
-                elif isinstance(cover, (TimeBasedCover, VenetianCover)):
-                    # BaseCover.send_state(state, json_position) takes 2 arguments
-                    cover.send_state(cover.state, cover.json_position)
+                cover.send_state(cover.state, cover.json_position)
             except Exception as e:
                 _LOGGER.debug("Error broadcasting cover state %s: %s", cover.id, e)
 

{boneio-1.2.0.dev20 → boneio-1.2.0.dev23}/boneio/hardware/display/oled.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+import subprocess
 from itertools import cycle
 from typing import TYPE_CHECKING
 
@@ -13,7 +14,7 @@ from luma.oled.device import sh1106
 from PIL import Image, ImageDraw
 from PIL.ImageDraw import ImageDraw as ImageDrawType
 
-from boneio.const import OLED_PIN, UPTIME, WHITE
+from boneio.const import LONG, OLED_PIN, SINGLE, UPTIME, WHITE
 from boneio.core.events import EventBus, async_track_point_in_time, utcnow
 from boneio.core.system import HostData
 from boneio.core.utils.font_util import make_font
@@ -102,6 +103,24 @@ class Oled:
         self._cancel_sleep_handle = None
         self._sleep_timeout = sleep_timeout
         
+        # Shutdown confirmation state machine
+        # States: None -> "wait_release" -> "confirm" -> "progress" -> shutdown
+        # - First long press → show confirm screen, enter "wait_release"
+        # - Release after first long → enter "confirm" (waiting for second long)
+        # - Second long press → enter "progress" with filling progress bar
+        # - Hold 5s → execute shutdown
+        # - Single click or 10s timeout → cancel
+        self._shutdown_state: str | None = None
+        self._shutdown_cancel_handle = None
+        # Timer to detect button release (no LONG event for 300ms = released)
+        self._shutdown_release_timer: asyncio.TimerHandle | None = None
+        # Last seen long press duration — used to detect new press cycle (duration resets)
+        self._shutdown_last_long_duration: float = 0.0
+        # Duration (seconds) the user must hold the button to confirm shutdown
+        self._shutdown_hold_duration: float = 5.0
+        # Timeout (seconds) to cancel shutdown confirmation if no action
+        self._shutdown_confirm_timeout: float = 10.0
+        
         # Initialize I2C display
         try:
             # Use luma.oled for now, but could be refactored to use SMBus2I2C
@@ -219,14 +238,98 @@ class Oled:
         # Display the centered QR code
         self._device.display(display_image)
 
-    async def _handle_button_press(self, event: dict) -> None:
-        """Handle button press event from input."""
-        _LOGGER.debug(f"OLED button pressed event received: {event}")
+    async def _handle_button_press(self, event) -> None:
+        """Handle button press event from input.
+
+        Supports shutdown flow via long press:
+        1. First long press → show confirmation screen
+        2. User releases button → state moves to "confirm"
+        3. Second long press (held 5s) → progress bar fills, then shutdown
+        4. Any single click or 10s timeout → cancel shutdown
+
+        The detector emits periodic LONG events (every 200ms) with growing
+        duration while the button is held. A new press cycle is detected
+        when duration resets (new duration < last tracked duration).
+
+        Args:
+            event: InputEvent from EventBus with click_type and duration
+        """
+        click_type = getattr(event, "click_type", None)
+        duration = getattr(event, "duration", None) or 0.0
+
+        _LOGGER.debug("OLED button event: click_type=%s, duration=%.2f, shutdown_state=%s",
+                       click_type, duration, self._shutdown_state)
+
+        # --- Shutdown state machine ---
+
+        if self._shutdown_state == "wait_release":
+            # Absorb periodic LONG events from the first long press.
+            # Detector does NOT emit SINGLE after long press release.
+            # Detect release via timer: each LONG resets a 300ms timer.
+            # When no more LONG events arrive, timer fires → "confirm".
+            if click_type == LONG:
+                self._shutdown_last_long_duration = duration
+                # Reset release-detection timer
+                self._reset_release_timer()
+                return
+            elif click_type == SINGLE:
+                # Shouldn't happen after long, but handle gracefully
+                self._cancel_release_timer()
+                self._shutdown_state = "confirm"
+                self._shutdown_last_long_duration = 0.0
+                return
+            # Ignore other events
+            return
+
+        if self._shutdown_state == "confirm":
+            if click_type == LONG:
+                # Second long press — enter progress mode
+                self._shutdown_state = "progress"
+                self._cancel_shutdown_timeout()
+                self._shutdown_last_long_duration = duration
+                self._draw_shutdown_progress(duration)
+                if duration >= self._shutdown_hold_duration:
+                    await self._execute_shutdown()
+                return
+            elif click_type == SINGLE:
+                # Single click cancels shutdown confirmation
+                self._cancel_shutdown()
+                return
+            # Ignore other events during confirm
+            return
+
+        if self._shutdown_state == "progress":
+            if click_type == LONG:
+                if duration < self._shutdown_last_long_duration:
+                    # Duration reset — user released and pressed again, cancel
+                    self._cancel_shutdown()
+                    return
+                # Still holding — update progress bar
+                self._shutdown_last_long_duration = duration
+                self._draw_shutdown_progress(duration)
+                if duration >= self._shutdown_hold_duration:
+                    await self._execute_shutdown()
+                return
+            else:
+                # Released (single) or other — cancel
+                self._cancel_shutdown()
+                return
+
+        # --- Normal mode ---
         if self._sleep:
-            # Display is sleeping - wake it up
             self.wake_up()
-        else:
-            # Display is active - go to next screen
+            return
+
+        if click_type == LONG and duration < 1.0:
+            # First long press event — show confirmation, enter wait_release
+            self._shutdown_state = "wait_release"
+            self._shutdown_last_long_duration = duration
+            self._draw_shutdown_confirm()
+            self._start_shutdown_timeout()
+            self._reset_release_timer()
+            return
+
+        if click_type == SINGLE:
             self._next_screen()
 
     def _next_screen(self) -> None:
@@ -240,6 +343,150 @@ class Oled:
         self._current_screen = next(self._screen_cycle)
         self.render_display()
 
+    # --- Shutdown helper methods ---
+
+    def _draw_shutdown_confirm(self) -> None:
+        """Draw shutdown confirmation screen on OLED.
+        
+        Shows a warning message asking the user to hold the button
+        for 5 seconds to confirm system shutdown.
+        """
+        with canvas(self._device) as draw:
+            # Warning triangle
+            draw.polygon([(64, 2), (54, 18), (74, 18)], outline=WHITE)
+            draw.text((61, 5), "!", font=fonts["small"], fill=WHITE)
+            # Message
+            draw.text((10, 24), "Shutdown system?", font=fonts["small"], fill=WHITE)
+            draw.text((4, 38), "Hold button 5s to confirm", font=fonts["extraSmall"], fill=WHITE)
+            draw.text((8, 52), "Click to cancel (10s)", font=fonts["extraSmall"], fill=WHITE)
+
+    def _draw_shutdown_progress(self, duration: float) -> None:
+        """Draw shutdown progress bar on OLED.
+        
+        Shows a progress bar that fills proportionally to how long
+        the user has been holding the button vs the required duration.
+        
+        Args:
+            duration: How long the button has been held (seconds)
+        """
+        progress = min(duration / self._shutdown_hold_duration, 1.0)
+        bar_x, bar_y = 10, 34
+        bar_w, bar_h = 108, 14
+        fill_w = int(bar_w * progress)
+
+        with canvas(self._device) as draw:
+            draw.text((20, 4), "Shutting down...", font=fonts["small"], fill=WHITE)
+            draw.text((28, 18), f"{int(progress * 100)}%", font=fonts["small"], fill=WHITE)
+            # Progress bar outline
+            draw.rectangle([bar_x, bar_y, bar_x + bar_w, bar_y + bar_h], outline=WHITE)
+            # Progress bar fill
+            if fill_w > 0:
+                draw.rectangle([bar_x + 1, bar_y + 1, bar_x + fill_w - 1, bar_y + bar_h - 1], fill=WHITE)
+            draw.text((22, 54), "Release to cancel", font=fonts["extraSmall"], fill=WHITE)
+
+    def _start_shutdown_timeout(self) -> None:
+        """Start a 10-second timeout that cancels the shutdown confirmation.
+        
+        If the user doesn't interact within the timeout period,
+        the shutdown flow is cancelled and the normal screen is restored.
+        """
+        self._cancel_shutdown_timeout()
+        loop = self._event_bus._loop
+
+        def _timeout_callback() -> None:
+            """Cancel shutdown after timeout expires."""
+            _LOGGER.info("Shutdown confirmation timed out, cancelling")
+            self._shutdown_state = None
+            self._shutdown_cancel_handle = None
+            self.render_display()
+
+        self._shutdown_cancel_handle = loop.call_later(
+            self._shutdown_confirm_timeout, _timeout_callback
+        )
+
+    def _cancel_shutdown_timeout(self) -> None:
+        """Cancel the pending shutdown timeout timer."""
+        if self._shutdown_cancel_handle is not None:
+            self._shutdown_cancel_handle.cancel()
+            self._shutdown_cancel_handle = None
+
+    def _reset_release_timer(self) -> None:
+        """Reset the 300ms release-detection timer.
+        
+        Called on each periodic LONG event during wait_release state.
+        If no more LONG events arrive within 300ms, the timer fires
+        and transitions to 'confirm' state (button was released).
+        """
+        self._cancel_release_timer()
+        loop = self._event_bus._loop
+
+        def _on_release_detected() -> None:
+            """No LONG event for 300ms — button was released."""
+            self._shutdown_release_timer = None
+            if self._shutdown_state == "wait_release":
+                _LOGGER.debug("OLED button release detected (no LONG for 300ms)")
+                self._shutdown_state = "confirm"
+                self._shutdown_last_long_duration = 0.0
+                # Timeout already running from first long press
+
+        self._shutdown_release_timer = loop.call_later(0.3, _on_release_detected)
+
+    def _cancel_release_timer(self) -> None:
+        """Cancel the pending release-detection timer."""
+        if self._shutdown_release_timer is not None:
+            self._shutdown_release_timer.cancel()
+            self._shutdown_release_timer = None
+
+    def _cancel_shutdown(self) -> None:
+        """Cancel the shutdown flow and return to normal display.
+        
+        Resets the shutdown state machine and restores the current screen.
+        """
+        _LOGGER.info("Shutdown cancelled by user")
+        self._cancel_shutdown_timeout()
+        self._cancel_release_timer()
+        self._shutdown_state = None
+        self._shutdown_last_long_duration = 0.0
+        self.render_display()
+
+    async def _execute_shutdown(self) -> None:
+        """Execute system shutdown.
+        
+        Draws a final 'Goodbye' message on the OLED, then runs
+        'sudo shutdown -h now' to power off the device.
+        """
+        _LOGGER.warning("System shutdown initiated from OLED button")
+        self._shutdown_state = None
+        self._shutdown_last_long_duration = 0.0
+        self._cancel_shutdown_timeout()
+
+        # Draw goodbye screen
+        with canvas(self._device) as draw:
+            draw.text((20, 10), "Goodbye!", font=fonts["big"], fill=WHITE)
+            draw.text((15, 35), "System shutting down...", font=fonts["extraSmall"], fill=WHITE)
+
+        # Small delay so the user sees the message
+        await asyncio.sleep(1)
+
+        try:
+            subprocess.run(
+                ["sudo", "shutdown", "-h", "now"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            _LOGGER.error("Failed to shutdown device: %s", e.stderr)
+            # Show error on OLED and return to normal
+            with canvas(self._device) as draw:
+                draw.text((10, 20), "Shutdown failed!", font=fonts["small"], fill=WHITE)
+                draw.text((10, 40), str(e.stderr)[:20], font=fonts["extraSmall"], fill=WHITE)
+            await asyncio.sleep(3)
+            self.render_display()
+        except Exception as e:
+            _LOGGER.error("Error shutting down device: %s", e)
+            self.render_display()
+
     def render_display(self) -> None:
         """Render display - main method that decides what to display."""
         

{boneio-1.2.0.dev20 → boneio-1.2.0.dev23}/boneio/schema/actions.yaml

@@ -35,7 +35,7 @@ schema:
       action: ['cover', 'cover_over_mqtt', 'remote_cover']
     forbidden_if:
       action: ['output', 'mqtt', 'mqtt_output', 'remote_output']
-    allowed: ['TOGGLE', 'OPEN', 'CLOSE', 'STOP', 'TOGGLE_OPEN', 'TOGGLE_CLOSE', 'TILT', 'TILT_OPEN', 'TILT_CLOSE']
+    allowed: ['TOGGLE', 'OPEN', 'CLOSE', 'STOP', 'TOGGLE_OPEN', 'TOGGLE_CLOSE', 'SMART_TOGGLE', 'TILT', 'TILT_OPEN', 'TILT_CLOSE']
     coerce: action_field
     default: TOGGLE
     case_insensitive: true
@@ -58,6 +58,18 @@ schema:
         required: False
         meta:
           label: Tilt position to set cover to. 0 means closed, 100 means opened.
+      always_open_till:
+        type: integer
+        required: False
+        min: 0
+        max: 100
+        default: 50
+        meta:
+          label: Smart toggle threshold (0-100%).
+          description: |
+            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.
   action_output:
     type: string
     required_if:

{boneio-1.2.0.dev20 → boneio-1.2.0.dev23}/boneio/schema/schema.yaml

@@ -1219,7 +1219,7 @@ cover:
         type: string
         required: True
         default: time_based
-        allowed: ['time_based', 'venetian', 'previous']
+        allowed: ['time_based', 'venetian']
         meta:
           label: Platform to use for cover.
       open_time:

boneio-1.2.0.dev23/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.2.0dev23"