nwp500-python 3.1.2__tar.gz → 3.1.4__tar.gz

{nwp500_python-3.1.2 → nwp500_python-3.1.4}/.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.2 → nwp500_python-3.1.4}/CHANGELOG.rst

@@ -2,6 +2,42 @@
 Changelog
 =========
 
+Version 3.1.4 (2025-10-26)
+==========================
+
+Fixed
+-----
+
+- **MQTT Reconnection**: Fixed MQTT reconnection failures due to expired AWS credentials
+  
+  - Added AWS credential expiration tracking (``_aws_expires_at`` field in ``AuthTokens``)
+  - Added ``are_aws_credentials_expired`` property to check AWS credential validity
+  - Modified ``ensure_valid_token()`` to prioritize AWS credential expiration check
+  - Triggers full re-authentication (not just token refresh) when AWS credentials expire
+  - Preserves AWS credential expiration timestamps during token refresh
+  - Prevents reconnection failures when connection interrupts after AWS credentials expire but before JWT tokens expire
+  - Resolves AWS_ERROR_HTTP_WEBSOCKET_UPGRADE_FAILURE errors during reconnection attempts
+  - Improved test coverage for auth module from 31% to 60% with comprehensive test suite
+
+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)
 ==========================
 

{nwp500_python-3.1.2/src/nwp500_python.egg-info → nwp500_python-3.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nwp500-python
-Version: 3.1.2
+Version: 3.1.4
 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.2 → nwp500_python-3.1.4}/src/nwp500/auth.py

@@ -73,6 +73,9 @@ class AuthTokens:
     _expires_at: datetime = field(
         default=datetime.now(), init=False, repr=False
     )
+    _aws_expires_at: Optional[datetime] = field(
+        default=None, init=False, repr=False
+    )
 
     def __post_init__(self) -> None:
         """Cache the expiration timestamp after initialization."""
@@ -80,6 +83,11 @@ class AuthTokens:
         self._expires_at = self.issued_at + timedelta(
             seconds=self.authentication_expires_in
         )
+        # Calculate AWS credentials expiration if available
+        if self.authorization_expires_in:
+            self._aws_expires_at = self.issued_at + timedelta(
+                seconds=self.authorization_expires_in
+            )
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "AuthTokens":
@@ -106,6 +114,25 @@ class AuthTokens:
         # Consider expired if within 5 minutes of expiration
         return datetime.now() >= (self._expires_at - timedelta(minutes=5))
 
+    @property
+    def are_aws_credentials_expired(self) -> bool:
+        """Check if AWS credentials have expired.
+
+        AWS credentials have a separate expiration time from JWT tokens.
+        If AWS credentials are expired, a full re-authentication is needed
+        since the token refresh endpoint doesn't provide new AWS credentials.
+
+        Returns:
+            True if AWS credentials are expired, False if expiration time is
+            unknown or credentials are still valid
+        """
+        if not self._aws_expires_at:
+            # If we don't know when AWS credentials expire, consider them valid
+            # This handles cases where authorization_expires_in wasn't provided
+            return False
+        # Consider expired if within 5 minutes of expiration
+        return datetime.now() >= (self._aws_expires_at - timedelta(minutes=5))
+
     @property
     def time_until_expiry(self) -> timedelta:
         """Get time remaining until token expiration.
@@ -423,6 +450,8 @@ class NavienAuthClient:
                         new_tokens.authorization_expires_in = (
                             old_tokens.authorization_expires_in
                         )
+                        # Also preserve the AWS expiration timestamp
+                        new_tokens._aws_expires_at = old_tokens._aws_expires_at
 
                 # Update stored auth response if we have one
                 if self._auth_response:
@@ -446,23 +475,36 @@ class NavienAuthClient:
         """
         Ensure we have a valid access token, refreshing if necessary.
 
+        This method checks both JWT token and AWS credentials expiration.
+        If AWS credentials are expired, it triggers a full re-authentication
+        since the token refresh endpoint doesn't provide new AWS credentials.
+
         Returns:
             Valid AuthTokens or None if not authenticated
 
         Raises:
             TokenRefreshError: If token refresh fails
+            AuthenticationError: If re-authentication fails
         """
         if not self._auth_response:
             _logger.warning("No authentication response available")
             return None
 
-        if self._auth_response.tokens.is_expired:
+        tokens = self._auth_response.tokens
+
+        # Check if AWS credentials have expired
+        if tokens.are_aws_credentials_expired:
+            _logger.info("AWS credentials expired, re-authenticating...")
+            # Re-authenticate to get fresh AWS credentials
+            await self.sign_in(self._user_id, self._password)
+            return self._auth_response.tokens if self._auth_response else None
+
+        # Check if JWT token has expired
+        if tokens.is_expired:
             _logger.info("Token expired, refreshing...")
-            return await self.refresh_token(
-                self._auth_response.tokens.refresh_token
-            )
+            return await self.refresh_token(tokens.refresh_token)
 
-        return self._auth_response.tokens
+        return tokens
 
     @property
     def is_authenticated(self) -> bool:

{nwp500_python-3.1.2 → nwp500_python-3.1.4}/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.2 → nwp500_python-3.1.4}/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.2 → nwp500_python-3.1.4}/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.2 → nwp500_python-3.1.4/src/nwp500_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nwp500-python
-Version: 3.1.2
+Version: 3.1.4
 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.2 → nwp500_python-3.1.4}/src/nwp500_python.egg-info/SOURCES.txt

@@ -120,6 +120,7 @@ src/nwp500_python.egg-info/requires.txt
 src/nwp500_python.egg-info/top_level.txt
 tests/conftest.py
 tests/test_api_helpers.py
+tests/test_auth.py
 tests/test_command_queue.py
 tests/test_events.py
 tests/test_utils.py