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

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

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

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

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

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

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

@@ -144,8 +144,13 @@ class HidLcd(Device[BulkTransport]):
 
                 result = self._parse_response(resp)
                 self._handshake = result
-                log.info("HidLcd type %d handshake OK: resolution=%s",
-                         self.info.device_type, result.resolution)
+                log.info(
+                    "HidLcd type %d handshake OK: PM=%s SUB=%s resolution=%s",
+                    self.info.device_type,
+                    getattr(result, "pm_byte", "?"),
+                    getattr(result, "sub_byte", "?"),
+                    result.resolution,
+                )
                 return result
 
             except Exception as e:

{trcc_linux-9.7.4 → trcc_linux-9.7.5}/src/trcc/core/commands/led.py

@@ -354,12 +354,36 @@ class RenderLed(Command[LedColorsResult]):
 
 @dataclass(frozen=True, slots=True)
 class SetLedMode(Command[LedColorsResult]):
-    """Set the global animation mode for an LED device."""
+    """Set the LED animation mode.
+
+    Global for ordinary devices; for a multi-zone style (PA120/LF10) the mode
+    applies to the *selected* zones (all when "select all"/``zone_sync`` is on,
+    else the ``zone_sync_zones`` mask) — the same per-zone path as
+    :class:`SetLedColor`.  Without this the mode/effect buttons did nothing on
+    a multi-zone device, because the render reads each zone's own mode (#192).
+    """
     key: str
     mode: LEDMode
 
     def execute(self, app: App) -> LedColorsResult:
-        app.settings.set_led_mode(self.key, self.mode)
+        zone_count = _multi_zone_count(app, self.key)
+        if zone_count is not None:
+            app.settings.set_led_zone_count(self.key, zone_count)
+            s = app.settings.for_led(self.key)
+            if s.zone_sync:
+                targets = list(range(zone_count))
+            else:
+                mask = s.zone_sync_zones
+                targets = [i for i in range(zone_count)
+                           if i < len(mask) and mask[i]]
+                if not targets:
+                    targets = [0]
+            for i in targets:
+                app.settings.set_led_zone(self.key, i, mode=self.mode)
+            log.info("SetLedMode %s: %s → zone(s) %s",
+                     self.key, self.mode.name, targets)
+        else:
+            app.settings.set_led_mode(self.key, self.mode)
         # Phase counters reset on mode change so animation restarts cleanly
         runtime = app.led_runtime.setdefault(self.key, LedRuntimeState())
         runtime.rgb_timer = 0

{trcc_linux-9.7.4 → trcc_linux-9.7.5}/src/trcc/core/commands/system.py

@@ -697,10 +697,44 @@ class InstallGpuReader(Command[GpuReaderInstallResult]):
     def execute(self, app: App) -> GpuReaderInstallResult:
         del app
         import subprocess
-
-        from ...adapters.diagnostics.health import detect_package_manager
+        import sys
 
         log.info("InstallGpuReader.execute: dry_run=%s", self.dry_run)
+
+        # In a virtualenv the OS package manager would install python3-pynvml
+        # into the SYSTEM interpreter — invisible to this venv.  Install the
+        # NVML bindings into THIS interpreter via pip instead (no privileges
+        # needed; it writes into the venv).  Fixes pip/venv users whose NVIDIA
+        # card is detected but pynvml is missing (#161).  A non-venv system
+        # Python can see apt/dnf/pacman-installed python3-pynvml, so that path
+        # is unchanged below.
+        if sys.prefix != sys.base_prefix:
+            cmd = [sys.executable, "-m", "pip", "install", "nvidia-ml-py"]
+            if self.dry_run:
+                return GpuReaderInstallResult(
+                    ok=True, command=list(cmd),
+                    message=f"Would run: {' '.join(cmd)}",
+                )
+            try:
+                proc = subprocess.run(
+                    cmd, capture_output=True, text=True, timeout=600.0, check=False,
+                )
+            except (FileNotFoundError, subprocess.SubprocessError, OSError) as e:
+                log.exception("InstallGpuReader.execute: pip install failed")
+                return GpuReaderInstallResult(
+                    ok=False, command=list(cmd),
+                    message=f"pip install failed: {type(e).__name__}: {e}",
+                )
+            ok = proc.returncode == 0
+            log.info("InstallGpuReader.execute: pip exit=%d", proc.returncode)
+            return GpuReaderInstallResult(
+                ok=ok, command=list(cmd), exit_code=proc.returncode,
+                message=("GPU sensor reader installed — restart trcc to enable "
+                         "GPU metrics" if ok else
+                         f"pip install failed (exit {proc.returncode})"),
+            )
+
+        from ...adapters.diagnostics.health import detect_package_manager
         pm = detect_package_manager()
         if pm is None:
             log.warning("InstallGpuReader.execute: no package manager detected")

{trcc_linux-9.7.4 → trcc_linux-9.7.5}/src/trcc/services/display.py

@@ -646,18 +646,19 @@ class DisplayService:
 
     def _log_cache_transition(self, key: str, bg_hit: bool,
                               ovl_hit: bool) -> None:
-        """Log INFO on the first call AND every state flip per device.
+        """Log on the first call AND every cache state flip per device.
 
