boneIO 1.5.0__tar.gz → 1.5.0.dev2__tar.gz

{boneio-1.5.0/boneio.egg-info → boneio-1.5.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.5.0
+Version: 1.5.0.dev2
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -13,7 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: smbus2==0.4.3
 Requires-Dist: aiomqtt==2.4.0
-Requires-Dist: aiohttp==3.14.1
+Requires-Dist: aiohttp==3.13.3
 Requires-Dist: Cerberus==1.3.7
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: luma-core==2.5.1
@@ -21,11 +21,11 @@ Requires-Dist: luma-oled==3.14.0
 Requires-Dist: pymodbus==3.11.3
 Requires-Dist: pyserial-asyncio-fast==0.16
 Requires-Dist: PyYAML==6.0.3
-Requires-Dist: psutil==7.2.2
+Requires-Dist: psutil==7.1.0
 Requires-Dist: w1thermsensor[async]==2.3.0
 Requires-Dist: fastapi==0.118.0
 Requires-Dist: pydantic==2.11.9
-Requires-Dist: hypercorn==0.18.0
+Requires-Dist: hypercorn==0.17.3
 Requires-Dist: websockets==15.0.1
 Requires-Dist: python-jose[cryptography]==3.5.0
 Requires-Dist: python-multipart==0.0.22

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/bonecli.py

@@ -132,7 +132,7 @@ def get_arguments() -> argparse.Namespace:
     set_modbus_parser.add_argument(
         "--device",
         type=str,
-        choices=["cwt", "r4dcb08", "liquid-sensor", "qdw90a", "sht20", "sht30", "custom"],
+        choices=["cwt", "r4dcb08", "liquid-sensor", "sht20", "sht30", "custom"],
         help="Choose device to set modbus address/baudrate. For custom you must provide --custom-value and --custom-register-address",
         required=True,
     )
@@ -217,9 +217,6 @@ def run(
     _t0 = _time.monotonic()
     setup_logging(debug_level=debug)
     _LOGGER.info("BoneIO %s starting.", __version__)
-    from boneio.core.config.yaml_compat import log_yaml_backend
-
-    log_yaml_backend()
     _LOGGER.debug("[STARTUP TIMING] after setup_logging: %.2fs", _time.monotonic() - _t0)
 
     # --- Initialize OLED before anything else (independent of config) ---

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/cover/cover.py

@@ -386,8 +386,8 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             **json_position,
         )
         self._event_bus.trigger_event(CoverEvent(entity_id=self.id, state=event))
-        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state, retain=True)
-        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json.dumps(json_position), retain=True)
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state)
+        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json.dumps(json_position))
 
     @property
     def saved_position(self) -> SavedPositionDict:

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/cover/time_based.py

@@ -12,7 +12,6 @@ from boneio.components.output import BasicOutput
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.core.events import EventBus
 from boneio.core.utils import TimePeriod
-from boneio.core.utils.timeperiod import ensure_time_period
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_RESTORED_STATE = {"position": 100}
@@ -152,6 +151,6 @@ class TimeBasedCover(BaseCover):
                    Keys: open_time, close_time
         """
         if "open_time" in config:
-            self._open_time = ensure_time_period(config["open_time"]).total_milliseconds
+            self._open_time = config["open_time"].total_milliseconds
         if "close_time" in config:
-            self._close_time = ensure_time_period(config["close_time"]).total_milliseconds
+            self._close_time = config["close_time"].total_milliseconds

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/cover/venetian.py

@@ -8,7 +8,6 @@ import time
 from boneio.components.cover.cover import BaseCover, BaseVenetianCoverABC
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.core.utils import TimePeriod
-from boneio.core.utils.timeperiod import ensure_time_period
 from boneio.models import PositionDict, SavedPositionDict
 
 _LOGGER = logging.getLogger(__name__)
@@ -182,12 +181,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
         # Tilt restore: schedule tilt recovery on the event loop.
-        # _tilt_before_close is only set by _save_tilt_for_restore() when
-        # the appropriate flag (UI or action) was enabled, so its presence
-        # is the authoritative signal that restore was requested.
         # Skip when position reached 0% (fully closed) or 100% (fully open)
         # — at extremes, restoring tilt contradicts user intent.
-        if self._tilt_before_close is not None:
+        if self._tilt_restore_after_close and self._tilt_before_close is not None:
             restore_tilt = self._tilt_before_close
             self._tilt_before_close = None
             at_extreme = self._position <= 0 or self._position >= 100
@@ -304,8 +300,8 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     def _save_tilt_for_restore(self) -> None:
         """Save current tilt position for later restoration.
 
-        Called before any movement (open, close, or set_position).
-        Determines whether to save based on the call source:
+        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)
         """
@@ -317,7 +313,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         if should_restore and self._tilt_position > 0:
             self._tilt_before_close = self._tilt_position
             _LOGGER.debug(
-                "VenetianCover %s: saving tilt=%d%% before movement",
+                "VenetianCover %s: saving tilt=%d%% before close",
                 self._id,
                 round(self._tilt_position),
             )
@@ -336,22 +332,26 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     async def set_cover_position(self, position: int) -> None:
         """Set cover position with tilt restore support.
 
-        Saves the current tilt so it can be restored after the movement
-        finishes, regardless of direction (up or down).
+        When moving to a lower position (closing direction) and
+        tilt_restore_after_close is enabled, saves the current tilt
+        so it can be restored after the movement finishes.
 
         Args:
             position: Target position (0-100).
         """
-        self._save_tilt_for_restore()
+        if position < self._position:
+            self._save_tilt_for_restore()
+        else:
+            self._tilt_before_close = None
         await super().set_cover_position(position)
 
     async def open(self) -> None:
         """Open venetian cover.
 
-        Saves the current tilt so it can be restored after the
-        opening movement finishes (same as close).
+        Clears any saved tilt-before-close value since opening
+        resets the tilt to 100% naturally.
         """
-        self._save_tilt_for_restore()
+        self._tilt_before_close = None
         await super().open()
 
     def update_config_times(self, config: dict) -> None:
@@ -362,11 +362,11 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
                    Keys: open_time, close_time, tilt_duration, tilt_restore_after_close
         """
         if "open_time" in config:
-            self._open_time = ensure_time_period(config["open_time"]).total_milliseconds
+            self._open_time = config["open_time"].total_milliseconds
         if "close_time" in config:
-            self._close_time = ensure_time_period(config["close_time"]).total_milliseconds
+            self._close_time = config["close_time"].total_milliseconds
         if "tilt_duration" in config and config["tilt_duration"]:
-            self._tilt_duration = ensure_time_period(config["tilt_duration"]).total_milliseconds
+            self._tilt_duration = config["tilt_duration"].total_milliseconds
         if "tilt_restore_after_close" in config:
             self._tilt_restore_after_close = bool(config["tilt_restore_after_close"])
 

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/input/detectors.py

@@ -65,9 +65,6 @@ class MultiClickDetector:
     Based on multiclick_detector.py from tests.
     """
 
-    # How often (in seconds) to verify physical GPIO state during long press
-    _GPIO_READBACK_INTERVAL_S = 3.0
-
     def __init__(
         self,
         loop: asyncio.AbstractEventLoop,
@@ -81,7 +78,7 @@ class MultiClickDetector:
         enable_triple_click: bool = False,
         name: str = "unknown",
         pin: str = "unknown",
-        max_long_press_seconds: float = 30.0,
+        max_long_press_seconds: float = 120.0,
     ):
         """Initialize multiclick detector.
         
@@ -97,7 +94,7 @@ class MultiClickDetector:
             enable_triple_click: Enable triple click detection (default: False)
             name: Name of the input
             pin: Pin name for logging
-            max_long_press_seconds: Safety timeout for long press in seconds (default: 30s)
+            max_long_press_seconds: Safety timeout for long press in seconds (default: 120s)
         """
         self._loop = loop
         self._callback = callback
@@ -110,19 +107,8 @@ class MultiClickDetector:
         self._enable_triple_click = enable_triple_click
         self._name = name
         self._pin = pin
-        self._max_long_press_seconds = min(max_long_press_seconds, 30.0)
+        self._max_long_press_seconds = max_long_press_seconds
         self._state = ClickState()
-        self._boot_press_suppressed = False  # Set by GpioManager._seed_initial_states
-        # Optional GPIO readback function: returns True if pin is HIGH (released)
-        # Set by GpioManager after startup to enable physical state verification
-        self._gpio_readback_fn: Callable[[], bool | None] | None = None
-        # Track last readback time to avoid reading GPIO too often
-        self._last_readback_time: float = 0.0
-        
-        _LOGGER.debug(
-            "MultiClickDetector init: %s (%s) max_long_press=%.1fs",
-            name, pin, self._max_long_press_seconds,
-        )
         
         # Pre-compute which click types should be delayed in exclusive mode
         # based on enabled sequences
@@ -376,20 +362,15 @@ class MultiClickDetector:
     def _detect_long_press(self) -> None:
         """Detect and report a long press and start periodic updates."""
         if not self._state.last_press_loop_ts:
-            _LOGGER.debug(
-                "_detect_long_press called for %s but no last_press_loop_ts — ignoring",
-                self._name,
-            )
             return
         
         # Reset executed actions for new long press
         self._state.executed_long_actions = set()
         self._state.last_repeat_times = {}
-        self._last_readback_time = self._loop.time()  # Reset readback timer
         
         duration = self._loop.time() - self._state.last_press_loop_ts
         
-        _LOGGER.info("Detected LONG press on %s (%s), duration=%.3fs", self._name, self._pin, duration)
+        _LOGGER.info("Detected LONG press on %s (%s)", self._name, self._pin)
         
         self._state.click_count = 0  # Reset click counter
         self._state.long_press_timer = None
@@ -403,29 +384,14 @@ class MultiClickDetector:
             0.2,  # 200ms
             self._send_periodic_long_event
         )
-        _LOGGER.debug(
-            "Started periodic long timer for %s (interval=200ms, max=%.0fs)",
-            self._name, self._max_long_press_seconds,
-        )
     
     def _send_periodic_long_event(self) -> None:
-        """Send periodic 'long' event with updated duration.
-        
-        Every _GPIO_READBACK_INTERVAL_S seconds, also reads the physical
-        GPIO state to detect missed RELEASE edge events.
-        """
+        """Send periodic 'long' event with updated duration."""
         if not self._state.last_press_loop_ts or self._state.last_release_ts:
             # Button released or invalid state
-            _LOGGER.debug(
-                "Periodic long skipped for %s: press_ts=%s, release_ts=%s",
-                self._name,
-                self._state.last_press_loop_ts is not None,
-                self._state.last_release_ts,
-            )
             return
         
-        now = self._loop.time()
-        duration = now - self._state.last_press_loop_ts
+        duration = self._loop.time() - self._state.last_press_loop_ts
         
         # Safety timeout: stop periodic events if duration exceeds max
         if duration > self._max_long_press_seconds:
@@ -440,35 +406,6 @@ class MultiClickDetector:
             self._force_stop_long_press()
             return
         
-        # GPIO readback check: every _GPIO_READBACK_INTERVAL_S, verify physical
-        # pin state to catch missed RELEASE edge events (EMI, kernel bugs, etc.)
-        if (
-            self._gpio_readback_fn is not None
-            and (now - self._last_readback_time) >= self._GPIO_READBACK_INTERVAL_S
-        ):
-            self._last_readback_time = now
-            try:
-                pin_is_high = self._gpio_readback_fn()
-                if pin_is_high is not None and pin_is_high:
-                    # Pin is HIGH = button released (pull-up), but we never got RISING_EDGE
-                    _LOGGER.warning(
-                        "GPIO readback: %s (%s) pin is HIGH (released) but no RELEASE event received! "
-                        "duration=%.1fs. Forcing stop — likely missed RISING_EDGE.",
-                        self._name,
-                        self._pin,
-                        duration,
-                    )
-                    self._force_stop_long_press()
-                    return
-                _LOGGER.debug(
-                    "GPIO readback: %s (%s) pin is LOW (still pressed), duration=%.1fs",
-                    self._name, self._pin, duration,
-                )
-            except Exception as exc:
-                _LOGGER.debug(
-                    "GPIO readback failed for %s: %s", self._name, exc,
-                )
-        
         _LOGGER.debug(
             "Periodic long event on %s (%s), duration=%.3fs",
             self._name,
@@ -554,21 +491,6 @@ class MultiClickDetector:
                 )
                 return
 
-            # Boot-press suppression: if GpioManager detected this pin was
-            # LOW at startup, the first FALLING_EDGE is a phantom boot event.
-            # Record the timestamp (for debounce) but do NOT schedule timers.
-            if self._boot_press_suppressed:
-                _LOGGER.info(
-                    "Suppressing phantom boot press on %s (%s) — recording timestamp only",
-                    self._name,
-                    self._pin,
-                )
-                self._state.last_press_ts = timestamp_s
-                self._state.last_press_loop_ts = None
-                self._state.last_release_ts = None
-                self._boot_press_suppressed = False
-                return
-
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
             self._state.last_press_loop_ts = self._loop.time()  # Store loop time for duration calc
@@ -630,35 +552,6 @@ class MultiClickDetector:
 
             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)
-
-            # Guard: stale release from phantom press at boot.
-            # If time since press exceeds max_long_press_seconds, the press
-            # was a startup artifact (GPIO settling at boot), not a real user
-            # action.  Reset the detector so the next real press is accepted.
-            if self._state.last_press_ts and press_duration_ms > self._max_long_press_seconds * 1000:
-                _LOGGER.warning(
-                    "Stale release on %s (%s): %.1fs since press exceeds max %.0fs. "
-                    "Likely phantom press from boot. Resetting detector.",
-                    self._name,
-                    self._pin,
-                    press_duration_ms / 1000,
-                    self._max_long_press_seconds,
-                )
-                self._state.last_press_ts = None
-                self._state.last_press_loop_ts = None
-                self._state.last_release_ts = timestamp_s
-                self._state.click_count = 0
-                if self._state.long_press_timer:
-                    self._state.long_press_timer.cancel()
-                    self._state.long_press_timer = None
-                    self._state.long_press_scheduled_loop_ts = None
-                if self._state.long_hold_periodic_timer:
-                    self._state.long_hold_periodic_timer.cancel()
-                    self._state.long_hold_periodic_timer = None
-                self._state.executed_long_actions = set()
-                self._state.last_repeat_times = {}
-                return
-
             self._state.last_release_ts = timestamp_s
             
             _LOGGER.debug(

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/input/event.py

@@ -80,32 +80,24 @@ class GpioEventButton(GpioBaseClass):
         # Get enable_triple_click setting (default: False)
         enable_triple_click = kwargs.get("enable_triple_click", False)
 
-        # Safety timeout for long press (default: 30s, hard max: 30s)
+        # Safety timeout for long press (default: 120s)
         max_long_press_seconds = (
             _to_milliseconds(
                 kwargs.get("max_long_press_duration"),
-                30 * 1000,  # 30s default
+                120 * 1000,  # 120s default
             )
             / 1000.0
         )
-        # Clamp to hard maximum of 30s — no one holds a button longer
-        if max_long_press_seconds > 30.0:
-            _LOGGER.info(
-                "max_long_press_duration for %s clamped from %.1fs to 30s (hard max)",
-                kwargs.get("name", "unknown"),
-                max_long_press_seconds,
-            )
-            max_long_press_seconds = 30.0
-        # Guard: if resolved to < 0.8s (misconfigured or zero), use default 30s
+        # Guard: if resolved to < 0.8s (misconfigured or zero), use default 120s
         if max_long_press_seconds < 0.8:
             raw = kwargs.get("max_long_press_duration")
             if raw is not None:
                 _LOGGER.warning(
-                    "max_long_press_duration for %s resolved to %.1fs (too small), using default 30s",
+                    "max_long_press_duration for %s resolved to %.1fs (too small), using default 120s",
                     kwargs.get("name", "unknown"),
                     max_long_press_seconds,
                 )
-            max_long_press_seconds = 30.0
+            max_long_press_seconds = 120.0
         _LOGGER.debug(
             "max_long_press_seconds for %s = %.1fs",
             kwargs.get("name", "unknown"),

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/irrigation/controller.py

@@ -113,7 +113,6 @@ class IrrigationController:
         self._schedule = schedule or []
         self._water_sources = water_sources or []
         self._active_water_source_idx: int = 0
-        self._running_water_source: WaterSource | None = None
         self._valve_open_delay_s = max(0, valve_open_delay_s)
         self._valve_overlap_s = max(0, valve_overlap_s)
         self._standby = standby
@@ -420,12 +419,6 @@ class IrrigationController:
         )
 
     async def shutdown(self) -> None:
-        """Stop the active irrigation cycle without killing schedule tasks.
-
-        This method is safe to call from within a schedule task — it does NOT
-        cancel schedule loops.  Use :meth:`full_stop` to tear down the
-        controller completely (including schedule tasks).
-        """
         _LOGGER.debug(
             "Irrigation %s shutdown called (state=%s, active_zone=%s). Caller: %s",
             self.id,
@@ -433,10 +426,10 @@ class IrrigationController:
             self._active_zone_idx,
             "".join(traceback.format_stack(limit=5)),
         )
+        self.stop_schedules()
         self._cancel_pause_timer()
         await self._stop_current_zone()
         await self._handle_pump_stop_sequence()
-        self._running_water_source = None
         self._state = ControllerState.IDLE
         self._active_zone_idx = None
         self._active_zone_remaining_s = None
@@ -444,16 +437,6 @@ class IrrigationController:
         self._single_zone_target_idx = None
         await self.publish_all_states()
 
-    async def full_stop(self) -> None:
-        """Fully stop the controller including schedule tasks.
-
-        Should only be called by the IrrigationManager when stopping
-        or reloading controllers — never from within a schedule task.
-        """
-        _LOGGER.info("Irrigation %s full_stop: stopping schedules and active cycle", self.id)
-        self.stop_schedules()
-        await self.shutdown()
-
     async def pause(self) -> None:
         if self._state != ControllerState.RUNNING or self._active_zone_idx is None:
             return
@@ -652,7 +635,7 @@ class IrrigationController:
             await self._stop_current_zone()
 
             # Handle valve_open_delay between zones
-            src = self._running_water_source or self.active_water_source
+            src = self.active_water_source
             if self._valve_open_delay_s > 0:
                 if src and src.pump_switch_off_during_valve_open_delay:
                     await self._deactivate_source()
@@ -820,17 +803,12 @@ class IrrigationController:
     async def _activate_source(self) -> bool:
         """Turn ON all outputs of the active water source.
 
-        Locks the source as ``_running_water_source`` so that mid-cycle
-        changes via HA select do not affect which outputs get deactivated
-        during shutdown.
-
         Returns:
             True if source was activated, False if blocked by interlock.
         """
         src = self.active_water_source
         if src is None:
             return True
-        self._running_water_source = src
         try:
             _LOGGER.debug("Irrigation %s: activating source '%s' outputs=%s", self.id, src.id, src.output_ids)
             return await src.activate(timestamp=time.time())
@@ -839,13 +817,8 @@ class IrrigationController:
             return False
 
     async def _deactivate_source(self) -> None:
-        """Turn OFF all outputs of the running water source.
-
-        Uses ``_running_water_source`` (set during activation) instead of
-        ``active_water_source`` so that mid-cycle HA select changes don't
-        cause us to deactivate the wrong source's outputs.
-        """
-        src = self._running_water_source or self.active_water_source
+        """Turn OFF all outputs of the active water source."""
+        src = self.active_water_source
         if src is None:
             return
         try:
@@ -904,12 +877,8 @@ class IrrigationController:
         await self.publish_all_states()
 
     async def _handle_pump_stop_sequence(self) -> None:
-        """Handle pump stop timing according to the running water source's delays.
-
-        Uses ``_running_water_source`` to ensure we deactivate the source
-        that was actually used during the cycle, not the one currently selected.
-        """
-        src = self._running_water_source or self.active_water_source
+        """Handle pump stop timing according to active water source's delays."""
+        src = self.active_water_source
         if src is None:
             return
         if src.pump_stop_valve_delay_s > 0:
