trcc-linux 9.0.0__tar.gz → 9.0.2__tar.gz

{trcc_linux-9.0.0 → trcc_linux-9.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.0.0
+Version: 9.0.2
 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.0.0 → trcc_linux-9.0.2}/pyproject.toml

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

{trcc_linux-9.0.0 → trcc_linux-9.0.2}/src/trcc/__version__.py

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

{trcc_linux-9.0.0 → trcc_linux-9.0.2}/src/trcc/adapters/device/windows/detector.py

@@ -171,85 +171,15 @@ def _match_device(
     return None
 
 
-def _scan_physical_drives_ctypes() -> list[tuple[str, str]]:
-    """Scan PhysicalDrive0..15 for USB-bus drives using ctypes.
-
-    Returns list of (drive_path, vendor_id_string) for USB-connected drives.
-    No WMI dependency — uses DeviceIoControl IOCTL_STORAGE_QUERY_PROPERTY.
-    """
-    import ctypes
-    import ctypes.wintypes  # pyright: ignore[reportMissingImports]
-
-    kernel32 = ctypes.windll.kernel32  # pyright: ignore[reportAttributeAccessIssue]
-
-    GENERIC_READ = 0x80000000
-    FILE_SHARE_RW = 0x3
-    OPEN_EXISTING = 3
-    IOCTL_STORAGE_QUERY_PROPERTY = 0x2D1400
-
-    # STORAGE_PROPERTY_QUERY: PropertyId=0 (StorageDeviceProperty), QueryType=0
-    query = (ctypes.c_ubyte * 12)()
-    query[0] = 0   # PropertyId = StorageDeviceProperty
-    query[4] = 0   # QueryType = PropertyStandardQuery
-
-    results: list[tuple[str, str]] = []
-
-    for i in range(16):
-        path = f'\\\\.\\PhysicalDrive{i}'
-        handle = kernel32.CreateFileW(
-            path, GENERIC_READ, FILE_SHARE_RW,
-            None, OPEN_EXISTING, 0, None,
-        )
-        if handle == -1:
-            continue
-        try:
-            # Query storage device descriptor (contains bus type + vendor ID)
-            out_buf = (ctypes.c_ubyte * 1024)()
-            bytes_returned = ctypes.wintypes.DWORD(0)
-            ok = kernel32.DeviceIoControl(
-                handle,
-                IOCTL_STORAGE_QUERY_PROPERTY,
-                ctypes.byref(query), ctypes.sizeof(query),
-                ctypes.byref(out_buf), ctypes.sizeof(out_buf),
-                ctypes.byref(bytes_returned),
-                None,
-            )
-            if not ok:
-                continue
-
-            # STORAGE_DEVICE_DESCRIPTOR layout:
-            #   offset 12: VendorIdOffset (DWORD) — offset to vendor string
-            #   offset 28: BusType (DWORD) — 7 = BusTypeUsb
-            bus_type = int.from_bytes(bytes(out_buf[28:32]), 'little')
-            if bus_type != 7:  # Not USB
-                continue
-
-            vendor_offset = int.from_bytes(bytes(out_buf[12:16]), 'little')
-            vendor = ''
-            if 0 < vendor_offset < 1024:
-                # Read null-terminated ASCII string
-                end = vendor_offset
-                while end < 1024 and out_buf[end] != 0:
-                    end += 1
-                vendor = bytes(out_buf[vendor_offset:end]).decode('ascii', errors='replace').strip()
-
-            results.append((path, vendor))
-        finally:
-            kernel32.CloseHandle(handle)
-
-    return results
-
-
 def _find_physical_drive(vid: int, pid: int) -> str | None:
     """Find the Windows physical drive path for a USB SCSI device.
 
-    Maps USB VID:PID → PhysicalDrive via WMI disk associations.
-    Returns e.g. '\\\\.\\PhysicalDrive2' or None.
+    Maps USB VID:PID → PhysicalDrive via WMI — VID/PID only, no vendor strings.
 
-    Two lookup strategies:
-    1. Direct: disk PNPDeviceID contains VID_xxxx (some USB devices).
-    2. USBSTOR: disk is a USBSTOR child — trace USB parent via
-       Win32_USBControllerDevice to match VID/PID.
+    Strategy:
+    1. Confirm device VID:PID exists via Win32_USBControllerDevice.
+    2. Find USBSTOR disk with size < 1 MB — LCD devices report zero real storage,
+       unlike USB flash drives or external HDDs. Return the first match.
     """
     vid_tag = f'VID_{vid:04X}'
     pid_tag = f'PID_{pid:04X}'
@@ -257,71 +187,33 @@ def _find_physical_drive(vid: int, pid: int) -> str | None:
         import wmi  # pyright: ignore[reportMissingImports]
         w = wmi.WMI()
 
-        # Strategy 1: VID directly in disk PNPDeviceID
-        for disk in w.Win32_DiskDrive():
-            pnp = (disk.PNPDeviceID or '').upper()
-            log.debug("Strategy 1: disk %s PNP=%s", disk.DeviceID, pnp[:80])
-            if vid_tag in pnp:
-                return disk.DeviceID
-
-        # Strategy 2: USBSTOR disks — PNPDeviceID uses vendor names
-        # (e.g. USBSTOR\DISK&VEN_USBLCD) instead of VID/PID.
-        # Confirm the USB device exists, then find the USBSTOR disk
-        # by matching known Thermalright USBSTOR vendor strings.
-        _USBSTOR_VENDORS = ('VEN_USBLCD', 'VEN_THERMALR', 'VEN_WINBOND')
-        has_usb_device = False
+        # Step 1: confirm VID/PID is present in the USB device tree
+        confirmed = False
         for rel in w.Win32_USBControllerDevice():
             dep = str(rel.Dependent or '').upper()
             if vid_tag in dep and pid_tag in dep:
-                has_usb_device = True
-                log.debug("USB parent found: %s", dep[:120])
+                confirmed = True
+                log.debug("VID/PID %04X:%04X confirmed in USB tree", vid, pid)
                 break
-        log.debug("Strategy 2: has_usb_device=%s", has_usb_device)
-        if has_usb_device:
-            for disk in w.Win32_DiskDrive():
-                pnp_upper = (disk.PNPDeviceID or '').upper()
-                log.debug("Strategy 2: checking disk %s PNP=%s", disk.DeviceID, pnp_upper[:80])
-                if not pnp_upper.startswith('USBSTOR'):
-                    continue
-                if any(v in pnp_upper for v in _USBSTOR_VENDORS):
-                    log.debug("Strategy 2: vendor match! %s", disk.DeviceID)
-                    return disk.DeviceID
-            # Fallback: no vendor match but USB device confirmed —
-            # try any USBSTOR disk with zero/tiny capacity (LCD devices
-            # report no real storage, unlike USB flash drives).
-            for disk in w.Win32_DiskDrive():
-                pnp_upper = (disk.PNPDeviceID or '').upper()
-                if not pnp_upper.startswith('USBSTOR'):
-                    continue
-                size = int(disk.Size or 0)
-                if size < 1_000_000:  # < 1MB = not a real storage device
-                    log.debug("USBSTOR fallback: %s (size=%d)", disk.DeviceID, size)
-                    return disk.DeviceID
-    except Exception as e:
-        log.debug("WMI strategies failed for %04X:%04X: %s", vid, pid, e)
 
-    # Strategy 3: brute-force scan PhysicalDrive0..15 — no WMI needed.
-    # Query each drive's bus type via IOCTL_STORAGE_QUERY_PROPERTY.
-    # USB devices report BusTypeUsb (7). Filter to USB-bus drives only,
-    # then check vendor string for Thermalright LCD identifiers.
-    log.debug("Strategy 3: brute-force PhysicalDrive scan")
-    try:
-        usb_drives = _scan_physical_drives_ctypes()
-        for path, vendor in usb_drives:
-            log.debug("Strategy 3: USB drive %s vendor=%r", path, vendor)
-            # Match known LCD vendor strings from USBSTOR enumeration
-            v_upper = vendor.upper()
-            if any(k in v_upper for k in ('USBLCD', 'USB PRC', 'THERMALR', 'WINBOND')):
-                log.info("Strategy 3: vendor match at %s (%s)", path, vendor)
-                return path
-        # Fallback: if only one USB drive found and we confirmed VID/PID
-        # exists via WMI (or detection), it's likely our device
-        if len(usb_drives) == 1:
-            path, vendor = usb_drives[0]
-            log.info("Strategy 3: single USB drive fallback %s (%s)", path, vendor)
-            return path
+        if not confirmed:
+            log.debug("VID/PID %04X:%04X not found in USB controller devices", vid, pid)
+            return None
+
+        # Step 2: find the USBSTOR disk with tiny capacity — LCD devices
+        # report 0 storage; flash drives and HDDs are always > 1 MB.
+        for disk in w.Win32_DiskDrive():
+            pnp = (disk.PNPDeviceID or '').upper()
+            if not pnp.startswith('USBSTOR'):
+                continue
+            size = int(disk.Size or 0)
+            log.debug("USBSTOR disk %s size=%d PNP=%s", disk.DeviceID, size, pnp[:60])
+            if size < 1_000_000:
+                log.debug("LCD device match — drive: %s (size=%d)", disk.DeviceID, size)
+                return disk.DeviceID
+
     except Exception as e:
-        log.debug("Strategy 3 failed: %s", e)
+        log.debug("WMI lookup failed for %04X:%04X: %s", vid, pid, e)
 
     log.debug("Could not find physical drive for %04X:%04X", vid, pid)
     return None

{trcc_linux-9.0.0 → trcc_linux-9.0.2}/src/trcc/adapters/system/linux/sensors.py

@@ -29,15 +29,20 @@ from trcc.adapters.infra.data_repository import SysUtils
 from trcc.core.models import SensorInfo
 from trcc.core.ports import SensorEnumerator as SensorEnumeratorABC
 
+log = logging.getLogger(__name__)
+
 try:
     import pynvml  # pyright: ignore[reportMissingImports]
     pynvml.nvmlInit()
     NVML_AVAILABLE = True
-except Exception:
+except ImportError:
     pynvml = None  # type: ignore[assignment]
     NVML_AVAILABLE = False
-
-log = logging.getLogger(__name__)
+    log.debug("pynvml not installed — NVIDIA GPU sensors unavailable. Install nvidia-ml-py to enable.")
+except Exception as e:
+    pynvml = None  # type: ignore[assignment]
+    NVML_AVAILABLE = False
+    log.warning("pynvml init failed — NVIDIA GPU sensors unavailable: %s", e)
 
 
 # Maps hwmon input prefix to (category, unit)

{trcc_linux-9.0.0 → trcc_linux-9.0.2}/src/trcc/cli/__init__.py

@@ -164,6 +164,7 @@ def gui(verbose=0, decorated=False, start_hidden=False):
     # Root logger at DEBUG — handlers filter independently
     root = logging.getLogger()
     root.setLevel(logging.DEBUG)
+    root.handlers.clear()  # remove early basicConfig handler from __main__.py
 
     # Console handler — verbosity-controlled
     console = logging.StreamHandler()

{trcc_linux-9.0.0 → trcc_linux-9.0.2}/tests/adapters/device/windows/test_detector.py

@@ -168,55 +168,27 @@ class TestFindPhysicalDrive:
         result = _find_physical_drive(0x0416, 0x5020)
         assert result is None
 
-    def test_strategy1_vid_in_disk_pnpdeviceid(self):
-        """Direct VID match in disk PNPDeviceID."""
+    def test_usbstor_tiny_disk_matches(self):
+        """USBSTOR disk with 0 size matches — VID/PID confirmed, any vendor string works."""
         from trcc.adapters.device.windows.detector import _find_physical_drive
 
-        disk = MagicMock()
-        disk.PNPDeviceID = 'USB\\VID_0402&PID_3922\\12345'
-        disk.DeviceID = '\\\\.\\PhysicalDrive1'
+        lcd_disk = MagicMock()
+        lcd_disk.PNPDeviceID = r'USBSTOR\DISK&VEN_USBLCD&PROD_USB_PRC_SYSTEM&REV_\7&AF300EF&0'
+        lcd_disk.DeviceID = '\\\\.\\PhysicalDrive1'
+        lcd_disk.Size = '0'
 
-        mock_wmi_mod = MagicMock()
-        mock_wmi_instance = MagicMock()
-        mock_wmi_mod.WMI.return_value = mock_wmi_instance
-        mock_wmi_instance.Win32_DiskDrive.return_value = [disk]
-
-        with patch.dict('sys.modules', {'wmi': mock_wmi_mod}):
-            result = _find_physical_drive(0x0402, 0x3922)
-
-        assert result == '\\\\.\\PhysicalDrive1'
-
-    def test_strategy2_usbstor_vendor_match(self):
-        """USBSTOR disk matched via known vendor string (VEN_USBLCD)."""
-        from trcc.adapters.device.windows.detector import _find_physical_drive
-
-        # Disk with USBSTOR path (no VID in PNPDeviceID)
-        usbstor_disk = MagicMock()
-        usbstor_disk.PNPDeviceID = (
-            r'USBSTOR\DISK&VEN_USBLCD&PROD_USB_PRC_SYSTEM&REV_\7&AF300EF&0'
-        )
-        usbstor_disk.DeviceID = '\\\\.\\PhysicalDrive1'
-        usbstor_disk.InterfaceType = 'USB'
-        usbstor_disk.Size = '0'
-
-        # QEMU system disk (should not match)
         qemu_disk = MagicMock()
         qemu_disk.PNPDeviceID = r'SCSI\DISK&VEN_QEMU&PROD_HARDDISK\4&35424867'
         qemu_disk.DeviceID = '\\\\.\\PhysicalDrive0'
-        qemu_disk.InterfaceType = 'SCSI'
         qemu_disk.Size = '64424509440'
 
-        # USB controller device confirming VID/PID exists
         usb_rel = MagicMock()
-        usb_rel.Dependent = (
-            r'\\HOST\root\cimv2:Win32_PnPEntity.DeviceID='
-            r'"USB\VID_0402&PID_3922\6&1C4D2F9B&0&21"'
-        )
+        usb_rel.Dependent = r'Win32_PnPEntity.DeviceID="USB\VID_0402&PID_3922\6&1C4D2F9B&0&21"'
 
         mock_wmi_mod = MagicMock()
         mock_wmi_instance = MagicMock()
         mock_wmi_mod.WMI.return_value = mock_wmi_instance
-        mock_wmi_instance.Win32_DiskDrive.return_value = [qemu_disk, usbstor_disk]
+        mock_wmi_instance.Win32_DiskDrive.return_value = [qemu_disk, lcd_disk]
         mock_wmi_instance.Win32_USBControllerDevice.return_value = [usb_rel]
 
         with patch.dict('sys.modules', {'wmi': mock_wmi_mod}):
@@ -224,78 +196,60 @@ class TestFindPhysicalDrive:
 
         assert result == '\\\\.\\PhysicalDrive1'
 
-    def test_strategy2_ignores_usb_flash_drive(self):
-        """USB flash drive should not match — wrong vendor name and large size."""
+    def test_xsail_firmware_tiny_disk_matches(self):
+        """Xsail firmware vendor string — size-based match works regardless."""
         from trcc.adapters.device.windows.detector import _find_physical_drive
 
-        flash_drive = MagicMock()
-        flash_drive.PNPDeviceID = (
-            r'USBSTOR\DISK&VEN_KINGSTON&PROD_DATATRAVELER&REV_1.0\1234'
-        )
-        flash_drive.DeviceID = '\\\\.\\PhysicalDrive2'
-        flash_drive.InterfaceType = 'USB'
-        flash_drive.Size = '32212254720'  # 32GB
+        lcd_disk = MagicMock()
+        lcd_disk.PNPDeviceID = r'USBSTOR\DISK&VEN_XSAIL&PROD_USB_PRC_SYSTEM&REV_\7&AF300EF&0'
+        lcd_disk.DeviceID = '\\\\.\\PhysicalDrive1'
+        lcd_disk.Size = '0'
 
         usb_rel = MagicMock()
-        usb_rel.Dependent = (
-            r'\\HOST\root\cimv2:Win32_PnPEntity.DeviceID='
-            r'"USB\VID_0402&PID_3922\6&1C4D2F9B&0&21"'
-        )
+        usb_rel.Dependent = r'Win32_PnPEntity.DeviceID="USB\VID_0402&PID_3922\6&1C4D2F9B&0&21"'
 
         mock_wmi_mod = MagicMock()
         mock_wmi_instance = MagicMock()
         mock_wmi_mod.WMI.return_value = mock_wmi_instance
-        mock_wmi_instance.Win32_DiskDrive.return_value = [flash_drive]
+        mock_wmi_instance.Win32_DiskDrive.return_value = [lcd_disk]
         mock_wmi_instance.Win32_USBControllerDevice.return_value = [usb_rel]
 
         with patch.dict('sys.modules', {'wmi': mock_wmi_mod}):
             result = _find_physical_drive(0x0402, 0x3922)
 
-        # Flash drive: wrong vendor, >1MB — should not match
-        assert result is None
+        assert result == '\\\\.\\PhysicalDrive1'
 
-    def test_strategy2_fallback_zero_size_disk(self):
-        """Unknown USBSTOR vendor but <1MB size — fallback match."""
+    def test_flash_drive_ignored(self):
+        """USB flash drive (large size) is not matched even if VID/PID confirmed."""
         from trcc.adapters.device.windows.detector import _find_physical_drive
 
-        tiny_disk = MagicMock()
-        tiny_disk.PNPDeviceID = (
-            r'USBSTOR\DISK&VEN_UNKNOWN&PROD_DEVICE&REV_\12345'
-        )
-        tiny_disk.DeviceID = '\\\\.\\PhysicalDrive3'
-        tiny_disk.InterfaceType = 'USB'
-        tiny_disk.Size = '0'
+        flash_drive = MagicMock()
+        flash_drive.PNPDeviceID = r'USBSTOR\DISK&VEN_KINGSTON&PROD_DATATRAVELER&REV_1.0\1234'
+        flash_drive.DeviceID = '\\\\.\\PhysicalDrive2'
+        flash_drive.Size = '32212254720'  # 32 GB
 
         usb_rel = MagicMock()
-        usb_rel.Dependent = (
-            r'\\HOST\root\cimv2:Win32_PnPEntity.DeviceID='
-            r'"USB\VID_0402&PID_3922\6&1C4D2F9B&0&21"'
-        )
+        usb_rel.Dependent = r'Win32_PnPEntity.DeviceID="USB\VID_0402&PID_3922\6&1C4D2F9B&0&21"'
 
         mock_wmi_mod = MagicMock()
         mock_wmi_instance = MagicMock()
         mock_wmi_mod.WMI.return_value = mock_wmi_instance
-        mock_wmi_instance.Win32_DiskDrive.return_value = [tiny_disk]
+        mock_wmi_instance.Win32_DiskDrive.return_value = [flash_drive]
         mock_wmi_instance.Win32_USBControllerDevice.return_value = [usb_rel]
 
         with patch.dict('sys.modules', {'wmi': mock_wmi_mod}):
             result = _find_physical_drive(0x0402, 0x3922)
 
-        assert result == '\\\\.\\PhysicalDrive3'
+        assert result is None
 
-    def test_no_usb_device_no_fallback(self):
-        """No USB VID/PID confirmed — strategy 2 should not run."""
+    def test_no_usb_device_returns_none(self):
+        """VID/PID not in USB tree — no disk returned."""
         from trcc.adapters.device.windows.detector import _find_physical_drive
 
-        usbstor_disk = MagicMock()
-        usbstor_disk.PNPDeviceID = r'USBSTOR\DISK&VEN_USBLCD&PROD_X\1'
-        usbstor_disk.DeviceID = '\\\\.\\PhysicalDrive1'
-        usbstor_disk.InterfaceType = 'USB'
-
         mock_wmi_mod = MagicMock()
         mock_wmi_instance = MagicMock()
         mock_wmi_mod.WMI.return_value = mock_wmi_instance
-        mock_wmi_instance.Win32_DiskDrive.return_value = [usbstor_disk]
+        mock_wmi_instance.Win32_DiskDrive.return_value = []
         mock_wmi_instance.Win32_USBControllerDevice.return_value = []
 
         with patch.dict('sys.modules', {'wmi': mock_wmi_mod}):
@@ -303,61 +257,14 @@ class TestFindPhysicalDrive:
 
         assert result is None
 
-    def test_strategy3_ctypes_vendor_match(self):
-        """Strategy 3: WMI fails, ctypes scan finds USB drive with LCD vendor."""
+    def test_wmi_exception_returns_none(self):
+        """WMI unavailable — returns None gracefully."""
         from trcc.adapters.device.windows.detector import _find_physical_drive
 
-        # WMI fails entirely
         mock_wmi_mod = MagicMock()
         mock_wmi_mod.WMI.side_effect = Exception("WMI unavailable")
 
-        # ctypes scan finds a USB drive with USBLCD vendor
-        with patch.dict('sys.modules', {'wmi': mock_wmi_mod}), \
-             patch(f'{MODULE}._scan_physical_drives_ctypes',
-                   return_value=[('\\\\.\\PhysicalDrive1', 'USBLCD')]):
-            result = _find_physical_drive(0x0402, 0x3922)
-
-        assert result == '\\\\.\\PhysicalDrive1'
-
-    def test_strategy3_single_usb_drive_fallback(self):
-        """Strategy 3: unknown vendor but only one USB drive — fallback match."""
-        from trcc.adapters.device.windows.detector import _find_physical_drive
-
-        mock_wmi_mod = MagicMock()
-        mock_wmi_mod.WMI.side_effect = Exception("WMI unavailable")
-
-        with patch.dict('sys.modules', {'wmi': mock_wmi_mod}), \
-             patch(f'{MODULE}._scan_physical_drives_ctypes',
-                   return_value=[('\\\\.\\PhysicalDrive2', 'UNKNOWN_DEVICE')]):
-            result = _find_physical_drive(0x0402, 0x3922)
-
-        assert result == '\\\\.\\PhysicalDrive2'
-
-    def test_strategy3_multiple_usb_drives_no_vendor_match(self):
-        """Strategy 3: multiple USB drives, no vendor match — returns None."""
-        from trcc.adapters.device.windows.detector import _find_physical_drive
-
-        mock_wmi_mod = MagicMock()
-        mock_wmi_mod.WMI.side_effect = Exception("WMI unavailable")
-
-        with patch.dict('sys.modules', {'wmi': mock_wmi_mod}), \
-             patch(f'{MODULE}._scan_physical_drives_ctypes',
-                   return_value=[('\\\\.\\PhysicalDrive1', 'KINGSTON'),
-                                 ('\\\\.\\PhysicalDrive2', 'SANDISK')]):
-            result = _find_physical_drive(0x0402, 0x3922)
-
-        assert result is None
-
-    def test_strategy3_no_usb_drives(self):
-        """Strategy 3: no USB drives found — returns None."""
-        from trcc.adapters.device.windows.detector import _find_physical_drive
-
-        mock_wmi_mod = MagicMock()
-        mock_wmi_mod.WMI.side_effect = Exception("WMI unavailable")
-
-        with patch.dict('sys.modules', {'wmi': mock_wmi_mod}), \
-             patch(f'{MODULE}._scan_physical_drives_ctypes',
-                   return_value=[]):
+        with patch.dict('sys.modules', {'wmi': mock_wmi_mod}):
             result = _find_physical_drive(0x0402, 0x3922)
 
         assert result is None