trcc-linux 9.6.0__tar.gz → 9.6.2__tar.gz

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/.gitignore

@@ -94,6 +94,11 @@ src/trcc/data/ui_*.json
 !/dev/smoke_rotation_mask.py
 !/dev/smoke_daemon_gui.py
 !/dev/smoke_sleep_cycle.py
+!/dev/smoke_linux.py
+!/dev/smoke_windows.py
+!/dev/smoke_macos.py
+!/dev/smoke_bsd.py
+!/dev/_smoke_runtime.py
 /dev_*
 # Dev scripts at root
 /test_*.py

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.6.0
+Version: 9.6.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
@@ -26,6 +26,7 @@ Requires-Python: >=3.10
 Requires-Dist: certifi>=2023.7.22
 Requires-Dist: click>=7.0
 Requires-Dist: fastapi>=0.100
+Requires-Dist: libusb-package>=1.0.26.3; sys_platform == 'win32' and python_version < '3.14'
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: prompt-toolkit>=3.0.0
 Requires-Dist: psutil>=5.9.0
@@ -64,8 +65,6 @@ Provides-Extra: wayland
 Requires-Dist: dbus-python>=1.3.0; extra == 'wayland'
 Requires-Dist: pygobject>=3.42.0; extra == 'wayland'
 Provides-Extra: windows
-Requires-Dist: hardwaremonitor>=1.1.0; (sys_platform == 'win32') and extra == 'windows'
-Requires-Dist: pythonnet>=3.0.3; (sys_platform == 'win32') and extra == 'windows'
 Requires-Dist: pywin32>=306; (sys_platform == 'win32') and extra == 'windows'
 Requires-Dist: wmi>=1.5.1; (sys_platform == 'win32') and extra == 'windows'
 Description-Content-Type: text/markdown

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.6.0"
+version = "9.6.2"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -33,6 +33,14 @@ dependencies = [
     "numpy>=1.24.0",
     "psutil>=5.9.0",
     "pyusb>=1.2.0",
+    # libusb-package bundles libusb-1.0.dll on Windows so pip-installed
+    # users get a working pyusb backend out of the box. Pyocd's canonical
+    # pattern (#131 — usb.core.NoBackendError on pip-install Windows).
+    # Pinned for Windows + Python <3.14 because upstream wheels only go
+    # to cp313 (verified PyPI 2026-05-14); pip install of trcc-linux on
+    # Python 3.14 Windows would otherwise fail at sdist build. Lift the
+    # python_version cap once libusb-package ships a cp314 wheel.
+    "libusb-package>=1.0.26.3; sys_platform == 'win32' and python_version < '3.14'",
     "click>=7.0",
     "typer>=0.9.0",
     "fastapi>=0.100",
@@ -56,8 +64,6 @@ wayland = [
 windows = [
     "wmi>=1.5.1; sys_platform == 'win32'",
     "pywin32>=306; sys_platform == 'win32'",
-    "pythonnet>=3.0.3; sys_platform == 'win32'",
-    "HardwareMonitor>=1.1.0; sys_platform == 'win32'",
 ]
 hid = [
     "hidapi>=0.14.0",

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/__init__.py

@@ -40,8 +40,8 @@ def detect_devices():
     Convenience for library users — wraps a one-shot platform build +
     detect. For sustained use, build a Trcc explicitly:
         from trcc.core.trcc import Trcc
-        from trcc.adapters.system import make_platform
-        trcc = Trcc(make_platform())
+        from trcc.adapters.system import PlatformFactory
+        trcc = Trcc(PlatformFactory.current())
         trcc.discover()
     """
     from trcc.core.ports import Platform

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/__main__.py

@@ -41,12 +41,47 @@ logging.basicConfig(
     datefmt='%Y-%m-%d %H:%M:%S',
     handlers=[
         _rotating_handler_cls(
-            _log_path, maxBytes=1_000_000, backupCount=3),
+            _log_path, maxBytes=1_000_000, backupCount=3,
+            encoding='utf-8', errors='replace'),
     ],
 )
 log = logging.getLogger('trcc.main')
 log.info("Starting TRCC — platform=%s, executable=%s", sys.platform, sys.executable)
 
+# Windows: stdout/stderr default to cp1252, which can't encode common
+# Unicode chars used in log messages (e.g. ``→``, ``°``).  ``reconfigure``
+# is a silent no-op on some Python deployments (Windows Store), so on
+# top of that we monkey-patch ``logging.StreamHandler.emit`` to wrap the
+# write call in its own ``except UnicodeEncodeError`` that re-encodes
+# with ``errors='replace'``.  This catches EVERY StreamHandler — ours,
+# stdlib lastResort, third-party — at the class level, no matter when
+# or where they're instantiated.
+if sys.platform == 'win32':
+    for _stream in (sys.stdout, sys.stderr):
+        if hasattr(_stream, 'reconfigure'):
+            try:
+                _stream.reconfigure(encoding='utf-8', errors='replace')
+            except (AttributeError, OSError, ValueError):
+                pass
+
+    def _safe_stream_emit(self: logging.StreamHandler, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+            stream = self.stream
+            try:
+                stream.write(msg + self.terminator)
+            except UnicodeEncodeError:
+                encoding = getattr(stream, 'encoding', 'ascii') or 'ascii'
+                safe = msg.encode(encoding, errors='replace').decode(encoding)
+                stream.write(safe + self.terminator)
+            self.flush()
+        except RecursionError:
+            raise
+        except Exception:
+            self.handleError(record)
+
+    logging.StreamHandler.emit = _safe_stream_emit  # type: ignore[method-assign]
+
 # Windows: ensure libusb-1.0.dll is findable by pyusb (ctypes).
 # PyInstaller bundles the DLL next to the exe, but Python 3.8+ on Windows
 # doesn't search the exe's directory for ctypes DLLs unless explicitly told.

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/__version__.py

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

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/_boot.py

@@ -106,7 +106,7 @@ def trcc(
 
     Parameters:
         platform: DI override. ``None`` triggers OS detection via
-            ``make_platform()``.  Tests pass ``MockPlatform`` to skip USB.
+            ``PlatformFactory.current()``.  Tests pass ``MockPlatform`` to skip USB.
         renderer: DI override. ``None`` builds an offscreen ``QtRenderer``.
             The GUI passes its own windowed renderer.
         discover_now: When True (default), runs ``Trcc.discover()`` so
@@ -143,8 +143,8 @@ def trcc(
 
         # 2. Resolve / accept the Platform.
         if platform is None:
-            from trcc.adapters.system import make_platform
-            platform = make_platform()
+            from trcc.adapters.system import PlatformFactory
+            platform = PlatformFactory.current()
 
         # 3. Bootstrap the process: logging, OS-specific stdout config,
         # settings file, first-run setup hook. All idempotent — safe

trcc_linux-9.6.2/src/trcc/adapters/device/_pyusb_find.py

@@ -0,0 +1,46 @@
+"""PyUSB find() wrapper — uses libusb_package's bundled backend on Windows.
+
+PyUSB needs ``libusb-1.0`` userspace to talk to USB devices. On Linux and
+macOS the system package manager ships it. On Windows there is no system
+libusb — pip-installed users hit ``usb.core.NoBackendError: No backend
+available`` (issue #131, lallemandgianni-boop on Windows 11 v9.6.1).
+
+The canonical fix is `libusb-package <https://github.com/pyocd/libusb-package>`_
+(pyocd's project) — a Windows wheel that bundles ``libusb-1.0.dll`` and
+exposes ``find()`` as a drop-in for ``usb.core.find()``.  pyproject.toml
+adds it as a Windows-only dependency::
+
+    libusb-package>=1.0.26.2; sys_platform == 'win32'
+
+This module exports a single :func:`find` shim that uses
+``libusb_package.find`` when available (Windows wheel installed) and
+falls back to ``usb.core.find`` otherwise (Linux/macOS users with system
+libusb, or anyone who installed the optional wheel themselves).  Every
+``usb.core.find`` call site in ``trcc.adapters.device`` goes through
+this seam so there's exactly one place that knows about the Windows
+quirk.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+try:
+    from libusb_package import find as _find  # type: ignore[import-not-found]
+    log.debug("pyusb backend: libusb-package (bundled libusb-1.0)")
+except ImportError:
+    from usb.core import find as _find  # type: ignore[no-redef]
+    log.debug("pyusb backend: system libusb via usb.core.find")
+
+
+def find(*args: Any, **kwargs: Any) -> Any:
+    """Drop-in for ``usb.core.find()`` with Windows-compatible backend.
+
+    Identical signature, identical return type. Routes through
+    ``libusb_package.find`` on platforms where it's installed (Windows
+    via pip), otherwise calls ``usb.core.find`` directly (Linux, macOS,
+    or any environment where the user manages libusb themselves).
+    """
+    return _find(*args, **kwargs)

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/adapters/device/_usb_bot_scsi.py

@@ -38,11 +38,11 @@ class UsbBotScsiTransport(ScsiTransport):
 
     def __init__(
         self, vid: int, pid: int,
-        *, addr: UsbAddress | None = None,
+        *, usb_address: UsbAddress | None = None,
     ) -> None:
         self._vid = vid
         self._pid = pid
-        self._addr = addr  # bind to specific (bus, address) — issue #128
+        self._usb_address = usb_address  # bind to specific (bus, address) — issue #128
         self._dev: Any = None
         self._ep_out: int | None = None
         self._ep_in: int | None = None
@@ -51,18 +51,19 @@ class UsbBotScsiTransport(ScsiTransport):
     def open(self) -> bool:
         """Find device, detach kernel driver, claim interface."""
         try:
-            import usb.core  # pyright: ignore[reportMissingImports]
             import usb.util  # pyright: ignore[reportMissingImports]
+
+            from . import _pyusb_find
         except ImportError:
             log.error(self._pyusb_install_hint)
             return False
 
         kwargs: dict[str, Any] = {'idVendor': self._vid, 'idProduct': self._pid}
-        if self._addr is not None:
-            kwargs['custom_match'] = self._addr.matches
-        dev: Any = usb.core.find(**kwargs)
+        if self._usb_address is not None:
+            kwargs['custom_match'] = self._usb_address.matches
+        dev: Any = _pyusb_find.find(**kwargs)
         if dev is None:
-            where = f" @ {self._addr}" if self._addr else ""
+            where = f" @ {self._usb_address}" if self._usb_address else ""
             log.error("Device %04X:%04X%s not found", self._vid, self._pid, where)
             return False
 

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/adapters/device/_usb_helpers.py

@@ -109,11 +109,11 @@ def _detach_kernel_drivers(dev: Any, count: int = 4) -> bool:
 
 def _reset_and_refind(dev: Any, vid: int, pid: int) -> Any:
     """Reset USB device, wait, re-find, detach drivers. Returns new handle."""
-    import usb.core  # type: ignore[import-untyped]
+    from . import _pyusb_find
 
     dev.reset()  # type: ignore[union-attr]
     time.sleep(0.5)
-    new_dev = usb.core.find(idVendor=vid, idProduct=pid)
+    new_dev = _pyusb_find.find(idVendor=vid, idProduct=pid)
     if new_dev is None:
         raise RuntimeError(_ERR_NOT_FOUND.format(vid=vid, pid=pid))
     _detach_kernel_drivers(new_dev)
@@ -126,7 +126,7 @@ def _reset_and_refind(dev: Any, vid: int, pid: int) -> Any:
 
 def open_usb_device(
     vid: int, pid: int,
-    *, addr: UsbAddress | None = None,
+    *, usb_address: UsbAddress | None = None,
 ) -> tuple[Any, Any]:
     """Find, configure, and claim a vendor-class USB device.
 
@@ -134,9 +134,9 @@ def open_usb_device(
       find -> detach kernel drivers -> configure
       -> find vendor interface -> claim (with EBUSY retry) -> return
 
-    ``addr`` (bus + address) binds to a specific physical USB device when two
-    coolers share VID:PID (issue #128). Without it, pyusb returns the first
-    match — fine for single-device users, ambiguous for dual.
+    ``usb_address`` (bus + address) binds to a specific physical USB device
+    when two coolers share VID:PID (issue #128). Without it, pyusb returns
+    the first match — fine for single-device users, ambiguous for dual.
 
     Returns:
         (device, interface) tuple ready for endpoint detection.
@@ -145,15 +145,17 @@ def open_usb_device(
         RuntimeError: Device not found, or kernel driver could not be detached.
         usb.core.USBError: Permission denied (errno 13).
     """
-    import usb.core  # type: ignore[import-untyped]
+    import usb.core  # type: ignore[import-untyped]  # for USBError below
     import usb.util  # type: ignore[import-untyped]
 
+    from . import _pyusb_find
+
     kwargs: dict[str, Any] = {'idVendor': vid, 'idProduct': pid}
-    if addr is not None:
-        kwargs['custom_match'] = addr.matches
-    dev = usb.core.find(**kwargs)
+    if usb_address is not None:
+        kwargs['custom_match'] = usb_address.matches
+    dev = _pyusb_find.find(**kwargs)
     if dev is None:
-        where = f" @ {addr}" if addr else ""
+        where = f" @ {usb_address}" if usb_address else ""
         raise RuntimeError(_ERR_NOT_FOUND.format(vid=vid, pid=pid) + where)
 
     # 1. Detach kernel drivers (post-verification included)
@@ -204,12 +206,12 @@ class BulkFrameDevice:
 
     def __init__(
         self, vid: int, pid: int, usb_path: str = "",
-        *, addr: UsbAddress | None = None,
+        *, usb_address: UsbAddress | None = None,
     ):
         self.vid = vid
         self.pid = pid
         self.usb_path = usb_path
-        self.addr = addr  # bus+addr — disambiguates dual same-VID/PID coolers (#128)
+        self.usb_address = usb_address  # disambiguates dual same-VID/PID coolers (#128)
         self._dev: Any = None
         self._ep_out: Any = None
         self._ep_in: Any = None
@@ -225,7 +227,7 @@ class BulkFrameDevice:
         """Find and claim the USB device, discover bulk IN/OUT endpoints."""
         import usb.util
 
-        dev, intf = open_usb_device(self.vid, self.pid, addr=self.addr)
+        dev, intf = open_usb_device(self.vid, self.pid, usb_address=self.usb_address)
 
         self._ep_out = usb.util.find_descriptor(
             intf,

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/adapters/device/bsd/detector.py

@@ -1,7 +1,7 @@
 """FreeBSD USB device detection utilities.
 
 Device detection on FreeBSD uses the cross-platform DeviceDetector
-(pyusb-based) via BSDPlatform.create_detect_fn(). SCSI devices are
+(pyusb-based) via BSDPlatform.detect_devices(). SCSI devices are
 addressed by VID:PID through pyusb — no /dev/pass* mapping needed.
 
 This module provides diagnostic utilities only.

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/adapters/device/bulk_protocol.py

@@ -28,18 +28,18 @@ class _BulkLikeProtocol(DeviceProtocol):
 
     def __init__(
         self, vid: int, pid: int,
-        *, addr: UsbAddress | None = None,
+        *, usb_address: UsbAddress | None = None,
     ):
         super().__init__()
         self._vid = vid
         self._pid = pid
-        self._addr = addr  # disambiguates dual same-VID/PID coolers (#128)
+        self._usb_address = usb_address  # disambiguates dual same-VID/PID coolers (#128)
         self._device: Any | None = None
 
     @staticmethod
     def _make_device(
         vid: int, pid: int,
-        *, addr: UsbAddress | None = None,
+        *, usb_address: UsbAddress | None = None,
     ) -> Any:
         raise NotImplementedError
 
@@ -47,8 +47,8 @@ class _BulkLikeProtocol(DeviceProtocol):
         if self._device is None:
             log.debug("%s: creating device %04X:%04X%s",
                       self._label, self._vid, self._pid,
-                      f" @ {self._addr}" if self._addr else "")
-            self._device = self._make_device(self._vid, self._pid, addr=self._addr)
+                      f" @ {self._usb_address}" if self._usb_address else "")
+            self._device = self._make_device(self._vid, self._pid, usb_address=self._usb_address)
             assert self._device is not None
             log.debug("%s: starting handshake", self._label)
             result = self._device.handshake()
@@ -98,10 +98,10 @@ class BulkProtocol(_BulkLikeProtocol):
     @staticmethod
     def _make_device(
         vid: int, pid: int,
-        *, addr: UsbAddress | None = None,
+        *, usb_address: UsbAddress | None = None,
     ) -> Any:
         from .bulk import BulkDevice
-        return BulkDevice(vid, pid, addr=addr)
+        return BulkDevice(vid, pid, usb_address=usb_address)
 
     def get_info(self) -> ProtocolInfo:
         return self._build_usb_protocol_info(

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/adapters/device/detector.py

@@ -85,7 +85,7 @@ class DeviceDetector:
     def _detect(scsi_resolver: ScsiResolver | None) -> list[DetectedDevice]:
         """Core detection via pyusb with injected SCSI resolver."""
         try:
-            import usb.core  # pyright: ignore[reportMissingImports]
+            from . import _pyusb_find
         except ImportError:
             log.error("pyusb not installed — pip install pyusb")
             return []
@@ -95,7 +95,7 @@ class DeviceDetector:
             # find_all=True yields every match; `or ()` handles None when
             # no devices are present, so two same-VID/PID coolers each
             # produce their own DetectedDevice (issue #128).
-            for usb_dev in (usb.core.find(find_all=True, idVendor=vid, idProduct=pid) or ()):
+            for usb_dev in (_pyusb_find.find(find_all=True, idVendor=vid, idProduct=pid) or ()):
                 dev: Any = usb_dev
                 usb_path = f'usb:{dev.bus}:{dev.address}'
                 scsi_dev = (

{trcc_linux-9.6.0 → trcc_linux-9.6.2}/src/trcc/adapters/device/factory.py

@@ -22,7 +22,7 @@ import logging
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from trcc.core.models import (
     DEVICE_TYPE_NAMES,
@@ -31,6 +31,9 @@ from trcc.core.models import (
     UsbAddress,
 )
 
+if TYPE_CHECKING:
+    from trcc.core.models import DeviceInfo
+
 log = logging.getLogger(__name__)
 
 
@@ -300,19 +303,19 @@ class UsbProtocol(LazyTransportProtocol):
 
     def __init__(
         self, vid: int, pid: int,
-        *, addr: UsbAddress | None = None,
+        *, usb_address: UsbAddress | None = None,
     ):
         super().__init__()
         self._vid = vid
         self._pid = pid
-        self._addr = addr  # bus+address from detector — disambiguates dual same-VID/PID coolers
+        self._usb_address = usb_address  # disambiguates dual same-VID/PID coolers (#128)
 
     def _open_transport(self) -> Any:
         log.debug("Opening %s transport: %04X:%04X%s",
                   self.protocol_name, self._vid, self._pid,
-                  f" @ {self._addr}" if self._addr else "")
+                  f" @ {self._usb_address}" if self._usb_address else "")
         transport = DeviceProtocolFactory.create_usb_transport(
-            self._vid, self._pid, addr=self._addr)
+            self._vid, self._pid, usb_address=self._usb_address)
         transport.open()
         return transport
 
@@ -452,20 +455,20 @@ class DeviceProtocolFactory:
     @staticmethod
     def create_usb_transport(
         vid: int, pid: int,
-        *, addr: UsbAddress | None = None,
+        *, usb_address: UsbAddress | None = None,
     ):
         """Create the best available USB transport (pyusb preferred, hidapi fallback).
 
-        ``addr`` (bus + address) binds the transport to a specific physical USB
-        device — required when two coolers share the same VID:PID (issue #128).
+        ``usb_address`` (bus + address) binds the transport to a specific physical
+        USB device — required when two coolers share the same VID:PID (#128).
         """
         from .hid import HIDAPI_AVAILABLE, PYUSB_AVAILABLE
         if PYUSB_AVAILABLE:
             from .hid import PyUsbTransport
-            return PyUsbTransport(vid, pid, addr=addr)
+            return PyUsbTransport(vid, pid, usb_address=usb_address)
         elif HIDAPI_AVAILABLE:
             from .hid import HidApiTransport
-            return HidApiTransport(vid, pid, addr=addr)
+            return HidApiTransport(vid, pid, usb_address=usb_address)
         else:
             raise ImportError(
                 "No USB backend available. Install pyusb or hidapi:\n"
@@ -603,7 +606,14 @@ class ProtocolInfo:
 
 
 # =========================================================================
-# Register concrete Protocol classes
+# ProtocolFactory — one factory subclass per protocol kind.
+#
+# Mirrors the ``PlatformFactory`` idiom in ``adapters/system/__init__.py``:
+# ABC + ``@ProtocolFactory.register('name')`` self-registering subclasses +
+# single ``ProtocolFactory.for_info(info)`` chokepoint that dispatches by
+# the protocol *name* carried on ``DeviceInfo``. Two factory layers, one
+# pattern — readers learn it once and apply it everywhere.
+#
 # Imports are at the bottom to avoid the circular dependency (each protocol
 # module imports DeviceProtocol/UsbProtocol/ProtocolInfo from this module).
 # =========================================================================
@@ -614,11 +624,90 @@ from .led_protocol import LedProtocol  # noqa: E402
 from .ly_protocol import LyProtocol  # noqa: E402
 from .scsi_protocol import ScsiProtocol  # noqa: E402
 
+
+class ProtocolFactory(ABC):
+    """Abstract factory for a single ``DeviceProtocol`` class.
+
+    Subclasses self-register via ``@ProtocolFactory.register('name')``. The
+    registry is consulted via ``ProtocolFactory.for_info(info)`` — the
+    single chokepoint that turns a ``DeviceInfo`` into the right
+    ``DeviceProtocol`` instance (DI'd into ``Device`` at construction).
+
+    Open/Closed: new protocol support = one new decorated subclass. Zero
+    touchpoints elsewhere.
+    """
+
+    _registry: ClassVar[dict[str, type['ProtocolFactory']]] = {}
+
+    @classmethod
+    def register(cls, name: str):
+        """Mark a factory subclass as the one to use for ``info.protocol == name``."""
+        def deco(sub: type['ProtocolFactory']) -> type['ProtocolFactory']:
+            cls._registry[name] = sub
+            return sub
+        return deco
+
+    @classmethod
+    def for_info(cls, info: 'DeviceInfo') -> DeviceProtocol:
+        """Build the right ``DeviceProtocol`` for a ``DeviceInfo`` (dispatch by name)."""
+        factory_cls = cls._registry.get(info.protocol)
+        if factory_cls is None:
+            raise ValueError(f"Unknown protocol: {info.protocol!r}")
+        return factory_cls().make(info)
+
+    @abstractmethod
+    def make(self, info: 'DeviceInfo') -> DeviceProtocol:
+        """Construct the protocol instance from a ``DeviceInfo``."""
+
+
+@ProtocolFactory.register('scsi')
+class ScsiProtocolFactory(ProtocolFactory):
+    """Build ``ScsiProtocol`` for ``info.protocol == 'scsi'``."""
+
+    def make(self, info: 'DeviceInfo') -> DeviceProtocol:
+        return ScsiProtocol(info.path, info.vid, info.pid, usb_address=info.usb_address)
+
+
+@ProtocolFactory.register('hid')
+class HidProtocolFactory(ProtocolFactory):
+    """Build ``HidProtocol`` (Type 2 or Type 3 chosen via ``info.device_type``)."""
+
+    def make(self, info: 'DeviceInfo') -> DeviceProtocol:
+        return HidProtocol(
+            vid=info.vid, pid=info.pid,
+            usb_address=info.usb_address,
+            device_type=info.device_type,
+        )
+
+
+@ProtocolFactory.register('bulk')
+class BulkProtocolFactory(ProtocolFactory):
+    """Build ``BulkProtocol`` for raw-USB-bulk LCDs (USBLCDNew)."""
+
+    def make(self, info: 'DeviceInfo') -> DeviceProtocol:
+        return BulkProtocol(vid=info.vid, pid=info.pid, usb_address=info.usb_address)
+
+
+@ProtocolFactory.register('ly')
+class LyProtocolFactory(ProtocolFactory):
+    """Build ``LyProtocol`` for LY USB-bulk LCDs (0416:5408 / 0416:5409)."""
+
+    def make(self, info: 'DeviceInfo') -> DeviceProtocol:
+        return LyProtocol(vid=info.vid, pid=info.pid, usb_address=info.usb_address)
+
+
+@ProtocolFactory.register('led')
+class LedProtocolFactory(ProtocolFactory):
+    """Build ``LedProtocol`` for RGB LED controllers (HID 64-byte reports)."""
+
+    def make(self, info: 'DeviceInfo') -> DeviceProtocol:
+        return LedProtocol(vid=info.vid, pid=info.pid, usb_address=info.usb_address)
+
+
+# Bridge the new factory subclasses into the orchestration class's registry —
+# keeps every legacy caller (``DeviceProtocolFactory.create_protocol`` /
+# ``.get_protocol``) working without rewrites.
 DeviceProtocolFactory._PROTOCOL_REGISTRY = {
-    'scsi': lambda di: ScsiProtocol(di.path, di.vid, di.pid),
-    'bulk': lambda di: BulkProtocol(vid=di.vid, pid=di.pid, addr=di.addr),
-    'ly':   lambda di: LyProtocol(vid=di.vid, pid=di.pid, addr=di.addr),
-    'led':  lambda di: LedProtocol(vid=di.vid, pid=di.pid, addr=di.addr),
-    'hid':  lambda di: HidProtocol(vid=di.vid, pid=di.pid, addr=di.addr,
-                device_type=getattr(di, 'device_type', 2)),
+    name: (lambda fc: lambda di: fc().make(di))(factory_cls)
+    for name, factory_cls in ProtocolFactory._registry.items()
 }