Merge pull request #7 from Pyhive/2020.1_code

2020.1 code

Author: Khole

.travis.yml

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

MANIFEST.in

@@ -1,2 +1,27 @@
-"""__init__.py"""
-from .pyhiveapi import Pyhiveapi
+"""__init__.py"""
+from .hive import Hive
+from .hive_session import Session
+from .const import *
+from .helper import HiveHelper
+from .client import Client
+from .hive_api import HiveApi
+from .hive_async_api import HiveAsync
+from .hive_auth_async import HiveAuthAsync
+
+
+def getMessage(__message, __type):
+    """
+    Gets a message
+    """
+    from cryptography.fernet import Fernet
+    import os
+    import json
+
+    __key = open(os.path.dirname(os.path.realpath(
+        __file__)) + "/.info.key", "rb").read()
+    __f = Fernet(__key)
+    __result = __f.decrypt(__message).decode()
+
+    if __type == "JSON":
+        __result = json.loads(__result)
+    return __result

examples/pyhiveapi_example_1.py

@@ -0,0 +1,97 @@
+"""Hive Action Module."""
+from .hive_session import Session
+from .hive_data import Data
+
+
+class Action(Session):
+    """Hive Action Code."""
+    actionType = 'Actions'
+
+    async def get_action(self, device):
+        """Get smart plug current power usage."""
+        await self.logger.log(device["hiveID"], self.actionType, "Getting action data.")
+        dev_data = {}
+
+        if device["hiveID"] in Data.actions:
+            dev_data = {"hiveID": device["hiveID"],
+                        "hiveName": device["hiveName"],
+                        "hiveType": device["hiveType"],
+                        "haName": device["haName"],
+                        "haType": device["haType"],
+                        "status": {
+                            "state": await self.get_state(device)},
+                        "power_usage": None,
+                        "deviceData": {},
+                        "custom": device.get("custom", None)
+                        }
+
+            await self.logger.log(device["hiveID"], self.actionType,
+                                  "action update {0}", info=[dev_data["status"]])
+            Data.ha_devices.update({device['hiveID']: dev_data})
+            return dev_data
+        else:
+            exists = Data.actions.get('hiveID', False)
+            if exists == False:
+                return 'REMOVE'
+            return device
+
+    async def get_state(self, device):
+        """Get action state."""
+        await self.logger.log(device["hiveID"], self.actionType + "_Extra", "Getting state")
+        state = None
+        final = None
+
+        if device["hiveID"] in Data.actions:
+            data = Data.actions[device["hiveID"]]
+            final = data["enabled"]
+            await self.logger.log(device["hiveID"], self.actionType + "_Extra", "Status is {0}", info=[final])
+            if device["hiveID"] in Data.errorList:
+                Data.errorList.pop(device["hiveID"])
+        else:
+            await self.logger.error_check(device["hiveID"], "ERROR", "Failed")
+
+        return final
+
+    async def turn_on(self, device):
+        """Set action turn on."""
+        import json
+        await self.logger.log(device["hiveID"], self.actionType + "_Extra", "Enabling action")
+        final = False
+
+        if device["hiveID"] in Data.actions:
+            await self.hiveRefreshTokens()
+            data = Data.actions[device["hiveID"]]
+            data.update({"enabled": True})
+            send = json.dumps(data)
+            resp = await self.api.set_action(device["hiveID"], send)
+            if resp["original"] == 200:
+                final = True
+                await self.getDevices(device["hiveID"])
+                await self.logger.log(device["hiveID"], "API", "Enabled action - " + device["hiveName"])
+            else:
+                await self.logger.error_check(
+                    device["hiveID"], "ERROR", "Failed_API", resp=resp["original"])
+
+        return final
+
+    async def turn_off(self, device):
+        """Set action to turn off."""
+        import json
+        await self.logger.log(device["hiveID"], self.actionType + "_Extra", "Disabling action")
+        final = False
+
+        if device["hiveID"] in Data.actions:
+            await self.hiveRefreshTokens()
+            data = Data.actions[device["hiveID"]]
+            data.update({"enabled": False})
+            send = json.dumps(data)
+            resp = await self.api.set_action(device["hiveID"], send)
+            if resp["original"] == 200:
+                final = True
+                await self.getDevices(device["hiveID"])
+                await self.logger.log(device["hiveID"], "API", "Disabled action - " + device["hiveName"])
+            else:
+                await self.logger.error_check(
+                    device["hiveID"], "ERROR", "Failed_API", resp=resp["original"])
+
+        return final

