trcc-linux 4.2.5__tar.gz → 4.2.6__tar.gz

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/PKG-INFO

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

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

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "4.2.5"
+__version__ = "4.2.6"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -159,3 +159,8 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #          resolve_style_id() name lookup matched style 7 (116 LEDs) instead
 #          of style 5 (93 LEDs). Now stores style_id from probe directly on
 #          DeviceInfo — no reverse name lookup. 2308 tests.
+# 4.2.6  - Refactor: inline trivial callbacks, DeviceInfo.from_dict() factory,
+#          LEDHandler/ScreencastHandler mediators, data-driven dispatch
+#          (pm_to_fbl, fbl_to_resolution), extract _render_and_send/_scan_lsscsi
+#          helpers, remove duplicate overlay.configure(), dead code cleanup.
+#          SCSI handshake fix (was returning None since v4.2.4). 2311 tests.

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/adapters/device/detector.py

@@ -232,33 +232,23 @@ class DeviceDetector:
             except (IOError, OSError):
                 continue
 
-        # Method 2: Use lsscsi -g
-        output = DeviceDetector.run_command(['lsscsi', '-g'])
-        if output:
-            for line in output.split('\n'):
-                if 'USBLCD' in line:
-                    match = re.search(r'/dev/sg\d+', line)
-                    if match:
-                        return match.group(0)
-
-        # Method 3: Use lsscsi -t
-        output = DeviceDetector.run_command(['lsscsi', '-t'])
-        if output:
-            for line in output.split('\n'):
-                if 'USBLCD' in line or 'usb' in line.lower():
-                    match = re.search(r'/dev/sg\d+', line)
-                    if match:
-                        return match.group(0)
-
-        # Method 4: Plain lsscsi
-        output = DeviceDetector.run_command(['lsscsi'])
-        if output:
-            for line in output.split('\n'):
-                if 'USBLCD' in line:
-                    match = re.search(r'/dev/sg\d+', line)
-                    if match:
-                        return match.group(0)
+        # Fallback: try lsscsi variants
+        _scan = DeviceDetector._scan_lsscsi
+        return (_scan(['lsscsi', '-g'], ['USBLCD'])
+                or _scan(['lsscsi', '-t'], ['USBLCD', 'usb'])
+                or _scan(['lsscsi'], ['USBLCD']))
 
+    @staticmethod
+    def _scan_lsscsi(cmd: list[str], patterns: list[str]) -> Optional[str]:
+        """Scan lsscsi output for /dev/sgN matching any pattern."""
+        output = DeviceDetector.run_command(cmd)
+        if not output:
+            return None
+        for line in output.split('\n'):
+            if any(p in line or p.lower() in line.lower() for p in patterns):
+                match = re.search(r'/dev/sg\d+', line)
+                if match:
+                    return match.group(0)
         return None
 
     @staticmethod

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/adapters/device/factory.py

@@ -103,8 +103,8 @@ class DeviceProtocol(ABC):
     def handshake(self) -> Optional[HandshakeResult]:
         """Perform device handshake and return capabilities.
 
-        Returns HandshakeResult (or subclass) with resolution, model_id, etc.
-        Returns None for protocols that don't handshake (e.g. SCSI).
+        Returns HandshakeResult with resolution, model_id, etc.
+        Returns None if handshake fails or device is unresponsive.
         """
 
     @property
@@ -143,8 +143,10 @@ class ScsiProtocol(DeviceProtocol):
         self._path = device_path
 
     def handshake(self) -> Optional[HandshakeResult]:
-        """SCSI devices don't handshake — resolution is known at detection time."""
-        return None
+        """Poll SCSI device to discover FBL → resolution."""
+        from .scsi import ScsiDevice
+        dev = ScsiDevice(self._path)
+        return dev.handshake()
 
     def send_image(self, image_data: bytes, width: int, height: int) -> bool:
         try:

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/adapters/device/led_segment.py

