transformers-mblt 0.0.0__py3-none-any.whl

transformers_mblt/__init__.py

@@ -0,0 +1,32 @@
+"""Mobilint NPU integrations for Hugging Face Transformers.
+
+Import :mod:`transformers_mblt` and call :func:`register` to make the ``mobilint-*`` model types resolvable by the
+``transformers`` Auto classes, or load ``mobilint/*`` Hub models with ``trust_remote_code=True``.
+"""
+
+from typing import TYPE_CHECKING
+
+__version__ = "0.0.0"
+
+if TYPE_CHECKING:
+    from . import models, utils
+    from ._registry import register
+    from .utils.api import list_models, list_tasks
+
+__all__ = ["__version__", "list_models", "list_tasks", "models", "register", "utils"]
+
+
+def __getattr__(name: str):
+    import importlib
+
+    if name in {"list_models", "list_tasks"}:
+        return getattr(importlib.import_module(".utils.api", __name__), name)
+    if name == "register":
+        return importlib.import_module("._registry", __name__).register
+    if name in {"models", "utils"}:
+        return importlib.import_module(f".{name}", __name__)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))

transformers_mblt/_npu.py

@@ -0,0 +1,43 @@
+"""NPU backend exports used by the Transformers integration.
+
+The backend implementation is maintained by ``mblt-npu-python`` (:mod:`mblt_npu`). This module adds the
+multi-slot ``dispatcher`` property that the Transformers models rely on, without coupling the NPU wheel to
+``transformers``.
+"""
+
+from mblt_npu import (
+    BACKEND_CLASSES,
+    DEFAULT_TARGET_DEVICE,
+    MobilintAriesBackend,
+    MobilintBackendAllocError,
+    MobilintNPUBackend,
+    MobilintRegulusBackend,
+    backend_class_for,
+)
+
+
+def _get_transformers_dispatcher(backend: MobilintNPUBackend):
+    """Return the backend's lazily created :class:`MultiSlotDispatcher`."""
+    # Attribute name is shared with mblt-model-zoo so a backend keeps one dispatcher when both packages are installed.
+    dispatcher = getattr(backend, "_mblt_model_zoo_dispatcher", None)
+    if dispatcher is None:
+        from .utils.multi_slot_dispatch import MultiSlotDispatcher
+
+        dispatcher = MultiSlotDispatcher(backend)
+        backend._mblt_model_zoo_dispatcher = dispatcher
+    return dispatcher
+
+
+# Guarded so installing alongside mblt-model-zoo (which installs the same property) never overrides an existing one.
+if not hasattr(MobilintNPUBackend, "dispatcher"):
+    MobilintNPUBackend.dispatcher = property(_get_transformers_dispatcher)
+
+__all__ = [
+    "BACKEND_CLASSES",
+    "DEFAULT_TARGET_DEVICE",
+    "MobilintBackendAllocError",
+    "MobilintAriesBackend",
+    "MobilintNPUBackend",
+    "MobilintRegulusBackend",
+    "backend_class_for",
+]

transformers_mblt/_registry.py

