vtune 0.1.0a1__tar.gz

vtune-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vTune contributors
+
+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.

vtune-0.1.0a1/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: vtune
+Version: 0.1.0a1
+Summary: Local-first experimentation for vLLM serving configurations
+License-Expression: MIT
+Project-URL: Repository, https://github.com/brtydse100/vTune
+Project-URL: Issues, https://github.com/brtydse100/vTune/issues
+Keywords: vllm,guidellm,benchmark,optimization,inference
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Optuna<5,>=4.0
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+# vTune
+
+vTune is a local-first experimentation and optimization tool for vLLM serving
+configurations. Users define the parameters and workloads they care about;
+vTune manages the server lifecycle, runs repeatable benchmarks, explores the
+search space, and reports which configurations performed best.
+
+vTune is alpha software targeting Linux with NVIDIA GPUs and Python 3.11–3.12.
+
+Tested integrations:
+
+- vLLM 0.10.2 with GuideLLM 0.7.3 on WSL2 and an RTX 3080.
+- vLLM 0.28.0 with GuideLLM 0.7.3 on the same system. WSL2 required
+  `VLLM_USE_V2_MODEL_RUNNER: "0"` because UVA was unavailable and
+  `VLLM_USE_FLASHINFER_SAMPLER: "0"` because the CUDA compiler toolkit was
+  not installed. Native Linux systems may not require these settings.
+
+Other combinations may work but are not yet verified.
+
+The published `py3-none-any` wheel installs on Linux and Windows. Configuration
+validation and stored-result inspection work on Windows, but starting an
+experiment is supported only on Linux because vLLM has no native Windows
+runtime.
+
+## Quick start
+
+Requirements: Linux, an NVIDIA GPU, a local model directory, and working
+`vllm` and `guidellm` commands. Install this checkout with:
+
+```bash
+pip install -e .
+```
+
+Create `experiment.yaml`:
+
+```yaml
+schema_version: 1
+experiment:
+  name: first-run
+model:
+  path: /models/opt-125m
+server:
+  args:
+    gpu-memory-utilization: 0.8
+  tune:
+    max-num-seqs:
+      values: [8, 16]
+benchmark:
+  runs:
+    - name: throughput
+      profile:
+        kind: throughput
+        max_concurrency: 16
+      constraints:
+        - kind: max_requests
+          count: 10
+      data:
+        - kind: synthetic_text
+          prompt_tokens: 32
+          output_tokens: 16
+optimization:
+  maximize: output_tokens_per_second
+  sampler: tpe
+  trials: 2
+```
+
+Run it:
+
+```bash
+vtune --config experiment.yaml
+```
+
+The short form is `vtune -c experiment.yaml`. The command validates the file,
+runs the experiment, persists results, and generates its exports and report.
+vTune binds vLLM to `127.0.0.1` by default. Set `server.args.host` explicitly
+only when the benchmark server must be reachable from another host.
+
+Terminal output is concise by default. To stream vLLM and GuideLLM logs:
+
+```bash
+vtune --config experiment.yaml --verbose
+```
+
+The persistent equivalent uses GuideLLM's logging level names:
+
+```yaml
+logging:
+  level: DEBUG
+```
+
+Supported levels are `DEBUG`, `INFO`, `WARNING`, `ERROR`, and `CRITICAL`.
+Full per-trial log files are always saved. `--verbose` overrides the configured
+level with `DEBUG` for that invocation.
+
+Retry one or more selected trials into a new immutable linked run:
+
+```bash
+vtune retry --run runs/EXPERIMENT/RUN_ID \
+  --trial trial-0001 --trial trial-0004
+```
+
+The source run is never modified.
+
+Display every stored vLLM and GuideLLM command for a trial without executing
+anything:
+
+```bash
+vtune reproduce --run runs/EXPERIMENT/RUN_ID --trial trial-0001
+```
+
+Each completed run also contains a self-contained `report.html` decision
+dashboard with the best observed configuration, baseline comparison, score
+history, throughput/latency tradeoff, and observed parameter effects.
+
+Random and TPE runs never execute the same resolved configuration twice.
+`optimization.trials` cannot exceed the number of unique configurations in
+the declared search space.
+
+## Product documents
+
+- [First MVP specification](docs/MVP_SPEC.md)
+- [Future implementation roadmap](docs/ROADMAP.md)
+- [Architecture overview and early sketch](docs/ARCHITECTURE.md)
+- [Editable Draw.io architecture diagram](docs/vtune-architecture.drawio)
+- [Contributor guide](CONTRIBUTING.md)
+- [Release notes](CHANGELOG.md)
+
+The MVP specification defines the first releasable version and its acceptance
+criteria. The roadmap describes capabilities that should be designed for now
+but implemented after the core experiment loop is reliable.
+
+vTune is available under the [MIT License](LICENSE).

