trcc-linux 9.10.2__tar.gz → 9.10.3__tar.gz

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: trcc-linux
-Version: 9.10.2
+Version: 9.10.3
 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
@@ -90,8 +90,8 @@ Description-Content-Type: text/markdown
 [![Platform](https://img.shields.io/badge/platform-Linux-FCC624?logo=linux&logoColor=black)](https://github.com/Lexonight1/thermalright-trcc-linux)
 
 [![CI](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml/badge.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
-[![Tests](https://img.shields.io/badge/tests-5827_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
-[![Coverage](https://img.shields.io/badge/coverage-8%25-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
+[![Tests](https://img.shields.io/badge/tests-27121_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/badge/coverage-0%25-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
 [![Code Style](https://img.shields.io/badge/code_style-ruff-D7FF64?logo=ruff&logoColor=black)](https://docs.astral.sh/ruff/)
 [![Type Check](https://img.shields.io/badge/type_check-pyright-blue?logo=python&logoColor=white)](https://microsoft.github.io/pyright/)

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/README.md

@@ -17,8 +17,8 @@
 [![Platform](https://img.shields.io/badge/platform-Linux-FCC624?logo=linux&logoColor=black)](https://github.com/Lexonight1/thermalright-trcc-linux)
 
 [![CI](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml/badge.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
-[![Tests](https://img.shields.io/badge/tests-5827_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
-[![Coverage](https://img.shields.io/badge/coverage-8%25-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
+[![Tests](https://img.shields.io/badge/tests-27121_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/badge/coverage-0%25-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
 [![Code Style](https://img.shields.io/badge/code_style-ruff-D7FF64?logo=ruff&logoColor=black)](https://docs.astral.sh/ruff/)
 [![Type Check](https://img.shields.io/badge/type_check-pyright-blue?logo=python&logoColor=white)](https://microsoft.github.io/pyright/)

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/pyproject.toml

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

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/__version__.py

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

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/device/_base.py

@@ -29,7 +29,7 @@ from typing import Any, ClassVar
 
 from ...core.errors import DeviceNotFoundError, HandshakeError, TransportError
 from ...core.factory import Registry, Reject
-from ...core.logs import per_frame, trace
+from ...core.logs import Blob, per_frame, trace
 from ...core.models import HandshakeResult, ProductInfo, Wire
 from ...core.ports import BulkTransport, Device, T
 from ...core.protocol import DeviceProfile
@@ -149,7 +149,7 @@ class BaseDevice(Device[T]):
         there, and the logger is the SUBCLASS's module so a report still says
         which wire spoke.
         """
-        log.debug("_trace_reply: resp=%s", resp)
+        log.debug("_trace_reply: resp=%s", Blob(resp))
         trace(logging.getLogger(type(self).__module__),
               "%s raw handshake reply (%d bytes, first %d): %s",
               self.info.key, len(resp), min(len(resp), _TRACE_REPLY_BYTES),
@@ -171,7 +171,8 @@ class BaseDevice(Device[T]):
         encoding it picked, the PID variant, the LED style.  Returns a string
         that already carries its own leading space, or empty.
         """
-        log.debug("_handshake_detail: result=%s", result)
+        log.debug("_handshake_detail: result=%s raw=%s",
+                  result, Blob(result.raw_response))
         return ""
 
     def _open_transport(self) -> None:
@@ -200,7 +201,7 @@ class BaseDevice(Device[T]):
            reconnect-and-retry / consecutive-failure escalation every wire
            shares (``core.ports.Device``).
         """
-        frame_log.debug("send: payload=%s", payload)
+        frame_log.debug("send: payload=%s", Blob(payload))
         self._require_connected()
         frame = self._prepare_frame(payload)
         return self._send_with_recovery(partial(self._write_frame, frame))

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

@@ -0,0 +1,113 @@
+"""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).
+    """
+    log.debug("find")
+    return _find(*args, **kwargs)
+
+
+def usb_path(dev: Any) -> str | None:
+    """Where this unit is PLUGGED IN, as a stable string — or ``None``.
+
+    Two identical coolers share a VID/PID and ship no serial, so nothing in
+    the USB descriptor tells them apart (#287).  What does is the topology:
+    they are in different ports.  ``usb_find(find_all=True)`` already yields
+    one object per physical unit and that object carries the answer; this
+    tree read ``iSerialNumber`` and ``bcdDevice`` off it and dropped the rest.
+
+    Format is the kernel's own USB topology name — ``1-14``, ``1-2.3`` —
+    because it is the one a user can check against ``lsusb -t`` and ``dmesg``
+    when a report says which panel did what.
+
+    **Port chain first, address second, and the difference matters.**  The
+    port chain is where the cable is: it survives a replug and a reboot, so it
+    can key persisted settings.  ``address`` is handed out by the host
+    controller and is reassigned on every replug — usable to tell two units
+    apart *right now*, never to remember which was which.  It is the fallback
+    only, spelled ``@`` so the two can never be confused on sight.
+
+    ``None`` is a real answer.  PyUSB sets ``bus`` / ``address`` /
+    ``port_number`` to ``None`` whenever the backend does not supply them
+    (``usb.core.Device.__init__``), so this is guarded on EVERY platform, not
+    just the ones we cannot test on.  A caller that gets ``None`` has learned
+    that this host cannot tell two identical units apart.
+    """
+    bus = getattr(dev, "bus", None)
+    if bus is None:
+        log.debug("usb_path: backend supplied no bus — not addressable")
+        return None
+    ports = getattr(dev, "port_numbers", None) or ()
+    if ports:
+        path = f"{int(bus)}-{'.'.join(str(int(p)) for p in ports)}"
+        log.debug("usb_path: %s (port chain — stable across replug)", path)
+        return path
+    address = getattr(dev, "address", None)
+    if address is None:
+        log.debug("usb_path: bus %s but no ports and no address", bus)
+        return None
+    path = f"{int(bus)}@{int(address)}"
+    log.debug("usb_path: %s (ADDRESS — changes on replug)", path)
+    return path
+
+
+def find_unit(vid: int, pid: int, unit: str) -> Any:
+    """The device of *vid:pid* plugged into *unit*, or ``None``.
+
+    ``find(idVendor=, idProduct=)`` returns whichever unit libusb lists
+    first, which is why two identical coolers both opened the same panel and
+    the second ``claim_interface`` failed with "in use by another process"
+    (#287).  This asks for a specific one instead.
+
+    An empty *unit* means "the only one of this model" and is NOT a match-all
+    here — callers that mean that call :func:`find` directly, so this function
+    can never silently hand back an arbitrary device when the caller asked for
+    a named one.
+    """
+    if not unit:
+        log.debug("find_unit: no unit asked for")
+        return None
+    for dev in find(find_all=True, idVendor=vid, idProduct=pid) or []:
+        if usb_path(dev) == unit:
+            log.info("find_unit: %04x:%04x at %s", vid, pid, unit)
+            return dev
+    log.warning("find_unit: %04x:%04x has no unit at %s — it may have been "
+                "unplugged or moved to another port", vid, pid, unit)
+    return None

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/device/bulk_lcd.py

@@ -18,7 +18,7 @@ from ...core.errors import (
     HandshakeError,
     TransportError,
 )
-from ...core.logs import per_frame
+from ...core.logs import Blob, per_frame
 from ...core.models import HandshakeResult, ProductInfo, Wire
 from ...core.ports import BulkTransport
 from ...core.protocol import (
@@ -79,7 +79,12 @@ _RGB565_PMS: set[int] = {32}
 # on the bulk path and told maintainers to keep it that way.  That was read off
 # the 2.0.3 decompile, and 2.1.6 falsifies it. (#176/#169)
 _BULK_BASE_FBL = 72
-_BULK_KNOWN_PMS: frozenset[int] = frozenset({5, 7, 9, 10, 11, 12, 32, 64, 65})
+# 20 joined in TRCC 2.1.8: FormCZTV.cs:947 extended the 854x480 branch from
+# (pm 9 || 11) to (pm 9 || 11 || 20).  Without it here the guard sends the panel
+# to the 480x480 fallback -- `audit_devices --exhaustive-bulk` read
+# `pm=20 sub=0: ours=480x480  C#=854x480` before this line.
+_BULK_KNOWN_PMS: frozenset[int] = frozenset(
+    {5, 7, 9, 10, 11, 12, 18, 20, 32, 64, 65})
 
 
 # JPEG start-of-frame markers carry the image's real dimensions.  C4/C8/CC
@@ -244,7 +249,8 @@ class BulkLcd(BaseBulkDevice, wire=Wire.BULK):
         report we had: #262 and #203 turned out to share ``PM=11 SUB=5`` and
         nobody could see it, including me, until I read the C# catalog rule.
         """
-        log.debug("_handshake_detail: result=%s", result)
+        log.debug("_handshake_detail: result=%s raw=%s",
+                  result, Blob(result.raw_response))
         if self._profile is None:
             return ""
         encoder = " (JPEG)" if self._profile.jpeg else " (RGB565)"
@@ -354,7 +360,7 @@ class BulkLcd(BaseBulkDevice, wire=Wire.BULK):
         The ZLP is exempt: it is a zero-length delimiter, so there is no
         payload to come up short.
         """
-        log.debug("_write_frame: frame=%s", frame)
+        log.debug("_write_frame: frame=%s", Blob(frame))
         for offset in range(0, len(frame), _WRITE_CHUNK_SIZE):
             chunk = frame[offset:offset + _WRITE_CHUNK_SIZE]
             if self._transport.write(

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/device/hid_lcd.py

@@ -25,7 +25,7 @@ from ...core.errors import (
     TransportError,
     UnsupportedOperationError,
 )
-from ...core.logs import per_frame
+from ...core.logs import Blob, per_frame
 from ...core.models import HandshakeResult, ProductInfo, Wire
 from ...core.ports import BulkTransport
 from ...core.protocol import DeviceProfile, get_profile, pm_to_fbl
@@ -107,7 +107,8 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
 
     def _handshake_detail(self, result: HandshakeResult) -> str:
         """Which firmware variant answered — the two speak different packets."""
-        log.debug("_handshake_detail: result=%s", result)
+        log.debug("_handshake_detail: result=%s raw=%s",
+                  result, Blob(result.raw_response))
         return f" (type {self.info.device_type})"
 
     def _require_connected(self) -> None:
@@ -316,7 +317,7 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
         #228) — the magic alone is enough to accept it; PM/SUB still parse from
         [5]/[4].
         """
-        log.debug("_validate_response_type2: resp=%s", resp)
+        log.debug("_validate_response_type2: resp=%s", Blob(resp))
         if not (len(resp) >= 6 and resp[0:4] == _TYPE2_MAGIC):
             return False
         if self._quirks.short_handshake:
@@ -338,7 +339,7 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
         panels share: a 1280×480 Trofeo Vision answering PM=128 was transposed
         to 480×1280 and never displayed (#244/#268).
         """
-        log.debug("_parse_response_type2: resp=%s", resp)
+        log.debug("_parse_response_type2: resp=%s", Blob(resp))
         pm = resp[5]
         sub = resp[4]
         has_serial = len(resp) > 36 and resp[16] == 0x10
@@ -370,7 +371,7 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
         fall back to ``info.native_resolution`` so smoke tests that build
         frames before connect() still produce a valid header.
         """
-        log.debug("_build_frame_type2: image_data=%s", image_data)
+        log.debug("_build_frame_type2: image_data=%s", Blob(image_data))
         is_jpeg = len(image_data) >= 2 and image_data[:2] == b'\xff\xd8'
         w, h = (self._profile.resolution if self._profile is not None
                 else self.info.native_resolution)
@@ -406,7 +407,7 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
         duplication ``_f5`` exists to prevent — so widening the set there did not
         widen it here.
         """
-        log.debug("_validate_response_type3: resp=%s", resp)
+        log.debug("_validate_response_type3: resp=%s", Blob(resp))
         return len(resp) >= 14 and resp[0] in _f5.VALID_IDENTITY
 
     def _parse_response_type3(self, resp: bytes) -> HandshakeResult:
@@ -414,7 +415,7 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
 
         Geometry comes from the FBL via ``get_profile`` (PM=FBL for Type 3).
         """
-        log.debug("_parse_response_type3: resp=%s", resp)
+        log.debug("_parse_response_type3: resp=%s", Blob(resp))
         serial = resp[10:14].hex().upper()
         fbl = resp[0] - 1
         # Sized from the identity at handshake, as the vendor does — a panel
@@ -433,7 +434,7 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
 
     def _build_frame_type3(self, image_data: bytes) -> bytes:
         """Type 3 frame: 16-byte prefix + exactly this panel's payload size."""
-        log.debug("_build_frame_type3: image_data=%s", image_data)
+        log.debug("_build_frame_type3: image_data=%s", Blob(image_data))
         size = getattr(self, "_f5_payload", _f5.DATA_SIZE)
         prefix = _f5.frame_header(size)
         if len(image_data) < size:
@@ -457,13 +458,13 @@ class HidLcd(BaseBulkDevice, wire=Wire.HID):
                 else _f5.RESPONSE_SIZE)
 
     def _validate_response(self, resp: bytes) -> bool:
-        log.debug("_validate_response: resp=%s", resp)
+        log.debug("_validate_response: resp=%s", Blob(resp))
         return (self._validate_response_type2(resp)
                 if self.info.device_type == 2
                 else self._validate_response_type3(resp))
 
     def _parse_response(self, resp: bytes) -> HandshakeResult:
-        log.debug("_parse_response: resp=%s", resp)
+        log.debug("_parse_response: resp=%s", Blob(resp))
         return (self._parse_response_type2(resp)
                 if self.info.device_type == 2
                 else self._parse_response_type3(resp))

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/device/led.py

@@ -31,6 +31,7 @@ from ...core.led_protocol import (
     resolve_model_name,
     resolve_pm,
 )
+from ...core.logs import Blob
 from ...core.models import HandshakeResult, LedHandshakeResult, ProductInfo, Wire
 from ...core.ports import BulkTransport
 from ._base import BaseBulkDevice
@@ -211,7 +212,8 @@ class Led(BaseBulkDevice, wire=Wire.LED):
 
     def _handshake_detail(self, result: HandshakeResult) -> str:
         """The resolved style + model — an LED's whole identity."""
-        log.debug("_handshake_detail: result=%s", result)
+        log.debug("_handshake_detail: result=%s raw=%s",
+                  result, Blob(result.raw_response))
         if self._led_handshake is None:
             return ""
         style = self._led_handshake.style
@@ -405,7 +407,7 @@ class Led(BaseBulkDevice, wire=Wire.LED):
 
     def _write_frame(self, frame: bytes) -> bool:
         """Stream the packet as 64-byte HID reports, zero-padding the last."""
-        log.debug("_write_frame: frame=%s", frame)
+        log.debug("_write_frame: frame=%s", Blob(frame))
         remaining = len(frame)
         offset = 0
         while remaining > 0:

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/device/ly_lcd.py

@@ -25,7 +25,7 @@ import struct
 from ...core.errors import (
     HandshakeError,
 )
-from ...core.logs import per_frame
+from ...core.logs import Blob, per_frame
 from ...core.models import HandshakeResult, ProductInfo, Wire
 from ...core.ports import BulkTransport
 from ...core.protocol import (
@@ -204,7 +204,8 @@ class LyLcd(BaseBulkDevice, wire=Wire.LY):
 
     def _handshake_detail(self, result: HandshakeResult) -> str:
         """The PID picks the variant (LY vs LY1) — worth having on the record."""
-        log.debug("_handshake_detail: result=%s", result)
+        log.debug("_handshake_detail: result=%s raw=%s",
+                  result, Blob(result.raw_response))
         return f" (pid=0x{self.info.pid:04x})"
 
     def _prepare_frame(self, payload: bytes) -> bytes:
@@ -249,7 +250,7 @@ class LyLcd(BaseBulkDevice, wire=Wire.LY):
 
     def _write_frame(self, frame: bytes) -> bool:
         """4096-byte USB writes over the chunk buffer, then the 512-byte ACK."""
-        log.debug("_write_frame: frame=%s", frame)
+        log.debug("_write_frame: frame=%s", Blob(frame))
         total_bytes = len(frame)
         pos = 0
         while pos < total_bytes:

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/device/scsi_lcd.py

@@ -13,7 +13,7 @@ import time
 import zlib
 
 from ...core.errors import TransportError
-from ...core.logs import per_frame
+from ...core.logs import Blob, per_frame
 from ...core.models import HandshakeResult, Wire
 from ...core.ports import ScsiTransport
 from ...core.protocol import get_profile
@@ -132,7 +132,8 @@ class ScsiLcd(BaseDevice[ScsiTransport], wire=Wire.SCSI):
 
     def _handshake_detail(self, result: HandshakeResult) -> str:
         """SCSI reports one byte — call it FBL, since PM *is* FBL here."""
-        log.debug("_handshake_detail: result=%s", result)
+        log.debug("_handshake_detail: result=%s raw=%s",
+                  result, Blob(result.raw_response))
         return f" (FBL {result.fbl})"
 
     def _frame_size(self) -> tuple[int, int]:

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/device/transport.py

@@ -19,9 +19,10 @@ import usb.core
 import usb.util
 
 from ...core.errors import PermissionError_, TransportError
-from ...core.logs import per_frame
+from ...core.logs import Blob, per_frame
 from ...core.ports import BulkTransport, WriteBuffer
 from ._pyusb_find import find as usb_find
+from ._pyusb_find import find_unit
 
 # Optional hidapi backend (the [hid] extra)
 try:
@@ -103,26 +104,40 @@ class PyUsbBulkTransport(BulkTransport):
     """
 
     def __init__(self, vid: int, pid: int,
-                 serial: str | None = None) -> None:
+                 serial: str | None = None, unit: str = "") -> None:
         self._vid = vid
         self._pid = pid
         self._serial = serial
+        #: Which physical unit, when several of the model are plugged in
+        #: (#287).  Empty means "the only one", which is every normal user.
+        self._unit = unit
         self._device: Any = None
         self._is_open = False
         self._ep_out: int | None = None
         self._ep_in: int | None = None
-        log.debug("PyUsbBulkTransport.__init__: %04x:%04x serial=%s",
-                  vid, pid, serial or "(any)")
+        log.debug("PyUsbBulkTransport.__init__: %04x:%04x serial=%s unit=%s",
+                  vid, pid, serial or "(any)", unit or "(only)")
 
     def open(self) -> bool:
-        kwargs: dict[str, Any] = {'idVendor': self._vid, 'idProduct': self._pid}
-        if self._serial:
-            kwargs['serial_number'] = self._serial
-
-        self._device = usb_find(**kwargs)
-        if self._device is None:
-            log.error("USB device %04X:%04X not found", self._vid, self._pid)
-            return False
+        if self._unit:
+            # A named unit is never satisfied by "whichever one libusb lists
+            # first" — that is the bug (#287).  Missing means unplugged or
+            # moved, and opening the sibling would drive the wrong panel.
+            self._device = find_unit(self._vid, self._pid, self._unit)
+            if self._device is None:
+                log.error("USB device %04X:%04X not present at unit %s",
+                          self._vid, self._pid, self._unit)
+                return False
+        else:
+            kwargs: dict[str, Any] = {'idVendor': self._vid,
+                                      'idProduct': self._pid}
+            if self._serial:
+                kwargs['serial_number'] = self._serial
+            self._device = usb_find(**kwargs)
+            if self._device is None:
+                log.error("USB device %04X:%04X not found",
+                          self._vid, self._pid)
+                return False
 
         # 1. Detach kernel drivers from interfaces 0..3.  USB cooler
         # firmware presents multiple interfaces (vendor + HID + mass-
@@ -457,12 +472,65 @@ class _HidBinding(ABC):
         Raises one of :meth:`open_errors` when the device is absent or
         inaccessible."""
 
+    @classmethod
+    @abstractmethod
+    def open_path(cls, path: bytes) -> Any:
+        """Open the ONE handle at *path*, hidapi's own device identifier.
+
+        ``open(vid, pid, serial)`` takes whichever unit hidapi lists first,
+        which is why two identical panels both opened the same one (#287).
+        Both supported bindings can do this — MEASURED: cython-hidapi exposes
+        ``device().open_path``, apmorton's constructor takes ``path=`` — so
+        this is a real abstraction over two real APIs, not a hook for one.
+        """
+
+    @classmethod
+    def path_for_unit(cls, vid: int, pid: int, unit: str) -> bytes | None:
+        """hidapi's path for the *unit* USB port, or ``None``.
+
+        Shared: ``hid.enumerate`` is identical in both bindings, and the
+        entry it returns carries ``bus_type``/``path`` but NOT the USB
+        topology — so the two are matched through PyUSB, which does know the
+        port.  One interface's path is enough, since every interface of one
+        physical device hangs off the same port.
+        """
+        from ._pyusb_find import find_unit
+        if not unit or not HIDAPI_AVAILABLE:
+            return None
+        if find_unit(vid, pid, unit) is None:
+            log.warning("path_for_unit: %04x:%04x is not at unit %s",
+                        vid, pid, unit)
+            return None
+        entries = [e for e in hidapi.enumerate(vid, pid) if e.get("path")]
+        log.info("path_for_unit: %04x:%04x unit=%s -> %d hid interface(s)",
+                 vid, pid, unit, len(entries))
+        if len(entries) <= 1:
+            return entries[0]["path"] if entries else None
+        # More than one unit of this model is present, so the first entry is
+        # exactly the coin-flip this exists to avoid.  Ordering hid's
+        # enumeration against PyUSB's is not a mapping either library
+        # promises, so refuse rather than guess wrong half the time.
+        log.warning(
+            "path_for_unit: %d hid entries for %04x:%04x — cannot say which "
+            "is the unit at %s, so it is not used (#287)",
+            len(entries), vid, pid, unit,
+        )
+        return None
+
 
 class _CythonHidBinding(_HidBinding):
     """PyPI ``hidapi`` (cython-hidapi) — ``hid.device``."""
 
     CLASS_ATTR: ClassVar[str] = "device"
 
+    @classmethod
+    def open_path(cls, path: bytes) -> Any:
+        log.info("_CythonHidBinding.open_path: %s", Blob(path))
+        handle = cls._require_class()()        # ctor takes no useful args
+        handle.open_path(path)
+        handle.set_nonblocking(0)
+        return handle
+
     @classmethod
     def open(cls, vid: int, pid: int, serial: str | None) -> Any:
         log.info("_CythonHidBinding.open: %04x:%04x serial=%s",
@@ -478,6 +546,13 @@ class _ApmortonHidBinding(_HidBinding):
 
     CLASS_ATTR: ClassVar[str] = "Device"
 
+    @classmethod
+    def open_path(cls, path: bytes) -> Any:
+        log.info("_ApmortonHidBinding.open_path: %s", Blob(path))
+        handle = cls._require_class()(path=path)
+        handle.nonblocking = 0
+        return handle
+
     @classmethod
     def open(cls, vid: int, pid: int, serial: str | None) -> Any:
         log.info("_ApmortonHidBinding.open: %04x:%04x serial=%s",
@@ -495,7 +570,7 @@ class HidApiTransport(BulkTransport):
     """
 
     def __init__(self, vid: int, pid: int,
-                 serial: str | None = None) -> None:
+                 serial: str | None = None, unit: str = "") -> None:
         if not HIDAPI_AVAILABLE:
             raise ImportError(
                 "no hid binding installed — install EITHER python-hidapi or "
@@ -507,10 +582,12 @@ class HidApiTransport(BulkTransport):
         self._vid = vid
         self._pid = pid
         self._serial = serial
+        #: Which physical unit (#287); empty means "the only one".
+        self._unit = unit
         self._device: Any = None
         self._is_open = False
-        log.debug("HidApiTransport.__init__: %04x:%04x serial=%s",
-                  vid, pid, serial or "(any)")
+        log.debug("HidApiTransport.__init__: %04x:%04x serial=%s unit=%s",
+                  vid, pid, serial or "(any)", unit or "(only)")
 
     def open(self) -> bool:
         binding = _HidBinding.detect()
@@ -533,7 +610,11 @@ class HidApiTransport(BulkTransport):
         last: BaseException | None = None
         for attempt in range(1, _HID_OPEN_ATTEMPTS + 1):
             try:
-                self._device = binding.open(self._vid, self._pid, self._serial)
+                path = binding.path_for_unit(self._vid, self._pid, self._unit)
+                self._device = (
+                    binding.open_path(path) if path is not None
+                    else binding.open(self._vid, self._pid, self._serial)
+                )
                 if attempt > 1:
                     log.info("HidApiTransport.open: %04x:%04x opened on "
                              "attempt %d — the panel was re-enumerating",

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/sensors/_hwinfo.py

@@ -37,7 +37,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Callable
 from typing import Any, NamedTuple
 
-from ...core.logs import per_frame
+from ...core.logs import Blob, per_frame
 from ...core.ports import CpuSource, GpuSource
 
 log = logging.getLogger(__name__)
@@ -80,7 +80,7 @@ _SNAPSHOT_TTL_S = 0.1
 
 def _decode_cstr(blob: bytes) -> str:
     """Decode a fixed-length NUL-terminated C string (latin-1, lossless)."""
-    log.debug("_decode_cstr: blob=%s", blob)
+    log.debug("_decode_cstr: blob=%s", Blob(blob))
     return blob.split(b"\x00", 1)[0].decode("latin-1", errors="replace").strip()
 
 
@@ -100,7 +100,7 @@ class _Header(NamedTuple):
 
 def _parse_header(buf: bytes) -> _Header:
     """Decode the 44-byte header.  Raises ValueError on bad magic / short buffer."""
-    log.debug("_parse_header: buf=%s", buf)
+    log.debug("_parse_header: buf=%s", Blob(buf))
     if len(buf) < _HEADER_SIZE:
         raise ValueError(
             f"HWiNFO header too short: {len(buf)} < {_HEADER_SIZE}",
@@ -134,7 +134,7 @@ class _BytesMapping(_MappingPort):
     """Test seam — wraps a ``bytes`` buffer captured from a real MMF dump."""
 
     def __init__(self, data: bytes) -> None:
-        log.debug("__init__: data=%s", data)
+        log.debug("__init__: data=%s", Blob(data))
         self._data = data
 
     def read(self, offset: int, length: int) -> bytes:
@@ -554,7 +554,7 @@ def discover_hwinfo_gpus(
 
 def _snapshot_from_bytes(data: bytes) -> _Snapshot:
     """Build a snapshot from a raw MMF byte buffer — used by tests."""
-    log.debug("_snapshot_from_bytes: data=%s", data)
+    log.debug("_snapshot_from_bytes: data=%s", Blob(data))
     return _Snapshot(_BytesMapping(data))
 
 

{trcc_linux-9.10.2 → trcc_linux-9.10.3}/src/trcc/adapters/sensors/_smc.py

@@ -33,7 +33,7 @@ import logging
 import struct
 from typing import Protocol
 
-from ...core.logs import per_frame
+from ...core.logs import Blob, per_frame
 
 log = logging.getLogger(__name__)
 #: Per-tick readers — their records must never be CONSTRUCTED at
@@ -146,7 +146,7 @@ def _parse_smc_bytes(data_type: int, raw: bytes, size: int) -> float:
     Pure function — no ctypes I/O, no platform check.  ``raw`` is the
     leading ``size`` bytes from ``SMCKeyData_t.bytes``.
     """
-    log.debug("_parse_smc_bytes: data_type=%s raw=%s", data_type, raw)
+    log.debug("_parse_smc_bytes: data_type=%s raw=%s", data_type, Blob(raw))
     dt = _datatype_to_str(data_type).rstrip()
     body = bytes(raw[:size])
     if len(body) < 1: