trcc-linux 5.0.0__tar.gz → 5.0.2__tar.gz

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/PKG-INFO

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

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

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "5.0.0"
+__version__ = "5.0.2"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -184,3 +184,14 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #          (15 dmidecode fields), disk SMART health, SPI byte order fix.
 #          VideoDecoder fit-mode via ffprobe + proportional scaling.
 #          2315 tests.
+# 5.0.1  - Fix SELinux detection without root: semodule -l requires root
+#          and always reported [!!] in setup-gui for non-root users.
+#          Fall back to sesearch --allow which queries the loaded kernel
+#          policy without elevated privileges. 2316 tests.
+# 5.0.2  - Fix LED auto-detection: probe PM byte during device enumeration
+#          so all 0416:8001 devices get correct style (was falling back to
+#          AX120_DIGITAL for all). Config version tracking: auto-clear stale
+#          device state and LED probe cache on upgrade. LED timer optimization:
+#          30ms→150ms matching C# 10-tick counter, remove redundant 30ms USB
+#          cooldown sleep, skip USB sends when colors unchanged (static mode).
+#          Sensor poll interval 0.9s→2.0s. 2319 tests.

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/adapters/device/led.py

@@ -66,7 +66,6 @@ HID_REPORT_SIZE = 64
 LED_COLOR_SCALE = 0.4
 
 # Timing (UCDevice.cs: Thread.Sleep(30) after ThreadSendDeviceData1 completes)
-SEND_COOLDOWN_S = 0.030
 
 # Handshake init packet size (device1 uses 64-byte reports, not 512)
 LED_INIT_SIZE = 64
@@ -426,8 +425,6 @@ class LedHidSender:
                 remaining -= chunk_size
                 offset += chunk_size
 
-            # Cooldown after send (UCDevice.cs Thread.Sleep(30))
-            time.sleep(SEND_COOLDOWN_S)
             return True
 
         except Exception:

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/adapters/infra/doctor.py

@@ -561,10 +561,15 @@ class SelinuxResult:
 
 
 def check_selinux() -> SelinuxResult:
-    """Check if SELinux is enforcing and if trcc_usb policy module is loaded.
+    """Check if SELinux is enforcing and if USB device access is allowed.
 
     Returns ok=True when no action is needed: SELinux absent, permissive,
-    disabled, or enforcing with the trcc_usb module already loaded.
+    disabled, or enforcing with USB access already permitted (via trcc_usb
+    module or base policy).
+
+    Detection order:
+    1. ``semodule -l`` — checks module list (requires root)
+    2. ``sesearch`` — queries loaded kernel policy (works without root)
     """
     import subprocess
 
@@ -583,25 +588,61 @@ def check_selinux() -> SelinuxResult:
         return SelinuxResult(ok=True, message=f'SELinux {status} (no policy needed)')
 
     # SELinux is enforcing — check if trcc_usb module is loaded
+    # semodule -l requires root; try it first, fall back to sesearch
     try:
         r = subprocess.run(
             ['semodule', '-l'], capture_output=True, text=True, timeout=10,
         )
-        loaded = 'trcc_usb' in r.stdout
+        if r.returncode == 0 and 'trcc_usb' in r.stdout:
+            return SelinuxResult(
+                ok=True, message='SELinux enforcing — trcc_usb module loaded',
+                enforcing=True, module_loaded=True,
+            )
     except (FileNotFoundError, Exception):
-        loaded = False
+        pass
 
-    if loaded:
+    # semodule failed (non-root) or module not listed — check if the
+    # needed USB permissions exist in the loaded policy via sesearch
+    if _selinux_usb_access_allowed():
         return SelinuxResult(
-            ok=True, message='SELinux enforcing — trcc_usb module loaded',
+            ok=True,
+            message='SELinux enforcing — USB access permitted by policy',
             enforcing=True, module_loaded=True,
         )
+
     return SelinuxResult(
         ok=False, message='SELinux enforcing — USB policy not installed',
         enforcing=True, module_loaded=False,
     )
 
 
+def _selinux_usb_access_allowed() -> bool:
+    """Check if the loaded SELinux policy allows USB device access.
+
+    Uses ``sesearch`` to query the kernel policy — works without root.
+    Our trcc_usb module grants:
+        allow unconfined_t usb_device_t:chr_file { ioctl open read write }
+    The base policy may already cover this via attribute rules.
+    """
+    import subprocess
+
+    try:
+        r = subprocess.run(
+            ['sesearch', '--allow', '-s', 'unconfined_t',
+             '-t', 'usb_device_t', '-c', 'chr_file'],
+            capture_output=True, text=True, timeout=10,
+        )
+        if r.returncode != 0:
+            return False
+        # Check that all required permissions are present
+        for perm in ('ioctl', 'open', 'read', 'write'):
+            if perm not in r.stdout:
+                return False
+        return True
+    except (FileNotFoundError, Exception):
+        return False
+
+
 def check_desktop_entry() -> bool:
     """Check if .desktop file is installed."""
     from pathlib import Path

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/adapters/system/sensors.py

@@ -177,7 +177,7 @@ class SensorEnumerator:
                     self._cached_readings = readings
             except Exception:
                 log.debug("Sensor poll error", exc_info=True)
-            self._poll_stop.wait(0.9)  # ~900ms between reads
+            self._poll_stop.wait(2.0)  # ~2s between reads (C# polls ~1s)
 
     def _read_all_sync(self) -> dict[str, float]:
         """Read current values for ALL discovered sensors (blocking)."""

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/conf.py

@@ -32,6 +32,7 @@ import os
 from pathlib import Path
 from typing import Optional
 
+from .__version__ import __version__
 from .adapters.infra.data_repository import (
     USER_DATA_DIR,
     DataManager,
@@ -78,6 +79,41 @@ def save_config(config: dict):
         json.dump(config, f, indent=2)
 
 
+def _migrate_config() -> None:
+    """Clear stale device-derived state when app version changes.
+
+    Preserves user prefs (temp_unit, lang, format_prefs, hdd_enabled).
+    Clears device-derived keys (devices, resolution, selected_device,
+    installed_resolutions) and LED probe cache so new detection logic
+    takes effect after upgrade.
+    """
+    config = load_config()
+    saved_version = config.get('config_version')
+
+    if saved_version == __version__:
+        return
+
+    if saved_version is not None:
+        # Version mismatch — clear device-derived state
+        log.info("Config version %s → %s: clearing device state",
+                 saved_version, __version__)
+        for key in ('devices', 'resolution', 'selected_device',
+                    'installed_resolutions'):
+            config.pop(key, None)
+
+        # Delete LED probe cache (stale PM → style mappings)
+        probe_cache = os.path.join(CONFIG_DIR, 'led_probe_cache.json')
+        if os.path.exists(probe_cache):
+            try:
+                os.remove(probe_cache)
+                log.info("Deleted stale LED probe cache")
+            except OSError as e:
+                log.warning("Failed to delete LED probe cache: %s", e)
+
+    config['config_version'] = __version__
+    save_config(config)
+
+
 # =========================================================================
 # Language detection (system locale → asset suffix)
 # =========================================================================
@@ -233,6 +269,7 @@ class Settings:
     # --- Instance methods and properties ---
 
     def __init__(self) -> None:
+        _migrate_config()
         w, h = Settings._get_saved_resolution()
         self._width = w
         self._height = h

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/core/controllers.py

@@ -627,6 +627,7 @@ class LEDController:
     def __init__(self, svc: Any = None):
         from ..services.led import LEDService
         self._svc: LEDService = svc or LEDService()
+        self._last_colors: tuple = ()
 
         # View callbacks
         self.on_state_changed: Optional[Callable] = None
@@ -725,6 +726,10 @@ class LEDController:
         if self.on_preview_update:
             self.on_preview_update(colors)
         if self._svc.has_protocol:
+            key = tuple(colors)
+            if key == self._last_colors:
+                return
+            self._last_colors = key
             success = self._svc.send_colors(colors)
             if self.on_send_complete:
                 self.on_send_complete(success)

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/qt_components/qt_app_mvc.py

@@ -124,7 +124,7 @@ class LEDHandler:
         self._controller.led.set_seg_temp_unit(seg_unit)
 
         self._active = True
-        self._timer.start(30)
+        self._timer.start(150)
 
     def stop(self):
         """Stop LED mode — save config, stop timers, release protocol."""
@@ -247,7 +247,7 @@ class LEDHandler:
         self._controller.led.tick()
 
         self._sensor_counter += 1
-        if self._sensor_counter >= 33:
+        if self._sensor_counter >= 7:
             self._sensor_counter = 0
             self._poll_sensors()
 

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/src/trcc/services/device.py

@@ -51,6 +51,11 @@ class DeviceService:
         except ImportError:
             self._devices = []
 
+        # Enrich LED devices with probe data (PM → style, model name).
+        for d, raw_d in zip(self._devices, raw):
+            if d.implementation == 'hid_led':
+                self._enrich_led_device(d, raw_d.usb_path)
+
         log.info("DeviceService: found %d device(s)", len(self._devices))
         for d in self._devices:
             log.debug("  %s [%04X:%04X] %s res=%s",
@@ -62,6 +67,25 @@ class DeviceService:
 
         return self._devices
 
+    @staticmethod
+    def _enrich_led_device(device: DeviceInfo, usb_path: str) -> None:
+        """Probe LED device to resolve PM → style and model name.
+
+        Without this, all 0416:8001 devices start as generic "LED_DIGITAL"
+        which falls back to style 1 (AX120_DIGITAL, 30 LEDs) — wrong for
+        multi-segment devices like PA120 (84), LF8 (93), etc.
+        """
+        try:
+            from ..adapters.device.led import probe_led_model
+            info = probe_led_model(device.vid, device.pid, usb_path=usb_path)
+            if info and info.style:
+                device.led_style_id = info.style.style_id
+                device.model = info.style.model_name
+                log.debug("LED probe: PM=%d → style=%d model=%s",
+                          info.pm, info.style.style_id, info.style.model_name)
+        except Exception as e:
+            log.debug("LED probe failed: %s", e)
+
     # ── Selection ────────────────────────────────────────────────────
 
     def select(self, device: DeviceInfo) -> None:

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/tests/hid_testing/test_device_led.py

@@ -32,7 +32,6 @@ from trcc.adapters.device.led import (
     LED_STYLES,
     LED_VID,
     PRESET_COLORS,
-    SEND_COOLDOWN_S,
     ColorEngine,
     LedDeviceStyle,
     LedHandshakeInfo,
@@ -1087,14 +1086,14 @@ class TestLedHidSenderSendLedData:
         for c in transport.write.call_args_list:
             assert c[0][2] == DEFAULT_TIMEOUT_MS
 
-    def test_send_cooldown(self):
-        """Should sleep SEND_COOLDOWN_S after successful send."""
+    def test_send_no_cooldown(self):
+        """Should NOT sleep after send (cooldown removed for 150ms timer)."""
         transport = _make_mock_transport()
         sender = LedHidSender(transport)
 
         with patch("trcc.adapters.device.led.time.sleep") as mock_sleep:
             sender.send_led_data(b'\xAA' * 20)
-            mock_sleep.assert_called_once_with(SEND_COOLDOWN_S)
+            mock_sleep.assert_not_called()
 
     def test_concurrent_send_guard(self):
         """Second send while first is in progress should return False."""
@@ -1306,9 +1305,6 @@ class TestLedConstants:
     def test_color_scale(self):
         assert LED_COLOR_SCALE == 0.4
 
-    def test_send_cooldown(self):
-        assert SEND_COOLDOWN_S == 0.030
-
     def test_led_init_size(self):
         assert LED_INIT_SIZE == 64
 

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/tests/test_data_repository.py

@@ -191,6 +191,90 @@ class TestTempUnitConfig(unittest.TestCase):
         self.assertEqual(Settings._get_saved_temp_unit(), 1)
 
 
+class TestConfigMigration(unittest.TestCase):
+    """Test _migrate_config version-aware state clearing."""
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp()
+        self.config_path = os.path.join(self.tmp, 'config.json')
+        self.patches = [
+            patch('trcc.conf.CONFIG_PATH', self.config_path),
+            patch('trcc.conf.CONFIG_DIR', self.tmp),
+        ]
+        for p in self.patches:
+            p.start()
+
+    def tearDown(self):
+        for p in self.patches:
+            p.stop()
+        import shutil
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_fresh_install_stamps_version(self):
+        """First run: no config → stamps current version."""
+        from trcc.conf import _migrate_config
+        _migrate_config()
+        cfg = load_config()
+        from trcc.__version__ import __version__
+        self.assertEqual(cfg['config_version'], __version__)
+
+    def test_same_version_no_change(self):
+        """Same version: config untouched."""
+        from trcc.__version__ import __version__
+        save_config({
+            'config_version': __version__,
+            'devices': {'0:0416_8001': {'theme': 'dark'}},
+            'resolution': [480, 480],
+            'temp_unit': 1,
+        })
+        from trcc.conf import _migrate_config
+        _migrate_config()
+        cfg = load_config()
+        self.assertIn('devices', cfg)
+        self.assertEqual(cfg['resolution'], [480, 480])
+        self.assertEqual(cfg['temp_unit'], 1)
+
+    def test_version_mismatch_clears_device_state(self):
+        """Upgrade: clears devices, resolution, selected_device; preserves user prefs."""
+        save_config({
+            'config_version': '0.0.1',
+            'devices': {'0:0416_8001': {'theme': 'dark'}},
+            'resolution': [480, 480],
+            'selected_device': '/dev/sg0',
+            'installed_resolutions': ['320x320'],
+            'temp_unit': 1,
+            'lang': 'en',
+            'format_prefs': {'time_format': 1},
+            'hdd_enabled': False,
+        })
+        from trcc.conf import _migrate_config
+        _migrate_config()
+        cfg = load_config()
+        # Device-derived state cleared
+        self.assertNotIn('devices', cfg)
+        self.assertNotIn('resolution', cfg)
+        self.assertNotIn('selected_device', cfg)
+        self.assertNotIn('installed_resolutions', cfg)
+        # User prefs preserved
+        self.assertEqual(cfg['temp_unit'], 1)
+        self.assertEqual(cfg['lang'], 'en')
+        self.assertEqual(cfg['format_prefs'], {'time_format': 1})
+        self.assertFalse(cfg['hdd_enabled'])
+        # Version stamped
+        from trcc.__version__ import __version__
+        self.assertEqual(cfg['config_version'], __version__)
+
+    def test_version_mismatch_deletes_probe_cache(self):
+        """Upgrade: deletes LED probe cache file."""
+        probe_cache = os.path.join(self.tmp, 'led_probe_cache.json')
+        with open(probe_cache, 'w') as f:
+            json.dump({'cache': True}, f)
+        save_config({'config_version': '0.0.1'})
+        from trcc.conf import _migrate_config
+        _migrate_config()
+        self.assertFalse(os.path.exists(probe_cache))
+
+
 class TestResolutionInstalled(unittest.TestCase):
     """Test one-time resolution install tracking."""
 

{trcc_linux-5.0.0 → trcc_linux-5.0.2}/tests/test_doctor.py

@@ -270,22 +270,45 @@ class TestCheckSelinux(unittest.TestCase):
             if cmd[0] == 'getenforce':
                 return Mock(stdout='Enforcing\n')
             if cmd[0] == 'semodule':
-                return Mock(stdout='trcc_usb\nother_mod\n')
-            return Mock(stdout='')
+                return Mock(stdout='trcc_usb\nother_mod\n', returncode=0)
+            return Mock(stdout='', returncode=0)
         mock_run.side_effect = side_effect
         r = check_selinux()
         self.assertTrue(r.ok)
         self.assertTrue(r.enforcing)
         self.assertTrue(r.module_loaded)
 
+    @patch('subprocess.run')
+    def test_enforcing_sesearch_fallback(self, mock_run):
+        """semodule -l fails (non-root) but sesearch finds permissions."""
+        def side_effect(cmd, **_kw):
+            if cmd[0] == 'getenforce':
+                return Mock(stdout='Enforcing\n')
+            if cmd[0] == 'semodule':
+                return Mock(stdout='', returncode=1)  # permission denied
+            if cmd[0] == 'sesearch':
+                return Mock(
+                    stdout='allow unconfined_t usb_device_t:chr_file '
+                           '{ ioctl open read write };',
+                    returncode=0,
+                )
+            return Mock(stdout='', returncode=1)
+        mock_run.side_effect = side_effect
+        r = check_selinux()
+        self.assertTrue(r.ok)
+        self.assertTrue(r.enforcing)
+
     @patch('subprocess.run')
     def test_enforcing_module_missing(self, mock_run):
+        """semodule says no module, sesearch finds no permissions."""
         def side_effect(cmd, **_kw):
             if cmd[0] == 'getenforce':
                 return Mock(stdout='Enforcing\n')
             if cmd[0] == 'semodule':
-                return Mock(stdout='other_mod\n')
-            return Mock(stdout='')
+                return Mock(stdout='other_mod\n', returncode=0)
+            if cmd[0] == 'sesearch':
+                return Mock(stdout='', returncode=1)
+            return Mock(stdout='', returncode=1)
         mock_run.side_effect = side_effect
         r = check_selinux()
         self.assertFalse(r.ok)
@@ -295,10 +318,8 @@ class TestCheckSelinux(unittest.TestCase):
 
     @patch('subprocess.run')
     def test_enforcing_semodule_not_found(self, mock_run):
-        calls = []
-
+        """Neither semodule nor sesearch available."""
         def side_effect(cmd, **_kw):
-            calls.append(cmd[0])
             if cmd[0] == 'getenforce':
                 return Mock(stdout='Enforcing\n')
             raise FileNotFoundError