pyhive-integration 1.0.9.dev2__tar.gz → 1.0.9.dev3__tar.gz

{pyhive_integration-1.0.9.dev2/pyhive_integration.egg-info → pyhive_integration-1.0.9.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyhive-integration
-Version: 1.0.9.dev2
+Version: 1.0.9.dev3
 Summary: A Python library to interface with the Hive API
 Home-page: https://github.com/Pyhive/pyhiveapi
 Author: KJonline24

{pyhive_integration-1.0.9.dev2 → pyhive_integration-1.0.9.dev3/pyhive_integration.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyhive-integration
-Version: 1.0.9.dev2
+Version: 1.0.9.dev3
 Summary: A Python library to interface with the Hive API
 Home-page: https://github.com/Pyhive/pyhiveapi
 Author: KJonline24

{pyhive_integration-1.0.9.dev2 → pyhive_integration-1.0.9.dev3}/setup.py

@@ -17,7 +17,7 @@ def requirements_from_file(filename="requirements.txt"):
 
 
 setup(
-    version="1.0.9.dev2",
+    version="1.0.9.dev3",
     packages=["apyhiveapi", "apyhiveapi.api", "apyhiveapi.helper"],
     package_dir={"apyhiveapi": "src"},
     package_data={"data": ["*.json"]},

{pyhive_integration-1.0.9.dev2 → pyhive_integration-1.0.9.dev3}/src/api/hive_auth_async.py

@@ -23,7 +23,6 @@ from ..helper.hive_exceptions import (
     HiveInvalidDeviceAuthentication,
     HiveInvalidPassword,
     HiveInvalidUsername,
-    HiveReauthRequired,
     HiveRefreshTokenExpired,
 )
 from .hive_api import HiveApi
@@ -362,13 +361,14 @@ class HiveAuthAsync:
         return response
 
     async def login(self):
-        """Login into a Hive account."""
+        """Login into a Hive account - handles initial SRP auth only."""
         if self.use_file:
             _LOGGER.debug("login - Using file-based authentication.")
             return self.file_response
 
         if self.client is None:
             await self.async_init()
+
         auth_params = await self.get_auth_params()
         response = None
         result = None
@@ -423,6 +423,8 @@ class HiveAuthAsync:
                     )
                     raise HiveApiError from err
 
+            _LOGGER.debug("login - SRP auth challenge completed successfully.")
+
             if (
                 "AuthenticationResult" in result
                 and "NewDeviceMetadata" in result["AuthenticationResult"]
@@ -434,73 +436,56 @@ class HiveAuthAsync:
                 self.device_key = result["AuthenticationResult"]["NewDeviceMetadata"][
                     "DeviceKey"
                 ]
+                _LOGGER.debug("login - Device keys stored successfully.")
 
-            _LOGGER.debug("login - SRP auth challenge completed successfully.")
             return result
+
         challenge_name = response["ChallengeName"]
         _LOGGER.error("Unsupported Cognito challenge: %s", challenge_name)
         raise NotImplementedError(f"The {challenge_name} challenge is not supported")
 
     async def device_login(self):
-        """Perform device login instead."""
+        """Perform device login - handles DEVICE_SRP_AUTH challenge.
+
+        Returns:
+            dict: Authentication result with tokens.
+        """
         _LOGGER.debug("device_login - Starting device SRP authentication.")
-        login_result = await self.login()
 
-        if "AuthenticationResult" in login_result:
-            # Login succeeded without a device challenge (e.g. device tracking
-            # not enforced). Tokens are already valid, return them directly.
-            _LOGGER.debug(
-                "device_login - Device login succeeded with only "
-                + "username/password challenge: %s",
-                login_result,
-            )
-            return login_result
+        if self.client is None:
+            await self.async_init()
 
         auth_params = await self.get_auth_params(is_device_login=True)
 
-        if login_result.get("ChallengeName") == self.DEVICE_VERIFIER_CHALLENGE:
-            _LOGGER.debug("device_login - Processing DEVICE_SRP_AUTH challenge.")
-            try:
-                initial_result = await self.loop.run_in_executor(
-                    None,
-                    functools.partial(
-                        self.client.respond_to_auth_challenge,
-                        ClientId=self.__client_id,
-                        ChallengeName=self.DEVICE_VERIFIER_CHALLENGE,
-                        ChallengeResponses=auth_params,
-                    ),
-                )
+        _LOGGER.debug("device_login - Processing DEVICE_SRP_AUTH challenge.")
+        try:
+            initial_result = await self.loop.run_in_executor(
+                None,
+                functools.partial(
+                    self.client.respond_to_auth_challenge,
+                    ClientId=self.__client_id,
+                    ChallengeName=self.DEVICE_VERIFIER_CHALLENGE,
+                    ChallengeResponses=auth_params,
+                ),
+            )
 
-                device_challenge_response = await self.process_device_challenge(
-                    initial_result["ChallengeParameters"]
-                )
-                result = await self.loop.run_in_executor(
-                    None,
-                    functools.partial(
-                        self.client.respond_to_auth_challenge,
-                        ClientId=self.__client_id,
-                        ChallengeName=self.DEVICE_PASSWORD_CHALLENGE,
-                        ChallengeResponses=device_challenge_response,
-                    ),
-                )
-            except botocore.exceptions.EndpointConnectionError as err:
-                if err.__class__.__name__ == "EndpointConnectionError":
-                    _LOGGER.error("Device login failed: cannot reach endpoint.")
-                    raise HiveApiError from err
-        elif login_result.get("ChallengeName") == self.SMS_MFA_CHALLENGE:
-            # Account has 2FA enabled and device is not remembered by Cognito.
-            # Automatic re-authentication is not possible without user interaction.
-            _LOGGER.error(
-                "Device login failed: SMS MFA challenge not supported  "
-                + "when device is not remembered."
+            device_challenge_response = await self.process_device_challenge(
+                initial_result["ChallengeParameters"]
             )
-            raise HiveReauthRequired
-        else:
-            _LOGGER.error(
-                "Device login failed: expected DEVICE_SRP_AUTH challenge, got %s.",
-                login_result.get("ChallengeName"),
+            result = await self.loop.run_in_executor(
+                None,
+                functools.partial(
+                    self.client.respond_to_auth_challenge,
+                    ClientId=self.__client_id,
+                    ChallengeName=self.DEVICE_PASSWORD_CHALLENGE,
+                    ChallengeResponses=device_challenge_response,
+                ),
             )
-            raise HiveInvalidDeviceAuthentication
+        except botocore.exceptions.EndpointConnectionError as err:
+            if err.__class__.__name__ == "EndpointConnectionError":
+                _LOGGER.error("Device login failed: cannot reach endpoint.")
+                raise HiveApiError from err
+            raise HiveInvalidDeviceAuthentication from err
 
         _LOGGER.debug("device_login - Device authentication completed successfully.")
         return result
@@ -671,6 +656,96 @@ class HiveAuthAsync:
         _LOGGER.debug("refresh_token - Cognito token refresh completed successfully.")
         return result
 
+    async def is_device_registered(self, access_token=None, device_key=None):
+        """Check if the current device is registered with Cognito.
+
+        Args:
+            access_token (str, optional): Access token. Defaults to self.access_token.
+            device_key (str, optional): Device key. Defaults to self.device_key.
+
+        Returns:
+            bool: True if device is registered and remembered, False otherwise.
+
+        Raises:
+            HiveApiError: If unable to reach Cognito endpoint.
+        """
+        if self.client is None:
+            await self.async_init()
+
+        token = access_token or self.access_token
+        key = device_key or self.device_key
+
+        if not token or not key:
+            _LOGGER.debug(
+                "is_device_registered - Missing access token or device key, "
+                "device not registered"
+            )
+            return False
+
+        _LOGGER.debug(
+            "is_device_registered - Checking device registration status for device: %s",
+            key,
+        )
+
+        try:
+            result = await self.loop.run_in_executor(
+                None,
+                functools.partial(
+                    self.client.get_device,
+                    AccessToken=token,
+                    DeviceKey=key,
+                ),
+            )
+
+            if result and "Device" in result:
+                device_status = result["Device"].get("DeviceAttributes", [])
+                # Check if device is in "remembered" status
+                for attr in device_status:
+                    if (
+                        attr.get("Name") == "dev:device_remembered_status"
+                        and attr.get("Value") == "remembered"
+                    ):
+                        _LOGGER.debug(
+                            "is_device_registered - Device %s is registered and remembered",
+                            key,
+                        )
+                        return True
+
+                _LOGGER.debug(
+                    "is_device_registered - Device %s is registered but not remembered",
+                    key,
+                )
+
+        except botocore.exceptions.ClientError as err:
+            error = (err.response or {}).get("Error", {})
+            error_code = error.get("Code")
+            error_message = error.get("Message", "")
+
+            if error_code == "ResourceNotFoundException":
+                _LOGGER.debug(
+                    "is_device_registered - Device %s not found in Cognito", key
+                )
+            elif error_code == "NotAuthorizedException":
+                _LOGGER.warning(
+                    "is_device_registered - Not authorized to check device status: %s",
+                    error_message,
+                )
+            else:
+                _LOGGER.error(
+                    "is_device_registered - Error checking device status: %s - %s",
+                    error_code,
+                    error_message,
+                )
+
+        except botocore.exceptions.EndpointConnectionError as err:
+            _LOGGER.error(
+                "is_device_registered - Cannot reach Cognito endpoint: %s", str(err)
+            )
+            raise HiveApiError from err
+
+        # Default: device not registered or status unknown
+        return False
+
     async def forget_device(self, access_token, device_key):
         """Forget device registered with Hive."""
         if self.client is None:

{pyhive_integration-1.0.9.dev2 → pyhive_integration-1.0.9.dev3}/src/session.py

@@ -293,7 +293,14 @@ class HiveSession:
         return self.tokens
 
     async def login(self):
-        """Login to hive account.
+        """Login to hive account with business logic routing.
+
+        Business Rules:
+        1) Login successfully - tokens returned, no device login or SMS2FA needed
+        2) Check for device login or SMS challenges
+        3) Direct flow to one of the two
+        4) If device login, process ends but check if device is registered
+        5) If SMS, follow on with device registration
 
         Raises:
             HiveUnknownConfiguration: Login information is unknown.
