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

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

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

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

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

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

{trcc_linux-9.8.0 → trcc_linux-9.8.2}/src/trcc/core/commands/theme.py

@@ -21,7 +21,7 @@ from ..events import (
     ThemeLoaded,
     ThemeSaved,
 )
-from ..geometry import content_is_portrait, plan_orientation
+from ..geometry import content_is_portrait, save_folder_resolution
 from ..registry import find_product
 from ..results import (
     CloudCategoryEntry,
@@ -391,13 +391,14 @@ class SaveTheme(Command[ThemeResult]):
             )
 
         device_settings = app.settings.for_device(self.key)
-        # Save into the folder matching the COMPOSED orientation, not the raw
+        # Save into the folder matching the content's orientation, not the raw
         # angle — the content's parent folder IS the orientation.  A connected
-        # device carries its profile, so we key the resolution on the same
-        # plan_orientation decision the renderer uses: a portrait selection
-        # (portrait mask / portrait theme) → theme{h}{w}; landscape content →
-        # theme{w}{h}.  This makes save + reload agree — a theme always reloads
-        # into the orientation it was composed in.  Disconnected (no live
+        # device carries its profile, so we key the resolution on
+        # save_folder_resolution: a portrait selection (portrait mask / portrait
+        # theme) → theme{h}{w}; landscape content → theme{w}{h}.  This makes
+        # save + reload agree — a theme always reloads into the orientation it
+        # was composed in.  (Folder selection is the asset-catalog concern, kept
+        # separate from the renderer's compose canvas.)  Disconnected (no live
         # profile) falls back to the angle-keyed resolution, unchanged.
         device = app.devices.get(self.key)
         profile = device.profile if device is not None else None
@@ -406,9 +407,9 @@ class SaveTheme(Command[ThemeResult]):
                 theme, profile, device_settings.mask_path,
                 device_settings.mask_visible,
             )
-            resolution = plan_orientation(
+            resolution = save_folder_resolution(
                 profile, device_settings.orientation, portrait,
-            ).canvas
+            )
         else:
             resolution = _resolve_oriented_resolution(app, self.key)
         if resolution is None:

{trcc_linux-9.8.0 → trcc_linux-9.8.2}/src/trcc/core/geometry.py

