trcc-linux 9.7.2__tar.gz → 9.7.4__tar.gz

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.7.2
+Version: 9.7.4
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.7.2"
+version = "9.7.4"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.7.2"
+__version__ = "9.7.4"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

trcc_linux-9.7.4/src/trcc/adapters/device/_pyusb_find.py

@@ -0,0 +1,43 @@
+"""PyUSB ``find()`` seam — uses libusb_package's bundled backend on Windows.
+
+PyUSB needs ``libusb-1.0`` userspace to talk to USB devices.  Linux/macOS/BSD
+ship it via the system package manager; **Windows has no system libusb**, so
+pip-installed *and* PyInstaller-frozen users hit
+``usb.core.NoBackendError: No backend available`` (#131, and again #187/#188 once
+the GUI launch crash was fixed and discovery actually ran).
+
+The canonical fix is `libusb-package <https://github.com/pyocd/libusb-package>`_
+(pyocd's project): a Windows wheel that bundles ``libusb-1.0.dll`` and exposes a
+``find()`` that loads that bundled DLL **explicitly by path** — not via the
+flaky ``ctypes``/PATH search that bare ``usb.core.find`` relies on.  It's a
+Windows-only dependency in ``pyproject.toml``.
+
+This module is the ONE seam every ``usb.core.find`` call goes through, so there
+is exactly one place that knows about the Windows backend quirk (the cutover
+dropped this seam and reverted every call site to bare ``usb.core.find``, which
+is what reintroduced the crash).  Importing ``libusb_package`` here is also what
+makes PyInstaller bundle the module + its DLL into the frozen Windows build.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+try:
+    from libusb_package import find as _find  # pyright: ignore[reportMissingImports]
+    log.debug("pyusb backend: libusb-package (bundled libusb-1.0)")
+except ImportError:
+    from usb.core import find as _find
+    log.debug("pyusb backend: system libusb via usb.core.find")
+
+
+def find(*args: Any, **kwargs: Any) -> Any:
+    """Drop-in for ``usb.core.find()`` with a Windows-compatible backend.
+
+    Identical signature + return type.  Routes through ``libusb_package.find``
+    where it's installed (Windows, via the bundled DLL) and falls back to
+    ``usb.core.find`` everywhere else (Linux/macOS/BSD system libusb).
+    """
+    return _find(*args, **kwargs)

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/device/bulk_lcd.py

@@ -15,7 +15,6 @@ import logging
 import struct
 
 from ...core.errors import (
-    DeviceDisconnectedError,
     HandshakeError,
     TransportError,
 )
@@ -194,68 +193,23 @@ class BulkLcd(Device[BulkTransport]):
                   self.info.key, len(frame),
                   "JPEG" if self._profile.jpeg else "RGB565", width, height)
 
-        # Two-attempt loop with reconnect between attempts.  KVM USB
-        # passthrough + slower hubs intermittently NAK a frame; legacy
-        # ``BulkDevice.send_frame:199-225`` handled this by closing,
-        # re-handshaking, and retrying once before giving up.  The
-        # outer except hands the FINAL error to the recovery tracker
-        # so the per-frame retry doesn't burn G14's consecutive-error
-        # budget.
-        last_exc: BaseException | None = None
-        for attempt in range(2):
-            try:
-                for offset in range(0, len(frame), _WRITE_CHUNK_SIZE):
-                    self._transport.write(
-                        _EP_WRITE, frame[offset:offset + _WRITE_CHUNK_SIZE],
-                        _WRITE_TIMEOUT_MS,
-                    )
-                # Zero-length packet on 512-byte alignment (frame delimiter)
-                if len(frame) % 512 == 0:
-                    self._transport.write(_EP_WRITE, b"", _WRITE_TIMEOUT_MS)
-                break  # success
-            except Exception as e:
-                last_exc = e
-                if attempt == 0:
-                    log.warning(
-                        "BulkLcd %s: send attempt 1 failed (%s) — "
-                        "reconnecting and retrying",
-                        self.info.key, e,
-                    )
-                    try:
-                        self._transport.close()
-                        self._transport.open()
-                        self.connect()
-                    except Exception as reconnect_err:
-                        log.warning(
-                            "BulkLcd %s: reconnect failed: %s",
-                            self.info.key, reconnect_err,
-                        )
-                        # Fall through — second attempt will likely also
-                        # raise, and the recovery tracker handles it.
-                    continue
-                # Second attempt also failed — defer to the tracker.
-                verdict = self._recovery.note_error(e)
-                if verdict == "threshold":
-                    try:
-                        self._transport.close()
-                    except OSError as close_err:
-                        log.debug("BulkLcd %s: close raised: %s",
-                                  self.info.key, close_err)
-                    raise DeviceDisconnectedError(
-                        f"BulkLcd {self.info.key} disconnected after "
-                        f"{self._recovery.consecutive_failures} consecutive failures",
-                    ) from e
-                return False
-        else:  # pragma: no cover — 'break' or 'return' always exits
-            log.debug("BulkLcd %s: send loop exhausted; last_exc=%s",
-                      self.info.key, last_exc)
-            return False
-
-        recovered = self._recovery.note_success()
-        if recovered:
-            log.info("BulkLcd %s: send recovered after %d disconnect failure(s)",
-                     self.info.key, recovered)
-        return True
+        def _write_frame() -> bool:
+            for offset in range(0, len(frame), _WRITE_CHUNK_SIZE):
+                self._transport.write(
+                    _EP_WRITE, frame[offset:offset + _WRITE_CHUNK_SIZE],
+                    _WRITE_TIMEOUT_MS,
+                )
+            # Zero-length packet on 512-byte alignment (frame delimiter)
+            if len(frame) % 512 == 0:
+                self._transport.write(_EP_WRITE, b"", _WRITE_TIMEOUT_MS)
+            return True
+
+        # Shared reconnect + recovery policy (base Device): one in-place
+        # close→open→handshake retry absorbs the intermittent NAKs that KVM
+        # USB passthrough / slow hubs produce (legacy ``BulkDevice.send_frame``
+        # did the same) and heals a stale handle after resume, before
+        # escalating the final error to the recovery tracker.
+        return self._send_with_recovery(_write_frame)
 
     def disconnect(self) -> None:
         log.info("BulkLcd %s: disconnecting", self.info.key)

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/device/hid_lcd.py

@@ -17,7 +17,6 @@ import struct
 import time
 
 from ...core.errors import (
-    DeviceDisconnectedError,
     HandshakeError,
     UnsupportedOperationError,
 )
@@ -176,47 +175,25 @@ class HidLcd(Device[BulkTransport]):
         timeout = _frame_timeout_ms(len(packet))
         log.debug("HidLcd %s (type %d): sending %d-byte packet",
                   self.info.key, self.info.device_type, len(packet))
-        try:
+        def _write_frame() -> bool:
             transferred = self._transport.write(_EP_WRITE, packet, timeout)
             if transferred == 0:
                 log.warning("HidLcd %s: write returned 0 transferred", self.info.key)
                 return False
-
             if self.info.device_type == 2:
                 time.sleep(_DELAY_FRAME_TYPE2_S)
-                ok = transferred == len(packet)
-            else:
-                ack = self._transport.read(
-                    _EP_READ, _TYPE3_ACK_SIZE, _DEFAULT_FRAME_TIMEOUT_MS,
-                )
-                if not ack:
-                    log.warning(
-                        "HidLcd %s: Type 3 ACK read returned empty",
-                        self.info.key,
-                    )
-                ok = len(ack) > 0
-        except Exception as e:
-            verdict = self._recovery.note_error(e)
-            if verdict == "threshold":
-                try:
-                    self._transport.close()
-                except OSError as close_err:
-                    log.debug("HidLcd %s: close raised: %s",
-                              self.info.key, close_err)
-                raise DeviceDisconnectedError(
-                    f"HidLcd {self.info.key} disconnected after "
-                    f"{self._recovery.consecutive_failures} consecutive failures",
-                ) from e
-            return False
-
-        if ok:
-            recovered = self._recovery.note_success()
-            if recovered:
-                log.info(
-                    "HidLcd %s: send recovered after %d disconnect failure(s)",
-                    self.info.key, recovered,
-                )
-        return ok
+                return transferred == len(packet)
+            ack = self._transport.read(
+                _EP_READ, _TYPE3_ACK_SIZE, _DEFAULT_FRAME_TIMEOUT_MS,
+            )
+            if not ack:
+                log.warning("HidLcd %s: Type 3 ACK read returned empty", self.info.key)
+            return len(ack) > 0
+
+        # Shared reconnect + recovery policy (base Device): a transport error
+        # gets one in-place close→open→handshake retry (heals a stale handle
+        # after resume, #189) before escalating to the recovery tracker.
+        return self._send_with_recovery(_write_frame)
 
     def disconnect(self) -> None:
         log.info("HidLcd %s: disconnecting", self.info.key)

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/device/led.py

@@ -19,7 +19,6 @@ import time
 from pathlib import Path
 
 from ...core.errors import (
-    DeviceDisconnectedError,
     HandshakeError,
     TransportError,
     UnsupportedOperationError,
@@ -360,36 +359,24 @@ class Led(Device[BulkTransport]):
             log.debug("Led %s: already sending — skipped", self.info.key)
             return False
 
-        try:
-            try:
-                remaining = len(packet)
-                offset = 0
-                while remaining > 0:
-                    chunk_size = min(remaining, _HID_REPORT_SIZE)
-                    chunk = packet[offset:offset + chunk_size]
-                    if len(chunk) < _HID_REPORT_SIZE:
-                        chunk = chunk + b"\x00" * (_HID_REPORT_SIZE - len(chunk))
-                    self._transport.write(_EP_WRITE, chunk, _DEFAULT_TIMEOUT_MS)
-                    remaining -= chunk_size
-                    offset += chunk_size
-            except Exception as e:
-                verdict = self._recovery.note_error(e)
-                if verdict == "threshold":
-                    try:
-                        self._transport.close()
-                    except OSError as close_err:
-                        log.debug("Led %s: close raised: %s",
-                                  self.info.key, close_err)
-                    raise DeviceDisconnectedError(
-                        f"Led {self.info.key} disconnected after "
-                        f"{self._recovery.consecutive_failures} consecutive failures",
-                    ) from e
-                return False
-            recovered = self._recovery.note_success()
-            if recovered:
-                log.info("Led %s: send recovered after %d disconnect failure(s)",
-                         self.info.key, recovered)
+        def _write_packet() -> bool:
+            remaining = len(packet)
+            offset = 0
+            while remaining > 0:
+                chunk_size = min(remaining, _HID_REPORT_SIZE)
+                chunk = packet[offset:offset + chunk_size]
+                if len(chunk) < _HID_REPORT_SIZE:
+                    chunk = chunk + b"\x00" * (_HID_REPORT_SIZE - len(chunk))
+                self._transport.write(_EP_WRITE, chunk, _DEFAULT_TIMEOUT_MS)
+                remaining -= chunk_size
+                offset += chunk_size
             return True
+
+        try:
+            # Shared reconnect + recovery policy: one in-place close→open→
+            # handshake retry heals a stale handle (e.g. EIO after resume),
+            # then escalates to the recovery tracker.  (base Device)
+            return self._send_with_recovery(_write_packet)
         finally:
             self._send_lock.release()
 

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/device/ly_lcd.py

@@ -20,7 +20,6 @@ import logging
 import struct
 
 from ...core.errors import (
-    DeviceDisconnectedError,
     HandshakeError,
     TransportError,
 )
@@ -184,7 +183,7 @@ class LyLcd(Device[BulkTransport]):
         total_bytes = padded_chunks * _CHUNK_SIZE
         send_buf = bytes(chunks) + bytes(total_bytes - len(chunks))
 
-        try:
+        def _write_frame() -> bool:
             pos = 0
             while pos < total_bytes:
                 remaining = total_bytes - pos
@@ -196,27 +195,14 @@ class LyLcd(Device[BulkTransport]):
                     _EP_WRITE, send_buf[pos:pos + write_size], _WRITE_TIMEOUT_MS,
                 )
                 pos += _USB_WRITE_SIZE
-
             # ACK read
             self._transport.read(_EP_READ, _HANDSHAKE_READ_SIZE, _READ_TIMEOUT_MS)
-        except Exception as e:
-            verdict = self._recovery.note_error(e)
-            if verdict == "threshold":
-                try:
-                    self._transport.close()
-                except OSError as close_err:
-                    log.debug("LyLcd %s: close raised: %s",
-                              self.info.key, close_err)
-                raise DeviceDisconnectedError(
-                    f"LyLcd {self.info.key} disconnected after "
-                    f"{self._recovery.consecutive_failures} consecutive failures",
-                ) from e
-            return False
-        recovered = self._recovery.note_success()
-        if recovered:
-            log.info("LyLcd %s: send recovered after %d disconnect failure(s)",
-                     self.info.key, recovered)
-        return True
+            return True
+
+        # Shared reconnect + recovery policy (base Device): a transport error
+        # gets one in-place close→open→handshake retry (heals a stale handle
+        # after resume, #189) before escalating to the recovery tracker.
+        return self._send_with_recovery(_write_frame)
 
     def disconnect(self) -> None:
         log.info("LyLcd %s: disconnecting", self.info.key)

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/device/scsi_lcd.py

@@ -14,7 +14,6 @@ import time
 import zlib
 
 from ...core.errors import (
-    DeviceDisconnectedError,
     HandshakeError,
     TransportError,
 )
@@ -180,7 +179,7 @@ class ScsiLcd(Device[ScsiTransport]):
 
         log.debug("ScsiLcd %s: sending %d bytes in %d chunk(s)",
                   self.info.key, total, len(chunks))
-        try:
+        def _write_frame() -> bool:
             offset = 0
             for cmd, size in chunks:
                 cdb = self._build_cdb(cmd, size)
@@ -195,33 +194,12 @@ class ScsiLcd(Device[ScsiTransport]):
                     )
                     return False
                 offset += size
-        except Exception as e:
-            verdict = self._recovery.note_error(e)
-            if verdict == "threshold":
-                self._close_transport_quietly()
-                raise DeviceDisconnectedError(
-                    f"ScsiLcd {self.info.key} disconnected after "
-                    f"{self._recovery.consecutive_failures} consecutive failures",
-                ) from e
-            return False
-        recovered = self._recovery.note_success()
-        if recovered:
-            log.info("ScsiLcd %s: send recovered after %d disconnect failure(s)",
-                     self.info.key, recovered)
-        return True
-
-    def _close_transport_quietly(self) -> None:
-        """Best-effort transport close used by the recovery path.
+            return True
 
-        The real :meth:`disconnect` also resets handshake/profile; that
-        state is preserved here so an immediate reconnect attempt can
-        re-use the cached identity.
-        """
-        try:
-            self._transport.close()
-        except OSError as e:
-            log.debug("ScsiLcd %s: transport close raised: %s",
-                      self.info.key, e)
+        # Shared reconnect + recovery policy (base Device): a transport error
+        # gets one in-place close→open→handshake retry (heals a stale handle
+        # after resume, #189) before escalating to the recovery tracker.
+        return self._send_with_recovery(_write_frame)
 
     def disconnect(self) -> None:
         log.info("ScsiLcd %s: disconnecting", self.info.key)

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/device/transport.py

@@ -19,6 +19,7 @@ import usb.util
 
 from ...core.errors import PermissionError_, TransportError
 from ...core.ports import BulkTransport
+from ._pyusb_find import find as usb_find
 
 # Optional hidapi backend (the [hid] extra)
 try:
@@ -79,7 +80,7 @@ class PyUsbBulkTransport(BulkTransport):
         if self._serial:
             kwargs['serial_number'] = self._serial
 
-        self._device = usb.core.find(**kwargs)
+        self._device = usb_find(**kwargs)
         if self._device is None:
             log.error("USB device %04X:%04X not found", self._vid, self._pid)
             return False
@@ -203,7 +204,7 @@ class PyUsbBulkTransport(BulkTransport):
         }
         if self._serial:
             kwargs['serial_number'] = self._serial
-        new_device = usb.core.find(**kwargs)
+        new_device = usb_find(**kwargs)
         if new_device is None:
             raise TransportError(
                 f"USB device {self._vid:04X}:{self._pid:04X} disappeared "

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/diagnostics/health.py

@@ -70,7 +70,7 @@ class HealthReport:
 # =========================================================================
 
 
-def check_python_version() -> HealthCheckResult:
+def check_python_version(platform: Platform) -> HealthCheckResult:
     """Python ≥ 3.11 is the project minimum (match-statement + slots)."""
     log.info("check_python_version: called")
     major, minor = sys.version_info[:2]
@@ -82,7 +82,7 @@ def check_python_version() -> HealthCheckResult:
     return HealthCheckResult(
         name="python-version", severity="FAIL",
         message=f"Python {major}.{minor} is below the 3.11 minimum",
-        fix_hint="Install Python 3.11+ via your distro package manager",
+        fix_hint=platform.software_install_hint("python"),
     )
 
 
@@ -143,9 +143,7 @@ def check_devices_visible(platform: Platform) -> HealthCheckResult:
         return HealthCheckResult(
             name="devices-visible", severity="WARN",
             message="No Thermalright devices detected on USB",
-            fix_hint=("Plug in a supported device and re-run; check udev "
-                      "rules with `trcc system doctor` if the device is "
-                      "physically attached"),
+            fix_hint=platform.no_devices_hint(),
         )
     return HealthCheckResult(
         name="devices-visible", severity="OK",
@@ -228,7 +226,7 @@ def check_gpu_sensors(platform: Platform) -> HealthCheckResult:
             name="gpu-sensors", severity="WARN",
             message="NVIDIA GPU detected but the pynvml reader is not installed "
                     "— GPU metrics will be empty",
-            fix_hint=package_install_hint("python3-pynvml")
+            fix_hint=platform.software_install_hint("pynvml")
                      + " (the trcc-linux package should pull this in)",
         )
     return HealthCheckResult(
@@ -238,7 +236,7 @@ def check_gpu_sensors(platform: Platform) -> HealthCheckResult:
     )
 
 
-def check_ffmpeg_present() -> HealthCheckResult:
+def check_ffmpeg_present(platform: Platform) -> HealthCheckResult:
     """ffmpeg is required for video themes; absence is WARN (still usable
     for image-only themes)."""
     log.info("check_ffmpeg_present: called")
@@ -250,8 +248,8 @@ def check_ffmpeg_present() -> HealthCheckResult:
     return HealthCheckResult(
         name="ffmpeg", severity="WARN",
         message="ffmpeg not on PATH",
-        fix_hint="Install ffmpeg via your distro package manager — "
-                 "image themes still work without it",
+        fix_hint=platform.software_install_hint("ffmpeg")
+                 + " — image themes still work without it",
     )
 
 
@@ -299,7 +297,7 @@ def check_udev_rules_linux() -> HealthCheckResult:
     )
 
 
-def check_seven_zip_present() -> HealthCheckResult:
+def check_seven_zip_present(platform: Platform) -> HealthCheckResult:
     """``7z`` is required for theme-pack extraction.  Absence is WARN —
     user can still install themes via tarballs or the cloud catalog."""
     log.info("check_seven_zip_present: called")
@@ -311,7 +309,7 @@ def check_seven_zip_present() -> HealthCheckResult:
     return HealthCheckResult(
         name="7z", severity="WARN",
         message="7z not on PATH",
-        fix_hint="Install p7zip-full / p7zip / 7zip via your package manager",
+        fix_hint=platform.software_install_hint("7z"),
     )
 
 
@@ -325,16 +323,16 @@ def run_health_checks(platform: Platform) -> HealthReport:
     log.info("run_health_checks: starting")
     paths = platform.paths()
     checks: list[HealthCheckResult] = [
-        check_python_version(),
+        check_python_version(platform),
         check_log_writable(paths),
         check_config_writable(paths),
         check_devices_visible(platform),
         check_sensors_enumerable(platform),
         check_gpu_sensors(platform),
-        check_ffmpeg_present(),
+        check_ffmpeg_present(platform),
         check_qt_importable(),
         check_udev_rules_linux(),
-        check_seven_zip_present(),
+        check_seven_zip_present(platform),
     ]
     for c in checks:
         log.info("  %s [%s]: %s", c.name, c.severity, c.message)

{trcc_linux-9.7.2 → trcc_linux-9.7.4}/src/trcc/adapters/sensors/_lhm.py

@@ -175,6 +175,7 @@ class LhmSubprocess:
         "_owned_process",
         "_probe",
         "_spawn",
+        "_unavailable",
         "_wait",
     )
 
@@ -190,6 +191,9 @@ class LhmSubprocess:
         self._wait = wait
         self._owned_process: subprocess.Popen[bytes] | None = None
         self._namespace_handle: Any = None
+        # True once a spawn attempt found no bundled exe — stops us
+        # re-attempting (and re-warning) on every poll.
+        self._unavailable = False
 
     @property
     def namespace(self) -> Any:
@@ -198,10 +202,12 @@ class LhmSubprocess:
     def start(self) -> Any:
         """Return the WMI namespace handle, spawning LHM if needed.
 
