boneio 1.5.0.dev41__tar.gz → 1.6.0.dev1__tar.gz

{boneio-1.5.0.dev41/boneio.egg-info → boneio-1.6.0.dev1}/PKG-INFO

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

boneio-1.6.0.dev1/boneio/components/cover/__init__.py

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

boneio-1.6.0.dev1/boneio/components/cover/remote.py

@@ -0,0 +1,277 @@
+"""Remote cover output for covers on remote devices (ESPHome API).
+
+``RemoteCoverOutput`` provides a duck-type compatible interface with
+:class:`TimeBasedCover` / :class:`VenetianCover` so that the conditions
+system (``is_open`` / ``is_closed``), ``CoverManager.get_cover()``,
+and WebSocket event emission work transparently with remote covers.
+
+The actual hardware control is delegated to the parent
+``ESPHomeDeviceManager`` via ``control_cover()``.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+from boneio.const import CLOSED, CLOSING, COVER, IDLE, OPEN, OPENING
+from boneio.core.events import EventBus
+from boneio.models import CoverState
+from boneio.models.events import CoverEvent
+
+if TYPE_CHECKING:
+    from boneio.core.messaging import MessageBus
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class RemoteCoverOutput:
+    """Remote cover from ESPHome — duck-type compatible with local Cover.
+
+    Provides the same public interface that the condition evaluators and
+    the ``CoverManager`` expect:
+
+    - ``is_open`` / ``is_closed`` property for action conditions
+    - ``state`` / ``position`` / ``tilt`` for state reporting
+    - ``on_remote_state_change()`` callback from ESPHome subscription
+    - ``CoverEvent`` emission on EventBus for WebSocket clients
+
+    Args:
+        id: Entity identifier (usually ``{device_id}_{cover_id}``).
+        name: Human-readable display name.
+        device_id: ID of the remote device hosting this cover.
+        cover_id: Entity object_id on the remote device.
+        remote_source: Transport protocol (``esphome_api``).
+        event_bus: Central event bus for emitting ``CoverEvent`` objects.
+        kind: Cover device class (``blind``, ``shutter``, ``gate``, etc.).
+        show_in_ha: Whether to publish HA autodiscovery.
+        area: Optional HA area assignment.
+    """
+
+    # Duck-type compatibility with local covers
+    is_remote: bool = True
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        name: str,
+        device_id: str,
+        cover_id: str,
+        remote_source: str,
+        event_bus: EventBus,
+        message_bus: MessageBus | None = None,
+        topic_prefix: str = "",
+        kind: str = "cover",
+        show_in_ha: bool = False,
+        area: str | None = None,
+    ) -> None:
+        self._id = id
+        self._name = name
+        self._device_id = device_id
+        self._cover_id = cover_id
+        self._remote_source = remote_source
+        self._event_bus = event_bus
+        self._message_bus: MessageBus | None = message_bus
+        self._send_topic = f"{topic_prefix}/{COVER}/{id}" if topic_prefix else ""
+        self._kind = kind
+        self.show_in_ha = show_in_ha
+        self.area: str | None = area
+
+        # State tracking
+        self._position: int = 0  # 0=closed, 100=open
+        self._tilt: int = 0
+        self._current_operation: str = IDLE
+        self._last_timestamp: float = 0.0
+        self._available: bool = False
+
+        # Reference to remote device manager — set by registration.
+        self._device_manager: Any = None
+        self._remote_devices_ref: Any = None
+
+    # ------------------------------------------------------------------
+    # Public properties (duck-type compatible with TimeBasedCover)
+    # ------------------------------------------------------------------
+
+    @property
+    def id(self) -> str:
+        """Entity identifier."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Human-readable name."""
+        return self._name
+
+    @property
+    def kind(self) -> str:
+        """Cover device class (blind, shutter, gate, etc.)."""
+        return self._kind
+
+    @property
+    def state(self) -> str:
+        """Current state as string (open/closed/opening/closing)."""
+        if self._current_operation == OPENING:
+            return OPENING
+        elif self._current_operation == CLOSING:
+            return CLOSING
+        else:
+            return CLOSED if self._position == 0 else OPEN
+
+    @property
+    def is_open(self) -> bool:
+        """True when cover position > 0 (not fully closed)."""
+        return self._position > 0
+
+    @property
+    def is_closed(self) -> bool:
+        """True when cover is fully closed (position == 0)."""
+        return self._position == 0
+
+    @property
+    def position(self) -> int:
+        """Current cover position (0-100)."""
+        return self._position
+
+    @property
+    def tilt(self) -> int:
+        """Current tilt position (0-100)."""
+        return self._tilt
+
+    @property
+    def current_operation(self) -> str:
+        """Current operation (idle/opening/closing)."""
+        return self._current_operation
+
+    @property
+    def last_timestamp(self) -> float:
+        """Timestamp of last state update."""
+        return self._last_timestamp
+
+    # ------------------------------------------------------------------
+    # Remote state callback
+    # ------------------------------------------------------------------
+
+    def on_remote_state_change(self, state_dict: dict[str, Any]) -> None:
+        """Called by ESPHome device manager when cover state changes.
+
+        Args:
+            state_dict: Cover state from ESPHome containing:
+                - position: float (0.0-1.0)
+                - tilt: float | None
+                - current_operation: int (0=IDLE, 1=OPENING, 2=CLOSING)
+        """
+        position_raw = state_dict.get("position")
+        if position_raw is not None:
+            self._position = round(float(position_raw) * 100)
+
+        tilt_raw = state_dict.get("tilt")
+        if tilt_raw is not None:
+            self._tilt = round(float(tilt_raw) * 100)
+
+        current_op_int = state_dict.get("current_operation", 0)
+        if current_op_int == 1:
+            self._current_operation = OPENING
+        elif current_op_int == 2:
+            self._current_operation = CLOSING
+        else:
+            self._current_operation = IDLE
+
+        self._last_timestamp = time.time()
+        self._available = True
+
+        _LOGGER.debug(
+            "Remote cover '%s' state: position=%d%%, tilt=%d%%, operation=%s",
+            self._id,
+            self._position,
+            self._tilt,
+            self._current_operation,
+        )
+
+        # Emit CoverEvent for WebSocket clients
+        self._emit_cover_event()
+
+    def _emit_cover_event(self) -> None:
+        """Emit a CoverEvent on the event bus."""
+        event = CoverState(
+            id=self._id,
+            name=self._name,
+            state=self.state,
+            kind=self._kind,
+            timestamp=self._last_timestamp,
+            current_operation=self._current_operation,
+            position=self._position,
+            tilt=self._tilt,
+        )
+        self._event_bus.trigger_event(CoverEvent(entity_id=self._id, state=event))
+
+    # ------------------------------------------------------------------
+    # Device manager resolution (lazy — same pattern as RemoteOutputBase)
+    # ------------------------------------------------------------------
+
+    def _resolve_device_manager(self) -> bool:
+        """Try to resolve device manager lazily from remote_devices reference.
+
+        Returns:
+            ``True`` if device manager is now available.
+        """
+        if self._device_manager is not None:
+            return True
+        if self._remote_devices_ref is None:
+            return False
+        device = self._remote_devices_ref.get_device(self._device_id)
+        if device is not None:
+            self._device_manager = device
+            self._remote_devices_ref = None
+            self._register_state_callback()
+            _LOGGER.info(
+                "Lazily resolved device manager for remote cover '%s' (device '%s')",
+                self._id,
+                self._device_id,
+            )
+            return True
+        return False
+
+    def _register_state_callback(self) -> None:
+        """Register a cover state change callback on the device manager.
+
+        Called after device manager is resolved (lazy or immediate).
+        ESPHome devices will call back on cover state changes.
+        Also syncs current state from the device if available.
+        """
+        if self._device_manager is None:
+            return
+        register_fn = getattr(self._device_manager, "register_cover_callback", None)
+        if register_fn is not None:
+            register_fn(self._cover_id, self.on_remote_state_change)
+            _LOGGER.debug(
+                "Registered cover callback for remote cover '%s' on device '%s'",
+                self._id,
+                self._device_id,
+            )
+
+        # Sync initial state from device's current known states
+        self._sync_initial_state()
+
+    def _sync_initial_state(self) -> None:
+        """Sync initial state from ESPHome device's cached cover states."""
+        if self._device_manager is None:
+            return
+
+        cover_states: dict[str, dict[str, Any]] = getattr(
+            self._device_manager, "_cover_states", {}
+        )
+        if self._cover_id in cover_states:
+            self.on_remote_state_change(cover_states[self._cover_id])
+            _LOGGER.debug(
+                "Synced initial cover state for '%s': position=%d%%",
+                self._id,
+                self._position,
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"RemoteCoverOutput(id={self._id!r}, device={self._device_id!r}, "
+            f"cover={self._cover_id!r}, position={self._position})"
+        )

{boneio-1.5.0.dev41 → boneio-1.6.0.dev1}/boneio/core/manager/manager.py

@@ -54,6 +54,7 @@ from boneio.core.messaging import MessageBus
 from boneio.core.state import StateManager
 from boneio.core.utils.timeperiod import parse_time_to_ms, parse_time_to_seconds
 from boneio.components.output.remote import RemoteOutputBase
+from boneio.components.cover.remote import RemoteCoverOutput
 from boneio.core.remote.wled import WLEDRemoteDevice
 from boneio.hardware.i2c.bus import SMBus2I2C
 from boneio.migrations import MigrationRunner
@@ -1401,100 +1402,166 @@ class Manager:
             dur_unit = str(out_cfg.get("duration_unit", "s"))
 
             # Check for duplicates
-            if self.outputs.get_output(entity_id) is not None:
+            if output_type == "cover":
+                if self.covers.get_cover(entity_id) is not None:
+                    _LOGGER.warning(
+                        "Remote cover '%s' conflicts with existing cover, skipping",
+                        entity_id,
+                    )
+                    continue
+            elif self.outputs.get_output(entity_id) is not None:
                 _LOGGER.warning(
                     "Remote output '%s' conflicts with existing output, skipping",
                     entity_id,
                 )
                 continue
 