@@ -117,5 +117,41 @@ def plan_orientation(
     if rotate_panel and not content_is_portrait and not profile.widescreen:
         return OrientationPlan((w, h), False, orientation)
     if rotate_panel:
-        return OrientationPlan((h, w), True, 0)
+        # Portrait content is composed on the transposed canvas with the
+        # orientation baked into the pixels — but the asset is authored for 90.
+        # 270 is 90 + a 180° flip, and 180° is dimension-preserving, so rotate
+        # the WHOLE composite (bg + mask + text) as one unit and everything
+        # stays true to the physical rotation instead of frozen at 90.
+        # Widescreen JPEG panels keep post_rotate=0: their 90/270 send-unrotated
+        # behaviour is hardware-verified (#169) and must not change.
+        # 270 is 90 + a dimension-preserving 180° flip — applies to EVERY rotate
+        # panel including widescreen (the C# decompile shows widescreen 854×480
+        # rotates 90→270° / 270→90°, a 180° difference, not frozen).  The flip
+        # keeps the portrait-buffer dimensions (#169) and only re-orients the
+        # content, so it's dimension-safe (no clip).  On-glass handedness for
+        # widescreen still wants a reporter photo (#203) to confirm.
+        post_rotate = 180 if orientation == 270 else 0
+        return OrientationPlan((h, w), True, post_rotate)
     return OrientationPlan(oriented_resolution((w, h), orientation), False, 0)
+
+
+def save_folder_resolution(
+    profile: DeviceProfile, orientation: int, content_is_portrait: bool,
+) -> tuple[int, int]:
+    """Resolution key for a saved theme's FOLDER (``theme{w}{h}`` vs ``{h}{w}``).
+
+    This is the **asset-catalog** concern — portrait content saves into the
+    portrait folder, landscape into the landscape folder — kept deliberately
+    separate from the render **compose canvas** (which is purely
+    :func:`oriented_resolution`, content-independent).  The two coincide today
+    but diverge for landscape content at a portrait angle, so ``SaveTheme`` owns
+    this predicate rather than borrowing the renderer's canvas.  Mirrors the
+    v9.8.0 folder-switch (Phase D): a portrait selection → ``theme{h}{w}``.
+    """
+    w, h = profile.resolution
+    rotate_panel = profile.rotate and w != h and orientation in (90, 270)
+    if rotate_panel and (content_is_portrait or profile.widescreen):
+        return (h, w)                       # portrait folder
+    if rotate_panel:
+        return (w, h)                       # landscape content at a portrait angle
+    return oriented_resolution((w, h), orientation)

trcc_linux-9.8.2/tests/test_diagnose_parse_report.py

@@ -0,0 +1,229 @@
+"""Cover ``dev/tools/diagnose.py::parse_report`` against real report layouts.
+
+The report-replay loop (``dev/mock_gui.py --report`` →
+``dev/_mock_bootstrap.py::_specs_from_report`` → ``parse_report``) is only as
+good as this parser: if it can't recover a reporter's device from the text they
+paste into a GitHub issue, the mock boots nothing.  These fixtures are the two
+shapes that actually turn up in issues:
+
+* **Current** (2026+) — a ``## Devices`` section + ``## Platform`` block, with
+  the handshake bytes in the log tail (issue #203 / #176 layout).
+* **Truncated current** — GitHub clipped the paste above ``## Devices`` (what
+  #203 actually pasted); only the log tail survives, so the device id must be
+  recovered from the ``found <vid:pid>`` scan line.
+* **Legacy** — the old ``[N] vid:pid (PROTO) path=…`` layout, which must still
+  parse so historical reports keep replaying.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_DEV_TOOLS = Path(__file__).resolve().parent.parent / "dev" / "tools"
+
+
+@pytest.fixture(scope="module")
+def parse_report():
+    sys.path.insert(0, str(_DEV_TOOLS))
+    try:
+        from diagnose import parse_report as fn  # type: ignore[import-not-found]
+    finally:
+        sys.path.remove(str(_DEV_TOOLS))
+    return fn
+
+
+@pytest.fixture(scope="module")
+def parse_dispatch_sequence():
+    sys.path.insert(0, str(_DEV_TOOLS))
+    try:
+        from diagnose import (  # type: ignore[import-not-found]
+            parse_dispatch_sequence as fn,
+        )
+    finally:
+        sys.path.remove(str(_DEV_TOOLS))
+    return fn
+
+
+# A log tail with the shapes App.dispatch actually emits: str/int/bool kwargs,
+# a PosixPath arg, connection + network + per-frame + query commands (all
+# skipped), and an unparseable enum repr (skipped without aborting the rest).
+_DISPATCH_LOG = """\
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch ConnectDevice(key='87ad:70db')
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch CheckForUpdate()
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch ListThemes(resolution=(854, 480), directory=None)
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch SetBrightness(key='87ad:70db', percent=100)
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch SetOrientation(key='87ad:70db', degrees=180)
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch LoadTheme(key='87ad:70db', path=PosixPath('/home/x/.trcc/data/theme854480/Theme5'), reset_overrides=True)
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch SetSplitMode(key='87ad:70db', mode=0)
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch SendFrame(key='87ad:70db')
+  2026-06-28 INFO trcc.app:App.dispatch:599: dispatch SetOrientation(key='87ad:70db', orient=<Orientation.PORTRAIT: 90>)
+"""
+
+
+# The current ``trcc report`` layout — device in its own section, handshake in
+# the log tail (mirrors debug_report.py::_render_devices + _render_kv).
+_CURRENT = """\
+## Platform
+  distro              Fedora Linux 44 (KDE Plasma Desktop Edition)
+  install_method      pip
+  python              3.14.5
+  system              Linux
+  release             7.0.12-201.fc44.x86_64
+
+## Devices (1)
+  87ad:70db       GrandVision 360 AIO             wire=bulk
+
+## Log tail (1000 lines)
+  2026-06-28T13:20:39 INFO    trcc.adapters.system.linux:LinuxPlatform.scan_devices:401:   found 87ad:70db serial='110702190133e003'
+  2026-06-28T13:20:39 INFO    trcc.adapters.device.bulk_lcd:BulkLcd.connect:165: BulkLcd handshake OK: PM=11 SUB=5 resolution=(854, 480) (JPEG)
+"""
+
+# The same report clipped above "## Devices" — only the log tail is left.
+_TRUNCATED = """\
+  gpu:primary:temp                    27.00 °C  (temperature)
+
+## Log tail (1000 lines)
+  2026-06-28T13:20:39 INFO    trcc.adapters.system:PlatformFactory.current:63: PlatformFactory.current: building LinuxPlatform
+  2026-06-28T13:20:39 INFO    trcc.adapters.system.linux:LinuxPlatform.scan_devices:401:   found 87ad:70db serial='110702190133e003'
+  2026-06-28T13:20:39 INFO    trcc.adapters.device.bulk_lcd:BulkLcd.connect:165: BulkLcd handshake OK: PM=11 SUB=5 resolution=(854, 480) (JPEG)
+"""
+
+# The pre-2026 layout the parser must still accept.
+_LEGACY = """\
+trcc-linux:    9.6.5
+OS:            Linux 6.8.0
+Python:        3.12.3
+
+Detected devices:
+  [0] 87ad:70db  GrandVision 360 AIO  (BULK)  path=/dev/bus/usb/003/004
+
+Handshakes:
+  BulkLcd handshake OK: PM=11 SUB=5 resolution=(854, 480)
+"""
+
+
+def test_current_layout_extracts_device_and_handshake(parse_report):
+    report = parse_report(_CURRENT)
+    assert report.os_name == "Linux"
+    assert report.python_version == "3.14.5"
+    assert len(report.devices) == 1
+    dev = report.devices[0]
+    assert (dev.vid, dev.pid) == (0x87AD, 0x70DB)
+    assert dev.protocol == "bulk"
+    assert (dev.pm, dev.sub) == (11, 5)
+    assert (dev.width, dev.height) == (854, 480)
+
+
+def test_truncated_report_recovers_device_from_log_tail(parse_report):
+    # GitHub clipped the "## Devices" section — the scan line in the log tail is
+    # the only surviving device id, and the handshake still supplies PM/SUB/res.
+    report = parse_report(_TRUNCATED)
+    assert report.os_name == "Linux"          # recovered from "building LinuxPlatform"
+    assert len(report.devices) == 1
+    dev = report.devices[0]
+    assert (dev.vid, dev.pid) == (0x87AD, 0x70DB)
+    assert dev.protocol == "bulk"             # inferred from "BulkLcd handshake OK"
+    assert (dev.pm, dev.sub) == (11, 5)
+    assert (dev.width, dev.height) == (854, 480)
+
+
+_LED_REPORT = """\
+## Platform
+  system              Linux
+
+## Devices (1)
+  0416:8001       Assassin 120 Digital            wire=led
+
+## Log tail (1000 lines)
+  2026-06-30 INFO trcc.adapters.device.led:Led.connect:252:   found 0416:8001 serial='z'
+  2026-06-30 INFO trcc.adapters.device.led:Led.connect:252: Led handshake OK: PM=16 SUB=16 style=pa120 model=PA120_DIGITAL
+"""
+
+
+def test_led_handshake_without_resolution_extracts_pm_sub(parse_report):
+    # LED / segment coolers log "handshake OK: PM=N SUB=M style=… model=…" with
+    # no "resolution=(w, h)" — PM/SUB must still be recovered (they are the
+    # whole fingerprint; width/height stay 0 and the model resolves from PM).
+    report = parse_report(_LED_REPORT)
+    assert len(report.devices) == 1
+    dev = report.devices[0]
+    assert (dev.vid, dev.pid) == (0x0416, 0x8001)
+    assert dev.protocol == "hid"          # led → hid test surface
+    assert (dev.pm, dev.sub) == (16, 16)
+    assert (dev.width, dev.height) == (0, 0)
+
+
+def test_variant_override_line_is_not_mistaken_for_handshake(parse_report):
+    # "variant override PM=… SUB=…" carries the same bytes but no resolution —
+    # only the real "handshake OK:" line should set the device's PM/SUB.
+    text = _CURRENT + (
+        "  2026 INFO trcc.core.commands.device:ConnectDevice.execute:188: "
+        "ConnectDevice 87ad:70db: variant override PM=99 SUB=99 → A1LF19\n"
+    )
+    report = parse_report(text)
+    # PM/SUB come from the handshake line (11/5), not the override line (99/99).
+    assert (report.devices[0].pm, report.devices[0].sub) == (11, 5)
+
+
+def test_legacy_layout_still_parses(parse_report):
+    report = parse_report(_LEGACY)
+    assert report.trcc_version == "9.6.5"
+    assert report.os_name == "Linux 6.8.0"
+    assert report.python_version == "3.12.3"
+    assert len(report.devices) == 1
+    dev = report.devices[0]
+    assert (dev.vid, dev.pid) == (0x87AD, 0x70DB)
+    assert dev.protocol == "bulk"
+    assert dev.path == "/dev/bus/usb/003/004"
+    assert (dev.pm, dev.sub) == (11, 5)
+    assert (dev.width, dev.height) == (854, 480)
+
+
+def test_log_tail_fallback_dedupes_repeated_scan_lines(parse_report):
+    # scan_devices runs several times per session, so "found 87ad:70db" repeats;
+    # the device must appear exactly once, not once per scan.
+    text = _TRUNCATED + (
+        "  found 87ad:70db serial='x'\n"
+        "  found 87ad:70db serial='x'\n"
+    )
+    report = parse_report(text)
+    assert len(report.devices) == 1
+
+
+def test_dispatch_sequence_reconstructs_display_actions(parse_dispatch_sequence):
+    seq = parse_dispatch_sequence(_DISPATCH_LOG)
+    # Connection, network, query, per-frame, and the enum-repr line are dropped;
+    # the four display-state actions remain, in order.
+    names = [e["command"] for e in seq]
+    assert names == [
+        "SetBrightness", "SetOrientation", "LoadTheme", "SetSplitMode",
+    ]
+
+
+def test_dispatch_sequence_preserves_kwargs_and_paths(parse_dispatch_sequence):
+    seq = parse_dispatch_sequence(_DISPATCH_LOG)
+    by_name = {e["command"]: e["kwargs"] for e in seq}
+    assert by_name["SetOrientation"] == {"key": "87ad:70db", "degrees": 180}
+    # PosixPath(...) collapses to the string the command builder re-coerces.
+    assert by_name["LoadTheme"] == {
+        "key": "87ad:70db",
+        "path": "/home/x/.trcc/data/theme854480/Theme5",
+        "reset_overrides": True,
+    }
+
+
+def test_dispatch_envelopes_decode_to_real_commands(parse_dispatch_sequence):
+    # The envelopes must be exactly what trcc.ipc.decode_command consumes —
+    # prove the whole replay contract, not just the parse.
+    import trcc.ipc as ipc
+    from trcc.core.commands import SetOrientation
+
+    seq = parse_dispatch_sequence(_DISPATCH_LOG)
+    orient_env = next(e for e in seq if e["command"] == "SetOrientation")
+    cmd = ipc.decode_command(orient_env)
+    assert isinstance(cmd, SetOrientation)
+    assert cmd.key == "87ad:70db"
+    assert cmd.degrees == 180

{trcc_linux-9.8.0 → trcc_linux-9.8.2}/tests/test_geometry.py

@@ -46,22 +46,28 @@ CASES = [
     # 90/270 landscape-only → LANDSCAPE canvas + whole-composite spin (fallback).
     ("s565@90L",   _SMALL_RGB565, 90,  False, OrientationPlan((320, 240), False, 90)),
     ("s565@270L",  _SMALL_RGB565, 270, False, OrientationPlan((320, 240), False, 270)),
-    # 90/270 portrait content → PORTRAIT canvas, NO spin (the fix's target).
+    # Portrait content → PORTRAIT canvas.  90 bakes orientation into the pixels
+    # (no spin); 270 is 90 + a dimension-preserving 180° flip so the whole
+    # composite stays true to the physical rotation instead of frozen at 90.
     ("s565@90P",   _SMALL_RGB565, 90,  True,  OrientationPlan((240, 320), True, 0)),
-    ("s565@270P",  _SMALL_RGB565, 270, True,  OrientationPlan((240, 320), True, 0)),
+    ("s565@270P",  _SMALL_RGB565, 270, True,  OrientationPlan((240, 320), True, 180)),
 
     # Small rotate JPEG (Mjolnir) behaves identically — rotate, not widescreen.
     ("sjpg@90L",   _SMALL_JPEG, 90,  False, OrientationPlan((320, 240), False, 90)),
     ("sjpg@90P",   _SMALL_JPEG, 90,  True,  OrientationPlan((240, 320), True, 0)),
+    ("sjpg@270P",  _SMALL_JPEG, 270, True,  OrientationPlan((240, 320), True, 180)),
 
-    # Widescreen JPEG (#169/#203) — NEVER gets post_rotate; at 90/270 always
-    # composes portrait (rides the second rotate_panel branch), regardless of
-    # content flag.  0/180 = oriented landscape.
+    # Widescreen JPEG (#169/#203) — always composes portrait at 90/270 (rides the
+    # second rotate_panel branch), regardless of content flag.  90 bakes the
+    # orientation into the pixels (no spin); 270 = 90 + a dimension-preserving
+    # 180° flip (the C# shows 854×480 rotates 90 and 270 a 180° apart — no longer
+    # frozen at 90).  0/180 = oriented landscape.
     ("wide@0",     _WIDE_JPEG, 0,   False, OrientationPlan((854, 480), False, 0)),
     ("wide@180",   _WIDE_JPEG, 180, False, OrientationPlan((854, 480), False, 0)),
     ("wide@90L",   _WIDE_JPEG, 90,  False, OrientationPlan((480, 854), True, 0)),
     ("wide@90P",   _WIDE_JPEG, 90,  True,  OrientationPlan((480, 854), True, 0)),
-    ("wide@270L",  _WIDE_JPEG, 270, False, OrientationPlan((480, 854), True, 0)),
+    ("wide@270L",  _WIDE_JPEG, 270, False, OrientationPlan((480, 854), True, 180)),
+    ("wide@270P",  _WIDE_JPEG, 270, True,  OrientationPlan((480, 854), True, 180)),
 ]
 
 
@@ -92,21 +98,30 @@ def test_plan_invariants_over_every_profile(
     assert plan.canvas in {(w, h), (h, w)}
     assert plan.canvas[0] * plan.canvas[1] == w * h
 
-    # post_rotate is only ever the raw orientation (fallback spin) or 0.
-    assert plan.post_rotate in {0, orientation}
+    # post_rotate is 0, the raw orientation (landscape-fallback spin), or 180
+    # (portrait-composed content at 270 — the dimension-preserving flip, which
+    # now includes widescreen: the C# shows 854×480 rotates 90 and 270 by a 180°
+    # difference, so widescreen is no longer frozen).
+    assert plan.post_rotate in {0, orientation, 180}
 
-    # Widescreen panels NEVER take the whole-composite spin — #169/#203 protection.
-    if profile.widescreen:
-        assert plan.post_rotate == 0
-
-    # A non-zero post_rotate implies a non-widescreen rotate panel at 90/270
-    # with landscape content composed on the landscape canvas.
+    # Any non-zero spin is a rotate panel at 90/270.
     if plan.post_rotate:
-        assert profile.rotate and w != h and not profile.widescreen
+        assert profile.rotate and w != h
         assert orientation in (90, 270)
-        assert not content_portrait
-        assert plan.canvas == (w, h)
-        assert plan.is_portrait_content is False
+        if plan.post_rotate == 180:
+            # The 270 flip on portrait-composed content — non-widescreen portrait
+            # content, OR any widescreen panel (which always composes portrait).
+            assert orientation == 270
+            assert plan.canvas == (h, w)
+            assert plan.is_portrait_content is True
+        else:
+            # Landscape-only fallback: composed on the landscape canvas, spun
+            # whole.  Non-widescreen only — widescreen always composes portrait.
+            assert plan.post_rotate == orientation
+            assert not content_portrait
+            assert not profile.widescreen
+            assert plan.canvas == (w, h)
+            assert plan.is_portrait_content is False
 
 
 def test_landscape_angles_never_spin() -> None: