burnintest-plugin 0.1.0__tar.gz

burnintest_plugin-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

burnintest_plugin-0.1.0/.python-version

@@ -0,0 +1 @@
+3.11

burnintest_plugin-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: burnintest-plugin
+Version: 0.1.0
+Summary: Python bindings for PassMark's BurnInTest plugin interface
+Author-email: Timothy Lassiter <tim.lassiter@ruggedscience.com>
+Requires-Python: >=3.11

burnintest_plugin-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+dynamic = ["version"]
+name = "burnintest-plugin"
+description = "Python bindings for PassMark's BurnInTest plugin interface"
+authors = [
+    { name = "Timothy Lassiter", email = "tim.lassiter@ruggedscience.com" }
+]
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    
+]
+dependencies = []
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"

burnintest_plugin-0.1.0/src/burnintest_plugin/__init__.py

@@ -0,0 +1,18 @@
+import importlib.metadata
+
+# 1. Fetch dynamic version from hatch-vcs
+try:
+    __version__ = importlib.metadata.version("burnintest-plugin")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.0.dev0"
+
+# 2. Import your public classes and enums from your internal modules
+from .bitinterface import BitInterface, PluginStatus, ErrorSeverity
+
+# 3. Explicitly declare your Public API
+__all__ = [
+    "__version__",
+    "BitInterface",
+    "PluginStatus",
+    "ErrorSeverity",
+]

burnintest_plugin-0.1.0/src/burnintest_plugin/bitinterface.py

@@ -0,0 +1,315 @@
+import ctypes
+import enum
+import time
+from multiprocessing import shared_memory
+from typing import Callable, Optional
+
+PLUGIN_INTERFACE_VERSION: int = 4
+
+PLUGIN_MAXDISPLAYTEXT: int = 20
+PLUGIN_MAXERRORTEXT: int = 100
+PLUGIN_MAXERRORTEXTLONG: int = 201
+
+
+class PluginStatus(enum.Enum):
+    PLUGIN_NOSTATUS = 0  # Nothing interesting for BurnInTest to know about
+    PLUGIN_STARTUP = 1  # Not used - for future use
+    PLUGIN_ALLOCATE = 2  # Not used - for future use
+    PLUGIN_WRITING = 3  # Not used - for future use
+    PLUGIN_READING = 4  # Not used - for future use
+    PLUGIN_VERIFYING = 5  # Not used - for future use
+    PLUGIN_WAITING = 6  # Not used - for future use
+    PLUGIN_CLEANUP = 7  # Not used - for future use
+    PLUGIN_ERROR = 8  # Not used - for future use
+    PRE_TEST_PLUGIN_COMPLETED = 9  # If this is flagged in status then BurnInTest will close the interface to the Plugin and continue - for a pre-test plugin
+    PLUGIN_MAXVAL = 10  # Must always be one bigger than the last value
+
+    PLUGIN_NOTUSED = -1
+
+
+# Error severity
+class ErrorSeverity(enum.Enum):
+    ERRORNONE = 0
+    ERRORINFORMATION = 1
+    ERRORWARNING = 2
+    ERRORSERIOUS = 3
+    ERRORCRITICAL = 4
+    ERRORTERM = 5
+
+
+class BitInterfaceStructure(ctypes.Structure):
+    test_running: int
+    duty_cycle: int
+    interface_version: int
+
+    window_title: bytes
+    cycle: int
+    status: int
+    status_message: bytes
+
+    error_count: int
+    error_message: bytes
+    error_severity: int
+
+    write_operations_text: bytes
+    write_operations: int
+
+    read_operations_text: bytes
+    read_operations: int
+    
+    verify_operations_text: bytes
+    verify_operations: int
+
+    user_defined_1_used: bool
+    user_defined_1_text: bytes
+    user_defined_1_value: bytes
+
+    user_defined_2_used: bool
+    user_defined_2_text: bytes
+    user_defined_2_value: bytes
+
+    user_defined_3_used: bool
+    user_defined_3_text: bytes
+    user_defined_3_value: bytes
+
+    user_defined_4_used: bool
+    user_defined_4_text: bytes
+    user_defined_4_value: bytes
+
+    user_defined_5_used: bool
+    user_defined_5_text: bytes
+    user_defined_5_value: bytes
+
+    user_defined_6_used: bool
+    user_defined_6_text: bytes
+    user_defined_6_value: bytes
+
+    new_display_text: bool
+    new_error: bool
+    new_status: bool
+    test_stopped: bool
+
+    error_message_long: bytes
+
+    _fields_ = [
+        # Data sent to plugin from BIT
+        ("test_running", ctypes.c_int),
+        ("duty_cycle", ctypes.c_int),
+        # Data sent to BIT from plugin
+        ("interface_version", ctypes.c_int),
+        ("window_title", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("cycle", ctypes.c_uint),
+        ("status", ctypes.c_int),
+        ("status_message", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("error_count", ctypes.c_int),
+        ("error_message", ctypes.c_char * PLUGIN_MAXERRORTEXT),
+        ("error_severity", ctypes.c_int),
+        ("write_operations_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("write_operations", ctypes.c_int64),
+        ("read_operations_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("read_operations", ctypes.c_int64),
+        ("verify_operations_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("verify_operations", ctypes.c_int64),
+        ("user_defined_1_used", ctypes.c_bool),
+        ("user_defined_1_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_1_value", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_2_used", ctypes.c_bool),
+        ("user_defined_2_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_2_value", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        # Event flags
+        ("new_display_text", ctypes.c_bool),
+        ("new_error", ctypes.c_bool),
+        ("new_status", ctypes.c_bool),
+        ("new_user_defined_1_value", ctypes.c_bool),
+        ("new_user_defined_2_value", ctypes.c_bool),
+        ("test_stopped", ctypes.c_bool),
+        # V# of Interface. BurnInTest 6.0.1000 (BIT601000.0005)
+        # Data sent to BIT from plugin
+        ("user_defined_3_used", ctypes.c_bool),
+        ("user_defined_3_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_3_value", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_4_used", ctypes.c_bool),
+        ("user_defined_4_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_4_value", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_5_used", ctypes.c_bool),
+        ("user_defined_5_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_5_value", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_6_used", ctypes.c_bool),
+        ("user_defined_6_text", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        ("user_defined_6_value", ctypes.c_char * PLUGIN_MAXDISPLAYTEXT),
+        # V4 of Interface. BurnInTest 7.0.1000
+        ("error_message_long", ctypes.c_char * PLUGIN_MAXERRORTEXTLONG),
+    ]
+
+
+class BitInterface:
+    def __init__(
+        self,
+        key: str,
+        window_title: str,
+        wait_callback: Optional[Callable[[], None]] = None,
+    ):
+        self._wait_callback = wait_callback or (lambda: time.sleep(0.01))
+        self._mem = shared_memory.SharedMemory(key, False)
+        self._struct = BitInterfaceStructure.from_buffer(self._mem.buf)  # type: ignore
+
+        self._struct.interface_version = PLUGIN_INTERFACE_VERSION
+
+        self._struct.cycle = 0
+        self._struct.error_count = 0
+        self._struct.error_severity = ErrorSeverity.ERRORNONE.value
+        self._struct.status = PluginStatus.PLUGIN_NOSTATUS.value
+
+        self._struct.write_operations = -1
+        self._struct.read_operations = -1
+        self._struct.verify_operations = -1
+
+        self._struct.new_error = False
+        self._struct.new_status = False
+        self._struct.test_stopped = False
+
+        self._set_string(self._struct.window_title, window_title)
+        self._set_string(self._struct.status_message, "Starting")
+        self._set_string(self._struct.error_message, "")
+        self._set_string(self._struct.write_operations_text, "Write:")
+        self._set_string(self._struct.read_operations_text, "Read:")
+        self._set_string(self._struct.verify_operations_text, "Verify:")
+        self._struct.new_display_text = True
+
+    @property
+    def test_running(self) -> bool:
+        return bool(self._struct.test_running == 1)
+
+    @property
+    def duty_cycle(self) -> int:
+        return int(self._struct.duty_cycle)
+
+    @property
+    def cycle(self) -> int:
+        return int(self._struct.cycle)
+
+    @cycle.setter
+    def cycle(self, value: int) -> None:
+        self._struct.cycle = value
+
+    @property
+    def error_count(self) -> int:
+        return self._struct.error_count
+
+    @property
+    def write_operations_text(self) -> str:
+        return self._struct.write_operations_text.decode("utf-8")
+
+    @write_operations_text.setter
+    def write_operations_text(self, value: str) -> None:
+        self._set_string(self._struct.write_operations_text, value)
+
+    @property
+    def write_operations(self) -> int:
+        return self._struct.write_operations
+
+    @write_operations.setter
+    def write_operations(self, value: int) -> None:
+        self._struct.write_operations = value
+
+    @property
+    def read_operations_text(self) -> str:
+        return self._struct.read_operations_text.decode("utf-8")
+
+    @read_operations_text.setter
+    def read_operations_text(self, value: str) -> None:
+        self._set_string(self._struct.read_operations_text, value)
+
+    @property
+    def read_operations(self) -> int:
+        return self._struct.read_operations
+
+    @read_operations.setter
+    def read_operations(self, value: int) -> None:
+        self._struct.read_operations = value
+
+    @property
+    def verify_operations_text(self) -> str:
+        return self._struct.verify_operations_text.decode("utf-8")
+
+    @verify_operations_text.setter
+    def verify_operations_text(self, value: str) -> None:
+        self._set_string(self._struct.verify_operations_text, value)
+
+    @property
+    def verify_operations(self) -> int:
+        return self._struct.verify_operations
+
+    @verify_operations.setter
+    def verify_operations(self, value: int) -> None:
+        self._struct.verify_operations = value
+
+    def set_status(
+        self, status: PluginStatus, message: str, wait: bool = False
+    ) -> None:
+        if len(message) > PLUGIN_MAXDISPLAYTEXT:
+            raise ValueError("Status message too long")
+
+        self._wait_for_status()
+        self._struct.status = status.value
+        self._set_string(self._struct.status_message, message)
+        self._struct.new_status = True
+
+        if wait:
+            self._wait_for_status()
+
+    def set_error(
+        self, severity: ErrorSeverity, message: str, wait: bool = False
+    ) -> None:
+        if len(message) > PLUGIN_MAXERRORTEXT:
+            raise ValueError("Error message too long")
+
+        self._wait_for_error()
+
+        if severity.value > ErrorSeverity.ERRORWARNING.value:
+            self._struct.error_count += 1
+
+        self._struct.error_severity = severity.value
+        self._set_string(self._struct.error_message, message)
+        self._struct.new_error = True
+
+        if wait:
+            self._wait_for_error()
+
+    def set_pretest_complete(self, wait: bool = False) -> None:
+        self._struct.status = PluginStatus.PRE_TEST_PLUGIN_COMPLETED.value
+        self._struct.new_status = True
+
+        if wait:
+            self._wait_for_status()
+
+    def _set_string(self, struct_field, text: str) -> None:
+        """Encodes string to utf-8 and truncates to fit the ctypes char array safely."""
+        max_bytes = len(struct_field) - 1  # Leave 1 byte for null terminator
+        encoded = text.encode("utf-8")[:max_bytes]
+        struct_field.value = encoded
+
+    def _wait_for_error(self) -> None:
+        while self.test_running and self._struct.new_error:
+            self._wait_callback()
+
+    def _wait_for_status(self) -> None:
+        while self.test_running and self._struct.new_status:
+            self._wait_callback()
+
+    def close(self):
+        try:
+            self._wait_for_error()
+            self._wait_for_status()
+            self._mem.close()
+        except Exception:
+            pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __del__(self):
+        self.close()

burnintest_plugin-0.1.0/uv.lock

@@ -0,0 +1,7 @@
+version = 1
+revision = 2
+requires-python = ">=3.11"
+
+[[package]]
+name = "burnintest-plugin"
+source = { editable = "." }