sima-cli 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

sima_cli/__version__.py

@@ -1,2 +1,2 @@
 # sima_cli/__version__.py
-__version__ = "0.0.35"
+__version__ = "0.0.37"

sima_cli/app_zoo/app.py

@@ -0,0 +1,435 @@
+# model_zoo/models.py
+
+import requests
+import click
+import os
+import yaml
+import zipfile
+import shutil
+from urllib.parse import urlparse
+from rich import print
+from rich.text import Text
+from rich.table import Table
+from rich.panel import Panel
+from rich.console import Console
+from sima_cli.utils.config import get_auth_token
+from sima_cli.utils.config_loader import artifactory_url
+from sima_cli.download import download_file_from_url
+
+ARTIFACTORY_BASE_URL = artifactory_url() + '/artifactory'
+
+def _is_valid_url(url: str) -> bool:
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc])
+    except:
+        return False
+
+def _describe_app_internal(ver: str, app_name: str):
+    repo = "vdp"
+    base_path = f"vdp-app-config-default/{ver}/{app_name}"
+    aql_query = f"""
+        items.find({{
+            "repo": "{repo}",
+            "path": "{base_path}",
+            "$or": [
+                {{ "name": {{ "$match": "*.yaml" }} }},
+                {{ "name": {{ "$match": "*.yml" }} }}
+            ],
+            "type": "file"
+        }}).include("repo","path","name")
+    """.strip()
+
+    headers = {
+        "Content-Type": "text/plain",
+        "Authorization": f"Bearer {get_auth_token(internal=True)}"
+    }
+    aql_url = f"{ARTIFACTORY_BASE_URL}/api/search/aql"
+    response = requests.post(aql_url, data=aql_query, headers=headers)
+    if response.status_code != 200:
+        click.echo(f"❌ Failed to list app files. Status: {response.status_code}")
+        click.echo(response.text)
+        return
+
+    results = response.json().get("results", [])
+    yaml_file = next((f for f in results if f["name"].endswith((".yaml", ".yml"))), None)
+
+    if not yaml_file:
+        click.echo(f"⚠️ No .yaml or .yml file found under: {base_path}")
+        return
+
+    # Download the YAML
+    yaml_url = f"{ARTIFACTORY_BASE_URL}/{repo}/{yaml_file['path']}/{yaml_file['name']}"
+    response = requests.get(yaml_url, headers={"Authorization": f"Bearer {get_auth_token(internal=True)}"})
+    if response.status_code != 200:
+        click.echo(f"❌ Failed to fetch YAML: {response.status_code}")
+        return
+
+    try:
+        data = yaml.safe_load(response.text)
+    except yaml.YAMLError as e:
+        click.echo(f"❌ Failed to parse YAML: {e}")
+        return
+
+    # ---- PIPELINE (new app YAML) ----
+    if "pipeline" in data:
+        pipeline = data.get("pipeline", {})
+
+        header = f"[bold green]{pipeline.get('name', app_name)}[/bold green] - {pipeline.get('category', 'Unknown')}"
+        desc = pipeline.get("short_description", "")
+
+        console = Console()
+        # Panel body holds description so it wraps
+        body = Text(desc, style="yellow", no_wrap=False)
+        panel_width = min(console.width, 100)
+
+        print(Panel(body, title=header, expand=False, width=80))
+
+        p_table = Table(title="Pipeline", header_style="bold magenta")
+        p_table.add_column("Field")
+        p_table.add_column("Value")
+        p_table.add_row("Input Format", pipeline.get("in_format", "-"))
+        p_table.add_row("Output Format", pipeline.get("out_format", "-"))
+
+        perf = pipeline.get("performance", {})
+        p_table.add_row("Davinci FPS", str(perf.get("davinci_fps", "-")))
+        p_table.add_row("Modalix FPS", str(perf.get("modalix_fps", "-")))
+
+        print(p_table)
+    # ---- MODEL(S) ----
+    if "model" in data:
+        models = data["model"]
+        if isinstance(models, dict):
+            models = [models]
+        elif not isinstance(models, list):
+            models = []
+
+        for idx, model in enumerate(models, start=1):
+            title = f"Model #{idx}" if len(models) > 1 else "Model"
+            m_table = Table(title=title, header_style="bold cyan")
+            m_table.add_column("Field")
+            m_table.add_column("Value")
+
+            m_table.add_row("Name", model.get("name", "-"))
+
+            if inp := model.get("input_description"):
+                m_table.add_row("Resolution", str(inp.get("resolution", "-")))
+                m_table.add_row("Format", inp.get("format", "-"))
+
+            if resize := model.get("resize_configuration"):
+                m_table.add_row("Resize Format", resize.get("input_image_format", "-"))
+                m_table.add_row("Input Shape", str(resize.get("input_shape", "-")))
+                m_table.add_row("Scaling Type", resize.get("scaling_type", "-"))
+                m_table.add_row("Padding Type", resize.get("padding_type", "-"))
+                m_table.add_row("Aspect Ratio", str(resize.get("aspect_ratio", "-")))
+
+            if norm := model.get("normalization_configuration"):
+                m_table.add_row("Channel Mean", str(norm.get("channel_mean", "-")))
+                m_table.add_row("Channel Stddev", str(norm.get("channel_stddev", "-")))
+                if "accuracy" in norm:
+                    m_table.add_row("Accuracy", str(norm.get("accuracy", "-")))
+
+            # Legacy model-centric fields
+            if "dataset" in model:
+                ds = model["dataset"]
+                m_table.add_row("Dataset", ds.get("name", "-"))
+                for k, v in (ds.get("params") or {}).items():
+                    m_table.add_row(k, str(v))
+                m_table.add_row("Accuracy", ds.get("accuracy", "-"))
+                m_table.add_row("Calibration", ds.get("calibration", "-"))
+
+            if "quantization_settings" in model:
+                q = model["quantization_settings"]
+                m_table.add_row("Calibration Samples", str(q.get("calibration_num_samples", "-")))
+                m_table.add_row("Calibration Method", q.get("calibration_method", "-"))
+                m_table.add_row("Requantization Mode", q.get("requantization_mode", "-"))
+                m_table.add_row("Bias Correction", str(q.get("bias_correction", "-")))
+
+            print(m_table)
+
+    # ---- PIPELINE TRANSFORMS (legacy YAML) ----
+    if "pipeline" in data and "transforms" in data["pipeline"]:
+        transforms = data["pipeline"]["transforms"]
+        if isinstance(transforms, list):
+            t_table = Table(title="Pipeline Transforms", header_style="bold green")
+            t_table.add_column("Name")
+            t_table.add_column("Params")
+
+            for step in transforms:
+                name = step.get("name")
+                params = step.get("params", {})
+                param_str = ", ".join(f"{k}={v}" for k, v in params.items()) if params else "-"
+                t_table.add_row(name, param_str)
+
+            print(t_table)
+
+    # If nothing useful parsed
+    if not any(k in data for k in ("pipeline", "model")):
+        click.echo("⚠️ YAML parsed, but no recognizable `pipeline` or `model` sections found.")
+
+def _download_app_internal(ver: str, app_name: str):
+    """
+    Download a specific app (.zip file) from Artifactory App Zoo, unzip it,
+    flatten the extracted content into the app folder, and clean up.
+    """
+    repo = "vdp"
+    base_path = f"vdp-app-config-default/{ver}/{app_name}"
+    aql_query = f"""
+        items.find({{
+            "repo": "{repo}",
+            "path": "{base_path}",
+            "name": {{"$match": "*.zip"}},
+            "type": "file"
+        }}).include("repo","path","name")
+    """.strip()
+
+    aql_url = f"{ARTIFACTORY_BASE_URL}/api/search/aql"
+    headers = {
+        "Content-Type": "text/plain",
+        "Authorization": f"Bearer {get_auth_token(internal=True)}"
+    }
+
+    response = requests.post(aql_url, data=aql_query, headers=headers)
+    if response.status_code != 200:
+        click.echo(f"❌ Failed to list app files. Status: {response.status_code}, path: {aql_url}")
+        click.echo(response.text)
+        return None
+
+    results = response.json().get("results", [])
+    if not results:
+        click.echo(f"⚠️ No .zip file found for app: {app_name}")
+        return None
+
+    # Expect only one .zip file per app
+    file_info = results[0]
+    file_path = file_info["path"]
+    file_name = file_info["name"]
+    download_url = f"{ARTIFACTORY_BASE_URL}/{repo}/{file_path}/{file_name}"
+
+    dest_dir = os.path.join(os.getcwd(), app_name)
+    os.makedirs(dest_dir, exist_ok=True)
+
+    click.echo(f"⬇️  Downloading app '{app_name}' to '{dest_dir}'...")
+
+    try:
+        local_zip = download_file_from_url(download_url, dest_folder=dest_dir, internal=True)
+        click.echo(f"✅ {file_name} -> {local_zip}")
+    except Exception as e:
+        click.echo(f"❌ Failed to download {file_name}: {e}")
+        return None
+
+    # Unzip into the destination folder
+    try:
+        with zipfile.ZipFile(local_zip, "r") as zip_ref:
+            zip_ref.extractall(dest_dir)
+        click.echo(f"📦 Extracted {file_name} into {dest_dir}")
+    except Exception as e:
+        click.echo(f"❌ Failed to unzip {file_name}: {e}")
+        return None
+
+    # Move contents up if unzipped into a nested folder
+    extracted_root = os.path.join(dest_dir, file_name.replace(".zip", ""))
+    if os.path.isdir(extracted_root):
+        for item in os.listdir(extracted_root):
+            src = os.path.join(extracted_root, item)
+            dst = os.path.join(dest_dir, item)
+            if os.path.isdir(src):
+                if os.path.exists(dst):
+                    shutil.rmtree(dst)
+                shutil.move(src, dst)
+            else:
+                shutil.move(src, dst)
+        shutil.rmtree(extracted_root)
+
+    # Remove the original zip file
+    try:
+        os.remove(local_zip)
+    except OSError:
+        pass
+
+    click.echo(f"✅ App '{app_name}' ready at {dest_dir}")
+    return dest_dir
+
+def _list_available_app_versions_internal(match_keyword: str = None):
+    """
+    List all available App Zoo versions from Artifactory (vdp-app-config-default).
+    If match_keyword is provided, only versions containing the keyword (case-insensitive) are returned.
+    """
+    repo = "vdp"
+    base_path = "vdp-app-config-default"
+    aql_query = f"""
+        items.find({{
+            "repo": "{repo}",
+            "path": {{"$match": "{base_path}/*"}},
+            "type": "folder"
+        }}).include("repo","path","name")
+    """.strip()
+
+    aql_url = f"{ARTIFACTORY_BASE_URL}/api/search/aql"
+    headers = {
+        "Content-Type": "text/plain",
+        "Authorization": f"Bearer {get_auth_token(internal=True)}"
+    }
+
+    response = requests.post(aql_url, data=aql_query, headers=headers)
+
+    if response.status_code == 401:
+        print('❌ You are not authorized to access Artifactory. Use `sima-cli -i login` with your Artifactory identity token to authenticate, then try again.')
+        return []
+
+    if response.status_code != 200:
+        print(f"❌ Failed to retrieve app versions (status {response.status_code})")
+        print(response.text)
+        return []
+
+    results = response.json().get("results", [])
+
+    # Versions = folder names under vdp-app-config-default/
+    versions = sorted({
+        item["path"].replace(base_path + "/", "").split("/")[0]
+        for item in results
+        if item["path"].startswith(base_path + "/")
+    })
+
+    if match_keyword:
+        mk = match_keyword.lower()
+        versions = [v for v in versions if mk in v.lower()]
+
+    return versions
+
+
+def _list_available_apps_internal(version: str):
+    """
+    List available app folders from Artifactory for the given SDK version.
+    Returns distinct top-level folders under vdp-app-config-default/{version}/.
+    After selecting an app, shows its description and action menu.
+    """
+    repo = "vdp"
+    base_prefix = f"vdp-app-config-default/{version}"
+    aql_query = f"""
+        items.find({{
+            "repo": "{repo}",
+            "path": {{"$match": "{base_prefix}/*"}}
+        }}).include("repo","path","name")
+    """.strip()
+
+    aql_url = f"{ARTIFACTORY_BASE_URL}/api/search/aql"
+    headers = {
+        "Content-Type": "text/plain",
+        "Authorization": f"Bearer {get_auth_token(internal=True)}"
+    }
+
+    response = requests.post(aql_url, data=aql_query, headers=headers)
+    if response.status_code != 200:
+        click.echo(f"❌ Failed to retrieve app list (status {response.status_code})")
+        click.echo(response.text)
+        return None
+
+    results = response.json().get("results", [])
+
+    # Collect only top-level folder names under {version}/
+    app_names = sorted({
+        item["path"].replace(base_prefix + "/", "").split("/")[0]
+        for item in results
+        if item["path"].startswith(base_prefix + "/")
+    })
+
+    if not app_names:
+        click.echo("⚠️ No apps found.")
+        return None
+
+    # Add Exit option at the bottom
+    app_names_with_exit = app_names + ["Exit"]
+
+    from InquirerPy import inquirer
+
+    while True:
+        # Step 1: Select app
+        selected_app = inquirer.fuzzy(
+            message=f"Select an app from version {version}:",
+            choices=app_names_with_exit,
+            max_height="70%",
+            instruction="(Use ↑↓ to navigate, / to search, Enter to select)"
+        ).execute()
+
+        if not selected_app or selected_app == "Exit":
+            click.echo("👋 Exiting.")
+            break
+
+        # Step 2: Describe the app
+        _describe_app_internal(version, selected_app)
+
+        # Step 3: Action menu
+        action = inquirer.select(
+            message=f"What would you like to do with {selected_app}?",
+            choices=["Download", "Back", "Exit"],
+            default="Back"
+        ).execute()
+
+        if action == "Download":
+            _download_app_internal(version, selected_app)
+            click.echo(f"✅ Downloaded {selected_app}")
+            # loop back to menu again after download
+        elif action == "Back":
+            # back to app list (continue loop)
+            continue
+        elif action == "Exit":
+            click.echo("👋 Exiting.")
+            break
+
+
+def list_apps(internal, ver):
+    if internal:
+        click.echo("App Zoo Source : SiMa Artifactory...")
+        versions = _list_available_app_versions_internal(ver)
+
+        if len(versions) == 1:
+            # Exactly one match → go straight to listing apps
+            return _list_available_apps_internal(versions[0])
+        elif len(versions) == 0:
+            print(f'❌ No version match found in Artifactory for [{ver}]')
+            return []
+        else:
+            # Multiple matches → prompt user to choose
+            click.echo("Multiple app zoo versions found matching your input:")
+
+            from InquirerPy import inquirer
+            selected_version = inquirer.fuzzy(
+                message="Select a version:",
+                choices=versions,
+                max_height="70%",  # scrollable
+                instruction="(Use ↑↓ to navigate, / to search, Enter to select)"
+            ).execute()
+
+            if not selected_version:
+                click.echo("No selection made. Exiting.", err=True)
+                raise SystemExit(1)
+
+            return _list_available_apps_internal(selected_version)
+
+    else:
+        print('External app zoo not supported yet')
+        return []
+
+def download_app(internal, ver, model_name):
+    if internal:
+        click.echo("App Zoo Source : SiMa Artifactory...")
+        return _download_app_internal(ver, model_name)
+    else:
+        print('External app zoo not supported yet')
+
+def describe_app(internal, ver, model_name):
+    if internal:
+        click.echo("App Zoo Source : SiMa Artifactory...")
+        return _describe_app_internal(ver, model_name)
+    else:
+        print('External app zoo not supported yet')
+
+# Module CLI tests
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python models.py <version>")
+    else:
+        version_arg = sys.argv[1]
+        _list_available_apps_internal(version_arg)

sima_cli/auth/basic_auth.py

@@ -121,7 +121,6 @@ def login_external():
         session.headers["X-CSRF-Token"] = csrf_token
 
         if _is_session_valid(session):
-            click.echo("🚀 You are already logged in.")
             return session
 
         # Fresh login prompt

sima_cli/cli.py

@@ -3,6 +3,7 @@ import click
 from sima_cli.utils.env import get_environment_type
 from sima_cli.update.updater import perform_update
 from sima_cli.model_zoo.model import list_models, download_model, describe_model
+from sima_cli.app_zoo.app import list_apps, download_app, describe_app
 from sima_cli.utils.config_loader import internal_resource_exists
 from sima_cli.mla.meminfo import monitor_simaai_mem_chart
 from sima_cli.__version__ import __version__ 
@@ -167,12 +168,25 @@ def update(ctx, version_or_url, ip, yes, passwd, flavor):
 # Model Zoo Subcommands
 # ----------------------
 @main.group()
-@click.option('--ver', default="1.6.0", show_default=True, help="SDK version, minimum and default is 1.6.0")
+@click.option(
+    "-v", "--ver", "--version",
+    "ver",
+    required=False,
+    help="SDK version (e.g. 1.7.0, 2.0.0). If not provided, you can select from available versions.",
+)
+@click.option(
+    "--boardtype",
+    type=click.Choice(["mlsoc", "modalix"], case_sensitive=False),
+    default='modalix',
+    required=False,
+    help="Target board type (mlsoc or modalix).",
+)
 @click.pass_context
