boneIO 1.1.0.dev3__tar.gz → 1.1.0.dev4__tar.gz

{boneio-1.1.0.dev3/boneio.egg-info → boneio-1.1.0.dev4}/PKG-INFO

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

{boneio-1.1.0.dev3 → boneio-1.1.0.dev4}/boneio/core/config/config_helper.py

@@ -45,6 +45,7 @@ class ConfigHelper:
         config_file_path: str | None = None,
         send_boneio_autodiscovery: bool = True,
         receive_boneio_autodiscovery: bool = True,
+        update_channel: str = "stable",
     ):
         self._name = name
         
@@ -63,6 +64,7 @@ class ConfigHelper:
         self._ha_discovery_prefix = ha_discovery_prefix
         self._send_boneio_autodiscovery = send_boneio_autodiscovery
         self._receive_boneio_autodiscovery = receive_boneio_autodiscovery
+        self._update_channel = update_channel
         self._device_type = device_type
         self._web_port = web_port
         self._proxy_port = proxy_port
@@ -79,6 +81,7 @@ class ConfigHelper:
             TEXT_SENSOR: {},
             SELECT: {},
             NUMERIC: {},
+            "update": {}
         }
         self.manager_ready: bool = False
         self._network_info = network_info
@@ -181,6 +184,11 @@ class ConfigHelper:
         """Check if BoneIO autodiscovery receiving is enabled."""
         return self._receive_boneio_autodiscovery
 
+    @property
+    def update_channel(self) -> str:
+        """Get update channel (stable or dev)."""
+        return self._update_channel
+
     @property
     def device_type(self) -> str:
         return self._device_type

{boneio-1.1.0.dev3 → boneio-1.1.0.dev4}/boneio/core/manager/inputs.py

@@ -687,6 +687,14 @@ class InputManager:
         # Send event to MQTT for Home Assistant
         self._publish_input_event_to_mqtt(input_instance, event)
         
+        # If publish_only is set, skip action execution (used for initial state sync)
+        if event.publish_only:
+            _LOGGER.debug(
+                "Skipping action execution for %s (publish_only=True)",
+                event.entity_id
+            )
+            return
+        
         # Execute actions with duration threshold support
         if actions and event.click_type == LONG:
             # Get executed_actions from detector state

{boneio-1.1.0.dev3 → boneio-1.1.0.dev4}/boneio/core/manager/manager.py

@@ -39,6 +39,7 @@ from boneio.core.manager.modbus import ModbusManager
 from boneio.core.manager.outputs import OutputManager
 from boneio.core.manager.sensors import SensorManager
 from boneio.core.manager.remote import RemoteDeviceManager
+from boneio.core.manager.update import UpdateManager
 from boneio.core.discovery import BlackDiscoveryPublisher
 from boneio.core.messaging import MessageBus
 from boneio.core.state import StateManager
@@ -204,6 +205,11 @@ class Manager:
             message_bus=message_bus,
         )
         
+        # 9. UpdateManager (checks for software updates and publishes to HA)
+        self.update_manager = UpdateManager(
+            manager=self,
+        )
+        
         # Configure virtual energy sensors (must be after outputs are initialized)
         self.sensors.configure_virtual_energy_sensors()
         
@@ -323,6 +329,7 @@ class Manager:
         await self.sensors.send_ha_autodiscovery()
         await self.modbus.send_ha_autodiscovery()
         await self.display.send_ha_autodiscovery()
+        await self.update_manager.send_ha_autodiscovery()
 
     def send_ha_autodiscovery(
         self,
@@ -380,6 +387,9 @@ class Manager:
             availability_msg_func = ha_cover_availabilty_message
         elif ha_type == BUTTON:
             availability_msg_func = ha_button_availabilty_message
+        elif ha_type == "update":
+            from boneio.integration.homeassistant import ha_update_availability_message
+            availability_msg_func = ha_update_availability_message
         
         # Use availability_msg_func from kwargs if provided (for sensors)
         if 'availability_msg_func' in kwargs:
@@ -400,6 +410,16 @@ class Manager:
             )
             self.send_message(topic=topic, payload=payload, retain=True)
 
+    async def _handle_update_install_command(self, topic: str, payload: str) -> None:
+        """Handle update install command from Home Assistant.
+        
+        Args:
+            topic: MQTT topic
+            payload: MQTT payload (should be "INSTALL")
+        """
+        _LOGGER.info("Received update install command: %s", payload)
+        await self.update_manager.handle_install_command(payload)
+
     def parse_actions(self, pin: str, actions: dict) -> dict:
         """Parse actions configuration.
         

boneio-1.1.0.dev4/boneio/core/manager/update.py

@@ -0,0 +1,341 @@
+"""Update manager for checking and publishing software updates to Home Assistant.
+
+This module manages periodic checking of software updates from GitHub
+and publishes the update status to Home Assistant via MQTT.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING
+
+from boneio.core.utils.async_updater import AsyncUpdater
+from boneio.core.utils.timeperiod import TimePeriod
+from boneio.version import __version__
+
+if TYPE_CHECKING:
+    from boneio.core.manager import Manager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class UpdateManager(AsyncUpdater):
+    """Manages software update checking and MQTT publishing.
+    
+    This manager:
+    - Checks for updates from GitHub periodically (default: 4 hours)
+    - Caches results to avoid rate limiting
+    - Publishes update state to MQTT for Home Assistant
+    - Supports on-demand update checks from frontend
+    """
+
+    def __init__(
+        self,
+        manager: Manager,
+        update_interval: TimePeriod | None = None,
+    ):
+        """Initialize UpdateManager.
+        
+        Args:
+            manager: Parent Manager instance
+            update_interval: Time between update checks (default: 4 hours)
+        """
+        self.id = "update_manager"
+        self._manager = manager
+        
+        # Update check interval (default: 4 hours)
+        if update_interval is None:
+            update_interval = TimePeriod(hours=4)
+        
+        # Cache for update info to avoid excessive GitHub API calls
+        self._last_check_result: dict | None = None
+        self._last_published_state: str | None = None
+        self._ha_discovery_sent: bool = False
+        
+        # Initialize AsyncUpdater (starts periodic task)
+        super().__init__(manager=manager, update_interval=update_interval)
+        
+        _LOGGER.info(
+            "UpdateManager initialized (check interval: %s)",
+            update_interval
+        )
+
+    async def async_update(self, timestamp: float) -> float | None:
+        """Perform periodic update check.
+        
+        Args:
+            timestamp: Current timestamp
+            
+        Returns:
+            Optional custom update interval in seconds
+        """
+        # Send HA discovery on first update (MQTT is connected by then)
+        if not self._ha_discovery_sent:
+            await self.send_ha_autodiscovery()
+            self._ha_discovery_sent = True
+        
+        _LOGGER.debug("Checking for software updates...")
+        
+        try:
+            # Check for updates from GitHub
+            update_info = await self._check_update_from_github()
+            
+            if update_info and update_info.get("status") == "success":
+                # Publish state to MQTT
+                await self._publish_state_to_mqtt(update_info)
+            else:
+                _LOGGER.warning(
+                    "Update check failed: %s",
+                    update_info.get("message", "Unknown error") if update_info else "No response"
+                )
+        except Exception as e:
+            _LOGGER.error("Error during update check: %s", e, exc_info=True)
+        
+        # Return None to use default interval
+        return None
+
+    async def _check_update_from_github(self) -> dict | None:
+        """Check for updates from GitHub releases.
+        
+        This method reuses the logic from /api/check_update endpoint.
+        
+        Returns:
+            Update information dict or None on error
+        """
+        current_version = __version__
+        
+        try:
+            import requests
+        except ImportError:
+            _LOGGER.error("Package 'requests' is not installed")
+            return {
+                "status": "error",
+                "message": "Package 'requests' is not installed",
+                "current_version": current_version
+            }
+        
+        try:
+            from packaging import version
+        except ImportError:
+            _LOGGER.error("Package 'packaging' is not installed")
+            return {
+                "status": "error",
+                "message": "Package 'packaging' is not installed",
+                "current_version": current_version
+            }
+        
+        try:
+            repo = "boneIO-eu/app_black"
+            api_url = f'https://api.github.com/repos/{repo}/releases'
+            response = requests.get(api_url, timeout=10)
+            
+            if response.status_code != 200:
+                return {
+                    "status": "error",
+                    "message": f"GitHub API error: {response.status_code}",
+                    "current_version": current_version
+                }
+            
+            releases = response.json()
+            
+            if not releases:
+                return {
+                    "status": "error",
+                    "message": "No releases found on GitHub",
+                    "current_version": current_version
+                }
+            
+            # Find latest stable and prerelease versions
+            latest_stable = None
+            latest_prerelease = None
+            
+            for release in releases:
+                tag = release['tag_name']
+                ver_str = tag[1:] if tag.startswith('v') else tag
+                
+                # Skip v0.x versions (Debian 10, incompatible)
+                if tag.startswith("v0."):
+                    continue
+                
+                is_prerelease = release.get('prerelease', False)
+                
+                if not is_prerelease:
+                    ver_lower = ver_str.lower()
+                    is_prerelease = any(x in ver_lower for x in ['dev', 'alpha', 'beta', 'rc'])
+                
+                ver_info = {
+                    "version": ver_str,
+                    "is_prerelease": is_prerelease,
+                    "release_url": release['html_url'],
+                    "published_at": release['published_at'],
+                    "release_notes": release.get('body', '')[:255],  # Max 255 chars for HA
+                }
+                
+                if not is_prerelease and latest_stable is None:
+                    latest_stable = ver_info
+                if is_prerelease and latest_prerelease is None:
+                    latest_prerelease = ver_info
+                
+                # Stop after finding both
+                if latest_stable and latest_prerelease:
+                    break
+            
+            # Determine which version to recommend based on update_channel setting
+            update_channel = self._manager._config_helper.update_channel
+            
+            if update_channel == "dev":
+                # Dev channel: prefer prerelease, fallback to stable
+                recommended = latest_prerelease or latest_stable
+            else:
+                # Stable channel (default): only stable releases
+                recommended = latest_stable
+            
+            if not recommended:
+                return {
+                    "status": "error",
+                    "message": "No suitable release found",
+                    "current_version": current_version
+                }
+            
+            # Check if update is available
+            is_update_available = False
+            try:
+                current_parsed = version.parse(current_version)
+                recommended_parsed = version.parse(recommended["version"])
+                is_update_available = recommended_parsed > current_parsed
+            except Exception as e:
+                _LOGGER.warning("Error parsing versions: %s", e)
+            
+            result = {
+                "status": "success",
+                "current_version": current_version,
+                "latest_version": recommended["version"],
+                "update_available": is_update_available,
+                "release_url": recommended["release_url"],
+                "release_notes": recommended.get("release_notes", ""),
+                "is_prerelease": recommended["is_prerelease"],
+            }
+            
+            # Cache result
+            self._last_check_result = result
+            
+            return result
+            
+        except Exception as e:
+            _LOGGER.error("Error checking for updates: %s", e, exc_info=True)
+            return {
+                "status": "error",
+                "message": f"Error: {str(e)}",
+                "current_version": current_version
+            }
+
+    async def _publish_state_to_mqtt(self, update_info: dict) -> None:
+        """Publish update state to MQTT for Home Assistant.
+        
+        Args:
+            update_info: Update information from GitHub check
+        """
+        if update_info.get("status") != "success":
+            return
+        
+        current_version = update_info.get("current_version", __version__)
+        latest_version = update_info.get("latest_version", current_version)
+        
+        # Build state payload (JSON format for HA Update entity)
+        state_payload = {
+            "installed_version": current_version,
+            "latest_version": latest_version,
+            "title": "boneIO Black Firmware",
+            "release_url": update_info.get("release_url", ""),
+            "release_summary": update_info.get("release_notes", "")[:255],  # HA limit
+        }
+        
+        # Add entity_picture (boneIO logo from HA brands)
+        state_payload["entity_picture"] = "http://boneio.eu/logo_fb_circle.png"
+        
+        # Convert to JSON
+        payload_json = json.dumps(state_payload)
+        
+        # Only publish if state changed (avoid unnecessary MQTT traffic)
+        if payload_json == self._last_published_state:
+            _LOGGER.debug("Update state unchanged, skipping MQTT publish")
+            return
+        
+        # Publish to MQTT
+        topic_prefix = self._manager._config_helper.topic_prefix
+        state_topic = f"{topic_prefix}/update/state"
+        
+        self._manager.send_message(
+            topic=state_topic,
+            payload=payload_json,
+            retain=True,
+        )
+        
+        self._last_published_state = payload_json
+        
+        _LOGGER.info(
+            "Published update state to MQTT: %s -> %s (update available: %s)",
+            current_version,
+            latest_version,
+            update_info.get("update_available", False)
+        )
+
+    def get_last_check_result(self) -> dict | None:
+        """Get the last update check result.
+        
+        Returns:
+            Last check result dict or None if no check performed yet
+        """
+        return self._last_check_result
+
+    async def handle_install_command(self, payload: str) -> None:
+        """Handle install command from Home Assistant.
+        
+        This is called when HA sends a message to the command topic.
+        
+        Args:
+            payload: MQTT payload (should be "INSTALL")
+        """
+        if payload != "INSTALL":
+            _LOGGER.warning("Invalid install command payload: %s", payload)
+            return
+        
+        _LOGGER.info("Received install command from Home Assistant")
+        
+        # Check if update is available
+        if not self._last_check_result:
+            _LOGGER.warning("No update check result available, checking now...")
+            await self.async_update(timestamp=0)
+        
+        if not self._last_check_result or not self._last_check_result.get("update_available"):
+            _LOGGER.warning("No update available to install")
+            return
+        
+        # Trigger update via existing update endpoint
+        # Note: This requires the update API to be accessible
+        # The actual installation is handled by /api/update endpoint
+        _LOGGER.info(
+            "Update installation should be triggered via WebUI or API endpoint /api/update"
+        )
+        
+        # TODO: Consider adding direct integration with update logic
+        # For now, users should use the WebUI to trigger updates
+
+    async def send_ha_autodiscovery(self) -> None:
+        """Send Home Assistant autodiscovery for Update entity."""
+        _LOGGER.debug("Sending HA autodiscovery for Update entity")
+        
+        self._manager.send_ha_autodiscovery(
+            id="firmware",
+            name="Update",
+            ha_type="update",
+        )
+        
+        # Subscribe to command topic for install commands
+        command_topic = f"{self._manager._topic_prefix}/update/install"
+        await self._manager._message_bus.subscribe_and_listen(
+            topic=command_topic,
+            callback=self._manager._handle_update_install_command
+        )
+        _LOGGER.info("Subscribed to update command topic: %s", command_topic)

{boneio-1.1.0.dev3 → boneio-1.1.0.dev4}/boneio/integration/homeassistant.py

@@ -661,3 +661,47 @@ def ha_cover_with_tilt_availabilty_message(
         "position_template": '{{ value_json.position }}',
         "tilt_status_template": '{{ value_json.tilt }}',
     }
+
+
+def ha_update_availability_message(
+    id: str, name: str, config_helper: ConfigHelper, **kwargs
+) -> HomeAssistantDiscoveryMessage:
+    """Create Update availability topic for HA.
+    
+    Args:
+        id: Entity ID
+        name: Entity name
+        config_helper: ConfigHelper instance
+        **kwargs: Additional fields (e.g., device_class, entity_category)
+    
+    Returns:
+        HA discovery message for Update entity
+    """
+    topic = config_helper.topic_prefix
+    
+    # Default kwargs for Update entity
+    default_kwargs = {
+        "device_class": "firmware",
+        "entity_category": "diagnostic",
+    }
+    
+    msg = ha_availabilty_message(
+        device_type="update",
+        entity_type="update",
+        config_helper=config_helper,
+        id=id,
+        name=name,
+        **{**default_kwargs, **kwargs}
+    )
+    
+    result = {
+        **msg,
+        "state_topic": f"{topic}/update/state",
+        "command_topic": f"{topic}/update/install",
+        "payload_install": "INSTALL",
+        "icon": "mdi:update",
+    }
+    
+    _LOGGER.debug("Update HA discovery message: %s", result)
+    
+    return result

{boneio-1.1.0.dev3 → boneio-1.1.0.dev4}/boneio/runner.py

@@ -120,6 +120,7 @@ async def async_run(
         config_file_path=config_file,
         send_boneio_autodiscovery=mqtt_config.get("send_boneio_autodiscovery", True),
         receive_boneio_autodiscovery=mqtt_config.get("receive_boneio_autodiscovery", True),
+        update_channel=mqtt_config.get("update_channel", "stable"),
     )
     
     # Load areas configuration

{boneio-1.1.0.dev3 → boneio-1.1.0.dev4}/boneio/schema/schema.yaml

@@ -87,6 +87,18 @@ mqtt:
         description: |
           When enabled, this device subscribes to BoneIO autodiscovery topics
           (boneio/+/discovery/#) and automatically discovers neighboring BoneIO devices.
+    update_channel:
+      type: string
+      default: stable
+      allowed:
+        - stable
+        - dev
+      meta:
+        label: Update channel
+        description: |
+          Which releases to show in Home Assistant Update entity:
+          - stable: Only stable releases (recommended)
+          - dev: Include development/pre-release versions
 
 web:
   type: dict

boneio-1.1.0.dev4/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.1.0dev4"

{boneio-1.1.0.dev3 → boneio-1.1.0.dev4}/boneio/webui/app.py

@@ -153,6 +153,7 @@ from boneio.webui.routes import covers as covers_module
 from boneio.webui.routes import modbus as modbus_module
 from boneio.webui.routes import sensors as sensors_module
 from boneio.webui.routes import remote_devices as remote_devices_module
+from boneio.webui.routes import update as update_module
 
 # Use dependency_overrides to replace the placeholder get_manager functions
 app.dependency_overrides[outputs_module.get_manager] = get_manager
@@ -160,6 +161,7 @@ app.dependency_overrides[covers_module.get_manager] = get_manager
 app.dependency_overrides[modbus_module.get_manager] = get_manager
 app.dependency_overrides[sensors_module.get_manager] = get_manager
 app.dependency_overrides[remote_devices_module.get_manager] = get_manager
+app.dependency_overrides[update_module.get_manager] = get_manager
 system_module.set_config_helper_getter(get_config_helper)