trcc-linux 9.8.4__tar.gz → 9.8.5__tar.gz

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.8.4
+Version: 9.8.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.8.4 → trcc_linux-9.8.5}/pyproject.toml

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

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/__version__.py

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

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/adapters/infra/sysinfo_config.py

@@ -291,12 +291,24 @@ class SysInfoConfig:
                 (i, b) for i, b in enumerate(fan_panel.sensors)
                 if not b.sensor_id
             ]
-            leftover_fan_ids = sorted(
-                r.sensor_id for r in readings
-                if r.sensor_id.startswith("fan:")
-                and r.sensor_id.endswith(":rpm")
-                and r.sensor_id not in bound_fan_ids
-            )
+            # Spinning fans first, dead headers last.  A super-I/O chip
+            # exposes every fan header (fan1..fan6) whether or not a fan is
+            # plugged in, and label-less boards (nct6xxx etc.) give no way to
+            # tell which is the CPU/pump.  Binding in raw id order lands the
+            # CPU/GPU slots on disconnected headers reading 0 RPM while the
+            # real fans (a water pump + radiator fans sit on arbitrary
+            # headers, always spinning) fall off the end — the "fans not
+            # reporting" bug (#145).  Order by (is-idle, id) so live readings
+            # claim the visible slots; idle headers only backfill leftovers.
+            leftover_fan_ids = [
+                r.sensor_id for r in sorted(
+                    (r for r in readings
+                     if r.sensor_id.startswith("fan:")
+                     and r.sensor_id.endswith(":rpm")
+                     and r.sensor_id not in bound_fan_ids),
+                    key=lambda r: ((r.value or 0.0) <= 0.0, r.sensor_id),
+                )
+            ]
             for (slot_idx, binding), fan_id in zip(
                 unbound_slots, leftover_fan_ids, strict=False,
             ):

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/app.py

@@ -54,7 +54,7 @@ from .services.led_effects import LEDEffectEngine
 from .services.media import MediaService
 from .services.metrics_loop import MetricsLoop
 from .services.migration import LibraryMigration
-from .services.overlay import OverlayService
+from .services.overlay import OverlayService, resolve_overlay_elements
 from .services.quickstart import QuickstartService
 from .services.settings import Settings
 from .services.slideshow import SlideshowService
@@ -413,6 +413,34 @@ class App:
             )
         return self._renderer
 
+    def effective_overlay_elements(self, key: str) -> list[dict]:
+        """The ONE overlay layout actually on screen for ``key``.
+
+        The single source every per-element operation (flash, select, edit)
+        must address — resolved by the same precedence the renderer uses
+        (user > mask > theme, each REPLACES; see
+        ``resolve_overlay_elements``).  Addressing only the user layer was
+        the ``FlashOverlayElement 'N' not found`` bug: when a mask or theme
+        supplies the live layout the user layer is empty, so an id/index
+        resolved against it matched nothing on screen.
+        """
+        s = self.settings.for_device(key)
+        theme = self.active_themes.get(key)
+        theme_config = theme.config if theme is not None else {}
+        elements = resolve_overlay_elements(
+            theme_config, s.mask_overlay_elements, s.user_overlay_elements,
+        )
+        log.debug(
+            "effective_overlay_elements: key=%s → %d element(s) "
+            "[theme=%d mask=%s user=%d]",
+            key, len(elements),
+            len(theme_config.get("elements") or []),
+            None if s.mask_overlay_elements is None
+            else len(s.mask_overlay_elements),
+            len(s.user_overlay_elements),
+        )
+        return elements
+
     # ── Device lifecycle ──────────────────────────────────────────────
 
     def attach(self, vid: int, pid: int) -> Device:
@@ -498,6 +526,16 @@ class App:
         self.metrics_loop.stop()
         self.led_animation_loop.stop()
         self.stop_hotplug()
+        # Blank every panel before releasing it so it goes dark on shutdown
+        # instead of holding its last frame lit (#143).  Best-effort: the
+        # Command swallows a mid-unplug send, and any unexpected error here
+        # must not block device release below.
+        from .core.commands import SleepDevice
+        for key in list(self.devices):
+            try:
+                self.dispatch(SleepDevice(key=key))
+            except Exception:
+                log.exception("close: SleepDevice raised for %s", key)
         for key in list(self.devices):
             self.detach(key)
         self._send_scheduler.shutdown()

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/core/commands/__init__.py