-        Idempotent — once a handle is cached, subsequent ``start()``
-        calls just return it.  Returns ``None`` when LHM isn't running
-        AND the bundled exe isn't available AND the namespace doesn't
-        register after spawning.
+        Idempotent AND spawn-safe — once a handle is cached, subsequent
+        ``start()`` calls just return it; and we NEVER spawn a second LHM
+        while one we already launched is still pending (the bug behind the
+        "multiple LibreHardwareMonitor windows", #191).  Returns ``None``
+        when LHM isn't running AND the bundled exe isn't available AND the
+        namespace doesn't register after spawning.
         """
         if self._namespace_handle is not None:
             return self._namespace_handle
@@ -212,12 +218,26 @@ class LhmSubprocess:
             self._namespace_handle = existing
             return existing
 
+        # We already launched LHM — its WMI namespace just hasn't registered
+        # yet (or never will).  Wait on THAT process; never spawn a second
+        # copy.  This is the #191 fix: without it, a slow/failed namespace
+        # registration made every poll spawn another LibreHardwareMonitor.
+        if self._owned_process is not None:
+            self._namespace_handle = self._wait()
+            return self._namespace_handle
+
+        # A previous spawn found no bundled exe — don't retry it (or re-warn)
+        # on every poll.  Cleared by stop() so a fresh session can try again.
+        if self._unavailable:
+            return None
+
         self._owned_process = self._spawn()
         if self._owned_process is None:
             log.warning(
                 "LibreHardwareMonitor not running and bundled exe not "
                 "found; LHM sensor source unavailable",
             )
+            self._unavailable = True
             return None
         log.info("Spawned LibreHardwareMonitor (pid=%d)",
                  self._owned_process.pid)
@@ -234,6 +254,7 @@ class LhmSubprocess:
     def stop(self) -> None:
         """Terminate the LHM subprocess if WE spawned it; else no-op."""
         self._namespace_handle = None
+        self._unavailable = False
         if self._owned_process is None:
             return
         try: