simple_keenetic_client 0.1.1__tar.gz

simple_keenetic_client-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Leonid Amirov
+
+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.

simple_keenetic_client-0.1.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: simple_keenetic_client
+Version: 0.1.1
+Summary: Client for KeeneticOS-based routers via HTTP interface
+License: MIT
+Author: Leonid Amirov
+Author-email: leonid.amirov@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiohttp (>=3.11.7,<4.0.0)
+Project-URL: repository, https://github.com/side2k/simple-keenetic-client
+Description-Content-Type: text/markdown
+
+# Simple Keenetic client
+
+HTTP client for KeeneticOS-based routers. Uses web interface to connect.
+Does not do more than authenticate, fetch SMS messages and mark them as read or delete them.
+
+Example usage:
+
+```python
+from simple_keenetic_client import SimpleKeeneticClient
+
+async def get_unread_sms():
+  async with SimpleKeeneticClient(
+      "http://keenetic-router.test",
+      username="testuser",
+      password="testpassword",
+  ) as client:
+      interfaces = await client.get_mobile_interfaces()
+
+      return await self.get_unread_sms(
+          interface_names=interfaces.keys()
+      )
+```
+
+"Real life" usage example: https://github.com/side2k/keensms2mqtt
+

simple_keenetic_client-0.1.1/README.md

@@ -0,0 +1,24 @@
+# Simple Keenetic client
+
+HTTP client for KeeneticOS-based routers. Uses web interface to connect.
+Does not do more than authenticate, fetch SMS messages and mark them as read or delete them.
+
+Example usage:
+
+```python
+from simple_keenetic_client import SimpleKeeneticClient
+
+async def get_unread_sms():
+  async with SimpleKeeneticClient(
+      "http://keenetic-router.test",
+      username="testuser",
+      password="testpassword",
+  ) as client:
+      interfaces = await client.get_mobile_interfaces()
+
+      return await self.get_unread_sms(
+          interface_names=interfaces.keys()
+      )
+```
+
+"Real life" usage example: https://github.com/side2k/keensms2mqtt

simple_keenetic_client-0.1.1/pyproject.toml

@@ -0,0 +1,46 @@
+[tool.poetry]
+name = "simple_keenetic_client"
+version = "0.1.1"
+description = "Client for KeeneticOS-based routers via HTTP interface"
+authors = ["Leonid Amirov <leonid.amirov@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+aiohttp = "^3.11.7"
+
+
+[tool.poetry.group.dev.dependencies]
+black = "^24.10.0"
+flake8 = "^7.1.1"
+isort = "^5.13.2"
+pytest = "^8.3.3"
+pytest-asyncio = "^0.24.0"
+pytest-mock = "^3.14.0"
+
+[tool.poetry.urls]
+repository = "https://github.com/side2k/simple-keenetic-client"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 95
+target-version = ['py311']
+exclude = '''
+/(
+    \.eggs
+  | \.git
+  | \.mypy_cache
+  | \.venv
+  | _build
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = 'black'
+line_length = 95

simple_keenetic_client-0.1.1/src/simple_keenetic_client/__init__.py

@@ -0,0 +1,150 @@
+import json
+import logging
+from hashlib import md5, sha256
+from urllib.parse import urljoin
+
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleKeeneticClient:
+    is_authenticated = False
+
+    def __init__(self, base_url, username, password):
+        self._base_url = base_url
+        self._username = username
+        self._password = password
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        logger.warning("Exiting keenetic loop")
+        await self.close()
+
+    async def connect(self):
+        logger.debug("Connecting to {self._base_url}")
+        self._session = aiohttp.ClientSession()
+        await self.login(self._username, self._password)
+
+    async def close(self):
+        if self.is_authenticated:
+            await self.logout()
+        await self._session.close()
+
+    def get_url(self, path):
+        return urljoin(self._base_url, path)
+
+    def get_headers(self, extra_headers):
+        headers = {"Content-Type": "application/json"}
+        if extra_headers:
+            headers.update(extra_headers)
+
+        return headers
+
+    async def get(self, path, extra_headers=None):
+        return await self._session.get(
+            self.get_url(path), headers=self.get_headers(extra_headers)
+        )
+
+    async def post(self, path, data, extra_headers=None):
+        url = self.get_url(path)
+        serialized_data = json.dumps(data) if data else None
+        logger.debug(f"POST {url}: {serialized_data}")
+        return await self._session.post(
+            url,
+            data=serialized_data,
+            headers=self.get_headers(extra_headers),
+        )
+
+    def prepare_auth_data(self, username, password, realm, challenge):
+        hash1 = md5(f"{username}:{realm}:{password}".encode("utf-8"))
+        hash2 = sha256(f"{challenge}{hash1.hexdigest()}".encode("utf-8"))
+
+        return {"login": username, "password": hash2.hexdigest()}
+
+    async def login(self, username, password):
+        challenge_response = await self.get("/auth")
+        auth_params = challenge_response.headers.get("WWW-Authenticate")
+        if not auth_params:
+            raise Exception(
+                "No 'WWW-Authenticate' header in /auth response - is it really a "
+                "Keenetic device?"
+            )
+
+        [auth_method, auth_method_params] = auth_params.split(" ", maxsplit=1)
+        if auth_method != "x-ndw2-interactive":
+            raise Exception(f"This client doesn't support {auth_method=} (hopefully, yet!)")
+
+        realm = challenge_response.headers.get("X-NDM-Realm")
+        challenge = challenge_response.headers.get("X-NDM-Challenge")
+
+        auth_data = self.prepare_auth_data(username, password, realm, challenge)
+
+        auth_response = await self.post("/auth", data=auth_data)
+        auth_response.raise_for_status()
+
+        control_response = await self.get("/auth")
+
+        control_response.raise_for_status()
+        self.is_authenticated = True
+
+    async def logout(self):
+        url = self.get_url("/auth")
+        logger.debug(f"DELETE {url}")
+        response = await self._session.delete(url)
+        response.raise_for_status()
+        self.is_authenticated = False
+
+    async def rci_interface(self):
+        response = await self.get("/rci/interface")
+        response.raise_for_status()
+        return await response.json()
+
+    async def get_interfaces(self):
+        response = await self.post("/rci/", data={"show": {"interface": {}}})
+        response.raise_for_status()
+        return await response.json()
+
+    def _is_mobile_interface(self, if_data):
+        return "Mobile" in if_data.get("traits", [])
+
+    async def get_mobile_interfaces(self):
+        rci_data = await self.get_interfaces()
+        return {
+            if_name: if_data
+            for if_name, if_data in rci_data["show"]["interface"].items()
+            if self._is_mobile_interface(if_data)
+        }
+
+    async def get_sms_by_interface(self, interface_name):
+        response = await self.post(
+            "/rci/", data={"sms": {"interface": interface_name, "list": {}}}
+        )
+        return await response.json()
+
+    async def mark_sms_as_read(self, interface_name: str, msg_ids: list[str]):
+        response = await self.post(
+            "/rci/",
+            data={
+                "sms": {
+                    "interface": interface_name,
+                    "read": [{"id": msg_id} for msg_id in msg_ids],
+                }
+            },
+        )
+        return await response.json()
+
+    async def delete_sms(self, interface_name: str, msg_ids: list[str]):
+        response = await self.post(
+            "/rci/",
+            data={
+                "sms": {
+                    "interface": interface_name,
+                    "delete": [{"id": msg_id} for msg_id in msg_ids],
+                }
+            },
+        )
+        return await response.json()