aiopapouch 0.2.4__py3-none-any.whl

aiopapouch/__init__.py

@@ -0,0 +1,22 @@
+"""This file is used as a hub for imports."""
+
+from .client import PapouchHTTPClient, PapouchSerialClient
+from .devices import (
+    PapouchDevice,
+    create_network_device,
+    create_serial_device,
+    is_device_supported,
+)
+from .utils import parse_device_location, parse_device_name, parse_device_serial_number
+
+__all__ = [
+    "PapouchDevice",
+    "PapouchHTTPClient",
+    "PapouchSerialClient",
+    "create_network_device",
+    "create_serial_device",
+    "is_device_supported",
+    "parse_device_location",
+    "parse_device_name",
+    "parse_device_serial_number",
+]

aiopapouch/client.py

@@ -0,0 +1,268 @@
+"""This file is used for communicating with the device."""
+
+import asyncio
+import base64
+import logging
+import re
+from typing import Any
+
+import aiohttp
+import defusedxml.ElementTree as defused_ET
+
+from pap_spinel import Packet97, SpinelClient, SpinelError
+
+from .exceptions import DeviceAuthError, DeviceConnectionError, DeviceLogicError
+
+INFO_URL = "is.xml"
+DATA_URL = "fresh.xml"
+SETTINGS_URL = "settings.xml"
+SET_URL = "set.xml"
+SAVE_URL = "save.xml"
+
+ENCODING = "iso-8859-2"
+WEB_MODE_INDEX = 3
+TIMEOUT_REQUEST = 10
+DEFAULT_WEB_PORT = 80
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class PapouchHTTPClient:
+    """API client for communicating with a device via network."""
+
+    def __init__(
+        self,
+        ip_address: str,
+        session: aiohttp.ClientSession,
+        password: str = "",
+        web_port: int = DEFAULT_WEB_PORT,
+    ) -> None:
+        """Constructor for API client."""
+        self.base_url = f"http://{ip_address}:{web_port}/"
+        self.session = session
+        self.ip_address = ip_address
+        self.web_port = web_port
+
+        auth_string = f"admin:{password}" if password != "" else ":"
+        b64_auth = base64.b64encode(auth_string.encode("utf-8")).decode("ascii")
+        self._auth_headers = {"Authorization": f"Basic {b64_auth}"}
+
+    async def _fetch(self, endpoint: str) -> str:
+        raw_xml = await self._send_request("GET", endpoint, context=endpoint)
+        return re.sub(r'\s+xmlns="[^"]+"', "", raw_xml)
+
+    async def fetch_info(self) -> str:
+        """Fetching information about a device."""
+        return await self._fetch(INFO_URL)
+
+    async def fetch_data(self) -> str:
+        """Fetching data about a device."""
+        return await self._fetch(DATA_URL)
+
+    async def fetch_settings(self) -> str:
+        """Fetching settings about a device."""
+        return await self._fetch(SETTINGS_URL)
+
+    async def get_device_info(self) -> tuple[str | None, str | None]:
+        info = await self.fetch_info()
+
+        try:
+            root = defused_ET.fromstring(info)
+        except defused_ET.ParseError:
+            return (None, None)
+
+        heartbeat = None
+        for element in root.iter():
+            if element.tag.endswith("heartbeat"):
+                heartbeat = element
+                break
+
+        if heartbeat is None:
+            return (None, None)
+
+        device_name = heartbeat.attrib.get("device")
+        device_location = heartbeat.attrib.get("location")
+
+        return (device_name, device_location)
+
+    async def get_device_mac(self) -> str:
+        settings = await self.fetch_settings()
+        root = defused_ET.fromstring(settings)
+        box = root.find(".//set[@box='12']")
+
+        if box is not None:
+            return str(box.attrib.get("mac", ""))
+
+        raise DeviceLogicError(
+            f"Device: {self.ip_address} doesn't have a box 12 with MAC address"
+        )
+
+    async def _send_request(
+        self, method: str, endpoint: str, context: str, **kwargs: Any
+    ) -> str:
+
+        timeout = aiohttp.ClientTimeout(total=TIMEOUT_REQUEST)
+
+        headers = kwargs.get("headers", {})
+        if self._auth_headers:
+            headers.update(self._auth_headers)
+        kwargs["headers"] = headers
+
+        try:
+            async with self.session.request(
+                method,
+                self.base_url + endpoint,
+                timeout=timeout,
+                **kwargs,
+            ) as response:
+                if response.status != 200:
+                    if response.status == 401:
+                        raise DeviceAuthError("Invalid password")
+
+                    raise DeviceConnectionError(
+                        f"Failed to send command: {response.status}"
+                    )
+                return await response.text(encoding=ENCODING)
+
+        except (aiohttp.ClientError, TimeoutError) as exception:
+            raise DeviceConnectionError(
+                f"Failed to connect to {context} - {self.ip_address}: {exception}"
+            ) from exception
+
+    async def read_command(
+        self, params: dict, context: str, endpoint: str = SET_URL
+    ) -> str:
+        """Command for communicating with any device by using GET request.
+
+        Parameters are GET queries that will be added to the request.
+        """
+
+        return await self._send_request("GET", endpoint, context, params=params)
+
+    async def write_command(
+        self, payload: str, context: str, endpoint: str = SAVE_URL
+    ) -> str:
+        """Command for communicating with any device by using POST request.
+
+        Data contains the POST payload that will be sent in the request body.
+        Context is a information about the device:
+
+        e.g. f"{self.name} ({self.location})"
+
+        Return response text.
+        """
+
+        return await self._send_request("POST", endpoint, context, data=payload)
+
+    async def get_device_mode(self) -> int:
+        """Function is used for the resolving the mode of the device."""
+        info_xml = await self.fetch_info()
+        root = defused_ET.fromstring(info_xml)
+
+        heartbeat_tag = None
+        for element in root.iter():
+            if element.tag.endswith("heartbeat"):
+                heartbeat_tag = element
+                break
+
+        if heartbeat_tag is not None:
+            mode = heartbeat_tag.attrib.get("mode")
+            if mode is not None:
+                return int(mode)
+
+            device_name = heartbeat_tag.attrib.get("device")
+            if self._check_exceptions_device_web_mode(device_name):
+                return WEB_MODE_INDEX
+
+            _LOGGER.error("Heartbeat tag found, but 'mode' attribute is missing!")
+            return -1
+
+        _LOGGER.error("Response doesn't have heartbeat tag!")
+        return -1
+
+    def _check_exceptions_device_web_mode(self, device_name: str) -> bool:
+        if device_name == "TME":
+            return True
+        return "Papago" in device_name and "ETH" in device_name
+
+
+class PapouchSerialClient:
+    """API client for communicating with a device via RS485."""
+
+    def __init__(self, spinel_client: SpinelClient) -> None:
+        """Constructor for serial API client."""
+        self._spinel_client = spinel_client
+        self.lock = asyncio.Lock()
+
+    async def open(self) -> None:
+        """Open port."""
+        await self._spinel_client.open()
+
+    async def close(self) -> None:
+        """Close port."""
+        await self._spinel_client.close()
+
+    async def write_command(
+        self,
+        addr: int,
+        inst: int,
+        context: str,
+        data: bytes = b"",
+        timeout: float = 2.0,
+    ) -> Packet97:
+        """Write command. Return Spinel97 Packet"""
+        async with self.lock:
+            try:
+                return await self._spinel_client.request(
+                    addr=addr, inst=inst, data=data, timeout=timeout
+                )
+            except SpinelError as err:
+                raise DeviceConnectionError(
+                    f"Device: {context} returned: {err}"
+                ) from err
+
+    async def get_info(self, address: int, context: str) -> Packet97:
+        """Get info in Spinel97 packet. Context is used for error message."""
+        try:
+            return await self._spinel_client.info(address)
+        except SpinelError as err:
+            raise DeviceConnectionError(f"Device: {context} returned: {err}") from err
+
+    async def get_man_data(self, address: int, context: str) -> Packet97:
+        """Get manufacturing data in Spinel97 packet. Context is used for error message."""
+        try:
+            return await self._spinel_client.man_data(address)
+        except SpinelError as err:
+            raise DeviceConnectionError(f"Device: {context} returned: {err}") from err
+
+    async def get_location(self, address: int, context: str) -> Packet97:
+        """Get location in Spinel97 packet. Context is used for error message."""
+        try:
+            return await self._spinel_client.user_data(address)
+        except SpinelError as err:
+            raise DeviceConnectionError(f"Device: {context} returned: {err}") from err
+
+    async def set_address(
+        self, new_address: int, serial_number: str, context: str
+    ) -> None:
+        """Set a new address using serial number. Serial number should have format 0123/45678. Context is used for error message."""
+
+        request_data = new_address.to_bytes(1, byteorder="big")
+
+        prod_part, ser_part = serial_number.split("/")
+
+        product_number = int(prod_part)
+        serial_number = int(ser_part)
+
+        prod_bytes = product_number.to_bytes(2, byteorder="big")
+        ser_bytes = serial_number.to_bytes(2, byteorder="big")
+
+        request_data += prod_bytes
+        request_data += ser_bytes
+
+        try:
+            await self._spinel_client.request(addr=0xFE, inst=0xEB, data=request_data)
+        except SpinelError as err:
+            raise DeviceConnectionError(
+                f"Failed setting a new address to the device: {context} "
+            ) from err

aiopapouch/devices/__init__.py

@@ -0,0 +1,119 @@
+"""This file is used as a hub for imports."""
+
+import logging
+from collections.abc import Callable
+from typing import NamedTuple
+
+from ..client import PapouchHTTPClient, PapouchSerialClient
+from ..utils import parse_device_location, parse_device_name, parse_device_serial_number
+from .base import PapouchDevice
+from .papago import async_setup_network_papago
+from .quido import async_setup_network_quido, async_setup_serial_quido
+from .th2e import async_setup_network_th2e
+from .tht2 import async_setup_serial_tht2
+from .tme import async_setup_network_tme
+
+SERIAL = "serial"
+NETWORK = "network"
+
+_LOGGER = logging.getLogger()
+
+
+class DeviceHandler(NamedTuple):
+    """Represents device handler containing a dictionary of setup functions keyed by connection type."""
+
+    setup_funcs: dict[str, Callable]
+
+
+DEVICE_SETUP_HANDLERS = {
+    "Quido": DeviceHandler({
+        NETWORK: async_setup_network_quido,
+        SERIAL: async_setup_serial_quido,
+    }),
+    "TH2E": DeviceHandler({
+        NETWORK: async_setup_network_th2e,
+    }),
+    "TME": DeviceHandler({
+        NETWORK: async_setup_network_tme,
+    }),
+    "Papago": DeviceHandler({
+        NETWORK: async_setup_network_papago,
+    }),
+    "THT2": DeviceHandler({
+        SERIAL: async_setup_serial_tht2,
+    }),
+}
+
+
+def _get_device_handler(
+    device_name: str | None, device_type: str
+) -> DeviceHandler | None:
+    if not device_name:
+        return None
+
+    for prefix, handler in DEVICE_SETUP_HANDLERS.items():
+        if prefix in device_name and device_type in handler.setup_funcs:
+            return handler
+
+    return None
+
+
+def is_device_supported(device_name: str | None, device_type: str) -> bool:
+    """Check if the extracted device name matches any supported prefix and type of the communication."""
+    return _get_device_handler(device_name, device_type) is not None
+
+
+async def create_network_device(api_client: PapouchHTTPClient) -> PapouchDevice | None:
+    """Create a proper device instance dynamically based on the fetched info.
+
+    Returns None if the device is not supported.
+    """
+
+    device_name, _ = await api_client.get_device_info()
+
+    handler = _get_device_handler(device_name, NETWORK)
+    if not handler:
+        return None
+
+    setup_func = handler.setup_funcs[NETWORK]
+    return await setup_func(api_client)
+
+
+async def create_serial_device(
+    api_client: PapouchSerialClient, address: int
+) -> PapouchDevice | None:
+    """Create a proper serial device instance dynamically based on the fetched info.
+
+    Returns None if the device is not supported.
+
+    Raises DeviceConnectionError.
+    """
+
+    pkt_man_data = await api_client.get_man_data(
+        address, f"Unknown device with {address} address"
+    )
+
+    serial_number = parse_device_serial_number(pkt_man_data.data)
+
+    pkt_info = await api_client.get_info(address, serial_number)
+    device_name = parse_device_name(pkt_info.data)
+
+    raw_location = await api_client.get_location(
+        address, f"{device_name} - SN: {serial_number}"
+    )
+    location = parse_device_location(raw_location.data)
+
+    handler = _get_device_handler(device_name, SERIAL)
+    if not handler:
+        return None
+
+    setup_func = handler.setup_funcs[SERIAL]
+    return await setup_func(api_client, address, serial_number, device_name, location)
+
+
+__all__ = [
+    "PapouchDevice",
+    "create_network_device",
+    "create_serial_device",
+    "is_device_supported",
+]