boneio 1.4.0.dev14__tar.gz → 1.4.2__tar.gz

{boneio-1.4.0.dev14/boneio.egg-info → boneio-1.4.2}/PKG-INFO

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

{boneio-1.4.0.dev14 → boneio-1.4.2}/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.dev14 → boneio-1.4.2}/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.dev14 → boneio-1.4.2}/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.dev14 → boneio-1.4.2}/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.dev14 → boneio-1.4.2}/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.2/boneio/version.py

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

{boneio-1.4.0.dev14 → boneio-1.4.2}/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: