trcc-linux 1.2.8__tar.gz → 1.2.9__tar.gz

{trcc_linux-1.2.8 → trcc_linux-1.2.9}/.gitignore

@@ -117,5 +117,8 @@ packages/
 # Root-level data dir
 /data/
 
+# Call graph images
+trcc_callgraph*
+
 # Large binary docs
 doc/*.pdf

{trcc_linux-1.2.8 → trcc_linux-1.2.9}/PKG-INFO

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

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

{trcc_linux-1.2.8 → trcc_linux-1.2.9}/src/trcc/__init__.py

@@ -27,6 +27,7 @@ __version__ = "1.0.0"
 __author__ = "TRCC Linux Contributors"
 
 # Core exports
+from trcc.dc_config import DcConfig
 from trcc.dc_parser import dc_to_overlay_config, parse_dc_file
 from trcc.device_detector import detect_devices, get_device_path
 
@@ -52,6 +53,7 @@ __all__ = [
     "get_all_metrics",
     "format_metric",
     # Theme parsing
+    "DcConfig",
     "parse_dc_file",
     "dc_to_overlay_config",
     # Animation

{trcc_linux-1.2.8 → trcc_linux-1.2.9}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "1.2.8"
+__version__ = "1.2.9"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -31,3 +31,5 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #         _has_actual_themes to require PNGs (ignore leftover .dc files)
 # 1.2.8 - KISS refactor: consolidate 5 duplicate settings handlers into
 #         _update_selected(), remove dead code (set_format_options, LED stubs)
+# 1.2.9 - Fix HID handshake protocol (retry, timeout, endpoint auto-detect,
+#         relaxed validation), OOP refactor (DcConfig, conf.py, dataclasses)

{trcc_linux-1.2.8 → trcc_linux-1.2.9}/src/trcc/cli.py

@@ -33,18 +33,8 @@ def _ensure_extracted(driver):
     try:
         if driver.implementation:
             w, h = driver.implementation.resolution
-            from trcc.paths import (
-                ensure_themes_extracted,
-                ensure_web_extracted,
-                ensure_web_masks_extracted,
-                is_resolution_installed,
-                mark_resolution_installed,
-            )
-            if not is_resolution_installed(w, h):
-                ensure_themes_extracted(w, h)
-                ensure_web_extracted(w, h)
-                ensure_web_masks_extracted(w, h)
-                mark_resolution_installed(w, h)
+            from trcc.paths import ensure_all_data
+            ensure_all_data(w, h)
     except Exception:
         pass  # Non-fatal — themes are optional for CLI commands
 
@@ -292,7 +282,7 @@ def _probe_device(dev):
     elif dev.implementation in ('hid_type2', 'hid_type3'):
         try:
             from trcc.device_factory import DeviceProtocolFactory
-            from trcc.hid_device import DeviceInfo as HidDeviceInfo
+            from trcc.hid_device import HidHandshakeInfo
             device_info = {
                 'vid': dev.vid, 'pid': dev.pid,
                 'protocol': dev.protocol, 'device_type': dev.device_type,
@@ -301,7 +291,7 @@ def _probe_device(dev):
             }
             protocol = DeviceProtocolFactory.get_protocol(device_info)
             raw_info = protocol.handshake()
-            if isinstance(raw_info, HidDeviceInfo):
+            if isinstance(raw_info, HidHandshakeInfo):
                 result['pm'] = raw_info.mode_byte_1
                 result['resolution'] = raw_info.resolution
                 if raw_info.serial:
@@ -520,9 +510,9 @@ def resume():
     try:
         import time
 
+        from trcc.conf import device_config_key, get_device_config
         from trcc.device_detector import detect_devices
         from trcc.lcd_driver import LCDDriver
-        from trcc.paths import device_config_key, get_device_config
 
         # Wait for USB devices to appear (they may not be ready at boot)
         devices = []
@@ -648,19 +638,127 @@ def show_info():
         return 1
 
 
+def _hex_dump(data: bytes, max_bytes: int = 64) -> None:
+    """Print a hex dump of data (for hid-debug diagnostics)."""
+    for row in range(0, min(len(data), max_bytes), 16):
+        hex_str = ' '.join(f'{b:02x}' for b in data[row:row + 16])
+        ascii_str = ''.join(
+            chr(b) if 32 <= b < 127 else '.'
+            for b in data[row:row + 16]
+        )
+        print(f"  {row:04x}: {hex_str:<48s} {ascii_str}")
+
+
+def _hid_debug_lcd(dev) -> None:
+    """HID handshake diagnostic for LCD devices (Type 2/3)."""
+    from trcc.device_factory import HidProtocol
+    from trcc.hid_device import (
+        FBL_TO_RESOLUTION,
+        PM_TO_BUTTON_IMAGE,
+        fbl_to_resolution,
+        pm_to_fbl,
+    )
+
+    protocol = HidProtocol(
+        vid=dev.vid, pid=dev.pid,
+        device_type=dev.device_type,
+    )
+    info = protocol.handshake()
+
+    if info is None:
+        error = protocol.last_error
+        if error:
+            print(f"  Handshake FAILED: {error}")
+        else:
+            print("  Handshake returned None (no response from device)")
+        protocol.close()
+        return
+
+    pm = info.mode_byte_1
+    sub = info.mode_byte_2
+    fbl = info.fbl if info.fbl is not None else pm_to_fbl(pm, sub)
+    resolution = info.resolution or fbl_to_resolution(fbl, pm)
+
+    print("  Handshake OK!")
+    print(f"  PM byte  = {pm} (0x{pm:02x})")
+    print(f"  SUB byte = {sub} (0x{sub:02x})")
+    print(f"  FBL      = {fbl} (0x{fbl:02x})")
+    print(f"  Serial   = {info.serial}")
+    print(f"  Resolution = {resolution[0]}x{resolution[1]}")
+
+    # Button image from PM
+    button = PM_TO_BUTTON_IMAGE.get(pm)
+    if button:
+        print(f"  Button image = {button}")
+    else:
+        print(f"  Button image = unknown PM={pm} (defaulting to CZTV)")
+
+    # Known FBL?
+    if fbl in FBL_TO_RESOLUTION:
+        print(f"  FBL {fbl} = known resolution")
+    else:
+        print(f"  FBL {fbl} = UNKNOWN (not in mapping table)")
+
+    # Raw response hex dump
+    if info.raw_response:
+        print("\n  Raw handshake response (first 64 bytes):")
+        _hex_dump(info.raw_response)
+
+    protocol.close()
+
+
+def _hid_debug_led(dev) -> None:
+    """HID handshake diagnostic for LED devices (Type 1)."""
+    from trcc.device_factory import LedProtocol
+    from trcc.led_device import PM_TO_STYLE
+
+    protocol = LedProtocol(vid=dev.vid, pid=dev.pid)
+    info = protocol.handshake()
+
+    if info is None:
+        error = protocol.last_error
+        if error:
+            print(f"  Handshake FAILED: {error}")
+        else:
+            print("  Handshake returned None (no response from device)")
+        protocol.close()
+        return
+
+    print("  Handshake OK!")
+    print(f"  PM byte    = {info.pm} (0x{info.pm:02x})")
+    print(f"  Sub-type   = {info.sub_type} (0x{info.sub_type:02x})")
+    print(f"  Model      = {info.model_name}")
+
+    style = info.style
+    if style:
+        print(f"  Style ID   = {style.style_id}")
+        print(f"  LED count  = {style.led_count}")
+        print(f"  Segments   = {style.segment_count}")
+        print(f"  Zones      = {style.zone_count}")
+
+    if info.pm in PM_TO_STYLE:
+        print(f"\n  Status: KNOWN device (PM {info.pm} in tables)")
+    else:
+        print(f"\n  Status: UNKNOWN PM byte ({info.pm})")
+        print("  This device falls back to AX120 defaults.")
+        print(f"  Please report PM {info.pm} in your GitHub issue.")
+
+    # Raw response hex dump
+    if info.raw_response:
+        print("\n  Raw handshake response (first 64 bytes):")
+        _hex_dump(info.raw_response)
+
+    protocol.close()
+
+
 def hid_debug():
     """HID handshake diagnostic — prints hex dump and resolved device info.
 
     Users can share this output in bug reports to help debug HID device issues.
+    Routes LED devices (Type 1) through LedProtocol, LCD devices through HidProtocol.
     """
     try:
         from trcc.device_detector import detect_devices
-        from trcc.hid_device import (
-            FBL_TO_RESOLUTION,
-            PM_TO_BUTTON_IMAGE,
-            fbl_to_resolution,
-            pm_to_fbl,
-        )
 
         print("HID Debug — Handshake Diagnostic")
         print("=" * 60)
@@ -675,70 +773,27 @@ def hid_debug():
             return 0
 
         for dev in hid_devices:
+            is_led = dev.implementation == 'hid_led'
+            dev_kind = "LED" if is_led else f"LCD (Type {dev.device_type})"
+
             print(f"\nDevice: {dev.vendor_name} {dev.product_name}")
             print(f"  VID:PID = {dev.vid:04x}:{dev.pid:04x}")
-            print(f"  Type = {dev.device_type}")
+            print(f"  Kind = {dev_kind}")
             print(f"  Implementation = {dev.implementation}")
 
-            # Attempt handshake
             print("\n  Attempting handshake...")
             try:
-                from trcc.device_factory import HidProtocol
-                protocol = HidProtocol(
-                    vid=dev.vid, pid=dev.pid,
-                    device_type=dev.device_type,
-                )
-                info = protocol.handshake()
-                if info is None:
-                    print("  Handshake returned None (protocol error)")
-                    protocol.close()
-                    continue
-
-                pm = info.mode_byte_1
-                sub = info.mode_byte_2
-                fbl = info.fbl if info.fbl is not None else pm_to_fbl(pm, sub)
-                resolution = info.resolution or fbl_to_resolution(fbl, pm)
-
-                print("  Handshake OK!")
-                print(f"  PM byte  = {pm} (0x{pm:02x})")
-                print(f"  SUB byte = {sub} (0x{sub:02x})")
-                print(f"  FBL      = {fbl} (0x{fbl:02x})")
-                print(f"  Serial   = {info.serial}")
-                print(f"  Resolution = {resolution[0]}x{resolution[1]}")
-
-                # Button image from PM
-                button = PM_TO_BUTTON_IMAGE.get(pm)
-                if button:
-                    print(f"  Button image = {button}")
-                else:
-                    print(f"  Button image = unknown PM={pm} (defaulting to CZTV)")
-
-                # Known FBL?
-                if fbl in FBL_TO_RESOLUTION:
-                    print(f"  FBL {fbl} = known resolution")
+                if is_led:
+                    _hid_debug_led(dev)
                 else:
-                    print(f"  FBL {fbl} = UNKNOWN (not in mapping table)")
-
-                # Raw response hex dump
-                if info.raw_response:
-                    print("\n  Raw handshake response (first 64 bytes):")
-                    raw = info.raw_response
-                    for row in range(0, min(len(raw), 64), 16):
-                        hex_str = ' '.join(f'{b:02x}' for b in raw[row:row+16])
-                        ascii_str = ''.join(
-                            chr(b) if 32 <= b < 127 else '.'
-                            for b in raw[row:row+16]
-                        )
-                        print(f"  {row:04x}: {hex_str:<48s} {ascii_str}")
-
-                protocol.close()
-
+                    _hid_debug_lcd(dev)
             except ImportError as e:
                 print(f"  Missing dependency: {e}")
                 print("  Install: pip install pyusb  (or pip install hidapi)")
             except Exception as e:
                 print(f"  Handshake FAILED: {e}")
-                print("  (This error is what causes 'Send failed' in the GUI)")
+                import traceback
+                traceback.print_exc()
 
         print(f"\n{'=' * 60}")
         print("Copy the output above and paste it in your GitHub issue.")
@@ -1024,7 +1079,7 @@ def uninstall():
     import shutil
     from pathlib import Path
 
-    from trcc.paths import clear_installed_resolutions
+    from trcc.conf import clear_installed_resolutions
 
     # Clear resolution markers before wiping config dir
     clear_installed_resolutions()
@@ -1154,7 +1209,7 @@ def download_themes(pack=None, show_list=False, force=False, show_info=False):
             return 0
 
         if force:
-            from trcc.paths import clear_installed_resolutions
+            from trcc.conf import clear_installed_resolutions
             clear_installed_resolutions()
 
         return download_pack(pack, force=force)

trcc_linux-1.2.9/src/trcc/conf.py

@@ -0,0 +1,214 @@
+"""Application settings and config persistence for TRCC.
+
+Single source of truth for resolution, paths, preferences, and device settings.
+Config is stored at ~/.config/trcc/config.json (XDG-compliant).
+
+Usage:
+    from trcc.conf import settings
+
+    settings.width          # LCD width
+    settings.height         # LCD height
+    settings.resolution     # (width, height) tuple
+    settings.theme_dir      # ThemeDir for current resolution
+    settings.web_dir        # Cloud theme preview dir
+    settings.masks_dir      # Cloud mask overlay dir
+    settings.temp_unit      # 0=Celsius, 1=Fahrenheit
+
+    # Low-level config access
+    from trcc.conf import load_config, save_config, device_config_key
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+from .paths import (
+    USER_DATA_DIR,
+    ThemeDir,
+    get_web_dir,
+    get_web_masks_dir,
+)
+
+log = logging.getLogger(__name__)
+
+# =========================================================================
+# Config file location (XDG-compliant)
+# =========================================================================
+
+_XDG_CONFIG = os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config'))
+CONFIG_DIR = os.path.join(_XDG_CONFIG, 'trcc')
+CONFIG_PATH = os.path.join(CONFIG_DIR, 'config.json')
+
+# USBLCD (SCSI/RGB565) supported resolutions
+SUPPORTED_RESOLUTIONS = [
+    (240, 240),
+    (320, 320),
+    (480, 480),
+    (640, 480),
+]
+
+
+# =========================================================================
+# Low-level config persistence
+# =========================================================================
+
+def load_config() -> dict:
+    """Load user config from disk. Returns empty dict on missing/corrupt file."""
+    try:
+        with open(CONFIG_PATH, 'r') as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_config(config: dict):
+    """Save user config to disk."""
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with open(CONFIG_PATH, 'w') as f:
+        json.dump(config, f, indent=2)
+
+
+# =========================================================================
+# Resolution persistence
+# =========================================================================
+
+def get_saved_resolution() -> tuple[int, int]:
+    """Get saved LCD resolution, defaulting to (320, 320)."""
+    config = load_config()
+    res = config.get('resolution', [320, 320])
+    if isinstance(res, list) and len(res) == 2:
+        return (int(res[0]), int(res[1]))
+    return (320, 320)
+
+
+def save_resolution(width: int, height: int):
+    """Persist LCD resolution to config."""
+    config = load_config()
+    config['resolution'] = [width, height]
+    save_config(config)
+
+
+# =========================================================================
+# Temperature unit persistence
+# =========================================================================
+
+def get_saved_temp_unit() -> int:
+    """Get saved temperature unit. 0=Celsius, 1=Fahrenheit. Defaults to 0."""
+    return load_config().get('temp_unit', 0)
+
+
+def save_temp_unit(unit: int):
+    """Persist temperature unit to config. 0=Celsius, 1=Fahrenheit."""
+    config = load_config()
+    config['temp_unit'] = unit
+    save_config(config)
+
+
+# =========================================================================
+# Per-device configuration
+# =========================================================================
+
+def device_config_key(index: int, vid: int, pid: int) -> str:
+    """Build per-device config key, e.g. '0:87cd_70db'."""
+    return f"{index}:{vid:04x}_{pid:04x}"
+
+
+def get_device_config(key: str) -> dict:
+    """Get per-device config dict. Returns empty dict if not found."""
+    return load_config().get('devices', {}).get(key, {})
+
+
+def save_device_setting(key: str, setting: str, value):
+    """Save a single setting for a device."""
+    config = load_config()
+    devices = config.setdefault('devices', {})
+    dev_cfg = devices.setdefault(key, {})
+    dev_cfg[setting] = value
+    save_config(config)
+
+
+# =========================================================================
+# Resolution installation markers
+# =========================================================================
+
+def clear_installed_resolutions():
+    """Remove all resolution-installed markers (used by uninstall)."""
+    config = load_config()
+    config.pop("installed_resolutions", None)
+    save_config(config)
+
+
+# =========================================================================
+# Settings singleton
+# =========================================================================
+
+class Settings:
+    """Application-wide settings singleton.
+
+    Components read from here instead of calling path helpers directly.
+    ``set_resolution()`` updates derived paths and persists to config.
+    """
+
+    def __init__(self) -> None:
+        # Resolution (from saved config)
+        w, h = get_saved_resolution()
+        self._width = w
+        self._height = h
+
+        # Derived paths (resolved for current resolution)
+        self.theme_dir: Optional[ThemeDir] = None
+        self.web_dir: Optional[Path] = None
+        self.masks_dir: Optional[Path] = None
+
+        # User preferences
+        self.temp_unit: int = get_saved_temp_unit()
+
+        # Static paths
+        self.user_data_dir = Path(USER_DATA_DIR)
+
+        # Resolve for initial resolution
+        if w and h:
+            self._resolve_paths()
+
+    @property
+    def width(self) -> int:
+        return self._width
+
+    @property
+    def height(self) -> int:
+        return self._height
+
+    @property
+    def resolution(self) -> tuple[int, int]:
+        return (self._width, self._height)
+
+    def set_resolution(self, width: int, height: int, persist: bool = True) -> None:
+        """Update resolution and re-resolve all derived paths."""
+        if (width, height) == (self._width, self._height):
+            return
+        log.info("Settings: resolution %dx%d → %dx%d",
+                 self._width, self._height, width, height)
+        self._width = width
+        self._height = height
+        self._resolve_paths()
+        if persist:
+            save_resolution(width, height)
+
+    def set_temp_unit(self, unit: int) -> None:
+        """Set temperature unit (0=Celsius, 1=Fahrenheit) and persist."""
+        self.temp_unit = unit
+        save_temp_unit(unit)
+
+    def _resolve_paths(self) -> None:
+        """Resolve theme/web/mask directories for current resolution."""
+        w, h = self._width, self._height
+        self.theme_dir = ThemeDir.for_resolution(w, h)
+        self.web_dir = Path(get_web_dir(w, h))
+        self.masks_dir = Path(get_web_masks_dir(w, h))
+
+
+# Module-level singleton — import and use directly
+settings = Settings()