tinytoolslib 0.2.5__py3-none-any.whl

tinytoolslib/parsers.py

@@ -0,0 +1,86 @@
+from datetime import datetime
+from functools import lru_cache
+
+
+def parse_version(data):
+    """Parse version info from data."""
+    hw = None
+    sw = None
+    if "ver" in data:
+        # LK2.X
+        hw = "2." + data.get("hw")
+        sw = data.get("ver")
+    elif "sw" in data:
+        # LK3.X
+        hw = data.get("hw")
+        sw = data.get("sw")
+    elif "hardwareVersion" in data:
+        hw = data.get("hardwareVersion")
+        sw = data.get("softwareVersion")
+    return {
+        "hardware_version": hw,
+        "software_version": sw,
+    }
+
+
+def int_inverted(value):
+    """Invert 0/1 value."""
+    return int(not int(value))
+
+
+def up_to_int(value):
+    """Convert text 'up' to 1 for LK2.5"""
+    if value == "up":
+        return 1
+    return 0
+
+
+def float_div10(value):
+    """Convert string number to float divided by 10"""
+    return float(value) / 10
+
+
+def float_div100(value):
+    """Convert string number to float divided by 100"""
+    return float(value) / 100
+
+
+def float_div1000(value):
+    """Convert string number to float divided by 1000"""
+    return float(value) / 1000
+
+
+def str_datetime(value):
+    """Convert string timestamp to datetime"""
+    return datetime.fromtimestamp(int(value))
+
+
+def strint_to_int_list(length):
+    """Convert string with number to list of ints (one for bit)"""
+    return lambda x: list(
+        reversed([int(item) for item in bin(int(x)).lstrip("-0b").zfill(length)])
+    )
+
+
+def strdot_to_int_list(value):
+    """Convert string with numbers divided with '*' to list of ints"""
+    return [int(item) for item in value.split("*")]
+
+
+def int_mul(value, multiplier):
+    """Multiply value and return int."""
+    return int(value * multiplier)
+
+
+def name_list(name, count, start=1):
+    """Return list of names with included index."""
+    tag = "{}"
+    if tag not in name:
+        name = name + tag
+    return [name.format(i) for i in range(start, start + count)]
+
+
+@lru_cache(None)
+def list_map(type_):
+    """Return function for mapping list items to given type."""
+    return lambda x: list(map(type_, x))

tinytoolslib/requests.py

@@ -0,0 +1,268 @@
+import json
+from typing import Union
+import socket
+from xml.etree import ElementTree
+import requests
+from functools import wraps
+import asyncio
+from .exceptions import (
+    TinyToolsRequestConnectionError,
+    TinyToolsRequestError,
+    TinyToolsRequestHTTPError,
+    TinyToolsRequestInternalServerError,
+    TinyToolsRequestNotFound,
+    TinyToolsRequestSSLError,
+    TinyToolsRequestTimeout,
+    TinyToolsRequestUnauthenticated,
+)
+from aiohttp import (
+    ClientSession,
+    BasicAuth,
+    ClientTimeout,
+    ClientConnectionError,
+    ClientConnectorCertificateError,
+    ClientOSError,
+    ClientResponseError,
+    InvalidURL,
+    ServerDisconnectedError,
+)
+
+
+DEFAULT_TIMEOUT = 3
+DEFAULT_RETRIES = 1
+
+
+def _parse_parameters(
+    host, path, schema, port, username, password, timeout, retries, verify
+):
+    """Parse parameters for request - url, auth, timeout."""
+    # Small modification to also handle general purpose requests
+    if (host.startswith("http://") or host.startswith("https://")) and path is None:
+        url = host
+        # Always verify when given complete URL
+        verify = True
+    else:
+        url = f"{schema}://{host}:{port}{path}"
+        if verify is None:
+            # Disable ssl verification for tinycontrol devices, which by default use insecure
+            # certificates, so they can be easily handled with library.
+            verify = schema != "https"
+    if username:
+        auth = (username, password)
+    else:
+        auth = None
+    if timeout is None:
+        timeout = DEFAULT_TIMEOUT
+    if retries is None:
+        retries = DEFAULT_RETRIES
+    return url, auth, timeout, retries, verify
+
+
+def _handle_errors(exc, response=None):
+    """Handle errors for request.
+
+    Unifies errors for asyncio and basic version.
+    """
+    try:
+        raise exc
+    except (requests.exceptions.ConnectTimeout, asyncio.TimeoutError) as exc:
+        raise TinyToolsRequestTimeout("Timed out") from exc
+    except (requests.exceptions.SSLError, ClientConnectorCertificateError) as exc:
+        raise TinyToolsRequestSSLError("SSL error") from exc
+    except (
+        requests.exceptions.ConnectionError,
+        ClientConnectionError,
+        socket.gaierror,
+    ) as exc:
+        raise TinyToolsRequestConnectionError("Connection error") from exc
+    except (requests.exceptions.InvalidURL, InvalidURL) as exc:
+        raise TinyToolsRequestError("Invalid URL") from exc
+    except (requests.exceptions.HTTPError, ClientResponseError) as exc:
+        if hasattr(response, "status_code"):
+            status_code = response.status_code
+        else:  # For aiohttp it will be status
+            status_code = response.status
+        if status_code == 401:
+            raise TinyToolsRequestUnauthenticated("Authentication error") from exc
+        elif status_code == 404:
+            raise TinyToolsRequestNotFound("Not found") from exc
+        elif status_code == 500:
+            raise TinyToolsRequestInternalServerError("Server error") from exc
+        else:
+            raise TinyToolsRequestHTTPError(f"HTTP {status_code} error") from exc
+    except Exception as exc:
+        raise TinyToolsRequestError("Unexpected request error") from exc
+
+
+def _handle_content(content_type, content, response):
+    """Handle response content and pack it into TinyToolsResponse."""
+    result = {
+        "_response": response,
+        "parsed": None,
+    }
+    # TODO: Add ping for requests method (ATM missing for aiohttp).
+    if hasattr(response, "elapsed"):
+        result["ping"] = round(response.elapsed.total_seconds() * 1000, 3)
+    try:
+        if content_type == "application/json":
+            result["parsed"] = json.loads(content)
+        elif content_type == "text/html":
+            result["parsed"] = {}
+        elif content_type == "text/xml":
+            result["parsed"] = {
+                item.tag: item.text for item in ElementTree.fromstring(content)
+            }
+    except (ElementTree.ParseError, ValueError) as exc:
+        raise TinyToolsRequestError("Cannot parse response") from exc
+    return result
+
+
+def request(
+    method,
+    host,
+    path,
+    schema="http",
+    port=80,
+    username="",
+    password="",
+    timeout=None,
+    retries=None,
+    verify=None,
+    data=None,
+    headers=None,
+):
+    """Send request to device and return dict with response or errors."""
+    url, auth, timeout, retries, verify = _parse_parameters(
+        host, path, schema, port, username, password, timeout, retries, verify
+    )
+    response = None
+    try:
+        response = requests.request(
+            method,
+            url,
+            auth=auth,
+            data=data,
+            headers=headers,
+            timeout=timeout,
+            verify=verify,
+        )
+        response.raise_for_status()
+    except requests.exceptions.ConnectTimeout as exc:
+        if retries:
+            return request(
+                method,
+                host,
+                path,
+                schema,
+                port,
+                username,
+                password,
+                timeout,
+                retries - 1,
+                verify,
+                data,
+                headers,
+            )
+        _handle_errors(exc, response)
+    except Exception as exc:
+        _handle_errors(exc, response)
+    else:
+        return _handle_content(
+            response.headers.get("content-type"), response.content, response
+        )
+
+
+@wraps(request)
+def get(*args, silent=False, **kwargs):
+    """Send GET request."""
+    try:
+        return request("GET", *args, **kwargs)
+    except TinyToolsRequestError:
+        if silent:
+            return None
+        raise
+
+
+@wraps(request)
+def post(*args, **kwargs):
+    """Send POST request."""
+    return request(
+        "POST",
+        *args,
+        headers={"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"},
+        **kwargs,
+    )
+
+
+async def async_request(
+    method,
+    host,
+    path,
+    schema="http",
+    port=80,
+    username=None,
+    password=None,
+    timeout=None,
+    retries=None,
+    verify=None,
+    params=None,
+    data=None,
+    headers=None,
+    session: Union[ClientSession, None] = None,
+):
+    """Async request with aiohttp for given resource.
+
+    It can return text or json-parsed response, else raise exception.
+    """
+    url, auth, timeout, retries, verify = _parse_parameters(
+        host, path, schema, port, username, password, timeout, retries, verify
+    )
+    if auth:
+        auth = BasicAuth(*auth)
+    response = None
+    try:
+        async with session.request(
+            method,
+            url,
+            auth=auth,
+            params=params,
+            timeout=ClientTimeout(total=timeout),
+            verify_ssl=verify,
+        ) as response:
+            response.raise_for_status()
+            content = await response.text()
+    except (asyncio.TimeoutError, ClientOSError, ServerDisconnectedError) as exc:
+        # Retry only on timeout and few specific client connection errors
+        # (they happen randomly at least on Windows).
+        if retries:
+            return await async_request(
+                method,
+                host,
+                path,
+                schema,
+                port,
+                username,
+                password,
+                timeout,
+                retries - 1,
+                verify,
+                params,
+                data,
+                headers,
+                session,
+            )
+        _handle_errors(exc, response)
+    except Exception as exc:
+        _handle_errors(exc, response)
+    return _handle_content(response.content_type, content, response)
+
+
+@wraps(async_request)
+async def async_get(*args, silent=False, **kwargs):
+    """Send async GET request."""
+    try:
+        return await async_request("GET", *args, **kwargs)
+    except TinyToolsRequestError:
+        if silent:
+            return None
+        raise

tinytoolslib-0.2.5.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,13 @@
+tinytoolslib/__init__.py,sha256=nMXg9GFsk8gCcyBnh1MAeUPvo4Zcuv3sdwGHZrxfpPE,36
+tinytoolslib/__version__.py,sha256=SXQZggCNtpYDwWAsfFLa0O_t3a-KL2cRKIMg40z4kgM,21
+tinytoolslib/constants.py,sha256=Vednh4IGZi3Lk4-8ivdM-RPWK0nUppata8ceVsNT5ww,443
+tinytoolslib/discovery.py,sha256=5nQNQvbk3Ywmg-uYG36CKJO0s7piUzmCvPAgnLASrj4,6028
+tinytoolslib/exceptions.py,sha256=hm_QtkFfAGSIrLK5WAGQr-tvMMQ14vaybLHrOqM1i_s,1301
+tinytoolslib/flash.py,sha256=OgV-Z3DiWkNxypcxN6-wwVR_fozd58EpuP4EDALZbaQ,11882
+tinytoolslib/models.py,sha256=YfhYGO-r0N11H55zw3bPPUVEf4JzeDFJrORMaJeeA0k,60885
+tinytoolslib/parsers.py,sha256=Buz9dNSms_2XOdLkqPQrEoqDebxNnzhAsXOOv42I9TA,2067
+tinytoolslib/requests.py,sha256=6k58Aq3BXggkoXuqYpVk1qxdgh9jRwqFXTsP0a1skvc,7893
+tinytoolslib-0.2.5.dist-info/METADATA,sha256=uFVo-wGG9PQBCibZnSTn_jACFo1XdmdubFOjmaBmJgM,2524
+tinytoolslib-0.2.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tinytoolslib-0.2.5.dist-info/top_level.txt,sha256=wjuFc8N3gdsNRhOmJEbVyO_xVe4s6YVgDd1Y6v3W3fI,13
+tinytoolslib-0.2.5.dist-info/RECORD,,

tinytoolslib-0.2.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tinytoolslib-0.2.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+tinytoolslib