@@ -27,7 +27,10 @@ from __future__ import annotations
 import logging
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple
+
+if TYPE_CHECKING:
+    from ...core.models import HardwareMetrics
 
 log = logging.getLogger(__name__)
 
@@ -103,7 +106,7 @@ class SegmentDisplay(ABC):
     @abstractmethod
     def compute_mask(
         self,
-        metrics: Dict[str, Any],
+        metrics: HardwareMetrics,
         phase: int = 0,
         temp_unit: str = "C",
         **kw: Any,
@@ -297,7 +300,7 @@ class AX120Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 4
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 30
         for idx in self.ALWAYS_ON:
@@ -312,7 +315,7 @@ class AX120Display(SegmentDisplay):
         else:
             mask[self.PERCENT] = True
 
-        value = int(metrics.get(metric_key, 0))
+        value = int(getattr(metrics, metric_key, 0))
         if is_temp:
             value = self._to_display_temp(value, temp_unit)
         self._encode_3digit(value, self.DIGITS, mask)
@@ -369,7 +372,7 @@ class PA120Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 1
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 84
 
@@ -388,20 +391,20 @@ class PA120Display(SegmentDisplay):
 
         # All 4 metrics simultaneously
         self._encode_3digit(
-            self._to_display_temp(metrics.get('cpu_temp', 0), temp_unit),
+            self._to_display_temp(getattr(metrics, 'cpu_temp', 0), temp_unit),
             self.CPU_TEMP_DIGITS, mask,
         )
         self._encode_2digit_partial(
-            int(metrics.get('cpu_percent', 0)),
+            int(getattr(metrics, 'cpu_percent', 0)),
             self.CPU_USE_DIGITS, self.CPU_USE_PARTIAL, mask,
         )
         self._encode_3digit(
-            self._to_display_temp(metrics.get('gpu_temp', 0), temp_unit),
+            self._to_display_temp(getattr(metrics, 'gpu_temp', 0), temp_unit),
             self.GPU_TEMP_DIGITS, mask,
         )
 
         # GPU usage: tens (full) + ones (B,C only) + hundreds (partial)
-        gu = max(0, min(199, int(metrics.get('gpu_usage', 0))))
+        gu = max(0, min(199, int(getattr(metrics, 'gpu_usage', 0))))
         if gu >= 100:
             mask[self.GPU_USE_PARTIAL[0]] = True
             mask[self.GPU_USE_PARTIAL[1]] = True
@@ -457,8 +460,8 @@ class AK120Display(SegmentDisplay):
     USE_PARTIAL = (62, 63)
 
     PHASES = (
-        ('cpu_temp', 'cpu_percent', 'cpu_watt', CPU1),
-        ('gpu_temp', 'gpu_usage', 'gpu_watt', GPU1),
+        ('cpu_temp', 'cpu_percent', 'cpu_power', CPU1),
+        ('gpu_temp', 'gpu_usage', 'gpu_power', GPU1),
     )
 
     # ── Interface ──────────────────────────────────────────────────
@@ -471,7 +474,7 @@ class AK120Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 2
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 69
 
@@ -482,10 +485,10 @@ class AK120Display(SegmentDisplay):
         mask[source_idx] = True
         mask[self.SSD if temp_unit == "C" else self.HSD] = True
 
-        self._encode_3digit(int(metrics.get(watt_key, 0)), self.WATT_DIGITS, mask)
-        self._encode_3digit(self._to_display_temp(metrics.get(temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
+        self._encode_3digit(int(getattr(metrics, watt_key, 0)), self.WATT_DIGITS, mask)
+        self._encode_3digit(self._to_display_temp(getattr(metrics, temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
         self._encode_2digit_partial(
-            int(metrics.get(use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
+            int(getattr(metrics, use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
         )
         return mask
 
@@ -529,7 +532,7 @@ class LC1Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 3
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 38
 
@@ -540,7 +543,7 @@ class LC1Display(SegmentDisplay):
 
         mask[indicator_idx] = True
 
-        value = int(metrics.get(metric_key, 0))
+        value = int(getattr(metrics, metric_key, 0))
         if actual_mode == -1:
             value = self._to_display_temp(value, "F")
         self._encode_3digit(value, self.DIGITS, mask)
@@ -590,8 +593,8 @@ class LF8Display(SegmentDisplay):
     USE_PARTIAL = (91, 92)
 
     PHASES = (
-        ('cpu_temp', 'cpu_watt', 'cpu_mhz', 'cpu_percent', CPU1),
-        ('gpu_temp', 'gpu_watt', 'gpu_mhz', 'gpu_usage', GPU1),
+        ('cpu_temp', 'cpu_power', 'cpu_freq', 'cpu_percent', CPU1),
+        ('gpu_temp', 'gpu_power', 'gpu_clock', 'gpu_usage', GPU1),
     )
 
     # ── Interface ──────────────────────────────────────────────────
@@ -604,7 +607,7 @@ class LF8Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 2
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * self.mask_size
 
@@ -616,11 +619,11 @@ class LF8Display(SegmentDisplay):
         mask[src] = True
         mask[self.SSD if temp_unit == "C" else self.HSD] = True
 
-        self._encode_3digit(self._to_display_temp(metrics.get(temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
-        self._encode_3digit(int(metrics.get(watt_key, 0)), self.WATT_DIGITS, mask)
-        self._encode_3digit(int(metrics.get(mhz_key, 0)), self.MHZ_DIGITS, mask)
+        self._encode_3digit(self._to_display_temp(getattr(metrics, temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
+        self._encode_3digit(int(getattr(metrics, watt_key, 0)), self.WATT_DIGITS, mask)
+        self._encode_3digit(int(getattr(metrics, mhz_key, 0)), self.MHZ_DIGITS, mask)
         self._encode_2digit_partial(
-            int(metrics.get(use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
+            int(getattr(metrics, use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
         )
         return mask
 
@@ -639,7 +642,7 @@ class LF12Display(LF8Display):
     def mask_size(self) -> int:
         return 124
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         # Compute digit mask using parent's logic on a 124-element mask
         mask = [False] * 124
@@ -652,11 +655,11 @@ class LF12Display(LF8Display):
         mask[src] = True
         mask[self.SSD if temp_unit == "C" else self.HSD] = True
 
-        self._encode_3digit(self._to_display_temp(metrics.get(temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
-        self._encode_3digit(int(metrics.get(watt_key, 0)), self.WATT_DIGITS, mask)
-        self._encode_3digit(int(metrics.get(mhz_key, 0)), self.MHZ_DIGITS, mask)
+        self._encode_3digit(self._to_display_temp(getattr(metrics, temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
+        self._encode_3digit(int(getattr(metrics, watt_key, 0)), self.WATT_DIGITS, mask)
+        self._encode_3digit(int(getattr(metrics, mhz_key, 0)), self.MHZ_DIGITS, mask)
         self._encode_2digit_partial(
-            int(metrics.get(use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
+            int(getattr(metrics, use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
         )
 
         # Decoration LEDs — always on
@@ -705,7 +708,7 @@ class LF10Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 1
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 116
 
@@ -721,12 +724,12 @@ class LF10Display(SegmentDisplay):
 
         # CPU temp (digits 1-3)
         self._encode_3digit_13seg(
-            self._to_display_temp(metrics.get('cpu_temp', 0), temp_unit),
+            self._to_display_temp(getattr(metrics, 'cpu_temp', 0), temp_unit),
             self.DIGIT_LEDS_13[0:3], mask,
         )
         # GPU temp (digits 4-6)
         self._encode_3digit_13seg(
-            self._to_display_temp(metrics.get('gpu_temp', 0), temp_unit),
+            self._to_display_temp(getattr(metrics, 'gpu_temp', 0), temp_unit),
             self.DIGIT_LEDS_13[3:6], mask,
         )
 
@@ -773,7 +776,7 @@ class CZ1Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 4
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 18
 
@@ -781,7 +784,7 @@ class CZ1Display(SegmentDisplay):
         for idx in indicator_on:
             mask[idx] = True
 
-        value = int(metrics.get(metric_key, 0))
+        value = int(getattr(metrics, metric_key, 0))
         if 'temp' in metric_key:
             value = self._to_display_temp(value, temp_unit)
         self._encode_2digit(value, self.DIGITS, mask)
@@ -821,7 +824,7 @@ class LC2Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 1
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 61
 
@@ -899,7 +902,7 @@ class LF11Display(SegmentDisplay):
     def phase_count(self) -> int:
         return 4
 
-    def compute_mask(self, metrics: Dict[str, Any], phase: int = 0,
+    def compute_mask(self, metrics: HardwareMetrics, phase: int = 0,
                      temp_unit: str = "C", **kw: Any) -> List[bool]:
         mask = [False] * 38
 
@@ -910,7 +913,7 @@ class LF11Display(SegmentDisplay):
         else:
             mask[self.BFB] = True
 
-        value = int(metrics.get(metric_key, 0))
+        value = int(getattr(metrics, metric_key, 0))
         if is_temp:
             value = self._to_display_temp(value, temp_unit)
         self._encode_3digit(value, self.DIGITS[0:3], mask)
@@ -949,7 +952,7 @@ DISPLAYS: Dict[int, SegmentDisplay] = {
 
 def compute_mask(
     style_id: int,
-    metrics: Dict[str, Any],
+    metrics: HardwareMetrics,
     phase: int = 0,
     temp_unit: str = "C",
     is_24h: bool = True,
@@ -959,7 +962,7 @@ def compute_mask(
 
     Args:
         style_id: LED device style (1-11).
-        metrics: Sensor readings dict (cpu_temp, cpu_percent, etc.).
+        metrics: HardwareMetrics DTO with sensor readings.
         phase: Current rotation phase (0-based).
         temp_unit: "C" or "F".
         is_24h: 24-hour clock mode (style 9 only).

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/adapters/device/scsi.py

@@ -18,7 +18,6 @@ import time
 from typing import Dict, List, Set
 
 from trcc.adapters.infra.data_repository import SysUtils
-from trcc.core.models import RESOLUTION_TO_PM as _RESOLUTION_TO_PM
 from trcc.core.models import HandshakeResult, fbl_to_resolution
 
 log = logging.getLogger(__name__)
@@ -218,27 +217,15 @@ def find_lcd_devices() -> List[Dict]:
             if not dev.scsi_device:
                 continue
 
-            # Resolution discovered via handshake (_init_device → poll → fbl_to_resolution)
-            resolution = (0, 0)
-
-            # SCSI poll byte[0] = resolution code = PM (matches USBLCD.exe).
-            # Use it to resolve variant-specific button image.
-            button_image = dev.button_image
-            scsi_pm = _RESOLUTION_TO_PM.get(resolution)
-            if scsi_pm is not None:
-                from .hid import get_button_image
-                resolved = get_button_image(scsi_pm, 0)
-                if resolved:
-                    button_image = resolved
-
+            # Resolution (0,0) until handshake polls FBL from device
             devices.append({
                 'name': f"{dev.vendor_name} {dev.product_name}",
                 'path': dev.scsi_device,
-                'resolution': resolution,
+                'resolution': (0, 0),
                 'vendor': dev.vendor_name,
                 'product': dev.product_name,
                 'model': dev.model,
-                'button_image': button_image,
+                'button_image': dev.button_image,
                 'vid': dev.vid,
                 'pid': dev.pid,
                 'protocol': 'scsi',

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/adapters/infra/dc_parser.py

@@ -18,6 +18,7 @@ from trcc.core.models import (
     DisplayElement,
     ElementConfig,
     FontConfig,
+    OverlayMode,
 )
 
 from .binary_reader import BinaryReader
@@ -479,32 +480,32 @@ class DcParser:
                 'mode_sub': elem.mode_sub,
             }
 
-            if elem.mode == 1:
+            if elem.mode == OverlayMode.TIME:
                 key = 'time' if time_count == 0 else f'time_{time_count}'
                 config_entry['metric'] = 'time'
                 config_entry['time_format'] = elem.mode_sub
                 overlay_config[key] = config_entry
                 time_count += 1
 
-            elif elem.mode == 2:
+            elif elem.mode == OverlayMode.WEEKDAY:
                 key = 'weekday' if weekday_count == 0 else f'weekday_{weekday_count}'
                 config_entry['metric'] = 'weekday'
                 overlay_config[key] = config_entry
                 weekday_count += 1
 
-            elif elem.mode == 3:
+            elif elem.mode == OverlayMode.DATE:
                 key = 'date' if date_count == 0 else f'date_{date_count}'
                 config_entry['metric'] = 'date'
                 config_entry['date_format'] = elem.mode_sub
                 overlay_config[key] = config_entry
                 date_count += 1
 
-            elif elem.mode == 4:
+            elif elem.mode == OverlayMode.CUSTOM:
                 key = f'custom_{len([k for k in overlay_config if k.startswith("custom")])}'
                 config_entry['text'] = elem.text
                 overlay_config[key] = config_entry
 
-            elif elem.mode == 0:
+            elif elem.mode == OverlayMode.HARDWARE:
                 hw_key = f'hw_{elem.main_count}_{elem.sub_count}'
                 config_entry['metric'] = DcParser.get_hardware_metric_name(elem.main_count, elem.sub_count)
                 config_entry['temp_unit'] = elem.mode_sub

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/adapters/infra/dc_writer.py

@@ -54,6 +54,7 @@ from trcc.core.models import (
     METRIC_TO_IDS,
     CarouselConfig,
     DisplayElement,
+    OverlayMode,
     ThemeConfig,
 )
 
@@ -238,18 +239,18 @@ class DcWriter:
             if 'metric' in cfg:
                 metric = cfg['metric']
                 if metric == 'time':
-                    elem.mode = 1
+                    elem.mode = OverlayMode.TIME
                     elem.mode_sub = cfg.get('time_format', cfg.get('mode_sub', 0))
                 elif metric == 'weekday':
-                    elem.mode = 2
+                    elem.mode = OverlayMode.WEEKDAY
                 elif metric == 'date':
-                    elem.mode = 3
+                    elem.mode = OverlayMode.DATE
                     elem.mode_sub = cfg.get('date_format', cfg.get('mode_sub', 0))
                 else:
-                    elem.mode = 0
+                    elem.mode = OverlayMode.HARDWARE
                     elem.main_count, elem.sub_count = METRIC_TO_IDS.get(metric, (0, 0))
             elif 'text' in cfg:
-                elem.mode = 4
+                elem.mode = OverlayMode.CUSTOM
                 elem.text = cfg['text']
 
             theme.elements.append(elem)

{trcc_linux-4.2.5 → trcc_linux-4.2.6}/src/trcc/api.py

@@ -163,8 +163,18 @@ async def send_image(device_id: int, image: UploadFile, rotation: int = 0,
     if brightness != 100:
         img = ImageService.apply_brightness(img, brightness)
 
-    # Resize to device resolution
-    w, h = dev.resolution if dev.resolution != (0, 0) else (320, 320)
+    # Discover resolution via handshake if not yet known
+    w, h = dev.resolution
+    if (w, h) == (0, 0):
+        from trcc.adapters.device.factory import DeviceProtocolFactory
+        protocol = DeviceProtocolFactory.get_protocol(dev)
+        result = protocol.handshake()
+        res = getattr(result, 'resolution', None) if result else None
+        if isinstance(res, tuple) and len(res) == 2 and res != (0, 0):
+            dev.resolution = res
+            w, h = res
+        else:
+            raise HTTPException(status_code=503, detail="Cannot discover device resolution")
     img = ImageService.resize(img, w, h)
 
     # Convert and send