vtune-0.1.0a1/README.md

@@ -0,0 +1,132 @@
+# vTune
+
+vTune is a local-first experimentation and optimization tool for vLLM serving
+configurations. Users define the parameters and workloads they care about;
+vTune manages the server lifecycle, runs repeatable benchmarks, explores the
+search space, and reports which configurations performed best.
+
+vTune is alpha software targeting Linux with NVIDIA GPUs and Python 3.11–3.12.
+
+Tested integrations:
+
+- vLLM 0.10.2 with GuideLLM 0.7.3 on WSL2 and an RTX 3080.
+- vLLM 0.28.0 with GuideLLM 0.7.3 on the same system. WSL2 required
+  `VLLM_USE_V2_MODEL_RUNNER: "0"` because UVA was unavailable and
+  `VLLM_USE_FLASHINFER_SAMPLER: "0"` because the CUDA compiler toolkit was
+  not installed. Native Linux systems may not require these settings.
+
+Other combinations may work but are not yet verified.
+
+The published `py3-none-any` wheel installs on Linux and Windows. Configuration
+validation and stored-result inspection work on Windows, but starting an
+experiment is supported only on Linux because vLLM has no native Windows
+runtime.
+
+## Quick start
+
+Requirements: Linux, an NVIDIA GPU, a local model directory, and working
+`vllm` and `guidellm` commands. Install this checkout with:
+
+```bash
+pip install -e .
+```
+
+Create `experiment.yaml`:
+
+```yaml
+schema_version: 1
+experiment:
+  name: first-run
+model:
+  path: /models/opt-125m
+server:
+  args:
+    gpu-memory-utilization: 0.8
+  tune:
+    max-num-seqs:
+      values: [8, 16]
+benchmark:
+  runs:
+    - name: throughput
+      profile:
+        kind: throughput
+        max_concurrency: 16
+      constraints:
+        - kind: max_requests
+          count: 10
+      data:
+        - kind: synthetic_text
+          prompt_tokens: 32
+          output_tokens: 16
+optimization:
+  maximize: output_tokens_per_second
+  sampler: tpe
+  trials: 2
+```
+
+Run it:
+
+```bash
+vtune --config experiment.yaml
+```
+
+The short form is `vtune -c experiment.yaml`. The command validates the file,
+runs the experiment, persists results, and generates its exports and report.
+vTune binds vLLM to `127.0.0.1` by default. Set `server.args.host` explicitly
+only when the benchmark server must be reachable from another host.
+
+Terminal output is concise by default. To stream vLLM and GuideLLM logs:
+
+```bash
+vtune --config experiment.yaml --verbose
+```
+
+The persistent equivalent uses GuideLLM's logging level names:
+
+```yaml
+logging:
+  level: DEBUG
+```
+
+Supported levels are `DEBUG`, `INFO`, `WARNING`, `ERROR`, and `CRITICAL`.
+Full per-trial log files are always saved. `--verbose` overrides the configured
+level with `DEBUG` for that invocation.
+
+Retry one or more selected trials into a new immutable linked run:
+
+```bash
+vtune retry --run runs/EXPERIMENT/RUN_ID \
+  --trial trial-0001 --trial trial-0004
+```
+
+The source run is never modified.
+
+Display every stored vLLM and GuideLLM command for a trial without executing
+anything:
+
+```bash
+vtune reproduce --run runs/EXPERIMENT/RUN_ID --trial trial-0001
+```
+
+Each completed run also contains a self-contained `report.html` decision
+dashboard with the best observed configuration, baseline comparison, score
+history, throughput/latency tradeoff, and observed parameter effects.
+
+Random and TPE runs never execute the same resolved configuration twice.
+`optimization.trials` cannot exceed the number of unique configurations in
+the declared search space.
+
+## Product documents
+
+- [First MVP specification](docs/MVP_SPEC.md)
+- [Future implementation roadmap](docs/ROADMAP.md)
+- [Architecture overview and early sketch](docs/ARCHITECTURE.md)
+- [Editable Draw.io architecture diagram](docs/vtune-architecture.drawio)
+- [Contributor guide](CONTRIBUTING.md)
+- [Release notes](CHANGELOG.md)
+
+The MVP specification defines the first releasable version and its acceptance
+criteria. The roadmap describes capabilities that should be designed for now
+but implemented after the core experiment loop is reliable.
+
+vTune is available under the [MIT License](LICENSE).

vtune-0.1.0a1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vtune"
+version = "0.1.0a1"
+description = "Local-first experimentation for vLLM serving configurations"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["vllm", "guidellm", "benchmark", "optimization", "inference"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Typing :: Typed",
+]
+dependencies = ["Optuna>=4.0,<5", "PyYAML>=6.0"]
+
+[project.urls]
+Repository = "https://github.com/brtydse100/vTune"
+Issues = "https://github.com/brtydse100/vTune/issues"
+
+[project.scripts]
+vtune = "vtune.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

vtune-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vtune-0.1.0a1/src/vtune/__init__.py

@@ -0,0 +1,7 @@
+"""vTune package."""
+
+__version__ = "0.1.0a1"
+
+from .orchestrator import Orchestrator, RunOutcome
+
+__all__ = ["Orchestrator", "RunOutcome"]

vtune-0.1.0a1/src/vtune/benchmarks/__init__.py

@@ -0,0 +1,9 @@
+"""Benchmark backend adapters."""
+
+from .guidellm import (
+    GuideLLMPlan, build_plan, configured_repeats, configured_runs, parse_result,
+)
+
+__all__ = [
+    "GuideLLMPlan", "build_plan", "configured_repeats", "configured_runs", "parse_result"
+]

vtune-0.1.0a1/src/vtune/benchmarks/guidellm.py

@@ -0,0 +1,145 @@
+"""GuideLLM configuration, command construction, and result normalization."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+import json
+from pathlib import Path
+import re
+
+from vtune.config.models import VTuneConfig
+from vtune.domain.benchmark import BenchmarkResult, WorkloadResult
+from vtune.benchmarks.timing import normalize_durations
+
+_RUN_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]*$")
+
+
+@dataclass(frozen=True, slots=True)
+class GuideLLMPlan:
+    run_name: str
+    argv: tuple[str, ...]
+    directory: Path
+    json_path: Path
+    log_path: Path
+
+
+def configured_runs(config: VTuneConfig) -> tuple[Mapping[str, object], ...]:
+    unknown = set(config.benchmark) - {"runs", "repeats"}
+    if unknown:
+        raise ValueError(f"Unsupported benchmark setting(s): {', '.join(sorted(unknown))}")
+    runs = config.benchmark.get("runs")
+    if not isinstance(runs, list) or not runs:
+        raise ValueError("'benchmark.runs' must be a non-empty list")
+    validated: list[Mapping[str, object]] = []
+    names: set[str] = set()
+    for index, value in enumerate(runs):
+        run = _mapping(value, f"run {index}")
+        unknown_run = set(run) - {
+            "name", "request_format", "profile", "constraints", "data"
+        }
+        if unknown_run:
+            options = ", ".join(sorted(unknown_run))
+            raise ValueError(f"Unsupported setting(s) in benchmark run {index}: {options}")
+        name = run.get("name")
+        if not isinstance(name, str) or not _RUN_NAME.fullmatch(name):
+            raise ValueError("benchmark run names must use letters, numbers, '_' or '-'")
+        if name in names:
+            raise ValueError(f"duplicate benchmark run name: {name}")
+        names.add(name)
+        data = run.get("data")
+        if not isinstance(data, list) or len(data) != 1:
+            raise ValueError(f"benchmark run '{name}' must configure exactly one dataset")
+        validated.append(run)
+    return tuple(validated)
+
+
+def configured_repeats(config: VTuneConfig) -> int:
+    value = config.benchmark.get("repeats", 1)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+        raise ValueError("benchmark.repeats must be a positive integer")
+    return value
+
+
+def build_plan(
+    config: VTuneConfig, run: Mapping[str, object], endpoint: str, artifacts: Path,
+) -> GuideLLMPlan:
+    name = run["name"]
+    request_format = run.get("request_format", "/v1/completions")
+    if not isinstance(request_format, str) or not request_format.strip():
+        raise ValueError("benchmark request_format must be a non-empty string")
+    directory = Path(artifacts) / str(name)
+    json_path = directory / "results.json"
+    argv = [
+        "guidellm", "run", "--backend",
+        _serialize({"kind": "openai_http", "target": endpoint,
+                    "model": config.model.path, "request_format": request_format}),
+        "--profile", _serialize(_mapping(run.get("profile"), "profile")),
+    ]
+    for option, label in (("constraints", "constraint"), ("data", "data")):
+        values = run.get(option, [])
+        if not isinstance(values, list):
+            raise ValueError(f"benchmark run '{option}' must be a list")
+        for value in values:
+            if label == "constraint" and isinstance(value, dict) and value.get("kind") == "max_duration":
+                value = {**value, "seconds": normalize_durations(value.get("seconds"))}
+            argv.extend((f"--{label}", _serialize(_mapping(value, label))))
+    argv.extend(("--output", f"kind=json,path={json_path}",
+                 "--disable-console-interactive"))
+    return GuideLLMPlan(str(name), tuple(argv), directory, json_path,
+                        directory / "benchmark.log")
+
+
+def parse_result(path: Path, run_name: str) -> BenchmarkResult:
+    source = Path(path)
+    try:
+        root = _mapping(json.loads(source.read_text(encoding="utf-8")), "result")
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise ValueError(f"Cannot read GuideLLM JSON result: {error}") from error
+    metadata = _mapping(root.get("metadata"), "metadata")
+    version = metadata.get("guidellm_version")
+    if not isinstance(version, str) or not version.strip():
+        raise ValueError("GuideLLM result is missing its version")
+    benchmarks = root.get("benchmarks")
+    if not isinstance(benchmarks, list) or not benchmarks:
+        raise ValueError("GuideLLM result must contain benchmarks")
+    workloads = tuple(
+        WorkloadResult(index, _mapping(item.get("config"), f"benchmark {index} config"),
+                       _mapping(item.get("metrics"), f"benchmark {index} metrics"))
+        for index, value in enumerate(benchmarks)
+        for item in (_mapping(value, f"benchmark {index}"),)
+    )
+    return BenchmarkResult(run_name, "guidellm", version, workloads, source)
+
+
+def _serialize(values: Mapping[str, object]) -> str:
+    kind = values.get("kind")
+    if not isinstance(kind, str) or not kind.strip():
+        raise ValueError("GuideLLM options require a non-empty 'kind'")
+    return ",".join(pair for key, value in values.items() for pair in _pairs(key, value))
+
+
+def _pairs(path: str, value: object) -> tuple[str, ...]:
+    if isinstance(value, Mapping):
+        return tuple(pair for key, item in value.items()
+                     for pair in _pairs(f"{path}.{key}", item))
+    if isinstance(value, list | tuple):
+        return tuple(pair for index, item in enumerate(value)
+                     for pair in _pairs(f"{path}[{index}]", item))
+    if isinstance(value, bool):
+        rendered = str(value).lower()
+    if isinstance(value, str | int | float) and not isinstance(value, bool):
+        rendered = str(value)
+    elif value is None:
+        rendered = "null"
+    elif not isinstance(value, bool):
+        raise ValueError(f"Unsupported GuideLLM value at '{path}'")
+    if "," in rendered:
+        raise ValueError(f"GuideLLM string values cannot contain commas: '{path}'")
+    return (f"{path}={rendered}",)
+
+
+def _mapping(value: object, label: str) -> Mapping[str, object]:
+    if not isinstance(value, dict) or any(not isinstance(key, str) for key in value):
+        raise ValueError(f"GuideLLM {label} must be an object")
+    return value

vtune-0.1.0a1/src/vtune/benchmarks/timing.py

@@ -0,0 +1,67 @@
+"""Duration parsing and GuideLLM timeout estimation."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+import re
+
+_DURATION = re.compile(r"^(\d+(?:\.\d+)?)\s*([smh]?)$")
+_UNITS = {"": 1, "s": 1, "m": 60, "h": 3600}
+
+
+def parse_duration(value: object, label: str = "duration") -> float:
+    if isinstance(value, bool):
+        raise ValueError(f"'{label}' must be a positive duration")
+    if isinstance(value, int | float):
+        seconds = float(value)
+    elif isinstance(value, str) and (match := _DURATION.fullmatch(value.strip().lower())):
+        seconds = float(match.group(1)) * _UNITS[match.group(2)]
+    else:
+        raise ValueError(f"'{label}' must use seconds, '30s', '2m', or '1h'")
+    if seconds <= 0:
+        raise ValueError(f"'{label}' must be positive")
+    return seconds
+
+
+def timeout_for_run(run: Mapping[str, object], configured: object = "auto") -> float:
+    """Return an explicit timeout or estimate duration plus a safety margin."""
+    if configured != "auto":
+        return parse_duration(configured, "timeouts.benchmark")
+    duration = _duration_constraint(run)
+    if duration is None:
+        return 180.0
+    expected = duration * _strategy_count(run.get("profile"))
+    return expected + max(30.0, expected * 0.25)
+
+
+def normalize_durations(value: object) -> object:
+    """Convert duration strings recursively before passing values to GuideLLM."""
+    if isinstance(value, list):
+        return [normalize_durations(item) for item in value]
+    if isinstance(value, str):
+        return parse_duration(value)
+    return value
+
+
+def _duration_constraint(run: Mapping[str, object]) -> float | None:
+    constraints = run.get("constraints", [])
+    if not isinstance(constraints, list):
+        return None
+    for constraint in constraints:
+        if isinstance(constraint, Mapping) and constraint.get("kind") == "max_duration":
+            seconds = constraint.get("seconds")
+            if isinstance(seconds, list):
+                return sum(parse_duration(item, "max_duration.seconds") for item in seconds)
+            return parse_duration(seconds, "max_duration.seconds")
+    return None
+
+
+def _strategy_count(profile: object) -> int:
+    if not isinstance(profile, Mapping):
+        return 1
+    for key in ("streams", "rates"):
+        value = profile.get(key)
+        if isinstance(value, list):
+            return max(1, len(value))
+    size = profile.get("sweep_size")
+    return size if isinstance(size, int) and size > 0 else 1

vtune-0.1.0a1/src/vtune/cli.py

@@ -0,0 +1,86 @@
+"""Command-line entry point for vTune."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+from collections.abc import Sequence
+from pathlib import Path
+import sys
+
+from vtune.config.errors import ConfigError
+from vtune.config.loader import load_config
+from vtune.cli_options import CLIUsageError, validate_cli_options
+from vtune.lifecycle import load_retry_plan
+from vtune.orchestrator import Orchestrator
+from vtune.reproduction.display import reproduce_trial
+from vtune.reproduction.export import export_vllm_command
+from vtune.terminal import with_debug_logging
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="vtune", description="Experiment with vLLM serving configurations."
+    )
+    parser.add_argument(
+        "action", nargs="?", choices=("validate", "export", "reproduce", "retry"),
+        help="Post-run action; omit to start a new experiment.")
+    parser.add_argument("--config", "-c", metavar="YAML",
+                        help="Experiment YAML for a new run or validation.")
+    parser.add_argument("--run", type=Path, metavar="DIRECTORY",
+                        help="Existing immutable run directory.")
+    parser.add_argument("--trial", action="append", metavar="ID",
+                        help="Trial ID; repeat the option when retrying several trials.")
+    parser.add_argument("--verbose", action="store_true",
+                        help="Override logging.level with DEBUG and stream child logs.")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        validate_cli_options(args)
+        if args.action == "export":
+            print(export_vllm_command(args.run, args.trial[0]))
+            return 0
+        if args.action == "reproduce":
+            print(reproduce_trial(args.run, args.trial[0]))
+            return 0
+        if args.action == "retry":
+            plan = load_retry_plan(args.run, args.trial)
+            for warning in plan.warnings:
+                print(f"Integrity warning: {warning}", file=sys.stderr)
+            retry_config = with_debug_logging(plan.config) if args.verbose else plan.config
+            outcome = asyncio.run(Orchestrator(
+                retry_config, plan.trials, plan.source_run_id, plan.sources,
+            ).run())
+        else:
+            config = load_config(args.config)
+            config = with_debug_logging(config) if args.verbose else config
+            if args.action == "validate":
+                Orchestrator(config).validate()
+                print(f"Configuration valid: {config.experiment.name}")
+                print(f"Model: {config.model.path}")
+                return 0
+            outcome = asyncio.run(Orchestrator(config).run())
+    except CLIUsageError as error:
+        print(f"Command error: {error}", file=sys.stderr)
+        return 2
+    except ConfigError as error:
+        print(f"Configuration error: {error}", file=sys.stderr)
+        return 2
+    except (OSError, TypeError, ValueError) as error:
+        print(f"Experiment error: {error}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("Experiment interrupted", file=sys.stderr)
+        return 130
+    print(outcome.summary)
+    if outcome.status == "interrupted":
+        return 130
+    completed = any(report.status.value == "completed" for report in outcome.trials)
+    return 0 if completed else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())