trcc-linux 8.3.1__tar.gz → 8.3.2__tar.gz

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 8.3.1
+Version: 8.3.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
@@ -74,7 +74,7 @@ Description-Content-Type: text/markdown
 [![Platform](https://img.shields.io/badge/platform-Linux-FCC624?logo=linux&logoColor=black)](https://github.com/Lexonight1/thermalright-trcc-linux)
 
 [![CI](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml/badge.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
-[![Tests](https://img.shields.io/badge/tests-4734_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
+[![Tests](https://img.shields.io/badge/tests-4784_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
 [![Coverage](https://img.shields.io/badge/coverage-73%25-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
 [![Python](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://python.org)
 [![Code Style](https://img.shields.io/badge/code_style-ruff-D7FF64?logo=ruff&logoColor=black)](https://docs.astral.sh/ruff/)

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/README.md

@@ -10,7 +10,7 @@
 [![Platform](https://img.shields.io/badge/platform-Linux-FCC624?logo=linux&logoColor=black)](https://github.com/Lexonight1/thermalright-trcc-linux)
 
 [![CI](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml/badge.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
-[![Tests](https://img.shields.io/badge/tests-4734_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
+[![Tests](https://img.shields.io/badge/tests-4784_passed-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
 [![Coverage](https://img.shields.io/badge/coverage-73%25-brightgreen.svg)](https://github.com/Lexonight1/thermalright-trcc-linux/actions/workflows/ci.yml)
 [![Python](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://python.org)
 [![Code Style](https://img.shields.io/badge/code_style-ruff-D7FF64?logo=ruff&logoColor=black)](https://docs.astral.sh/ruff/)

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/pyproject.toml

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

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/__version__.py

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

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/api/devices.py

@@ -83,22 +83,22 @@ def select_device(device_id: int) -> dict:
     api.stop_video_playback()
     api.stop_overlay_loop()
 
-    # Check if GUI daemon is running — if so, route through IPC
-    from trcc.ipc import IPCClient
+    # Check if another instance (GUI) already owns the device
+    from trcc.core.instance import find_active
+    from trcc.ipc import create_lcd_proxy, create_led_proxy
 
-    if IPCClient.available():
-        from trcc.ipc import IPCDisplayProxy, IPCLEDProxy
+    active = find_active()
 
-        api._display_dispatcher = IPCDisplayProxy()
-        api._led_dispatcher = IPCLEDProxy()
+    if active is not None:
+        api._display_dispatcher = create_lcd_proxy(active)
+        api._led_dispatcher = create_led_proxy(active)
 
-        # Daemon already discovered resolution — sync it to DeviceInfo
-        # so static dirs mount correctly and response has real resolution
+        # Active instance already discovered resolution — sync to DeviceInfo
         proxy_res = api._display_dispatcher.resolution
         if proxy_res != (0, 0):
             dev.resolution = proxy_res
 
-        log.info("Using GUI daemon for device %s", dev.name)
+        log.info("Using %s instance for device %s", active.value, dev.name)
     else:
         # Standalone mode — API manages device directly
         _device_svc.on_frame_sent = api.set_current_image

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/api/themes.py

@@ -188,23 +188,70 @@ def list_masks(resolution: str = "320x320") -> list[MaskResponse]:
 def load_theme(body: ThemeLoadRequest) -> dict:
     """Load a theme by name and send to device.
 
-    Thin adapter — routes through LCDDevice.load_theme_by_name().
+    Full pipeline matching GUI/CLI behavior:
+    1. Stop any running video/overlay
+    2. load_theme_by_name() → select + send + persist
+    3. Start video playback for animated themes
+    4. Start overlay loop for themes with config1.dc
+    5. Update preview image for WebSocket stream
+
     Works in both standalone and IPC (GUI daemon) modes.
+    In IPC mode, the GUI daemon handles the full pipeline.
     """
-    from trcc.api import _display_dispatcher, stop_overlay_loop, stop_video_playback
+    import trcc.api as api
     from trcc.api.models import dispatch_result
 
-    if not _display_dispatcher or not _display_dispatcher.connected:
+    if not api._display_dispatcher or not api._display_dispatcher.connected:
         raise HTTPException(status_code=409, detail="No LCD device selected. POST /devices/{id}/select first.")
 
-    stop_video_playback()
-    stop_overlay_loop()
+    api.stop_video_playback()
+    api.stop_overlay_loop()
 
     w, h = 0, 0
     if body.resolution:
         w, h = _parse_resolution(body.resolution)
 
-    result = _display_dispatcher.load_theme_by_name(body.name, w, h)
+    result = api._display_dispatcher.load_theme_by_name(body.name, w, h)
+    if not result.get("success"):
+        return dispatch_result(result)
+
+    # Update preview image for WebSocket stream
+    image = result.get("image")
+    if image:
+        api.set_current_image(image)
+
+    # Standalone mode — start video/overlay loops (GUI handles its own)
+    is_animated = result.get("is_animated", False)
+    theme_path = result.get("theme_path")
+    config_path = result.get("config_path")
+
+    if not w or not h:
+        res = getattr(api._display_dispatcher, 'resolution', None)
+        if res:
+            w, h = res
+        else:
+            w, h = getattr(api._display_dispatcher, 'lcd_size', (320, 320))
+
+    if is_animated and theme_path:
+        # Find video file (Theme.zt or .mp4)
+        from pathlib import Path
+        theme_dir = Path(str(theme_path))
+        video_path = None
+        for ext in ('.zt', '.mp4'):
+            for name in ('Theme', 'theme'):
+                candidate = theme_dir / f"{name}{ext}"
+                if candidate.exists():
+                    video_path = str(candidate)
+                    break
+            if video_path:
+                break
+        if video_path:
+            api.start_video_playback(video_path, w, h, loop=True)
+
+    elif config_path and os.path.isfile(config_path) and image:
+        # Static theme with overlay config — start metrics loop
+        api.start_overlay_loop(image, str(config_path), w, h)
+
     return dispatch_result(result)
 
 

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/cli/__init__.py

@@ -728,10 +728,10 @@ def _cmd_perf(
     _ensure_renderer()
 
     if device:
-        from trcc.ipc import IPCClient
+        from trcc.core.instance import InstanceKind, find_active
         from trcc.services.perf import run_device_benchmarks
 
-        gui_running = IPCClient.available()
+        gui_running = find_active() == InstanceKind.GUI
         if gui_running:
             print("GUI daemon detected — pausing display refresh...")
         print("Running device I/O benchmarks (this takes ~10s)...")

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/cli/_display.py

@@ -21,18 +21,22 @@ from trcc.core.models import parse_hex_color as _parse_hex
 def _connect_or_fail(device: str | None = None) -> tuple[LCDDevice, int]:
     """Create device, connect. Returns (device, exit_code).
 
-    When the GUI daemon is running and no explicit device path is given,
-    returns an IPC proxy that routes all commands through the daemon.
+    Composition root: injects instance detection (find_active) and proxy
+    factory so core routes through GUI/API if one is already running.
     """
-    if device is None:
-        from trcc.ipc import IPCClient, IPCDisplayProxy
-        if IPCClient.available():
-            return IPCDisplayProxy(), 0  # type: ignore[return-value]
-    lcd = LCDDevice()
+    from trcc.core.instance import find_active
+    from trcc.ipc import create_lcd_proxy
+
+    lcd = LCDDevice(
+        find_active_fn=find_active,
+        proxy_factory_fn=create_lcd_proxy,
+    )
     result = lcd.connect(device)
     if not result["success"]:
         print(result["error"])
         return lcd, 1
+    if result.get("proxy"):
+        print(f"Routing through {result['proxy'].value} instance")
     return lcd, 0
 
 

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/cli/_led.py

@@ -16,18 +16,23 @@ from trcc.core.models import parse_hex_color as _parse_hex
 def _connect_or_fail() -> tuple[LEDDevice, int]:
     """Create device, connect. Returns (device, exit_code).
 
-    When the GUI daemon is running, returns an IPC proxy that routes
-    all commands through the daemon.
+    Composition root: injects instance detection (find_active) and proxy
+    factory so core routes through GUI/API if one is already running.
     """
-    from trcc.ipc import IPCClient, IPCLEDProxy
-    if IPCClient.available():
-        return IPCLEDProxy(), 0  # type: ignore[return-value]
-    led = LEDDevice()
+    from trcc.core.instance import find_active
+    from trcc.ipc import create_led_proxy
+
+    led = LEDDevice(
+        find_active_fn=find_active,
+        proxy_factory_fn=create_led_proxy,
+    )
     result = led.connect()
     if not result["success"]:
         print("No LED device found.")
         return led, 1
-    if result.get("status"):
+    if result.get("proxy"):
+        print(f"Routing through {result['proxy'].value} instance")
+    elif result.get("status"):
         print(result["status"])
     return led, 0
 

trcc_linux-8.3.2/src/trcc/core/instance.py

@@ -0,0 +1,78 @@
+"""Unified instance detection — which trcc process owns the device?
+
+Pure core module: no adapter imports, no framework deps.
+Any adapter (GUI, CLI, API) calls find_active() before touching USB.
+
+Priority: GUI > API > direct.
+"""
+from __future__ import annotations
+
+import enum
+import logging
+import os
+import socket
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+# Default API port — single source of truth (used by CLI serve and detection)
+DEFAULT_API_PORT = 9876
+
+# IPC socket name — matches ipc.py
+_SOCK_NAME = "trcc-linux.sock"
+
+
+class InstanceKind(enum.Enum):
+    """Which type of trcc instance is running."""
+    GUI = "gui"
+    API = "api"
+
+
+def _socket_path() -> Path:
+    return Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / _SOCK_NAME
+
+
+def _gui_running() -> bool:
+    """Check if GUI daemon is listening on IPC socket."""
+    path = _socket_path()
+    if not path.exists():
+        return False
+    try:
+        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        s.settimeout(1.0)
+        s.connect(str(path))
+        s.close()
+        return True
+    except OSError:
+        return False
+
+
+def _api_running(port: int = DEFAULT_API_PORT) -> bool:
+    """Check if API server responds on localhost."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(1.0)
+        s.connect(("127.0.0.1", port))
+        # Send minimal HTTP GET /health
+        s.sendall(b"GET /health HTTP/1.0\r\nHost: 127.0.0.1\r\n\r\n")
+        data = s.recv(512)
+        s.close()
+        return b"200" in data and b"trcc" in data.lower()
+    except OSError:
+        return False
+
+
+def find_active(port: int = DEFAULT_API_PORT) -> InstanceKind | None:
+    """Detect which trcc instance (if any) currently owns the device.
+
+    Check order: GUI (IPC socket) > API (HTTP health) > None.
+    Returns None when no other instance is running — caller should
+    take device ownership directly.
+    """
+    if _gui_running():
+        log.info("Detected running GUI daemon (IPC socket)")
+        return InstanceKind.GUI
+    if _api_running(port):
+        log.info("Detected running API server (port %d)", port)
+        return InstanceKind.API
+    return None

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/core/lcd_device.py

@@ -43,6 +43,8 @@ class LCDDevice(Device):
         renderer: Any = None,
         dc_config_cls: Any = None,
         load_config_json_fn: Any = None,
+        find_active_fn: Any = None,
+        proxy_factory_fn: Any = None,
     ) -> None:
         self._device_svc = device_svc
         self._display_svc = display_svc
@@ -50,6 +52,9 @@ class LCDDevice(Device):
         self._renderer = renderer
         self._dc_config_cls = dc_config_cls
         self._load_config_json_fn = load_config_json_fn
+        self._find_active_fn = find_active_fn
+        self._proxy_factory_fn = proxy_factory_fn
+        self._proxy: Any = None  # Set when routing through another instance
 
         # All capability accessors point to self — methods are on LCDDevice
         self.theme: LCDDevice = self  # type: ignore[assignment]
@@ -114,14 +119,33 @@ class LCDDevice(Device):
     # ── Device ABC ─────────────────────────────────────────────────
 
     def connect(self, detected: Any = None) -> dict:
-        """Connect to LCD device. Handshakes, fills DeviceInfo from models.
+        """Connect to LCD device — or route through active instance.
+
+        If find_active_fn and proxy_factory_fn are injected and another
+        trcc instance owns the device, delegates all future method calls
+        to the proxy. Otherwise connects to USB directly.
 
         Args:
             detected: DetectedDevice, device_path str, or None for auto-detect.
 
         Returns:
-            {"success": bool, "resolution": (w, h), "device_path": str}
+            {"success": bool, "resolution": (w, h), "device_path": str,
+             "proxy": InstanceKind | None}
         """
+        # Check if another instance already owns the device
+        if detected is None and self._find_active_fn and self._proxy_factory_fn:
+            active = self._find_active_fn()
+            if active is not None:
+                proxy = self._proxy_factory_fn(active)
+                self._set_proxy(proxy)
+                log.info("Routing through %s instance", active.value)
+                return {
+                    "success": True,
+                    "proxy": active,
+                    "resolution": getattr(self._proxy, 'resolution', (0, 0)),
+                    "device_path": getattr(self._proxy, 'device_path', ''),
+                }
+
         from ..adapters.device.detector import DeviceDetector
         from ..adapters.device.factory import DeviceProtocolFactory
         from ..adapters.device.led import probe_led_model
@@ -154,6 +178,8 @@ class LCDDevice(Device):
 
     @property
     def connected(self) -> bool:
+        if self._proxy is not None:
+            return getattr(self._proxy, 'connected', True)
         return (self._device_svc is not None
                 and self._device_svc.selected is not None)
 
@@ -161,6 +187,15 @@ class LCDDevice(Device):
     def device_info(self) -> Any:
         return self._device_svc.selected if self._device_svc else None
 
+    def _set_proxy(self, proxy: Any) -> None:
+        """Route all capability accessors through proxy."""
+        self._proxy = proxy
+        self.theme = proxy  # type: ignore[assignment]
+        self.frame = proxy  # type: ignore[assignment]
+        self.video = proxy  # type: ignore[assignment]
+        self.overlay = proxy  # type: ignore[assignment]
+        self.settings = proxy  # type: ignore[assignment]
+
     def cleanup(self) -> None:
         if self._display_svc:
             self._display_svc.cleanup()
@@ -559,17 +594,18 @@ class LCDDevice(Device):
         }
 
     def load_theme_by_name(self, name: str, width: int = 0, height: int = 0) -> dict:
-        """Load a theme by name and send to device.
+        """Load a theme by name, send to device, persist as last-used.
 
-        Discovers themes for the given (or device) resolution, finds the
-        matching name, and routes through select() for full pipeline
-        (brightness, rotation, overlay, video).
+        Full pipeline matching GUI/CLI behavior:
+        1. Discover themes for resolution → find by name
+        2. select() → DisplayService processes (brightness, rotation)
+        3. Send static image to device (video themes return for caller to loop)
+        4. Persist theme_path to per-device config
 
-        Args:
-            name: Theme directory name (e.g. "003a", "Custom_MyTheme").
-            width: Resolution width (0 = use device resolution).
-            height: Resolution height (0 = use device resolution).
+        Returns dict with: success, image, is_animated, interval,
+        theme_path (Path), config_path (Path|None for overlay dc).
         """
+        from ..conf import Settings
         from ..services import ThemeService
         from .models import ThemeDir as CoreThemeDir
 
@@ -579,7 +615,30 @@ class LCDDevice(Device):
         match = next((t for t in themes if t.name == name), None)
         if not match:
             return {"success": False, "error": f"Theme '{name}' not found"}
-        return self.select(match)
+
+        result = self.select(match)
+        if not result.get("success"):
+            return result
+
+        image = result.get("image")
+        is_animated = result.get("is_animated", False)
+
+        # Send static image to device (matches GUI/CLI behavior)
+        if image and not is_animated:
+            self.send(image)
+
+        # Include theme paths for caller to handle overlay/persist
+        result["theme_path"] = match.path
+        result["config_path"] = match.config_path
+
+        # Persist as last-used theme
+        dev = self._device_svc.selected if self._device_svc else None
+        if dev and match.path:
+            key = Settings.device_config_key(dev.device_index, dev.vid, dev.pid)
+            Settings.save_device_setting(key, 'theme_path', str(match.path))
+            Settings.save_device_setting(key, 'mask_path', '')
+
+        return result
 
     def load_local(self, resolution: tuple[int, int]) -> dict:
         themes = self._theme_svc.load_local_themes(resolution)

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/core/led_device.py

@@ -8,11 +8,25 @@ CLI, GUI, and API all consume this directly (DIP — core/, not adapter/).
 """
 from __future__ import annotations
 
+import functools
+import logging
 from typing import Any
 
 from .models import LEDMode
 from .ports import Device
 
+log = logging.getLogger(__name__)
+
+
+def _forward_to_proxy(method):
+    """Forward method call to proxy if one is active."""
+    @functools.wraps(method)
+    def wrapper(self, *args, **kwargs):
+        if self._proxy is not None:
+            return getattr(self._proxy, method.__name__)(*args, **kwargs)
+        return method(self, *args, **kwargs)
+    return wrapper
+
 
 class LEDDevice(Device):
     """LED device — extends Device ABC, delegates to LEDService.
@@ -27,14 +41,23 @@ class LEDDevice(Device):
 
         led = LEDDevice()
         led.initialize(device_info, style)   # GUI: device already detected
+
+    DI for instance detection:
+        led = LEDDevice(find_active_fn=find_active, proxy_factory_fn=factory)
+        led.connect()  # routes through GUI/API if one is running
     """
 
     def __init__(self, svc: Any = None,
                  get_protocol: Any = None,
-                 device_svc: Any = None) -> None:
+                 device_svc: Any = None,
+                 find_active_fn: Any = None,
+                 proxy_factory_fn: Any = None) -> None:
         self._svc = svc
         self._get_protocol = get_protocol
         self._device_svc = device_svc
+        self._find_active_fn = find_active_fn
+        self._proxy_factory_fn = proxy_factory_fn
+        self._proxy: Any = None
         self._init_status: str | None = None
         self._device: Any = None  # DetectedDevice from detection
 
@@ -43,11 +66,27 @@ class LEDDevice(Device):
     def connect(self, detected: Any = None) -> dict:
         """Detect LED device, probe model, initialize LEDService.
 
+        If find_active_fn and proxy_factory_fn are injected and another
+        trcc instance owns the device, delegates all future method calls
+        to the proxy. Otherwise connects to USB directly.
+
         Returns: {"success": bool, "status": str}
         """
         if self._svc:
             return {"success": True, "status": self._init_status or ""}
 
+        # Check if another instance already owns the device
+        if detected is None and self._find_active_fn and self._proxy_factory_fn:
+            active = self._find_active_fn()
+            if active is not None:
+                self._proxy = self._proxy_factory_fn(active)
+                log.info("LED routing through %s instance", active.value)
+                return {
+                    "success": True,
+                    "proxy": active,
+                    "status": f"Connected (via {active.value})",
+                }
+
         from ..services import LEDService
 
         if self._device_svc is None:
@@ -78,6 +117,8 @@ class LEDDevice(Device):
 
     @property
     def connected(self) -> bool:
+        if self._proxy is not None:
+            return getattr(self._proxy, 'connected', True)
         return self._svc is not None
 
     @property
@@ -249,7 +290,10 @@ class LEDDevice(Device):
         self._svc.set_selected_zone(zone)
 
     # ── Global operations (CLI/API — immediate tick/send/save) ────
+    # @_forward_to_proxy: when another trcc instance owns the device,
+    # these calls route through the proxy transparently.
 
+    @_forward_to_proxy
     def set_color(self, r: int, g: int, b: int) -> dict:
         self._svc.set_mode(LEDMode.STATIC)
         self._svc.set_color(r, g, b)
@@ -257,6 +301,7 @@ class LEDDevice(Device):
         return {"success": True, "colors": colors,
                 "message": f"LED color set to #{r:02x}{g:02x}{b:02x}"}
 
+    @_forward_to_proxy
     def set_mode(self, mode: LEDMode | str | int) -> dict:
         resolved = self._resolve_mode(mode)
         if not resolved:
@@ -269,6 +314,7 @@ class LEDDevice(Device):
         return {"success": True, "colors": colors, "animated": animated,
                 "message": f"LED mode: {resolved.name.lower()}"}
 
+    @_forward_to_proxy
     def set_brightness(self, level: int) -> dict:
         if level < 0 or level > 100:
             return {"success": False, "error": "Brightness must be 0-100"}
@@ -277,16 +323,19 @@ class LEDDevice(Device):
         return {"success": True, "colors": colors,
                 "message": f"LED brightness set to {level}%"}
 
+    @_forward_to_proxy
     def toggle_global(self, on: bool) -> dict:
         self._svc.toggle_global(on)
         self._send_and_save()
         return {"success": True, "message": f"LEDs {'on' if on else 'off'}"}
 
+    @_forward_to_proxy
     def off(self) -> dict:
         self._svc.toggle_global(False)
         self._send_and_save()
         return {"success": True, "message": "LEDs turned off"}
 
+    @_forward_to_proxy
     def set_sensor_source(self, source: str) -> dict:
         source = source.lower()
         if source not in ('cpu', 'gpu'):
@@ -299,6 +348,7 @@ class LEDDevice(Device):
 
     # ── Zone operations ────────────────────────────────────────────
 
+    @_forward_to_proxy
     def set_zone_color(self, zone: int, r: int, g: int, b: int) -> dict:
         if err := self._validate_zone(zone):
             return err
@@ -307,6 +357,7 @@ class LEDDevice(Device):
         return {"success": True, "colors": colors,
                 "message": f"Zone {zone} color set to #{r:02x}{g:02x}{b:02x}"}
 
+    @_forward_to_proxy
     def set_zone_mode(self, zone: int, mode: LEDMode | str | int) -> dict:
         if err := self._validate_zone(zone):
             return err
@@ -318,6 +369,7 @@ class LEDDevice(Device):
         return {"success": True, "colors": colors,
                 "message": f"Zone {zone} mode set to {resolved.name.lower()}"}
 
+    @_forward_to_proxy
     def set_zone_brightness(self, zone: int, level: int) -> dict:
         if err := self._validate_zone(zone):
             return err
@@ -328,6 +380,7 @@ class LEDDevice(Device):
         return {"success": True, "colors": colors,
                 "message": f"Zone {zone} brightness set to {level}%"}
 
+    @_forward_to_proxy
     def toggle_zone(self, zone: int, on: bool) -> dict:
         if err := self._validate_zone(zone):
             return err
@@ -336,6 +389,7 @@ class LEDDevice(Device):
         return {"success": True,
                 "message": f"Zone {zone} {'ON' if on else 'OFF'}"}
 
+    @_forward_to_proxy
     def set_zone_sync(self, enabled: bool,
                       interval: int | None = None) -> dict:
         if interval is not None:
@@ -359,6 +413,7 @@ class LEDDevice(Device):
 
     # ── Segment operations ─────────────────────────────────────────
 
+    @_forward_to_proxy
     def toggle_segment(self, index: int, on: bool) -> dict:
         if err := self._validate_segment(index):
             return err
@@ -367,17 +422,20 @@ class LEDDevice(Device):
         return {"success": True,
                 "message": f"Segment {index} {'ON' if on else 'OFF'}"}
 
+    @_forward_to_proxy
     def set_clock_format(self, is_24h: bool) -> dict:
         self._svc.set_clock_format(is_24h)
         self._send_and_save()
         return {"success": True,
                 "message": f"Clock format set to {'24h' if is_24h else '12h'}"}
 
+    @_forward_to_proxy
     def set_week_start(self, is_sunday: bool) -> dict:
         self._svc.set_week_start(is_sunday)
         self._send_and_save()
         return {"success": True}
 
+    @_forward_to_proxy
     def set_temp_unit(self, unit: str) -> dict:
         unit = unit.upper()
         if unit not in ('C', 'F'):

{trcc_linux-8.3.1 → trcc_linux-8.3.2}/src/trcc/core/ports.py

@@ -196,6 +196,16 @@ DcConfigFactory = Callable[..., Any]
 # Concrete: dc_parser.load_config_json
 LoadConfigJsonFn = Callable[[str], Any]
 
+# Type alias for instance detection callable.
+# Concrete: core.instance.find_active
+# Returns InstanceKind | None — who currently owns the device.
+FindActiveFn = Callable[[], Any]
+
+# Type alias for proxy factory callable.
+# Concrete: ipc.create_lcd_proxy / ipc.create_led_proxy
+# Takes InstanceKind, returns a proxy object (IPCDisplayProxy, APIDisplayProxy, etc.)
+ProxyFactoryFn = Callable[[Any], Any]
+
 # Type alias for theme export callable.
 # Concrete: dc_writer.export_theme
 ExportThemeFn = Callable[[str, str], None]