-        Per-tick HIT/MISS already logs at DEBUG in ``build_frame``; this
-        is the load-bearing diagnostic: "video should be animating but
-        cache is steady-HIT" is the shape of every "frozen on frame N"
-        regression, and surfaces as a missing flip in this log.
+        DEBUG, not INFO: on animated / cloud-background content the state flips
+        EVERY frame, so at INFO this floods the log and scrolls the once-per-
+        connect handshake line (PM/SUB/resolution) out of the report's tail.
+        The "frozen on frame N" diagnostic (a missing flip) is still here at
+        ``-v``; per-tick HIT/MISS already logs at DEBUG in ``build_frame``.
         """
         new_state = (bg_hit, ovl_hit)
         prev_state = self._cache_state.get(key)
         if prev_state == new_state:
             return
-        log.info(
+        log.debug(
             "build_frame %s: cache state %s → bg=%s overlay=%s",
             key,
             "(first)" if prev_state is None

{trcc_linux-9.7.4 → trcc_linux-9.7.5}/src/trcc/ui/gui/trcc_app.py

@@ -518,7 +518,7 @@ class TRCCApp(QMainWindow):
         keepalive) leave ``surface`` None; those fall back to a one-off
         re-render.  Only the active device writes the shared preview.
         """
-        log.info("_on_bus_frame_sent")
+        log.debug("_on_bus_frame_sent")  # per-frame — DEBUG so reports aren't flooded
         if event.key != self._active_key:
             return
         handler = self._handlers.get(event.key)

{trcc_linux-9.7.4 → trcc_linux-9.7.5}/tests/test_diagnostics.py

@@ -338,11 +338,19 @@ def test_get_gpu_reader_status_no_offer_on_version_mismatch(
     assert result.init_failed is True
 
 
+def _force_not_venv(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Pin the interpreter to look non-venv so the OS-package path is tested
+    deterministically regardless of where the suite runs (CI may be a venv)."""
+    import sys
+    monkeypatch.setattr(sys, "prefix", sys.base_prefix)
+
+
 def test_install_gpu_reader_dry_run_builds_pkexec_command(
     _trcc_app, monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     from trcc.core.commands import InstallGpuReader
 
+    _force_not_venv(monkeypatch)
     monkeypatch.setattr(
         "trcc.adapters.diagnostics.health.detect_package_manager", lambda: "dnf",
     )
@@ -357,6 +365,7 @@ def test_install_gpu_reader_no_recipe_falls_back_to_guide(
 ) -> None:
     from trcc.core.commands import InstallGpuReader
 
+    _force_not_venv(monkeypatch)
     monkeypatch.setattr(
         "trcc.adapters.diagnostics.health.detect_package_manager", lambda: "apk",
     )
@@ -365,6 +374,22 @@ def test_install_gpu_reader_no_recipe_falls_back_to_guide(
     assert "manually" in result.message
 
 
+def test_install_gpu_reader_uses_pip_in_a_venv(
+    _trcc_app, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """In a virtualenv, install nvidia-ml-py via pip into THIS interpreter —
+    the OS package manager would target system python the venv can't see (#161)."""
+    import sys
+
+    from trcc.core.commands import InstallGpuReader
+
+    monkeypatch.setattr(sys, "base_prefix", "/usr")
+    monkeypatch.setattr(sys, "prefix", "/home/u/.venv")
+    result = _trcc_app.dispatch(InstallGpuReader(dry_run=True))
+    assert result.ok is True
+    assert result.command == [sys.executable, "-m", "pip", "install", "nvidia-ml-py"]
+
+
 def test_install_gpu_reader_no_package_manager(
     _trcc_app, monkeypatch: pytest.MonkeyPatch,
 ) -> None:

{trcc_linux-9.7.4 → trcc_linux-9.7.5}/tests/test_render_led.py

@@ -427,3 +427,27 @@ def test_set_led_color_stays_global_for_non_zone_style(
     s = app.settings.for_led(_LED_KEY)
     assert s.color == (7, 8, 9)
     assert s.zones == []
+
+
+def test_set_led_mode_targets_selected_zones_pa120(
+    fake_platform: FakePlatform,
+) -> None:
+    """#192 follow-up: mode (effect) applies per-zone for multi-zone styles."""
+    from trcc.core.commands import SetLedMode
+    from trcc.core.led_models import LEDMode
+    from trcc.services.led_segment import get_display
+
+    app = App(fake_platform)
+    _attach_and_connect(app, fake_platform, pm=16)   # PA120
+    n = len(get_display(LedStyle.PA120).zone_led_map)  # type: ignore[arg-type]
+
+    # circulate off, select zones 0 & 2, set BREATHING
+    app.settings.set_led_zone_count(_LED_KEY, n)
+    app.settings.set_led_zone_sync(_LED_KEY, False)
+    app.settings.set_led_zone_sync_zones(_LED_KEY, [i in (0, 2) for i in range(n)])
+    app.dispatch(SetLedMode(key=_LED_KEY, mode=LEDMode.BREATHING))
+
+    zones = app.settings.for_led(_LED_KEY).zones
+    assert zones[0].mode is LEDMode.BREATHING
+    assert zones[2].mode is LEDMode.BREATHING
+    assert zones[1].mode is not LEDMode.BREATHING   # untouched