nwp500-python 3.1.1__tar.gz → 3.1.3__tar.gz

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/.github/copilot-instructions.md

@@ -26,6 +26,8 @@ Always run these checks before finalizing changes to ensure your code will pass
 
 This prevents "passes locally but fails in CI" issues.
 
+**Important**: When updating CHANGELOG.rst or any file with dates, always use `date +"%Y-%m-%d"` to get the correct current date. Never hardcode or guess dates.
+
 ### After Completing a Task
 Always run these checks after completing a task to validate your changes:
 1. **Type checking**: `python3 -m mypy src/nwp500 --config-file pyproject.toml` - Verify no type errors were introduced

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/CHANGELOG.rst

@@ -2,6 +2,42 @@
 Changelog
 =========
 
+Version 3.1.3 (2025-10-24)
+==========================
+
+Fixed
+-----
+
+- **MQTT Reconnection**: Improved MQTT reconnection reliability with active reconnection
+  
+  - **Breaking Internal Change**: ``MqttReconnectionHandler`` now requires ``reconnect_func`` parameter (not Optional)
+  - Implemented active reconnection that always recreates MQTT connection on interruption
+  - Removed unreliable passive fallback to AWS IoT SDK automatic reconnection
+  - Added automatic connection state checking during reconnection attempts
+  - Now emits ``reconnection_failed`` event when max reconnection attempts are exhausted
+  - Improved error handling and logging during reconnection process
+  - Better recovery from WebSocket connection interruptions (AWS_ERROR_MQTT_UNEXPECTED_HANGUP)
+  - Resolves issues where connection would fail to recover after network interruptions
+  - Note: Public API unchanged - ``NavienMqttClient`` continues to work as before
+  - Compatible with existing auto-recovery examples (``auto_recovery_example.py``, ``simple_auto_recovery.py``)
+
+Version 3.1.2 (2025-01-23)
+==========================
+
+Fixed
+-----
+
+- **Authentication**: Fixed 401 authentication errors with automatic token refresh
+  
+  - Add automatic token refresh on 401 Unauthorized responses in API client
+  - Preserve AWS credentials when refreshing tokens (required for MQTT)
+  - Save refreshed tokens to cache after successful API calls
+  - Add retry logic to prevent infinite retry loops
+  - Validate refresh_token exists before attempting refresh
+  - Use specific exception types (TokenRefreshError, AuthenticationError) in error handling
+  - Prevents masking unexpected errors during token refresh
+  - Resolves 'API request failed: 401' error when using cached tokens
+
 Version 3.1.1 (2025-01-22)
 ==========================
 

{nwp500_python-3.1.1/src/nwp500_python.egg-info → nwp500_python-3.1.3}/PKG-INFO

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

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/src/nwp500/api_client.py

@@ -9,7 +9,11 @@ from typing import Any, Optional
 
 import aiohttp
 
-from .auth import AuthenticationError, NavienAuthClient
+from .auth import (
+    AuthenticationError,
+    NavienAuthClient,
+    TokenRefreshError,
+)
 from .config import API_BASE_URL
 from .models import Device, FirmwareInfo, TOUInfo
 
@@ -114,6 +118,7 @@ class NavienAPIClient:
         endpoint: str,
         json_data: Optional[dict[str, Any]] = None,
         params: Optional[dict[str, Any]] = None,
+        retry_on_auth_failure: bool = True,
     ) -> dict[str, Any]:
         """
         Make an authenticated API request.
@@ -123,6 +128,7 @@ class NavienAPIClient:
             endpoint: API endpoint path
             json_data: JSON body data
             params: Query parameters
+            retry_on_auth_failure: Whether to retry once on 401 errors
 
         Returns:
             Response data dictionary
@@ -158,6 +164,42 @@ class NavienAPIClient:
                 msg = response_data.get("msg", "")
 
                 if code != 200 or not response.ok:
+                    # If we get a 401 and haven't retried yet, try refreshing
+                    # token
+                    if code == 401 and retry_on_auth_failure:
+                        _logger.warning(
+                            "Received 401 Unauthorized. "
+                            "Attempting to refresh token..."
+                        )
+                        try:
+                            # Try to refresh the token
+                            tokens = self._auth_client.current_tokens
+                            if tokens and tokens.refresh_token:
+                                await self._auth_client.refresh_token(
+                                    tokens.refresh_token
+                                )
+                                # Retry the request once with new token
+                                return await self._make_request(
+                                    method,
+                                    endpoint,
+                                    json_data,
+                                    params,
+                                    retry_on_auth_failure=False,
+                                )
+                            else:
+                                _logger.error(
+                                    "Cannot refresh token: "
+                                    "refresh_token not available"
+                                )
+                        except (
+                            TokenRefreshError,
+                            AuthenticationError,
+                        ) as refresh_error:
+                            _logger.error(
+                                f"Token refresh failed: {refresh_error}"
+                            )
+                            # Fall through to raise original error
+
                     _logger.error(f"API error: {code} - {msg}")
                     raise APIError(
                         f"API request failed: {msg}",

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/src/nwp500/auth.py

@@ -400,6 +400,30 @@ class NavienAuthClient:
                 data = response_data.get("data", {})
                 new_tokens = AuthTokens.from_dict(data)
 
+                # Preserve AWS credentials from old tokens if not in refresh
+                # response
+                if self._auth_response and self._auth_response.tokens:
+                    old_tokens = self._auth_response.tokens
+                    if (
+                        not new_tokens.access_key_id
+                        and old_tokens.access_key_id
+                    ):
+                        new_tokens.access_key_id = old_tokens.access_key_id
+                    if not new_tokens.secret_key and old_tokens.secret_key:
+                        new_tokens.secret_key = old_tokens.secret_key
+                    if (
+                        not new_tokens.session_token
+                        and old_tokens.session_token
+                    ):
+                        new_tokens.session_token = old_tokens.session_token
+                    if (
+                        not new_tokens.authorization_expires_in
+                        and old_tokens.authorization_expires_in
+                    ):
+                        new_tokens.authorization_expires_in = (
+                            old_tokens.authorization_expires_in
+                        )
+
                 # Update stored auth response if we have one
                 if self._auth_response:
                     self._auth_response.tokens = new_tokens

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/src/nwp500/cli/__main__.py

@@ -130,6 +130,10 @@ async def async_main(args: argparse.Namespace) -> int:
         _logger.info("Fetching device information...")
         device = await api_client.get_first_device()
 
+        # Save tokens if they were refreshed during API call
+        if auth_client.current_tokens and auth_client.user_email:
+            save_tokens(auth_client.current_tokens, auth_client.user_email)
+
         if not device:
             _logger.error("No devices found for this account.")
             return 1

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/src/nwp500/mqtt_client.py

@@ -279,6 +279,72 @@ class NavienMqttClient(EventEmitter):
             self._connection_manager.publish, lambda: self._connected
         )
 
+    async def _active_reconnect(self) -> None:
+        """
+        Actively trigger a reconnection attempt.
+
+        This method is called by the reconnection handler to actively
+        reconnect instead of passively waiting for AWS IoT SDK.
+
+        Note: This creates a new connection while preserving subscriptions
+        and configuration.
+        """
+        if self._connected:
+            _logger.debug("Already connected, skipping reconnection")
+            return
+
+        _logger.info("Attempting active reconnection...")
+
+        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
+                _logger.debug("Recreating MQTT connection...")
+
+                # 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,
+                    on_connection_interrupted=self._on_connection_interrupted_internal,
+                    on_connection_resumed=self._on_connection_resumed_internal,
+                )
+
+                # Try to connect
+                success = await self._connection_manager.connect()
+
+                if success:
+                    # Update connection references
+                    self._connection = self._connection_manager.connection
+                    self._connected = True
+
+                    # Update subscription manager with new connection
+                    if self._subscription_manager and self._connection:
+                        self._subscription_manager.update_connection(
+                            self._connection
+                        )
+
+                    _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(
+                    "No connection manager available for reconnection"
+                )
+
+        except Exception as e:
+            _logger.error(
+                f"Error during active reconnection: {e}", exc_info=True
+            )
+            raise
+
     async def connect(self) -> bool:
         """
         Establish connection to AWS IoT Core.
@@ -327,6 +393,8 @@ class NavienMqttClient(EventEmitter):
                     config=self.config,
                     is_connected_func=lambda: self._connected,
                     schedule_coroutine_func=self._schedule_coroutine,
+                    reconnect_func=self._active_reconnect,
+                    emit_event_func=self.emit,
                 )
                 self._reconnection_handler.enable()
 

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/src/nwp500/mqtt_reconnection.py

@@ -8,6 +8,7 @@ the MQTT connection is interrupted.
 import asyncio
 import contextlib
 import logging
+from collections.abc import Awaitable
 from typing import TYPE_CHECKING, Any, Callable, Optional
 
 if TYPE_CHECKING:
@@ -33,6 +34,8 @@ class MqttReconnectionHandler:
         config: "MqttConnectionConfig",
         is_connected_func: Callable[[], bool],
         schedule_coroutine_func: Callable[[Any], None],
+        reconnect_func: Callable[[], Awaitable[None]],
+        emit_event_func: Optional[Callable[..., Awaitable[Any]]] = None,
     ):
         """
         Initialize reconnection handler.
@@ -42,10 +45,15 @@ class MqttReconnectionHandler:
             is_connected_func: Function to check if currently connected
             schedule_coroutine_func: Function to schedule coroutines from any
             thread
+            reconnect_func: Async function to trigger active reconnection
+            emit_event_func: Optional async function to emit events
+                (e.g., EventEmitter.emit)
         """
         self.config = config
         self._is_connected_func = is_connected_func
         self._schedule_coroutine = schedule_coroutine_func
+        self._reconnect_func = reconnect_func
+        self._emit_event = emit_event_func
 
         self._reconnect_attempts = 0
         self._reconnect_task: Optional[asyncio.Task[None]] = None
@@ -156,24 +164,54 @@ class MqttReconnectionHandler:
             try:
                 await asyncio.sleep(delay)
 
-                # AWS IoT SDK will handle the actual reconnection automatically
-                # We just need to wait and monitor the connection state
-                _logger.debug(
-                    "Waiting for AWS IoT SDK automatic reconnection..."
-                )
+                # Check if we're already connected (AWS SDK auto-reconnected)
+                if self._is_connected_func():
+                    _logger.info(
+                        "AWS IoT SDK automatically reconnected during delay"
+                    )
+                    break
+
+                # Trigger active reconnection
+                _logger.info("Triggering active reconnection...")
+                try:
+                    await self._reconnect_func()
+                    if self._is_connected_func():
+                        _logger.info("Successfully reconnected")
+                        break
+                except Exception as e:
+                    _logger.warning(
+                        f"Active reconnection failed: {e}. "
+                        "Will retry if attempts remain."
+                    )
 
             except asyncio.CancelledError:
                 _logger.info("Reconnection task cancelled")
                 break
             except Exception as e:
-                _logger.error(f"Error during reconnection attempt: {e}")
+                _logger.error(
+                    f"Error during reconnection attempt: {e}", exc_info=True
+                )
 
-        if self._reconnect_attempts >= self.config.max_reconnect_attempts:
+        # Check final state
+        if (
+            self._reconnect_attempts >= self.config.max_reconnect_attempts
+            and not self._is_connected_func()
+        ):
             _logger.error(
                 f"Failed to reconnect after "
                 f"{self.config.max_reconnect_attempts} attempts. "
                 "Manual reconnection required."
             )
+            # Emit reconnection_failed event if event emitter is available
+            if self._emit_event:
+                try:
+                    await self._emit_event(
+                        "reconnection_failed", self._reconnect_attempts
+                    )
+                except Exception as e:
+                    _logger.error(
+                        f"Error emitting reconnection_failed event: {e}"
+                    )
 
     async def cancel(self) -> None:
         """Cancel any pending reconnection task."""

{nwp500_python-3.1.1 → nwp500_python-3.1.3}/src/nwp500/mqtt_subscriptions.py

@@ -72,6 +72,24 @@ class MqttSubscriptionManager:
         """Get current subscriptions."""
         return self._subscriptions.copy()
 
+    def update_connection(self, connection: Any) -> None:
+        """
+        Update the MQTT connection reference.
+
+        This is used when the connection is recreated (e.g., after reconnection)
+        to update the internal reference while preserving subscriptions.
+
+        Args:
+            connection: New MQTT connection object
+
+        Note:
+            This does not re-establish subscriptions. Call the appropriate
+            subscribe methods to re-register subscriptions with the new
+            connection if needed.
+        """
+        self._connection = connection
+        _logger.debug("Updated subscription manager connection reference")
+
     def _on_message_received(
         self, topic: str, payload: bytes, **kwargs: Any
     ) -> None:

{nwp500_python-3.1.1 → nwp500_python-3.1.3/src/nwp500_python.egg-info}/PKG-INFO

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