pyhiveapi/__init__.py

@@ -0,0 +1,18 @@
+"""Define a client to interact with the Hive APIs."""
+import logging
+from typing import Optional
+
+from aiohttp import ClientSession
+from .hive_async_api import HiveAsync
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_API_VERSION = 1
+
+
+class Client:  # pylint: disable=too-few-public-methods
+    """Define the client."""
+
+    def __init__(self, session: Optional[ClientSession] = None,):
+        """Initialize."""
+        client = HiveAsync(session)

pyhiveapi/action.py

@@ -0,0 +1,3 @@
+"""Constants for Pyhiveapi."""
+PACKAGE_NAME = "Pyhiveapi"
+PACKAGE_DIR = "/pyhiveapi/"

pyhiveapi/client.py

@@ -0,0 +1,89 @@
+"""Custom Logging Module."""
+import logging
+
+from datetime import datetime
+from .hive_data import Data
+from .helper import HiveHelper
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Logger:
+    """Custom Logging Code."""
+
+    @staticmethod
+    async def checkDebugging(enable_debug: list):
+        """Check Logging Active"""
+
+        if len(enable_debug) > 0:
+            Data.debugEnabled = True
+        else:
+            Data.debugEnabled = False
+
+        Data.debugList = enable_debug
+        return Data.debugEnabled
+
+    @staticmethod
+    async def log(n_id, l_type, new_message, **kwargs):
+        """Output new log entry if logging is turned on."""
+        name = HiveHelper.get_device_name(n_id) + ' - '
+        data = kwargs.get("info", [])
+        if "_" in l_type:
+            nxt = l_type.split("_")
+            for i in nxt:
+                if i != "Extra":
+                    if i in Data.debugList and "Extra" in Data.debugList:
+                        l_type = i
+                        break
+
+        if Data.debugEnabled and new_message is not None and any(elem in Data.debugList for elem in [l_type, 'All']):
+            if l_type != "ERROR":
+                logging_data = name + new_message.format(*data)
+                _LOGGER.debug(logging_data)
+
+            try:
+                l_file = open(Data.debugOutFile, "a")
+                l_file.write(
+                    datetime.now().strftime(
+                        "%d-%b-%Y %H:%M:%S")
+                    + " - "
+                    + l_type
+                    + " - "
+                    + name
+                    + " : "
+                    + new_message.format(data)
+                    + "\n"
+                )
+                l_file.close()
+            except FileNotFoundError:
+                pass
+        else:
+            pass
+
+    async def error_check(self, n_id, n_type, error_type, **kwargs):
+        """Error has occurred."""
+        message = None
+        new_data = None
+        result = False
+        name = HiveHelper.get_device_name(n_id)
+
+        if error_type == False:
+            message = "Device offline could not update entity - " + name
+            result = True
+            if n_id not in Data.errorList:
+                _LOGGER.warning(message)
+                Data.errorList.update({n_id: datetime.now()})
+        elif error_type == "Failed":
+            message = "ERROR - No data found for device - " + name
+            result = True
+            if n_id not in Data.errorList:
+                _LOGGER.error(message)
+                Data.errorList.update({n_id: datetime.now()})
+        elif error_type == "Failed_API":
+            new_data = str(kwargs.get("resp"))
+            message = "ERROR - Received {0} response from API."
+            result = True
+            _LOGGER.error(message.format(new_data))
+
+        await self.log(n_id, n_type, message, info=[new_data])
+        return result