@@ -19,6 +19,7 @@ from .device import (
     DisconnectDevice,
     DiscoverDevices,
     EnableOverlay,
+    EnsureConnected,
     FlashOverlayElement,
     LcdSnapshot,
     LoopVideo,
@@ -42,6 +43,7 @@ from .device import (
     SetOverlayBackground,
     SetOverlayConfig,
     SetSplitMode,
+    SleepDevice,
     StartScreencast,
     StopScreencast,
     StopVideo,
@@ -147,6 +149,7 @@ __all__ = [
     "EnableAutostart",
     "EnableLedTestMode",
     "EnableOverlay",
+    "EnsureConnected",
     "EnsureDataDownload",
     "ExportConfig",
     "ExportDcTheme",
@@ -234,6 +237,7 @@ __all__ = [
     "SetTempUnit",
     "SetTimeFormat",
     "SetWeekStart",
+    "SleepDevice",
     "StartScreencast",
     "StopScreencast",
     "StopVideo",

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/core/commands/device.py

@@ -236,6 +236,34 @@ class ConnectDevice(Command[ConnectResult]):
         )
 
 
+@dataclass(frozen=True, slots=True)
+class EnsureConnected(Command[ConnectResult]):
+    """Bring *key* up for a wire command only if it isn't already connected.
+
+    The idempotent counterpart to :class:`ConnectDevice`.  A stateless CLI
+    process holds no attached devices, so a wire command (``color``, ``play``,
+    ``load-theme`` …) dispatched from a fresh process would fail with "not
+    connected".  This attaches + handshakes once; when a daemon/GUI already
+    holds the device it is a pure no-op — unlike ``ConnectDevice`` it never
+    rebuilds the transport or re-handshakes a live device, so it is safe to
+    call before every wire command and once before a render/play loop without
+    disrupting an active stream.  (``ConnectDevice`` keeps its always-handshake
+    contract for the reconnect / dev-console inject-reply paths.)
+    """
+    key: str
+
+    def execute(self, app: App) -> ConnectResult:
+        existing = app.devices.get(self.key)
+        if existing is not None and existing.is_connected:
+            log.debug("EnsureConnected %s: already connected — no-op", self.key)
+            return ConnectResult(
+                ok=True, key=self.key,
+                message=f"{self.key} already connected",
+            )
+        log.info("EnsureConnected %s: not connected — attaching", self.key)
+        return app.dispatch(ConnectDevice(key=self.key))
+
+
 @dataclass(frozen=True, slots=True)
 class DeviceConnectionIssues(Command[ConnectionIssuesResult]):
     """Query devices that were found but failed to connect (with per-OS hints).
@@ -357,6 +385,44 @@ class SendColor(Command[SendResult]):
                      if ok else "Send returned False"),
         )
 
+@dataclass(frozen=True, slots=True)
+class SleepDevice(Command[SendResult]):
+    """Blank a connected panel so it goes dark on shutdown / quit (#143).
+
+    The unified "turn the screen off" action every surface dispatches — the
+    GUI/daemon shutdown hook (``App.close``), ``trcc display sleep`` (CLI),
+    and the ``/sleep`` API route all send this one Command.  Mirrors the C#
+    exit path (stop streaming + close the device) but adds an explicit dark
+    frame first, so the panel visibly clears instead of holding its last
+    image until the firmware idle-sleeps.
+
+    Composes the existing wire paths rather than duplicating them: LCD →
+    :class:`SendColor` (a solid-black frame via
+    ``DisplayService.build_solid_color_frame``); LED → :class:`SetLedColors`
+    with ``global_on=False`` (an all-off payload).  Best-effort by design —
+    a device mid-unplug returns ``ok=False`` instead of raising, so it can
+    never abort ``App.close`` mid-shutdown.
+    """
+    key: str
+
+    def execute(self, app: App) -> SendResult:
+        log.info("SleepDevice: key=%s", self.key)
+        device = app.devices.get(self.key)
+        if device is None or not device.is_connected:
+            log.info("SleepDevice %s: not connected — nothing to blank",
+                     self.key)
+            return SendResult(ok=False, key=self.key, bytes_sent=0,
+                              message=f"{self.key} not connected")
+        if device.is_led:
+            from .led import SetLedColors
+            result = SetLedColors(
+                key=self.key, colors=[(0, 0, 0)], global_on=False,
+            ).execute(app)
+            return SendResult(ok=result.ok, key=self.key, bytes_sent=0,
+                              message=result.message)
+        return SendColor(key=self.key, r=0, g=0, b=0).execute(app)
+
+
 @dataclass(frozen=True, slots=True)
 class SendImage(Command[SendResult]):
     """Push an image file to the LCD without staging it as a theme.
@@ -1535,16 +1601,20 @@ class FlashOverlayElement(Command[OverlayElementResult]):
     duration_ms: int = 1500
 
     def execute(self, app: App) -> OverlayElementResult:
-        elements = app.settings.for_device(self.key).user_overlay_elements
-        for e in elements:
-            if e.id == self.element_id:
+        # Resolve against the EFFECTIVE layout on screen (user > mask >
+        # theme), not just the user layer — a mask/theme supplies the live
+        # elements while the user layer is empty, so a user-only lookup
+        # never matched them (the "element 'N' not found" flash bug).
+        for e in app.effective_overlay_elements(self.key):
+            if e.get("id") == self.element_id:
                 app.events.publish(OverlayChanged(
                     key=self.key, enabled=True,
                     flash_element_id=self.element_id,
                     flash_duration_ms=self.duration_ms,
                 ))
                 return OverlayElementResult(
-                    ok=True, key=self.key, element=_element_to_entry(e),
+                    ok=True, key=self.key,
+                    element=_element_to_entry(OverlayElement.from_dict(e)),
                     message=f"Flashing overlay element {self.element_id} "
                             f"for {self.duration_ms}ms",
                 )

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/core/protocol.py

@@ -322,3 +322,35 @@ def wire_rotation(profile: DeviceProfile, orientation: int, pm: int = 0) -> int:
     log.debug("wire_rotation: %dx%d jpeg=%s pm=%d base=%d orient=%d → %d°",
               w, h, profile.jpeg, pm, base, orientation, angle)
     return angle
+
+
+def wire_angle(
+    profile: DeviceProfile, orientation: int, portrait_content: bool,
+) -> int:
+    """The single wire-frame rotation a device gets at a user *orientation*.
+
+    Collapses ``DisplayService.build_frame``'s three-way selection into one
+    pure decision so the render path and any auditor share it (DRY):
+
+      * non-widescreen rotate panels → :func:`wire_rotation` (``base − orient``)
+      * widescreen JPEG rotate panels → :func:`resolve_encode_angle` (the
+        hardware-verified #169 per-resolution encode table)
+      * squares / non-rotate panels → user orientation only (``360 − orient``)
+
+    A portrait-content theme on a rotate panel is pre-rotated at compose time
+    (``post_rotate``) and opts out by passing ``portrait_content=True``.
+    """
+    wire_rotate_panel = (
+        profile.rotate and not portrait_content and not profile.widescreen
+    )
+    fold_into_encode = (
+        profile.rotate and not portrait_content
+        and profile.widescreen and profile.jpeg
+    )
+    if wire_rotate_panel:
+        return wire_rotation(profile, orientation)
+    if fold_into_encode:
+        return resolve_encode_angle(profile, orientation)
+    if orientation and not portrait_content:
+        return (360 - orientation) % 360
+    return 0

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/core/registry.py

@@ -51,8 +51,11 @@ ALL_DEVICES: dict[tuple[int, int], ProductInfo] = {
         vid=0x0416, pid=0x5406,
         vendor="Winbond",
         product="LCD Display",
-        wire=Wire.SCSI, kind=Kind.LCD,
-        device_type=1, fbl=100,
+        # Elite Vision 360 ARGB (#212): enumerates vendor-specific with two BULK
+        # endpoints, never a /dev/sg* node — it is a BULK device, not SCSI.  Its
+        # PM/resolution table already lives in _BULK_VARIANTS (variants.py).
+        wire=Wire.BULK, kind=Kind.LCD,
+        device_type=4, fbl=100,
         native_resolution=(320, 320),
         orientations=(0, 90, 180, 270),
     ),

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/services/_dc.py

@@ -44,26 +44,27 @@ _MODE_DATE = 3
 _MODE_CUSTOM = 4
 
 
-# Metric VALUE slots render the BARE INTEGER — never the unit.  The Windows
-# app strips the unit off every sensor value before drawing it on the panel
-# (TRCC.cs: val.Replace("℃"/"℉"/"MHz"/"%"/"RPM","") → Convert.ToInt32 →
-# DrawString) because the unit is part of the theme's background artwork, not
-# the overlay.  Baking "°C"/"%"/"MHz" into the format double-prints the unit
-# on top of the baked-in glyph (#150/#203 diagnosis).  Label slots keep their
-# text; only the value slots are bare.
+# Metric VALUE slots carry their unit in the format so it renders DYNAMICALLY —
+# matching the C# flag-template reader (case 220), which sets every value
+# element's ``myModeSub = 1`` → ``UCXiTongXianShiSubTimer`` draws number + unit.
+# The unit is our decorator (``_draw_metric`` swaps °C→°F on the global toggle
+# and button0 can hide it), NOT a baked glyph: a baked "°C" is static and reads
+# wrong the moment the user picks Fahrenheit, so the unit must be drawn.  (The
+# earlier #150/#203 "render bare" was wrong for these masks — the art's unit
+# glyph is decoration; the functional unit is drawn, per the C#.)
 _SLOT_MAP: list[tuple[str, str | None, str, str]] = [
     ("custom_text",       None,               "",      ""),
-    ("cpu_temp",          "cpu:temp",         "CPU",   "{value:.0f}"),
+    ("cpu_temp",          "cpu:temp",         "CPU",   "{value:.0f}°C"),
     ("cpu_temp_label",    None,               "CPU",   ""),
-    ("cpu_freq",          "cpu:freq",         "CPU",   "{value:.0f}"),
+    ("cpu_freq",          "cpu:freq",         "CPU",   "{value:.0f} MHz"),
     ("cpu_freq_label",    None,               "CPU",   ""),
-    ("cpu_usage",         "cpu:usage",        "CPU",   "{value:.0f}"),
+    ("cpu_usage",         "cpu:usage",        "CPU",   "{value:.0f}%"),
     ("cpu_usage_label",   None,               "CPU",   ""),
-    ("gpu_temp",          "gpu:primary:temp", "GPU",   "{value:.0f}"),
+    ("gpu_temp",          "gpu:primary:temp", "GPU",   "{value:.0f}°C"),
     ("gpu_temp_label",    None,               "GPU",   ""),
-    ("gpu_clock",         "gpu:primary:clock","GPU",   "{value:.0f}"),
+    ("gpu_clock",         "gpu:primary:clock","GPU",   "{value:.0f} MHz"),
     ("gpu_clock_label",   None,               "GPU",   ""),
-    ("gpu_usage",         "gpu:primary:usage","GPU",   "{value:.0f}"),
+    ("gpu_usage",         "gpu:primary:usage","GPU",   "{value:.0f}%"),
     ("gpu_usage_label",   None,               "GPU",   ""),
 ]
 

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/services/display.py

@@ -37,8 +37,7 @@ from ..core.ports import Renderer
 from ..core.protocol import (
     DeviceProfile,
     get_profile,
-    resolve_encode_angle,
-    wire_rotation,
+    wire_angle,
 )
 from ._clock import compute_clock
 from .media import MediaService
@@ -382,26 +381,9 @@ class DisplayService:
         #    the per-resolution encode TABLE (resolve_encode_angle) — the
         #    hardware-verified #169 path, unchanged.
         #  * Squares + non-rotate panels: user orientation only.
-        wire_rotate_panel = (
-            resolved_profile.rotate and not portrait
-            and not resolved_profile.widescreen
-        )
-        fold_into_encode = (
-            resolved_profile.rotate and not portrait
-            and resolved_profile.widescreen and resolved_profile.jpeg
-        )
-        if wire_rotate_panel:
-            angle = wire_rotation(resolved_profile, s.orientation)
-        elif fold_into_encode:
-            angle = resolve_encode_angle(resolved_profile, s.orientation)
-        elif s.orientation and not portrait:
-            angle = 360 - s.orientation
-        else:
-            angle = 0
+        angle = wire_angle(resolved_profile, s.orientation, portrait)
         if angle % 360:
-            log.debug("build_frame %s: wire rotate %d° "
-                      "(wire_panel=%s widescreen=%s)",
-                      info.key, angle, wire_rotate_panel, fold_into_encode)
+            log.debug("build_frame %s: wire rotate %d°", info.key, angle)
             surface = self._r.rotate(composite, angle)
         else:
             surface = composite

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/ui/api/display.py

@@ -49,6 +49,7 @@ from ...core.commands import (
     SetOverlayConfig,
     SetSlideshow,
     SetSplitMode,
+    SleepDevice,
     StartScreencast,
     StopScreencast,
     StopVideo,
@@ -768,6 +769,19 @@ def send_color(key: str, body: ColorRequest, request: Request) -> SendResponse:
     return to_send_response(result)
 
 
+@router.post("/sleep", response_model=SendResponse)
+def sleep(key: str, request: Request) -> SendResponse:
+    """Blank the panel so it goes dark — the shutdown / turn-off action.
+
+    Sends a solid-black frame (LCD) or an all-off payload (LED), the same
+    Command the GUI + daemon fire at PC shutdown.
+    """
+    log.info("api POST /devices/{key}/display/sleep: key=%s", key)
+    result = request.app.state.trcc.dispatch(SleepDevice(key=key))
+    http_error_if_failed(result)
+    return to_send_response(result)
+
+
 @router.post("/reset", response_model=SendResponse)
 def reset(key: str, request: Request) -> SendResponse:
     """Reset the display — stop any active video, then send a solid red frame.

{trcc_linux-9.8.4 → trcc_linux-9.8.5}/src/trcc/ui/cli/_ctx.py

@@ -35,6 +35,47 @@ def emit_json(result: Any) -> None:
     typer.echo(dumps_json(dataclasses.asdict(result)))
 
 
+def ensure_connected(app: App, key: str) -> None:
+    """Attach + handshake *key* if this stateless CLI process hasn't yet.
+
+    Every CLI invocation is a fresh, non-daemon App holding no attached
+    devices, so a wire command (``color`` / ``play`` / ``load-theme`` / LED
+    ``render`` …) dispatched straight away would fail with "not connected".
+    ``EnsureConnected`` is idempotent — a no-op when a daemon/GUI already holds
+    the device — so this is safe before a single wire command and once before a
+    render/play loop.  Exits with the connect error on failure (a wire command
+    against an unattached device can do nothing useful).
+    """
+    from ...core.commands import EnsureConnected
+    result = app.dispatch(EnsureConnected(key=key))
+    if not result.ok:
+        typer.echo(result.message, err=True)
+        raise typer.Exit(code=1)
+
+
+def dispatch_echo(cmd: Any) -> Any:
+    """Dispatch *cmd*, echo its ``message``, exit(1) on failure; return the Result.
+
+    Collapses the `result = get_app().dispatch(...); typer.echo(result.message);
+    if not result.ok: raise typer.Exit(1)` tail that every non-interactive CLI
+    command repeats.  Commands that read fields off the Result keep the returned
+    value; the rest just call it.
+    """
+    result = get_app().dispatch(cmd)
+    typer.echo(result.message)
+    if not result.ok:
+        raise typer.Exit(code=1)
+    return result
+
+
+def parse_on_off(state: str) -> bool:
+    """Parse an ``on``/``off`` CLI argument to bool, or raise ``BadParameter``."""
+    lowered = state.lower()
+    if lowered not in ("on", "off"):
+        raise typer.BadParameter(f"state must be 'on' or 'off', got {state!r}")
+    return lowered == "on"
+
+
 _platform_override: Platform | None = None
 _renderer_override: Renderer | None = None