@@ -318,82 +325,122 @@ class HiveSession:
             _LOGGER.error("Login failed: API error or no internet connection.")
             raise
 
+        # Rule 1: Login successful - tokens returned, no challenges needed
         if result and "AuthenticationResult" in result:
             auth_keys = list(result["AuthenticationResult"].keys())
             _LOGGER.debug(
                 "login - Login successful — AuthenticationResult keys: %s", auth_keys
             )
             await self.updateTokens(result)
-        return result
+            return result
+
+        # Rule 2 & 3: Check for device login or SMS challenges and route
+        challenge_name = result.get("ChallengeName")
+        _LOGGER.debug("login - Challenge detected: %s", challenge_name)
+
+        if challenge_name == self.auth.DEVICE_VERIFIER_CHALLENGE:
+            # Rule 4: Device login flow - check if device is registered
+            _LOGGER.debug("login - Routing to device login flow")
+            return await self._handleDeviceLoginChallenge(result)
+        elif challenge_name == self.auth.SMS_MFA_CHALLENGE:
+            # Rule 5: SMS flow - will need device registration after 2FA
+            _LOGGER.debug("login - Routing to SMS 2FA flow (requires user input)")
+            return result
+        else:
+            _LOGGER.error("login - Unsupported challenge: %s", challenge_name)
+            raise HiveUnknownConfiguration
 
-    async def sms2fa(self, code, session):
-        """Login to hive account with 2 factor authentication.
+    async def _handleDeviceLoginChallenge(self, login_result):
+        """Handle device login challenge.
 
-        Raises:
-            HiveUnknownConfiguration: Login information is unknown.
+        Args:
+            login_result (dict): Result from initial login with DEVICE_SRP_AUTH challenge.
 
         Returns:
-            dict: result of the authentication request.
+            dict: Authentication result with tokens.
+
+        Raises:
+            HiveReauthRequired: If device login encounters SMS_MFA (device not remembered).
+            HiveInvalidDeviceAuthentication: If device is not registered.
         """
-        result = None
-        if not self.auth:
-            _LOGGER.error("2FA failed: authentication not initialised.")
-            raise HiveUnknownConfiguration
+        _LOGGER.debug("_handleDeviceLoginChallenge - Processing device login")
+
+        # Check if device is registered before attempting device login
+        is_registered = await self.auth.is_device_registered()
+        if not is_registered:
+            _LOGGER.warning(
+                "_handleDeviceLoginChallenge - Device not registered, "
+                "cannot complete device login. User must complete SMS 2FA."
+            )
+            raise HiveInvalidDeviceAuthentication
 
-        _LOGGER.debug("sms_2fa - Submitting 2FA code.")
-        try:
-            result = await self.auth.sms_2fa(code, session)
-        except HiveInvalid2FACode:
-            _LOGGER.error("2FA failed: invalid code entered.")
-            raise
-        except HiveApiError:
-            _LOGGER.error("2FA failed: API error or no internet connection.")
-            raise
+        # Device is registered, proceed with device login
+        _LOGGER.debug("_handleDeviceLoginChallenge - Device is registered, proceeding")
+        result = await self.auth.device_login()
+
+        # Check if device login returned SMS_MFA challenge (device not remembered by Cognito)
+        if result and result.get("ChallengeName") == self.auth.SMS_MFA_CHALLENGE:
+            _LOGGER.error(
+                "_handleDeviceLoginChallenge - Device login failed: SMS MFA challenge detected. "
+                "Device is not remembered by Cognito. User must reauthenticate."
+            )
+            raise HiveReauthRequired
 
         if result and "AuthenticationResult" in result:
             auth_keys = list(result["AuthenticationResult"].keys())
             _LOGGER.debug(
-                "sms_2fa - 2FA login successful — AuthenticationResult keys: %s",
+                "_handleDeviceLoginChallenge - Device login successful — AuthenticationResult keys: %s",
                 auth_keys,
             )
             await self.updateTokens(result)
+
         return result
 
-    async def deviceLogin(self):
-        """Login to hive account using device authentication.
+    async def sms2fa(self, code, session):
+        """Login to hive account with 2 factor authentication.
+
+        After successful SMS 2FA, checks if device needs registration and
+        handles it automatically (Rule 5).
 
         Raises:
             HiveUnknownConfiguration: Login information is unknown.
-            HiveInvalidDeviceAuthentication: Device information is unknown.
 
         Returns:
-            dict: result of the authentication request.
+            dict: result of the authentication request with device data if registered.
         """
         result = None
         if not self.auth:
-            _LOGGER.error("Device login failed: authentication not initialised.")
+            _LOGGER.error("2FA failed: authentication not initialised.")
             raise HiveUnknownConfiguration
 
-        _LOGGER.debug("deviceLogin - Attempting device login.")
+        _LOGGER.debug("sms_2fa - Submitting 2FA code.")
         try:
-            result = await self.auth.device_login()
-        except HiveInvalidDeviceAuthentication:
-            _LOGGER.error("Device login failed: invalid device credentials.")
+            result = await self.auth.sms_2fa(code, session)
+        except HiveInvalid2FACode:
+            _LOGGER.error("2FA failed: invalid code entered.")
+            raise
+        except HiveApiError:
+            _LOGGER.error("2FA failed: API error or no internet connection.")
             raise
 
         if result and "AuthenticationResult" in result:
             auth_keys = list(result["AuthenticationResult"].keys())
             _LOGGER.debug(
-                "deviceLogin - Device login successful — AuthenticationResult keys: %s",
+                "sms_2fa - 2FA login successful — AuthenticationResult keys: %s",
                 auth_keys,
             )
             await self.updateTokens(result)
+
         return result
 
-    async def _retryDeviceLogin(self):
-        """Attempt device login with retries and backoff.
+    async def _retryLogin(self):
+        """Attempt login with retries and backoff.
+
+        This is called when token refresh fails. It attempts to login again,
+        which may succeed via device login or may require user interaction (SMS 2FA).
 
         Raises:
+            HiveReauthRequired: User interaction required (SMS 2FA challenge).
             HiveInvalidDeviceAuthentication: Device credentials are invalid.
             HiveApiError: API error or no internet connection.
         """
@@ -402,26 +449,37 @@ class HiveSession:
             try:
                 if delay_s:
                     _LOGGER.debug(
-                        "deviceLogin - Retrying device login in %s seconds.", delay_s
+                        "_retryLogin - Retrying login in %s seconds.", delay_s
                     )
                     await asyncio.sleep(delay_s)
-                await self.deviceLogin()
+                result = await self.login()
+
+                # Check if login returned SMS_MFA challenge (requires user interaction)
+                if (
+                    result
+                    and result.get("ChallengeName") == self.auth.SMS_MFA_CHALLENGE
+                ):
+                    _LOGGER.error(
+                        "_retryLogin - Login requires SMS 2FA. User must reauthenticate."
+                    )
+                    raise HiveReauthRequired
+
                 last_err = None
                 break
-            except HiveInvalidDeviceAuthentication:
+            except (HiveInvalidUsername, HiveInvalidPassword):
                 _LOGGER.error(
-                    "Device login failed with invalid credentials, reauthentication required."
+                    "_retryLogin - Login failed with invalid credentials, reauthentication required."
                 )
+                raise HiveReauthRequired
+            except HiveReauthRequired:
+                # Propagate reauthentication requirement immediately
+                raise
             except HiveApiError as err:
-                _LOGGER.error("Device login attempt failed: %s", err)
+                _LOGGER.error("_retryLogin - Login attempt failed: %s", err)
                 last_err = err
         if last_err is not None:
-            _LOGGER.error(
-                "All device login retries exhausted, but device login may resolve the issue."
-            )
-            # Don't raise HiveReauthRequired - let the caller handle the error
-            # Device login itself should resolve 403 issues when successful
-            return
+            _LOGGER.error("_retryLogin - All login retries exhausted.")
+            raise HiveReauthRequired from last_err
 
         await self.hiveRefreshTokens(force_refresh=True)
 
@@ -488,11 +546,11 @@ class HiveSession:
                             )
                     except (HiveRefreshTokenExpired, HiveFailedToRefreshTokens) as exc:
                         _LOGGER.warning(
-                            "Session Token refresh failed (%s), falling back to device login.",
+                            "Session Token refresh failed (%s), falling back to login.",
                             type(exc).__name__,
                         )
                         if not force_refresh:
-                            await self._retryDeviceLogin()
+                            await self._retryLogin()
                         else:
                             _LOGGER.error(
                                 "Token refresh failed during retry attempt, giving up."
@@ -648,7 +706,7 @@ class HiveSession:
                         "Auth error (401/403) after token refresh, "
                         "falling back to full device re-login."
                     )
-                    await self._retryDeviceLogin()
+                    await self._retryLogin()
                     last_auth_err = None
                     for api_retry_delay in (0, 5, 10):
                         try: