tinytoolslib 0.2.5__tar.gz

tinytoolslib-0.2.5/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: tinytoolslib
+Version: 0.2.5
+Summary: Set of tools for use with Tinycontrol devices like LK2.X, LK3.X, LK4.X or tcPDU.
+Author-email: Bartek Barszczewski <tinycontrol.software@gmail.com>
+Keywords: tinycontrol,lk,tcpdu
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp<4,>=3.9.3
+Requires-Dist: netifaces<1,>=0.11.0
+Requires-Dist: requests<3,>=2.31.0
+Requires-Dist: tftpy<1,>=0.8.2
+
+# tinyToolsLib
+
+Set of tools for use with tinycontrol devices like LK2.X, LK3.X, LK4.X or tcPDU.
+
+## Features
+
+Easy to use functions for common actions with tinycontrol devices:
+
+- Flashing firmware via TFTP (LK2.X, LK3.X).
+- Flashing firmware via HTTP (LK4, tcPDU).
+- Getting data from devices.
+- Sending commands to devices (for common tasks like controlling OUTs, PWMs, etc.).
+- Checking device version.
+
+## Usage
+
+Discovering devices in network:
+
+```py
+from tinytoolslib.discovery import run_discovery_all
+
+devices = run_discovery_all()
+for device in devices:
+    print('{ip_address:20}{name:20}{mac_address:20}{family:10}{hardware_version:10}{software_version:15}'.format_map(device))
+```
+
+Flashing firmware:
+
+```py
+from tinytoolslib.flash import get_latest_firmware, Flasher
+
+success, data = get_latest_firmware(IP_ADDRESS, USERNAME, PASSWORD, DIRECTORY_FOR_FIRMWARE_FILES)
+if success:
+    flasher = Flasher()
+    success = flasher.run(data['path'], IP_ADDRESS, USERNAME, PASSWORD)
+```
+
+Working with tinycontrol devices:
+
+```py
+from tinytoolslib.models import get_version
+
+version_info = get_version(IP_ADDRESS, with_device=True)
+if version_info:
+    device_model = version_info['device_model']
+    # Get reading from device
+    device_model.get_all()
+    # Control outputs OUT
+    device_model.set_out(1, 1)
+```
+
+## File structure
+
+- constants.py - constants related to tinycontrol devices.
+- discovery.py - functions for discovering devices in network via UDP broadcast. Works for LK2.X, LK3.5 SW 1.26+, LK4.0, tcPDU.
+- exceptions.py - errors raised in this library.
+- flash.py - functions for updating the firmware of devices. Includes both method: TFTP and HTTP.
+- models.py - models for working with different device types.
+- parsers.py - functions for working with data formats used on LKs.
+- requests.py - base request functions.

tinytoolslib-0.2.5/README.md

@@ -0,0 +1,60 @@
+# tinyToolsLib
+
+Set of tools for use with tinycontrol devices like LK2.X, LK3.X, LK4.X or tcPDU.
+
+## Features
+
+Easy to use functions for common actions with tinycontrol devices:
+
+- Flashing firmware via TFTP (LK2.X, LK3.X).
+- Flashing firmware via HTTP (LK4, tcPDU).
+- Getting data from devices.
+- Sending commands to devices (for common tasks like controlling OUTs, PWMs, etc.).
+- Checking device version.
+
+## Usage
+
+Discovering devices in network:
+
+```py
+from tinytoolslib.discovery import run_discovery_all
+
+devices = run_discovery_all()
+for device in devices:
+    print('{ip_address:20}{name:20}{mac_address:20}{family:10}{hardware_version:10}{software_version:15}'.format_map(device))
+```
+
+Flashing firmware:
+
+```py
+from tinytoolslib.flash import get_latest_firmware, Flasher
+
+success, data = get_latest_firmware(IP_ADDRESS, USERNAME, PASSWORD, DIRECTORY_FOR_FIRMWARE_FILES)
+if success:
+    flasher = Flasher()
+    success = flasher.run(data['path'], IP_ADDRESS, USERNAME, PASSWORD)
+```
+
+Working with tinycontrol devices:
+
+```py
+from tinytoolslib.models import get_version
+
+version_info = get_version(IP_ADDRESS, with_device=True)
+if version_info:
+    device_model = version_info['device_model']
+    # Get reading from device
+    device_model.get_all()
+    # Control outputs OUT
+    device_model.set_out(1, 1)
+```
+
+## File structure
+
+- constants.py - constants related to tinycontrol devices.
+- discovery.py - functions for discovering devices in network via UDP broadcast. Works for LK2.X, LK3.5 SW 1.26+, LK4.0, tcPDU.
+- exceptions.py - errors raised in this library.
+- flash.py - functions for updating the firmware of devices. Includes both method: TFTP and HTTP.
+- models.py - models for working with different device types.
+- parsers.py - functions for working with data formats used on LKs.
+- requests.py - base request functions.

tinytoolslib-0.2.5/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tinytoolslib"
+version = "0.2.5"
+authors = [
+    { name="Bartek Barszczewski", email="tinycontrol.software@gmail.com" },
+]
+description = "Set of tools for use with Tinycontrol devices like LK2.X, LK3.X, LK4.X or tcPDU."
+requires-python = ">=3.7"
+classifiers = [
+   "Programming Language :: Python :: 3",
+   "Operating System :: OS Independent",
+   "License :: OSI Approved :: Apache Software License",
+]
+dependencies = [
+   "aiohttp >= 3.9.3, < 4",
+   "netifaces >= 0.11.0, < 1",
+   "requests >= 2.31.0, < 3",
+   "tftpy >= 0.8.2, < 1",
+]
+readme = "README.md"
+keywords = ["tinycontrol", "lk", "tcpdu"]
+
+[tool.setuptools.packages]
+find = {}

tinytoolslib-0.2.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tinytoolslib-0.2.5/tinytoolslib/__init__.py

@@ -0,0 +1 @@
+from .__version__ import __version__

tinytoolslib-0.2.5/tinytoolslib/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.2.5'

tinytoolslib-0.2.5/tinytoolslib/constants.py

@@ -0,0 +1,14 @@
+"""Constants related to tinycontrol devices."""
+
+# Discovery related stuff
+LK_UDP_PORT = 30403
+LK_UDP_BOOTLOADER_MSG = b"\x12\xf4\x81"
+LK_UDP_DISCOVERY_MSG = b"Discovery: Who is out there?"
+
+# Device families. PS and DCDC are pretty much the same as LK (UI differs)
+FAMILY_LK = "LK"
+FAMILY_PS = "PS"  # Power socket
+FAMILY_DCDC = "DCDC"  # Converter DC/DC
+FAMILY_TCPDU = "tcPDU"
+
+FW_URL_TEMPLATE = "https://tinycontrol.pl/firmware/{}/latest/"

tinytoolslib-0.2.5/tinytoolslib/discovery.py