-def modelzoo(ctx, ver):
+def modelzoo(ctx, ver, boardtype):
     """Access models from the Model Zoo."""
     ctx.ensure_object(dict)
     ctx.obj['ver'] = ver
+    ctx.obj["boardtype"] = boardtype
     internal = ctx.obj.get("internal", False)
     if not internal:
         click.echo(f"Public developer portal environment is not supported yet..")
@@ -186,8 +200,9 @@ def list_models_cmd(ctx):
     """List available models."""
     internal = ctx.obj.get("internal", False)
     version = ctx.obj.get("ver")
+    boardtype = ctx.obj.get('boardtype')
     click.echo(f"Listing models for version: {version}")
-    list_models(internal, version)
+    list_models(internal, version, boardtype)
 
 @modelzoo.command("get")
 @click.argument('model_name') 
@@ -209,6 +224,57 @@ def get_model(ctx, model_name):
     click.echo(f"Getting model '{model_name}' for version: {ver}")
     describe_model(internal, ver, model_name)
 
+# ----------------------
+# App Zoo Subcommands
+# ----------------------
+@main.group()
+@click.option(
+    "-v", "--ver", "--version",
+    "ver",
+    required=False,
+    help="SDK version (e.g. 1.7.0, 2.0.0). If not provided, you can select from available versions.",
+)
+@click.pass_context
+def appzoo(ctx, ver):
+    """Access models from the Model Zoo."""
+    ctx.ensure_object(dict)
+    ctx.obj['ver'] = ver
+    internal = ctx.obj.get("internal", False)
+    if not internal:
+        click.echo(f"Public developer portal environment is not supported yet..")
+        exit(0)
+
+    pass
+
+@appzoo.command("list")
+@click.pass_context
+def list_apps_cmd(ctx):
+    """List available models."""
+    internal = ctx.obj.get("internal", False)
+    version = ctx.obj.get("ver")
+    click.echo(f"Listing apps for version: {version}")
+    list_apps(internal, version)
+
+@appzoo.command("get")
+@click.argument('app_name') 
+@click.pass_context
+def get_app(ctx, app_name):
+    """Download a specific model."""
+    ver = ctx.obj.get("ver")
+    internal = ctx.obj.get("internal", False)
+    click.echo(f"Getting app '{app_name}' for version: {ver}")
+    download_app(internal, ver, app_name)
+
+@appzoo.command("describe")
+@click.argument('app_name') 
+@click.pass_context
+def get_model(ctx, app_name):
+    """Download a specific model."""
+    ver = ctx.obj.get("ver")
+    internal = ctx.obj.get("internal", False)
+    click.echo(f"Getting model '{app_name}' for version: {ver}")
+    describe_app(internal, ver, app_name)
+
 # ----------------------
 # Authentication Command
 # ----------------------
@@ -313,9 +379,7 @@ def install_cmd(ctx, component, version, mirror, tag):
         if component:
             click.echo(f"⚠️ Component '{component}' is ignored when using --metadata. Proceeding with metadata-based installation.")
         click.echo(f"🔧 Installing generic component from metadata URL: {mirror}")
-        if install_from_metadata(metadata_url=mirror, internal=internal):
-            click.echo("✅ Installation complete.")
-        return
+        return install_from_metadata(metadata_url=mirror, internal=internal)
 
     # No component and no metadata: error
     if not component:
@@ -324,6 +388,10 @@ def install_cmd(ctx, component, version, mirror, tag):
 
     component = component.lower()
 
+    # if user specified gh: as component, treat it the same as -m
+    if component.startswith("gh:"):
+        return install_from_metadata(metadata_url=component, internal=False)
+
     # Validate version requirement
     if component in SDK_DEPENDENT_COMPONENTS and not version:
         click.echo(f"❌ The component '{component}' requires a specific SDK version. Please provide one using -v.")

sima_cli/download/downloader.py

@@ -135,6 +135,38 @@ def download_file_from_url(url: str, dest_folder: str = ".", internal: bool = Fa
 
     return dest_path
 
+def check_url_available(url: str, internal: bool = False) -> bool:
+    """
+    Perform a HEAD request to check if a resource is available.
+
+    Args:
+        url (str): The full URL to check.
+        internal (bool): Whether this is an internal resource on Artifactory.
+
+    Returns:
+        bool: True if the resource is available (status 200–399), False otherwise.
+    """
+    headers = {}
+    try:
+        if internal:
+            auth_token = get_auth_token(internal=True)
+            if auth_token:
+                headers["Authorization"] = f"Bearer {auth_token}"
+            head_fn = requests.head
+        elif 'https://docs.sima.ai' in url:
+            session = login_external()
+            head_fn = session.head
+        else:
+            session = requests.Session()
+            head_fn = session.head
+
+        resp = head_fn(url, headers=headers, timeout=10, allow_redirects=True)
+        # Consider any 2xx or 3xx as "available"
+        return 200 <= resp.status_code < 400
+
+    except Exception as e:
+        print(f"⚠️ HEAD check failed for {url}: {e}")
+        return False
 
 def download_folder_from_url(url: str, dest_folder: str = ".", internal: bool = False) -> List[str]:
     """

sima_cli/install/metadata_installer.py

@@ -8,6 +8,7 @@ import shutil
 import tarfile
 import zipfile
 import stat
+import shlex
 from urllib.parse import urlparse
 
 from typing import Dict
@@ -15,6 +16,7 @@ from tqdm import tqdm
 from urllib.parse import urljoin
 from pathlib import Path
 import subprocess
+import requests
 
 from rich.console import Console
 from rich.panel import Panel
@@ -29,7 +31,224 @@ from sima_cli.install.metadata_info import print_metadata_summary, parse_size_st
 
 console = Console()
 
-def _download_assets(metadata: dict, base_url: str, dest_folder: str, internal: bool = False, skip_models: bool = False) -> list:
+def _copy_dir(src: Path, dest: Path, label: str):
+    """
+    Copy files from src → dest, merging with existing files (no deletion).
+    Does NOT overwrite files if they already exist.
+    Ensures that all parent directories for dest are created.
+    """
+    if not src.exists():
+        raise FileNotFoundError(f"SDK {label} not found: {src}")
+
+    dest.mkdir(parents=True, exist_ok=True)
+
+    for item in src.iterdir():
+        target = dest / item.name
+        if item.is_dir():
+            _copy_dir(item, target, label)
+        else:
+            if not target.exists():
+                shutil.copy2(item, target)
+    
+    click.echo(f"✅ Copied {label} into {dest}")
+
+def _prepare_pipeline_project(repo_dir: Path):
+    """
+    Prepare a pipeline project by copying required SDK sources into the repo.
+
+    Steps:
+      1. Copy core sources into the project folder
+      2. Parse .project/pluginsInfo
+      3. Copy required plugin sources from the SDK plugin zoo
+    """
+    plugins_info_file = repo_dir / ".project" / "pluginsInfo.json"
+    if not plugins_info_file.exists():
+        return 
+
+    click.echo("📦 Preparing pipeline project...")
+
+    try:
+        data = json.loads(plugins_info_file.read_text())
+        plugins = data.get("pluginsInfo", [])
+    except Exception as e:
+        raise RuntimeError(f"Failed to read {plugins_info_file}: {e}")
+
+    # Step a: copy core
+    # Define what to copy
+    copy_map = [
+        (
+            Path("/usr/local/simaai/plugin_zoo/gst-simaai-plugins-base/core"),
+            repo_dir / "core",
+            "core"
+        ),
+        (
+            Path("/usr/local/simaai/utils/gst_app"),
+            repo_dir / "dependencies" / "gst_app",
+            "dependencies/gst_app"
+        ),
+        (
+            Path("/usr/local/simaai/plugin_zoo/gst-simaai-plugins-base/gst/templates"),
+            repo_dir / "plugins" / "templates",
+            "plugins/templates"
+        ),
+    ]
+
+    # Execute
+    for src, dest, label in copy_map:
+        _copy_dir(src, dest, label)
+
+    # Step b/c: scan plugin paths and copy SDK plugins
+    sdk_plugins_base = Path("/usr/local/simaai/plugin_zoo/gst-simaai-plugins-base/gst")
+    sdk_alt_base = sdk_plugins_base / "PyGast-plugins"
+
+    dest_plugins_dir = repo_dir / "plugins"
+    dest_plugins_dir.mkdir(exist_ok=True)
+
+    for plugin in plugins:
+        try:
+            path = plugin.get("path", "")
+            if not path:
+                continue
+            parts = path.split("/")
+            if len(parts) < 2:
+                continue
+
+            plugin_name = parts[1]
+
+            # Look first in gst/, then fallback to gst/PyGast-plugins/
+            sdk_plugin_path = sdk_plugins_base / plugin_name
+            if not sdk_plugin_path.exists():
+                sdk_plugin_path = sdk_alt_base / plugin_name
+
+            if not sdk_plugin_path.exists():
+                click.echo(
+                    f"⚠️ Missing plugin source: {plugin_name} in the SDK, skipping. "
+                    "It is likely a custom plugin already in the repo so it's safe to ignore this warning."
+                )
+                continue
+
+            dest_plugin_path = dest_plugins_dir / plugin_name
+            dest_plugin_path.mkdir(parents=True, exist_ok=True)
+
+            # Walk the SDK plugin dir and copy only missing files
+            for src_file in sdk_plugin_path.rglob("*"):
+                if src_file.is_file():
+                    rel_path = src_file.relative_to(sdk_plugin_path)
+                    dest_file = dest_plugin_path / rel_path
+                    if dest_file.exists():
+                        click.echo(f"↩️  Skipped existing file in the repo: {dest_file}")
+                        continue
+                    dest_file.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(src_file, dest_file)
+
+            click.echo(f"✅ Copied plugin {plugin_name} into {dest_plugin_path} (safe copy)")
+
+        except Exception as e:
+            click.echo(f"❌ Error copying plugin {plugin}: {e}")
+
+    click.echo("🎉 Pipeline project prepared.")
+
+def _download_requirements_wheels(repo_dir: Path):
+    """
+    Look for resources/dependencies/requirements.txt under the repo,
+    parse each line, and download wheels into the same folder.
+    Supports optional pip download flags in parentheses.
+
+    Example line formats:
+        jax==0.6.2
+        jaxlib==0.6.2 (--platform manylinux2014_aarch64 --python-version 310 --abi cp310)
+    """
+    deps_dir = repo_dir / "resources" / "dependencies"
+    req_file = deps_dir / "requirements.txt"
+
+    if not req_file.exists():
+        click.echo("⚠️ No requirements.txt found under resources/dependencies, skipping wheel download.")
+        return
+
+    deps_dir.mkdir(parents=True, exist_ok=True)
+
+    with req_file.open("r") as f:
+        lines = [line.strip() for line in f if line.strip() and not line.startswith("#")]
+
+    if not lines:
+        click.echo("⚠️ requirements.txt is empty, nothing to download.")
+        return
+
+    for line in lines:
+        # Split package and extra params if present
+        if "(" in line and ")" in line:
+            pkg_part, extra = line.split("(", 1)
+            package = pkg_part.strip()
+            extra_args = shlex.split(extra.strip(") "))
+        else:
+            package = line.strip()
+            extra_args = []
+
+        click.echo(f"⬇️  Downloading {package} {extra_args if extra_args else ''}")
+
+        try:
+            cmd = [
+                "pip3", "download", "--no-deps",
+                "--only-binary=:all:",
+                "-d", str(deps_dir),
+                package,
+            ] + extra_args
+
+            rc = os.system(" ".join(shlex.quote(c) for c in cmd))
+            if rc != 0:
+                click.echo(f"❌ pip download failed for {package}")
+            else:
+                click.echo(f"✅ Downloaded {package} into {deps_dir}")
+        except Exception as e:
+            click.echo(f"❌ Error downloading {package}: {e}")
+
+def _download_github_repo(owner: str, repo: str, ref: str, dest_folder: str, token: str = None) -> str:
+    """
+    Download and extract a GitHub repo tarball via the REST API (no git required).
+
+    Args:
+        owner (str): GitHub org/user
+        repo (str): Repo name
+        ref (str): Branch, tag, or commit (default = default branch)
+        dest_folder (str): Where to extract
+        token (str): Optional GitHub token for private repos
+
+    Returns:
+        str: Path to the extracted repo
+    """
+    url = f"https://api.github.com/repos/{owner}/{repo}/tarball/{ref}" if ref else f"https://api.github.com/repos/{owner}/{repo}/tarball"
+    headers = {}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    click.echo(f"🐙 Downloading GitHub repo: {owner}/{repo}" + (f"@{ref}" if ref else ""))
+
+    with requests.get(url, headers=headers, stream=True) as r:
+        if r.status_code in (401, 403):
+            raise PermissionError("Authentication required for GitHub repo")
+        r.raise_for_status()
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".tar.gz") as tmp_file:
+            for chunk in r.iter_content(chunk_size=8192):
+                tmp_file.write(chunk)
+            tmp_path = Path(tmp_file.name)
+
+    repo_dir = Path(dest_folder) / repo
+    repo_dir.mkdir(parents=True, exist_ok=True)
+
+    _extract_tar_strip_top_level(tmp_path, repo_dir)
+    tmp_path.unlink(missing_ok=True)
+    click.echo(f"✅ Downloaded GitHub repo to folder: {repo_dir}")
+    _download_requirements_wheels(repo_dir=repo_dir)
+
+    try:
+        _prepare_pipeline_project(repo_dir)
+    except Exception as e:
+        click.echo(f"⚠️  Pipeline preparation skipped: {e}")
+
+    return str(repo_dir)
+
+def _download_assets(metadata: dict, base_url: str, dest_folder: str, internal: bool = False, skip_models: bool = False, tag: str = None) -> list:
     """
     Downloads resources defined in metadata to a local destination folder.
 
@@ -39,6 +258,7 @@ def _download_assets(metadata: dict, base_url: str, dest_folder: str, internal:
         dest_folder (str): Local path to download resources into
         internal (bool): Whether to use internal download routing (if applicable)
         skip_models (bool): If True, skips downloading any file path starting with 'models/'
+        tag (str): metadata.json tag from GitHub will be passed into the resources in the file
 
     Returns:
         list: Paths to the downloaded local files
@@ -84,11 +304,34 @@ def _download_assets(metadata: dict, base_url: str, dest_folder: str, internal:
                 model_path = snapshot_download(
                     repo_id=repo_id,
                     local_dir=target_dir,
-                    revision=revision  # None if not specified
+                    local_dir_use_symlinks=False
                 )
                 local_paths.append(model_path)
                 continue
 
+            if resource.startswith("gh:"):
+                resource_spec = resource[3:]
+                if "@" in resource_spec:
+                    repo_id, ref = resource_spec.split("@", 1)
+                else:
+                    repo_id, ref = resource_spec, tag
+
+                if "/" not in repo_id:
+                    raise click.ClickException(f"❌ Invalid GitHub repo spec: {resource}")
+
+                owner, name = repo_id.split("/", 1)
+
+                try:
+                    token = os.getenv("GITHUB_TOKEN", None)
+                    repo_path = _download_github_repo(owner, name, ref, dest_folder, token)
+                except Exception as e:
+                    raise click.ClickException(
+                        f"❌ Failed to download GitHub repo {owner}/{name}@{ref or 'default'}: {e}"
+                    )
+
+                local_paths.append(repo_path)
+                continue
+
             # Handle normal relative or absolute URLs
             resource_url = urljoin(base_url, resource)
             local_path = download_file_from_url(
@@ -296,6 +539,25 @@ def _extract_zip_streaming(zip_path: Path, extract_dir: Path, overwrite: bool =
 
     print(f"✅ Extracted {len(members)} entries to {extract_dir}/")
 
+def _extract_tar_strip_top_level(tar_path: Path, extract_dir: Path):
+    """Extract a GitHub tarball, stripping the top-level folder."""
+    with tarfile.open(tar_path, "r:*") as tar:
+        members = tar.getmembers()
+
+        # Detect top-level prefix (first part before '/')
+        top_level = None
+        if members:
+            first_name = members[0].name
+            top_level = first_name.split("/", 1)[0]
+
+        for member in members:
+            # Strip top-level folder
+            if top_level and member.name.startswith(top_level + "/"):
+                member.name = member.name[len(top_level) + 1 :]
+            if not member.name:
+                continue
+            tar.extract(member, path=extract_dir)
+
 def _combine_multipart_files(folder: str):
     """
     Scan a folder for multipart files like name-split-aa, -ab, etc.,
@@ -353,20 +615,27 @@ def _combine_multipart_files(folder: str):
 
         print(f"✅ Extracted to: {extract_dir}/")
 
-def _extract_archives_in_folder(folder: str):
+def _extract_archives_in_folder(folder: str, local_paths):
     """
-    Extract all .tar.gz and .zip files in the given folder into subdirectories.
+    Extract .tar, .gz, .tar.gz, and .zip files in the given folder,
+    but only if they are listed in local_paths.
     Uses streaming to avoid NFS performance issues.
     """
     folder = Path(folder)
+    local_paths = {str(Path(p).resolve()) for p in local_paths}
+
     for file in folder.iterdir():
         if not file.is_file():
             continue
 
-        # TAR.GZ
-        if file.suffixes == [".tar", ".gz"] or file.name.endswith(".tar.gz"):
+        file_resolved = str(file.resolve())
+        if file_resolved not in local_paths:
+            continue
+
+        # TAR, GZ, TAR.GZ → all handled by _extract_tar_streaming
+        if file.suffix in [".tar", ".gz"] or file.name.endswith(".tar.gz"):
             extract_dir = folder / file.stem.replace(".tar", "")
-            print(f"📦 Extracting TAR.GZ: {file.name} to {extract_dir}/")
+            print(f"📦 Extracting TAR/GZ: {file.name} to {extract_dir}/")
             _extract_tar_streaming(file, extract_dir)
 
         # ZIP
@@ -471,17 +740,56 @@ def _run_installation_script(metadata: Dict, extract_path: str = "."):
 
     print("✅ Installation completed successfully.")
 
+def _resolve_github_metadata_url(gh_ref: str) -> str:
+    """
+    Resolve a GitHub shorthand like gh:org/repo@tag into a raw URL for metadata.json.
+    If tag is omitted, defaults to 'main'.
+    """
+    try:
+        _, repo_ref = gh_ref.split(":", 1)  # remove 'gh:'
+        if "@" in repo_ref:
+            org_repo, tag = repo_ref.split("@", 1)
+        else:
+            org_repo, tag = repo_ref, "main"
+
+        owner, repo = org_repo.split("/", 1)
+        token = os.getenv("GITHUB_TOKEN")
+
+        # Use GitHub API to fetch the metadata.json file
+        api_url = f"https://api.github.com/repos/{owner}/{repo}/contents/metadata.json?ref={tag}"
+        headers = {"Accept": "application/vnd.github.v3.raw"}
+        if token:
+            headers["Authorization"] = f"token {token}"
+
+        r = requests.get(api_url, headers=headers)
+        r.raise_for_status()
+        
+        # Write metadata.json locally so downstream logic can use a file/URL
+        local_path = os.path.join("/tmp", f"{repo}-{tag}-metadata.json")
+        with open(local_path, "wb") as f:
+            f.write(r.content)
+
+        return local_path, tag
+    except Exception as e:
+        raise RuntimeError(f"Failed to resolve GitHub metadata URL {gh_ref}: {e}")
+
 def install_from_metadata(metadata_url: str, internal: bool, install_dir: str = '.'):
     try:
+        tag = None
+
+        if metadata_url.startswith("gh:"):
+            metadata_url, tag = _resolve_github_metadata_url(metadata_url)
+            internal = False
+
         metadata, _ = _download_and_validate_metadata(metadata_url, internal)
         print_metadata_summary(metadata=metadata)
 
         if _check_whether_disk_is_big_enough(metadata):
             if _is_platform_compatible(metadata):
-                local_paths = _download_assets(metadata, metadata_url, install_dir, internal)
+                local_paths = _download_assets(metadata, metadata_url, install_dir, internal, tag=tag)
                 if len(local_paths) > 0:
                     _combine_multipart_files(install_dir)
-                    _extract_archives_in_folder(install_dir)
+                    _extract_archives_in_folder(install_dir, local_paths)
                     _run_installation_script(metadata=metadata, extract_path=install_dir)
 
     except Exception as e:

sima_cli/model_zoo/model.py

@@ -4,6 +4,7 @@ import requests
 import click
 import os
 import yaml
+from InquirerPy import inquirer
 from urllib.parse import urlparse
 from rich import print
 from rich.table import Table
@@ -186,35 +187,38 @@ def _download_model_internal(ver: str, model_name: str):
             else:
                 click.echo("⚠️ model_path.txt exists but does not contain a valid URL.")
 
-def _list_available_models_internal(version: str):
+def _list_available_models_internal(version: str, boardtype: str):
+    """
+    Query Artifactory for available models for the given SDK version.
+    Display them in an interactive menu with an 'Exit' option.
+    Apply boardtype filtering:
+      - gen1_target* → only shown for mlsoc
+      - gen2_target* → only shown for modalix
+      - others → always shown
+    """
     repo_path = f"SiMaCLI-SDK-Releases/{version}-Release/modelzoo_edgematic"
     aql_query = f"""
-                items.find({{
-                "repo": "sima-qa-releases",
-                "path": {{
-                    "$match": "{repo_path}/*"
-                }},
-                "type": "folder"
-                }}).include("repo", "path", "name")
-                """.strip()
+        items.find({{
+            "repo": "sima-qa-releases",
+            "path": {{"$match": "{repo_path}/*"}},
+            "type": "folder"
+        }}).include("repo","path","name")
+    """.strip()
 
     aql_url = f"{ARTIFACTORY_BASE_URL}/api/search/aql"
-    print(aql_url)
     headers = {
         "Content-Type": "text/plain",
         "Authorization": f"Bearer {get_auth_token(internal=True)}"
     }
 
     response = requests.post(aql_url, data=aql_query, headers=headers)
-
     if response.status_code != 200:
-        click.echo(f"Failed to retrieve model list. Status: {response.status_code}")
+        click.echo(f"❌ Failed to retrieve model list (status {response.status_code})")
         click.echo(response.text)
-        return
+        return None
 
     results = response.json().get("results", [])
-    
-    base_prefix = f"SiMaCLI-SDK-Releases/{version}-Release/modelzoo_edgematic/"
+    base_prefix = f"{repo_path}/"
     model_paths = sorted({
         item["path"].replace(base_prefix, "").rstrip("/") + "/" + item["name"]
         for item in results
@@ -222,20 +226,63 @@ def _list_available_models_internal(version: str):
 
     if not model_paths:
         click.echo("No models found.")
-        return
-
-    # Pretty print table
-    max_len = max(len(name) for name in model_paths)
-    click.echo(f"{'-' * max_len}")
-    for path in model_paths:
-        click.echo(path.ljust(max_len))
-
-    return model_paths
-
-def list_models(internal, ver):
+        return None
+
+    # Apply boardtype filtering
+    filtered_models = []
+    for model in model_paths:
+        if model.startswith("gen1_target") and boardtype != "mlsoc":
+            continue
+        if model.startswith("gen2_target") and boardtype != "modalix":
+            continue
+        filtered_models.append(model)
+
+    if not filtered_models:
+        click.echo(f"No models found for board type '{boardtype}'.")
+        return None
+
+    while True:
+        # Add Exit option
+        choices = filtered_models + ["Exit"]
+
+        # Interactive selection with InquirerPy
+        selected_model = inquirer.fuzzy(
+            message=f"Select a model from version {version}:",
+            choices=choices,
+            max_height="70%",
+            instruction="(Use ↑↓ to navigate, / to search, Enter to select)"
+        ).execute()
+
+        if selected_model == "Exit":
+            click.echo("👋 Exiting without selecting a model.")
+            return None
+
+        click.echo(f"✅ Selected model: {selected_model}")
+
+        # Auto-describe
+        _describe_model_internal(version, selected_model)
+
+        # Action menu loop
+        while True:
+            action = inquirer.select(
+                message=f"What do you want to do with {selected_model}?",
+                choices=["Download model", "Back", "Exit"],
+                default="Download model",
+                qmark="👉",
+            ).execute()
+
+            if action == "Download model":
+                _download_model_internal(version, selected_model)
+            elif action == "Back":
+                break  # back to model list
+            else:  # Exit
+                click.echo("👋 Exiting.")
+                return None
+
+def list_models(internal, ver, boardtype):
     if internal:
         click.echo("Model Zoo Source : SiMa Artifactory...")
-        return _list_available_models_internal(ver)
+        return _list_available_models_internal(ver, boardtype)
     else:
         print('External model zoo not supported yet')
 
@@ -260,4 +307,5 @@ if __name__ == "__main__":
         print("Usage: python models.py <version>")
     else:
         version_arg = sys.argv[1]
-        _list_available_models_internal(version_arg)
+        boardtype = sys.argv[2]
+        _list_available_models_internal(version_arg, boardtype)

{sima_cli-0.0.35.dist-info → sima_cli-0.0.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sima-cli
-Version: 0.0.35
+Version: 0.0.37
 Summary: CLI tool for SiMa Developer Portal to download models, firmware, and apps.
 Home-page: https://developer.sima.ai/
 Author: SiMa.ai

{sima_cli-0.0.35.dist-info → sima_cli-0.0.37.dist-info}/RECORD

@@ -1,26 +1,26 @@
 sima_cli/__init__.py,sha256=Nb2jSg9-CX1XvSc1c21U9qQ3atINxphuNkNfmR-9P3o,332
 sima_cli/__main__.py,sha256=ehzD6AZ7zGytC2gLSvaJatxeD0jJdaEvNJvwYeGsWOg,69
-sima_cli/__version__.py,sha256=dV_wUomyW1FHtFgcX6fG1NT7ViHhyASu0XFi6X2mgRA,49
-sima_cli/cli.py,sha256=qnAQtlaM87tM8t9663NTIxxqMWIpU5--4V-v_0-gYZQ,17224
+sima_cli/__version__.py,sha256=4m-QBPuK5Old2YxxO8B7YbrZhHPXQ0fWWTNKgReu9TE,49
+sima_cli/cli.py,sha256=uPfpXDkmX_bv5s1zjUD_pZabxnRxihg6ad_2obs9IZ8,19276
 sima_cli/app_zoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sima_cli/app_zoo/app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sima_cli/app_zoo/app.py,sha256=6u3iIqVZkuMK49kK0f3dVJCCf5-qC-xzLOS78-TkeN8,15738
 sima_cli/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sima_cli/auth/basic_auth.py,sha256=ht_mVXBtxV2UGvUYwvhkPHs4cMWL5Hw2B_OFxWdKw6c,8825
+sima_cli/auth/basic_auth.py,sha256=UMEXCCnNQpjpp6RZxREs6iiKtYyaeqZBnTSR0wA8s6Q,8767
 sima_cli/auth/login.py,sha256=nE-dSHK_husXw1XJaEcOe3I1_bnwHkLgO_BqKuQODDM,3781
 sima_cli/data/resources_internal.yaml,sha256=zlQD4cSnZK86bLtTWuvEudZTARKiuIKmB--Jv4ajL8o,200
 sima_cli/data/resources_public.yaml,sha256=U7hmUomGeQ2ULdo1BU2OQHr0PyKBamIdK9qrutDlX8o,201
 sima_cli/download/__init__.py,sha256=6y4O2FOCYFR2jdnQoVi3hRtEoZ0Gw6rydlTy1SGJ5FE,218
-sima_cli/download/downloader.py,sha256=nCBrr_0WdnKTIyecwKpg1sCdfm_4PSQTRPwEbiezy8M,5339
+sima_cli/download/downloader.py,sha256=UQdrBWLQsPQygaoVaufOjbzWmRoNnk6pgLdnbnVi04U,6436
 sima_cli/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/install/hostdriver.py,sha256=kAWDLebs60mbWIyTbUxmNrChcKW1uD5r7FtWNSUVUE4,5852
 sima_cli/install/metadata_info.py,sha256=wmMqwzGfXbuilkqaxRVrFOzOtTOiONkmPCyA2oDAQpA,2168
-sima_cli/install/metadata_installer.py,sha256=kWhERFYfv3hkfAkFJ5yIMu0vv4Kkav8w1DPOOQEysmc,19098
+sima_cli/install/metadata_installer.py,sha256=DtfuyBy0eGm6itL6wC9d4tj16nIDRxvszEQ7z2ogW74,30306
 sima_cli/install/metadata_validator.py,sha256=7954rp9vFRNnqmIMvCVTjq40kUIEbGXzfc8HmQmChe0,5221
 sima_cli/install/optiview.py,sha256=r4DYdQDTUbZVCR87hl5T21gsjZrhqpU8hWnYxKmUJ_k,4790
 sima_cli/install/palette.py,sha256=uRznoHa4Mv9ZXHp6AoqknfC3RxpYNKi9Ins756Cyifk,3930
 sima_cli/mla/meminfo.py,sha256=ndc8kQJmWGEIdvNh6iIhATGdrkqM2pbddr_eHxaPNfg,1466
 sima_cli/model_zoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sima_cli/model_zoo/model.py,sha256=q91Nrg62j1TqwPO8HiX4nlEFCCmzNEFcyFTBVMbJm8w,9836
+sima_cli/model_zoo/model.py,sha256=WjkVd5ZNadWkBRaOpiBBvgFmrZ2CcEtV56vj3h63eH8,11613
 sima_cli/network/network.py,sha256=kXYI2oxgeIg7LoGt2VKF9JlK8DIfQT87A9-x-D6uHCA,7714
 sima_cli/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/sdk/syscheck.py,sha256=h9zCULW67y4i2hqiGc-hc1ucBDShA5FAe9NxwBGq-fM,4575
@@ -46,7 +46,7 @@ sima_cli/utils/env.py,sha256=LtV8S1kCkOpi-7Gj4rhidQRN13x_NDKy4W_LxujheeI,8400
 sima_cli/utils/net.py,sha256=WVntA4CqipkNrrkA4tBVRadJft_pMcGYh4Re5xk3rqo,971
 sima_cli/utils/network.py,sha256=UvqxbqbWUczGFyO-t1SybG7Q-x9kjUVRNIn_D6APzy8,1252
 sima_cli/utils/pkg_update_check.py,sha256=IAV_NAOsBDL_lYNYMRYfdZWuVq-rJ_zzHjJJZ7UQaoc,3274
-sima_cli-0.0.35.dist-info/licenses/LICENSE,sha256=a260OFuV4SsMZ6sQCkoYbtws_4o2deFtbnT9kg7Rfd4,1082
+sima_cli-0.0.37.dist-info/licenses/LICENSE,sha256=a260OFuV4SsMZ6sQCkoYbtws_4o2deFtbnT9kg7Rfd4,1082
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_app_zoo.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_auth.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -55,8 +55,8 @@ tests/test_download.py,sha256=t87DwxlHs26_ws9rpcHGwr_OrcRPd3hz6Zmm0vRee2U,4465
 tests/test_firmware.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_model_zoo.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sima_cli-0.0.35.dist-info/METADATA,sha256=wT-QS9rbFlezkg5M_CmGhmMmHhxZ4XqPVovYiLJLSRw,3705
-sima_cli-0.0.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sima_cli-0.0.35.dist-info/entry_points.txt,sha256=xRYrDq1nCs6R8wEdB3c1kKuimxEjWJkHuCzArQPT0Xk,47
-sima_cli-0.0.35.dist-info/top_level.txt,sha256=FtrbAUdHNohtEPteOblArxQNwoX9_t8qJQd59fagDlc,15
-sima_cli-0.0.35.dist-info/RECORD,,
+sima_cli-0.0.37.dist-info/METADATA,sha256=q4R_yQkhPyP_qD9c7ZIwI5RN-2wnMVyw1mChmwrhG4o,3705
+sima_cli-0.0.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sima_cli-0.0.37.dist-info/entry_points.txt,sha256=xRYrDq1nCs6R8wEdB3c1kKuimxEjWJkHuCzArQPT0Xk,47
+sima_cli-0.0.37.dist-info/top_level.txt,sha256=FtrbAUdHNohtEPteOblArxQNwoX9_t8qJQd59fagDlc,15
+sima_cli-0.0.37.dist-info/RECORD,,