-            # Determine brightness support from device entity data
-            sup_brightness = False
-            if output_type == "light":
+            if output_type == "cover":
+                # ── Cover path ──────────────────────────────────────────
+                # Determine cover kind from device entity data
+                cover_kind = "cover"
                 device = self.remote_devices.get_device(device_id)
                 if device is not None:
-                    # WLED: all outputs support brightness
-                    if isinstance(device, WLEDRemoteDevice):
-                        sup_brightness = True
-                    else:
-                        # ESPHome: check _lights list for supports_brightness flag
-                        lights_list: list[dict] = getattr(device, "_lights", [])
-                        for light in lights_list:
-                            if light.get("id") == output_id:
-                                sup_brightness = bool(light.get("supports_brightness", False))
-                                break
-
-            remote_output = RemoteOutputBase(
-                id=entity_id,
-                name=name,
-                device_id=device_id,
-                output_id=output_id,
-                remote_source=remote_source,
-                event_bus=self._event_bus,
-                message_bus=self._message_bus,
-                topic_prefix=self._topic_prefix,
-                output_type=output_type,
-                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,
-                supports_brightness=sup_brightness,
-            )
+                    covers_list: list[dict] = getattr(device, "_covers_list", [])
+                    for cv in covers_list:
+                        if cv.get("id") == output_id:
+                            cover_kind = cv.get("kind", "cover") or "cover"
+                            break
+
+                remote_cover = RemoteCoverOutput(
+                    id=entity_id,
+                    name=name,
+                    device_id=device_id,
+                    cover_id=output_id,
+                    remote_source=remote_source,
+                    event_bus=self._event_bus,
+                    message_bus=self._message_bus,
+                    topic_prefix=self._topic_prefix,
+                    kind=cover_kind,
+                    show_in_ha=show_in_ha,
+                    area=area,
+                )
 
-            # 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
-            # RemoteOutputBase.control_output() or when the device connects.
-            device = self.remote_devices.get_device(device_id)
-            if device is not None:
-                remote_output._device_manager = device
-                remote_output._register_state_callback()
-            else:
-                # Store reference to remote_devices so the output can
-                # resolve its device manager lazily when needed.
-                remote_output._remote_devices_ref = self.remote_devices
-                _LOGGER.debug(
-                    "Remote output '%s': device '%s' not yet available, will resolve lazily",
+                # Set the device manager reference if the device is already loaded.
+                device = self.remote_devices.get_device(device_id)
+                if device is not None:
+                    remote_cover._device_manager = device
+                    remote_cover._register_state_callback()
+                else:
+                    remote_cover._remote_devices_ref = self.remote_devices
+                    _LOGGER.debug(
+                        "Remote cover '%s': device '%s' not yet available, will resolve lazily",
+                        entity_id,
+                        device_id,
+                    )
+
+                # Register in CoverManager so conditions and UI work
+                self.covers._covers[entity_id] = remote_cover  # type: ignore[assignment]
+                _LOGGER.info(
+                    "Registered remote cover: id='%s' device='%s' cover='%s' kind='%s'",
                     entity_id,
                     device_id,
+                    output_id,
+                    cover_kind,
                 )
 
-            # 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' interlock=%s",
-                entity_id,
-                device_id,
-                output_id,
-                output_type,
-                interlock_groups or "none",
-            )
+            else:
+                # ── Output path (switch / light / valve) ────────────────
+                # Determine brightness support from device entity data
+                sup_brightness = False
+                if output_type == "light":
+                    device = self.remote_devices.get_device(device_id)
+                    if device is not None:
+                        # WLED: all outputs support brightness
+                        if isinstance(device, WLEDRemoteDevice):
+                            sup_brightness = True
+                        else:
+                            # ESPHome: check _lights list for supports_brightness flag
+                            lights_list: list[dict] = getattr(device, "_lights", [])
+                            for light in lights_list:
+                                if light.get("id") == output_id:
+                                    sup_brightness = bool(light.get("supports_brightness", False))
+                                    break
+
+                remote_output = RemoteOutputBase(
+                    id=entity_id,
+                    name=name,
+                    device_id=device_id,
+                    output_id=output_id,
+                    remote_source=remote_source,
+                    event_bus=self._event_bus,
+                    message_bus=self._message_bus,
+                    topic_prefix=self._topic_prefix,
+                    output_type=output_type,
+                    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,
+                    supports_brightness=sup_brightness,
+                )
+
+                # 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
+                # RemoteOutputBase.control_output() or when the device connects.
+                device = self.remote_devices.get_device(device_id)
+                if device is not None:
+                    remote_output._device_manager = device
+                    remote_output._register_state_callback()
+                else:
+                    # Store reference to remote_devices so the output can
+                    # resolve its device manager lazily when needed.
+                    remote_output._remote_devices_ref = self.remote_devices
+                    _LOGGER.debug(
+                        "Remote output '%s': device '%s' not yet available, will resolve lazily",
+                        entity_id,
+                        device_id,
+                    )
+
+                # 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' interlock=%s",
+                    entity_id,
+                    device_id,
+                    output_id,
+                    output_type,
+                    interlock_groups or "none",
+                )
 
+        remote_output_count = sum(1 for o in self.outputs._outputs.values() if getattr(o, "is_remote", False))
+        remote_cover_count = sum(1 for c in self.covers._covers.values() if getattr(c, "is_remote", False))
         _LOGGER.info(
-            "Remote outputs registered: %d total",
-            sum(1 for o in self.outputs._outputs.values() if getattr(o, "is_remote", False)),
+            "Remote entities registered: %d outputs, %d covers",
+            remote_output_count,
+            remote_cover_count,
         )
 
     def unregister_remote_outputs(self) -> None:
-        """Remove all remote outputs from OutputManager."""
+        """Remove all remote outputs and covers from their managers."""
         remote_ids = [oid for oid, o in self.outputs._outputs.items() if getattr(o, "is_remote", False)]
         for oid in remote_ids:
             del self.outputs._outputs[oid]
             _LOGGER.debug("Unregistered remote output: %s", oid)
 
+        remote_cover_ids = [cid for cid, c in self.covers._covers.items() if getattr(c, "is_remote", False)]
+        for cid in remote_cover_ids:
+            del self.covers._covers[cid]
+            _LOGGER.debug("Unregistered remote cover: %s", cid)
+
     async def _reload_remote_outputs(self) -> None:
         """Reload only the remote_outputs section.
 

{boneio-1.5.0.dev41 → boneio-1.6.0.dev1}/boneio/core/remote/esphome.py

@@ -182,6 +182,10 @@ class ESPHomeRemoteDevice(RemoteDevice):
         # Keyed by entity_id → callable(new_state: bool, brightness: int | None)
         self._output_callbacks: dict[str, Any] = {}
 
+        # Callbacks for cover state changes.
+        # Keyed by cover_id → callable(state_dict: dict)
+        self._cover_callbacks: dict[str, Any] = {}
+
         # Load configured entities
         if switches:
             self._switches = switches
@@ -288,6 +292,29 @@ class ESPHomeRemoteDevice(RemoteDevice):
         """
         self._output_callbacks.pop(entity_id, None)
 
+    def register_cover_callback(self, cover_id: str, callback: Any) -> None:
+        """Register a callback for cover state changes.
+
+        Args:
+            cover_id: Cover object_id on this device.
+            callback: Callable(state_dict: dict) invoked on cover state change.
+                      state_dict contains position, tilt, current_operation.
+        """
+        self._cover_callbacks[cover_id] = callback
+        _LOGGER.debug(
+            "Registered cover callback for '%s' on device '%s'",
+            cover_id,
+            self._name,
+        )
+
+    def unregister_cover_callback(self, cover_id: str) -> None:
+        """Remove a cover state callback.
+
+        Args:
+            cover_id: Cover object_id.
+        """
+        self._cover_callbacks.pop(cover_id, None)
+
     def has_light(self, entity_id: str) -> bool:
         """Check if entity_id is a light on this device.
 
@@ -531,6 +558,17 @@ class ESPHomeRemoteDevice(RemoteDevice):
                             current_op,
                             last_op,
                         )
+                        # Notify registered cover callback
+                        cb = self._cover_callbacks.get(cover_id)
+                        if cb is not None:
+                            try:
+                                cb(self._cover_states[cover_id])
+                            except Exception as cb_err:
+                                _LOGGER.error(
+                                    "Error in cover callback for '%s': %s",
+                                    cover_id,
+                                    cb_err,
+                                )
                         break
 
             elif isinstance(state, BinarySensorState):

{boneio-1.5.0.dev41 → boneio-1.6.0.dev1}/boneio/integration/homeassistant.py

@@ -175,6 +175,9 @@ def ha_availabilty_message(
     unique_id = f"{unique_id_prefix}_{device_type}{id}"
     default_entity_id = f"{entity_type}.{config_helper.serial_number}_{id}"
     
+    # Filter out None values — HA rejects fields like device_class: None
+    filtered_kwargs = {k: v for k, v in kwargs.items() if v is not None}
+
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
         "optimistic": False,
@@ -184,7 +187,7 @@ def ha_availabilty_message(
         "unique_id": unique_id,
         "default_entity_id": default_entity_id,
         # "object_id": f"{topic}{device_type}{id}",
-        **kwargs,
+        **filtered_kwargs,
     }
 
 

{boneio-1.5.0.dev41 → boneio-1.6.0.dev1}/boneio/schema/remote_outputs.yaml

@@ -59,7 +59,7 @@ schema:
       type: string
       required: False
       default: "switch"
-      allowed: ['switch', 'light', 'valve']
+      allowed: ['switch', 'light', 'valve', 'cover']
       meta:
         label: Output Type
         description: |
@@ -67,6 +67,7 @@ schema:
           - switch: Generic switch
           - light: Light entity
           - valve: Valve entity (for irrigation)
+          - cover: Cover entity (gate, blind, shutter)
     show_in_ha:
       type: boolean
       required: False

boneio-1.6.0.dev1/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.6.0.dev1"