trcc-linux 9.8.2__tar.gz → 9.8.3__tar.gz

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.8.2
+Version: 9.8.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
@@ -28,6 +28,7 @@ Requires-Dist: click>=7.0
 Requires-Dist: fastapi>=0.100
 Requires-Dist: libusb-package>=1.0.26.3; sys_platform == 'win32' and python_version < '3.14'
 Requires-Dist: numpy>=1.24.0
+Requires-Dist: nvidia-ml-py>=11.0.0
 Requires-Dist: prompt-toolkit>=3.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pyside6>=6.5.0
@@ -43,7 +44,6 @@ Provides-Extra: all
 Requires-Dist: dbus-python>=1.3.0; extra == 'all'
 Requires-Dist: hidapi>=0.14.0; extra == 'all'
 Requires-Dist: httpx>=0.24.0; extra == 'all'
-Requires-Dist: nvidia-ml-py>=11.0.0; extra == 'all'
 Requires-Dist: pygobject>=3.42.0; extra == 'all'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'all'
 Requires-Dist: pytest-qt>=4.0.0; extra == 'all'
@@ -61,7 +61,6 @@ Requires-Dist: types-qrcode>=7.0; extra == 'dev'
 Provides-Extra: hid
 Requires-Dist: hidapi>=0.14.0; extra == 'hid'
 Provides-Extra: nvidia
-Requires-Dist: nvidia-ml-py>=11.0.0; extra == 'nvidia'
 Provides-Extra: remote
 Requires-Dist: qrcode>=7.0; extra == 'remote'
 Provides-Extra: wayland

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.8.2"
+version = "9.8.3"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -57,12 +57,18 @@ dependencies = [
     # Core feature, not optional; the graceful-None fallback only covers exotic
     # environments that strip libudev (#139).
     "pyudev>=0.24.1; sys_platform == 'linux'",
+    # NVIDIA GPU temp/usage/clock via NVML.  Pure-Python (~53 KB), imports on
+    # any OS/hardware — nvmlInit() just no-ops without a card.  Core, not an
+    # extra, so `pip install trcc-linux` gets it out of the box: #161 was a
+    # pip-channel install where the card was present but the reader was never
+    # importable because the [nvidia] extra wasn't pulled.
+    "nvidia-ml-py>=11.0.0",
 ]
 
 [project.optional-dependencies]
