PyNetioConf 0.3.0b1__py3-none-any.whl

PyNetioConf/ESPCore/esp_520_device.py

@@ -0,0 +1,348 @@
+"""
+Implementation specifics for ESP devices with the firmware 5.2.x.
+"""
+
+import atexit
+import io
+import json
+import os
+import ssl
+import sys
+from collections import deque
+from io import BytesIO
+from pathlib import Path
+from time import sleep, time
+
+from ..constants import (
+    DEFAULT_KEEP_ALIVE_QUEUE_LEN,
+    DEFAULT_REQUEST_QUEUE_LEN,
+)
+
+if sys.version_info >= (3, 12):
+    from typing import IO, Any, AnyStr, Dict, List, Tuple, override
+else:
+    from typing import IO, Any, AnyStr, Dict, List, Tuple
+
+    from typing_extensions import override
+
+import logging
+import threading
+
+import websocket
+from websocket import WebSocket
+
+from .. import NetioManager
+from ..exceptions import CommunicationError, ElementNotFound
+from ..netio_device import NETIODevice
+from . import esp_api, ws_api
+from .esp_500_device import ESP500Device
+
+
+class ESP520Device(ESP500Device):
+    """
+    A class to control ESP devices with the firmware 5.2.x.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        username: str,
+        password: str,
+        sn_number: str,
+        hostname: str,
+        keep_alive: bool = True,
+        netio_manager: NetioManager | None = None,
+        use_https: bool = False,
+        **kwargs: Any,
+    ):
+        """
+        The 5.x.x versions of Netio firmware have been severely redesigned which includes the entirety of the API that is used for communication with the device therefore this init is completely separated from the base classes and does not call super().__init__ but instead makes a new class from scratch. If the base NETIODevice class gets updated this has to be done accordingly here.
+
+        Parameters
+        ----------
+        host : str
+
+        username : str
+
+        password : str
+
+        sn_number : str
+
+        hostname : str
+
+         : Any
+
+        keep_alive : bool
+
+        netio_manager : NetioManager | None
+
+        use_https : bool
+
+
+        """
+        self.host = host
+        self.username = username
+        self.password = password
+        self.sn_number = sn_number
+        self.hostname = hostname
+        self.session_id = ""
+        self.supported_features: dict[str, Any] = dict()
+        self.output_count = 4
+        self.user_permissions: list[str] = list()
+        self._keep_alive_flag = keep_alive
+        self.ws_req_id = kwargs.get("ws_req_id", 0)
+        self.use_https = use_https
+        if use_https:
+            from urllib3 import disable_warnings
+            from urllib3.exceptions import InsecureRequestWarning
+
+            disable_warnings(category=InsecureRequestWarning)
+
+        self._request_queue = deque(maxlen=DEFAULT_REQUEST_QUEUE_LEN)
+        self._pong_queue = deque(maxlen=DEFAULT_KEEP_ALIVE_QUEUE_LEN)
+
+        # Init from base ESP Device
+        self.ws: WebSocket | None = kwargs.get("ws_connection", None)
+        self.logger = logging.getLogger(__name__)
+        if kwargs.get("is_ws_auth", False):
+            self.session_id = "TODO AUTH"
+        else:
+            self.session_id = self.login(username, password)
+        # self.supported_features = self.get_features()
+        # self.output_count: int = self.supported_features["outputCount"]
+        # self.user_permissions = self.get_current_user()["privileges"]
+        if keep_alive:
+            self._ka_thread = threading.Timer(120, self._keep_alive)
+            self._ka_thread.daemon = True
+            self._ka_thread.start()
+        atexit.register(self._cleanup)
+
+        # New Init
+        self.ssl_options: dict[str, Any] | None = kwargs.get("ssl_options", dict())
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.netio_manager = netio_manager
+        # self.fw_version = self.get_version()
+
+        _system_info = self.get_system_info()
+        self.output_count = _system_info["outputCount"]
+        self.input_count = _system_info["inputCount"]
+        self.supported_features["wifi"] = _system_info["wifiSupport"]
+        self.supported_features["eth"] = _system_info["ethSupport"]
+
+    # TODO: Handle repeated code for uploading files using chunking
+    @override
+    def upload_mqtt_client_key(self, key: str) -> None:
+        import base64
+
+        ws_type = "SET"
+        ws_topic = "protocols/mqtt/clientkeyupload"
+        ws_data: dict[str, Any] = {}
+
+        self.logger.debug(f"Uploading MQTT client key to device {self.host}.")
+        upload_id = ws_api.send_request(self, ws_type, ws_topic, ws_data)["data"][
+            "uploadId"
+        ]
+        original_bytes = key.encode("utf-8")
+        base64_string = base64.b64encode(original_bytes).decode("utf-8")
+        ws_api.chunk_file_upload(self, base64_string, 0, len(key), len(key), upload_id)
+
+    @override
+    def upload_mqtt_ca_certificate(self, ca: str) -> None:
+        import base64
+
+        ws_type = "SET"
+        ws_topic = "protocols/mqtt/cacertupload"
+        ws_data: dict[str, Any] = {}
+
+        self.logger.debug(f"Uploading MQTT CA certificate to device {self.host}.")
+        upload_id = ws_api.send_request(self, ws_type, ws_topic, ws_data)["data"][
+            "uploadId"
+        ]
+        original_bytes = ca.encode("utf-8")
+        base64_string = base64.b64encode(original_bytes).decode("utf-8")
+        ws_api.chunk_file_upload(self, base64_string, 0, len(ca), len(ca), upload_id)
+
+    @override
+    def upload_mqtt_client_certificate(self, cert: str) -> None:
+        import base64
+
+        ws_type = "SET"
+        ws_topic = "protocols/mqtt/clientcertupload"
+        ws_data: dict[str, Any] = {}
+
+        self.logger.debug(f"Uploading MQTT client certificate to device {self.host}.")
+        upload_id = ws_api.send_request(self, ws_type, ws_topic, ws_data)["data"][
+            "uploadId"
+        ]
+        original_bytes = cert.encode("utf-8")
+        base64_string = base64.b64encode(original_bytes).decode("utf-8")
+        ws_api.chunk_file_upload(
+            self, base64_string, 0, len(cert), len(cert), upload_id
+        )
+
+    @override
+    def update_firmware(self, file: os.PathLike[AnyStr] | BytesIO) -> NETIODevice:
+        # TODO: Implement permission checks
+        # if "can_alter_settings" not in self.user_permissions:
+        #     raise PermissionError(
+        #         "You don't have permission to alter settings on this device."
+        #     )
+        if self._ka_thread:
+            self._ka_thread.cancel()
+            self._ka_thread.join()
+
+        pre_reconnect_wait = 20
+        # TODO: Implement supported_features
+        try:
+            if self.supported_features["wifi"] == "yes":
+                wifi_settings = self.get_wifi_settings()
+                if (
+                    wifi_settings["mode"] == "client"
+                    and wifi_settings["client"]["status"] == "Connected"
+                ):
+                    pre_reconnect_wait = 50
+                    self.logger.debug(
+                        "Increased wait time after fimrware update due to active Wi-Fi connection."
+                    )
+        except KeyError:
+            pre_reconnect_wait = 100
+
+        # TODO: Checnk connectivity
+        # if esp_api.check_connectivity(self) > (pre_reconnect_wait / 10.0):
+        #     pre_reconnect_wait = pre_reconnect_wait * 2
+        #     self.logger.debug(
+        #         "Increased wait time after firmware update due to poor connection quality."
+        #     )
+
+        try:
+            ws_type = "SET"
+            ws_topic = "system/fwupdate"
+            ws_data = {}
+            upload_id = ws_api.send_request(self, ws_type, ws_topic, ws_data)["data"][
+                "uploadId"
+            ]
+
+            if isinstance(file, io.BufferedIOBase):
+                ws_api.upload_file(self, file, upload_id)
+            else:
+                self.logger.debug("Unsupported file format.")
+        except CommunicationError:
+            self.logger.warning(
+                f"Device {self.host} couldn't verify firmware update process beginning, this should be harmless if the device connects, waiting for connection."
+            )
+        self.logger.debug(
+            f"Uploaded firmware, device {self.host} might be unresponsive for a while."
+        )
+
+        # TODO: Sophisticated
+        pre_reconnect_wait = 30
+        sleep(pre_reconnect_wait)
+
+        self.logger.debug(
+            f"Retrying connection to device {self.host} after updating firmware to new version, the device class is now going to update."
+        )
+
+        # TODO: Check connectivity for new FW
+        # device_response_time = esp_api.check_connectivity(self)
+        # retry_limit = 3 if device_response_time == -1 else 0
+        # for _ in range(0, retry_limit):
+        #     device_response_time = esp_api.check_connectivity(self)
+        #
+        # if device_response_time == -1:
+        #     raise CommunicationError(
+        #         "Device couldn't establish connection after firmware update."
+        #     )
+
+        updated_instance = None
+        if type(self.netio_manager) is NetioManager:
+            updated_instance = self.netio_manager.update_device(self, ws_expected=True)
+
+        if isinstance(updated_instance, NETIODevice):
+            self.logger.info(
+                f"The device has updated to {updated_instance.get_version_detailed()}, the device object is now of the {type(updated_instance)} class, check documentation for supported features and changes."
+            )
+
+        if not updated_instance:
+            raise CommunicationError("Coudln't get updated instance.")
+
+        return updated_instance
+
+    @override
+    def import_config(self, file, **kwargs):
+        ws_type = "SET"
+        ws_topic = "system/cfgimport"
+        ws_data = {}
+        upload_id = ws_api.send_request(self, ws_type, ws_topic, ws_data)["data"][
+            "uploadId"
+        ]
+
+        if isinstance(file, io.BufferedIOBase):
+            self.logger.debug(f"Importing configuration to host {self.host}")
+            ws_api.upload_file(self, file, upload_id)
+        elif isinstance(file, str):
+            file_path = Path(file)
+            if file_path.exists():
+                with open(file, "rb") as file:
+                    ws_api.upload_file(self, file, upload_id)
+        else:
+            self.logger.debug("Unsupported file format.")
+
+    @override
+    def ping(self) -> bool:
+        ws_type = "PING"
+        start_time = time()
+        ws_api.send_request(self, ws_type)
+        end_time = time()
+        self.logger.debug(
+            f"Pinging device {self.host} successful. Response time: {end_time - start_time}"
+        )
+        return True
+
+    @override
+    def export_config(self, save_file: str | None = None) -> dict[str, Any]:
+        ws_type = "SET"
+        ws_export_topics_list = [
+            "export/config/inputs",
+            "export/config/network",
+            "export/config/outputs",
+            "export/config/PAB",
+            "export/config/protocols",
+            "export/config/rules",
+            "export/config/schedules",
+            "export/config/system",
+            "export/config/users",
+            "export/config/wdtpingers",
+            "export/config/mqtt",
+            "export/config/nbus",
+        ]
+        ws_data: dict[str, Any] = {}
+
+        config_export: dict[str, Any] = dict()
+
+        for config_group in ws_export_topics_list:
+            self.logger.debug(
+                f"Exporting configuration for {config_group.split('/')[-1]} from device {self.host}"
+            )
+            group_data = ws_api.send_request(self, ws_type, config_group, ws_data).get(
+                "data", {}
+            )
+            config_export |= {config_group.split("/")[-1]: group_data}
+        if save_file is not None:
+            file_path = Path(save_file)
+            if file_path.exists():
+                self.logger.warning("Export config file exists, overriding.")
+                # TODO: Make override a method parameter
+
+            with open(save_file, "w+") as file:
+                conf_string = json.dumps(config_export, ensure_ascii=False, indent=4)
+                file.write(conf_string)
+
+        return config_export
+
+    @override
+    def _keep_alive(self) -> None:
+        self.logger.debug(f"Sending keep-alive to device {self.host}")
+        self._ka_thread = threading.Timer(120, self._keep_alive)
+        self._ka_thread.daemon = True
+        self._ka_thread.start()
+        self.ping()

PyNetioConf/ESPCore/esp_5beta_device.py

@@ -0,0 +1,263 @@
+"""
+Implementation specifics for ESP devices with the firmware 5.0.x.
+"""
+
+import json
+import ssl
+from collections import deque
+from time import sleep
+from typing import Dict, List, Tuple
+
+import websocket
+
+from PyNetioConf.constants import (
+    DEFAULT_KEEP_ALIVE_QUEUE_LEN,
+    DEFAULT_REQUEST_QUEUE_LEN,
+)
+
+from .. import NetioManager
+from ..exceptions import CommunicationError
+from . import esp_api, ws_api
+from .esp_400_device import ESP400Device
+
+
+class ESP5BetaDevice(ESP400Device):
+    """
+    A class to control ESP devices with the firmware 5.0.x BETA.
+
+    DEPRICATED: This beta class will get removed in a future release.
+    WARNING: This release was and never will be fully supported, many features are missing and it is provided only for users who implemented their solution
+    alongside the development of the 5.0.x firmware. If anything doesn't work then please update the firmware of your device first.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        username: str,
+        password: str,
+        sn_number: str,
+        hostname: str,
+        keep_alive: bool = True,
+        netio_manager: NetioManager = None,
+        use_https: bool = False,
+    ):
+        self.use_https = use_https
+        super().__init__(
+            host, username, password, sn_number, hostname, keep_alive, netio_manager
+        )
+
+        # Backporting these to the beta so it can remain compatible with ws_api for as long as possible
+        self._request_queue = deque(maxlen=DEFAULT_REQUEST_QUEUE_LEN)
+        self._pong_queue = deque(maxlen=DEFAULT_KEEP_ALIVE_QUEUE_LEN)
+
+        self.fw_version = self.get_version()
+
+        self._ssl_context = ssl.create_default_context()
+        self._ssl_context.check_hostname = False
+        self._ssl_context.verify_mode = ssl.CERT_NONE
+        if self.use_https:
+            self.ws = websocket.create_connection(
+                f"wss://{host}/emweb", sslopt={"cert_reqs": ssl.CERT_NONE}
+            )
+        else:
+            self.ws = websocket.create_connection(f"ws://{host}/emweb")
+        self.ws_req_id = 0
+        self._login_new(username, password)
+
+    def _login_new(self, username: str, password: str, logout=False) -> str:
+        if self.use_https:
+            self.ws = websocket.create_connection(
+                f"wss://{self.host}/emweb", sslopt={"cert_reqs": ssl.CERT_NONE}
+            )
+        else:
+            self.ws = websocket.create_connection(f"ws://{self.host}/emweb")
+        self.ws_req_id = 0
+        hello_response = ws_api.send_request(self, "HELO")
+
+        ws_api.login(
+            self,
+            hello_response["data"]["localTimestamp"],
+            hello_response["data"]["publicKey"],
+            username,
+            password,
+        )
+
+    def set_output(self, output_id: int, state: bool) -> None:
+        self._check_socket_index(output_id)
+        ws_api.send_request(
+            self,
+            "SET",
+            f"outputs/id/{output_id}/ctrl",
+            {"request": "on" if state else "off"},
+        )
+        self.logger.debug(
+            f"Setting output {output_id} on device {self.host} to {state}."
+        )
+
+    def set_json_api_state(
+        self,
+        protocol_enabled: bool,
+        read_enable: bool = None,
+        write_enable: bool = None,
+        read_auth: tuple[str, str] = None,
+        write_auth: tuple[str, str] = None,
+    ) -> None:
+        old_protocol_data = self.get_json_api_state()
+
+        protocol_data = {
+            "enable": protocol_enabled,
+            "port": 80,
+            "readOnlyEnable": read_enable
+            if read_enable is not None
+            else old_protocol_data["read"]["enable"],
+            "readUsername": read_auth[0]
+            if read_auth is not None
+            else old_protocol_data["read"]["username"],
+            "readPassword": read_auth[1]
+            if read_auth is not None
+            else old_protocol_data["read"]["password"],
+            "readWriteEnable": write_enable
+            if write_enable is not None
+            else old_protocol_data["write"]["enable"],
+            "writeUsername": write_auth[0]
+            if write_auth is not None
+            else old_protocol_data["write"]["username"],
+            "writePassword": write_auth[1]
+            if write_auth is not None
+            else old_protocol_data["write"]["password"],
+        }
+
+        ws_api.send_request(self, "SET", "protocols/json/config", protocol_data)
+
+    def get_output_states(self) -> list[tuple[int, bool]]:
+        socket_list = ws_api.send_request(self, "UNSUBSCRIBE", "outputs/measure")
+        return [
+            (socket["id"], socket["state"] == "on")
+            for socket in socket_list["data"]["items"]
+        ]
+
+    def get_measurement(self):
+        return ws_api.send_request(self, "UNSUBSCRIBE", "outputs/measure")
+
+    def upload_mqtt_client_key(self, key: str) -> None:
+        upload_path = ws_api.send_request(
+            self, "SET", "protocols/mqtt/clientkeyupload", {}
+        )["data"]["uploadPath"]
+        response = esp_api.send_file(self, upload_path, key)
+        sleep(0.1)
+
+    def upload_mqtt_client_certificate(self, cert: str) -> None:
+        upload_path = ws_api.send_request(
+            self, "SET", "protocols/mqtt/clientcertupload", {}
+        )["data"]["uploadPath"]
+        response = esp_api.send_file(self, upload_path, cert)
+        sleep(0.1)
+
+    def upload_mqtt_ca_certificate(self, ca: str) -> None:
+        upload_path = ws_api.send_request(
+            self, "SET", "protocols/mqtt/cacertupload", {}
+        )["data"]["uploadPath"]
+        response = esp_api.send_file(self, upload_path, ca)
+        sleep(0.1)
+
+    def get_mqttflex_state(self) -> dict:
+        return ws_api.send_request(self, "UNSUBSCRIBE", "protocols/mqtt/config")["data"]
+
+    def set_mqttflex_state(self, state: bool, config: dict = None) -> None:
+        if config is None:
+            config = self.get_mqttflex_state()["config"]
+        ws_api.send_request(
+            self,
+            "SET",
+            "protocols/mqtt/config",
+            {"enable": state, "config": json.dumps(config)},
+        )
+        sleep(1)
+
+    def export_config(self, save_file: str = None) -> dict:
+        config = ws_api.send_request(self, "SET", "system/cfgexport", data={})
+        if save_file:
+            with open(save_file, "w") as file:
+                json.dump(config["data"]["config"], file)
+        return config["data"]["config"]
+
+    def import_config(self, file, **kwargs) -> None:
+        if "can_alter_settings" not in self.user_permissions:
+            raise PermissionError(
+                "You don't have permission to alter settings on this device."
+            )
+        if self._ka_thread:
+            self._ka_thread.cancel()
+            self._ka_thread.join()
+        data = json.load(file)
+        encoded_data = json.dumps(data).encode("utf-8")
+        ws_api.send_request(self, "SET", "system/cfgimport", data={})
+        esp_api.send_file(self, "/cfgimport", encoded_data)
+        self.logger.info(
+            f"Imported configuration from {file.name}, device {self.host} is restarting..."
+        )
+        sleep(kwargs.get("sleep_time", 15))
+        username = kwargs.get("username", self.username)
+        password = kwargs.get("password", self.password)
+
+        self._login_new(username, password)
+        if self._ka_thread:
+            self._keep_alive()
+
+    def update_firmware(self, file) -> None:
+        if "can_alter_settings" not in self.user_permissions:
+            raise PermissionError(
+                "You don't have permission to alter settings on this device."
+            )
+        if self._ka_thread:
+            self._ka_thread.cancel()
+            self._ka_thread.join()
+
+        pre_reconnect_wait = 20
+        if self.supported_features["wifi"] == "yes":
+            wifi_settings = self.get_wifi_settings()
+            if (
+                wifi_settings["mode"] == "client"
+                and wifi_settings["client"]["status"] == "Connected"
+            ):
+                pre_reconnect_wait = 50
+                self.logger.debug(
+                    "Increased wait time after fimrware update due to active Wi-Fi connection."
+                )
+
+        if esp_api.check_connectivity(self) > (pre_reconnect_wait / 10.0):
+            pre_reconnect_wait = pre_reconnect_wait * 2
+            self.logger.debug(
+                "Increased wait time after firmware update due to poor connection quality."
+            )
+
+        _ = esp_api.send_request(self, "prepFwUpgrade")
+        _ = esp_api.send_file(self, "/upload/firmware", file)
+        try:
+            _ = esp_api.send_request(self, "startUpgrade", close=True)
+        except CommunicationError:
+            self.logger.warn(
+                f"Device {self.host} couldn't verify firmware update process beginning, this should be harmless if the device connects, waiting for connection."
+            )
+        self.logger.debug(
+            f"Uploaded firmware {file.name}, device {self.host} might be unresponsive for a while."
+        )
+
+        sleep(pre_reconnect_wait)
+
+        self.logger.debug(
+            f"Retrying connection to device {self.host} after updating firmware to {file.name}."
+        )
+        device_response_time = esp_api.check_connectivity(self)
+        retry_limit = 3 if device_response_time == -1 else 0
+        for _ in range(0, retry_limit):
+            device_response_time = esp_api.check_connectivity(self)
+
+        if device_response_time == -1:
+            raise CommunicationError(
+                "Device couldn't establish connection after firmware update."
+            )
+
+        updated_instance = self.netio_manager.update_device(self)
+
+        return updated_instance