@@ -0,0 +1,167 @@
+import concurrent.futures
+import logging
+import socket
+import socketserver
+import threading
+import time
+
+import netifaces
+
+from tinytoolslib.constants import LK_UDP_DISCOVERY_MSG, LK_UDP_PORT
+from tinytoolslib.models import detect_version, get_device_info
+
+
+def get_ips():
+    """Return list of IPs to check."""
+    try:
+        gateways = netifaces.gateways()
+        interfaces = []
+        for key, value in gateways.items():
+            if key != "default":
+                for item in value:
+                    interfaces.append(item[1])
+        addresses = set()
+        for interface in interfaces:
+            addresses_tmp = netifaces.ifaddresses(interface).get(2)
+            if addresses_tmp:
+                for addr in addresses_tmp:
+                    addresses.add(addr["addr"])
+    except ValueError:
+        addresses = socket.gethostbyname_ex(socket.gethostname())[2]
+    return addresses
+
+
+def run_discovery_single(address, timelimit=3):
+    """Run discovery for given address (tuple) in timelimit."""
+    devices = []
+    with DiscoveryServer(address, DiscoveryHandler) as server:
+        server_thread = threading.Thread(target=server.serve_forever)
+        server_thread.start()
+        time.sleep(timelimit)
+        server.shutdown()
+        devices = server.devices.copy()
+        del server_thread
+    return devices
+
+
+def serve_forever(server):
+    """Wrapper for serve_forever method of server."""
+    server.serve_forever()
+
+
+def run_discovery_all(timelimit=3, port=LK_UDP_PORT, version=2, addresses=None):
+    """Run discovery on all available addresses.
+
+    `version` - 1 and 2 are parallel, where time execution of 2
+    is closer to timelimit; 3 is sequential run;
+    """
+    if addresses is None:
+        addresses = [ip for ip in get_ips() if not ip.startswith("169.254")]
+    devices = []
+    if version == 1:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            servers = [
+                DiscoveryServer((address, port), DiscoveryHandler)
+                for address in addresses
+            ]
+            executor.map(serve_forever, servers)
+            time.sleep(timelimit)
+            for server in servers:
+                server.shutdown()
+                devices.extend(server.devices)
+    elif version == 2:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            servers = [
+                DiscoveryServerAuto(
+                    (address, port), DiscoveryHandler, timelimit=timelimit
+                )
+                for address in addresses
+            ]
+            futures = {
+                executor.submit(server.serve_forever): server for server in servers
+            }
+            for future in concurrent.futures.as_completed(futures):
+                try:
+                    data = future.result()
+                except Exception as exc:
+                    logging.warning("discovery error: %s", str(exc))
+                else:
+                    devices.extend(data)
+    else:
+        for address in addresses:
+            temp = run_discovery_single((address, port))
+            devices.extend(temp)
+    return devices
+
+
+class DiscoveryHandler(socketserver.BaseRequestHandler):
+    """Handler for LK discovery server."""
+
+    def handle(self):
+        data = self.request[0].strip()
+        if self.server.server_address[0] != self.client_address[0]:
+            try:
+                device_response = data.decode(errors="ignore").splitlines()
+                device_data = {
+                    "ip_address": self.client_address[0],
+                    "name": device_response[0],
+                    "mac_address": device_response[1].replace("-", ":"),
+                    "software_version": None,
+                    "hardware_version": None,
+                }
+                if len(device_response) == 4:
+                    device_data["software_version"] = device_response[2]
+                    device_data["hardware_version"] = device_response[3]
+                else:
+                    # LK2.0/2.5 response do not include hardware_version, so detect it.
+                    device_data["software_version"] = device_response[2][:-1]
+                    device_data["hardware_version"] = detect_version(
+                        device_data["software_version"]
+                    )
+                device_data.update(
+                    get_device_info(
+                        device_data["hardware_version"],
+                        device_data["software_version"],
+                        asdict_=True,
+                    )
+                )
+                self.server.devices.append(device_data)
+            except (UnicodeDecodeError, IndexError):
+                pass
+
+
+class DiscoveryServer(socketserver.UDPServer):
+    """Server for finding LKs in networks."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.devices = []
+
+    def server_activate(self):
+        """Send discovery message after activation."""
+        super().server_activate()
+        dst_ip = ".".join(self.server_address[0].split(".")[:3]) + ".255"
+        dst_port = self.server_address[1]
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        self.socket.sendto(LK_UDP_DISCOVERY_MSG, (dst_ip, dst_port))
+
+
+class DiscoveryServerAuto(DiscoveryServer):
+    """DiscoveryServer that autmatically shuts down."""
+
+    def __init__(self, *args, **kwargs):
+        self.started_at = time.time()
+        self.timelimit = kwargs.pop("timelimit", 3)
+        super().__init__(*args, **kwargs)
+
+    def service_actions(self):
+        super().service_actions()
+        now = time.time()
+        if now - self.started_at >= self.timelimit:
+            if not self._BaseServer__shutdown_request:
+                self._BaseServer__shutdown_request = True
+
+    def serve_forever(self, *args, **kwargs):
+        """Return devices list after auto shutdown."""
+        super().serve_forever(*args, **kwargs)
+        return self.devices

tinytoolslib-0.2.5/tinytoolslib/exceptions.py

@@ -0,0 +1,49 @@
+"""Exceptions for tinyToolsLib."""
+
+
+class TinyToolsError(Exception):
+    """Generic tinyTools exception."""
+
+
+class TinyToolsUnsupported(TinyToolsError):
+    """Unsupported action of tinycontrol device."""
+
+
+# region Request related errors
+class TinyToolsRequestError(TinyToolsError):
+    """Base exception for request errors."""
+
+
+class TinyToolsRequestTimeout(TinyToolsRequestError):
+    """Request timed out while trying to connect to server."""
+
+
+class TinyToolsRequestConnectionError(TinyToolsRequestError):
+    """Connection error occurred."""
+
+
+class TinyToolsRequestSSLError(TinyToolsRequestConnectionError):
+    """An SSL error occurred."""
+
+
+class TinyToolsRequestHTTPError(TinyToolsRequestError):
+    """HTTP error occurred while handling request(HTTP 4xx/5xx)."""
+
+
+class TinyToolsRequestUnauthenticated(TinyToolsRequestHTTPError):
+    """Request requires authentication or is invalid (HTTP 401)."""
+
+
+class TinyToolsRequestNotFound(TinyToolsRequestHTTPError):
+    """Server could not find the requested resource (HTTP 404)."""
+
+
+class TinyToolsRequestInternalServerError(TinyToolsRequestHTTPError):
+    """Server has encountered a situation it does not know how to handle. (HTTP 500)."""
+
+
+# endregion
+
+
+class TinyToolsFlashError(TinyToolsError):
+    """tinyTools flashing exception."""