@@ -1079,11 +1048,6 @@ class IrrigationController:
     async def set_water_source(self, source_id: str) -> None:
         """Switch active water source by ID.
 
-        If the controller is currently running, the change is deferred.
-        The selected source index is updated and persisted immediately,
-        but ``_running_water_source`` (used for activation/deactivation)
-        remains unchanged until the next cycle starts.
-
         Args:
             source_id: ID of the water source to activate.
         """
@@ -1091,16 +1055,7 @@ class IrrigationController:
             if ws.id == source_id:
                 self._active_water_source_idx = i
                 self._save("active_water_source", source_id)
-                if self._state in (ControllerState.RUNNING, ControllerState.PAUSED):
-                    _LOGGER.info(
-                        "Irrigation %s: water source will change to '%s' after current cycle ends "
-                        "(running source '%s' stays active)",
-                        self.id,
-                        source_id,
-                        self._running_water_source.id if self._running_water_source else "none",
-                    )
-                else:
-                    _LOGGER.info("Irrigation %s: water source changed to '%s'", self.id, source_id)
+                _LOGGER.info("Irrigation %s: water source changed to '%s'", self.id, source_id)
                 await self.publish_all_states()
                 return
         _LOGGER.warning("Irrigation %s: unknown water source '%s'", self.id, source_id)

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/output/__init__.py

@@ -1,16 +1,13 @@
 """Output components (relays, PWM, switches, lights)."""
 
 from boneio.components.output.basic import BasicOutput
-from boneio.components.output.buzzer import BuzzerOutput
 from boneio.components.output.mcp import MCPOutput
 from boneio.components.output.pca import PWMOutput
 from boneio.components.output.pcf import PCFOutput
 
 __all__ = [
     "BasicOutput",
-    "BuzzerOutput",
     "MCPOutput",
     "PCFOutput",
     "PWMOutput",
 ]
-

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/output/basic.py

@@ -186,13 +186,7 @@ class BasicOutput(BasicMqtt):
         """
         can_turn_on = self.check_interlock()
         if can_turn_on:
-            try:
-                await self._loop.run_in_executor(None, self.turn_on, timestamp)
-            except RuntimeError as err:
-                if "Executor shutdown" in str(err):
-                    self.turn_on(timestamp)  # Fall back to sync during shutdown
-                else:
-                    raise
+            await self._loop.run_in_executor(None, self.turn_on, timestamp)
         else:
             _LOGGER.warning("Interlock active: cannot turn on %s.", self.id)
             # Workaround for HA is sendind state ON/OFF without physically changing the relay.
@@ -203,13 +197,7 @@ class BasicOutput(BasicMqtt):
 
     async def async_turn_off(self, timestamp=None) -> None:
         """Turn off the relay asynchronously."""
-        try:
-            await self._loop.run_in_executor(None, self.turn_off, timestamp)
-        except RuntimeError as err:
-            if "Executor shutdown" in str(err):
-                self.turn_off(timestamp)  # Fall back to sync during shutdown
-            else:
-                raise
+        await self._loop.run_in_executor(None, self.turn_off, timestamp)
         await self.async_send_state()
 
     async def async_toggle(self, timestamp=None) -> None:

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/output/mcp.py

@@ -37,8 +37,6 @@ class MCPOutput(BasicOutput):
         ):
             _LOGGER.warning(f"Interlock active: cannot restore ON state for {self._pin_id} at startup")
             restored_state = False
-            # Fix: also reset the software state that was set in BasicOutput.__init__
-            self._state = OFF
         self._mcp.configure_pin_as_output(self._pin_id, restored_state)
 
     @property

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/output/remote.py

@@ -79,7 +79,6 @@ class RemoteOutputBase:
         duration_min: float = 1.0,
         duration_max: float = 3600.0,
         duration_unit: str = "s",
-        supports_brightness: bool = False,
     ) -> None:
         self._id = id
         self._name = name
@@ -118,7 +117,6 @@ class RemoteOutputBase:
         self._state: str = OFF
         self._last_timestamp: float = 0.0
         self._available: bool = False
-        self._supports_brightness: bool = supports_brightness
         self._brightness: int | None = None  # 0-255, None if not a dimmable light
         self._loop: asyncio.AbstractEventLoop | None = None
 
@@ -235,9 +233,9 @@ class RemoteOutputBase:
             )
             return
 
-        # If output supports brightness, initialize brightness to 0 so the
+        # If output_type is 'light', initialize brightness to 0 so the
         # slider renders immediately (will update on first state event).
-        if self._supports_brightness:
+        if self._output_type == "light":
             self._brightness = 0
             _LOGGER.debug(
                 "Initialized brightness=0 for remote light '%s' (no state yet)",

{boneio-1.5.0 → boneio-1.5.0.dev2}/boneio/components/template/gate_cover.py

@@ -191,14 +191,10 @@ class BoneIOGateCover:
     # -- MQTT ----------------------------------------------------------------
 
     async def start(self) -> None:
-        """Subscribe to MQTT command topic and publish current state.
-
-        Initial sensor state is already set by TemplateManager during
-        configuration, so start() just subscribes and publishes.
-        """
+        """Subscribe to MQTT command topic."""
         await self._message_bus.subscribe_and_listen(self._cmd_topic, self.handle_command)
         self._publish_state()
-        _LOGGER.info("GateCover %s started (state=%s), subscribed to %s", self._id, self._state, self._cmd_topic)
+        _LOGGER.info("GateCover %s started, subscribed to %s", self._id, self._cmd_topic)
 
     async def stop(self) -> None:
         """Unsubscribe from MQTT and cancel timers."""