pyhive-integration 1.0.8.dev10__tar.gz → 1.0.9.dev1__tar.gz

{pyhive_integration-1.0.8.dev10/pyhive_integration.egg-info → pyhive_integration-1.0.9.dev1}/PKG-INFO

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

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1/pyhive_integration.egg-info}/PKG-INFO

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

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/setup.py

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

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/src/action.py

@@ -32,6 +32,14 @@ class HiveAction:
         Returns:
             dict: Updated device.
         """
+        if self.session.shouldUseCachedData():
+            cached = self.session.getCachedDevice(device)
+            if cached is not None:
+                _LOGGER.debug(
+                    "Returning cached state for action %s (slow/busy poll).",
+                    device["haName"],
+                )
+                return cached
         dev_data = {}
 
         if device["hiveID"] in self.data["action"]:
@@ -47,8 +55,7 @@ class HiveAction:
                 "custom": device.get("custom", None),
             }
 
-            self.session.devices.update({device["hiveID"]: dev_data})
-            return self.session.devices[device["hiveID"]]
+            return self.session.setCachedDevice(device, dev_data)
         else:
             exists = self.session.data.actions.get("hiveID", False)
             if exists is False:

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/src/alarm.py

@@ -96,6 +96,14 @@ class Alarm(HiveHomeShield):
         Returns:
             dict: Updated device.
         """
+        if self.session.shouldUseCachedData():
+            cached = self.session.getCachedDevice(device)
+            if cached is not None:
+                _LOGGER.debug(
+                    "Returning cached state for alarm %s (slow/busy poll).",
+                    device["haName"],
+                )
+                return cached
         device["deviceData"].update(
             {"online": await self.session.attr.onlineOffline(device["device_id"])}
         )
@@ -125,8 +133,7 @@ class Alarm(HiveHomeShield):
                 ),
             }
 
-            self.session.devices.update({device["hiveID"]: dev_data})
-            return self.session.devices[device["hiveID"]]
+            return self.session.setCachedDevice(device, dev_data)
         else:
             await self.session.helper.errorCheck(
                 device["device_id"], "ERROR", device["deviceData"]["online"]

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/src/api/hive_api.py

@@ -2,6 +2,7 @@
 
 # pylint: skip-file
 import json
+import logging
 
 import requests
 import urllib3
@@ -9,6 +10,8 @@ from pyquery import PyQuery
 
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class HiveApi:
     """Hive API Code."""
@@ -43,6 +46,10 @@ class HiveApi:
 
     def request(self, type, url, jsc=None, camera=False):
         """Make API request."""
+        _LOGGER.debug("request - Making %s request to: %s", type, url)
+        if jsc:
+            _LOGGER.debug("request - Request payload: %s", jsc)
+
         if self.session is not None:
             if camera:
                 self.headers = {
@@ -72,17 +79,27 @@ class HiveApi:
                     "authorization": self.token,
                 }
 
-        if type == "GET":
-            return requests.get(
-                url=url, headers=self.headers, data=jsc, timeout=self.timeout
-            )
-        if type == "POST":
-            return requests.post(
-                url=url, headers=self.headers, data=jsc, timeout=self.timeout
-            )
+        _LOGGER.debug(
+            "request - Request headers: %s",
+            {k: v for k, v in self.headers.items() if k.lower() != "authorization"},
+        )
+
+        try:
+            if type == "GET":
+                return requests.get(
+                    url=url, headers=self.headers, data=jsc, timeout=self.timeout
+                )
+            if type == "POST":
+                return requests.post(
+                    url=url, headers=self.headers, data=jsc, timeout=self.timeout
+                )
+        except Exception as e:
+            _LOGGER.error("Request failed: %s", e)
+            raise
 
     def refreshTokens(self, tokens={}):
         """Get new session tokens - DEPRECATED NOW BY AWS TOKEN MANAGEMENT."""
+        _LOGGER.debug("refreshTokens - Attempting token refresh (deprecated method)")
         url = self.urls["refresh"]
         if self.session is not None:
             tokens = self.session.tokens.tokenData
@@ -97,21 +114,31 @@ class HiveApi:
             info = self.request("POST", url, jsc)
             data = json.loads(info.text)
             if "token" in data and self.session:
+                _LOGGER.debug(
+                    "refreshTokens - Token refresh successful, updating session"
+                )
                 self.session.updateTokens(data)
                 self.urls.update({"base": data["platform"]["endpoint"]})
                 self.urls.update({"camera": data["platform"]["cameraPlatform"]})
             self.json_return.update({"original": info.status_code})
             self.json_return.update({"parsed": info.json()})
-        except (OSError, RuntimeError, ZeroDivisionError):
+        except (OSError, RuntimeError, ZeroDivisionError, json.JSONDecodeError) as e:
+            _LOGGER.error("Token refresh failed: %s", str(e))
             self.error()
 
         return self.json_return
 
     def getLoginInfo(self):
         """Get login properties to make the login request."""
+        _LOGGER.debug(
+            "getLoginInfo - Fetching login info from: %s", self.urls["properties"]
+        )
         url = self.urls["properties"]
         try:
             data = requests.get(url=url, verify=False, timeout=self.timeout)
+            _LOGGER.debug(
+                "getLoginInfo - Login info response status: %s", data.status_code
+            )
             html = PyQuery(data.content)
             json_data = json.loads(
                 '{"'
@@ -126,19 +153,35 @@ class HiveApi:
             loginData.update({"UPID": json_data["HiveSSOPoolId"]})
             loginData.update({"CLIID": json_data["HiveSSOPublicCognitoClientId"]})
             loginData.update({"REGION": json_data["HiveSSOPoolId"]})
+            _LOGGER.debug("getLoginInfo - Login info extracted successfully")
             return loginData
-        except (OSError, RuntimeError, ZeroDivisionError):
+        except (
+            OSError,
+            RuntimeError,
+            ZeroDivisionError,
+            json.JSONDecodeError,
+            KeyError,
+        ) as e:
+            _LOGGER.error("Failed to get login info: %s", str(e))
             self.error()
 
     def getAll(self):
         """Build and query all endpoint."""
+        _LOGGER.debug("getAll - Fetching all devices/products/actions from Hive API")
         json_return = {}
         url = self.urls["base"] + self.urls["all"]
         try:
             info = self.request("GET", url)
-            json_return.update({"original": info.status_code})
-            json_return.update({"parsed": info.json()})
-        except (OSError, RuntimeError, ZeroDivisionError):
+            if info is not None:
+                json_return.update({"original": info.status_code})
+                json_return.update({"parsed": info.json()})
+                _LOGGER.debug(
+                    "getAll - All data fetch successful, status: %s", info.status_code
+                )
+            else:
+                _LOGGER.error("Failed to get response from all endpoint")
+        except (OSError, RuntimeError, ZeroDivisionError, json.JSONDecodeError) as e:
+            _LOGGER.error("Failed to fetch all data: %s", str(e))
             self.error()
 
         return json_return
@@ -259,6 +302,12 @@ class HiveApi:
 
     def setState(self, n_type, n_id, **kwargs):
         """Set the state of a Device."""
+        _LOGGER.debug(
+            "setState - Setting state for device %s (type: %s): %s",
+            n_id,
+            n_type,
+            kwargs,
+        )
         jsc = (
             "{"
             + ",".join(
@@ -271,9 +320,24 @@ class HiveApi:
 
         try:
             response = self.request("POST", url, jsc)
-            self.json_return.update({"original": response.status_code})
-            self.json_return.update({"parsed": response.json()})
-        except (OSError, RuntimeError, ZeroDivisionError, ConnectionError):
+            if response is not None:
+                self.json_return.update({"original": response.status_code})
+                self.json_return.update({"parsed": response.json()})
+                _LOGGER.debug(
+                    "setState - State set successfully for %s, status: %s",
+                    n_id,
+                    response.status_code,
+                )
+            else:
+                _LOGGER.error("Failed to set state for %s - no response", n_id)
+        except (
+            OSError,
+            RuntimeError,
+            ZeroDivisionError,
+            ConnectionError,
+            json.JSONDecodeError,
+        ) as e:
+            _LOGGER.error("Failed to set state for %s: %s", n_id, str(e))
             self.error()
 
         return self.json_return
@@ -293,6 +357,7 @@ class HiveApi:
 
     def error(self):
         """An error has occurred interacting with the Hive API."""
+        _LOGGER.error("API error occurred - returning error response")
         self.json_return.update({"original": "Error making API call"})
         self.json_return.update({"parsed": "Error making API call"})
 

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/src/api/hive_async_api.py

@@ -169,7 +169,6 @@ class HiveApiAsync:
         """Build and query all endpoint."""
         json_return = {}
         url = self.urls["all"]
-        _LOGGER.debug("Fetching all nodes from Hive API.")
         try:
             resp = await self.request("get", url)
             json_return.update({"original": resp.status})
@@ -303,7 +302,7 @@ class HiveApiAsync:
 
     async def setState(self, n_type, n_id, **kwargs):
         """Set the state of a Device."""
-        _LOGGER.debug("Setting state for %s/%s: %s", n_type, n_id, kwargs)
+        _LOGGER.debug("setState - Setting state for %s/%s: %s", n_type, n_id, kwargs)
         json_return = {}
         jsc = (
             "{"

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/src/api/hive_auth.py

@@ -18,6 +18,7 @@ from ..helper.hive_exceptions import (
     HiveInvalidDeviceAuthentication,
     HiveInvalidPassword,
     HiveInvalidUsername,
+    HiveReauthRequired,
 )
 from .hive_api import HiveApi
 
@@ -383,6 +384,12 @@ class HiveAuth:
     def device_login(self):
         """Perform device login instead."""
         login_result = 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.
+            return login_result
+
         auth_params = self.get_auth_params()
         auth_params["DEVICE_KEY"] = self.device_key
 
@@ -405,6 +412,10 @@ class HiveAuth:
             except botocore.exceptions.EndpointConnectionError as err:
                 if err.__class__.__name__ == "EndpointConnectionError":
                     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.
+            raise HiveReauthRequired
         else:
             raise HiveInvalidDeviceAuthentication
 

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/src/api/hive_auth_async.py

@@ -23,6 +23,7 @@ from ..helper.hive_exceptions import (
     HiveInvalidDeviceAuthentication,
     HiveInvalidPassword,
     HiveInvalidUsername,
+    HiveReauthRequired,
     HiveRefreshTokenExpired,
 )
 from .hive_api import HiveApi
@@ -182,8 +183,9 @@ class HiveAuthAsync:
         )
         return hkdf
 
-    async def get_auth_params(self):
+    async def get_auth_params(self, is_device_login=False):
         """Get auth params."""
+        _LOGGER.debug("get_auth_params - Getting auth params")
         auth_params = {
             "USERNAME": self.username,
             "SRP_A": long_to_hex(self.large_a_value),
@@ -196,6 +198,11 @@ class HiveAuthAsync:
                     )
                 }
             )
+
+        if is_device_login:
+            auth_params["DEVICE_KEY"] = self.device_key
+
+        _LOGGER.debug("Auth params: %s", auth_params)
         return auth_params
 
     @staticmethod
@@ -357,7 +364,7 @@ class HiveAuthAsync:
     async def login(self):
         """Login into a Hive account."""
         if self.use_file:
-            _LOGGER.debug("Using file-based authentication.")
+            _LOGGER.debug("login - Using file-based authentication.")
             return self.file_response
 
         if self.client is None:
@@ -365,7 +372,7 @@ class HiveAuthAsync:
         auth_params = await self.get_auth_params()
         response = None
         result = None
-        _LOGGER.debug("Initiating SRP auth with Cognito.")
+        _LOGGER.debug("login - Initiating SRP auth with Cognito.")
         try:
             response = await self.loop.run_in_executor(
                 None,
@@ -386,7 +393,7 @@ class HiveAuthAsync:
                 raise HiveApiError from err
 
         if response["ChallengeName"] == self.PASSWORD_VERIFIER_CHALLENGE:
-            _LOGGER.debug("Processing PASSWORD_VERIFIER challenge.")
+            _LOGGER.debug("login - Processing PASSWORD_VERIFIER challenge.")
             challenge_response = await self.process_challenge(
                 response["ChallengeParameters"]
             )
@@ -416,7 +423,19 @@ class HiveAuthAsync:
                     )
                     raise HiveApiError from err
 
-            _LOGGER.debug("SRP auth challenge completed successfully.")
+            if (
+                "AuthenticationResult" in result
+                and "NewDeviceMetadata" in result["AuthenticationResult"]
+            ):
+                self.access_token = result["AuthenticationResult"]["AccessToken"]
+                self.device_group_key = result["AuthenticationResult"][
+                    "NewDeviceMetadata"
+                ]["DeviceGroupKey"]
+                self.device_key = result["AuthenticationResult"]["NewDeviceMetadata"][
+                    "DeviceKey"
+                ]
+
+            _LOGGER.debug("login - SRP auth challenge completed successfully.")
             return result
         challenge_name = response["ChallengeName"]
         _LOGGER.error("Unsupported Cognito challenge: %s", challenge_name)
@@ -424,13 +443,23 @@ class HiveAuthAsync:
 
     async def device_login(self):
         """Perform device login instead."""
-        _LOGGER.debug("Starting device SRP authentication.")
+        _LOGGER.debug("device_login - Starting device SRP authentication.")
         login_result = await self.login()
-        auth_params = await self.get_auth_params()
-        auth_params["DEVICE_KEY"] = self.device_key
+
+        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
+
+        auth_params = await self.get_auth_params(is_device_login=True)
 
         if login_result.get("ChallengeName") == self.DEVICE_VERIFIER_CHALLENGE:
-            _LOGGER.debug("Processing DEVICE_SRP_AUTH challenge.")
+            _LOGGER.debug("device_login - Processing DEVICE_SRP_AUTH challenge.")
             try:
                 initial_result = await self.loop.run_in_executor(
                     None,
@@ -458,6 +487,14 @@ class HiveAuthAsync:
                 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."
+            )
+            raise HiveReauthRequired
         else:
             _LOGGER.error(
                 "Device login failed: expected DEVICE_SRP_AUTH challenge, got %s.",
@@ -465,7 +502,7 @@ class HiveAuthAsync:
             )
             raise HiveInvalidDeviceAuthentication
 
-        _LOGGER.debug("Device authentication completed successfully.")
+        _LOGGER.debug("device_login - Device authentication completed successfully.")
         return result
 
     async def sms_2fa(
@@ -477,7 +514,7 @@ class HiveAuthAsync:
         session = challenge_parameters.get("Session")
         code = str(entered_code)
         result = None
-        _LOGGER.debug("Submitting SMS 2FA code to Cognito.")
+        _LOGGER.debug("sms_2fa - Submitting SMS 2FA code to Cognito.")
         try:
             result = await self.loop.run_in_executor(
                 None,
@@ -512,12 +549,12 @@ class HiveAuthAsync:
                 _LOGGER.error("2FA failed: cannot reach Cognito endpoint.")
                 raise HiveApiError from err
 
-        _LOGGER.debug("2FA authentication completed successfully.")
+        _LOGGER.debug("sms_2fa - 2FA authentication completed successfully.")
         return result
 
     async def device_registration(self, device_name: str = None):
         """Register device with Hive."""
-        _LOGGER.debug("Registering device with Hive.")
+        _LOGGER.debug("device_registration - Registering device with Hive.")
         await self.confirm_device(device_name)
         await self.update_device_status()
 
@@ -588,7 +625,7 @@ class HiveAuthAsync:
         """Refresh Hive Tokens."""
         if self.client is None:
             await self.async_init()
-        _LOGGER.debug("Requesting token refresh from Cognito.")
+        _LOGGER.debug("refresh_token - Requesting token refresh from Cognito.")
         result = None
         auth_params = {"REFRESH_TOKEN": token}
         if self.device_key is not None:
@@ -618,14 +655,20 @@ class HiveAuthAsync:
                 _LOGGER.warning("Refresh token is invalid or expired.")
                 raise HiveRefreshTokenExpired from err
 
-            _LOGGER.error("Token refresh failed: %s - %s", error_code, error_message)
+            _LOGGER.error(
+                "refresh_token - Token refresh failed: %s - %s",
+                error_code,
+                error_message,
+            )
             raise HiveFailedToRefreshTokens from err
         except botocore.exceptions.EndpointConnectionError as err:
             if err.__class__.__name__ == "EndpointConnectionError":
-                _LOGGER.error("Token refresh failed: cannot reach Cognito endpoint.")
+                _LOGGER.error(
+                    "refresh_token - Token refresh failed: cannot reach Cognito endpoint."
+                )
                 raise HiveApiError from err
 
-        _LOGGER.debug("Cognito token refresh completed successfully.")
+        _LOGGER.debug("refresh_token - Cognito token refresh completed successfully.")
         return result
 
     async def forget_device(self, access_token, device_key):

{pyhive_integration-1.0.8.dev10 → pyhive_integration-1.0.9.dev1}/src/camera.py

@@ -94,7 +94,7 @@ class HiveCamera:
             device["hiveID"] in self.session.data.devices
             and device["deviceData"]["online"]
         ):
-            _LOGGER.debug("Setting camera ON for %s.", device["haName"])
+            _LOGGER.debug("setCameraOn - Setting camera ON for %s.", device["haName"])
             await self.session.hiveRefreshTokens()
             resp = await self.session.api.setState(mode=mode)
             if resp["original"] == 200:
@@ -118,7 +118,7 @@ class HiveCamera:
             device["hiveID"] in self.session.data.devices
             and device["deviceData"]["online"]
         ):
-            _LOGGER.debug("Setting camera OFF for %s.", device["haName"])
+            _LOGGER.debug("setCameraOff - Setting camera OFF for %s.", device["haName"])
             await self.session.hiveRefreshTokens()
             resp = await self.session.api.setState(mode=mode)
             if resp["original"] == 200:
@@ -152,6 +152,14 @@ class Camera(HiveCamera):
         Returns:
             dict: Updated device.
         """
+        if self.session.shouldUseCachedData():
+            cached = self.session.getCachedDevice(device)
+            if cached is not None:
+                _LOGGER.debug(
+                    "getCamera - Returning cached state for camera %s (slow/busy poll).",
+                    device["haName"],
+                )
+                return cached
         device["deviceData"].update(
             {"online": await self.session.attr.onlineOffline(device["device_id"])}
         )
@@ -159,7 +167,7 @@ class Camera(HiveCamera):
 
         if device["deviceData"]["online"]:
             self.session.helper.deviceRecovered(device["device_id"])
-            _LOGGER.debug("Updating camera data for %s.", device["haName"])
+            _LOGGER.debug("getCamera - Updating camera data for %s.", device["haName"])
             data = self.session.data.devices[device["device_id"]]
             dev_data = {
                 "hiveID": device["hiveID"],
@@ -183,8 +191,7 @@ class Camera(HiveCamera):
                 ),
             }
 
-            self.session.devices.update({device["hiveID"]: dev_data})
-            return self.session.devices[device["hiveID"]]
+            return self.session.setCachedDevice(device, dev_data)
         else:
             await self.session.helper.errorCheck(
                 device["device_id"], "ERROR", device["deviceData"]["online"]