boneio 1.4.0.dev13__tar.gz → 1.4.1__tar.gz

{boneio-1.4.0.dev13/boneio.egg-info → boneio-1.4.1}/PKG-INFO

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

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/components/irrigation/controller.py

@@ -691,6 +691,13 @@ class IrrigationController:
         self._active_zone_remaining_s = duration
         self._state = ControllerState.RUNNING
 
+        # Publish state immediately so the UI (frontend + HA) shows
+        # RUNNING right away, before any pump/valve delay sleeps.
+        # The timer has not been armed yet so zone_end_time will be
+        # empty, but a second publish happens after hardware activation.
+        self._run_start_utc = utcnow()
+        await self.publish_all_states()
+
         if src is not None:
             if src.pump_start_valve_delay_s > 0:
                 # Source first (pump+valve), then zone valve after delay

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/core/cloud/registration.py

@@ -300,20 +300,57 @@ class CloudRegistration:
         """
         Check if certificate needs to be refreshed.
 
+        Parses the actual X.509 Not After date from the PEM file using openssl.
+        Returns True if cert expires within 14 days or can't be parsed.
+
         Returns:
-            True if cert is older than 30 days or doesn't exist
+            True if certificate should be refreshed
         """
         if not self._cert_exists():
             return True
 
         try:
-            # Check cert file age
-            import time
+            result = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: subprocess.run(
+                    ["openssl", "x509", "-enddate", "-noout", "-in", str(CERT_FILE)],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                ),
+            )
 
-            cert_age = time.time() - CERT_FILE.stat().st_mtime
-            # Refresh if older than 30 days
-            return cert_age > (30 * 24 * 3600)
-        except Exception:
+            if result.returncode != 0:
+                _LOGGER.warning("Failed to read cert expiry: %s", result.stderr.strip())
+                return True
+
+            # Output format: "notAfter=Jun  3 12:00:00 2026 GMT"
+            line = result.stdout.strip()
+            date_str = line.split("=", 1)[1]
+
+            from datetime import datetime, timezone
+
+            expiry = datetime.strptime(date_str, "%b %d %H:%M:%S %Y %Z").replace(
+                tzinfo=timezone.utc
+            )
+            now = datetime.now(tz=timezone.utc)
+            days_left = (expiry - now).total_seconds() / 86400
+
+            _LOGGER.debug(
+                "SSL certificate expires: %s (%.1f days left)", expiry.isoformat(), days_left
+            )
+
+            # Refresh if expiring within 14 days
+            if days_left < 14:
+                _LOGGER.info(
+                    "SSL certificate expires in %.1f days, refreshing", days_left
+                )
+                return True
+
+            return False
+
+        except Exception as e:
+            _LOGGER.warning("Error checking cert expiry, forcing refresh: %s", e)
             return True
 
     def update_ip(self, new_ip: str) -> None:

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/core/manager/inputs.py

@@ -130,8 +130,16 @@ class InputManager:
                 return False
             return False
 
-        def configure_single_input(configure_sensor_func: Callable, gpio: dict) -> None:
-            """Configure a single input (event or binary sensor)."""
+        def configure_single_input(
+            configure_sensor_func: Callable, gpio: dict, expected_class: type
+        ) -> None:
+            """Configure a single input (event or binary sensor).
+
+            Args:
+                configure_sensor_func: The _configure_event_sensor or _configure_binary_sensor method.
+                gpio: GPIO configuration dictionary.
+                expected_class: The expected class type (GpioEventButton or GpioInputBinarySensor).
+            """
             # Work on a copy to avoid modifying the cached config
             gpio_copy = gpio.copy()
 
@@ -149,6 +157,18 @@ class InputManager:
 
             existing_input = self._inputs.get(input_id, None) if reload_config else None
 
+            # Guard: if the existing input is a different class (type changed,
+            # e.g. event → binary_sensor), do NOT pass it as existing_input.
+            # A new object with the correct detector must be created instead.
+            if existing_input is not None and not isinstance(existing_input, expected_class):
+                _LOGGER.info(
+                    "Input %s type changed from %s to %s, creating new input object",
+                    input_id,
+                    type(existing_input).__name__,
+                    expected_class.__name__,
+                )
+                existing_input = None
+
             input_device = configure_sensor_func(
                 gpio=gpio_copy,
                 pin=pin,
@@ -172,14 +192,22 @@ class InputManager:
         # Configure event buttons
         for gpio in self._event_pins:
             try:
-                configure_single_input(configure_sensor_func=self._configure_event_sensor, gpio=gpio)
+                configure_single_input(
+                    configure_sensor_func=self._configure_event_sensor,
+                    gpio=gpio,
+                    expected_class=GpioEventButton,
+                )
             except GPIOInputException as err:
                 _LOGGER.error("Failed to configure event input: %s", err)
 
         # Configure binary sensors
         for gpio in self._binary_pins:
             try:
-                configure_single_input(configure_sensor_func=self._configure_binary_sensor, gpio=gpio)
+                configure_single_input(
+                    configure_sensor_func=self._configure_binary_sensor,
+                    gpio=gpio,
+                    expected_class=GpioInputBinarySensor,
+                )
             except GPIOInputException as err:
                 _LOGGER.error("Failed to configure binary sensor: %s", err)
 
@@ -490,21 +518,25 @@ class InputManager:
         # Get config from ConfigHelper (already reloaded by Manager)
         config = self._manager._config_helper.get_config()
 
-        # Build map of new inputs from config (input_id -> {pin, area})
+        # Build map of new inputs from config (input_id -> {pin, area, ha_type})
         # Note: boneio_input is normalized to lowercase to match yaml_util.py behavior
         new_input_map: dict[str, dict] = {}
-        for gpio in config.get(EVENT_ENTITY, []) + config.get(BINARY_SENSOR, []):
-            pin = gpio.get("pin")
-            # Determine input ID (same logic as in _configure_event_sensor/_configure_binary_sensor)
-            if "id" in gpio:
-                input_id = gpio["id"]
-            elif "boneio_input" in gpio:
-                input_id = gpio["boneio_input"].lower()
-            elif pin:
-                input_id = pin
-            else:
-                continue
-            new_input_map[input_id] = {"pin": pin, "area": gpio.get("area")}
+        for ha_type, gpio_list in [
+            (EVENT_ENTITY, config.get(EVENT_ENTITY, [])),
+            (BINARY_SENSOR, config.get(BINARY_SENSOR, [])),
+        ]:
+            for gpio in gpio_list:
+                pin = gpio.get("pin")
+                # Determine input ID (same logic as in _configure_event_sensor/_configure_binary_sensor)
+                if "id" in gpio:
+                    input_id = gpio["id"]
+                elif "boneio_input" in gpio:
+                    input_id = gpio["boneio_input"].lower()
+                elif pin:
+                    input_id = pin
+                else:
+                    continue
+                new_input_map[input_id] = {"pin": pin, "area": gpio.get("area"), "ha_type": ha_type}
 
         # Find inputs to remove (in current config but not in new config)
         current_input_ids = set(self._inputs.keys())
@@ -512,12 +544,29 @@ class InputManager:
 
         inputs_to_remove = current_input_ids - new_input_ids
 
-        _LOGGER.info(f"Input reload: current={current_input_ids}, new={new_input_ids}, to_remove={inputs_to_remove}")
+        _LOGGER.info("Input reload: current=%s, new=%s, to_remove=%s", current_input_ids, new_input_ids, inputs_to_remove)
+
+        # Detect inputs whose type changed (event <-> binary_sensor).
+        # These must be removed and re-created with the correct detector class.
+        inputs_type_changed: set[str] = set()
+        for input_id, new_info in new_input_map.items():
+            existing = self._inputs.get(input_id)
+            if existing is None:
+                continue
+            new_ha_type = new_info["ha_type"]
+            # GpioEventButton has input_type=INPUT, GpioInputBinarySensor has input_type=INPUT_SENSOR
+            if new_ha_type == EVENT_ENTITY and not isinstance(existing, GpioEventButton):
+                inputs_type_changed.add(input_id)
+            elif new_ha_type == BINARY_SENSOR and not isinstance(existing, GpioInputBinarySensor):
+                inputs_type_changed.add(input_id)
+
+        if inputs_type_changed:
+            _LOGGER.info("Input type changed for: %s — will recreate with new detector", inputs_type_changed)
 
         # Remove deleted inputs from internal state (GPIO pin stays registered - minimal overhead)
         ha_discovery_changed = False
 
-        for input_id in inputs_to_remove:
+        for input_id in inputs_to_remove | inputs_type_changed:
             input_device = self._inputs.get(input_id)
             if input_device:
                 old_area = getattr(input_device, "area", None)
@@ -528,7 +577,7 @@ class InputManager:
 
                 # Remove from internal state (GPIO detector will be replaced by new input class)
                 del self._inputs[input_id]
-                _LOGGER.info(f"Removed input {input_id}")
+                _LOGGER.info("Removed input %s (type_changed=%s)", input_id, input_id in inputs_type_changed)
 
         # Check for area changes on remaining inputs
         for input_id, input_device in self._inputs.items():
@@ -537,7 +586,7 @@ class InputManager:
 
             if old_area != new_area:
                 ha_discovery_changed = True
-                _LOGGER.info(f"Input {input_id} area changed: {old_area} -> {new_area}, removing old HA Discovery")
+                _LOGGER.info("Input %s area changed: %s -> %s, removing old HA Discovery", input_id, old_area, new_area)
                 self._remove_input_ha_discovery(input_id, old_area)
 
         # Wait for HA to process the removal before sending new discovery
@@ -547,6 +596,7 @@ class InputManager:
 
         # _configure_inputs with reload_config=True will:
         # - Update existing inputs (actions, area, name)
+        # - Create new inputs for type-changed entries (old objects removed above)
         # - Add new inputs if their GPIO pin is already registered
         self._configure_inputs(reload_config=True)
 

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/core/sensor/base.py

@@ -83,6 +83,7 @@ class BaseSensor(BasicMqtt, AsyncUpdater, Filter):
         
         # Sensor state
         self._state: Any = None
+        self._attributes: dict[str, Any] = {}
         self._timestamp: float | None = None
         self._unit_of_measurement = unit_of_measurement or ""
         
@@ -135,10 +136,13 @@ class BaseSensor(BasicMqtt, AsyncUpdater, Filter):
         """
         self._timestamp = timestamp
         
-        # Send to MQTT
+        # Send to MQTT — include extra attributes if set by subclass
+        payload: dict[str, Any] = {STATE: self.state}
+        if self._attributes:
+            payload.update(self._attributes)
         self._message_bus.send_message(
             topic=self._send_topic,
-            payload={STATE: self.state},
+            payload=payload,
         )
         
         
@@ -150,6 +154,7 @@ class BaseSensor(BasicMqtt, AsyncUpdater, Filter):
                 state=self.state,   
                 unit=self.unit_of_measurement,
                 timestamp=self.last_timestamp,
+                attributes=self._attributes if self._attributes else None,
             )
         ))
         

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/core/sensor/system.py

@@ -89,14 +89,17 @@ class DiskUsageSensor(BaseSensor):
 
     async def async_update(self, timestamp: float) -> None:
         """Fetch disk usage and publish to MQTT.
-        
+
+        Publishes percentage as main state plus extra attributes
+        (disk_total_gib, disk_used_gib, disk_free_gib) for HA.
+
         Args:
             timestamp: Current timestamp
         """
         try:
             disk = psutil.disk_usage(self._mount_point)
             usage_percent = round(disk.percent, 1)
-            
+
             _LOGGER.debug(
                 "Disk usage for %s: %.1f%% (used: %d bytes, total: %d bytes)",
                 self._mount_point,
@@ -104,10 +107,15 @@ class DiskUsageSensor(BaseSensor):
                 disk.used,
                 disk.total
             )
-            
+
             self._state = usage_percent
+            self._attributes = {
+                "disk_total_gib": round(disk.total / (1024 ** 3), 2),
+                "disk_used_gib": round(disk.used / (1024 ** 3), 2),
+                "disk_free_gib": round(disk.free / (1024 ** 3), 2),
+            }
             self._publish_state(timestamp=timestamp)
-            
+
         except Exception as err:
             _LOGGER.error("Error reading disk usage: %s", err)
 
@@ -161,24 +169,32 @@ class MemoryUsageSensor(BaseSensor):
 
     async def async_update(self, timestamp: float) -> None:
         """Fetch memory usage and publish to MQTT.
-        
+
+        Publishes percentage as main state plus extra attributes
+        (memory_total_gib, memory_used_gib, memory_available_gib) for HA.
+
         Args:
             timestamp: Current timestamp
         """
         try:
             memory = psutil.virtual_memory()
             usage_percent = round(memory.percent, 1)
-            
+
             _LOGGER.debug(
                 "Memory usage: %.1f%% (used: %d bytes, total: %d bytes)",
                 usage_percent,
                 memory.used,
                 memory.total
             )
-            
+
             self._state = usage_percent
+            self._attributes = {
+                "memory_total_gib": round(memory.total / (1024 ** 3), 2),
+                "memory_used_gib": round(memory.used / (1024 ** 3), 2),
+                "memory_available_gib": round(memory.available / (1024 ** 3), 2),
+            }
             self._publish_state(timestamp=timestamp)
-            
+
         except Exception as err:
             _LOGGER.error("Error reading memory usage: %s", err)
 

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/hardware/display/oled.py

@@ -541,7 +541,7 @@ class Oled:
         else:
             self._next_screen()
 
-        if not self._cancel_sleep_handle and self._sleep_timeout.total_seconds > 0:
+        if self._sleep_timeout.total_seconds > 0:
             self.start_sleep_timer()
 
     def _update_display(self) -> None:

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/integration/homeassistant.py

@@ -776,7 +776,10 @@ def ha_sensor_system_availabilty_message(
     **kwargs
 ):
     """Create availability topic for system sensors (disk, memory, CPU).
-    
+
+    Includes json_attributes_topic so HA picks up extra attributes
+    (e.g. disk_total_gb, memory_used_gb) from the same state topic.
+
     Args:
         id: Sensor ID
         name: Sensor name
@@ -785,7 +788,7 @@ def ha_sensor_system_availabilty_message(
         device_class: HA device class (optional)
         icon: MDI icon (optional)
         **kwargs: Additional fields
-        
+
     Returns:
         HA discovery message dict
     """
@@ -801,12 +804,19 @@ def ha_sensor_system_availabilty_message(
     msg["state_class"] = "measurement"
     msg["value_template"] = "{{ value_json.state }}"
     msg["entity_category"] = "diagnostic"
-    
+
+    # Expose extra attributes (e.g. disk_total_gb, memory_available_gb)
+    state_topic = msg.get("state_topic", f"{config_helper.topic_prefix}/{SENSOR}/{id}")
+    msg["json_attributes_topic"] = state_topic
+    msg["json_attributes_template"] = (
+        "{{ value_json | tojson }}"
+    )
+
     if device_class:
         msg["device_class"] = device_class
     if icon:
         msg["icon"] = icon
-        
+
     return msg
 
 

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/models/state.py

@@ -69,6 +69,7 @@ class SensorState(BaseModel):
     state: float | str | None
     unit: str | None
     timestamp: float | None
+    attributes: dict[str, float | str | int | bool | None] | None = None
 
 class ModbusDeviceState(BaseModel):
     """Modbus device state model."""

boneio-1.4.1/boneio/version.py

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

{boneio-1.4.0.dev13 → boneio-1.4.1}/boneio/webui/app.py

@@ -497,6 +497,23 @@ async def send_initial_states(
             except Exception as e:
                 _LOGGER.error(f"Error preparing ADC sensor state: {type(e).__name__} - {e}")
 
+        # Send system sensor states (CPU, disk, memory)
+        for sensor in boneio_manager.sensors.get_system_sensors():
+            try:
+                sensor_state = SensorState(
+                    id=sensor.id,
+                    name=sensor.name,
+                    state=sensor.state,
+                    unit=sensor.unit_of_measurement,
+                    timestamp=sensor.last_timestamp,
+                    attributes=sensor._attributes if hasattr(sensor, "_attributes") and sensor._attributes else None,
+                )
+                update = SensorEvent(entity_id=sensor.id, state=sensor_state)
+                if not await send_state_update(update):
+                    return False
+            except Exception as e:
+                _LOGGER.error(f"Error preparing system sensor state: {type(e).__name__} - {e}")
+
         # Send virtual energy sensor states
         for ve_sensor in boneio_manager.sensors.get_virtual_energy_sensors():
             try: