nwp500-python 8.0.0__tar.gz → 8.1.1__tar.gz

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/CHANGELOG.rst

@@ -2,8 +2,73 @@
 Changelog
 =========
 
-Unreleased (8.x)
-================
+Unreleased
+==========
+
+Version 8.1.1 (2026-05-18)
+==========================
+
+Version 8.1.0 (2026-05-16)
+==========================
+
+Bug Fixes
+---------
+- **Fix MQTT connection flapping after reconnect**: When ``_active_reconnect()``
+  created a new ``MqttConnection``, the old connection was never closed. The old
+  SDK connection's built-in auto-reconnect would eventually succeed, creating two
+  active connections sharing the same client ID. Because AWS IoT allows only one
+  connection per client ID, the broker would kick one off, triggering
+  ``on_connection_interrupted`` and starting yet another reconnection — an
+  infinite connect/disconnect loop. Fixed by adding ``MqttConnection.close()``
+  (unconditional teardown regardless of ``_connected`` state) and calling it
+  before creating the replacement connection in both ``_active_reconnect()`` and
+  ``_deep_reconnect()``.
+
+- **Thread-safety race in ``ensure_device_info_cached``**: The ``future.done()``
+  check and ``future.set_result()`` were performed in the AWS SDK callback thread
+  without synchronisation, creating a race against the asyncio event loop thread.
+  Moved both operations inside a ``call_soon_threadsafe`` callback so they execute
+  atomically on the event loop thread.
+
+- **ZeroDivisionError when ``deep_reconnect_threshold`` is 0**: Config validation
+  now clamps ``deep_reconnect_threshold`` to a minimum of 1, preventing a
+  ``ZeroDivisionError`` in the exponential-backoff reconnection logic.
+
+- **Reconnect counter never incremented**: ``total_reconnect_attempts`` in
+  diagnostics was not incremented on connection drops, so it always reported 0
+  despite active reconnections. Counter is now incremented on each
+  ``on_connection_interrupted`` event.
+
+- **``shortest_session_seconds`` not JSON-serialisable**: The diagnostics
+  ``to_dict()`` method used ``float('inf')`` as the initial value for
+  ``shortest_session_seconds``, which is not valid JSON. Changed to ``None``
+  so serialisation succeeds when no session has completed yet.
+
+- **``wait_for()`` future not bound to running loop**: ``wait_for()`` created a
+  bare ``asyncio.Future()`` rather than
+  ``asyncio.get_running_loop().create_future()``, which could bind the future to
+  a different loop in multi-loop test setups.
+
+- **Reservation temperature validation was US-only**: ``build_reservation_entry``
+  validated set-point temperatures against hardcoded Fahrenheit bounds (95–150 °F)
+  regardless of the active unit system. Validation now uses the current unit system
+  context: 35–65 °C in metric mode, 95–150 °F in US mode. Celsius users previously
+  received spurious ``ValueError`` rejections for valid temperatures.
+
+- **Malformed reservation data silently dropped**: ``build_reservation_entry`` now
+  logs a warning when reservation hex data contains unexpected trailing bytes
+  instead of silently dropping partial entries.
+
+- **Unknown ``PeriodicRequestType`` silently ignored**: The periodic-request handler
+  now logs an error and breaks when it encounters an unknown request type instead of
+  doing nothing.
+
+- **Memory leak in device info cache**: ``get_all_cached()`` only filtered expired
+  entries from its return value but left them in the cache dictionary. Expired
+  entries are now evicted during ``get_all_cached()`` to prevent unbounded growth.
+
+Version 8.0.0 (2026-05-13)
+===========================
 
 Bug Fixes
 ---------

{nwp500_python-8.0.0/src/nwp500_python.egg-info → nwp500_python-8.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nwp500-python
-Version: 8.0.0
+Version: 8.1.1
 Summary: A library for controlling Navien NWP500 Water Heaters via NaviLink
 Home-page: https://github.com/eman/nwp500-python
 Author: Emmanuel Levijarvi

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/scripts/bump_version.py

@@ -22,6 +22,8 @@ field is for the PyScaffold tool version, not the package version!
 import re
 import subprocess
 import sys
+from datetime import date
+from pathlib import Path
 
 
 def run_git_command(args: list) -> str:
@@ -140,6 +142,75 @@ def check_working_directory_clean() -> None:
         sys.exit(1)
 
 
+def update_changelog(version: str) -> None:
+    """Insert a version heading into CHANGELOG.rst below the Unreleased section.
+
+    Transforms:
+
+        Unreleased
+        ==========
+
+        <content...>
+
+    into:
+
+        Unreleased
+        ==========
+
+        Version X.Y.Z (YYYY-MM-DD)
+        ===========================
+
+        <content...>
+    """
+    changelog_path = Path("CHANGELOG.rst")
+    if not changelog_path.exists():
+        print("Warning: CHANGELOG.rst not found, skipping changelog update.")
+        return
+
+    content = changelog_path.read_text(encoding="utf-8")
+
+    heading = f"Version {version} ({date.today().isoformat()})"
+    underline = "=" * len(heading)
+    version_block = f"{heading}\n{underline}\n"
+
+    # Match "Unreleased\n==========\n" (any number of = signs) followed by
+    # one or more blank lines, then insert the version block after them.
+    pattern = re.compile(
+        r"(Unreleased\n=+\n)"  # group 1: Unreleased heading
+        r"(\n+)",              # group 2: blank line(s) separator
+        re.MULTILINE,
+    )
+
+    match = pattern.search(content)
+    if not match:
+        print(
+            "Warning: Could not find 'Unreleased' section in CHANGELOG.rst. "
+            "Skipping changelog update.",
+            file=sys.stderr,
+        )
+        return
+
+    # Insert the version block after the blank lines that follow "Unreleased"
+    new_content = (
+        content[: match.end()]
+        + version_block
+        + "\n"
+        + content[match.end() :]
+    )
+
+    changelog_path.write_text(new_content, encoding="utf-8")
+    print(f"[OK] Updated CHANGELOG.rst with {heading}")
+
+
+def commit_changelog(version: str) -> None:
+    """Stage and commit the CHANGELOG.rst update."""
+    run_git_command(["add", "CHANGELOG.rst"])
+    run_git_command(
+        ["commit", "-m", f"Update changelog for v{version}"]
+    )
+    print("[OK] Committed changelog update")
+
+
 def create_tag(version: str, message: str = None) -> None:
     """Create a git tag for the version."""
     tag_name = f"v{version}"
@@ -223,6 +294,11 @@ def main() -> None:
     # Validate version progression
     validate_version_progression(current_version, new_version)
 
+    # Update CHANGELOG.rst and commit, then create the tag
+    print("\nUpdating CHANGELOG.rst...")
+    update_changelog(new_version)
+    commit_changelog(new_version)
+
     # Create the tag
     print(f"\nCreating tag v{new_version}...")
     create_tag(new_version)
@@ -230,6 +306,7 @@ def main() -> None:
     print("\n[OK] Version bump complete!")
     print("\nNext steps:")
     print(f"  1. Push the tag:    git push origin v{new_version}")
+    print("     (also push the changelog commit: git push origin HEAD)")
     print("  2. Build release:   make build")
     print("  3. Test on TestPyPI: make publish-test")
     print("  4. Publish to PyPI:  make publish")

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/device_info_cache.py

@@ -137,12 +137,15 @@ class MqttDeviceInfoCache:
             Dictionary mapping MAC addresses to DeviceFeature objects
         """
         async with self._lock:
-            # Filter out expired entries
-            return {
-                mac: features
-                for mac, (features, timestamp) in self._cache.items()
-                if not self.is_expired(timestamp)
-            }
+            # Filter out expired entries and purge them from cache
+            expired_keys = [
+                mac
+                for mac, (_, timestamp) in self._cache.items()
+                if self.is_expired(timestamp)
+            ]
+            for mac in expired_keys:
+                del self._cache[mac]
+            return {mac: features for mac, (features, _) in self._cache.items()}
 
     async def get_cache_info(
         self,

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/encoding.py

@@ -8,11 +8,14 @@ These utilities are used by both the API client and MQTT client.
 
 from __future__ import annotations
 
+import logging
 from collections.abc import Iterable
 from numbers import Real
 
 from .exceptions import ParameterValidationError, RangeValidationError
 
+_logger = logging.getLogger(__name__)
+
 # MGPP Week Bitfield Encoding (from NaviLink APK KDEnum.MgppReservationWeek).
 # Uses a single byte where bits 1-7 represent days; bit 0 is unused.
 #
@@ -342,14 +345,18 @@ def decode_reservation_hex(hex_string: str) -> list[dict[str, int]]:
     data = bytes.fromhex(hex_string)
     reservations = []
 
+    if len(data) % 6 != 0:
+        _logger.warning(
+            "Reservation hex data length %d is not a multiple of 6; "
+            "trailing %d bytes will be ignored",
+            len(data),
+            len(data) % 6,
+        )
+
     # Process 6 bytes at a time
-    for i in range(0, len(data), 6):
+    for i in range(0, len(data) - (len(data) % 6), 6):
         chunk = data[i : i + 6]
 
-        # Ensure we have a full 6-byte entry
-        if len(chunk) != 6:
-            break
-
         # Skip empty entries (all zeros)
         if all(b == 0 for b in chunk):
             continue
@@ -425,11 +432,26 @@ def build_reservation_entry(
     """
     # Import here to avoid circular import
     from .models import preferred_to_half_celsius
+    from .unit_system import get_unit_system
+
+    # Read unit system once to keep min/max bounds consistent
+    unit_system = get_unit_system()
 
     # Use device-provided limits if available, otherwise use defaults
-    # Defaults are conservative: 95°F / 35°C minimum, 150°F / 65°C maximum
-    min_temp = temperature_min if temperature_min is not None else 95
-    max_temp = temperature_max if temperature_max is not None else 150
+    # in the user's preferred unit system.
+    if temperature_min is not None:
+        min_temp = temperature_min
+    elif unit_system == "metric":
+        min_temp = 35.0  # ~35°C
+    else:
+        min_temp = 95.0  # 95°F
+
+    if temperature_max is not None:
+        max_temp = temperature_max
+    elif unit_system == "metric":
+        max_temp = 65.0  # ~65°C
+    else:
+        max_temp = 150.0  # 150°F
 
     if not 0 <= hour <= 23:
         raise RangeValidationError(

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/events.py

@@ -396,7 +396,7 @@ class EventEmitter:
             current_temp = temperature_event.new_temperature
         """
         future: asyncio.Future[tuple[tuple[Any, ...], dict[str, Any]]] = (
-            asyncio.Future()
+            asyncio.get_running_loop().create_future()
         )
 
         def handler(*args: Any, **kwargs: Any) -> None:

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/mqtt/client.py

@@ -226,6 +226,11 @@ class NavienMqttClient(EventEmitter):
         # Connection state (simpler than checking _connection_manager)
         self._connection: mqtt.Connection | None = None
         self._connected = False
+        # Guards _active_reconnect / _deep_reconnect against re-entrancy.
+        # While True, _on_connection_interrupted_internal will not forward
+        # events to the reconnection handler, preventing the intentional
+        # teardown of the old connection from spawning a competing backoff loop.
+        self._actively_reconnecting = False
 
         _logger.info(
             f"Initialized MQTT client with ID: {self.config.client_id}"
@@ -276,8 +281,17 @@ class NavienMqttClient(EventEmitter):
             )
         )
 
-        # Delegate to reconnection handler if available
-        if self._reconnection_handler and self.config.auto_reconnect:
+        # Delegate to reconnection handler if available.
+        # Skip while _actively_reconnecting: the interruption was caused by
+        # _active_reconnect / _deep_reconnect intentionally closing the old
+        # connection.  Forwarding it would queue a _start_reconnect_task
+        # coroutine that could fire after the new connection is up and the
+        # existing backoff task has been cancelled, spawning a competing loop.
+        if (
+            self._reconnection_handler
+            and self.config.auto_reconnect
+            and not self._actively_reconnecting
+        ):
             self._reconnection_handler.on_connection_interrupted(error)
 
         # Record diagnostic event
@@ -371,26 +385,40 @@ class NavienMqttClient(EventEmitter):
         reconnect instead of passively waiting for AWS IoT SDK.
 
         Note: This creates a new connection while preserving subscriptions
-        and configuration.
+        and configuration. The old connection is closed first to prevent
+        its SDK auto-reconnect from creating a competing connection with
+        the same client ID (which causes the broker to kick one off,
+        leading to an infinite connect/disconnect loop).
         """
         if self._connected:
             _logger.debug("Already connected, skipping reconnection")
             return
 
+        if self._actively_reconnecting:
+            _logger.debug("Active reconnection already in progress, skipping")
+            return
+
         _logger.info("Attempting active reconnection...")
 
+        self._actively_reconnecting = True
         try:
             # Ensure tokens are still valid
             await self._auth_client.ensure_valid_token()
 
             # If we have a connection manager, try to reconnect using it
             if self._connection_manager:
-                # The connection might be in a bad state, so we need to
-                # recreate the underlying connection
+                # Close old connection to stop SDK auto-reconnect and
+                # prevent two connections with the same client ID.
+                # _actively_reconnecting suppresses the
+                # on_connection_interrupted callback that closing triggers,
+                # preventing a competing backoff loop from being spawned.
                 _logger.debug("Recreating MQTT connection...")
+                try:
+                    await self._connection_manager.close()
+                except (AwsCrtError, RuntimeError) as e:
+                    _logger.debug(f"Old connection cleanup (benign): {e}")
 
                 # Create a new connection manager with same config
-                old_connection_manager = self._connection_manager
                 self._connection_manager = MqttConnection(
                     config=self.config,
                     auth_client=self._auth_client,
@@ -415,9 +443,6 @@ class NavienMqttClient(EventEmitter):
 
                     _logger.info("Active reconnection successful")
                 else:
-                    # Restore old connection manager and connection reference
-                    self._connection_manager = old_connection_manager
-                    self._connection = old_connection_manager.connection
                     _logger.warning("Active reconnection failed")
             else:
                 _logger.warning(
@@ -429,6 +454,8 @@ class NavienMqttClient(EventEmitter):
                 f"Error during active reconnection: {e}", exc_info=True
             )
             raise
+        finally:
+            self._actively_reconnecting = False
 
     async def _deep_reconnect(self) -> None:
         """
@@ -448,18 +475,25 @@ class NavienMqttClient(EventEmitter):
             _logger.debug("Already connected, skipping deep reconnection")
             return
 
+        if self._actively_reconnecting:
+            _logger.debug("Active reconnection already in progress, skipping")
+            return
+
         _logger.warning(
             "Performing deep reconnection (full rebuild)... "
             "This may take longer."
         )
 
+        self._actively_reconnecting = True
         try:
-            # Step 1: Clean up existing connection if any
+            # Step 1: Clean up existing connection if any.
+            # _actively_reconnecting suppresses the on_connection_interrupted
+            # callback that closing triggers, preventing a competing backoff
+            # loop from being spawned.
             if self._connection_manager:
                 _logger.debug("Cleaning up old connection...")
                 try:
-                    if self._connection_manager.is_connected:
-                        await self._connection_manager.disconnect()
+                    await self._connection_manager.close()
                 except (AwsCrtError, RuntimeError) as e:
                     # Expected: connection already dead or in bad state
                     _logger.debug(f"Error during cleanup: {e} (expected)")
@@ -532,6 +566,8 @@ class NavienMqttClient(EventEmitter):
         ) as e:
             _logger.error(f"Error during deep reconnection: {e}", exc_info=True)
             raise
+        finally:
+            self._actively_reconnecting = False
 
     async def connect(self) -> bool:
         """
@@ -1294,14 +1330,20 @@ class NavienMqttClient(EventEmitter):
             return True
 
         # Not cached, request and wait
-        future: asyncio.Future[DeviceFeature] = (
-            asyncio.get_running_loop().create_future()
-        )
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[DeviceFeature] = loop.create_future()
 
         def on_feature(feature: DeviceFeature) -> None:
-            if not future.done():
-                _logger.info(f"Device feature received for {redacted_mac}")
-                future.set_result(feature)
+            # Called from AWS SDK thread — schedule onto the event loop
+            # thread-safely. The done() check is inside the scheduled
+            # callback so it runs on the event loop thread, eliminating
+            # the race between the check and set_result.
+            def _set_result() -> None:
+                if not future.done():
+                    _logger.info(f"Device feature received for {redacted_mac}")
+                    future.set_result(feature)
+
+            loop.call_soon_threadsafe(_set_result)
 
         _logger.info(f"Ensuring device info cached for {redacted_mac}")
         await self.subscribe_device_feature(device, on_feature)

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/mqtt/connection.py

@@ -245,6 +245,44 @@ class MqttConnection:
             _logger.error(f"Error during disconnect: {e}")
             raise
 
+    async def close(self) -> None:
+        """Unconditionally close the underlying SDK connection.
+
+        Unlike :meth:`disconnect`, this method closes the connection
+        regardless of the ``_connected`` flag.  After a connection
+        interruption, ``_connected`` is ``False`` but the SDK connection
+        object is still alive and its built-in auto-reconnect can still
+        fire.  Calling ``close()`` ensures the SDK connection is fully
+        torn down so its callbacks and auto-reconnect cannot interfere
+        with a replacement connection.
+
+        This method is safe to call multiple times or on already-closed
+        connections.
+        """
+        connection = self._connection
+        self._connection = None
+        self._connected = False
+
+        if connection is None:
+            return
+
+        _logger.debug("Closing underlying SDK connection...")
+        try:
+            disconnect_future = cast(
+                asyncio.Future[Any], connection.disconnect()
+            )
+            await asyncio.shield(asyncio.wrap_future(disconnect_future))
+            _logger.debug("SDK connection closed")
+        except (AwsCrtError, RuntimeError) as e:
+            # Expected when connection is already dead or in bad state
+            _logger.debug(f"SDK connection close (benign): {e}")
+        except asyncio.CancelledError:
+            _logger.debug(
+                "Close operation cancelled but SDK disconnect "
+                "will complete in background"
+            )
+            raise
+
     async def subscribe(
         self,
         topic: str,

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/mqtt/diagnostics.py

@@ -95,7 +95,11 @@ class MqttMetrics:
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
-        return asdict(self)
+        d = asdict(self)
+        # Replace inf with None for JSON compatibility
+        if d.get("shortest_session_seconds") == float("inf"):
+            d["shortest_session_seconds"] = None
+        return d
 
 
 class MqttDiagnosticsCollector:
@@ -213,6 +217,7 @@ class MqttDiagnosticsCollector:
 
         # Update metrics
         self._metrics.total_connection_drops += 1
+        self._metrics.total_reconnect_attempts += 1
         if error_name:
             self._metrics.connection_drops_by_error[error_name] = (
                 self._metrics.connection_drops_by_error.get(error_name, 0) + 1

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/mqtt/periodic.py

@@ -173,6 +173,12 @@ class MqttPeriodicRequestManager:
                             await self._request_device_info(device)
                         elif request_type == PeriodicRequestType.DEVICE_STATUS:
                             await self._request_device_status(device)
+                        else:
+                            _logger.error(
+                                "Unknown periodic request type: %s",
+                                request_type,
+                            )
+                            break
 
                         _logger.debug(
                             "Sent periodic %s request for %s",

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/mqtt/reconnection.py

@@ -94,11 +94,18 @@ class MqttReconnectionHandler:
         """
         _logger.warning(f"Connection interrupted: {error}")
 
-        # Start automatic reconnection if enabled
+        # Start automatic reconnection if enabled.
+        # Also guard against stale interruption events that arrive after the
+        # connection has already been restored: these can be queued via
+        # run_coroutine_threadsafe and fire after on_connection_resumed has
+        # cancelled _reconnect_task (setting it to None), which would
+        # otherwise bypass the task-existence check and spawn a new backoff
+        # loop while the client is perfectly healthy.
         if (
             self.config.auto_reconnect
             and self._enabled
             and not self._manual_disconnect
+            and not self._is_connected_func()
             and (not self._reconnect_task or self._reconnect_task.done())
         ):
             _logger.info("Starting automatic reconnection...")
@@ -132,8 +139,16 @@ class MqttReconnectionHandler:
 
         This is a helper method to create the reconnect task from within
         a coroutine that's scheduled via _schedule_coroutine.
+
+        The is_connected guard is re-checked here because this coroutine may
+        be queued via run_coroutine_threadsafe and run after the connection
+        has already been restored (e.g. by on_connection_resumed cancelling
+        _reconnect_task), in which case starting a new backoff loop would
+        incorrectly tear down a healthy connection.
         """
-        if not self._reconnect_task or self._reconnect_task.done():
+        if not self._is_connected_func() and (
+            not self._reconnect_task or self._reconnect_task.done()
+        ):
             self._reconnect_task = asyncio.create_task(
                 self._reconnect_with_backoff()
             )

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500/mqtt/utils.py

@@ -233,11 +233,13 @@ class MqttConnectionConfig:
     max_queued_commands: int = 100
 
     def __post_init__(self) -> None:
-        """Generate client ID if not provided."""
+        """Generate client ID if not provided and validate settings."""
         if not self.client_id:
             object.__setattr__(
                 self, "client_id", f"navien-client-{uuid.uuid4().hex[:8]}"
             )
+        if self.deep_reconnect_threshold < 1:
+            object.__setattr__(self, "deep_reconnect_threshold", 1)
 
 
 @dataclass

{nwp500_python-8.0.0 → nwp500_python-8.1.1/src/nwp500_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nwp500-python
-Version: 8.0.0
+Version: 8.1.1
 Summary: A library for controlling Navien NWP500 Water Heaters via NaviLink
 Home-page: https://github.com/eman/nwp500-python
 Author: Emmanuel Levijarvi

{nwp500_python-8.0.0 → nwp500_python-8.1.1}/src/nwp500_python.egg-info/SOURCES.txt

@@ -175,6 +175,7 @@ src/nwp500_python.egg-info/top_level.txt
 tests/conftest.py
 tests/test_api_helpers.py
 tests/test_auth.py
+tests/test_bug_fixes.py
 tests/test_cli_basic.py
 tests/test_cli_commands.py
 tests/test_command_decorators.py
@@ -187,6 +188,8 @@ tests/test_model_converters.py
 tests/test_models.py
 tests/test_mqtt_client_init.py
 tests/test_mqtt_hypothesis.py
+tests/test_mqtt_reconnection.py
+tests/test_mqtt_reconnection_storm.py
 tests/test_multi_device.py
 tests/test_openei.py
 tests/test_reservations.py