tinytoolslib 0.2.5__tar.gz → 0.3.2__tar.gz

tinytoolslib-0.3.2/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: tinytoolslib
+Version: 0.3.2
+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
+
+Usage is described in documentation.
+
+## Documentation
+
+Documentation is available at <https://tinycontrol-software.gitlab.io/tinytoolslib/>

tinytoolslib-0.3.2/README.md

@@ -0,0 +1,21 @@
+# 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
+
+Usage is described in documentation.
+
+## Documentation
+
+Documentation is available at <https://tinycontrol-software.gitlab.io/tinytoolslib/>

{tinytoolslib-0.2.5 → tinytoolslib-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tinytoolslib"
-version = "0.2.5"
+version = "0.3.2"
 authors = [
     { name="Bartek Barszczewski", email="tinycontrol.software@gmail.com" },
 ]

tinytoolslib-0.3.2/tinytoolslib/__init__.py

@@ -0,0 +1,4 @@
+from .__version__ import __version__
+from .models import get_device, get_version
+from .discovery import run_discovery
+from .flash import run_flash, check_for_latest_firmware, get_latest_firmware

tinytoolslib-0.3.2/tinytoolslib/__version__.py

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

tinytoolslib-0.3.2/tinytoolslib/constants.py

@@ -0,0 +1,40 @@
+"""Constants related to tinycontrol devices."""
+
+from enum import Enum
+
+
+LK_UDP_PORT = 30403
+"""Port for UDP commands"""
+
+LK_UDP_DISCOVERY_MSG = b"Discovery: Who is out there?"
+"""Message for Discovery query"""
+
+LK_UDP_BOOTLOADER_MSG = b"\x12\xf4\x81"
+"""Message for starting bootloader/restart device"""
+
+
+FW_URL_TEMPLATE = "https://tinycontrol.pl/firmware/{}/latest/"
+"""URL format for getting information about firmware from tinycontrol.pl"""
+
+
+class FWUpdateMethod(str, Enum):
+    """Method used for updating FW.
+
+    HTTP - for LK4, tcPDU (generally ESP32 based ones)
+    TFTP - for LK3.5, LK3, LK2.5, LK2
+    """
+
+    TFTP = "TFTP"
+    HTTP = "HTTP"
+
+
+class DeviceFamily(str, Enum):
+    """Device families.
+
+    PS and DCDC are pretty much the same as LK (UI differs)
+    """
+
+    LK = "LK"
+    PS = "PS"  # Power socket
+    DCDC = "DCDC"  # Converter DC/DC
+    TCPDU = "tcPDU"

{tinytoolslib-0.2.5 → tinytoolslib-0.3.2}/tinytoolslib/discovery.py

@@ -1,99 +1,20 @@
+"""Discovery function for finding tinycontrol devices in the network.
+
+Works with LK4, tcPPDU, LK3.5 SW 1.26+, LK2.5, LK2.0.
+"""
+
 import concurrent.futures
 import logging
 import socket
 import socketserver
-import threading
 import time
-
+from typing import Any, Dict, List, Set, Union
 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."""
 
@@ -147,21 +68,71 @@ class DiscoveryServer(socketserver.UDPServer):
 
 
 class DiscoveryServerAuto(DiscoveryServer):
-    """DiscoveryServer that autmatically shuts down."""
+    """DiscoveryServer that automatically shuts down."""
 
     def __init__(self, *args, **kwargs):
-        self.started_at = time.time()
-        self.timelimit = kwargs.pop("timelimit", 3)
+        self.started_at: float = time.time()
+        """float: Timestamp of when discovery server started"""
+        self.time_limit: float = kwargs.pop("time_limit", 3)
+        """float: Limit of time for how long should discovery server run"""
         super().__init__(*args, **kwargs)
 
     def service_actions(self):
+        """Checks if should stop the server due to time_limit."""
         super().service_actions()
         now = time.time()
-        if now - self.started_at >= self.timelimit:
-            if not self._BaseServer__shutdown_request:
-                self._BaseServer__shutdown_request = True
+        if now - self.started_at >= self.time_limit:
+            if not getattr(self, "_BaseServer__shutdown_request"):
+                setattr(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
+
+
+def get_ips() -> Set[str]:
+    """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(
+    time_limit: int = 3,
+    port: int = LK_UDP_PORT,
+    addresses: Union[List[str], None] = None,
+) -> List[Dict[str, Any]]:
+    """Run discovery on all available addresses or given one."""
+    if addresses is None:
+        addresses = [ip for ip in get_ips() if not ip.startswith("169.254")]
+    devices = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+        servers = [
+            DiscoveryServerAuto(
+                (address, port), DiscoveryHandler, time_limit=time_limit
+            )
+            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)
+    return devices