boneIO 1.0.0.dev20__tar.gz → 1.0.0.dev22__tar.gz

{boneio-1.0.0.dev20/boneio.egg-info → boneio-1.0.0.dev22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.0.0.dev20
+Version: 1.0.0.dev22
 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.dev20 → boneio-1.0.0.dev22}/boneio/components/cover/time_based.py

@@ -41,7 +41,13 @@ class TimeBasedCover(BaseCover):
 
 
     def _move_cover(self, direction: str, duration: float, target_position: int | None = None):
-        """Metoda uruchamiana w oddzielnym wątku do fizycznego ruchu rolety."""
+        """Run in sepearate thread.
+        
+        Args:
+            direction: Direction of movement (OPEN or CLOSE)
+            duration: Full time for 0-100% movement in milliseconds
+            target_position: Optional target position (0-100)
+        """
         if direction == OPEN:
             relay = self._open_relay
             total_steps = 100 - self._position
@@ -56,18 +62,22 @@ class TimeBasedCover(BaseCover):
             self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
             return
 
+        # Calculate actual duration based on remaining distance
+        # duration is full time for 100% movement, scale it by actual distance to travel
+        actual_duration = duration * (total_steps / 100.0)
+
         relay.turn_on()
         start_time = time.monotonic()
 
         while not self._stop_event.is_set():
             current_time = time.monotonic()  # Pobierz aktualny czas tylko raz na iterację
             elapsed_time = (current_time - start_time) * 1000  # Konwersja na milisekundy
-            progress = elapsed_time / duration
+            progress = elapsed_time / actual_duration if actual_duration > 0 else 1.0
 
             if direction == OPEN:
-                self._position = min(100.0, self._initial_position + progress * 100)
+                self._position = min(100.0, self._initial_position + progress * total_steps)
             elif direction == CLOSE:
-                self._position = max(0.0, self._initial_position - progress * 100)
+                self._position = max(0.0, self._initial_position - progress * total_steps)
 
             self._last_timestamp = current_time # Użyj pobranego czasu
             if current_time - self._last_update_time >= 1:

{boneio-1.0.0.dev20 → boneio-1.0.0.dev22}/boneio/components/cover/venetian.py

@@ -97,6 +97,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             )
             return
 
+        # Calculate actual duration based on remaining distance
+        # duration is full time for 100% movement, scale it by actual distance to travel
+        actual_duration = duration * (total_steps / 100.0)
+
         relay.turn_on()
         start_time = time.monotonic()
         progress = 0.0
@@ -116,15 +120,15 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
            
             if elapsed_time < needed_tilt_duration:
-                tilt_progress = elapsed_time / needed_tilt_duration
+                tilt_progress = elapsed_time / needed_tilt_duration if needed_tilt_duration > 0 else 1.0
                 progress = 0.0
             else:
                 tilt_progress = 1.0
-                progress = (elapsed_time - needed_tilt_duration) / duration
+                progress = (elapsed_time - needed_tilt_duration) / actual_duration if actual_duration > 0 else 1.0
 
             if direction == OPEN:
                 # Obliczanie _position dla kierunku OPEN
-                self._position = min(100.0, self._initial_position + progress * 100)
+                self._position = min(100.0, self._initial_position + progress * total_steps)
 
                 # Obliczanie _tilt_position dla kierunku OPEN
                 if target_tilt_position is not None:
@@ -135,7 +139,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
                     )
             elif direction == CLOSE:
                 # Obliczanie _position dla kierunku CLOSE
-                self._position = max(0.0, self._initial_position - progress * 100)
+                self._position = max(0.0, self._initial_position - progress * total_steps)
 
                 # Obliczanie _tilt_position dla kierunku CLOSE
                 if target_tilt_position is not None:

{boneio-1.0.0.dev20 → boneio-1.0.0.dev22}/boneio/components/input/binary_sensor.py

@@ -54,9 +54,9 @@ class GpioInputBinarySensor(GpioBaseClass):
         _LOGGER.debug("Configured binary sensor %s on pin %s (inverted=%s)", 
                      self._name, self._pin, inverted)
         
-        # Send initial state if requested
+        # Send initial state if requested - register callback to run after GPIO manager starts
         if kwargs.get("initial_send", False):
-            self._loop.call_soon(callback=self._send_initial_state)
+            gpio_manager.register_on_start_callback(self._send_initial_state)
 
     def _send_initial_state(self) -> None:
         """Send initial state after setup."""

{boneio-1.0.0.dev20 → boneio-1.0.0.dev22}/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.dev20 → boneio-1.0.0.dev22}/boneio/core/manager/display.py

@@ -190,10 +190,28 @@ class DisplayManager:
             
         except (GPIOInputException, I2CError) as err:
             _LOGGER.error("Can't configure OLED display: %s", err)
+            # Store error in manager for WebUI display
+            self._manager._hardware_errors.append({
+                'type': 'display',
+                'id': 'oled',
+                'name': 'OLED Display',
+                'address': 0x3C,
+                'error': str(err),
+                'message': f"OLED display at address 0x3C: {err}",
+            })
         except ImportError as err:
             _LOGGER.error("Failed to import OLED modules: %s", err)
         except Exception as err:
             _LOGGER.error("Unexpected error configuring OLED: %s", err)
+            # Store error in manager for WebUI display
+            self._manager._hardware_errors.append({
+                'type': 'display',
+                'id': 'oled',
+                'name': 'OLED Display',
+                'address': 0x3C,
+                'error': str(err),
+                'message': f"OLED display: {err}",
+            })
 
     def get_oled(self) -> Any | None:
         """Get OLED display instance.

{boneio-1.0.0.dev20 → boneio-1.0.0.dev22}/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.dev20 → boneio-1.0.0.dev22}/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.dev20 → boneio-1.0.0.dev22}/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
@@ -173,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
@@ -209,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.
         
@@ -233,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
@@ -249,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,
@@ -262,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:
@@ -278,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,
@@ -585,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.dev20 → boneio-1.0.0.dev22}/boneio/core/manager/sensors.py

@@ -183,6 +183,16 @@ class SensorManager:
             return temp_sensor
         except I2CError as err:
             _LOGGER.error("Can't configure temp sensor %s: %s", name, err)
+            # Store error in manager for WebUI display
+            self._manager._hardware_errors.append({
+                'type': 'sensor',
+                'sensor_type': 'temperature',
+                'id': id,
+                'name': name,
+                'address': config.get(ADDRESS),
+                'error': str(err),
+                'message': f"Temperature sensor {name} at address 0x{config.get(ADDRESS, 0):02X}: {err}",
+            })
             return None
 
     # -------------------------------------------------------------------------
@@ -240,6 +250,16 @@ class SensorManager:
             return ina219
         except I2CError as err:
             _LOGGER.error("Can't configure INA219 sensor: %s", err)
+            # Store error in manager for WebUI display
+            self._manager._hardware_errors.append({
+                'type': 'sensor',
+                'sensor_type': 'ina219',
+                'id': id,
+                'name': id,
+                'address': address,
+                'error': str(err),
+                'message': f"INA219 sensor at address 0x{address:02X}: {err}",
+            })
             return None
 
     # -------------------------------------------------------------------------

{boneio-1.0.0.dev20 → boneio-1.0.0.dev22}/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.dev20 → boneio-1.0.0.dev22}/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.dev20 → boneio-1.0.0.dev22}/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.dev20 → boneio-1.0.0.dev22}/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",
 ]