pro-os-connect-py 0.8.0__tar.gz

pro_os_connect_py-0.8.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Petr Sedlacek
+
+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.

pro_os_connect_py-0.8.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pro-os-connect-py
+Version: 0.8.0
+Summary: Library to interface with the Donaldson Bofa Pro OS Connect fume extractor controller
+Author-email: Petr Sedlacek <piit@zz9.cz>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/piit79/pro-os-connect-py
+Project-URL: Repository, https://github.com/piit79/pro-os-connect-py
+Project-URL: Issues, https://github.com/piit79/pro-os-connect-py/issues
+Keywords: fume extractor,donaldson bofa,bofa,pro os,pro os connect
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: crccheck<1.4.0,>=1.3.1
+Dynamic: license-file
+
+# pro-os-connect-py
+Python library for controlling Donaldson Bofa Pro OS Connect fume extractor devices
+
+It includes a simple `pro-os-connect-cli` CLI tool.
+
+Example invocation:
+```
+pro-os-connect-cli --device bofa.local get_telemetry
+```

pro_os_connect_py-0.8.0/README.md

@@ -0,0 +1,9 @@
+# pro-os-connect-py
+Python library for controlling Donaldson Bofa Pro OS Connect fume extractor devices
+
+It includes a simple `pro-os-connect-cli` CLI tool.
+
+Example invocation:
+```
+pro-os-connect-cli --device bofa.local get_telemetry
+```

pro_os_connect_py-0.8.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "pro-os-connect-py"
+version = "0.8.0"
+authors = [
+  { name="Petr Sedlacek", email="piit@zz9.cz" },
+]
+description = "Library to interface with the Donaldson Bofa Pro OS Connect fume extractor controller"
+keywords=["fume extractor", "donaldson bofa", "bofa", "pro os", "pro os connect"]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+  "crccheck >=1.3.1, <1.4.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+pro-os-connect-cli = "pro_os_connect.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/piit79/pro-os-connect-py"
+Repository = "https://github.com/piit79/pro-os-connect-py"
+Issues = "https://github.com/piit79/pro-os-connect-py/issues"
+
+[tool.uv]
+package = true
+dev-dependencies = [
+    "ipython>=8.38.0, <9.0.0",
+    "pytest>=9.0.2, <10.0.0",
+    "pytest-cov>=7.0.0, <8.0.0",
+]

pro_os_connect_py-0.8.0/setup.cfg

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

pro_os_connect_py-0.8.0/src/pro_os_connect/__init__.py

@@ -0,0 +1,206 @@
+import logging
+import select
+import socket
+import time
+from datetime import datetime
+
+from pro_os_connect.common import TelemetryFields
+
+from .request import (
+    EchoRequest,
+    GetCpuSerialNumberRequest,
+    GetNetworkConfigurationRequest,
+    GetProtocolVersionRequest,
+    GetSerialNumberRequest,
+    GetSoftwareVersionRequest,
+    GetTelemetryRequest,
+    GetTimeRequest,
+    PumpStartRequest,
+    PumpStopRequest,
+    RebootRequest,
+    Request,
+    SetSetpointRequest,
+    SetTimeRequest,
+)
+from .response import (
+    Response,
+    ResponseError,
+    ResponsePacket,
+    ResponsePacketIncompleteError,
+    StatusCode,
+)
+
+TCP_PORT = 2345
+
+
+class ProOSConnectError(Exception):
+    pass
+
+
+class ProOSConnectRequestError(Exception):
+    pass
+
+
+class ProOSConnectConnectError(ProOSConnectRequestError):
+    pass
+
+
+class ProOSConnectTimeoutError(ProOSConnectRequestError):
+    pass
+
+
+class ProOSConnectResponseError(ProOSConnectError):
+    pass
+
+
+class ProOSConnect:
+    def __init__(self, host: str, port: int = TCP_PORT, timeout: float = 2.0):
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self.socket = None
+        self.logger = logging.getLogger(__name__)
+
+    def connect(self):
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            self.socket.connect((self.host, self.port))
+            self.socket.setblocking(False)
+        except (OSError, ConnectionRefusedError, socket.gaierror) as e:
+            raise ProOSConnectConnectError(e)
+
+    def disconnect(self):
+        if self.socket:
+            self.socket.close()
+            self.socket = None
+
+    def get_response_packet(self) -> ResponsePacket:
+        readers = [self.socket]
+        select_timeout = 0.1  # seconds
+        resp_packet = ResponsePacket()
+        start_time = time.time()
+        while not resp_packet.is_valid() and (time.time() - start_time) < self.timeout:
+            read_ready, _, _ = select.select(readers, [], [], select_timeout)
+            if not read_ready:
+                continue
+
+            packet = self.socket.recv(4096)  # pyright: ignore[reportOptionalMemberAccess]
+            self.logger.debug(f"Received packet: {packet.hex()}")
+            if packet:
+                resp_packet.append(packet)
+
+        return resp_packet
+
+    def send_request(self, request: Request) -> Response | None:
+        if not self.socket:
+            self.connect()
+
+        request_packet = request.get_packet()
+        self.logger.debug(f"Sending packet: {request_packet.hex()}")
+        self.socket.sendall(request_packet)  # type: ignore
+
+        self.logger.debug("Waiting for response...")
+        response_packet = self.get_response_packet()
+
+        try:
+            response_packet.parse()
+        except ResponsePacketIncompleteError:
+            if not response_packet.has_data():
+                raise ProOSConnectTimeoutError("Timeout waiting for response")
+            else:
+                raise ProOSConnectResponseError("Response packet incomplete")
+        except ResponseError as e:
+            raise ProOSConnectResponseError(e.description)
+
+        if response_packet.status != StatusCode.OK.value:
+            self.logger.debug(f"Response status: {response_packet.status}")
+            raise ProOSConnectResponseError(
+                f"Error in response: {StatusCode(response_packet.status).name}"
+            )
+
+        return response_packet.get_response()
+
+    def get_protocol_version(self) -> int | None:
+        response = self.send_request(GetProtocolVersionRequest())
+        if not response or not isinstance(response.result, int):
+            return None
+        return response.result
+
+    # FIXME: Doesn't work for some reason. No response received
+    def echo(self, test_payload: bytes | None = None) -> bool:
+        if test_payload is None:
+            test_payload = b"Test Echo Payload"
+        response = self.send_request(EchoRequest(test_payload))
+        if response is None:
+            return False
+        return response.result == test_payload
+
+    def reboot(self) -> bool:
+        response = self.send_request(RebootRequest())
+        return response is not None
+
+    def get_telemetry(self) -> TelemetryFields | None:
+        response = self.send_request(GetTelemetryRequest())
+        return (
+            response.result
+            if response and isinstance(response.result, TelemetryFields)
+            else None
+        )
+
+    def get_uptime(self) -> int | None:
+        """Return device uptime in seconds."""
+        fields = self.get_telemetry()
+        return int(fields.timestamp / 100.0) if fields else None
+
+    def is_running(self) -> bool | None:
+        """Return True if the pump is running"""
+        fields = self.get_telemetry()
+        return bool(fields.is_running) if fields else None
+
+    def get_time(self) -> datetime | None:
+        """Return device time as datetime object"""
+        response = self.send_request(GetTimeRequest())
+        return (
+            response.result
+            if response and isinstance(response.result, datetime)
+            else None
+        )
+
+    def set_time(self, date_obj: datetime) -> bool:
+        response = self.send_request(SetTimeRequest(date_obj))
+        return response is not None
+
+    def pump_start(self) -> bool:
+        response = self.send_request(PumpStartRequest())
+        return response is not None
+
+    def pump_stop(self) -> bool:
+        response = self.send_request(PumpStopRequest())
+        return response is not None
+
+    # FIXME: Response payload CRC mismatch
+    def get_software_version(self) -> str | None:
+        response = self.send_request(GetSoftwareVersionRequest())
+        return (
+            response.result if response and isinstance(response.result, str) else None
+        )
+
+    # FIXME: Response payload CRC mismatch
+    def get_serial_number(self) -> str | None:
+        response = self.send_request(GetSerialNumberRequest())
+        return (
+            response.result if response and isinstance(response.result, str) else None
+        )
+
+    # FIXME: Response payload CRC mismatch
+    def get_cpu_serial_number(self) -> str | None:
+        response = self.send_request(GetCpuSerialNumberRequest())
+        return response.result if response else None  # pyright: ignore[reportReturnType]
+
+    def get_network_configuration(self) -> str | None:
+        response = self.send_request(GetNetworkConfigurationRequest())
+        return response.result if response else None  # pyright: ignore[reportReturnType]
+
+    def set_setpoint(self, setpoint: int) -> bool:
+        response = self.send_request(SetSetpointRequest(setpoint))
+        return response is not None

pro_os_connect_py-0.8.0/src/pro_os_connect/cli.py

@@ -0,0 +1,222 @@
+import argparse
+import json
+import logging
+import sys
+from collections.abc import Mapping
+from datetime import datetime
+from time import sleep, time
+
+from . import ProOSConnect, ProOSConnectRequestError, ProOSConnectResponseError
+from .common import Node
+
+COMMANDS = {
+    "get_protocol_version": [],
+    "echo": [
+        (("--payload", "-p"), {"type": str, "help": "Test payload for echo command"})
+    ],
+    "reboot": [],
+    "get_telemetry": [],
+    "get_setpoint": [],
+    "get_uptime": [],
+    "is_running": [],
+    "get_time": [],
+    "set_time": [(("time",), {"type": str, "help": "Time to set"})],
+    "pump_start": [],
+    "pump_stop": [],
+    "get_software_version": [],
+    "get_serial_number": [],
+    "get_cpu_serial_number": [],
+    "get_network_configuration": [],
+    "set_setpoint": [(("setpoint",), {"type": int, "help": "Setpoint value to set"})],
+}
+
+
+def output_text(data: str | bool | Mapping, error=False):
+    """Output data as formatted text."""
+    stream = sys.stderr if error else sys.stdout
+    if isinstance(data, Mapping):
+        for key, value in data.items():
+            print(f"{key}={value}", file=stream)
+    elif isinstance(data, bool):
+        print(1 if data else 0, file=stream)
+    else:
+        print(data, file=stream)
+
+
+def output_json(data: Mapping):
+    """Output data as formatted JSON."""
+    print(json.dumps(data, indent=2))
+
+
+class ProOSConnectCli:
+    DONE = object()
+
+    def __init__(self):
+        self.args = self.get_args()
+        self.command: str = self.args.command
+        self.poc = ProOSConnect(self.args.device)
+        self.setup_logging()
+        self.json_result_key: str | None = None
+
+    def get_args(self):
+        parser = argparse.ArgumentParser(description="Pro-OS Connect CLI")
+        parser.add_argument(
+            "--device",
+            "-d",
+            type=str,
+            help="Hostname or IP address of the Pro OS Connect device",
+            required=True,
+        )
+        parser.add_argument(
+            "--json", "-j", action="store_true", help="Output in JSON format"
+        )
+        parser.add_argument(
+            "--node",
+            "-n",
+            choices=[Node.PRO_OS.name, Node.NETWORK_CARD.name],
+            help="Destination node",
+        )
+        parser.add_argument(
+            "--precision",
+            "-p",
+            type=int,
+            default=1,
+            help="Display precision in decimal digits",
+        )
+        parser.add_argument(
+            "--log-level",
+            "-l",
+            choices=["ERROR", "WARNING", "INFO", "DEBUG"],
+            help="Logging level",
+        )
+        subparsers = parser.add_subparsers(
+            required=True, help="Command to execute", dest="command"
+        )
+
+        for cmd_name, cmd_args in COMMANDS.items():
+            cmd_parser = subparsers.add_parser(cmd_name, help=f"{cmd_name} help")
+            for args, kwargs in cmd_args:
+                cmd_parser.add_argument(*args, **kwargs)
+
+        return parser.parse_args()
+
+    def setup_logging(self):
+        handler = logging.StreamHandler(stream=sys.stderr)
+        handler.setFormatter(logging.Formatter(fmt="{levelname}: {message}", style="{"))
+        self.poc.logger.addHandler(handler)
+        if self.args.log_level:
+            self.poc.logger.setLevel(self.args.log_level)
+
+    def ensure_json_result_key(self):
+        if self.json_result_key is None:
+            if self.command.startswith("get_"):
+                self.json_result_key = self.command[4:]
+            elif self.command.startswith("is_"):
+                self.json_result_key = self.command[3:]
+            else:
+                self.json_result_key = "result"
+
+    def output(self, data, json_data: Mapping | None = None, error=False):
+        if self.args.json:
+            if json_data is None:
+                if isinstance(data, Mapping):
+                    json_data = data
+                else:
+                    if isinstance(data, datetime):
+                        data = data.isoformat()
+                    json_data = {self.json_result_key: data}
+            output_json(json_data)
+        else:
+            output_text(data, error=error)
+
+    def error(self, error_msg):
+        self.output(error_msg, {"success": False, "error": error_msg}, error=True)
+
+    def echo(self):
+        test_payload = self.args.payload.encode("utf-8") if self.args.payload else None
+        start_time = time()
+        res = self.poc.echo(test_payload)
+        if res:
+            rtt = round(
+                (time() - start_time) * 100, 2
+            )  # Round trim time in milliseconds
+            self.output(
+                f"Echo response received in {rtt} ms", {"result": True, "time": rtt}
+            )
+
+    def get_telemetry(self):
+        fields = self.poc.get_telemetry()
+        res = fields
+        if fields:
+            res = fields._asdict()
+            for f, v in res.items():
+                if isinstance(v, float):
+                    res[f] = round(v, self.args.precision)
+        return res
+
+    def set_time(self):
+        """Set time to current time"""
+        self.poc.set_time(datetime.now())
+
+    def get_network_configuration(self):
+        return self.poc.get_network_configuration()
+
+    def get_setpoint(self) -> int | None:
+        fields = self.poc.get_telemetry()
+        return fields.setpoint if fields else None
+
+    def set_setpoint(self):
+        res = self.poc.set_setpoint(self.args.setpoint)
+        if not res:
+            self.error("Error setting setpoint")
+            sys.exit(1)
+        sleep(0.01)  # Wait a bit otherwise the old setpoint will be returned
+        setpoint = self.get_setpoint()
+        if not setpoint:
+            self.error("Error getting new setpoint")
+            sys.exit(1)
+        self.output(
+            f"Setpoint set to {setpoint}",
+            {"success": res, "setpoint": setpoint},
+        )
+        return self.DONE
+
+    def pro_os_command(self):
+        method = getattr(self.poc, self.command)
+        if method is None:
+            self.error(f"Invalid command: {self.command}")
+            return
+
+        return method()
+
+    def run(self):
+        method = getattr(self, self.command, self.pro_os_command)
+
+        try:
+            result = method()
+        except ProOSConnectRequestError as e:
+            self.error(f"Error sending request: {e}")
+            sys.exit(5)
+        except ProOSConnectResponseError as e:
+            self.error(f"Response error: {e}")
+            sys.exit(6)
+
+        match result:
+            case self.DONE:
+                # Output was handled by the method
+                return
+            case None:
+                self.error("Command failed, no result received")
+                sys.exit(7)
+
+        self.ensure_json_result_key()
+        self.output(result)
+
+
+def main():
+    cli = ProOSConnectCli()
+    cli.run()
+
+
+if __name__ == "__main__":
+    main()

pro_os_connect_py-0.8.0/src/pro_os_connect/codecs.py

@@ -0,0 +1,140 @@
+import json
+import struct
+from abc import ABC
+from datetime import datetime
+
+from .common import TelemetryFields
+
+
+class Codec(ABC):
+    """Base class for the payload encoder/decoder classes"""
+
+    @classmethod
+    def null(cls):
+        return CodecNull()
+
+    @classmethod
+    def cstr(cls):
+        return CodecCstr()
+
+    @classmethod
+    def struct(cls, format):
+        return CodecStruct(format)
+
+    @classmethod
+    def telemetry_fields(cls):
+        return CodecTelemetryFields()
+
+    @classmethod
+    def int(cls, format):
+        return CodecInt(format)
+
+    @classmethod
+    def iso_datetime(cls):
+        return CodecIsoDateTime()
+
+    @classmethod
+    def raw_hex(cls):
+        return CodecRawHex()
+
+    @classmethod
+    def json_cstr(cls):
+        return CodecCstrJson()
+
+    def pack(self, data) -> bytes:
+        raise NotImplementedError
+
+    def unpack(self, payload: bytes):
+        raise NotImplementedError
+
+
+class CodecNull(Codec):
+    """Encoder/decoder class for a raw unformatted payload"""
+
+    def pack(self, data: bytes) -> bytes:
+        return data
+
+    def unpack(self, payload: bytes) -> bytes:
+        return payload
+
+
+class CodecCstr(Codec):
+    """Encoder/decoder class for a null-terminated string payload"""
+
+    def pack(self, data: str) -> bytes:
+        return data.encode("utf-8") + b"\x00"
+
+    def unpack(self, payload: bytes) -> str:
+        return payload.decode("utf-8").rstrip("\x00")
+
+
+class CodecStruct(Codec):
+    """Encoder/decoder class for a struct payload"""
+
+    def __init__(self, format) -> None:
+        self.format = format
+
+    def pack(self, data: tuple) -> bytes:
+        return struct.pack(self.format, *data)
+
+    def unpack(self, payload: bytes) -> tuple:
+        return struct.unpack(self.format, payload)
+
+
+class CodecTelemetryFields(CodecStruct):
+    """Encoder/decoder class for a telemetry field struct payload"""
+
+    def __init__(self) -> None:
+        self.format = "<IIIffffHBBBBBb"
+
+    def pack(self, data: tuple) -> bytes:
+        """Pack not implemented, this is only a decoder"""
+        raise NotImplementedError()
+
+    def unpack(self, payload: bytes) -> tuple:
+        return TelemetryFields(*super().unpack(payload))
+
+
+class CodecInt(CodecStruct):
+    """Encoder/decoder class for a struct payload"""
+
+    def pack(self, data: int) -> bytes:  # pyright: ignore[reportIncompatibleMethodOverride]
+        return super().pack((data,))
+
+    def unpack(self, payload: bytes) -> int:  # pyright: ignore[reportIncompatibleMethodOverride]
+        (val,) = super().unpack(payload)
+        return val
+
+
+class CodecIsoDateTime(CodecCstr):
+    """Encoder/decoder class for an ISO datetime payload in a null-terminated string"""
+
+    def pack(self, data: datetime) -> bytes:  # pyright: ignore[reportIncompatibleMethodOverride]
+        datetime_str = data.isoformat()
+        return super().pack(datetime_str)
+
+    def unpack(self, payload: bytes) -> datetime:  # pyright: ignore[reportIncompatibleMethodOverride]
+        datetime_str = super().unpack(payload)
+        return datetime.fromisoformat(datetime_str)
+
+
+class CodecRawHex(Codec):
+    """Encoder/decoder class for raw data represented as hex string"""
+
+    def pack(self, data: str) -> bytes:
+        return bytes.fromhex(data)
+
+    def unpack(self, payload: bytes) -> str:
+        return payload.hex()
+
+
+class CodecCstrJson(CodecCstr):
+    """Encoder/decoder class for a JSON payload in a null-terminated string"""
+
+    def pack(self, data: dict) -> bytes:  # pyright: ignore[reportIncompatibleMethodOverride]
+        json_str = json.dumps(data, indent=2)
+        return super().pack(json_str)
+
+    def unpack(self, payload: bytes) -> dict:  # pyright: ignore[reportIncompatibleMethodOverride]
+        json_str = super().unpack(payload)
+        return json.loads(json_str)