@@ -0,0 +1,92 @@
+"""Explicit registration of Mobilint architectures with the ``transformers`` Auto classes.
+
+Every ``configuration_*``, ``modeling_*`` and ``processing_*`` module calls ``AutoConfig.register`` /
+``AutoModel*.register`` / ``AutoProcessor.register`` at import time. :func:`register` imports them all so
+``AutoModel*.from_pretrained("mobilint/...")`` resolves the ``mobilint-*`` model types locally, without executing
+the Hub ``proxy_*.py`` remote code.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import warnings
+
+_ARCHITECTURES: tuple[str, ...] = (
+    "llama",
+    "qwen2",
+    "qwen3",
+    "exaone",
+    "exaone4",
+    "cohere2",
+    "bert",
+    "siglip",
+    "blip",
+    "aya_vision",
+    "qwen2_vl",
+    "qwen3_vl",
+    "whisper",
+    "qwen3_asr",
+    "llama_eagle3",
+    "qwen2_eagle3",
+    "qwen3_eagle3",
+)
+_MODULE_KINDS: tuple[str, ...] = ("configuration", "modeling", "processing")
+
+# The Auto registries (CONFIG_MAPPING and the model/processor mappings) live in `transformers.models.auto.*` and are
+# shared by every `transformers` top-level module object, including the fresh `_LazyModule` that Transformers'
+# lazy imports can bind to sys.modules["transformers"] mid-process, so one registration serves them all.
+# Only successfully imported architectures are cached; skipped ones are retried on every call so a later
+# ``register(strict=True)`` still raises for them (and succeeds once their dependency is installed).
+_registered: dict[str, list[str]] = {}
+_warned_skips: set[str] = set()
+
+
+def _architecture_modules(arch: str) -> list[str]:
+    """Return the importable registration modules for ``arch`` in dependency order."""
+    package = importlib.import_module(f"{__package__}.models.{arch}")
+    names = []
+    for kind in _MODULE_KINDS:
+        module_name = f"{package.__name__}.{kind}_{arch}"
+        if importlib.util.find_spec(module_name) is not None:
+            names.append(module_name)
+    return names
+
+
+def register(*, strict: bool = False) -> dict[str, list[str]]:
+    """Import every Mobilint architecture module so the Auto classes know the ``mobilint-*`` model types.
+
+    Architectures that were already registered are not imported again. Architectures that failed to import are
+    retried on every call, so a strict call is never satisfied by an earlier non-strict partial result.
+
+    Args:
+        strict: Re-raise the first import failure instead of warning and skipping that architecture. Architectures
+            such as Qwen3-VL and Qwen3-ASR require newer ``transformers`` releases or optional extras and are
+            skipped otherwise. Each skip is warned about once per process.
+
+    Returns:
+        Mapping of architecture name to the module names that were imported. The same mapping object is returned
+        by every call and grows as previously skipped architectures become importable.
+    """
+    for arch in _ARCHITECTURES:
+        if arch in _registered:
+            continue
+        try:
+            modules = _architecture_modules(arch)
+            for module_name in modules:
+                importlib.import_module(module_name)
+        except ImportError as exc:
+            if strict:
+                raise
+            if arch not in _warned_skips:
+                _warned_skips.add(arch)
+                warnings.warn(f"Skipping Mobilint architecture '{arch}': {exc}", RuntimeWarning, stacklevel=2)
+            continue
+        _registered[arch] = modules
+
+    return _registered
+
+
+def registered_architectures() -> tuple[str, ...]:
+    """Return every architecture name :func:`register` attempts to import."""
+    return _ARCHITECTURES

transformers_mblt/cli/__init__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+__all__ = ["main"]

transformers_mblt/cli/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

transformers_mblt/cli/chat.py

@@ -0,0 +1,38 @@
+from argparse import Namespace
+
+
+def register_mobilint_models(args: Namespace, transformers):
+    """Register Mobilint model classes using the active CLI trust and revision settings."""
+    revision = getattr(args, "model_revision", None)
+    trust_remote_code = getattr(args, "trust_remote_code", False)
+    config = transformers.AutoConfig.from_pretrained(
+        args.model_name_or_path_or_address,
+        revision=revision,
+        trust_remote_code=trust_remote_code,
+    )
+
+    model_type = getattr(config, "model_type", "")
+    arch_name = config.architectures[0] if getattr(config, "architectures", None) else ""
+
+    if model_type.startswith("mobilint-") or arch_name.startswith("Mobilint"):
+        original_model_type = model_type[len("mobilint-") :] if model_type.startswith("mobilint-") else model_type
+        module_model_type = original_model_type.replace("-", "_")
+
+        import importlib
+
+        module = importlib.import_module(f"transformers_mblt.models.{module_model_type}.modeling_{module_model_type}")
+        # Importing the modeling module already registers its Auto classes. The class injection and task-mapping
+        # patch below need a concrete architecture name, so skip them when the config omits `architectures`.
+        if not arch_name:
+            return
+        setattr(transformers, arch_name, module.__dict__[arch_name])
+
+        MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = transformers.models.auto.modeling_auto.MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
+        MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES = (
+            transformers.models.auto.modeling_auto.MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES
+        )
+
+        if arch_name.endswith("CausalLM"):
+            MODEL_FOR_CAUSAL_LM_MAPPING_NAMES[model_type] = arch_name
+        elif arch_name.endswith("ConditionalGeneration"):
+            MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES[model_type] = arch_name

transformers_mblt/cli/list.py

@@ -0,0 +1,56 @@
+"""``transformers-mblt list`` command: list Mobilint Transformers models and tasks."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from typing import Any
+
+
+def add_list_parser(subparsers: Any) -> argparse.ArgumentParser:
+    """Register the ``list`` subcommand."""
+    from ..utils.api import list_tasks
+
+    parser = subparsers.add_parser(
+        "list",
+        help="List Mobilint models on the Hugging Face Hub (falls back to the local cache)",
+        description=(
+            "List Mobilint Transformers models grouped by pipeline task. Queries the Hugging Face Hub and falls "
+            "back to the local Hugging Face cache when the Hub is unreachable."
+        ),
+    )
+    parser.add_argument(
+        "--task",
+        action="append",
+        choices=list_tasks(),
+        default=None,
+        help="Pipeline task to list. Repeat to list several tasks. Default: every supported task.",
+    )
+    parser.add_argument(
+        "--include-private",
+        action="store_true",
+        help="Include private repositories visible to the current Hugging Face token.",
+    )
+    parser.add_argument("--json", action="store_true", help="Print the result as JSON.")
+    parser.add_argument("--tasks", action="store_true", help="Only print the supported task names.")
+    parser.set_defaults(_handler=_cmd_list)
+    return parser
+
+
+def _cmd_list(args: argparse.Namespace) -> int:
+    from ..utils.api import list_models, list_tasks
+
+    if args.tasks:
+        tasks = list_tasks()
+        print(json.dumps(tasks, indent=2) if args.json else "\n".join(tasks))
+        return 0
+
+    models = list_models(args.task or list_tasks(), include_private=args.include_private)
+    if args.json:
+        print(json.dumps(models, indent=2))
+        return 0
+    for task, model_ids in models.items():
+        print(f"{task} ({len(model_ids)})")
+        for model_id in model_ids:
+            print(f"  {model_id}")
+    return 0

transformers_mblt/cli/main.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .list import add_list_parser
+from .tps import add_tps_parser
+from .transformers_compat import dispatch_transformers_cli, is_transformers_cli_command
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="transformers-mblt",
+        description=(
+            "Mobilint NPU helpers for Hugging Face Transformers. Upstream Transformers commands such as "
+            "`chat`, `serve`, `download`, `env`, and `version` are delegated to the installed `transformers` "
+            "package with Mobilint models registered."
+        ),
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {_package_version()}")
+    commands_parser = parser.add_subparsers(help="transformers-mblt command helpers")
+
+    add_list_parser(commands_parser)
+    add_tps_parser(commands_parser)
+
+    return parser
+
+
+def _package_version() -> str:
+    from .. import __version__
+
+    return __version__
+
+
+def main() -> int:
+    # Upstream Transformers commands own their argument parsing, so delegate before argparse sees them.
+    if is_transformers_cli_command(sys.argv):
+        return dispatch_transformers_cli(sys.argv)
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if hasattr(args, "_handler"):
+        return args._handler(args)
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())