boneIO 1.0.0.dev19__tar.gz → 1.0.0.dev21__tar.gz

{boneio-1.0.0.dev19/boneio.egg-info → boneio-1.0.0.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.0.0.dev19
+Version: 1.0.0.dev21
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -32,6 +32,8 @@ Requires-Dist: qrcode==8.2
 Requires-Dist: gpiod==2.3.0
 Requires-Dist: requests==2.32.5
 Requires-Dist: packaging==25.0
+Requires-Dist: aioesphomeapi>=29.0.0
+Requires-Dist: zeroconf>=0.148.0
 Dynamic: license-file
 
 Example usage:

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/config/config_helper.py

@@ -5,7 +5,10 @@ from __future__ import annotations
 
 import logging
 from _collections_abc import dict_values
-from typing import Any
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from boneio.integration.homeassistant import HomeAssistantDiscoveryMessage
 
 from boneio.const import (
     BINARY_SENSOR,
@@ -222,7 +225,12 @@ class ConfigHelper:
     def subscribe_topic(self) -> str:
         return f"{self.cmd_topic_prefix}+/+/#"
 
-    def add_autodiscovery_msg(self, ha_type: str, topic: str, payload: str | dict | None):
+    def add_autodiscovery_msg(
+        self, 
+        ha_type: str, 
+        topic: str, 
+        payload: str | dict[str, Any] | "HomeAssistantDiscoveryMessage" | None
+    ):
         """Add autodiscovery message."""
         self._autodiscovery_messages[ha_type][topic] = {"topic": topic, "payload": payload}
 

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/manager/manager.py

@@ -22,6 +22,8 @@ from boneio.const import (
     ONLINE,
     OUTPUT,
     OUTPUT_OVER_MQTT,
+    REMOTE_COVER,
+    REMOTE_OUTPUT,
     SET_BRIGHTNESS,
     STATE,
     cover_actions,
@@ -192,6 +194,7 @@ class Manager:
             message_bus=message_bus,
             remote_devices_config=remote_devices,
             own_serial=config_helper.serial_no,
+            name=self.config_helper.name
         )
         
         # 8. BlackDiscoveryPublisher (publishes device info for autodiscovery of neighboring BoneIO devices)
@@ -207,6 +210,20 @@ class Manager:
         # (removing duplicate registration here that caused double event handling)
         
         _LOGGER.info("Manager initialization complete")
+    
+    async def stop(self) -> None:
+        """Stop manager async tasks.
+        
+        This should be called during shutdown to cleanly stop:
+        - ESPHome connections
+        - Other async tasks
+        """
+        _LOGGER.info("Stopping manager async tasks")
+        
+        # Stop ESPHome connections
+        await self.remote_devices.stop_all_connections()
+        
+        _LOGGER.info("Manager async tasks stopped")
 
     @property
     def loop(self) -> asyncio.AbstractEventLoop:
@@ -521,7 +538,7 @@ class Manager:
         Args:
             actions: List of actions to execute
         """
-        from boneio.const import REMOTE_OUTPUT, REMOTE_COVER
+        
         
         start_time = time.time()
         
@@ -604,7 +621,7 @@ class Manager:
                 )
             
             elif action == REMOTE_COVER:
-                # Control cover on remote device
+                # Control cover on remote device (BoneIO MQTT or ESPHome API)
                 remote_device_id = action_definition.get("remote_device")
                 cover_id = action_definition.get("cover_id")
                 action_cover = action_definition.get("action_cover", "TOGGLE")

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/manager/modbus.py

@@ -131,7 +131,8 @@ class ModbusManager:
                     model = device_config.get(MODEL, "")
                     
                     # Generate ID from address and model if not provided
-                    if device_config.get(ID):
+                    has_custom_id = bool(device_config.get(ID))
+                    if has_custom_id:
                         device_id = str(device_config[ID]).replace(" ", "").lower()
                     else:
                         device_id = f"{address}_{model}".lower().replace(" ", "_")
@@ -160,6 +161,7 @@ class ModbusManager:
                         sensors_filters=device_config.get("sensors_filters", {}),
                         additional_data=additional_data,
                         area=area,
+                        has_custom_id=has_custom_id,
                     )
                     coordinators[device_id] = coordinator
                     _LOGGER.info("Configured Modbus coordinator: %s", device_id)
@@ -358,6 +360,18 @@ class ModbusManager:
             new_coordinators = self._configure_modbus_coordinators(devices=configs_to_add)
             self._modbus_coordinators.update(new_coordinators)
             _LOGGER.info("Added/recreated %d Modbus devices", len(new_coordinators))
+            
+            # Send online status for newly created/recreated coordinators
+            # This ensures the new availability topic gets the online status immediately
+            for coordinator in new_coordinators.values():
+                try:
+                    await coordinator.send_online_status()
+                except Exception as err:
+                    _LOGGER.error(
+                        "Failed to send online status for coordinator %s: %s",
+                        coordinator.id,
+                        err
+                    )
         
         _LOGGER.info(
             "Modbus devices reload complete: %d coordinators (removed=%d, added=%d, recreated=%d)",

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/manager/remote.py

@@ -6,6 +6,7 @@ Supports autodiscovery of neighboring BoneIO Black devices via MQTT.
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 from typing import TYPE_CHECKING, Any
@@ -16,6 +17,7 @@ from boneio.core.remote.base import (
     RemoteDeviceType,
 )
 from boneio.core.remote.mqtt import MQTTRemoteDevice
+from boneio.core.remote.esphome import ESPHomeRemoteDevice, ESPHOME_API_AVAILABLE
 
 if TYPE_CHECKING:
     from boneio.core.messaging import MessageBus
@@ -44,6 +46,7 @@ class RemoteDeviceManager:
         message_bus: MessageBus | None = None,
         remote_devices_config: list[dict[str, Any]] | None = None,
         own_serial: str | None = None,
+        name: str | None = None,
     ) -> None:
         """Initialize remote device manager.
         
@@ -55,6 +58,7 @@ class RemoteDeviceManager:
         self._message_bus = message_bus
         self._devices: dict[str, RemoteDevice] = {}
         self._own_serial = own_serial
+        self._name = name
         # Track autodiscovered devices separately from configured ones
         self._autodiscovered_devices: dict[str, MQTTRemoteDevice] = {}
         # Track devices that manage this boneIO (received via discovery/managed_by topic)
@@ -111,8 +115,7 @@ class RemoteDeviceManager:
         
         # Build payload with our device info
         payload = json.dumps({
-            "id": self._own_serial,
-            "name": self._own_serial,  # Will be updated with actual name if available
+            "name": self._name or self._own_serial,
             "serial": self._own_serial,
         })
         
@@ -172,8 +175,7 @@ class RemoteDeviceManager:
             _LOGGER.warning("ESPHome UDP protocol not yet implemented for device '%s'", device_id)
             return None
         elif protocol == RemoteDeviceProtocol.ESPHOME_API:
-            _LOGGER.warning("ESPHome API protocol not yet implemented for device '%s'", device_id)
-            return None
+            return self._create_esphome_device(device_id, name, config)
         else:
             _LOGGER.error("Unsupported protocol '%s' for device '%s'", protocol, device_id)
             return None
@@ -208,6 +210,103 @@ class RemoteDeviceManager:
             covers=covers,
         )
     
+    def _create_esphome_device(
+        self,
+        device_id: str,
+        name: str,
+        config: dict[str, Any],
+    ) -> ESPHomeRemoteDevice | None:
+        """Create ESPHome API remote device.
+        
+        Args:
+            device_id: Device ID
+            name: Device name
+            config: Full device configuration
+            
+        Returns:
+            ESPHomeRemoteDevice instance or None if creation failed
+        """
+        if not ESPHOME_API_AVAILABLE:
+            _LOGGER.error(
+                "aioesphomeapi not installed - cannot create ESPHome device '%s'",
+                device_id
+            )
+            return None
+        
+        esphome_config = config.get("esphome_api", {})
+        host = esphome_config.get("host")
+        
+        if not host:
+            _LOGGER.error("ESPHome device '%s' missing 'host' in esphome_api config", device_id)
+            return None
+        
+        port = esphome_config.get("port", 6053)
+        password = esphome_config.get("password", "")
+        encryption_key = esphome_config.get("encryption_key", "")
+        switches = esphome_config.get("switches", [])
+        lights = esphome_config.get("lights", [])
+        covers = esphome_config.get("covers", [])
+        
+        return ESPHomeRemoteDevice(
+            id=device_id,
+            name=name,
+            host=host,
+            port=port,
+            password=password,
+            encryption_key=encryption_key,
+            switches=switches,
+            lights=lights,
+            covers=covers,
+        )
+    
+    async def start_all_connections(self, delay_seconds: float = 10.0) -> None:
+        """Start persistent connections for all ESPHome devices.
+        
+        This should be called during application startup to establish
+        connections to all ESPHome devices with ReconnectLogic.
+        
+        ESPHome connections are delayed to prioritize local device functionality
+        (GPIO, MQTT) over remote device connections.
+        
+        Args:
+            delay_seconds: Seconds to wait before starting ESPHome connections
+        """
+        esphome_devices = [
+            (device_id, device) 
+            for device_id, device in self._devices.items() 
+            if isinstance(device, ESPHomeRemoteDevice)
+        ]
+        
+        if not esphome_devices:
+            return
+        
+        _LOGGER.info(
+            "Delaying ESPHome connections by %.1f seconds (found %d devices)",
+            delay_seconds, len(esphome_devices)
+        )
+        await asyncio.sleep(delay_seconds)
+        
+        _LOGGER.info("Starting ESPHome connections...")
+        for device_id, device in esphome_devices:
+            try:
+                await device.start_connection()
+                _LOGGER.info("Started connection for ESPHome device '%s'", device_id)
+            except Exception as e:
+                _LOGGER.error("Failed to start connection for ESPHome device '%s': %s", device_id, e)
+    
+    async def stop_all_connections(self) -> None:
+        """Stop all persistent connections.
+        
+        This should be called during application shutdown.
+        """
+        for device_id, device in self._devices.items():
+            if isinstance(device, ESPHomeRemoteDevice):
+                try:
+                    await device.disconnect()
+                    _LOGGER.info("Stopped connection for ESPHome device '%s'", device_id)
+                except Exception as e:
+                    _LOGGER.error("Failed to stop connection for ESPHome device '%s': %s", device_id, e)
+    
     def get_device(self, device_id: str) -> RemoteDevice | None:
         """Get remote device by ID.
         
@@ -232,13 +331,20 @@ class RemoteDeviceManager:
         device_id: str,
         output_id: str,
         action: str,
+        brightness: int | None = None,
+        transition: float | None = None,
     ) -> bool:
-        """Control output on remote device.
+        """Control output on remote device (BoneIO MQTT or ESPHome API).
+        
+        Automatically detects device protocol and routes to appropriate method.
+        For ESPHome devices, output_id can be a switch or light entity.
         
         Args:
             device_id: ID of the remote device
-            output_id: ID of the output to control
-            action: Action to perform (ON, OFF, TOGGLE)
+            output_id: ID of the output/switch/light to control
+            action: Action to perform (ON, OFF, TOGGLE, BRIGHTNESS_UP, BRIGHTNESS_DOWN, SET_BRIGHTNESS)
+            brightness: Brightness level (0-255) - only for ESPHome lights
+            transition: Transition time in seconds - only for ESPHome lights
             
         Returns:
             True if command was sent successfully
@@ -248,6 +354,25 @@ class RemoteDeviceManager:
             _LOGGER.error("Remote device '%s' not found", device_id)
             return False
         
+        # For ESPHome devices, try to determine if it's a switch or light
+        if isinstance(device, ESPHomeRemoteDevice):
+            # Check if output_id is a light
+            if device.has_light(output_id):
+                _LOGGER.debug("Controlling ESPHome light '%s' on device '%s'", output_id, device_id)
+                return await device.control_light(
+                    light_id=output_id,
+                    action=action,
+                    brightness=brightness,
+                    transition=transition if transition is not None else 0.0,
+                )
+            # Otherwise treat as switch
+            _LOGGER.debug("Controlling ESPHome switch '%s' on device '%s'", output_id, device_id)
+            return await device.control_switch(
+                switch_id=output_id,
+                action=action,
+            )
+        
+        # For MQTT devices, use standard control_output
         return await device.control_output(
             output_id=output_id,
             action=action,
@@ -261,12 +386,14 @@ class RemoteDeviceManager:
         action: str,
         **kwargs,
     ) -> bool:
-        """Control cover on remote device.
+        """Control cover on remote device (BoneIO MQTT or ESPHome API).
+        
+        Automatically detects device protocol and routes to appropriate method.
         
         Args:
             device_id: ID of the remote device
             cover_id: ID of the cover to control
-            action: Action to perform (OPEN, CLOSE, STOP, etc.)
+            action: Action to perform (OPEN, CLOSE, STOP, TOGGLE, etc.)
             **kwargs: Additional parameters (position, tilt_position)
             
         Returns:
@@ -277,6 +404,15 @@ class RemoteDeviceManager:
             _LOGGER.error("Remote device '%s' not found", device_id)
             return False
         
+        # For ESPHome devices, use native API
+        if isinstance(device, ESPHomeRemoteDevice):
+            _LOGGER.debug("Controlling ESPHome cover '%s' on device '%s'", cover_id, device_id)
+            return await device.control_cover(
+                cover_id=cover_id,
+                action=action,
+            )
+        
+        # For MQTT devices, use standard control_cover
         return await device.control_cover(
             cover_id=cover_id,
             action=action,
@@ -352,7 +488,27 @@ class RemoteDeviceManager:
         device_id = parts[1]  # e.g., "blk_abc123"
         discovery_type = parts[3] if len(parts) > 3 else None  # e.g., "outputs", "covers", "device"
         
-        # Skip our own device
+        # Handle managed_by BEFORE skipping own device check
+        # Topic: boneio/{our_device}/discovery/managed_by/{manager_serial}
+        # This is for messages TO our device, so device_id will be our serial
+        if discovery_type == "managed_by":
+            manager_serial = parts[4] if len(parts) > 4 else None
+            if manager_serial and self._own_serial != manager_serial:
+                try:
+                    data = json.loads(payload) if payload else None
+                except json.JSONDecodeError as e:
+                    _LOGGER.warning("Invalid JSON in managed_by payload: %s", e)
+                    return
+                if data:
+                    self.handle_managed_by_discovery(manager_serial, data)
+                else:
+                    # Empty payload - remove managed_by entry
+                    if manager_serial in self._managed_by_devices:
+                        del self._managed_by_devices[manager_serial]
+                        _LOGGER.info("Removed managed_by device: %s", manager_serial)
+            return
+        
+        # Skip our own device (for other discovery types)
         if self._own_serial and device_id == self._own_serial:
             _LOGGER.debug("Ignoring discovery from own device: %s", device_id)
             return
@@ -385,12 +541,6 @@ class RemoteDeviceManager:
             self._handle_outputs_discovery(device_id, data)
         elif discovery_type == "covers":
             self._handle_covers_discovery(device_id, data)
-        elif discovery_type == "managed_by":
-            # Handle managed_by - this is for OUR device, not the sender
-            # Topic: boneio/{our_device}/discovery/managed_by/{manager_serial}
-            manager_serial = parts[4] if len(parts) > 4 else None
-            if manager_serial:
-                self.handle_managed_by_discovery(manager_serial, data)
         else:
             _LOGGER.debug("Ignoring discovery type '%s' for device %s", discovery_type, device_id)
     
@@ -570,6 +720,11 @@ class RemoteDeviceManager:
         Returns:
             Dictionary with autodiscovered devices information
         """
+        _LOGGER.debug(
+            "autodiscovered_to_dict called, _autodiscovered_devices has %d items: %s",
+            len(self._autodiscovered_devices),
+            list(self._autodiscovered_devices.keys())
+        )
         return {
             device_id: device.to_dict()
             for device_id, device in self._autodiscovered_devices.items()

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/messaging/basic.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 
 import logging
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 from collections.abc import Awaitable, Callable
 
 if TYPE_CHECKING:
     from boneio.core.manager import Manager
+    from boneio.integration.homeassistant import HomeAssistantDiscoveryMessage
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -18,7 +19,7 @@ class MessageBus(ABC):
     def send_message(
         self,
         topic: str,
-        payload: str | int | dict[str, str | float | int | None] | None,
+        payload: str | int | dict[str, Any] | "HomeAssistantDiscoveryMessage" | None,
         retain: bool = False,
         qos: int = 0,
     ) -> None:

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/messaging/local.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Any
 
 if TYPE_CHECKING:
     from boneio.core.manager import Manager
@@ -26,7 +26,7 @@ class LocalMessageBus(MessageBus):
     def send_message(
         self,
         topic: str,
-        payload: str | int | dict[str, str | float | int] | None,
+        payload: str | int | dict[str, Any] | None,
         retain: bool = False,
         qos: int = 0,
     ) -> None:

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/messaging/mqtt.py

@@ -13,6 +13,9 @@ from collections.abc import Awaitable, Callable
 from contextlib import AsyncExitStack
 from typing import TYPE_CHECKING, Any, override
 
+if TYPE_CHECKING:
+    from boneio.integration.homeassistant import HomeAssistantDiscoveryMessage
+
 from aiomqtt import Client as AsyncioClient
 from aiomqtt import MqttError, Will
 from paho.mqtt.properties import Properties
@@ -164,7 +167,7 @@ class MQTTClient(MessageBus):
     def send_message(
         self,
         topic: str,
-        payload: str | int | bytes | dict[str, str | float | int] | None,
+        payload: str | int | bytes | dict[str, Any] | None,
         retain: bool = False,
         qos: int = 0,
     ) -> None:

{boneio-1.0.0.dev19 → boneio-1.0.0.dev21}/boneio/core/remote/__init__.py

@@ -2,16 +2,28 @@
 
 Supports multiple protocols:
 - MQTT: Standard MQTT communication (boneIO Black, ESPHome, etc.)
+- ESPHome API: Native ESPHome API via TCP/IP
 - CAN: CAN bus communication (future)
 - Loxone: Loxone Miniserver integration (future)
-- ESPHome API: Native ESPHome API (future)
 """
 
 from boneio.core.remote.base import RemoteDevice, RemoteDeviceProtocol
 from boneio.core.remote.mqtt import MQTTRemoteDevice
+from boneio.core.remote.esphome import (
+    ESPHomeRemoteDevice,
+    discover_esphome_entities,
+    scan_esphome_devices,
+    ESPHOME_API_AVAILABLE,
+    ZEROCONF_AVAILABLE,
+)
 
 __all__ = [
     "RemoteDevice",
     "RemoteDeviceProtocol",
     "MQTTRemoteDevice",
+    "ESPHomeRemoteDevice",
+    "discover_esphome_entities",
+    "scan_esphome_devices",
+    "ESPHOME_API_AVAILABLE",
+    "ZEROCONF_AVAILABLE",
 ]