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

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.7.3"
+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.3 → 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.3"
+__version__ = "9.7.4"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.7.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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:

trcc_linux-9.7.4/src/trcc/adapters/sensors/_wmi_gpu.py

@@ -0,0 +1,102 @@
+"""Last-resort GPU enumeration via WMI ``Win32_VideoController``.
+
+When no live sensor backend (pynvml / HWiNFO / LibreHardwareMonitor)
+reports a GPU — e.g. an AMD/Intel card with none of those tools running
+— the GPU picker would otherwise show "No GPU detected".  ``Win32_-
+VideoController`` always lists every adapter by name, so we surface it as
+a name-only :class:`GpuSource`: real ``key`` / ``name`` / ``is_discrete``,
+but every live reading is ``None`` (the ABC contract is ``float | None``,
+so this is a faithful "name known, no telemetry" source, not a stub).
+
+Chained LAST in ``_build_windows_gpu_chains`` — only consulted when the
+live backends found nothing, mirroring legacy ``windows/enumerator.py::
+_wmi_video_controller_gpus``.
+"""
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+from ...core.ports import GpuSource
+
+log = logging.getLogger(__name__)
+
+# Name fragments that mark a dedicated card.  Anything unmatched is
+# treated as integrated (the safe default — an iGPU never claims a fan).
+_DISCRETE_MARKERS: tuple[str, ...] = (
+    "RTX", "GTX", "GEFORCE", "QUADRO", "TITAN",
+    "RADEON RX", "RADEON PRO", "FIREPRO", "ARC",
+)
+
+
+def _default_handle_factory() -> Any:
+    """One-shot ``root\\cimv2`` WMI handle; ``None`` when wmi is absent."""
+    from ..system._windows_wmi import wmi_handle
+    try:
+        return wmi_handle()
+    except ImportError:
+        log.debug("wmi package unavailable — no WMI GPU enumeration")
+        return None
+    except Exception as e:
+        log.debug("WMI handle for GPU enumeration failed: %s", type(e).__name__)
+        return None
+
+
+def _is_discrete(name: str) -> bool:
+    upper = name.upper()
+    return any(marker in upper for marker in _DISCRETE_MARKERS)
+
+
+class WmiVideoControllerGpu(GpuSource):
+    """One ``Win32_VideoController`` adapter — name only, no telemetry."""
+
+    def __init__(self, index: int, name: str) -> None:
+        self._index = index
+        self._name = name
+        self._discrete = _is_discrete(name)
+
+    @property
+    def key(self) -> str:
+        return f"wmi:{self._index}"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def is_discrete(self) -> bool:
+        return self._discrete
+
+    # Win32_VideoController carries no live sensor data — every reading is
+    # genuinely unavailable from this backend (AdapterRAM caps at 4 GiB and
+    # is unreliable, so VRAM is omitted too).
+    def temp(self) -> float | None: return None
+    def usage(self) -> float | None: return None
+    def clock(self) -> float | None: return None
+    def power(self) -> float | None: return None
+    def fan(self) -> float | None: return None
+    def vram_used(self) -> float | None: return None
+    def vram_total(self) -> float | None: return None
+
+
+def discover_wmi_gpus(
+    handle_factory: Callable[[], Any] = _default_handle_factory,
+) -> list[GpuSource]:
+    """Enumerate display adapters via ``Win32_VideoController`` (name only)."""
+    log.info("discover_wmi_gpus: called")
+    handle = handle_factory()
+    if handle is None:
+        return []
+    gpus: list[GpuSource] = []
+    try:
+        for i, vc in enumerate(handle.Win32_VideoController()):
+            name = (str(vc.Name).strip() if vc.Name is not None else "")
+            if not name:
+                continue
+            gpus.append(WmiVideoControllerGpu(i, name))
+    except Exception as e:  # WMI/COM surface is wide
+        log.debug("Win32_VideoController query failed: %s", type(e).__name__)
+        return []
+    log.info("discover_wmi_gpus: %d adapter(s)", len(gpus))
+    return gpus

{trcc_linux-9.7.3 → trcc_linux-9.7.4}/src/trcc/adapters/sensors/windows.py

@@ -20,6 +20,7 @@ from ...core.ports import CpuSource, GpuSource
 from ._hwinfo import HwinfoCpu, discover_hwinfo_gpus
 from ._lhm import LhmCpu, discover_lhm_gpus
 from ._msacpi import WmiAcpiCpu
+from ._wmi_gpu import discover_wmi_gpus
 from .aggregator import BaselineSensors
 from .chain import CpuSourceChain, GpuSourceChain
 from .nvml import discover_nvidia_gpus
@@ -74,4 +75,12 @@ def _build_windows_gpu_chains() -> list[GpuSource]:
             chains.append(sources[0])
         else:
             chains.append(GpuSourceChain(sources))
+
+    # Last resort: no live backend saw a GPU (AMD/Intel card with no
+    # HWiNFO/LHM running, non-NVIDIA so pynvml is N/A).  Surface the
+    # adapter by name via Win32_VideoController so the picker isn't empty.
+    if not chains:
+        chains = discover_wmi_gpus()
+        log.info("_build_windows_gpu_chains: live backends empty — "
+                 "WMI fallback yielded %d adapter(s)", len(chains))
     return chains