mblt-npu-python 0.0.1__tar.gz → 0.1.0__tar.gz

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mblt-npu-python
-Version: 0.0.1
+Version: 0.1.0
 Summary: Shared NPU access for the Mobilint Python packages
 Author: Mobilint
 License: BSD-3-Clause
@@ -18,7 +18,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: <3.13,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mobilint-qb-runtime>=1.0.0
+Requires-Dist: mobilint-qb-runtime>=1.4.0
 Requires-Dist: huggingface-hub
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
@@ -84,9 +84,11 @@ finally:
 
 `MobilintNPUBackend` selects the appropriate implementation from
 `target_device` (default: `"aries-rb"`). `"aries-rb"` selects
-`MobilintAriesBackend`; `"regulus-ra"` and `"regulus-rb"` select
-`MobilintRegulusBackend`. The former generic values `"aries"` and `"regulus"`
-remain accepted when loading older configurations.
+`MobilintAriesBackend`; `"regulus-ra"`, `"regulus-rb"`, `"regulus-ra-usb"`,
+and `"regulus-rb-usb"` select `MobilintRegulusBackend`. The former generic
+values `"aries"` and `"regulus"` remain accepted when loading older
+configurations. The board name is forwarded to `qbruntime.Accelerator` so the
+runtime opens the matching device (requires `mobilint-qb-runtime>=1.4.0`).
 `backend_class_for()` and `BACKEND_CLASSES` are available for integrations that
 need to inspect the supported targets.
 

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/README.md

@@ -56,9 +56,11 @@ finally:
 
 `MobilintNPUBackend` selects the appropriate implementation from
 `target_device` (default: `"aries-rb"`). `"aries-rb"` selects
-`MobilintAriesBackend`; `"regulus-ra"` and `"regulus-rb"` select
-`MobilintRegulusBackend`. The former generic values `"aries"` and `"regulus"`
-remain accepted when loading older configurations.
+`MobilintAriesBackend`; `"regulus-ra"`, `"regulus-rb"`, `"regulus-ra-usb"`,
+and `"regulus-rb-usb"` select `MobilintRegulusBackend`. The former generic
+values `"aries"` and `"regulus"` remain accepted when loading older
+configurations. The board name is forwarded to `qbruntime.Accelerator` so the
+runtime opens the matching device (requires `mobilint-qb-runtime>=1.4.0`).
 `backend_class_for()` and `BACKEND_CLASSES` are available for integrations that
 need to inspect the supported targets.
 

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/mblt_npu/__init__.py

@@ -22,7 +22,7 @@ from .npu_backend import (
 from .logging import log_model_details
 from .onnx_backend import ONNXBackend
 
-__version__ = "0.0.1"
+__version__ = "0.1.0"
 
 __all__ = [
     "BACKEND_CLASSES",

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/mblt_npu/npu_backend.py

@@ -31,7 +31,7 @@ import math
 import os
 import re
 import sys
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Sequence, Union
 
 from huggingface_hub import HfApi, hf_hub_download
 from huggingface_hub.errors import EntryNotFoundError
@@ -74,7 +74,13 @@ def normalize_target_device(target_device: str) -> str:
     normalized = _TARGET_DEVICE_ALIASES.get(
         target_device.lower(), target_device.lower()
     )
-    if normalized not in {"aries-rb", "regulus-ra", "regulus-rb"}:
+    if normalized not in {
+        "aries-rb",
+        "regulus-ra",
+        "regulus-rb",
+        "regulus-ra-usb",
+        "regulus-rb-usb",
+    }:
         raise ValueError(f"unknown target_device {target_device!r}")
     return normalized
 
@@ -194,7 +200,13 @@ class MobilintNPUBackend:
     num_of_cores_in_cluster = 4
 
     default_target_device = DEFAULT_TARGET_DEVICE
-    supported_target_devices = ("aries-rb", "regulus-ra", "regulus-rb")
+    supported_target_devices = (
+        "aries-rb",
+        "regulus-ra",
+        "regulus-rb",
+        "regulus-ra-usb",
+        "regulus-rb-usb",
+    )
 
     def __new__(cls, *args: Any, **kwargs: Any):
         """Select a board-specific backend while retaining the legacy constructor."""
@@ -211,7 +223,7 @@ class MobilintNPUBackend:
         dev_no: Optional[Union[int, List[int]]] = None,
         core_mode: CoreMode = "single",
         target_cores: Optional[List[Union[str, "CoreId"]]] = None,
-        target_clusters: Optional[List[Union[int, str, "Cluster"]]] = None,
+        target_clusters: Optional[Sequence[Union[int, str, "Cluster"]]] = None,
         revision: Optional[str] = None,
         commit_hash: Optional[str] = None,
         target_device: Optional[str] = None,
@@ -300,9 +312,14 @@ class MobilintNPUBackend:
             spec_kwargs["target_cores"] = list(target_cores)
         if target_clusters is not None:
             spec_kwargs["target_clusters"] = list(target_clusters)
+        # Config-layer normalization reads ``target_device`` directly from
+        # ``spec_kwargs``. Setter-chain normalization runs later without
+        # target_device in scope, so seed it on the pending here.
+        spec_kwargs["target_device"] = self.target_device
         initial_spec = NPUTargetSpec.from_kwargs(spec_kwargs)
         self._pending: NPUTargetSpecPending = NPUTargetSpecPending(
-            baseline=initial_spec
+            baseline=initial_spec,
+            target_device=self.target_device,
         )
         self._finalized: Optional[NPUTargetSpec] = initial_spec
 
@@ -337,7 +354,11 @@ class MobilintNPUBackend:
             self._finalized = self._pending.finalize()
             # Close the current override epoch: the next setter chain
             # accumulates on a fresh baseline with all intent flags cleared.
-            self._pending = NPUTargetSpecPending.from_baseline(self._finalized)
+            # Carry ``target_device`` forward so a later setter chain that
+            # re-expands ``dev_no`` sugar still sees the backend's board.
+            self._pending = NPUTargetSpecPending.from_baseline(
+                self._finalized, target_device=self.target_device
+            )
         return self._finalized
 
     # ---- Target-topology accessors ------------------------------------------
@@ -943,7 +964,9 @@ class MobilintNPUBackend:
         if not unique_devs:
             unique_devs = [self._fallback_dev()]
 
-        self.accs = {int(d): Accelerator(int(d)) for d in unique_devs}
+        self.accs = {
+            int(d): Accelerator(self.target_device, int(d)) for d in unique_devs
+        }
         self.mxq_models = []
         self.model_dev_no = []
         self.n_models = 0
@@ -1350,7 +1373,7 @@ class MobilintNPUBackend:
         return result
 
     @target_clusters.setter
-    def target_clusters(self, values: List[Union[int, str, "Cluster"]]) -> None:
+    def target_clusters(self, values: Sequence[Union[int, str, "Cluster"]]) -> None:
         """Record a raw ``target_clusters`` override on the pending accumulator.
 
         Normalization (legacy migration, grain fold/unfold, device-set
@@ -1489,7 +1512,12 @@ class MobilintRegulusBackend(MobilintNPUBackend):
     """Regulus backend: validates its one-core, single/auto-only topology."""
 
     default_target_device = "regulus-ra"
-    supported_target_devices = ("regulus-ra", "regulus-rb")
+    supported_target_devices = (
+        "regulus-ra",
+        "regulus-rb",
+        "regulus-ra-usb",
+        "regulus-rb-usb",
+    )
     num_of_clusters = 1
     num_of_cores_in_cluster = 1
 
@@ -1576,6 +1604,8 @@ BACKEND_CLASSES = {
     "aries-rb": MobilintAriesBackend,
     "regulus-ra": MobilintRegulusBackend,
     "regulus-rb": MobilintRegulusBackend,
+    "regulus-ra-usb": MobilintRegulusBackend,
+    "regulus-rb-usb": MobilintRegulusBackend,
 }
 
 

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/mblt_npu/npu_target.py

@@ -52,11 +52,32 @@ from .core_mode import CoreMode, normalize_core_mode
 # Default device index for ``dev_no`` when the caller does not pin one.
 _DEFAULT_DEV_NO: int = 0
 
+
 # Sentinel used to distinguish "field not overridden this session" from
 # "field explicitly set to None/empty". Kept module-private and reused by
 # both :class:`NPUTargetSpec` (single-call ``_with`` shim) and
 # :class:`NPUTargetSpecPending` (accumulator).
-_UNSET: Any = object()
+#
+# Identity, not equality, is what every ``raw_* is not _UNSET`` check relies
+# on. A bare ``object()`` does not survive ``copy.deepcopy`` as the same
+# instance, and upstream ``transformers.PretrainedConfig.to_dict()`` runs
+# ``copy.deepcopy(self.__dict__)`` on every config it serializes -- including
+# nested sub-configs whose ``npu_backend`` still holds a pending spec with
+# unresolved ``_UNSET`` slots. That deep-copied sentinel then fails every
+# ``is not _UNSET`` check, so callers see a bogus "overridden" field. Make the
+# sentinel copy/deepcopy to itself so its identity survives that path.
+class _UnsetType:
+    def __repr__(self) -> str:
+        return "_UNSET"
+
+    def __copy__(self) -> "_UnsetType":
+        return self
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "_UnsetType":
+        return self
+
+
+_UNSET: Any = _UnsetType()
 
 
 cluster_map: Dict[int, "Cluster"] = {
@@ -110,6 +131,33 @@ _VALID_CLUSTER_INDICES: frozenset = frozenset(cluster_map.keys())
 _VALID_CORE_INDICES: frozenset = frozenset(core_map.keys())
 
 
+def _topology_for_target(target_device: Optional[str]) -> tuple[int, int]:
+    """Return ``(num_clusters, num_cores_per_cluster)`` for a board identifier.
+
+    Consumed by :func:`_resolve_targets` when expanding ``dev_no`` sugar into
+    a default target-core / target-cluster list: without a board-appropriate
+    topology, a Regulus config that names only ``target_device`` would be
+    populated with Aries's 2×4 grid and then rejected by
+    :class:`MobilintRegulusBackend` for referencing cores its single-cluster
+    hardware does not have.
+
+    Args:
+        target_device: The board identifier from the caller's config
+            (``"aries-rb"``, ``"regulus-rb-usb"``, legacy ``"aries"`` /
+            ``"regulus"``, ...), or ``None`` when the caller has not
+            declared one. Case-insensitive.
+
+    Returns:
+        ``(2, 4)`` for Aries (and the historical unspecified default so
+        callers with legacy configs keep the same sugar expansion); ``(1, 1)``
+        for every Regulus variant (RA / RB / RA-USB / RB-USB, the ``regulus``
+        family alias, and any future ``regulus-*`` addition).
+    """
+    if target_device and target_device.lower().startswith("regulus"):
+        return (1, 1)
+    return (2, 4)
+
+
 def _check_cluster_core_indices(c_val: int, k_val: int, entry: Any) -> None:
     """Raise ``ValueError`` when ``c_val`` / ``k_val`` fall outside the Aries2 topology."""
     if (
@@ -453,6 +501,16 @@ class NPUTargetSpec:
     _pending: Optional["NPUTargetSpecPending"] = field(
         default=None, compare=False, hash=False, repr=False
     )
+    # Board identifier carried alongside the canonical fields so a subsequent
+    # :meth:`_with` (or a fresh :class:`NPUTargetSpecPending` derived from
+    # this spec) still knows which topology to use when ``dev_no`` sugar has
+    # to re-expand. Excluded from equality/hash/repr because it is not part
+    # of the canonical ``(dev_no, core_mode, cores, clusters)`` identity —
+    # two Aries specs with identical grain must still compare equal even if
+    # only one of them recorded ``target_device``.
+    target_device: Optional[str] = field(
+        default=None, compare=False, hash=False, repr=False
+    )
 
     @property
     def _dev_no_overridden(self) -> bool:
@@ -518,6 +576,7 @@ class NPUTargetSpec:
         dev_no_key = f"{prefix}dev_no"
         cores_key = f"{prefix}target_cores"
         clusters_key = f"{prefix}target_clusters"
+        target_device_key = f"{prefix}target_device"
 
         core_mode = normalize_core_mode(kwargs.get(core_mode_key, "single"))
         dev_no = _dedup_dev_no(kwargs.get(dev_no_key, _DEFAULT_DEV_NO))
@@ -525,6 +584,7 @@ class NPUTargetSpec:
         dev_list = _normalize_dev_list(dev_no)
         fallback_dev = dev_list[0]
         dev_no_given = dev_no_key in kwargs
+        target_device = kwargs.get(target_device_key)
 
         raw_cores = kwargs.get(cores_key)
         raw_clusters = kwargs.get(clusters_key)
@@ -537,6 +597,7 @@ class NPUTargetSpec:
             dev_no_given=dev_no_given,
             raw_cores=list(raw_cores) if raw_cores else [],
             raw_clusters=list(raw_clusters) if raw_clusters else [],
+            target_device=target_device,
         )
 
         # Mutate the caller's ``kwargs`` dict in place for downstream code
@@ -566,6 +627,7 @@ class NPUTargetSpec:
             core_mode=core_mode,
             cores=tuple(cores),
             clusters=tuple(clusters),
+            target_device=target_device,
         )
 
     def _with(
@@ -606,7 +668,10 @@ class NPUTargetSpec:
                 :meth:`NPUTargetSpecPending.finalize`.
         """
         if self._pending is None:
-            base_pending = NPUTargetSpecPending(baseline=replace(self, _pending=None))
+            base_pending = NPUTargetSpecPending(
+                baseline=replace(self, _pending=None),
+                target_device=self.target_device,
+            )
         else:
             base_pending = self._pending
         new_pending = base_pending._with(
@@ -663,6 +728,7 @@ def _resolve_targets(
     dev_no_given: bool,
     raw_cores: List[Any],
     raw_clusters: List[Any],
+    target_device: Optional[str] = None,
 ) -> tuple[List[str], List[str]]:
     """Canonicalize a ``(dev_no, core_mode, cores, clusters)`` payload.
 
@@ -700,11 +766,24 @@ def _resolve_targets(
     )
 
     if not cores and not clusters:
-        # ``dev_no`` sugar expansion when both target lists are absent.
+        # ``dev_no`` sugar expansion when both target lists are absent. The
+        # topology is board-dependent: Aries exposes 2 clusters × 4 cores per
+        # device, Regulus exposes 1 cluster × 1 core. Without threading
+        # ``target_device`` here, a Regulus config that only names
+        # ``target_device`` receives Aries's 8-core grid and later fails
+        # :class:`MobilintRegulusBackend`'s topology check.
+        num_clusters, num_cores = _topology_for_target(target_device)
         if core_mode == "single":
-            cores = [f"{d}:{c}:{k}" for d in dev_list for c in (0, 1) for k in range(4)]
+            cores = [
+                f"{d}:{c}:{k}"
+                for d in dev_list
+                for c in range(num_clusters)
+                for k in range(num_cores)
+            ]
         else:
-            clusters = [f"{d}:{c}" for d in dev_list for c in (0, 1)]
+            clusters = [
+                f"{d}:{c}" for d in dev_list for c in range(num_clusters)
+            ]
     else:
         # Grain unification per core_mode.
         if core_mode == "single":
@@ -776,6 +855,13 @@ class NPUTargetSpecPending:
             strings, or canonical ``"d:c:k"`` strings), or :data:`_UNSET`.
         raw_clusters: The caller's raw ``target_clusters`` override, or
             :data:`_UNSET`.
+        target_device: Board identifier carried alongside the override
+            history so :meth:`finalize` can pick the right ``dev_no`` sugar
+            topology (Aries 2×4 vs Regulus 1×1). Attached by the backend at
+            init time (and preserved across chained :meth:`_with` /
+            :meth:`from_baseline` calls) because the spec-level normalization
+            layer sees target_device only at the config-load entry point;
+            per-field setter chains would otherwise lose it.
     """
 
     baseline: NPUTargetSpec
@@ -783,9 +869,15 @@ class NPUTargetSpecPending:
     raw_core_mode: Any = _UNSET
     raw_cores: Any = _UNSET
     raw_clusters: Any = _UNSET
+    target_device: Optional[str] = None
 
     @classmethod
-    def from_baseline(cls, spec: NPUTargetSpec) -> "NPUTargetSpecPending":
+    def from_baseline(
+        cls,
+        spec: NPUTargetSpec,
+        *,
+        target_device: Optional[str] = None,
+    ) -> "NPUTargetSpecPending":
         """Return a fresh pending baseline for the next override epoch.
 
         :class:`MobilintNPUBackend` calls this immediately after materializing
@@ -801,13 +893,21 @@ class NPUTargetSpecPending:
             spec: Canonical :class:`NPUTargetSpec` to seed the fresh pending's
                 baseline with. Typically the finalized result of the previous
                 override epoch.
+            target_device: Board identifier attached to the fresh pending so
+                :meth:`finalize` picks the right ``dev_no`` sugar topology.
+                Defaults to ``spec.target_device`` so callers that omit it
+                (or specs constructed outside the backend) still keep their
+                board; the backend's explicit override wins when provided.
 
         Returns:
             A new :class:`NPUTargetSpecPending` whose baseline is ``spec``
             (with any prior ``_pending`` history stripped) and whose intent
             slots are all :data:`_UNSET`.
         """
-        return cls(baseline=replace(spec, _pending=None))
+        return cls(
+            baseline=replace(spec, _pending=None),
+            target_device=target_device if target_device is not None else spec.target_device,
+        )
 
     def _with(
         self,
@@ -941,6 +1041,7 @@ class NPUTargetSpecPending:
             dev_no_given=dev_no_overridden,
             raw_cores=raw_cores,
             raw_clusters=raw_clusters,
+            target_device=self.target_device,
         )
 
         # Resolve the effective ``dev_no`` for the returned canonical spec.
@@ -962,6 +1063,7 @@ class NPUTargetSpecPending:
             cores=tuple(cores),
             clusters=tuple(clusters),
             _pending=self,
+            target_device=self.target_device,
         )
 
 

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/mblt_npu_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mblt-npu-python
-Version: 0.0.1
+Version: 0.1.0
 Summary: Shared NPU access for the Mobilint Python packages
 Author: Mobilint
 License: BSD-3-Clause
@@ -18,7 +18,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: <3.13,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mobilint-qb-runtime>=1.0.0
+Requires-Dist: mobilint-qb-runtime>=1.4.0
 Requires-Dist: huggingface-hub
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
@@ -84,9 +84,11 @@ finally:
 
 `MobilintNPUBackend` selects the appropriate implementation from
 `target_device` (default: `"aries-rb"`). `"aries-rb"` selects
-`MobilintAriesBackend`; `"regulus-ra"` and `"regulus-rb"` select
-`MobilintRegulusBackend`. The former generic values `"aries"` and `"regulus"`
-remain accepted when loading older configurations.
+`MobilintAriesBackend`; `"regulus-ra"`, `"regulus-rb"`, `"regulus-ra-usb"`,
+and `"regulus-rb-usb"` select `MobilintRegulusBackend`. The former generic
+values `"aries"` and `"regulus"` remain accepted when loading older
+configurations. The board name is forwarded to `qbruntime.Accelerator` so the
+runtime opens the matching device (requires `mobilint-qb-runtime>=1.4.0`).
 `backend_class_for()` and `BACKEND_CLASSES` are available for integrations that
 need to inspect the supported targets.
 

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/mblt_npu_python.egg-info/requires.txt

@@ -1,4 +1,4 @@
-mobilint-qb-runtime>=1.0.0
+mobilint-qb-runtime>=1.4.0
 huggingface-hub
 
 [onnxruntime]

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "Shared NPU access for the Mobilint Python packages"
 readme = "README.md"
 dependencies = [
-    "mobilint-qb-runtime>=1.0.0",
+    "mobilint-qb-runtime>=1.4.0",
     "huggingface-hub",
 ]
 requires-python = ">=3.10,<3.13"

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/tests/test_npu_backend_multi_slot.py

@@ -28,9 +28,10 @@ from mblt_npu.npu_backend import (
 
 
 class _FakeAccelerator:
-    """Records the device number an accelerator was opened for."""
+    """Records the target device name and device number an accelerator was opened for."""
 
-    def __init__(self, dev_no: int) -> None:
+    def __init__(self, target_device: str, dev_no: int) -> None:
+        self.target_device = target_device
         self.dev_no = int(dev_no)
 
 

{mblt_npu_python-0.0.1 → mblt_npu_python-0.1.0}/tests/test_target_device.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import copy
 from pathlib import Path
 from typing import Any, cast
 
@@ -9,6 +10,7 @@ import pytest
 
 from mblt_npu import MobilintAriesBackend, MobilintNPUBackend, MobilintRegulusBackend
 import mblt_npu.npu_backend as npu_backend
+from mblt_npu.npu_target import _UNSET, NPUTargetSpec
 
 
 @pytest.mark.parametrize(
@@ -17,6 +19,8 @@ import mblt_npu.npu_backend as npu_backend
         ("aries-rb", MobilintAriesBackend),
         ("regulus-ra", MobilintRegulusBackend),
         ("regulus-rb", MobilintRegulusBackend),
+        ("regulus-ra-usb", MobilintRegulusBackend),
+        ("regulus-rb-usb", MobilintRegulusBackend),
     ],
 )
 def test_target_device_selects_the_product_backend(
@@ -31,6 +35,40 @@ def test_target_device_selects_the_product_backend(
     assert backend.to_dict()["target_device"] == target_device
 
 
+def test_unset_sentinel_survives_deepcopy() -> None:
+    """Keep the ``_UNSET`` sentinel's identity across ``copy.deepcopy``.
+
+    ``transformers.PretrainedConfig.to_dict()`` runs ``copy.deepcopy(self.__dict__)``
+    on every config it serializes, including nested sub-configs whose
+    ``npu_backend`` still holds unresolved ``_UNSET`` slots. A bare ``object()``
+    sentinel would be reconstructed as a distinct instance there, so every
+    ``is not _UNSET`` override check on the copy would wrongly report the
+    field as overridden.
+    """
+
+    assert copy.deepcopy(_UNSET) is _UNSET
+    assert copy.copy(_UNSET) is _UNSET
+
+
+def test_backend_survives_deepcopy_before_finalization() -> None:
+    """Finalize identically after a deepcopy taken before the next ``_spec`` read.
+
+    Reproduces the HF ``PretrainedConfig.to_dict()`` path: overriding one field
+    (``target_clusters``) invalidates ``_finalized`` without touching the other
+    fields' still-``_UNSET`` raw slots. Deep-copying the backend in that state
+    (as upstream does for nested sub-configs, before their own ``to_dict()``
+    ever ran) must not corrupt those slots when the copy is finalized.
+    """
+
+    backend = MobilintAriesBackend()
+    backend.target_clusters = [0, 1]
+    assert backend._finalized is None
+
+    copied = copy.deepcopy(backend)
+
+    assert copied.to_dict() == backend.to_dict()
+
+
 def test_default_target_device_is_aries_rb() -> None:
     """Use Aries RB when callers do not declare a board."""
 
@@ -40,7 +78,10 @@ def test_default_target_device_is_aries_rb() -> None:
     assert backend.target_device == "aries-rb"
 
 
-@pytest.mark.parametrize("target_device", ["regulus-ra", "regulus-rb"])
+@pytest.mark.parametrize(
+    "target_device",
+    ["regulus-ra", "regulus-rb", "regulus-ra-usb", "regulus-rb-usb"],
+)
 def test_positional_target_device_selects_the_product_backend(
     target_device: str,
 ) -> None:
@@ -376,3 +417,145 @@ def test_regulus_auto_positional_empty_cluster_targets_are_canonicalized() -> No
     backend = MobilintRegulusBackend("", 0, "auto", None, [])
 
     assert backend.to_dict()["target_clusters"] == ["0:0"]
+
+
+@pytest.mark.parametrize(
+    "target_device",
+    ["regulus-ra", "regulus-rb", "regulus-ra-usb", "regulus-rb-usb"],
+)
+def test_regulus_dev_no_sugar_expands_to_single_core(target_device: str) -> None:
+    """Expand Regulus ``dev_no`` sugar to its one-core topology, not Aries's grid.
+
+    Without target-device-aware sugar expansion, a Regulus config that only
+    names ``target_device`` receives Aries's 2 clusters × 4 cores default
+    and is then rejected by :class:`MobilintRegulusBackend`'s topology check.
+    Every Regulus board (PCIe and USB) must produce a single ``d:0:0`` core.
+    """
+
+    backend = MobilintNPUBackend(target_device=target_device)
+
+    assert isinstance(backend, MobilintRegulusBackend)
+    assert backend.to_dict()["target_cores"] == ["0:0:0"]
+
+
+def test_regulus_dev_no_sugar_respects_device_list() -> None:
+    """Expand Regulus ``dev_no=[0, 1]`` sugar to one core per named device."""
+
+    backend = MobilintNPUBackend(target_device="regulus-rb-usb", dev_no=[0, 1])
+
+    assert set(backend.to_dict()["target_cores"]) == {"0:0:0", "1:0:0"}
+
+
+@pytest.mark.parametrize(
+    "target_device",
+    ["regulus-ra", "regulus-rb", "regulus-ra-usb", "regulus-rb-usb"],
+)
+def test_from_kwargs_sugar_uses_regulus_topology(target_device: str) -> None:
+    """Populate ``dev_no`` sugar with Regulus topology at the config layer.
+
+    Direct :meth:`NPUTargetSpec.from_kwargs` exercises the sugar-expansion
+    branch that Model Zoo hits before the concrete backend __init__ can
+    populate its own single-core default: when the config layer sees only
+    ``target_device`` (no ``target_cores`` / ``target_clusters``), the spec
+    must emit ``["0:0:0"]`` for every Regulus board so a subsequent
+    :class:`MobilintRegulusBackend` construction accepts the pre-populated
+    grain.
+    """
+
+    spec = NPUTargetSpec.from_kwargs(
+        {"target_device": target_device, "core_mode": "single"}
+    )
+
+    assert list(spec.cores) == ["0:0:0"]
+
+
+@pytest.mark.parametrize(
+    "target_device",
+    ["regulus-ra", "regulus-rb", "regulus-ra-usb", "regulus-rb-usb"],
+)
+def test_spec_with_override_preserves_regulus_topology(target_device: str) -> None:
+    """Keep a Regulus spec's board identity across a derived ``_with`` override.
+
+    Regression for the case where ``NPUTargetSpec.from_kwargs`` set
+    ``target_device`` only on the fresh pending and lost it on the returned
+    spec. A follow-up ``spec._with(dev_no=...)`` then created a new pending
+    with ``target_device=None``, and the sugar re-expansion produced Aries's
+    2×4 grid, which :class:`MobilintRegulusBackend` would then reject for
+    referencing cores its single-cluster hardware does not have.
+    """
+
+    root = NPUTargetSpec.from_kwargs(
+        {"target_device": target_device, "core_mode": "single"}
+    )
+    assert root.target_device == target_device
+
+    derived = root._with(dev_no=1)
+
+    assert derived.target_device == target_device
+    assert list(derived.cores) == ["1:0:0"]
+
+
+def test_from_kwargs_sugar_uses_aries_topology_by_default() -> None:
+    """Fall back to Aries 2×4 sugar when no ``target_device`` is declared.
+
+    Callers with legacy configs that never named a board must keep receiving
+    the historical 8-core Aries default; :func:`_topology_for_target` treats
+    ``None`` and any non-Regulus string as Aries.
+    """
+
+    spec = NPUTargetSpec.from_kwargs({"core_mode": "single"})
+
+    assert len(spec.cores) == 8
+    assert list(spec.cores) == [
+        "0:0:0",
+        "0:0:1",
+        "0:0:2",
+        "0:0:3",
+        "0:1:0",
+        "0:1:1",
+        "0:1:2",
+        "0:1:3",
+    ]
+
+
+@pytest.mark.parametrize(
+    "target_device",
+    ["aries-rb", "regulus-ra", "regulus-rb", "regulus-ra-usb", "regulus-rb-usb"],
+)
+def test_create_passes_target_device_to_accelerator(
+    monkeypatch: pytest.MonkeyPatch, target_device: str
+) -> None:
+    """Forward the resolved board name to ``qbruntime.Accelerator``.
+
+    ``qbruntime>=1.4`` selects the physical device from the target-device
+    string passed as the first positional argument. Regressing that call
+    would silently strand USB and Regulus workloads on the default
+    accelerator, so pin the argument shape explicitly.
+    """
+
+    captured: list[tuple[Any, ...]] = []
+
+    class _Acc:
+        def __init__(self, *args: Any) -> None:
+            captured.append(args)
+
+        def dispose(self) -> None:
+            pass
+
+    class _StopCreate(Exception):
+        pass
+
+    def _no_model(*_args: Any, **_kwargs: Any) -> None:
+        raise _StopCreate
+
+    monkeypatch.setattr(npu_backend, "Accelerator", _Acc)
+    monkeypatch.setattr(npu_backend, "Model", _no_model)
+    monkeypatch.setattr(
+        npu_backend.MobilintNPUBackend, "check_model_path", lambda self, path: path
+    )
+
+    backend = MobilintNPUBackend(mxq_path="m.mxq", target_device=target_device, dev_no=0)
+    with pytest.raises(_StopCreate):
+        backend.create()
+
+    assert captured == [(target_device, 0)]