span-panel-api 2.6.0__tar.gz → 2.6.2__tar.gz

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.6.2] - 04/2026
+
+### Changed
+
+- **Reconnect loop log noise reduced** — `SpanMqttClient._reconnect_loop` now splits the catch-all exception handler in two: expected transient failures (`OSError` family — refused connection, DNS miss, socket timeout, `ssl.SSLError`) log a one-line
+  WARNING with the exception repr, while unexpected exceptions retain the full traceback via `exc_info=True`. The common "panel offline" case no longer buries logs in paho/stdlib stack frames that add no diagnostic signal; genuinely unknown failures still
+  surface full tracebacks for support-ticket triage.
+
+## [2.6.1] - 04/2026
+
+### Changed
+
+- **`get_fqdn()` returns `str | None`** — `None` now distinguishes "no FQDN configured" (HTTP 404 or missing field) from an explicit empty string. Callers that treated `""` as "not registered" must update to check for `None`.
+- **Connection callback errors logged at WARNING** — `SpanMqttClient._on_connection_change` now logs callback exceptions via `_LOGGER.warning(..., exc_info=True)` instead of `_LOGGER.exception(...)`, consistent with `_dispatch_snapshot`.
+- **Reconnect loop catches all exceptions** — `AsyncMqttBridge._reconnect_loop` no longer silently drops on non-`OSError` failures (e.g. `WebsocketConnectionError`, `ssl.SSLError`). All exceptions are logged at WARNING and the loop keeps backing off.
+- **Abnormal MQTT disconnects logged at WARNING** — disconnects where `reason_code.is_failure` is true now log at WARNING; clean disconnects continue to log at DEBUG.
+
+### Fixed
+
+- **CA certificate no longer written to disk** — `AsyncMqttBridge.connect()` builds the `ssl.SSLContext` from the fetched PEM via `cadata`, eliminating the temp-file lifecycle (and the small leak window on unexpected process exit) that the prior
+  `tls_set(ca_certs=path)` path required.
+- **Deprecated `asyncio.get_event_loop()` removed** — `_wait_for_circuit_names` now uses `time.monotonic()`. The previous code emitted a `DeprecationWarning` on Python 3.12+.
+- **Negative-zero on circuit `instant_power_w`** — explicit guard replaces a cryptic `-raw or 0.0` idiom in `HomieDeviceConsumer._build_circuit`.
+- **DSM grid-exchanging heuristic uses epsilon** — replaces `!= 0.0` float comparison with `abs(x) > 1.0 W`, so the `DSM_OFF_GRID` branch is actually reachable when no BESS is commissioned and lugs readings hover near zero.
+- **`SpanPanelAPIError.__str__` override removed** — the override silently hid exception args beyond the first; default `Exception.__str__` is now used.
+- **Paho lock-layout check at import** — `span_panel_api.mqtt.async_client` verifies on import that the `_PAHO_LOCK_ATTRS` list exactly matches paho's `*_mutex` attributes. Raises `RuntimeError` (not `assert`, so `python -O` does not bypass it) on drift.
+
+### Documentation
+
+- **`register_v2()`** — docstring now warns that each call creates a new client entry on the panel; callers should persist and reuse the returned `V2AuthResponse` rather than re-registering on every restart.
+- **Stale simulation transport references removed** from `protocol.py` and `models.py` module docstrings.
+
 ## [2.6.0] - 04/2026
 
 ### Added

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: span-panel-api
-Version: 2.6.0
+Version: 2.6.2
 Summary: A client library for SPAN Panel API
 Project-URL: Homepage, https://github.com/SpanPanel/span-panel-api
 Project-URL: Issues, https://github.com/SpanPanel/span-panel-api/issues
@@ -250,9 +250,14 @@ await client.connect()
 
 `set_snapshot_interval()` controls how often push-mode snapshot callbacks fire. Lower values mean lower latency; higher values reduce CPU usage on constrained hardware. Dirty-node caching (v2.5.0) further reduces per-scan cost by skipping unchanged nodes.
 
+Passing `0` (or any non-positive value) disables debounce and dispatches a snapshot for every incoming property message — real-time mode, intended for fast consumers.
+
 ```python
 # Reduce snapshot frequency to every 2 seconds
 client.set_snapshot_interval(2.0)
+
+# Real-time dispatch — every property update triggers a callback
+client.set_snapshot_interval(0)
 ```
 
 ### Circuit Control

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/README.md

@@ -235,9 +235,14 @@ await client.connect()
 
 `set_snapshot_interval()` controls how often push-mode snapshot callbacks fire. Lower values mean lower latency; higher values reduce CPU usage on constrained hardware. Dirty-node caching (v2.5.0) further reduces per-scan cost by skipping unchanged nodes.
 
+Passing `0` (or any non-positive value) disables debounce and dispatches a snapshot for every incoming property message — real-time mode, intended for fast consumers.
+
 ```python
 # Reduce snapshot frequency to every 2 seconds
 client.set_snapshot_interval(2.0)
+
+# Real-time dispatch — every property update triggers a callback
+client.set_snapshot_interval(0)
 ```
 
 ### Circuit Control

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "span-panel-api"
-version = "2.6.0"
+version = "2.6.2"
 description = "A client library for SPAN Panel API"
 authors = [
     {name = "SpanPanel"}

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/auth.py

@@ -47,6 +47,12 @@ async def register_v2(
     If ``passphrase`` is provided, it is sent as ``hopPassphrase``; omitting
     it enables door-bypass registration.
 
+    .. note::
+        Every call creates a new registered client entry on the panel. Callers
+        should persist and reuse the returned ``V2AuthResponse`` rather than
+        re-registering on every restart — otherwise stale entries will
+        accumulate over the panel's lifetime.
+
     Args:
         host: IP address or hostname of the SPAN Panel
         name: Client display name base (e.g., "home-assistant"); a UUID suffix is appended
@@ -310,7 +316,7 @@ async def get_fqdn(
     timeout: float = 10.0,
     port: int = 80,
     httpx_client: httpx.AsyncClient | None = None,
-) -> str:
+) -> str | None:
     """Retrieve the currently registered FQDN from the SPAN Panel.
 
     Args:
@@ -321,7 +327,9 @@ async def get_fqdn(
         httpx_client: Optional shared ``httpx.AsyncClient``; not closed by this function.
 
     Returns:
-        The registered FQDN, or empty string if none is configured
+        The registered FQDN string, or ``None`` when no FQDN is configured
+        (HTTP 404 or missing ``ebusTlsFqdn`` field). An empty string is only
+        returned when the panel reports an explicit empty FQDN value.
 
     Raises:
         SpanPanelAuthError: Token invalid or expired
@@ -344,13 +352,16 @@ async def get_fqdn(
         raise SpanPanelAuthError(f"Authentication failed (HTTP {response.status_code})")
 
     if response.status_code == 404:
-        return ""
+        return None
 
     if response.status_code != 200:
         raise SpanPanelAPIError(f"Failed to get FQDN: HTTP {response.status_code}")
 
     data: dict[str, object] = response.json()
-    return _str(data.get("ebusTlsFqdn"))
+    raw = data.get("ebusTlsFqdn")
+    if raw is None:
+        return None
+    return str(raw)
 
 
 async def delete_fqdn(

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/exceptions.py

@@ -28,9 +28,6 @@ class SpanPanelAPIError(SpanPanelError):
         super().__init__(message)
         self.status_code = status_code
 
-    def __str__(self) -> str:
-        return self.args[0] if self.args else ""
-
 
 class SpanPanelServerError(SpanPanelAPIError):
     """Server error (500)."""

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/models.py

@@ -1,8 +1,8 @@
 """Transport-agnostic snapshot models for SPAN Panel state.
 
-These dataclasses represent panel state regardless of how it was obtained
-(REST polling or MQTT push). Energy and power sign conventions are
-normalized at the transport boundary — consumers see a consistent view.
+These dataclasses represent panel state as produced by the MQTT/Homie
+transport. Energy and power sign conventions are normalized at the
+transport boundary — consumers see a consistent view.
 
 All snapshots are immutable (frozen) and memory-efficient (slots).
 """

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/mqtt/async_client.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 from types import TracebackType
 
 from paho.mqtt.client import Client as MQTTClient
+from paho.mqtt.enums import CallbackAPIVersion
 
 _PAHO_LOCK_ATTRS = (
     "_in_callback_mutex",
@@ -23,6 +24,29 @@ _PAHO_LOCK_ATTRS = (
 )
 
 
+def _verify_paho_lock_attrs() -> None:
+    """Verify paho-mqtt's lock layout matches the list we monkey-patch.
+
+    Runs once at import. Raises ``RuntimeError`` if any expected attribute
+    is missing (paho renamed/removed one) or if paho grew a new lock we
+    don't yet patch. Running ``python -O`` does not bypass this check.
+    """
+    probe = MQTTClient(callback_api_version=CallbackAPIVersion.VERSION2)
+    expected = set(_PAHO_LOCK_ATTRS)
+    found = {name for name in vars(probe) if name.endswith("_mutex")}
+    missing = expected - found
+    extra = found - expected
+    if missing or extra:
+        raise RuntimeError(
+            "paho-mqtt lock attributes changed — NullLock monkey-patch is out of date. "
+            f"missing={sorted(missing)}, extra={sorted(extra)}. "
+            "Update _PAHO_LOCK_ATTRS in span_panel_api.mqtt.async_client."
+        )
+
+
+_verify_paho_lock_attrs()
+
+
 class NullLock:
     """No-op lock for single-threaded event loop execution.
 

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/mqtt/client.py

@@ -11,6 +11,7 @@ import asyncio
 from collections.abc import Awaitable, Callable
 import contextlib
 import logging
+import time
 
 from ..auth import get_homie_schema
 from ..exceptions import SpanPanelConnectionError, SpanPanelServerError, SpanPanelStaleDataError
@@ -324,7 +325,7 @@ class SpanMqttClient:
         # Dispatch snapshot callbacks if streaming
         if self._streaming and homie.is_ready() and self._loop is not None:
             if self._snapshot_interval <= 0:
-                # No debounce — dispatch immediately (backward compat)
+                # Real-time mode — dispatch immediately, no debounce.
                 self._create_dispatch_task()
             elif self._snapshot_timer is None:
                 # Schedule debounced dispatch
@@ -366,7 +367,7 @@ class SpanMqttClient:
             try:
                 cb(connected)
             except Exception:  # pylint: disable=broad-exception-caught
-                _LOGGER.exception("Connection callback raised")
+                _LOGGER.warning("Connection callback raised", exc_info=True)
 
     async def _wait_for_circuit_names(self, timeout: float) -> None:
         """Wait for all circuit-like nodes to have a ``name`` property.
@@ -377,8 +378,8 @@ class SpanMqttClient:
         timeout elapses (non-fatal — entities will use fallback names).
         """
         homie = self._require_homie()
-        deadline = asyncio.get_event_loop().time() + timeout
-        while asyncio.get_event_loop().time() < deadline:
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
             missing = homie.circuit_nodes_missing_names()
             if not missing:
                 _LOGGER.debug("All circuit names received")
@@ -419,7 +420,10 @@ class SpanMqttClient:
         """Update the snapshot debounce interval at runtime.
 
         Args:
-            interval: Seconds between snapshot dispatches. 0 = no debounce.
+            interval: Seconds between snapshot dispatches. ``0`` (or any
+                non-positive value) disables debounce and dispatches a
+                snapshot for every incoming property message — real-time
+                mode, intended for fast consumers.
         """
         self._snapshot_interval = interval
         # Cancel any pending timer so the new interval takes effect on next message

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/mqtt/connection.py

@@ -13,9 +13,7 @@ import asyncio
 from collections.abc import Callable
 from functools import partial
 import logging
-from pathlib import Path
 import ssl
-import tempfile
 from typing import TYPE_CHECKING
 
 import paho.mqtt.client as paho
@@ -42,6 +40,20 @@ if TYPE_CHECKING:
 _LOGGER = logging.getLogger(__name__)
 
 
+def _build_ssl_context(ca_pem: str) -> ssl.SSLContext:
+    """Build an SSLContext that trusts only the provided panel CA.
+
+    The panel issues a private CA and a server cert signed by it. We do
+    not want to trust system CAs for this connection, so the context is
+    built fresh rather than via ``ssl.create_default_context()``.
+    """
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    ctx.verify_mode = ssl.CERT_REQUIRED
+    ctx.check_hostname = True
+    ctx.load_verify_locations(cadata=ca_pem)
+    return ctx
+
+
 class AsyncMqttBridge:
     """Event-loop-driven paho-mqtt wrapper with async callback dispatch.
 
@@ -77,7 +89,6 @@ class AsyncMqttBridge:
         self._connected = False
         self._client: AsyncMQTTClient | None = None
         self._connect_event: asyncio.Event | None = None
-        self._ca_cert_path: Path | None = None
 
         self._misc_timer: asyncio.TimerHandle | None = None
         self._should_reconnect = False
@@ -117,96 +128,83 @@ class AsyncMqttBridge:
 
         # Fetch CA cert from panel for TLS
         _LOGGER.debug("BRIDGE: Fetching CA cert from %s (use_tls=%s)", self._panel_host, self._use_tls)
-        ca_pem: str | None = None
-        ca_cert_path: Path | None = None
+        ssl_context: ssl.SSLContext | None = None
         if self._use_tls:
             try:
                 ca_pem = await download_ca_cert(self._panel_host, port=self._panel_http_port)
             except (OSError, SpanPanelConnectionError, SpanPanelTimeoutError) as exc:
                 raise SpanPanelConnectionError(f"Failed to fetch CA certificate from {self._panel_host}") from exc
-
-        try:
-            self._client = AsyncMQTTClient(
-                callback_api_version=CallbackAPIVersion.VERSION2,
-                transport=self._transport,
-                reconnect_on_failure=False,
+            # Build the SSLContext from PEM data in memory — no temp file.
+            # A malformed PEM raises ssl.SSLError or ValueError; wrap both
+            # so callers only see the documented SpanPanelConnectionError.
+            try:
+                ssl_context = _build_ssl_context(ca_pem)
+            except (ssl.SSLError, ValueError) as exc:
+                raise SpanPanelConnectionError(f"Failed to build SSL context for {self._panel_host}") from exc
+
+        self._client = AsyncMQTTClient(
+            callback_api_version=CallbackAPIVersion.VERSION2,
+            transport=self._transport,
+            reconnect_on_failure=False,
+        )
+        self._client.setup()
+
+        self._client.username_pw_set(self._username, self._password)
+
+        # Wire socket callbacks (async versions by default)
+        self._client.on_socket_close = self._async_on_socket_close
+        self._client.on_socket_unregister_write = self._async_on_socket_unregister_write
+
+        # Wire MQTT callbacks (run directly on event loop — no thread dispatch)
+        self._client.on_connect = self._on_connect
+        self._client.on_disconnect = self._on_disconnect
+        self._client.on_message = self._on_message
+
+        if ssl_context is not None:
+            self._client.tls_set_context(ssl_context)
+
+        # Connect in executor (blocking: DNS, TCP, TLS handshake).
+        # During executor connect, socket callbacks bridge to the event
+        # loop via call_soon_threadsafe.
+        def _blocking_connect() -> None:
+            if self._client is None:
+                raise RuntimeError("MQTT client not initialised before connect")
+            self._client.connect(
+                host=self._host,
+                port=self._port,
+                keepalive=MQTT_KEEPALIVE_S,
             )
-            self._client.setup()
-
-            self._client.username_pw_set(self._username, self._password)
-
-            # Wire socket callbacks (async versions by default)
-            self._client.on_socket_close = self._async_on_socket_close
-            self._client.on_socket_unregister_write = self._async_on_socket_unregister_write
-
-            # Wire MQTT callbacks (run directly on event loop — no thread dispatch)
-            self._client.on_connect = self._on_connect
-            self._client.on_disconnect = self._on_disconnect
-            self._client.on_message = self._on_message
-
-            # TLS setup + connect in executor (blocking: temp file write,
-            # load_verify_locations, DNS, TCP, and TLS handshake).
-            # During executor connect, socket callbacks bridge to the event
-            # loop via call_soon_threadsafe.
-            def _blocking_tls_and_connect() -> None:
-                """Write CA cert to temp file, configure TLS, and connect."""
-                nonlocal ca_cert_path
-                if self._client is None:
-                    raise RuntimeError("MQTT client not initialised before connect")
-                if self._use_tls and ca_pem is not None:
-                    tmp = tempfile.NamedTemporaryFile(  # pylint: disable=consider-using-with  # noqa: SIM115
-                        mode="w", suffix=".pem", delete=False
-                    )
-                    tmp.write(ca_pem)
-                    tmp.close()
-                    ca_cert_path = Path(tmp.name)
-                    self._client.tls_set(
-                        ca_certs=str(ca_cert_path),
-                        cert_reqs=ssl.CERT_REQUIRED,
-                        tls_version=ssl.PROTOCOL_TLS_CLIENT,
-                    )
-                self._client.connect(
-                    host=self._host,
-                    port=self._port,
-                    keepalive=MQTT_KEEPALIVE_S,
-                )
 
+        try:
+            self._client.on_socket_open = self._on_socket_open_sync
+            self._client.on_socket_register_write = self._on_socket_register_write_sync
+            _LOGGER.debug("BRIDGE: Running connect in executor to %s:%s", self._host, self._port)
             try:
-                self._client.on_socket_open = self._on_socket_open_sync
-                self._client.on_socket_register_write = self._on_socket_register_write_sync
-                _LOGGER.debug("BRIDGE: Running TLS+connect in executor to %s:%s", self._host, self._port)
-                try:
-                    await self._loop.run_in_executor(None, _blocking_tls_and_connect)
-                except OSError as exc:
-                    raise SpanPanelConnectionError(
-                        f"Cannot connect to MQTT broker at {self._host}:{self._port}: {exc}"
-                    ) from exc
-                _LOGGER.debug("BRIDGE: Executor connect returned, waiting for CONNACK...")
-            finally:
-                # Switch to async-only socket callbacks now that we are
-                # back on the event loop thread.
-                self._client.on_socket_open = self._async_on_socket_open
-                self._client.on_socket_register_write = self._async_on_socket_register_write
-
-            # Wait for CONNACK
-            try:
-                await asyncio.wait_for(self._connect_event.wait(), timeout=MQTT_CONNECT_TIMEOUT_S)
-            except asyncio.TimeoutError as exc:
-                await self.disconnect()
-                raise SpanPanelTimeoutError(f"Timed out connecting to MQTT broker at {self._host}:{self._port}") from exc
-
-            if not self._connected:
-                raise SpanPanelConnectionError(f"MQTT connection failed to {self._host}:{self._port}")
+                await self._loop.run_in_executor(None, _blocking_connect)
+            except Exception as exc:  # pylint: disable=broad-exception-caught
+                # paho raises OSError for TCP failures and transport-specific
+                # errors (e.g. WebsocketConnectionError) that do not inherit
+                # from OSError. Wrap all of them uniformly so callers only
+                # see the documented SpanPanelConnectionError.
+                raise SpanPanelConnectionError(f"Cannot connect to MQTT broker at {self._host}:{self._port}: {exc}") from exc
+            _LOGGER.debug("BRIDGE: Executor connect returned, waiting for CONNACK...")
+        finally:
+            # Switch to async-only socket callbacks now that we are
+            # back on the event loop thread.
+            self._client.on_socket_open = self._async_on_socket_open
+            self._client.on_socket_register_write = self._async_on_socket_register_write
+
+        # Wait for CONNACK
+        try:
+            await asyncio.wait_for(self._connect_event.wait(), timeout=MQTT_CONNECT_TIMEOUT_S)
+        except asyncio.TimeoutError as exc:
+            await self.disconnect()
+            raise SpanPanelTimeoutError(f"Timed out connecting to MQTT broker at {self._host}:{self._port}") from exc
 
-            self._initial_connect_done = True
-            # Keep cert alive until disconnect — paho may reference it
-            self._ca_cert_path = ca_cert_path
+        if not self._connected:
+            raise SpanPanelConnectionError(f"MQTT connection failed to {self._host}:{self._port}")
 
-        except Exception:
-            # Clean up temp CA cert file on failure only
-            if ca_cert_path is not None:
-                self._remove_cert_file(ca_cert_path)
-            raise
+        self._initial_connect_done = True
 
     async def disconnect(self) -> None:
         """Disconnect from the MQTT broker."""
@@ -229,25 +227,11 @@ class AsyncMqttBridge:
         self._client = None
         self._initial_connect_done = False
 
-        cert_path = self._ca_cert_path
-        self._ca_cert_path = None
-        if cert_path is not None:
-            loop = asyncio.get_running_loop()
-            await loop.run_in_executor(None, partial(self._remove_cert_file, cert_path))
-
     def subscribe(self, topic: str, qos: int = 0) -> None:
         """Subscribe to a topic. Must be called after connect()."""
         if self._client is not None:
             self._client.subscribe(topic, qos=qos)
 
-    @staticmethod
-    def _remove_cert_file(path: Path) -> None:
-        """Remove a temporary CA certificate file (safe to call from any thread)."""
-        try:
-            path.unlink()
-        except OSError:
-            _LOGGER.debug("Failed to remove temp CA cert file: %s", path)
-
     def publish(self, topic: str, payload: str, qos: int = 1) -> None:
         """Publish a message. Must be called after connect()."""
         if self._client is not None:
@@ -379,7 +363,10 @@ class AsyncMqttBridge:
     ) -> None:
         """Handle disconnect from broker."""
         self._connected = False
-        _LOGGER.debug("MQTT disconnected: %s", reason_code)
+        if reason_code.is_failure:
+            _LOGGER.warning("MQTT disconnected abnormally: %s", reason_code)
+        else:
+            _LOGGER.debug("MQTT disconnected: %s", reason_code)
 
         # Signal connect event if still waiting (socket closed before CONNACK)
         if self._connect_event is not None and not self._connect_event.is_set():
@@ -420,8 +407,18 @@ class AsyncMqttBridge:
                     self._client.on_socket_open = self._on_socket_open_sync
                     self._client.on_socket_register_write = self._on_socket_register_write_sync
                     await self._loop.run_in_executor(None, self._client.reconnect)
-                except OSError:
-                    _LOGGER.debug("Reconnect failed, retrying in %ss", delay)
+                except (OSError, TimeoutError) as exc:
+                    # Expected transient failures — panel offline, DNS miss, socket
+                    # timeout, refused connection. The exception type and errno are
+                    # the full diagnostic; paho/stdlib stack frames add no signal.
+                    # ssl.SSLError is an OSError subclass and falls in here too;
+                    # SSL misconfiguration would have failed at setup, so a
+                    # reconnect-time SSL error is handled as a transient failure.
+                    _LOGGER.warning("Reconnect failed (%s), retrying in %ss", exc, delay)
+                except Exception:  # pylint: disable=broad-exception-caught
+                    # Unknown territory — keep the traceback so support tickets
+                    # are actionable. Never let the reconnect loop die.
+                    _LOGGER.warning("Reconnect failed, retrying in %ss", delay, exc_info=True)
                 finally:
                     if self._client is not None:
                         self._client.on_socket_open = self._async_on_socket_open

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/mqtt/homie.py

@@ -31,6 +31,11 @@ from .const import (
 
 _LOGGER = logging.getLogger(__name__)
 
+# Threshold below which grid power is considered "not exchanging" when no
+# authoritative bess/grid-state is available. Real lugs readings never land
+# exactly on 0.0; 1 W is well below sensor noise.
+_GRID_POWER_EPSILON_W = 1.0
+
 
 def _parse_bool(value: str) -> bool:
     """Parse a Homie boolean string."""
@@ -230,9 +235,10 @@ class HomieDeviceConsumer:
         """Build a circuit snapshot from accumulated properties."""
         circuit_id = normalize_circuit_id(node_id)
 
-        # active-power is in watts; negate so positive = consumption
+        # active-power is in watts; negate so positive = consumption.
+        # Guard against -0.0 creeping in when raw_power_w is 0.0.
         raw_power_w = _parse_float(self._acc.get_prop(node_id, "active-power"))
-        instant_power_w = -raw_power_w or 0.0
+        instant_power_w = 0.0 if raw_power_w == 0.0 else -raw_power_w
 
         # Energy: exported-energy = consumption (panel exports TO circuit)
         consumed_wh = _parse_float(self._acc.get_prop(node_id, "exported-energy"))
@@ -387,7 +393,9 @@ class HomieDeviceConsumer:
                 return "DSM_ON_GRID"
 
             if dps in ("BATTERY", "PV", "GENERATOR"):
-                grid_exchanging = grid_power != 0.0 or (power_flow_grid is not None and power_flow_grid != 0.0)
+                grid_exchanging = abs(grid_power) > _GRID_POWER_EPSILON_W or (
+                    power_flow_grid is not None and abs(power_flow_grid) > _GRID_POWER_EPSILON_W
+                )
                 return "DSM_ON_GRID" if grid_exchanging else "DSM_OFF_GRID"
 
         return "UNKNOWN"

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/src/span_panel_api/protocol.py

@@ -1,8 +1,8 @@
 """Protocol interfaces for SPAN Panel API transports.
 
-Defines structural subtyping contracts (PEP 544) that both MQTT and
-simulation transports implement. The integration codes against these
-protocols — never against transport-specific classes.
+Defines structural subtyping contracts (PEP 544) that the MQTT transport
+implements. The integration codes against these protocols — never against
+transport-specific classes.
 """
 
 from __future__ import annotations

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/tests/conftest.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 import json
-import tempfile
 from collections.abc import AsyncGenerator
 from unittest.mock import MagicMock, patch
 
@@ -109,14 +108,9 @@ async def mqtt_client_mock() -> AsyncGenerator[MagicMock, None]:
     with (
         patch("span_panel_api.mqtt.connection.AsyncMQTTClient") as cls,
         patch("span_panel_api.mqtt.connection.download_ca_cert", return_value="FAKE-PEM"),
-        patch("span_panel_api.mqtt.connection.tempfile") as mock_tempfile,
+        patch("span_panel_api.mqtt.connection._build_ssl_context", return_value=MagicMock()),
         patch("span_panel_api.mqtt.client.get_homie_schema", return_value=_MOCK_SCHEMA),
     ):
-        # Make tempfile return a mock file object
-        mock_tmp = MagicMock()
-        mock_tmp.name = f"{tempfile.gettempdir()}/fake_ca.pem"
-        mock_tempfile.NamedTemporaryFile.return_value = mock_tmp
-
         mock_client = cls.return_value
         mock_client.connect.side_effect = _connect
         mock_client.reconnect.side_effect = _reconnect

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/tests/test_detection_auth.py

@@ -668,7 +668,7 @@ class TestGetFqdn:
         assert result == "panel.example.com"
 
     @pytest.mark.asyncio
-    async def test_get_fqdn_not_configured_returns_empty(self):
+    async def test_get_fqdn_not_configured_returns_none(self):
         mock_response = _mock_response(404)
         with patch("span_panel_api._http.httpx.AsyncClient") as mock_client_cls:
             mock_client = AsyncMock()
@@ -679,6 +679,34 @@ class TestGetFqdn:
 
             result = await get_fqdn("192.168.65.70", "jwt-token")
 
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_get_fqdn_missing_field_returns_none(self):
+        mock_response = _mock_response(200, {})
+        with patch("span_panel_api._http.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.return_value = mock_response
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            result = await get_fqdn("192.168.65.70", "jwt-token")
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_get_fqdn_empty_string_preserved(self):
+        mock_response = _mock_response(200, {"ebusTlsFqdn": ""})
+        with patch("span_panel_api._http.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.return_value = mock_response
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            result = await get_fqdn("192.168.65.70", "jwt-token")
+
         assert result == ""
 
     @pytest.mark.asyncio

{span_panel_api-2.6.0 → span_panel_api-2.6.2}/tests/test_mqtt_client_connection.py

@@ -176,7 +176,7 @@ class TestConnectionEventDispatch:
         client.register_connection_callback(bad)
         client.register_connection_callback(good_calls.append)
 
-        with caplog.at_level(logging.ERROR):
+        with caplog.at_level(logging.WARNING):
             client._on_connection_change(True)
 
         assert good_calls == [True]