pyhive-integration 0.5.17__tar.gz

pyhive_integration-0.5.17/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Pyhive
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyhive_integration-0.5.17/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include pyhiveapi *
+include requirements.txt
+include requirements_test.txt
+recursive-include data *

pyhive_integration-0.5.17/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.2
+Name: pyhive-integration
+Version: 0.5.17
+Summary: A Python library to interface with the Hive API
+Home-page: https://github.com/Pyhive/pyhiveapi
+Author: KJonline24
+Author-email: khole_47@icloud.com
+License: MIT
+Project-URL: Source, https://github.com/Pyhive/Pyhiveapi
+Project-URL: Issue tracker, https://github.com/Pyhive/Pyhiveapi/issues
+Keywords: Hive API Library
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.6
+License-File: LICENSE
+Requires-Dist: pre-commit
+Requires-Dist: boto3>=1.16.10
+Requires-Dist: botocore>=1.19.10
+Requires-Dist: requests
+Requires-Dist: aiohttp
+Requires-Dist: pyquery
+Requires-Dist: unasync
+Requires-Dist: loguru
+Provides-Extra: dev
+Requires-Dist: tox; extra == "dev"
+Dynamic: provides-extra
+Dynamic: requires-dist

pyhive_integration-0.5.17/README.md

@@ -0,0 +1,15 @@
+
+![CodeQL](https://github.com/Pyhive/Pyhiveapi/workflows/CodeQL/badge.svg) ![Python Linting](https://github.com/Pyhive/Pyhiveapi/workflows/Python%20package/badge.svg)
+
+# Introduction
+This is a library which intefaces with the Hive smart home platform. 
+This library is built mainly to integrate with the Home Assistant platform,
+but it can also be used independently (See examples below.)
+
+
+## Examples
+Here are examples and documentation on how to use the library independently.
+
+https://pyhass.github.io/pyhiveapi.docs/  [WIP]
+
+

pyhive_integration-0.5.17/pyhiveapi/apyhiveapi/__init__.py

@@ -0,0 +1,11 @@
+"""__init__.py."""
+# pylint: skip-file
+if __name__ == "pyhiveapi":
+    from .api.hive_api import HiveApi as API  # noqa: F401
+    from .api.hive_auth import HiveAuth as Auth  # noqa: F401
+else:
+    from .api.hive_async_api import HiveApiAsync as API  # noqa: F401
+    from .api.hive_auth_async import HiveAuthAsync as Auth  # noqa: F401
+
+from .helper.const import SMS_REQUIRED  # noqa: F401
+from .hive import Hive  # noqa: F401

pyhive_integration-0.5.17/pyhiveapi/apyhiveapi/action.py

@@ -0,0 +1,121 @@
+"""Hive Action Module."""
+# pylint: skip-file
+
+
+class HiveAction:
+    """Hive Action Code.
+
+    Returns:
+        object: Return hive action object.
+    """
+
+    actionType = "Actions"
+
+    def __init__(self, session: object = None):
+        """Initialise Action.
+
+        Args:
+            session (object, optional): session to interact with hive account. Defaults to None.
+        """
+        self.session = session
+
+    async def getAction(self, device: dict):
+        """Action device to update.
+
+        Args:
+            device (dict): Device to be updated.
+
+        Returns:
+            dict: Updated device.
+        """
+        dev_data = {}
+
+        if device["hiveID"] in self.data["action"]:
+            dev_data = {
+                "hiveID": device["hiveID"],
+                "hiveName": device["hiveName"],
+                "hiveType": device["hiveType"],
+                "haName": device["haName"],
+                "haType": device["haType"],
+                "status": {"state": await self.getState(device)},
+                "power_usage": None,
+                "deviceData": {},
+                "custom": device.get("custom", None),
+            }
+
+            self.session.devices.update({device["hiveID"]: dev_data})
+            return self.session.devices[device["hiveID"]]
+        else:
+            exists = self.session.data.actions.get("hiveID", False)
+            if exists is False:
+                return "REMOVE"
+            return device
+
+    async def getState(self, device: dict):
+        """Get action state.
+
+        Args:
+            device (dict): Device to get state of.
+
+        Returns:
+            str: Return state.
+        """
+        final = None
+
+        try:
+            data = self.session.data.actions[device["hiveID"]]
+            final = data["enabled"]
+        except KeyError as e:
+            await self.session.log.error(e)
+
+        return final
+
+    async def setStatusOn(self, device: dict):
+        """Set action turn on.
+
+        Args:
+            device (dict): Device to set state of.
+
+        Returns:
+            boolean: True/False if successful.
+        """
+        import json
+
+        final = False
+
+        if device["hiveID"] in self.session.data.actions:
+            await self.session.hiveRefreshTokens()
+            data = self.session.data.actions[device["hiveID"]]
+            data.update({"enabled": True})
+            send = json.dumps(data)
+            resp = await self.session.api.setAction(device["hiveID"], send)
+            if resp["original"] == 200:
+                final = True
+                await self.session.getDevices(device["hiveID"])
+
+        return final
+
+    async def setStatusOff(self, device: dict):
+        """Set action to turn off.
+
+        Args:
+            device (dict): Device to set state of.
+
+        Returns:
+            boolean: True/False if successful.
+        """
+        import json
+
+        final = False
+
+        if device["hiveID"] in self.session.data.actions:
+            await self.session.hiveRefreshTokens()
+            data = self.session.data.actions[device["hiveID"]]
+            data.update({"enabled": False})
+            send = json.dumps(data)
+            resp = await self.session.api.setAction(device["hiveID"], send)
+            if resp["original"] == 200:
+                final = True
+                await self.session.getDevices(device["hiveID"])
+
+        return final

pyhive_integration-0.5.17/pyhiveapi/apyhiveapi/alarm.py

@@ -0,0 +1,128 @@
+"""Hive Alarm Module."""
+# pylint: skip-file
+
+
+class HiveHomeShield:
+    """Hive homeshield alarm.
+
+    Returns:
+        object: Hive homeshield
+    """
+
+    alarmType = "Alarm"
+
+    async def getMode(self):
+        """Get current mode of the alarm.
+
+        Returns:
+            str: Mode if the alarm [armed_home, armed_away, armed_night]
+        """
+        state = None
+
+        try:
+            data = self.session.data.alarm
+            state = data["mode"]
+        except KeyError as e:
+            await self.session.log.error(e)
+
+        return state
+
+    async def getState(self, device: dict):
+        """Get the alarm triggered state.
+
+        Returns:
+            boolean: True/False if alarm is triggered.
+        """
+        state = None
+
+        try:
+            data = self.session.data.devices[device["hiveID"]]
+            state = data["state"]["alarmActive"]
+        except KeyError as e:
+            await self.session.log.error(e)
+
+        return state
+
+    async def setMode(self, device: dict, mode: str):
+        """Set the alarm mode.
+
+        Args:
+            device (dict): Alarm device.
+
+        Returns:
+            boolean: True/False if successful.
+        """
+        final = False
+
+        if (
+            device["hiveID"] in self.session.data.devices
+            and device["deviceData"]["online"]
+        ):
+            await self.session.hiveRefreshTokens()
+            resp = await self.session.api.setAlarm(mode=mode)
+            if resp["original"] == 200:
+                final = True
+                await self.session.getAlarm()
+
+        return final
+
+
+class Alarm(HiveHomeShield):
+    """Home assistant alarm.
+
+    Args:
+        HiveHomeShield (object): Class object.
+    """
+
+    def __init__(self, session: object = None):
+        """Initialise alarm.
+
+        Args:
+            session (object, optional): Used to interact with the hive account. Defaults to None.
+        """
+        self.session = session
+
+    async def getAlarm(self, device: dict):
+        """Get alarm data.
+
+        Args:
+            device (dict): Device to update.
+
+        Returns:
+            dict: Updated device.
+        """
+        device["deviceData"].update(
+            {"online": await self.session.attr.onlineOffline(device["device_id"])}
+        )
+        dev_data = {}
+
+        if device["deviceData"]["online"]:
+            self.session.helper.deviceRecovered(device["device_id"])
+            data = self.session.data.devices[device["device_id"]]
+            dev_data = {
+                "hiveID": device["hiveID"],
+                "hiveName": device["hiveName"],
+                "hiveType": device["hiveType"],
+                "haName": device["haName"],
+                "haType": device["haType"],
+                "device_id": device["device_id"],
+                "device_name": device["device_name"],
+                "status": {
+                    "state": await self.getState(device),
+                    "mode": await self.getMode(),
+                },
+                "deviceData": data.get("props", None),
+                "parentDevice": data.get("parent", None),
+                "custom": device.get("custom", None),
+                "attributes": await self.session.attr.stateAttributes(
+                    device["device_id"], device["hiveType"]
+                ),
+            }
+
+            self.session.devices.update({device["hiveID"]: dev_data})
+            return self.session.devices[device["hiveID"]]
+        else:
+            await self.session.log.errorCheck(
+                device["device_id"], "ERROR", device["deviceData"]["online"]
+            )
+            return device

pyhive_integration-0.5.17/pyhiveapi/apyhiveapi/api/__init__.py

@@ -0,0 +1 @@
+"""__init__.py file."""

pyhive_integration-0.5.17/pyhiveapi/apyhiveapi/api/hive_api.py

@@ -0,0 +1,300 @@
+"""Hive API Module."""
+# pylint: skip-file
+import json
+
+import requests
+import urllib3
+from pyquery import PyQuery
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+class HiveApi:
+    """Hive API Code."""
+
+    def __init__(self, hiveSession=None, websession=None, token=None):
+        """Hive API initialisation."""
+        self.cameraBaseUrl = "prod.hcam.bgchtest.info"
+        self.urls = {
+            "properties": "https://sso.hivehome.com/",
+            "login": "https://beekeeper.hivehome.com/1.0/cognito/login",
+            "refresh": "https://beekeeper.hivehome.com/1.0/cognito/refresh-token",
+            "long_lived": "https://api.prod.bgchprod.info/omnia/accessTokens",
+            "base": "https://beekeeper-uk.hivehome.com/1.0",
+            "weather": "https://weather.prod.bgchprod.info/weather",
+            "holiday_mode": "/holiday-mode",
+            "all": "/nodes/all?products=true&devices=true&actions=true",
+            "alarm": "/security-lite?homeId=",
+            "cameraImages": f"https://event-history-service.{self.cameraBaseUrl}/v1/events/cameras?latest=true&cameraId={{0}}",
+            "cameraRecordings": f"https://event-history-service.{self.cameraBaseUrl}/v1/playlist/cameras/{{0}}/events/{{1}}.m3u8",
+            "devices": "/devices",
+            "products": "/products",
+            "actions": "/actions",
+            "nodes": "/nodes/{0}/{1}",
+        }
+        self.timeout = 10
+        self.json_return = {
+            "original": "No response to Hive API request",
+            "parsed": "No response to Hive API request",
+        }
+        self.session = hiveSession
+        self.token = token
+
+    def request(self, type, url, jsc=None, camera=False):
+        """Make API request."""
+        if self.session is not None:
+            if camera:
+                self.headers = {
+                    "content-type": "application/json",
+                    "Accept": "*/*",
+                    "Authorization": f"Bearer {self.session.tokens.tokenData['token']}",
+                    "x-jwt-token": self.session.tokens.tokenData["token"],
+                }
+            else:
+                self.headers = {
+                    "content-type": "application/json",
+                    "Accept": "*/*",
+                    "authorization": self.session.tokens.tokenData["token"],
+                }
+        else:
+            if camera:
+                self.headers = {
+                    "content-type": "application/json",
+                    "Accept": "*/*",
+                    "Authorization": f"Bearer {self.token}",
+                    "x-jwt-token": self.token,
+                }
+            else:
+                self.headers = {
+                    "content-type": "application/json",
+                    "Accept": "*/*",
+                    "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
+            )
+
+    def refreshTokens(self, tokens={}):
+        """Get new session tokens - DEPRECATED NOW BY AWS TOKEN MANAGEMENT."""
+        url = self.urls["refresh"]
+        if self.session is not None:
+            tokens = self.session.tokens.tokenData
+        jsc = (
+            "{"
+            + ",".join(
+                ('"' + str(i) + '": ' '"' + str(t) + '" ' for i, t in tokens.items())
+            )
+            + "}"
+        )
+        try:
+            info = self.request("POST", url, jsc)
+            data = json.loads(info.text)
+            if "token" in data and self.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):
+            self.error()
+
+        return self.json_return
+
+    def getLoginInfo(self):
+        """Get login properties to make the login request."""
+        url = self.urls["properties"]
+        try:
+            data = requests.get(url=url, verify=False, timeout=self.timeout)
+            html = PyQuery(data.content)
+            json_data = json.loads(
+                '{"'
+                + (html("script:first").text())
+                .replace(",", ', "')
+                .replace("=", '":')
+                .replace("window.", "")
+                + "}"
+            )
+
+            loginData = {}
+            loginData.update({"UPID": json_data["HiveSSOPoolId"]})
+            loginData.update({"CLIID": json_data["HiveSSOPublicCognitoClientId"]})
+            loginData.update({"REGION": json_data["HiveSSOPoolId"]})
+            return loginData
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+    def getAll(self):
+        """Build and query all endpoint."""
+        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):
+            self.error()
+
+        return json_return
+
+    def getAlarm(self, homeID=None):
+        """Build and query alarm endpoint."""
+        if self.session is not None:
+            homeID = self.session.config.homeID
+        url = self.urls["base"] + self.urls["alarm"] + homeID
+        try:
+            info = self.request("GET", url)
+            self.json_return.update({"original": info.status_code})
+            self.json_return.update({"parsed": info.json()})
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+        return self.json_return
+
+    def getCameraImage(self, device=None, accessToken=None):
+        """Build and query camera endpoint."""
+        json_return = {}
+        url = self.urls["cameraImages"].format(device["props"]["hardwareIdentifier"])
+        try:
+            info = self.request("GET", url, camera=True)
+            json_return.update({"original": info.status_code})
+            json_return.update({"parsed": info.json()})
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+        return json_return
+
+    def getCameraRecording(self, device=None, eventId=None):
+        """Build and query camera endpoint."""
+        json_return = {}
+        url = self.urls["cameraRecordings"].format(
+            device["props"]["hardwareIdentifier"], eventId
+        )
+        try:
+            info = self.request("GET", url, camera=True)
+            json_return.update({"original": info.status_code})
+            json_return.update({"parsed": info.text.split("\n")[3]})
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+        return json_return
+
+    def getDevices(self):
+        """Call the get devices endpoint."""
+        url = self.urls["base"] + self.urls["devices"]
+        try:
+            response = self.request("GET", url)
+            self.json_return.update({"original": response.status_code})
+            self.json_return.update({"parsed": response.json()})
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+        return self.json_return
+
+    def getProducts(self):
+        """Call the get products endpoint."""
+        url = self.urls["base"] + self.urls["products"]
+        try:
+            response = self.request("GET", url)
+            self.json_return.update({"original": response.status_code})
+            self.json_return.update({"parsed": response.json()})
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+        return self.json_return
+
+    def getActions(self):
+        """Call the get actions endpoint."""
+        url = self.urls["base"] + self.urls["actions"]
+        try:
+            response = self.request("GET", url)
+            self.json_return.update({"original": response.status_code})
+            self.json_return.update({"parsed": response.json()})
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+        return self.json_return
+
+    def motionSensor(self, sensor, fromepoch, toepoch):
+        """Call a way to get motion sensor info."""
+        url = (
+            self.urls["base"]
+            + self.urls["products"]
+            + "/"
+            + sensor["type"]
+            + "/"
+            + sensor["id"]
+            + "/events?from="
+            + str(fromepoch)
+            + "&to="
+            + str(toepoch)
+        )
+        try:
+            response = self.request("GET", url)
+            self.json_return.update({"original": response.status_code})
+            self.json_return.update({"parsed": response.json()})
+        except (OSError, RuntimeError, ZeroDivisionError):
+            self.error()
+
+        return self.json_return
+
+    def getWeather(self, weather_url):
+        """Call endpoint to get local weather from Hive API."""
+        t_url = self.urls["weather"] + weather_url
+        url = t_url.replace(" ", "%20")
+        try:
+            response = self.request("GET", url)
+            self.json_return.update({"original": response.status_code})
+            self.json_return.update({"parsed": response.json()})
+        except (OSError, RuntimeError, ZeroDivisionError, ConnectionError):
+            self.error()
+
+        return self.json_return
+
+    def setState(self, n_type, n_id, **kwargs):
+        """Set the state of a Device."""
+        jsc = (
+            "{"
+            + ",".join(
+                ('"' + str(i) + '": ' '"' + str(t) + '" ' for i, t in kwargs.items())
+            )
+            + "}"
+        )
+
+        url = self.urls["base"] + self.urls["nodes"].format(n_type, n_id)
+
+        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):
+            self.error()
+
+        return self.json_return
+
+    def setAction(self, n_id, data):
+        """Set the state of a Action."""
+        jsc = data
+        url = self.urls["base"] + self.urls["actions"] + "/" + n_id
+        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):
+            self.error()
+
+        return self.json_return
+
+    def error(self):
+        """An error has occurred interacting with the Hive API."""
+        self.json_return.update({"original": "Error making API call"})
+        self.json_return.update({"parsed": "Error making API call"})
+
+
+class UnknownConfig(Exception):
+    """Unknown API config."""