@datalayer/agent-runtimes 1.3.62 → 1.3.64

package/scripts/codegen/generate_voices.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+"""
+Generate the voice catalogue (VOICE.md VO-40) in Python and TypeScript.
+
+Read through ``agentspecs.speech``, which refuses a voice or a model whose
+licence the register does not allow: what is generated has passed it.
+
+Usage:
+    python generate_voices.py \\
+      --python-output agent_runtimes/specs/voices.py \\
+      --typescript-output src/specs/voices.ts
+"""
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from agentspecs.speech import list_speech_models, list_voices, register
+
+
+def _voice(voice: Any) -> dict[str, Any]:
+    return {
+        "id": voice.id,
+        "version": voice.version,
+        "name": voice.name,
+        "description": " ".join(voice.description.split()),
+        "engine": voice.engine,
+        "model": voice.model,
+        "voice": voice.voice,
+        "languages": list(voice.languages),
+        "where": list(voice.where),
+        "licence": voice.licence.model_dump(exclude_defaults=True),
+        "attribution": " ".join(voice.attribution.split()),
+        "watermark": voice.watermark,
+        "sample": voice.sample,
+    }
+
+
+def _model(model: Any) -> dict[str, Any]:
+    return {
+        "id": model.id,
+        "version": model.version,
+        "name": model.name,
+        "task": model.task,
+        "engine": model.engine,
+        "dtype": model.dtype,
+        "languages": list(model.languages),
+        "where": list(model.where),
+        "streaming": model.streaming,
+        "licence": model.licence.model_dump(exclude_defaults=True),
+        "attribution": " ".join(model.attribution.split()),
+        "upstream": model.source.upstream,
+        "revision": model.source.revision,
+        "files": [item.model_dump() for item in model.files],
+    }
+
+
+def _py(value: Any) -> str:
+    """A Python literal; `ruff format` lays it out."""
+    return repr(value)
+
+
+def generate_python_code(
+    voices: list[dict[str, Any]], models: list[dict[str, Any]], allowed: list[str]
+) -> str:
+    return "\n".join(
+        [
+            "# Copyright (c) 2025-2026 Datalayer, Inc.",
+            "# Distributed under the terms of the Modified BSD License.",
+            '"""',
+            "The voice catalogue (VOICE.md VO-40): voices and speech models.",
+            "",
+            "This file is AUTO-GENERATED from agentspecs (voices, speech-models).",
+            "DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
+            '"""',
+            "",
+            "from typing import Any, Dict, List, Optional",
+            "",
+            "#: The licences the register allows anywhere, the browser included.",
+            f"SPEECH_ALLOWED_LICENCES: List[str] = {_py(allowed)}",
+            "",
+            "#: The voices, by id.",
+            "VOICE_CATALOGUE: Dict[str, Dict[str, Any]] = {",
+            *[
+                f'    "{voice["id"]}": {_py(voice)},'.replace("\n", "\n    ")
+                for voice in voices
+            ],
+            "}",
+            "",
+            "#: The speech models, by id, each file pinned by its SHA-256.",
+            "SPEECH_MODEL_CATALOGUE: Dict[str, Dict[str, Any]] = {",
+            *[
+                f'    "{model["id"]}": {_py(model)},'.replace("\n", "\n    ")
+                for model in models
+            ],
+            "}",
+            "",
+            "",
+            "def get_voice_spec(voice_id: str) -> Optional[Dict[str, Any]]:",
+            '    """A voice of the catalogue, or None."""',
+            "    return VOICE_CATALOGUE.get(voice_id)",
+            "",
+            "",
+            "def get_speech_model_spec(model_id: str) -> Optional[Dict[str, Any]]:",
+            '    """A speech model of the catalogue, or None."""',
+            "    return SPEECH_MODEL_CATALOGUE.get(model_id)",
+            "",
+            "",
+            "def voice_speaks(voice: Dict[str, Any], language: str) -> bool:",
+            '    """Whether a voice speaks a language: `fr` and `fr-FR` are spoken by a `fr-FR` voice."""',
+            "    return any(own == language or own.split('-')[0] == language for own in voice['languages'])",
+            "",
+            "",
+            "def voice_for(language: str) -> Optional[Dict[str, Any]]:",
+            '    """The first voice of the catalogue that speaks a language, or None."""',
+            "    base = (language or '').strip()",
+            "    exact = [v for v in VOICE_CATALOGUE.values() if base in v['languages']]",
+            "    near = [v for v in VOICE_CATALOGUE.values() if voice_speaks(v, base.split('-')[0])]",
+            "    return (exact or near or [None])[0]",
+            "",
+        ]
+    )
+
+
+def generate_typescript_code(
+    voices: list[dict[str, Any]], models: list[dict[str, Any]], allowed: list[str]
+) -> str:
+    def ts(value: Any) -> str:
+        return json.dumps(value, indent=2, ensure_ascii=False)
+
+    return "\n".join(
+        [
+            "/*",
+            " * Copyright (c) 2025-2026 Datalayer, Inc.",
+            " * Distributed under the terms of the Modified BSD License.",
+            " */",
+            "",
+            "/**",
+            " * The voice catalogue (VOICE.md VO-40): voices and speech models.",
+            " *",
+            " * This file is AUTO-GENERATED from agentspecs (voices, speech-models).",
+            " * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
+            " *",
+            " * @module specs/voices",
+            " */",
+            "",
+            "/** Where a step of speech runs: the person's browser, or Datalayer's servers. */",
+            "export type SpeechWhere = 'device' | 'server';",
+            "",
+            "/** The licences a voice or a model is admitted by. */",
+            "export interface SpeechLicence {",
+            "  weights: string;",
+            "  code?: string;",
+            "  dataset?: string;",
+            "}",
+            "",
+            "/** A voice an application may speak with. */",
+            "export interface VoiceSpec {",
+            "  id: string;",
+            "  version: string;",
+            "  name: string;",
+            "  description: string;",
+            "  engine: string;",
+            "  /** The speech model it is a voice of. */",
+            "  model: string;",
+            "  /** The engine's own name for it. */",
+            "  voice: string;",
+            "  /** BCP 47. */",
+            "  languages: string[];",
+            "  where: SpeechWhere[];",
+            "  licence: SpeechLicence;",
+            "  /** What a page listing the voices shows, when the licence asks. */",
+            "  attribution: string;",
+            "  watermark: boolean;",
+            "  sample: string;",
+            "}",
+            "",
+            "/** One file of a model, pinned by its hash and its size. */",
+            "export interface PinnedFile {",
+            "  path: string;",
+            "  sha256: string;",
+            "  size: number;",
+            "}",
+            "",
+            "/** A model of speech: to text, to speech, or voice activity. */",
+            "export interface SpeechModelSpec {",
+            "  id: string;",
+            "  version: string;",
+            "  name: string;",
+            "  task: 'stt' | 'tts' | 'vad';",
+            "  engine: string;",
+            "  dtype: string;",
+            "  languages: string[];",
+            "  where: SpeechWhere[];",
+            "  streaming: boolean;",
+            "  licence: SpeechLicence;",
+            "  attribution: string;",
+            "  upstream: string;",
+            "  revision: string;",
+            "  files: PinnedFile[];",
+            "}",
+            "",
+            "/** The licences the register allows anywhere, the browser included. */",
+            f"export const SPEECH_ALLOWED_LICENCES: readonly string[] = {ts(allowed)};",
+            "",
+            "export const VOICE_CATALOGUE: Record<string, VoiceSpec> = {",
+            *[
+                f"  {json.dumps(voice['id'])}: {ts(voice)},".replace("\n", "\n  ")
+                for voice in voices
+            ],
+            "};",
+            "",
+            "export const SPEECH_MODEL_CATALOGUE: Record<string, SpeechModelSpec> = {",
+            *[
+                f"  {json.dumps(model['id'])}: {ts(model)},".replace("\n", "\n  ")
+                for model in models
+            ],
+            "};",
+            "",
+            "/** Whether a voice speaks a language: `fr` and `fr-FR` are spoken by a `fr-FR` voice. */",
+            "export function voiceSpeaks(voice: VoiceSpec, language: string): boolean {",
+            "  return voice.languages.some(",
+            "    own => own === language || own.split('-')[0] === language,",
+            "  );",
+            "}",
+            "",
+            "/** The voice a language is spoken with when none is said: the first that speaks it. */",
+            "export function voiceFor(language: string): VoiceSpec | undefined {",
+            "  const voices = Object.values(VOICE_CATALOGUE);",
+            "  return (",
+            "    voices.find(voice => voice.languages.includes(language)) ??",
+            "    voices.find(voice => voiceSpeaks(voice, language.split('-')[0]))",
+            "  );",
+            "}",
+            "",
+            "/**",
+            " * The speech-to-text model for a language, on the device: Moonshine where it",
+            " * hears it, Whisper otherwise (VOICE.md decision 3).",
+            " */",
+            "export function transcriberFor(language: string): SpeechModelSpec | undefined {",
+            "  const base = language.split('-')[0];",
+            "  const hearing = Object.values(SPEECH_MODEL_CATALOGUE).filter(",
+            "    model =>",
+            "      model.task === 'stt' &&",
+            "      model.where.includes('device') &&",
+            "      model.languages.includes(base),",
+            "  );",
+            "  return (",
+            "    hearing.find(model => model.id === 'moonshine-tiny-en') ??",
+            "    hearing.find(model => model.id.startsWith('moonshine-')) ??",
+            "    hearing[0]",
+            "  );",
+            "}",
+            "",
+        ]
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate the voice catalogue from agentspecs"
+    )
+    parser.add_argument("--python-output", type=Path, required=True)
+    parser.add_argument("--typescript-output", type=Path, required=True)
+    args = parser.parse_args()
+    voices = [_voice(voice) for voice in list_voices()]
+    models = [_model(model) for model in list_speech_models()]
+    allowed = list(register().allowed)
+    args.python_output.write_text(generate_python_code(voices, models, allowed))
+    args.typescript_output.write_text(generate_typescript_code(voices, models, allowed))
+    print(f"✓ Generated {len(voices)} voices and {len(models)} speech models")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/voice/measure.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+"""Measure the speech models on the recorded fixtures (VOICE.md VO-05, VO-51, VO-52).
+
+    python scripts/voice/measure.py --store ~/.cache/speech-store
+
+Writes ``tests/voice/measured/*.json``, which ``test_voice_wer.py`` checks
+against ``tests/voice/baselines.json``:
+
+- **speech to text**, each device model of the catalogue on the fixtures of
+  each language it hears, run as the browser runs it (transformers.js, the
+  same pinned files; in Node, so the timings are the CPU's, not the
+  browser's): what it heard, and how long it took;
+- **text to speech**, each voice saying its sample and a few of the
+  product's sentences (Kokoro on the CPU, as ai-agents-speech runs it): how
+  long the synthesis took against the length of the speech (the real-time
+  factor), and what the device model of its language hears of it — the
+  intelligibility of the voice, a round trip.
+
+Needs ``kokoro-onnx`` and ``soundfile`` (the speech service's own), and
+``@huggingface/transformers`` where ``node`` resolves it (``--node-modules``
+when it is not this checkout's). One heavy process at a time: the models run
+one after the other.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+import numpy as np
+import soundfile as sf
+
+ROOT = Path(__file__).resolve().parents[2]
+VOICE_TESTS = ROOT / "tests" / "voice"
+
+#: Sentences the product says, spoken by each voice of their language.
+PHRASES = {
+    "en": [
+        "Open the notebook and run the first cell.",
+        "Datalayer saved the report at three forty five.",
+        "Ask the agent to compare the two suppliers.",
+    ],
+    "fr": [
+        "Ouvre le notebook et lance la première cellule.",
+        "Le rapport est prêt, je l'envoie à l'équipe.",
+        "Demande à l'agent de comparer les deux fournisseurs.",
+    ],
+}
+
+
+def catalogue() -> Any:
+    """The generated catalogue, read without importing agent_runtimes."""
+    spec = importlib.util.spec_from_file_location(
+        "voices", ROOT / "agent_runtimes" / "specs" / "voices.py"
+    )
+    module = importlib.util.module_from_spec(spec)  # type: ignore[arg-type]
+    spec.loader.exec_module(module)  # type: ignore[union-attr]
+    return module
+
+
+def resample(samples: np.ndarray, rate: int, to: int = 16000) -> np.ndarray:
+    if rate == to:
+        return samples.astype(np.float32)
+    count = int(round(len(samples) * to / rate))
+    return np.interp(
+        np.linspace(0, len(samples) - 1, count), np.arange(len(samples)), samples
+    ).astype(np.float32)
+
+
+def transcribe(
+    store: Path, model: str, language: str, wavs: List[Path], env: Dict[str, str]
+) -> Dict[str, Any]:
+    script = ROOT / "scripts" / "voice" / "transcribe.mjs"
+    done = subprocess.run(
+        ["node", str(script), str(store), model, language, *map(str, wavs)],
+        capture_output=True,
+        text=True,
+        env=env,
+        check=True,
+    )
+    return json.loads(done.stdout.strip().splitlines()[-1])
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("--store", type=Path, required=True)
+    parser.add_argument(
+        "--node-modules",
+        type=Path,
+        default=None,
+        help="Where @huggingface/transformers is installed, when not in this checkout",
+    )
+    args = parser.parse_args()
+    voices = catalogue()
+    env = dict(os.environ)
+    script_dir = ROOT / "scripts" / "voice"
+    linked = None
+    if args.node_modules is not None:
+        # Node resolves a package from the script's folders up: lend it one.
+        linked = script_dir / "node_modules"
+        if not linked.exists():
+            linked.symlink_to(args.node_modules)
+    fixtures = json.loads((VOICE_TESTS / "fixtures.json").read_text())["clips"]
+    measured = VOICE_TESTS / "measured"
+    measured.mkdir(exist_ok=True)
+    try:
+        with tempfile.TemporaryDirectory() as scratch:
+            wavs: Dict[str, Path] = {}
+            for clip in fixtures:
+                samples, rate = sf.read(
+                    VOICE_TESTS / "fixtures" / clip["file"], dtype="float32"
+                )
+                wav = Path(scratch) / f"{clip['id']}.wav"
+                sf.write(wav, resample(samples, rate), 16000, subtype="PCM_16")
+                wavs[clip["id"]] = wav
+            # --- speech to text, on the device's models ---------------------------------
+            for model in voices.SPEECH_MODEL_CATALOGUE.values():
+                if model["task"] != "stt" or "device" not in model["where"]:
+                    continue
+                by_language = {}
+                for language in model["languages"]:
+                    clips = [clip for clip in fixtures if clip["language"] == language]
+                    if not clips:
+                        continue
+                    print(f"{model['id']} on {len(clips)} {language} clips", flush=True)
+                    heard = transcribe(
+                        args.store,
+                        model["id"],
+                        language,
+                        [wavs[c["id"]] for c in clips],
+                        env,
+                    )
+                    by_language[language] = {
+                        "load_ms": heard["load_ms"],
+                        "clips": [
+                            {
+                                "id": clip["id"],
+                                "heard": result["text"],
+                                "ms": result["ms"],
+                                "audio_s": result["audio_s"],
+                            }
+                            for clip, result in zip(clips, heard["results"])
+                        ],
+                    }
+                (measured / f"stt-{model['id']}.json").write_text(
+                    json.dumps(
+                        {
+                            "model": model["id"],
+                            "runtime": "transformers.js 4.3.0 on onnxruntime-node, CPU",
+                            "languages": by_language,
+                        },
+                        indent=2,
+                        ensure_ascii=False,
+                    )
+                    + "\n"
+                )
+            # --- text to speech, and what the device hears of it -----------------------
+            from kokoro_onnx import Kokoro
+
+            kokoro_dir = args.store / "kokoro-82m"
+            files = {
+                item["path"]
+                for item in voices.SPEECH_MODEL_CATALOGUE["kokoro-82m"]["files"]
+            }
+            onnx = next(name for name in files if name.endswith(".onnx"))
+            started = time.monotonic()
+            kokoro = Kokoro(str(kokoro_dir / onnx), str(kokoro_dir / "voices-v1.0.bin"))
+            load_ms = round((time.monotonic() - started) * 1000)
+            spoken: List[Dict[str, Any]] = []
+            for voice in voices.VOICE_CATALOGUE.values():
+                language = voice["languages"][0]
+                base = language.split("-")[0]
+                for index, text in enumerate([voice["sample"], *PHRASES.get(base, [])]):
+                    started = time.monotonic()
+                    samples, rate = kokoro.create(
+                        text, voice=voice["voice"], lang=language.lower()
+                    )
+                    took = time.monotonic() - started
+                    wav = Path(scratch) / f"{voice['id']}-{index}.wav"
+                    sf.write(wav, resample(samples, rate), 16000, subtype="PCM_16")
+                    spoken.append(
+                        {
+                            "voice": voice["id"],
+                            "language": base,
+                            "text": text,
+                            "wav": wav,
+                            "synthesis_ms": round(took * 1000),
+                            "audio_s": round(len(samples) / rate, 2),
+                        }
+                    )
+            round_trips = []
+            for base in sorted({item["language"] for item in spoken}):
+                model = voices.SPEECH_MODEL_CATALOGUE[
+                    "moonshine-tiny-en" if base == "en" else "whisper-base"
+                ]
+                items = [item for item in spoken if item["language"] == base]
+                heard = transcribe(
+                    args.store, model["id"], base, [item["wav"] for item in items], env
+                )
+                for item, result in zip(items, heard["results"]):
+                    round_trips.append(
+                        {
+                            **{
+                                key: value
+                                for key, value in item.items()
+                                if key != "wav"
+                            },
+                            "heard_by": model["id"],
+                            "heard": result["text"],
+                        }
+                    )
+            (measured / "tts-kokoro-82m.json").write_text(
+                json.dumps(
+                    {
+                        "model": "kokoro-82m",
+                        "runtime": "kokoro-onnx 0.6.1, onnxruntime CPU",
+                        "load_ms": load_ms,
+                        "spoken": round_trips,
+                    },
+                    indent=2,
+                    ensure_ascii=False,
+                )
+                + "\n"
+            )
+    finally:
+        if linked is not None and linked.is_symlink():
+            linked.unlink()
+    print(f"wrote {measured}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/voice/pin_store.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+"""The pinned-file store of the speech models (VOICE.md VO-03, VO-48, VO-49).
+
+Every file of every speech model of the catalogue, laid out as
+``<store>/<model id>/<path>`` and checked against the SHA-256 and the size
+the catalogue pins. The store is filled **once**, from where each model was
+published, and then copied to Datalayer's storage; the browser and the speech
+service read it from there and never from a third party's hub.
+
+    python scripts/voice/pin_store.py --store ~/.cache/speech-store [--from DIR]
+    python scripts/voice/pin_store.py --store ~/.cache/speech-store --verify
+
+``--from`` takes files already downloaded (any layout) whose hash matches,
+instead of downloading them again. ``--verify`` downloads nothing and fails
+on a missing or changed file.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import shutil
+import sys
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, Iterator, Optional
+
+import httpx
+
+from agent_runtimes.specs.voices import SPEECH_MODEL_CATALOGUE
+
+#: Where the npm package that ships Silero VAD is published.
+NPM_TARBALL = "https://registry.npmjs.org/@ricky0123/vad-web/-/vad-web-{revision}.tgz"
+
+
+def sha256_of(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def upstream_url(model: Dict[str, Any], path: str) -> Optional[str]:
+    """Where a file was published: a Hugging Face revision or a GitHub release; None for npm."""
+    repository = _repository(model)
+    if repository.startswith("https://huggingface.co/"):
+        return f"{repository}/resolve/{model['revision']}/{path}"
+    if "/releases/tag/" in repository:
+        return f"{repository.replace('/releases/tag/', '/releases/download/')}/{path}"
+    return None
+
+
+def _repository(model: Dict[str, Any]) -> str:
+    from agentspecs.speech import get_speech_model
+
+    spec = get_speech_model(model["id"])
+    if spec is None:
+        raise SystemExit(
+            f"{model['id']} is in the generated catalogue and not in agentspecs: run make specs"
+        )
+    return spec.source.repository
+
+
+def _found(local: Optional[Path], sha256: str, size: int) -> Optional[Path]:
+    if local is None:
+        return None
+    for candidate in local.rglob("*"):
+        if (
+            candidate.is_file()
+            and candidate.stat().st_size == size
+            and sha256_of(candidate) == sha256
+        ):
+            return candidate
+    return None
+
+
+def _npm_file(model: Dict[str, Any], path: str, into: Path) -> None:
+    with tempfile.TemporaryDirectory() as scratch:
+        tarball = Path(scratch) / "package.tgz"
+        _download(NPM_TARBALL.format(revision=model["revision"]), tarball)
+        with tarfile.open(tarball) as archive:
+            member = archive.getmember(f"package/dist/{path}")
+            extracted = archive.extractfile(member)
+            if extracted is None:
+                raise SystemExit(f"{path} is not a file of the vad-web package")
+            into.write_bytes(extracted.read())
+
+
+def _download(url: str, target: Path) -> None:
+    """Copy a published file, once, from where it was published (HTTPS only)."""
+    if not url.startswith("https://"):
+        raise SystemExit(f"{url} is not an HTTPS address: refused.")
+    with httpx.stream("GET", url, follow_redirects=True, timeout=120.0) as answered:
+        answered.raise_for_status()
+        with target.open("wb") as stream:
+            for block in answered.iter_bytes(1 << 20):
+                stream.write(block)
+
+
+def files() -> Iterator[tuple[Dict[str, Any], Dict[str, Any]]]:
+    for model in SPEECH_MODEL_CATALOGUE.values():
+        for item in model["files"]:
+            yield model, item
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("--store", type=Path, required=True)
+    parser.add_argument("--from", dest="local", type=Path, default=None)
+    parser.add_argument("--verify", action="store_true")
+    args = parser.parse_args()
+    problems = []
+    total = 0
+    for model, item in files():
+        target = args.store / model["id"] / item["path"]
+        total += item["size"]
+        if (
+            target.is_file()
+            and target.stat().st_size == item["size"]
+            and sha256_of(target) == item["sha256"]
+        ):
+            continue
+        if args.verify:
+            problems.append(
+                f"{model['id']}/{item['path']} is missing or does not match its pin"
+            )
+            continue
+        target.parent.mkdir(parents=True, exist_ok=True)
+        local = _found(args.local, item["sha256"], item["size"])
+        if local is not None:
+            shutil.copyfile(local, target)
+        else:
+            url = upstream_url(model, item["path"])
+            print(f"downloading {model['id']}/{item['path']}", flush=True)
+            if url is None:
+                _npm_file(model, item["path"], target)
+            else:
+                _download(url, target)
+        if sha256_of(target) != item["sha256"]:
+            target.unlink()
+            problems.append(
+                f"{model['id']}/{item['path']} was published with another hash: refused"
+            )
+    for problem in problems:
+        print(problem, file=sys.stderr)
+    if not problems:
+        print(
+            f"{args.store}: {sum(1 for _ in files())} files, {total / 1e6:.0f} MB, every one as pinned"
+        )
+    return 1 if problems else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())