siglip2-toolkit 0.0.1__tar.gz

siglip2_toolkit-0.0.1/.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+
+# Tooling
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+coverage.xml
+
+# Editors / OS
+.idea/
+.vscode/
+.DS_Store

siglip2_toolkit-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GIA-UH (Universidad de La Habana) and Syalia S.R.L.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

siglip2_toolkit-0.0.1/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.5
+Name: siglip2-toolkit
+Version: 0.0.1
+Summary: Local-first toolkit around Google's SigLIP 2 models: text/image embeddings, zero-shot and fine-tuned classification, incremental corpus export and retrieval math. Library-first, with CLI and REST interfaces.
+Project-URL: Homepage, https://github.com/gia-uh/siglip2-toolkit
+Project-URL: Repository, https://github.com/gia-uh/siglip2-toolkit
+Project-URL: Issues, https://github.com/gia-uh/siglip2-toolkit/issues
+Author-email: Yudivián Almeida Cruz <yudivian@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: embeddings,image-classification,image-retrieval,image-search,local-first,siglip2
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: >=3.12
+Requires-Dist: huggingface-hub>=0.23
+Requires-Dist: numpy>=1.26
+Requires-Dist: pillow-heif>=0.16
+Requires-Dist: pillow>=10.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: torch>=2.2
+Requires-Dist: tqdm>=4.60
+Requires-Dist: transformers>=4.51
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.115; extra == 'server'
+Requires-Dist: python-multipart>=0.0.9; extra == 'server'
+Requires-Dist: uvicorn[standard]>=0.30; extra == 'server'
+Description-Content-Type: text/markdown
+
+# siglip2-toolkit
+
+Local-first toolkit around Google's **SigLIP 2** models: text/image embeddings, zero-shot and fine-tuned classification, incremental corpus export, and retrieval math.
+
+It is **not a vector database**: it produces embeddings and portable exports, and stays agnostic about where you store or search your vectors.
+
+Co-developed by [GIA-UH](https://github.com/gia-uh) and [Syalia S.R.L.](https://github.com/syalia-srl).
+
+## Installation
+
+```bash
+pip install siglip2-toolkit             # library + CLI
+pip install "siglip2-toolkit[server]"   # + REST server (FastAPI)
+```
+
+## Model management (the toolkit's own cache)
+
+Models live in the toolkit's **own cache**, independent from HuggingFace's
+cache. The only command that uses the network is `models download`;
+everything else works with what you already have locally.
+
+```bash
+siglip2 models                       # your cache (★ model in use, origin, size)
+siglip2 models --hf                  # SigLIP-2 catalog on HuggingFace: ✓ have it / ☁ downloadable
+siglip2 models current               # the model in use (+ path, origin; --json)
+siglip2 models use <id>              # set the model in use (persistent)
+siglip2 models download <org/name> [--revision REV]   # into the toolkit cache (network)
+siglip2 models import <path> [--name ALIAS]           # copy a local model into the cache
+siglip2 models delete <id>           # delete from the cache (refuses the model in use)
+```
+
+Configuration lives in `<home>/config.json` (default home
+`~/.local/share/siglip2-toolkit/`, created on first use):
+
+```json
+{
+  "cache_dir": "~/.local/share/siglip2-toolkit/models",
+  "current": "google/siglip2-base-patch16-naflex",
+  "device": "auto"
+}
+```
+
+- **`cache_dir`**: where the cache lives; change it to relocate it (e.g. another disk).
+- **`current`**: the model in use.
+- **`device`**: `auto` (CUDA → MPS → CPU), or `cuda`, `cpu`, `mps`, `cuda:1`, …
+  Any command's `--device` overrides it for that run.
+
+There are **no environment variables**; for non-default installations pass
+`--home DIR` (global option, before the command).
+
+`--model` accepts either an identifier from your cache or a path to a local
+model directory. The implicit default is
+`google/siglip2-base-patch16-naflex`: on a machine that does not have it yet,
+the first command tells you the exact `models download` to run. The toolkit
+never picks a model for you.
+
+Incremental exports refuse to run when the existing export was produced by a
+different model: mixing embedding spaces would silently corrupt the vectors.
+
+## Three ways to use it
+
+**1. As a library (primary interface)**
+
+```python
+from siglip2_toolkit import Embedder, models
+
+# Resolve from your cache (download/import first) or pass a local path.
+resolved = models.resolve_model("google/siglip2-base-patch16-naflex")
+embedder = Embedder(model=resolved.path, model_id=resolved.identifier, device="auto")
+
+vectors = embedder.embed_texts(["a wedding at sunset"])
+results = embedder.classify(["photo.jpg"], labels=["beach", "mountain", "wedding"])
+
+from siglip2_toolkit.filters import field, matches
+
+matches({"width": 2400}, field("width") >= 2000)  # -> True
+```
+
+**2. As a CLI**
+
+```bash
+siglip2 models download google/siglip2-base-patch16-naflex
+siglip2 models use google/siglip2-base-patch16-naflex
+siglip2 export -i /path/to/photos -o embeddings.jsonl --incremental
+siglip2 classify --image photo.jpg --labels "beach,mountain,wedding"
+```
+
+**3. As a REST service (optional extra)**
+
+```bash
+pip install "siglip2-toolkit[server]"
+siglip2 serve --host 0.0.0.0 --port 8000
+```
+
+Endpoints: `/v1/embed/text`, `/v1/embed/image`, `/v1/classify`, `/v1/health`, `/v1/info`.
+
+## Highlights
+
+- **Library-first design**: the CLI and the REST server are thin adapters over the same public API.
+- **Zero-shot classification**: prompt-based labels using the model's calibrated SigLIP logits, plus fine-tuned classification heads (`ImageClassifier`).
+- **Own model cache**: downloads and imports live in the toolkit cache (independent from HuggingFace's); only `models download` uses the network.
+- **GPU-ready**: `device: "auto"` picks CUDA when available (FP16; FP32 on CPU); override per command with `--device`.
+- **Incremental export**: new, modified and deleted files are detected (modification detection requires metadata).
+- **Resumable runs**: interrupted exports continue where they left off.
+- **Optional metadata**: rich file metadata (EXIF, dimensions, timestamps, thumbnails) — or ids and vectors only, your choice.
+- **Versioned export format** (`jsonl` / `pkl`) with an embedding-space manifest.
+- **Retrieval math**: top-k scoring, RRF fusion, similarity-drop filtering and serializable metadata filters, composable with any store.
+
+> **Status:** first preview (0.0.1, October 2026). The public API and the
+export format may still change before 1.0; pin the version you depend on.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

siglip2_toolkit-0.0.1/README.md

@@ -0,0 +1,114 @@
+# siglip2-toolkit
+
+Local-first toolkit around Google's **SigLIP 2** models: text/image embeddings, zero-shot and fine-tuned classification, incremental corpus export, and retrieval math.
+
+It is **not a vector database**: it produces embeddings and portable exports, and stays agnostic about where you store or search your vectors.
+
+Co-developed by [GIA-UH](https://github.com/gia-uh) and [Syalia S.R.L.](https://github.com/syalia-srl).
+
+## Installation
+
+```bash
+pip install siglip2-toolkit             # library + CLI
+pip install "siglip2-toolkit[server]"   # + REST server (FastAPI)
+```
+
+## Model management (the toolkit's own cache)
+
+Models live in the toolkit's **own cache**, independent from HuggingFace's
+cache. The only command that uses the network is `models download`;
+everything else works with what you already have locally.
+
+```bash
+siglip2 models                       # your cache (★ model in use, origin, size)
+siglip2 models --hf                  # SigLIP-2 catalog on HuggingFace: ✓ have it / ☁ downloadable
+siglip2 models current               # the model in use (+ path, origin; --json)
+siglip2 models use <id>              # set the model in use (persistent)
+siglip2 models download <org/name> [--revision REV]   # into the toolkit cache (network)
+siglip2 models import <path> [--name ALIAS]           # copy a local model into the cache
+siglip2 models delete <id>           # delete from the cache (refuses the model in use)
+```
+
+Configuration lives in `<home>/config.json` (default home
+`~/.local/share/siglip2-toolkit/`, created on first use):
+
+```json
+{
+  "cache_dir": "~/.local/share/siglip2-toolkit/models",
+  "current": "google/siglip2-base-patch16-naflex",
+  "device": "auto"
+}
+```
+
+- **`cache_dir`**: where the cache lives; change it to relocate it (e.g. another disk).
+- **`current`**: the model in use.
+- **`device`**: `auto` (CUDA → MPS → CPU), or `cuda`, `cpu`, `mps`, `cuda:1`, …
+  Any command's `--device` overrides it for that run.
+
+There are **no environment variables**; for non-default installations pass
+`--home DIR` (global option, before the command).
+
+`--model` accepts either an identifier from your cache or a path to a local
+model directory. The implicit default is
+`google/siglip2-base-patch16-naflex`: on a machine that does not have it yet,
+the first command tells you the exact `models download` to run. The toolkit
+never picks a model for you.
+
+Incremental exports refuse to run when the existing export was produced by a
+different model: mixing embedding spaces would silently corrupt the vectors.
+
+## Three ways to use it
+
+**1. As a library (primary interface)**
+
+```python
+from siglip2_toolkit import Embedder, models
+
+# Resolve from your cache (download/import first) or pass a local path.
+resolved = models.resolve_model("google/siglip2-base-patch16-naflex")
+embedder = Embedder(model=resolved.path, model_id=resolved.identifier, device="auto")
+
+vectors = embedder.embed_texts(["a wedding at sunset"])
+results = embedder.classify(["photo.jpg"], labels=["beach", "mountain", "wedding"])
+
+from siglip2_toolkit.filters import field, matches
+
+matches({"width": 2400}, field("width") >= 2000)  # -> True
+```
+
+**2. As a CLI**
+
+```bash
+siglip2 models download google/siglip2-base-patch16-naflex
+siglip2 models use google/siglip2-base-patch16-naflex
+siglip2 export -i /path/to/photos -o embeddings.jsonl --incremental
+siglip2 classify --image photo.jpg --labels "beach,mountain,wedding"
+```
+
+**3. As a REST service (optional extra)**
+
+```bash
+pip install "siglip2-toolkit[server]"
+siglip2 serve --host 0.0.0.0 --port 8000
+```
+
+Endpoints: `/v1/embed/text`, `/v1/embed/image`, `/v1/classify`, `/v1/health`, `/v1/info`.
+
+## Highlights
+
+- **Library-first design**: the CLI and the REST server are thin adapters over the same public API.
+- **Zero-shot classification**: prompt-based labels using the model's calibrated SigLIP logits, plus fine-tuned classification heads (`ImageClassifier`).
+- **Own model cache**: downloads and imports live in the toolkit cache (independent from HuggingFace's); only `models download` uses the network.
+- **GPU-ready**: `device: "auto"` picks CUDA when available (FP16; FP32 on CPU); override per command with `--device`.
+- **Incremental export**: new, modified and deleted files are detected (modification detection requires metadata).
+- **Resumable runs**: interrupted exports continue where they left off.
+- **Optional metadata**: rich file metadata (EXIF, dimensions, timestamps, thumbnails) — or ids and vectors only, your choice.
+- **Versioned export format** (`jsonl` / `pkl`) with an embedding-space manifest.
+- **Retrieval math**: top-k scoring, RRF fusion, similarity-drop filtering and serializable metadata filters, composable with any store.
+
+> **Status:** first preview (0.0.1, October 2026). The public API and the
+export format may still change before 1.0; pin the version you depend on.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

siglip2_toolkit-0.0.1/pyproject.toml

@@ -0,0 +1,82 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "siglip2-toolkit"
+version = "0.0.1"
+description = "Local-first toolkit around Google's SigLIP 2 models: text/image embeddings, zero-shot and fine-tuned classification, incremental corpus export and retrieval math. Library-first, with CLI and REST interfaces."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Yudivián Almeida Cruz", email = "yudivian@gmail.com" },
+]
+keywords = [
+    "siglip2",
+    "embeddings",
+    "image-search",
+    "image-classification",
+    "image-retrieval",
+    "local-first",
+]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Graphics",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+]
+
+dependencies = [
+    "numpy>=1.26",
+    "torch>=2.2",
+    "transformers>=4.51",
+    "huggingface_hub>=0.23",
+    "Pillow>=10.0",
+    "pillow-heif>=0.16",
+    "PyYAML>=6.0",
+    "tqdm>=4.60",
+]
+
+[project.optional-dependencies]
+server = [
+    "fastapi>=0.115",
+    "uvicorn[standard]>=0.30",
+    "python-multipart>=0.0.9",
+]
+dev = [
+    "pytest>=8",
+    "pytest-cov>=5",
+    "ruff>=0.6",
+]
+
+[project.scripts]
+siglip2 = "siglip2_toolkit.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/gia-uh/siglip2-toolkit"
+Repository = "https://github.com/gia-uh/siglip2-toolkit"
+Issues = "https://github.com/gia-uh/siglip2-toolkit/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/siglip2_toolkit"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+markers = [
+    "integration: requires torch and a cached SigLIP 2 model; enabled with SIGLIP2_INTEGRATION=1",
+]

siglip2_toolkit-0.0.1/src/siglip2_toolkit/__init__.py

@@ -0,0 +1,71 @@
+"""siglip2-toolkit — local-first toolkit around Google's SigLIP 2 models.
+
+The package is deliberately lazy: importing :mod:`siglip2_toolkit` does not
+import torch, transformers or FastAPI. Heavy modules are loaded on first
+attribute access, so tooling and metadata inspection stay fast::
+
+    from siglip2_toolkit import Embedder
+
+    embedder = Embedder(model="google/siglip2-base-patch16-naflex", device="auto")
+    vectors = embedder.embed_texts(["a wedding at sunset"])
+"""
+
+from importlib import import_module
+
+try:
+    from importlib.metadata import version as _dist_version
+
+    __version__ = _dist_version("siglip2-toolkit")
+except Exception:  # pragma: no cover - source checkout without installed metadata
+    __version__ = "0.0.1"
+
+#: Lazy attributes: name -> (relative module, attribute or None for the module itself)
+_LAZY_ATTRS: dict[str, tuple[str, str | None]] = {
+    # Public API
+    "Embedder": (".embedder", "Embedder"),
+    "Exporter": (".exporter", "Exporter"),
+    "ExportConfig": (".exporter", "ExportConfig"),
+    "ExportResult": (".exporter", "ExportResult"),
+    "EmbeddingSpace": (".formats", "EmbeddingSpace"),
+    "ImageClassifier": (".classification", "ImageClassifier"),
+    "Filter": (".filters", "Filter"),
+    "field": (".filters", "field"),
+    # Submodules
+    "formats": (".formats", None),
+    "retrieval": (".retrieval", None),
+    "filters": (".filters", None),
+    "models": (".models", None),
+    "utils": (".utils", None),
+    "embedder": (".embedder", None),
+    "exporter": (".exporter", None),
+    "classification": (".classification", None),
+    "cli": (".cli", None),
+    "server": (".server", None),
+}
+
+__all__ = [
+    "Embedder",
+    "Exporter",
+    "ExportConfig",
+    "ExportResult",
+    "EmbeddingSpace",
+    "ImageClassifier",
+    "Filter",
+    "field",
+    "__version__",
+]
+
+
+def __getattr__(name: str):
+    try:
+        module_name, attr = _LAZY_ATTRS[name]
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+    module = import_module(module_name, __name__)
+    value = module if attr is None else getattr(module, attr)
+    globals()[name] = value  # cache for subsequent lookups
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_LAZY_ATTRS))

siglip2_toolkit-0.0.1/src/siglip2_toolkit/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m siglip2_toolkit`` as an alias for the ``siglip2`` CLI."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

siglip2_toolkit-0.0.1/src/siglip2_toolkit/classification.py

@@ -0,0 +1,161 @@
+"""Fine-tuned image classification with SigLIP-family checkpoints.
+
+Zero-shot classification (prompt-based) lives on the embedder:
+:meth:`siglip2_toolkit.embedder.Embedder.classify`. This module covers
+checkpoints that ship a trained classification head, consumed through
+``AutoModelForImageClassification`` (e.g. ``SiglipForImageClassification``).
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from pathlib import Path
+from typing import Any, Optional, Sequence
+
+import numpy as np
+
+from . import utils
+from .embedder import ImageInput, softmax_rows
+
+logger = logging.getLogger(__name__)
+
+
+class ImageClassifier:
+    """Classifies images with a fine-tuned image-classification model.
+
+    The model and its image processor are loaded lazily on first use. Labels
+    come from the checkpoint's ``config.id2label``; ``num_labels`` overrides
+    the head size when the checkpoint requires it.
+    """
+
+    def __init__(
+        self,
+        model: str | Path,
+        device: str = "auto",
+        dtype: Optional[str] = None,
+        num_labels: Optional[int] = None,
+        trust_remote_code: bool = False,
+    ) -> None:
+        self.model_path = str(Path(model).expanduser())
+        self.model_name = self.model_path
+        self.requested_device = device
+        self.requested_dtype = dtype
+        self.num_labels = num_labels
+        self.trust_remote_code = trust_remote_code
+
+        self._model: Any = None
+        self._processor: Any = None
+        self._torch: Any = None
+        self._device: Any = None
+        self._id2label: dict[int, str] = {}
+        self._lock = threading.Lock()
+
+    # ------------------------------------------------------------------ #
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._model is not None
+
+    @property
+    def labels(self) -> dict[int, str]:
+        """``id -> label`` mapping (empty until the model is loaded)."""
+        return dict(self._id2label)
+
+    @property
+    def device(self) -> Optional[str]:
+        return str(self._device) if self._device is not None else None
+
+    def load(self) -> "ImageClassifier":
+        """Load the model and its image processor from a local directory (idempotent)."""
+        if self._model is not None:
+            return self
+
+        path = Path(self.model_path)
+        if not path.is_dir():
+            raise FileNotFoundError(
+                f"ImageClassifier expects a local model directory, got: "
+                f"'{self.model_path}'. Get one with `siglip2 models download` or "
+                "`siglip2 models import`, or pass the path to one."
+            )
+
+        import torch
+        from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+        device, dtype = utils.resolve_torch_device(
+            torch, self.requested_device, self.requested_dtype
+        )
+        logger.info("Loading classifier '%s' on %s (%s)...", self.model_name, device, dtype)
+
+        extra: dict[str, Any] = {}
+        if self.num_labels is not None:
+            extra["num_labels"] = self.num_labels
+
+        try:
+            model = AutoModelForImageClassification.from_pretrained(
+                self.model_path,
+                trust_remote_code=self.trust_remote_code,
+                torch_dtype=dtype,
+                **extra,
+            )
+            processor = AutoImageProcessor.from_pretrained(
+                self.model_path,
+                trust_remote_code=self.trust_remote_code,
+            )
+        except Exception as exc:
+            raise OSError(
+                f"Could not load a classifier from '{self.model_path}': {exc}"
+            ) from exc
+        model = model.to(device).eval()
+
+        self._torch = torch
+        self._model = model
+        self._processor = processor
+        self._device = device
+        self._id2label = {
+            int(key): str(value)
+            for key, value in (getattr(model.config, "id2label", None) or {}).items()
+        }
+        logger.info("Classifier ready: %d label(s) ✅", len(self._id2label))
+        return self
+
+    # ------------------------------------------------------------------ #
+
+    def classify(
+        self,
+        images: Sequence[ImageInput],
+        top_k: Optional[int] = None,
+        batch_size: int = 16,
+    ) -> list[list[tuple[str, float]]]:
+        """Classify images; returns (label, probability) pairs sorted by score."""
+        self.load()
+        images = list(images)
+        results: list[list[tuple[str, float]]] = []
+
+        for start in range(0, len(images), batch_size):
+            batch = [utils.load_image(item) for item in images[start : start + batch_size]]
+            if not batch:
+                continue
+            inputs = self._processor(images=batch, return_tensors="pt").to(self._device)
+            with self._lock, self._torch.no_grad():
+                logits = self._model(**inputs).logits
+            probabilities = softmax_rows(
+                logits.detach().cpu().to(self._torch.float32).numpy()
+            )
+            for row in probabilities:
+                order = np.argsort(row)[::-1]
+                if top_k is not None:
+                    order = order[: max(0, int(top_k))]
+                results.append(
+                    [
+                        (self._id2label.get(int(index), f"LABEL_{int(index)}"), float(row[index]))
+                        for index in order
+                    ]
+                )
+        return results
+
+    def __repr__(self) -> str:
+        return (
+            f"ImageClassifier(model={self.model_name!r}, "
+            f"device={self.requested_device!r}, loaded={self.is_loaded})"
+        )