pro_os_connect_py-0.8.0/src/pro_os_connect/common.py

@@ -0,0 +1,76 @@
+from collections import namedtuple
+from enum import Enum
+
+FRAMING_PHRASE = 0xB0FAB0FA
+
+
+class Node(Enum):
+    PRO_OS = 0x0001
+    NETWORK_CARD = 0x0002
+    CLIENT = 0x0003
+
+
+class Command(Enum):
+    NONE = None
+    GET_PROTOCOL_VERSION = 0x00010001
+    ECHO = 0x00010002
+    REBOOT = 0x00010003
+    GET_TELEMETRY = 0x00010004
+    GET_TIME = 0x00010006
+    SET_TIME = 0x00010007
+    SOFTWARE_UPDATE_START = 0x00010008
+    SOFTWARE_UPDATE_FLASH_PAGE = 0x00010009
+    SOFTWARE_UPDATE_FINISH = 0x0001000A
+    FILE_GET_START = 0x0001000C
+    FILE_GET_PAGE = 0x0001000D
+    FILE_GET_FINISH = 0x0001000E
+    PUMP_START = 0x0001000F
+    PUMP_STOP = 0x00010010
+    GET_SOFTWARE_VERSION = 0x00010011
+    GET_SERIAL_NUMBER = 0x00010012
+    GET_CPU_SERIAL_NUMBER = 0x00010013
+    GET_NETWORK_CONFIGURATION = 0x00010014
+    SET_DISPLAYED_IP_ADDRESS = 0x00010015  # Not intended for use by end client device
+    SET_CLIENT_TIMEOUT = 0x00010016
+    SET_SETPOINT = 0x00010017
+
+
+class StatusCode(Enum):
+    NONE = None
+    OK = 0x00000000  # Success status, no errors, packet processed successfully
+    NOT_PROCESSED = 0x0FFFFFFF  # The initial packet request status
+    INTERNAL_ERROR = 0xB0000000  # General error code, usually if internal process has failed in some way
+    INTERNAL_NULL_PTR = 0xB0000001  # If an internal process errored out due to null pointer
+    INTERNAL_BAD_ARG = 0xB0000002  # If an internal process errored out due to bad argument
+    INTERNAL_OVERFLOW = 0xB0000003  # If an internal process produced a potential buffer overflow
+    INTERNAL_TIMEOUT = 0xB0000004  # If an internal process timed-out
+    INVALID_ADDRESS = 0xC0000000  # Command Header’s To-From address was incorrectly set
+    INVALID_STATUS = 0xC0000001  # Command Header’s Status code was incorrectly set
+    INVALID_COMMAND = 0xC0000002  # Command was not found or not supported
+    WRITE_PROTECTED = 0xC0000003  # If Command was rejected because the iQ2 is configured in a read only state
+    COMMAND_BAD_ARG = 0xE0000000  # Requested command has invalid argument
+    COMMAND_NOT_IN_PROGRESS = 0xE0000001  # Requested command has been called out of order (PROTOCOL_COMMAND_FILE_GET ***)
+    COMMAND_WRONG_SEQUENCE = 0xE0000002  # Command sequence is invalid
+    COMMAND_CRC_INVALID = 0xE0000003  # Command CRC mismatch (PROTOCOL_COMMAND_SW_FINISH)
+    COMMAND_FILE_EMPTY = 0xE0000004  # Requested File does not exist or is empty
+
+
+TelemetryFields = namedtuple(
+    "TelemetryFields",
+    [
+        "timestamp",
+        "alarms",
+        "setpoint",
+        "flow_rate",
+        "combined_pressure",
+        "pre_pressure",
+        "inlet_pressure",
+        "pump_level",
+        "rcb",
+        "rpb",
+        "rib",
+        "ccb",
+        "cpb",
+        "is_running",
+    ],
+)

pro_os_connect_py-0.8.0/src/pro_os_connect/request.py

@@ -0,0 +1,126 @@
+import logging
+import struct
+from abc import ABC
+from typing import Any
+
+from .codecs import Codec
+from .common import FRAMING_PHRASE, Command, Node, StatusCode
+from .util import calculate_crc
+
+
+class Request(ABC):
+    COMMAND = Command.NONE
+    CODEC: Codec | None = None
+
+    def __init__(self, data: Any = None, to_addr: Node = Node.PRO_OS):
+        """
+        :param data: Command data
+        :type data: Any
+        :param to_addr: Destination address - Node.PRO_OS or Node.NETWORK_CARD
+        :type to_addr: Node
+        """
+        self.data = data
+        self.from_addr = Node.CLIENT
+        self.to_addr = to_addr
+        self.logger = logging.getLogger(__name__)
+
+    # bit   0        31 32      63 64 79 80 95 96
+    #       +----------+----------+-----+-----+----------
+    #       | Command  | Status   | From| To  | Data
+    #       | Code     | Code     |     |     | Bytes
+    #       +----------+----------+-----+-----+----------
+    #       Protocol Header                   | Payload -->
+    def get_protocol_packet(self, payload: bytes) -> bytes:
+        """Create and return the protocol packet from the command payload"""
+        protocol_packet = struct.pack(
+            "<IIHH",
+            self.COMMAND.value,
+            StatusCode.NOT_PROCESSED.value,
+            self.from_addr.value,
+            self.to_addr.value,
+        )
+        return protocol_packet + payload
+
+    # bit   0        31 32      63 64      95 96     127
+    #       +----------+----------+----------+----------+----------
+    #       | Framing  | Payload  | Payload  | Header   | Data
+    #       | phrase   | Length   | CRC      | CRC      | Bytes
+    #       +----------+----------+----------+----------+----------
+    #       Transport Header                            | Payload -->
+    def get_transport_packet(self, protocol_packet: bytes) -> bytes:
+        """Create and return the transport packet from the protocol packet"""
+        payload_crc = calculate_crc(protocol_packet)
+        header_base = struct.pack(
+            "<III", FRAMING_PHRASE, len(protocol_packet), payload_crc
+        )
+        header_crc = calculate_crc(header_base)
+        header = header_base + struct.pack("<I", header_crc)
+        return header + protocol_packet
+
+    def get_payload(self) -> bytes:
+        """Return the encoded command data"""
+        if self.CODEC is not None:
+            return self.CODEC.pack(self.data)
+        return b""
+
+    def get_packet(self) -> bytes:
+        """Create and return the network packet data"""
+        payload = self.get_payload()
+        protocol_packet = self.get_protocol_packet(payload)
+        transport_packet = self.get_transport_packet(protocol_packet)
+        return transport_packet
+
+
+class GetProtocolVersionRequest(Request):
+    COMMAND = Command.GET_PROTOCOL_VERSION
+
+
+class EchoRequest(Request):
+    COMMAND = Command.ECHO
+    CODEC = Codec.null()
+
+
+class RebootRequest(Request):
+    COMMAND = Command.REBOOT
+
+
+class GetTelemetryRequest(Request):
+    COMMAND = Command.GET_TELEMETRY
+
+
+class GetTimeRequest(Request):
+    COMMAND = Command.GET_TIME
+
+
+class SetTimeRequest(Request):
+    COMMAND = Command.SET_TIME
+    CODEC = Codec.iso_datetime()
+
+
+class PumpStartRequest(Request):
+    COMMAND = Command.PUMP_START
+
+
+class PumpStopRequest(Request):
+    COMMAND = Command.PUMP_STOP
+
+
+class GetSoftwareVersionRequest(Request):
+    COMMAND = Command.GET_SOFTWARE_VERSION
+
+
+class GetSerialNumberRequest(Request):
+    COMMAND = Command.GET_SERIAL_NUMBER
+
+
+class GetCpuSerialNumberRequest(Request):
+    COMMAND = Command.GET_CPU_SERIAL_NUMBER
+
+
+class GetNetworkConfigurationRequest(Request):
+    COMMAND = Command.GET_NETWORK_CONFIGURATION
+
+
+class SetSetpointRequest(Request):
+    COMMAND = Command.SET_SETPOINT
+    CODEC = Codec.int("<I")

pro_os_connect_py-0.8.0/src/pro_os_connect/response.py

@@ -0,0 +1,248 @@
+import logging
+import struct
+from abc import ABC
+from typing import Any, ClassVar
+
+from .codecs import Codec
+from .common import FRAMING_PHRASE, Command, Node, StatusCode
+from .util import calculate_crc
+
+_registry: dict[Command, type["Response"]] = {}
+
+
+def response(cls: type["Response"]) -> type["Response"]:
+    _registry[cls.COMMAND] = cls
+    return cls
+
+
+class ResponseError(Exception):
+    description = "Response error"
+
+
+class ResponseNotDefinedError(ResponseError):
+    description = "Response not defined"
+
+
+class ResponsePacketIncompleteError(ResponseError):
+    description = "Response packet incomplete"
+
+
+class ResponseFramingPhraseError(ResponseError):
+    description = "Invalid framing phrase"
+
+
+class ResponseHeaderCrcError(ResponseError):
+    description = "Response header CRC error"
+
+
+class ResponsePayloadLengthError(ResponseError):
+    description = "Response payload length incorrect"
+
+
+class ResponsePayloadCrcError(ResponseError):
+    description = "Response payload CRC error"
+
+
+class ResponsePacket:
+    TRANSPORT_HEADER_SIZE = 16
+    PROTOCOL_HEADER_SIZE = 12
+
+    # List of commands with known incorrect CRC in the response
+    KNOWN_INCORRECT_CRC_COMMANDS: ClassVar = [
+        Command.GET_CPU_SERIAL_NUMBER,
+        Command.GET_SERIAL_NUMBER,
+        Command.GET_SOFTWARE_VERSION,
+        Command.GET_NETWORK_CONFIGURATION,
+    ]
+
+    def __init__(self, data: bytes = b""):
+        """
+        :param data: Response network packet data
+        :type data: bytes
+        """
+        self.data = data
+        self.command: Command = Command.NONE
+        self.status: StatusCode = StatusCode.NONE
+        self.from_addr: Node | None = None
+        self.to_addr: Node | None = None
+        self.transport_header = b""
+        self.protocol_packet = b""
+        self.protocol_header = b""
+        self.payload = b""
+        self.logger = logging.getLogger(__name__)
+
+    def append(self, data: bytes):
+        """Add more packet data to the response"""
+        self.data += data
+
+    def __iadd__(self, data: bytes):
+        self.append(data)
+        return self
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def has_data(self) -> bool:
+        return len(self) > 0
+
+    def is_valid(self) -> bool:
+        try:
+            self.parse_transport_packet(test=True)
+        except ResponseError:
+            return False
+
+        return True
+
+    def parse_transport_packet(self, test=False):
+        if len(self) < self.TRANSPORT_HEADER_SIZE:
+            raise ResponsePacketIncompleteError()
+        self.transport_header = self.data[: self.TRANSPORT_HEADER_SIZE]
+        self.protocol_packet = self.data[self.TRANSPORT_HEADER_SIZE :]
+        framing_phrase, payload_length, payload_crc, header_crc = struct.unpack(
+            "<IIII", self.transport_header
+        )
+        if framing_phrase != FRAMING_PHRASE:
+            msg = f"Response framing phrase invalid: {framing_phrase}"
+            self.logger.error(msg)
+            raise ResponseFramingPhraseError(msg)
+        calculated_header_crc = calculate_crc(self.transport_header[:12])
+        if calculated_header_crc != header_crc:
+            msg = f"Response header CRC mismatch: calculated={calculated_header_crc} actual={header_crc}"
+            self.logger.error(msg)
+            raise ResponseHeaderCrcError(msg)
+        if len(self.protocol_packet) != payload_length:
+            msg = f"Response payload length mismatch: actual={len(self.protocol_packet)} header={payload_length}"
+            level = logging.DEBUG if test else logging.ERROR
+            self.logger.log(level, msg)
+            raise ResponsePayloadLengthError(msg)
+        calculated_payload_crc = calculate_crc(self.protocol_packet)
+        if calculated_payload_crc != payload_crc:
+            self.parse_protocol_packet()
+            msg = f"Response payload CRC mismatch: calculated={calculated_payload_crc:x} received={payload_crc:x}"
+            if self.command in self.KNOWN_INCORRECT_CRC_COMMANDS:
+                self.logger.warning(msg)
+            else:
+                self.logger.error(msg)
+                raise ResponsePayloadCrcError("Response payload CRC mismatch")
+
+    def parse_protocol_packet(self):
+        self.protocol_header = self.protocol_packet[: self.PROTOCOL_HEADER_SIZE]
+        command, self.status, self.from_addr, self.to_addr = struct.unpack(
+            "<IIHH", self.protocol_header
+        )
+        self.command = Command(command)
+        self.payload = self.protocol_packet[self.PROTOCOL_HEADER_SIZE :]
+
+    def parse(self):
+        self.parse_transport_packet()
+        self.parse_protocol_packet()
+
+    def get_response(self) -> "Response | None":
+        try:
+            cls = _registry[self.command]
+        except KeyError:
+            raise ResponseError
+
+        return cls(self)
+
+
+class Response(ABC):
+    COMMAND = Command.NONE
+    CODEC: Codec | None = None
+
+    def __init__(self, packet: ResponsePacket):
+        """
+        :param packet: Response network packet data
+        :type packet: ResponsePacket
+        """
+        self.packet = packet
+        self.status: StatusCode = self.packet.status
+        self.from_addr = self.packet.from_addr
+        self.to_addr = self.packet.to_addr
+        self.result: Any = None
+        self.unpack()
+
+    def unpack(self):
+        if self.CODEC is not None:
+            self.result = self.CODEC.unpack(self.packet.payload)
+
+
+@response
+class GetProtocolVersionResponse(Response):
+    COMMAND = Command.GET_PROTOCOL_VERSION
+    CODEC = Codec.int("<I")
+
+
+@response
+class EchoResponse(Response):
+    COMMAND = Command.ECHO
+    CODEC = Codec.null()
+
+
+#                           Response payload
+# bit   0                         31 32                       63
+#       +------+------+------+------+------+------+------+------+
+#       |         Timestamp         |          Alarms           |
+#       +------+------+------+------+------+------+------+------+
+#       |          Setpoint         |         Flow Rate         |
+#       +------+------+------+------+------+------+------+------+
+#       |     Combined Pressure     |       Pre Pressure        |
+#       +------+------+------+------+------+------+------+------+
+#       |       Inlet Pressure      |  Pump Level | RCB  | RPB  |
+#       +------+------+------+------+------+------+------+------+
+#       | RIB  | CCB  | CPB  | Run  |
+#       +------+------+------+------+
+@response
+class GetTelemetryResponse(Response):
+    COMMAND = Command.GET_TELEMETRY
+    CODEC = Codec.telemetry_fields()
+
+
+@response
+class GetTimeResponse(Response):
+    COMMAND = Command.GET_TIME
+    CODEC = Codec.iso_datetime()
+
+
+@response
+class SetTimeResponse(Response):
+    COMMAND = Command.SET_TIME
+
+
+@response
+class PumpStartResponse(Response):
+    COMMAND = Command.PUMP_START
+
+
+@response
+class PumpStopResponse(Response):
+    COMMAND = Command.PUMP_STOP
+
+
+@response
+class GetSoftwareVersionResponse(Response):
+    COMMAND = Command.GET_SOFTWARE_VERSION
+    CODEC = Codec.cstr()
+
+
+@response
+class GetSerialNumberResponse(Response):
+    COMMAND = Command.GET_SERIAL_NUMBER
+    CODEC = Codec.cstr()
+
+
+@response
+class GetCpuSerialNumberResponse(Response):
+    COMMAND = Command.GET_CPU_SERIAL_NUMBER
+    CODEC = Codec.raw_hex()
+
+
+@response
+class GetNetworkConfigurationResponse(Response):
+    COMMAND = Command.GET_NETWORK_CONFIGURATION
+    CODEC = Codec.json_cstr()
+
+
+@response
+class SetSetpointResponse(Response):
+    COMMAND = Command.SET_SETPOINT

pro_os_connect_py-0.8.0/src/pro_os_connect/util.py

@@ -0,0 +1,15 @@
+from crccheck.crc import Crc32Mpeg2
+
+
+def calculate_crc(data: bytes) -> int:
+    """Calculate CRC32/MPEG-2 for provided data bytes.
+
+    Args:
+        data: bytes to calculate CRC for
+
+    Returns:
+        int: computed CRC value
+    """
+    crc = Crc32Mpeg2()
+    crc.process(data)
+    return crc.final()

pro_os_connect_py-0.8.0/src/pro_os_connect_py.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pro-os-connect-py
+Version: 0.8.0
+Summary: Library to interface with the Donaldson Bofa Pro OS Connect fume extractor controller
+Author-email: Petr Sedlacek <piit@zz9.cz>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/piit79/pro-os-connect-py
+Project-URL: Repository, https://github.com/piit79/pro-os-connect-py
+Project-URL: Issues, https://github.com/piit79/pro-os-connect-py/issues
+Keywords: fume extractor,donaldson bofa,bofa,pro os,pro os connect
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: crccheck<1.4.0,>=1.3.1
+Dynamic: license-file
+
+# pro-os-connect-py
+Python library for controlling Donaldson Bofa Pro OS Connect fume extractor devices
+
+It includes a simple `pro-os-connect-cli` CLI tool.
+
+Example invocation:
+```
+pro-os-connect-cli --device bofa.local get_telemetry
+```

pro_os_connect_py-0.8.0/src/pro_os_connect_py.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/pro_os_connect/__init__.py
+src/pro_os_connect/cli.py
+src/pro_os_connect/codecs.py
+src/pro_os_connect/common.py
+src/pro_os_connect/request.py
+src/pro_os_connect/response.py
+src/pro_os_connect/util.py
+src/pro_os_connect_py.egg-info/PKG-INFO
+src/pro_os_connect_py.egg-info/SOURCES.txt
+src/pro_os_connect_py.egg-info/dependency_links.txt
+src/pro_os_connect_py.egg-info/entry_points.txt
+src/pro_os_connect_py.egg-info/requires.txt
+src/pro_os_connect_py.egg-info/top_level.txt

pro_os_connect_py-0.8.0/src/pro_os_connect_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pro_os_connect_py-0.8.0/src/pro_os_connect_py.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pro-os-connect-cli = pro_os_connect.cli:main

pro_os_connect_py-0.8.0/src/pro_os_connect_py.egg-info/requires.txt

@@ -0,0 +1 @@
+crccheck<1.4.0,>=1.3.1

pro_os_connect_py-0.8.0/src/pro_os_connect_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+pro_os_connect