-nvidia = [
-    "nvidia-ml-py>=11.0.0",
-]
+# Promoted to a core dependency (see [project].dependencies).  Kept as an empty
+# alias so existing `pip install trcc-linux[nvidia]` invocations still resolve.
+nvidia = []
 wayland = [
     "dbus-python>=1.3.0",
     "PyGObject>=3.42.0",

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/__version__.py

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

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/adapters/sensors/gpu_detect.py

@@ -86,7 +86,7 @@ def install_matching_gpu_extras(vendors: set[str],
     # are not visible in this virtualenv") and aborts setup — exactly what the
     # bundled-venv .deb hits (#161).  Install into the venv directly; only a
     # non-venv system Python needs --user (writes to the user's site-packages,
-    # no root).  Same detection as InstallGpuReader.
+    # no root).
     in_venv = sys.prefix != sys.base_prefix
     user_flag = [] if in_venv else ["--user"]
     cmd = [sys.executable, "-m", "pip", "install", *user_flag, *needed]

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/adapters/sensors/nvml.py

@@ -20,15 +20,20 @@ log = logging.getLogger(__name__)
 try:
     import pynvml  # pyright: ignore[reportMissingImports]
     _AVAILABLE = True
-except ImportError:
+    _import_error: str | None = None
+except ImportError as e:
     pynvml = None  # type: ignore[assignment]
     _AVAILABLE = False
+    # Recorded, not logged here — logging isn't configured at module-import
+    # time.  Surfaced lazily (once) the first time init is attempted.
+    _import_error = str(e)
 
 
 _init_lock = threading.Lock()
 _initialized = False
 _init_error: str | None = None
 _warned_init_failure = False
+_warned_unavailable = False
 
 # Canonical fix for an NVML version mismatch (driver updated without reboot) —
 # referenced by both the runtime warning and the doctor's GPU check.
@@ -58,10 +63,20 @@ def _nvml_fix_hint(e: Exception) -> str:
 
 def _ensure_init() -> bool:
     """Lazy NVML init — retries until driver is loaded."""
-    global _initialized, _init_error, _warned_init_failure
+    global _initialized, _init_error, _warned_init_failure, _warned_unavailable
     if _initialized:
         return True
     if not _AVAILABLE or pynvml is None:
+        # pynvml itself couldn't be imported in this interpreter — the #161
+        # case (card present, reader missing).  Warn ONCE with the fix so it's
+        # visible at the default log level instead of a silent gpu:[].
+        if not _warned_unavailable:
+            _warned_unavailable = True
+            log.warning(
+                "pynvml not importable in this interpreter (%s) — NVIDIA GPU "
+                "sensors unavailable; install nvidia-ml-py into trcc's "
+                "environment", _import_error or "ImportError",
+            )
         return False
     with _init_lock:
         if _initialized:
@@ -99,6 +114,8 @@ def nvml_init_state() -> tuple[bool, bool, str | None]:
     late-loaded driver is reflected.
     """
     _ensure_init()
+    log.debug("nvml_init_state: available=%s initialized=%s error=%s",
+              _AVAILABLE, _initialized, _init_error)
     return _AVAILABLE, _initialized, _init_error
 
 

trcc_linux-9.8.3/src/trcc/assets/trcc-quirk-fix.service

@@ -0,0 +1,18 @@
+[Unit]
+Description=TRCC LCD USB Storage Quirk Fix
+Before=multi-user.target
+DefaultDependencies=no
+
+[Service]
+Type=oneshot
+# Force usb-storage Bulk-Only on every SCSI display so /dev/sgN is created.
+# The quirks sysfs param is a single comma-list and `echo` OVERWRITES it, so we
+# MUST write the FULL list — echoing one device here silently clobbered the
+# others set by /etc/modprobe.d/trcc-lcd.conf (#212: 0416:5406 lost its quirk).
+# MUST stay in sync with packaging/modprobe/trcc-lcd.conf AND
+# adapters/system/_udev.py build_modprobe_conf() — same list, three sources.
+ExecStart=/bin/sh -c 'modprobe sg && echo "0402:3922:u,0416:5406:u,87cd:70db:u" > /sys/module/usb_storage/parameters/quirks'
+RemainAfterExit=yes
+
+[Install]
+WantedBy=sysinit.target

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/core/commands/__init__.py

@@ -86,9 +86,7 @@ from .system import (
     GenerateDebugReport,
     GetAutostartStatus,
     GetFirstRunStatus,
-    GetGpuReaderStatus,
     GetPlatformInfo,
-    InstallGpuReader,
     KeepAliveLoop,
     ListDisks,
     ListFonts,
@@ -158,12 +156,10 @@ __all__ = [
     "GenerateDebugReport",
     "GetAutostartStatus",
     "GetFirstRunStatus",
-    "GetGpuReaderStatus",
     "GetPlatformInfo",
     "ImportConfig",
     "ImportTheme",
     "InitializeLed",
-    "InstallGpuReader",
     "KeepAliveLoop",
     "LcdSnapshot",
     "LedSnapshot",

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/core/commands/_helpers.py

@@ -188,20 +188,6 @@ _UPGRADE_COMMANDS: dict[str, tuple[str, ...]] = {
 }
 
 
-# Install the NVIDIA NVML python reader (pynvml) when an NVIDIA GPU is
-# detected.  ``pkexec`` (graphical polkit prompt) rather than ``sudo`` —
-# this is dispatched from the GUI, which has no TTY for a sudo password.
-# Argv is a fixed list per package manager (never interpolate input).
-# Only distros whose package name is verified are auto-installable; an
-# unmapped PM falls back to detect-and-guide (the doctor prints the
-# manual command) rather than guessing a wrong package name.
-_GPU_READER_INSTALL_COMMANDS: dict[str, tuple[str, ...]] = {
-    "dnf":    ("pkexec", "dnf", "install", "-y", "python3-pynvml"),
-    "apt":    ("pkexec", "apt-get", "install", "-y", "python3-pynvml"),
-    "pacman": ("pkexec", "pacman", "-S", "--noconfirm", "python-nvidia-ml-py"),
-}
-
-
 def _json_default_tuple(obj: Any) -> Any:
     """tuple → list for JSON serialisation (no other coercions)."""
     log.debug("_json_default_tuple: type=%s", type(obj).__name__)

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/core/commands/system.py

@@ -32,8 +32,6 @@ from ..results import (
     FontsListResult,
     GpuDeviceResult,
     GpuEntry,
-    GpuReaderInstallResult,
-    GpuReaderStatusResult,
     GpusListResult,
     HealthReportResult,
     KeepaliveResult,
@@ -56,7 +54,6 @@ from ..results import (
 )
 from ._base import Command
 from ._helpers import (
-    _GPU_READER_INSTALL_COMMANDS,
     _UPGRADE_COMMANDS,
     _autostart_path,
     _health_entries,
@@ -599,137 +596,6 @@ class RunUpgrade(Command[UpgradeResult]):
                      else f"Upgrade failed (exit {proc.returncode})"),
         )
 
-@dataclass(frozen=True, slots=True)
-class GetGpuReaderStatus(Command[GpuReaderStatusResult]):
-    """Report whether the NVIDIA sensor reader (pynvml) should be offered for install.
-
-    The GUI dispatches this at startup: if ``offer_install`` is True (an
-    NVIDIA GPU is present but pynvml isn't installed) it surfaces a consent
-    prompt to install it.  ``init_failed`` (reader present, ``nvmlInit``
-    failed) is the version-mismatch/reboot case — NOT installable, so not
-    offered (the doctor's WARN already guides the user to reboot/reload).
-    Pure read; safe to call headless.
-    """
-
-    def execute(self, app: App) -> GpuReaderStatusResult:
-        state = app.diagnostics.gpu_reader_state()
-        present = state.nvidia_present
-        reader_available = state.reader_installed
-        initialized = state.initialized
-        offer = present and not reader_available
-        init_failed = present and reader_available and not initialized
-        log.info(
-            "GetGpuReaderStatus.execute: nvidia_present=%s reader=%s "
-            "initialized=%s offer_install=%s",
-            present, reader_available, initialized, offer,
-        )
-        return GpuReaderStatusResult(
-            ok=True,
-            nvidia_present=present,
-            reader_installed=reader_available,
-            init_failed=init_failed,
-            offer_install=offer,
-            message=(
-                "NVIDIA GPU present, reader missing — install offered"
-                if offer else
-                "NVIDIA reader present"
-                if reader_available else
-                "No NVIDIA GPU detected"
-            ),
-        )
-
-
-@dataclass(frozen=True, slots=True)
-class InstallGpuReader(Command[GpuReaderInstallResult]):
-    """Install the NVIDIA NVML python reader (pynvml) via the package manager.
-
-    Mirrors :class:`RunUpgrade` — detect the PM, map to a fixed ``pkexec``
-    argv (never interpolate input), run it.  GUI-triggered after explicit
-    user consent.  pynvml was imported (and failed) at process start, so the
-    newly-installed reader only takes effect on the next launch — the message
-    says so rather than pretending it comes live.  ``dry_run=True`` returns
-    the command without executing it so UIs/tests can preview.
-    """
-    dry_run: bool = False
-
-    def execute(self, app: App) -> GpuReaderInstallResult:
-        import subprocess
-        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})"),
-            )
-
-        pm = app.diagnostics.package_manager()
-        if pm is None:
-            log.warning("InstallGpuReader.execute: no package manager detected")
-            return GpuReaderInstallResult(
-                ok=False, message="No supported package manager detected on this system",
-            )
-        cmd = _GPU_READER_INSTALL_COMMANDS.get(pm)
-        if cmd is None:
-            log.warning("InstallGpuReader.execute: no recipe for pm=%r", pm)
-            return GpuReaderInstallResult(
-                ok=False, package_manager=pm,
-                message=(f"No auto-install recipe for {pm!r} — install the NVML "
-                         "python bindings (pynvml / nvidia-ml-py) manually"),
-            )
-        if self.dry_run:
-            return GpuReaderInstallResult(
-                ok=True, package_manager=pm, 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: subprocess failed")
-            return GpuReaderInstallResult(
-                ok=False, package_manager=pm, command=list(cmd),
-                message=f"Install subprocess failed: {type(e).__name__}: {e}",
-            )
-        ok = proc.returncode == 0
-        log.info("InstallGpuReader.execute: pm=%s exit=%d", pm, proc.returncode)
-        return GpuReaderInstallResult(
-            ok=ok, package_manager=pm, command=list(cmd), exit_code=proc.returncode,
-            message=("GPU sensor reader installed — restart trcc to enable GPU metrics"
-                     if ok else
-                     f"Install failed (exit {proc.returncode})"),
-        )
-
-
 @dataclass(frozen=True, slots=True)
 class ConfigureSlideshow(Command[SlideshowResult]):
     """Set the slideshow theme list + interval for a device.

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/core/diagnostics.py

@@ -68,9 +68,9 @@ class GpuReaderState:
     """Whether the NVIDIA NVML reader (pynvml) is present and initialised.
 
     ``nvidia_present`` — an NVIDIA card was detected.  ``reader_installed`` —
-    pynvml importable.  ``initialized`` — ``nvmlInit`` succeeded.  Drives the
-    "offer to install the reader" / "reader present but needs a reboot" logic
-    in :class:`GetGpuReaderStatus` without core importing the sensor adapter.
+    pynvml importable.  ``initialized`` — ``nvmlInit`` succeeded.  Surfaced by
+    the doctor's GPU health check (reader present / needs a reboot) without core
+    importing the sensor adapter.
     """
     nvidia_present: bool
     reader_installed: bool

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/core/ports.py

@@ -873,11 +873,10 @@ class Diagnostics(ABC):
 
     The diagnostics adapters consume the ``Platform`` port to probe the
     machine; this port lets core Commands (``RunHealthCheck``, ``RunDoctor``,
-    ``GenerateDebugReport``, ``GetGpuReaderStatus``, ``RunUpgrade``,
-    ``InstallGpuReader``) and the ``QuickstartService`` reach that work through
-    an injected interface instead of importing the adapter — so core stays
-    pure.  Debug reports cross as rendered text, not a struct, so the
-    ``DebugReport`` bundle stays an adapter implementation detail.
+    ``GenerateDebugReport``, ``RunUpgrade``) and the ``QuickstartService`` reach
+    that work through an injected interface instead of importing the adapter —
+    so core stays pure.  Debug reports cross as rendered text, not a struct, so
+    the ``DebugReport`` bundle stays an adapter implementation detail.
     """
 
     @abstractmethod

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/core/results.py

@@ -702,29 +702,6 @@ class UpgradeResult(Result):
     exit_code: int = 0
 
 
-@dataclass(frozen=True, slots=True)
-class GpuReaderStatusResult(Result):
-    """Whether the NVIDIA sensor reader (pynvml) should be offered for install.
-
-    ``offer_install`` is the actionable signal the GUI keys off — an NVIDIA
-    GPU is present but the reader isn't installed.  ``init_failed`` (reader
-    present, ``nvmlInit`` failed) is the version-mismatch/reboot case, which
-    is NOT installable and so not offered.
-    """
-    nvidia_present: bool = False
-    reader_installed: bool = False
-    init_failed: bool = False
-    offer_install: bool = False
-
-
-@dataclass(frozen=True, slots=True)
-class GpuReaderInstallResult(Result):
-    """Outcome of installing the NVIDIA sensor reader via the package manager."""
-    package_manager: str = ""
-    command: list[str] = field(default_factory=list)
-    exit_code: int = 0
-
-
 # Slideshow + keepalive
 @dataclass(frozen=True, slots=True)
 class SlideshowResult(Result):

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/services/settings.py

@@ -70,11 +70,6 @@ class AppSettings:
     # User-selected primary GPU (e.g. 'nvidia:0', 'amd:0', or 'intel:igpu').
     # None = let SensorEnumerator.primary_gpu() pick automatically.
     active_gpu: str | None = None
-    # The GUI offers to install the NVIDIA NVML reader (pynvml) once an
-    # NVIDIA GPU is detected without it.  "Not now" sets this so we stop
-    # re-offering on every launch; installing the reader clears the need
-    # naturally (the reader becomes importable next launch).
-    gpu_reader_install_declined: bool = False
 
 
 # =========================================================================
@@ -541,13 +536,6 @@ class Settings:
             self._app.hdd_enabled = enabled
             self._save()
 
-    def set_gpu_reader_install_declined(self, declined: bool) -> None:
-        """Remember the user said "Not now" to the GPU-reader install offer."""
-        log.info("set_gpu_reader_install_declined: declined=%s", declined)
-        with self._lock:
-            self._app.gpu_reader_install_declined = declined
-            self._save()
-
     def set_background_mode(
         self, key: str,
         mode: Literal["theme", "color", "transparent"],

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/ui/gui/__init__.py

@@ -190,14 +190,6 @@ def run_gui(platform: Any, *, decorated: bool = False,
         window.notify_device_failures(
             app.dispatch(DeviceConnectionIssues()).issues,
         )
-        # Foolproof GPU sensors: if an NVIDIA card is present but its reader
-        # isn't installed, offer a one-click install (consented).  Guarded so
-        # an optional prompt can never block startup.
-        from .gpu_reader_prompt import maybe_offer_gpu_reader_install
-        try:
-            maybe_offer_gpu_reader_install(app, window)
-        except Exception:
-            log.exception("GPU reader install prompt failed — continuing")
 
     try:
         exit_code = qapp.exec()

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/ui/presentation/device_presentation.py

@@ -13,10 +13,13 @@ Unit-testable with plain ``pytest`` — there is no toolkit here.
 """
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass
 
 from ...core.models import Kind, ProductInfo
 
+log = logging.getLogger(__name__)
+
 #: View identifiers the graphical UIs switch their panel stack on.
 VIEW_LED = "led"
 VIEW_FORM = "form"
@@ -45,9 +48,13 @@ def presentation_for(info: ProductInfo) -> DevicePresentation:
     graphical UIs agree on what a device presents without re-deriving it.
     """
     if info.kind is Kind.LED:
+        log.info("presentation_for: %s → view=%s gauges=True (LED)",
+                 info.kind.name, VIEW_LED)
         return DevicePresentation(
             kind=Kind.LED, view_name=VIEW_LED, shows_metric_gauges=True,
         )
+    log.info("presentation_for: %s → view=%s gauges=False (LCD form)",
+             info.kind.name, VIEW_FORM)
     return DevicePresentation(
         kind=Kind.LCD, view_name=VIEW_FORM, shows_metric_gauges=False,
     )

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/ui/presentation/lcd_panel.py

@@ -24,8 +24,11 @@ Unit-testable with plain ``pytest`` — there is no toolkit here.
 """
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass
 
+log = logging.getLogger(__name__)
+
 # Preview placement per resolution: (left, top, width, height, frame_image).
 # Native 1:1 for square / small panels; scaled to fit the 500x500 container for
 # the larger widescreen ones.  Mirrors C# UCScreenImage.SetMyUCScreenImage().
@@ -99,8 +102,15 @@ def lcd_panel_for(resolution: tuple[int, int]) -> LcdPanelModel:
     historical default.
     """
     w, h = resolution
+    widescreen = (w, h) in _WIDESCREEN or (h, w) in _WIDESCREEN
+    offset = _PREVIEW_OFFSETS.get((w, h))
+    if offset is None:
+        log.warning("lcd_panel_for: no preview offset for %dx%d — falling back to "
+                    "320x320 default; add it to _PREVIEW_OFFSETS", w, h)
+        offset = _DEFAULT_OFFSET
+    else:
+        log.info("lcd_panel_for: %dx%d → widescreen=%s frame=%s", w, h,
+                 widescreen, offset[4])
     return LcdPanelModel(
-        resolution=(w, h),
-        widescreen=(w, h) in _WIDESCREEN or (h, w) in _WIDESCREEN,
-        offset_info=_PREVIEW_OFFSETS.get((w, h), _DEFAULT_OFFSET),
+        resolution=(w, h), widescreen=widescreen, offset_info=offset,
     )

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/ui/presentation/lcd_presentation_model.py

@@ -15,6 +15,7 @@ Its purity (Qt-free, App-free, adapter-free) is machine-enforced by
 """
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -29,6 +30,8 @@ if TYPE_CHECKING:
     from ...core.models import ProductInfo, Theme
     from ...core.protocol import DeviceProfile
 
+log = logging.getLogger(__name__)
+
 # Default brightness % before the user picks one (legacy default).
 _DEFAULT_BRIGHTNESS = 100
 
@@ -94,6 +97,8 @@ class LcdPresentationModel:
         """
         self.state.canvas_size = (width, height)
         self.state.lcd_size = (width, height)
+        log.info("set_canvas: %s → canvas=lcd=%dx%d",
+                 self.device_key, width, height)
 
     def apply_rotation(self, degrees: int) -> None:
         """Update ``is_rotated`` + post-rotation ``lcd_size`` for an orientation.
@@ -104,6 +109,9 @@ class LcdPresentationModel:
         self.state.is_rotated, self.state.lcd_size = rotated_lcd_size(
             self.state.canvas_size, degrees,
         )
+        log.info("apply_rotation: %s %d° → is_rotated=%s lcd_size=%dx%d",
+                 self.device_key, degrees, self.state.is_rotated,
+                 *self.state.lcd_size)
 
     # ── Video math (B5) ────────────────────────────────────────────────
     # Pure per-tick arithmetic lifted off the handler's video path; the
@@ -135,7 +143,11 @@ class LcdPresentationModel:
         """
         self.split_mode = persisted_mode or 2
         self.ldd_is_split = lcd_size in SPLIT_MODE_RESOLUTIONS
-        return self.split_mode if self.ldd_is_split else 0
+        dispatch_mode = self.split_mode if self.ldd_is_split else 0
+        log.info("apply_split_mode: %s persisted=%d size=%dx%d → split_mode=%d "
+                 "ldd_is_split=%s dispatch=%d", self.device_key, persisted_mode,
+                 *lcd_size, self.split_mode, self.ldd_is_split, dispatch_mode)
+        return dispatch_mode
 
     def preview_size(
         self,
@@ -152,7 +164,11 @@ class LcdPresentationModel:
         canvas swapped for the user orientation.  The View supplies the
         device/theme primitives; the model owns the cached ``canvas_size``.
         """
-        return composed_preview_size(
+        size = composed_preview_size(
             display, info=info, theme=theme, profile=profile,
             orientation=orientation, canvas_size=self.state.canvas_size,
         )
+        log.info("preview_size: %s orient=%d device=%s theme=%s → %dx%d",
+                 self.device_key, orientation, info is not None,
+                 theme is not None, *size)
+        return size

{trcc_linux-9.8.2 → trcc_linux-9.8.3}/src/trcc/ui/presentation/led_display.py

@@ -30,9 +30,12 @@ Unit-testable with plain ``pytest`` — there is no toolkit here.
 """
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass
 from enum import Enum
 
+log = logging.getLogger(__name__)
+
 
 class LedSelector(Enum):
     """What the panel's button row selects for a given LED style."""
@@ -88,4 +91,11 @@ def led_display_for(style_id: int) -> LedDisplayModel:
 
     Unknown ids fall back to NONE (no selector).
     """
-    return _DISPLAY.get(style_id, _DEFAULT)
+    model = _DISPLAY.get(style_id)
+    if model is None:
+        log.warning("led_display_for: unknown style=%d → NONE selector (no metric "
+                    "pages / zones); expected 1-12", style_id)
+        return _DEFAULT
+    log.info("led_display_for: style=%d → selector=%s slots=%d",
+             style_id, model.selector.value, model.slot_count)
+    return model