litert-cli-nightly 0.1.0.dev20260513__py3-none-any.whl

litert_cli/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2026 The LiteRT CLI Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+

litert_cli/commands/benchmark/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2026 The LiteRT CLI Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""CLI command for benchmarking LiteRT models."""

litert_cli/commands/benchmark/android.py

@@ -0,0 +1,177 @@
+# Copyright 2026 The LiteRT CLI Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Android Benchmark Module."""
+
+from __future__ import annotations
+
+import pathlib
+import shlex
+import subprocess
+
+import click
+from litert_cli.core import android_utils
+from litert_cli.core import constants
+from litert_cli.core import npu_utils as npu
+
+
+def run_android(*, model_path: pathlib.Path, accelerator: str) -> None:
+  """Runs the model on an Android device.
+
+  Pushes the model and benchmark_model binary to the device and runs it.
+
+  Args:
+    model_path: Path to the local LiteRT model file.
+    accelerator: Hardware accelerator to use (cpu, gpu, npu).
+
+  Raises:
+    subprocess.CalledProcessError: If any adb command fails on the device.
+  """
+  click.echo("Preparing to run on Android device via adb...")
+
+  android_utils.check_adb()
+  abi = android_utils.get_android_abi()
+  click.echo(f"Detected Android device ABI: {abi}")
+
+  cli_android_root = constants.LITERT_CLI_ANDROID_ROOT
+
+  model_name = model_path.name
+  remote_model_path = f"{cli_android_root}/{model_name}"
+
+  benchmark_model_bin = android_utils.find_android_binary(
+      "benchmark_model", abi
+  )
+
+  remote_dispatch_dir = ""
+  if accelerator == "npu":
+    remote_dispatch_dir = npu.push_npu_runtime_libraries(None, cli_android_root)
+
+    # Download and push SOC-specific LiteRT dispatch and compiler plugin libraries
+    target_model = npu.get_soc_target_model(None)
+    soc_vendor = "mediatek" if "mt" in target_model else "qualcomm"
+    lib_dispatch = android_utils.find_npu_dispatch_lib(soc_vendor, abi)
+    lib_compiler = android_utils.find_npu_compiler_plugin_lib(soc_vendor, abi)
+
+    remote_lib_dispatch = f"{cli_android_root}/{lib_dispatch.name}"
+    if (
+        subprocess.run(
+            ["adb", "shell", f"[ -f {remote_lib_dispatch} ]"], check=False
+        ).returncode
+        == 0
+    ):
+      click.echo(f"  Skipping {lib_dispatch.name} (already on device)")
+    else:
+      click.echo(f"Pushing {lib_dispatch.name} to device...")
+      subprocess.run(
+          ["adb", "push", str(lib_dispatch), remote_lib_dispatch], check=True
+      )
+
+    remote_lib_compiler = f"{cli_android_root}/{lib_compiler.name}"
+    if (
+        subprocess.run(
+            ["adb", "shell", f"[ -f {remote_lib_compiler} ]"], check=False
+        ).returncode
+        == 0
+    ):
+      click.echo(f"  Skipping {lib_compiler.name} (already on device)")
+    else:
+      click.echo(f"Pushing {lib_compiler.name} to device...")
+      subprocess.run(
+          ["adb", "push", str(lib_compiler), remote_lib_compiler], check=True
+      )
+
+  click.echo(f"Pushing model {model_name} to device...")
+  subprocess.run(["adb", "shell", "mkdir", "-p", cli_android_root], check=True)
+  subprocess.run(
+      ["adb", "push", str(model_path), remote_model_path], check=True
+  )
+
+  click.echo("Pushing benchmark_model to device...")
+  subprocess.run(
+      [
+          "adb",
+          "push",
+          str(benchmark_model_bin),
+          f"{cli_android_root}/benchmark_model",
+      ],
+      check=True,
+  )
+  subprocess.run(
+      ["adb", "shell", "chmod", "+x", f"{cli_android_root}/benchmark_model"],
+      check=True,
+  )
+
+  click.echo("Executing benchmark on device...\n")
+  try:
+    bench_args = [
+        f"{cli_android_root}/benchmark_model",
+        f"--graph={shlex.quote(remote_model_path)}",
+    ]
+    if accelerator == "gpu":
+      bench_args.append("--use_gpu=true")
+    elif accelerator == "npu":
+      bench_args.append("--use_npu=true")
+      bench_args.append(f"--dispatch_library_path={shlex.quote(cli_android_root)}")
+      bench_args.append(
+          f"--compiler_plugin_library_path={shlex.quote(cli_android_root)}"
+      )
+
+      if soc_vendor == "mediatek":
+        recommend_version = constants.MEDIATEK_SOC_VERSION_MAP.get(
+            target_model, ""
+        )
+        if "v9" in recommend_version:
+          bench_args.append("--mediatek_nerun_pilot_version=version9")
+        elif "v8" in recommend_version:
+          bench_args.append("--mediatek_nerun_pilot_version=version8")
+
+    env_vars = ""
+    if remote_dispatch_dir:
+      quoted_dispatch_dir = shlex.quote(remote_dispatch_dir)
+      env_vars = (
+          f"LD_LIBRARY_PATH={quoted_dispatch_dir} "
+          f"ADSP_LIBRARY_PATH={quoted_dispatch_dir} "
+      )
+
+    full_command = env_vars + " ".join(bench_args)
+    process = subprocess.Popen(
+        ["adb", "shell", full_command],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+
+    from litert_cli.core.log_filters import BenchmarkLogFilter
+
+    output_lines = []
+    log_filter = BenchmarkLogFilter(constants.DEFAULT_QUIET)
+
+    for line in process.stdout:
+      output_lines.append(line)
+      if log_filter.should_show(line):
+        click.echo(line, nl=False)
+
+    process.wait()
+    if process.returncode != 0:
+      click.secho(
+          f"Execution failed on device with exit code {process.returncode}",
+          fg="red",
+      )
+      click.echo("Full output for debugging:")
+      for line in output_lines:
+        click.echo(line, nl=False)
+      raise click.ClickException("Benchmark failed on device.")
+  except Exception as e:
+    raise click.ClickException(f"Failed to execute benchmark on device: {e}")

litert_cli/commands/benchmark/cli.py

@@ -0,0 +1,163 @@
+# Copyright 2026 The LiteRT CLI Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""CLI Benchmark Module providing commands to benchmark LiteRT models.
+
+This module defines the `benchmark` command using Click. It supports:
+1. Benchmarking on a local Android device via adb (Default).
+2. Benchmarking on Google Cloud Platform (GCP) via AI Edge Portal Cloud API.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import textwrap
+
+import click
+from litert_cli.core import constants
+from litert_cli.core import utils
+
+
+@click.command(
+    "benchmark",
+    help="""\b
+Benchmark LiteRT models on different platforms.
+\b
+MODEL: Path to the LiteRT model file.
+\b
+Examples:
+\b
+  # Benchmark on Desktop with CPU (Default) or GPU
+\b
+    $ litert benchmark model.tflite
+    $ litert benchmark model.tflite --gpu
+\b
+  # Benchmark on Android with CPU (Default) or GPU or NPU
+    $ litert benchmark model.tflite --android
+    $ litert benchmark model.tflite --android --gpu
+    $ litert benchmark model.tflite --android --npu
+\b
+  # Benchmark on Google AI Edge Portal in Google Cloud. Prerequisites:
+  # - Set up your Google AI Edge Portal account by following up the instructions at:
+  #   https://ai.google.dev/edge/ai-edge-portal
+  # - Set up authentication by running: gcloud auth login
+  # - You can set the default GCP project by setting the environment variable LITERT_GCP_PROJECT,
+  #  or by providing the --gcp-project option.
+  # 
+    $ litert benchmark model.tflite --gcp --device "pixel 7"
+    $ litert benchmark model.tflite --gcp --device "pixel 7" --gcp-project "your-gcp-project-id"
+    $ litert benchmark model.tflite --gcp --devices "pixel 7, sm-s931u1" --gpu
+""",
+)
+@click.argument("model", type=str)
+@click.option(
+    "--android",
+    "target",
+    flag_value="android",
+    default=True,
+    help="Benchmark on Android device (Default)",
+)
+@click.option(
+    "--gcp",
+    "target",
+    flag_value="gcp",
+    help="Benchmark on Google AI Edge Portal in Google Cloud.",
+)
+@click.option(
+    "--cpu",
+    "accelerator",
+    flag_value="cpu",
+    default=True,
+    help="Use CPU accelerator (Default)",
+)
+@click.option(
+    "--gpu",
+    "accelerator",
+    flag_value="gpu",
+    help="Use GPU accelerator",
+)
+@click.option(
+    "--npu",
+    "accelerator",
+    flag_value="npu",
+    help="Use NPU accelerator",
+)
+@click.option(
+    "--device",
+    "--devices",
+    "devices",
+    type=str,
+    multiple=True,
+    default=["pixel 7"],
+    help=(
+        "Target device model name(s) (e.g., 'pixel 7'). Can be specified"
+        " --device multiple times or use --devices 'pixel 7, sm-s931u1'."
+        " Default is 'pixel 7'"
+    ),
+)
+@click.option(
+    "--gcp-project",
+    type=str,
+    help="GCP project ID for benchmarking (Only for GCP target).",
+)
+def benchmark_cmd(
+    model: str,
+    target: str,
+    accelerator: str,
+    devices: tuple[str, ...],
+    gcp_project: str | None = None,
+) -> None:
+  """Benchmarks LiteRT models on different platforms.
+
+  Args:
+    model: Path to the LiteRT model file or Model Reference.
+    target: Target platform for benchmark (android, gcp).
+    accelerator: Accelerator to use (cpu, gpu, npu).
+    devices: Target device model(s) (e.g., 'pixel 7').
+    gcp_project: GCP project ID for benchmarking.
+  """
+  from litert_cli.core import models as core_models
+
+  # Quiet if default is true
+  if constants.DEFAULT_QUIET:
+    utils.enable_quiet_mode()
+
+  resolved_model_path, _ = core_models.resolve_model_reference(model)
+
+  if resolved_model_path != model:
+    click.echo(f"Resolved model '{model}' to '{resolved_model_path}'")
+
+  model_path = pathlib.Path(resolved_model_path)
+
+  if target == "android":
+    # pylint: disable=g-import-not-at-top
+    from litert_cli.commands.benchmark import android
+
+    if not model_path.exists():
+      raise click.ClickException(f"Local model file not found: {model_path}")
+
+    android.run_android(model_path=model_path, accelerator=accelerator)
+  elif target == "gcp":
+    # pylint: disable=g-import-not-at-top
+    from litert_cli.commands.benchmark import gcp
+
+    gcp.run_gcp(
+        str(model_path),
+        accelerator,
+        devices,
+        gcp_project,
+    )
+  else:
+    click.secho(f"Target '{target}' is not yet supported.", fg="red")

litert_cli/commands/benchmark/gcp.py

@@ -0,0 +1,257 @@
+# Copyright 2026 The LiteRT CLI Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Benchmarking on Google AI Edge Portal in GCP."""
+
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+import subprocess
+import time
+import urllib.error
+import urllib.request
+import uuid
+
+import click
+
+_DEFAULT_GCP_PROJECT = os.environ.get("LITERT_GCP_PROJECT", "aep-e2e-test")
+_DEFAULT_GCP_LOCATION = "us-central1"
+_GCP_BUCKET = os.environ.get("LITERT_GCP_BUCKET", "litert-cli-test")
+_DEFAULT_PORTAL_ENDPOINT = "https://aiedgeportal.googleapis.com/v1alpha"
+
+
+def _get_submission_url(
+    portal_endpoint: str, gcp_project: str, gcp_location: str, job_id: str
+) -> str:
+  """Returns the URL for submitting a benchmark job."""
+  return (
+      f"{portal_endpoint}/projects/{gcp_project}/locations/{gcp_location}"
+      f"/benchmarks?benchmarkId={job_id}"
+  )
+
+
+def _get_operation_url(portal_endpoint: str, op_name: str) -> str:
+  """Returns the URL for polling operation status."""
+  return f"{portal_endpoint}/{op_name}"
+
+
+def _get_console_url(
+    gcp_project: str, gcp_location: str, benchmark_id: str
+) -> str:
+  """Returns the Google Cloud Console URL for viewing progress."""
+  return (
+      "https://console.cloud.google.com/ai-edge-portal/benchmarks/details/"
+      f"{gcp_location}/{benchmark_id}?project={gcp_project}"
+  )
+
+
+def run_gcp(
+    model_path_str: str,
+    accelerator: str,
+    devices: list[str],
+    gcp_project: str | None = None,
+) -> None:
+  """Runs the model on GCP via AI Edge Portal Cloud API.
+
+  Uploads model to GCS if it's not already there.
+  Submits benchmark job to AI Edge Portal Cloud API.
+  Polls benchmark job status.
+
+  Args:
+    model_path_str: Path to the LiteRT model file (local or gs://).
+    accelerator: Hardware accelerator to use (cpu, gpu, npu).
+    devices: Target device model(s) (e.g., 'pixel 7', 'pixel 8').
+    gcp_project: GCP project ID for benchmarking.
+  """
+  if accelerator.lower() == "npu":
+    click.secho(
+        "Warning: NPU benchmarking on GCP is not fully implemented via CLI yet."
+        " Please use the Google AI Edge Portal web UI to run and test NPU"
+        " benchmarks.",
+        fg="yellow",
+    )
+    return
+
+  device_list = []
+  if isinstance(devices, str):
+    items = [devices]
+  else:
+    items = devices
+
+  for item in items:
+    if item:
+      parts = [p.strip() for p in item.split(",") if p.strip()]
+      device_list.extend(parts)
+
+  if not device_list:
+    device_list = ["pixel 7"]
+
+  if not gcp_project:
+    gcp_project = _DEFAULT_GCP_PROJECT
+  model_path = model_path_str
+  # Upload model to GCS if it's not already there.
+  if not model_path.startswith("gs://"):
+    local_model = pathlib.Path(model_path)
+    if not local_model.exists():
+      click.secho(f"Error: Local model file not found: {model_path}", fg="red")
+      return
+
+    click.secho(
+        f"Uploading local model '{model_path}' to"
+        f" gs://{_GCP_BUCKET}/...",
+        fg="cyan",
+    )
+    try:
+      subprocess.run(
+          [
+              "gcloud",
+              "storage",
+              "cp",
+              str(local_model),
+              f"gs://{_GCP_BUCKET}/",
+          ],
+          check=True,
+      )
+      model_path = f"gs://{_GCP_BUCKET}/{local_model.name}"
+    except subprocess.CalledProcessError as e:
+      click.secho(
+          f"Error: Failed to upload '{model_path}' to Google Cloud Storage:"
+          f" {e}",
+          fg="red",
+      )
+      return
+
+  job_id = f"litert-cli-benchmark-{uuid.uuid4().hex[:8]}"
+
+  click.echo("Fetching GCP access token...")
+  try:
+    token = subprocess.check_output(
+        ["gcloud", "auth", "print-access-token"], text=True
+    ).strip()
+  except subprocess.CalledProcessError as e:
+    click.secho(
+        "Error: Failed to get gcloud access token. Please run 'gcloud auth"
+        f" login' first. Details: {e}",
+        fg="red",
+    )
+    return
+
+  portal_endpoint = os.environ.get(
+      "AI_EDGE_PORTAL_ENDPOINT", _DEFAULT_PORTAL_ENDPOINT
+  ).rstrip("/")
+  url = _get_submission_url(
+      portal_endpoint, gcp_project, _DEFAULT_GCP_LOCATION, job_id
+  )
+  headers = {
+      "Authorization": f"Bearer {token}",
+      "Content-Type": "application/json",
+      "X-Goog-User-Project": gcp_project,
+  }
+
+  accel_name = accelerator.upper()
+
+  body = {
+      "display_name": job_id,
+      "device_configs": [{"device_model": d} for d in device_list],
+      "run_specs": [{
+          "accelerator": accel_name,
+          "model_path": model_path.replace("gs://", ""),
+          "id": accelerator.lower(),
+          "display_name": f"{accelerator.lower()}_test",
+      }],
+  }
+
+  if gcp_project == "aep-e2e-test":
+    click.secho(
+        "Warning: You need to specify your own GCP project by passing"
+        " '--gcp-project <PROJECT_ID>' or by setting the 'LITERT_GCP_PROJECT'"
+        " environment variable.",
+        fg="yellow",
+    )
+
+  # Submit the benchmark job via http requests to AI Edge Portal Cloud API.
+  req = urllib.request.Request(
+      url, data=json.dumps(body).encode("utf-8"), headers=headers, method="POST"
+  )
+  click.echo(
+      f"Submitting '{accelerator}' benchmark job '{job_id}' to AI Edge Portal"
+      f" (Project: {gcp_project}, Location:"
+      f" {_DEFAULT_GCP_LOCATION})..."
+  )
+
+  try:
+    with urllib.request.urlopen(req) as response:
+      resp_data = json.loads(response.read().decode())
+      click.secho("Benchmark job submitted successfully!", fg="green")
+
+      op_name = resp_data.get("name", "")
+      if op_name and "operations" in op_name:
+        op_url = _get_operation_url(portal_endpoint, op_name)
+        console_url = _get_console_url(
+            gcp_project, _DEFAULT_GCP_LOCATION, job_id
+        )
+        click.echo(
+            f"Waiting for benchmark to complete (Operation: {op_name}). This"
+            " may take a few minutes..."
+        )
+        click.secho(
+            f"View progress on the Cloud Console: {console_url}", fg="cyan"
+        )
+
+        try:
+          while True:
+            time.sleep(15)
+            click.echo(".", nl=False)
+            req_op = urllib.request.Request(op_url, headers=headers)
+            try:
+              with urllib.request.urlopen(req_op) as res_op:
+                op_data = json.loads(res_op.read().decode())
+            except urllib.error.HTTPError as e:
+              with e:
+                click.secho(f"\nError polling operation: {e}", fg="yellow")
+              continue
+
+            if op_data.get("done"):
+              click.echo("")  # Print a newline after the dots
+              if "error" in op_data:
+                click.secho(
+                    "Benchmark failed:"
+                    f" {json.dumps(op_data['error'], indent=2)}",
+                    fg="red",
+                )
+              else:
+                click.secho(
+                    "Benchmark operation completed successfully!", fg="green"
+                )
+                click.echo(json.dumps(op_data.get("response", {}), indent=2))
+              break
+        except KeyboardInterrupt:
+          click.echo("")
+          click.secho(
+              "\nPolling interrupted. The benchmark job is still running.",
+              fg="yellow",
+          )
+          click.echo(
+              f"You can check its status later by viewing it in the console:"
+              " {console_url}"
+          )
+      else:
+        click.echo(json.dumps(resp_data, indent=2))
+  except urllib.error.HTTPError as e:
+    err_body = e.read().decode()
+    click.secho(f"Failed to submit benchmark: {e.code} {e.reason}", fg="red")
+    click.secho(f"Details: {err_body}", fg="red")

litert_cli/commands/clean.py

@@ -0,0 +1,73 @@
+# Copyright 2026 The LiteRT CLI Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Clean command for LiteRT CLI."""
+
+from __future__ import annotations
+
+import pathlib
+import shlex
+import shutil
+import subprocess
+
+import click
+from litert_cli.core import android_utils
+from litert_cli.core import constants
+
+
+@click.command(name="clean")
+def clean_cmd() -> None:
+  """Cleans up local caches, downloaded files, and remote Android directories."""
+
+  click.echo("Cleaning LiteRT CLI workspace...")
+
+  # 1. Clean local downloaded CLI root qairt directory
+  qairt_dir = pathlib.Path(constants.LITERT_CLI_ROOT) / "qairt"
+  try:
+    shutil.rmtree(qairt_dir)
+    click.echo(f"Removing local qairt workspace: {qairt_dir}")
+  except FileNotFoundError:
+    pass
+  except OSError as e:
+    click.secho(f"Warning: Failed to remove {qairt_dir}: {e}", fg="yellow")
+
+  # 2. Clean local cache directory (e.g., ~/.cache/litert-cli)
+  cache_dir = pathlib.Path(constants.LITERT_CLI_CACHE_DIR)
+  try:
+    shutil.rmtree(cache_dir)
+    click.echo(f"Removing local cache: {cache_dir}")
+  except FileNotFoundError:
+    pass
+  except OSError as e:
+    click.secho(f"Warning: Failed to remove {cache_dir}: {e}", fg="yellow")
+
+  # 3. Clean remote Android directory
+  try:
+    android_utils.check_adb()
+    android_root = constants.LITERT_CLI_ANDROID_ROOT
+    click.echo(f"Removing remote Android workspace via adb: {android_root}")
+
+    subprocess.run(
+        ["adb", "shell", f"rm -rf {shlex.quote(android_root)}"],
+        check=False,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+  except click.ClickException:
+    click.echo(
+        "No active Android device found via adb. Skipping remote cleanup."
+    )
+
+  click.secho("Cleanup complete!", fg="green")