sima-cli 0.0.18__py3-none-any.whl → 0.0.19__py3-none-any.whl

sima_cli/__version__.py

@@ -1,2 +1,2 @@
 # sima_cli/__version__.py
-__version__ = "0.0.18"
+__version__ = "0.0.19"

sima_cli/auth/login.py

@@ -61,14 +61,14 @@ def login_internal():
     click.echo(f"✅ Identity token is valid")
 
     # Step 2: Exchange for a short-lived access token (default: 7 days)
-    access_token, user_name = exchange_identity_token(identity_token, exchange_url, expires_in=604800)
+    access_token, user_name = exchange_identity_token(identity_token, exchange_url, expires_in=1209600)
 
     if not access_token:
         return click.echo("❌ Failed to acquire short-lived access token.")
 
     # Step 3: Save token to internal auth config
     set_auth_token(access_token, internal=True)
-    click.echo(f"💾 Short-lived access token saved successfully for {user_name} (valid for 7 days).")
+    click.echo(f"💾 Short-lived access token saved successfully for {user_name} (valid for 14 days).")
 
 
 def _login_external():

sima_cli/cli.py

@@ -7,6 +7,8 @@ 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__ 
 from sima_cli.utils.config import CONFIG_PATH
+from sima_cli.install.optiview import install_optiview
+from sima_cli.install.hostdriver import install_hostdriver
 
 # Entry point for the CLI tool using Click's command group decorator
 @click.group()
@@ -164,7 +166,7 @@ def modelzoo(ctx, ver):
     ctx.obj['ver'] = ver
     internal = ctx.obj.get("internal", False)
     if not internal:
-        click.echo(f"external environment is not supported yet..")
+        click.echo(f"Public developer portal environment is not supported yet..")
         exit(0)
 
     pass
@@ -217,6 +219,84 @@ def show_mla_memory_usage(ctx):
     monitor_simaai_mem_chart()
     pass
 
+
+# ----------------------
+# bootimg Command
+# ----------------------
+@main.command(name="bootimg")
+@click.option("-v", "--version", required=True, help="Firmware version to download and write (e.g., 1.6.0)")
+@click.option("--boardtype", type=click.Choice(["modalix", "mlsoc"], case_sensitive=False), default="mlsoc", show_default=True, help="Target board type.")
+@click.pass_context
+def bootimg_cmd(ctx, version, boardtype):
+    """
+    Download and burn a bootable image onto removable media (e.g., SD card or USB stick).
+
+    Examples:
+      sima-cli bootimg -v 1.6.0
+      sima-cli bootimg -v 1.6.0 --boardtype mlsoc
+      sima-cli bootimg -v 1.6.0 --boardtype modalix
+    """
+
+    from sima_cli.update.bootimg import write_image
+
+    internal = ctx.obj.get("internal", False)
+
+    click.echo(f"📦 Preparing boot image:")
+    click.echo(f"   🔹 Version   : {version}")
+    click.echo(f"   🔹 Board Type: {boardtype}")
+    
+    try:
+        boardtype = boardtype if boardtype != 'mlsoc' else 'davinci'
+        write_image(version, boardtype, 'yocto', internal)
+        click.echo("✅ Boot image successfully written.")
+    except Exception as e:
+        click.echo(f"❌ Failed to write boot image: {e}", err=True)
+        ctx.exit(1)
+
+# ----------------------
+# install Command
+# ----------------------
+SDK_DEPENDENT_COMPONENTS = {"palette", "hostdriver"}
+SDK_INDEPENDENT_COMPONENTS = {"optiview"}
+ALL_COMPONENTS = SDK_DEPENDENT_COMPONENTS | SDK_INDEPENDENT_COMPONENTS
+
+@main.command(name="install")
+@click.argument("component", type=click.Choice(ALL_COMPONENTS, case_sensitive=False))
+@click.option("-v", "--version", help="SDK version (required for SDK-dependent components)")
+@click.pass_context
+def install_cmd(ctx, component, version):
+    """
+    Install supported components such as SDKs or tools.
+
+    Examples:
+      cli install palette -v 1.6.0
+      cli install hostdriver -v 1.6.0
+
+      cli install optiview
+    """
+    component = component.lower()
+    internal = ctx.obj.get("internal", False)
+
+    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.")
+        ctx.exit(1)
+
+    if component in SDK_INDEPENDENT_COMPONENTS and version:
+        click.echo(f"ℹ️ The component '{component}' does not require an SDK version. Ignoring -v {version}.")
+
+    # Perform the installation logic
+    if component == "palette":
+        click.echo(f"🔧 Installing SDK component 'palette' for version {version} is not implemented yet...")
+    elif component == "hostdriver":
+        click.echo(f"🔧 Installing SDK component 'hostdriver' for version {version}...")
+        install_hostdriver(version=version, internal=internal)
+    elif component == "optiview":
+        click.echo("🔧 Installing tool 'optiview'...")
+        install_optiview()
+
+    click.echo("✅ Installation complete.")
+    
+
 # ----------------------
 # App Zoo Subcommands
 # ----------------------

sima_cli/install/hostdriver.py

@@ -0,0 +1,152 @@
+import sys
+import click
+import os
+import subprocess
+from pathlib import Path
+
+from sima_cli.update.updater import download_image
+from sima_cli.utils.env import is_pcie_host
+
+def _check_driver_installation():
+    """
+    Checks whether the PCIe host driver (sima_mla_drv) and related components are correctly installed.
+
+    Returns:
+        dict: A dictionary with validation results for gstreamer, kernel module, and PCI device.
+    """
+    results = {}
+
+    # 1. Check GStreamer plugin
+    try:
+        gst_output = subprocess.check_output(["gst-inspect-1.0", "pciehost"], stderr=subprocess.STDOUT, text=True)
+        if "pciehost" in gst_output:
+            results["gstreamer"] = {
+                "success": True,
+                "message": "✅ GStreamer plugin 'pciehost' is installed."
+            }
+        else:
+            results["gstreamer"] = {
+                "success": False,
+                "message": "❌ GStreamer plugin 'pciehost' not found."
+            }
+    except subprocess.CalledProcessError as e:
+        results["gstreamer"] = {
+            "success": False,
+            "message": f"❌ GStreamer check failed: {e.output.strip()}"
+        }
+
+    # 2. Check kernel module
+    try:
+        modinfo_output = subprocess.check_output(["modinfo", "sima_mla_drv"], stderr=subprocess.STDOUT, text=True)
+        if "filename:" in modinfo_output and "sima_mla_drv" in modinfo_output:
+            results["kernel_module"] = {
+                "success": True,
+                "message": "✅ Kernel module 'sima_mla_drv' is installed."
+            }
+        else:
+            results["kernel_module"] = {
+                "success": False,
+                "message": "❌ Kernel module 'sima_mla_drv' not found."
+            }
+    except subprocess.CalledProcessError as e:
+        results["kernel_module"] = {
+            "success": False,
+            "message": f"❌ Kernel module check failed: {e.output.strip()}"
+        }
+
+    # 3. Check PCI device presence
+    try:
+        lspci_output = subprocess.check_output(["lspci", "-vd", "1f06:abcd"], stderr=subprocess.STDOUT, text=True)
+        if "sima_mla_drv" in lspci_output or "1f06:abcd" in lspci_output:
+            results["pci_device"] = {
+                "success": True,
+                "message": "✅ PCIe device (1f06:abcd) detected and bound to 'sima_mla_drv'."
+            }
+        else:
+            results["pci_device"] = {
+                "success": False,
+                "message": "❌ PCIe device not detected."
+            }
+    except subprocess.CalledProcessError as e:
+        results["pci_device"] = {
+            "success": False,
+            "message": f"❌ PCIe device check failed: {e.output.strip()}"
+        }
+
+    return results
+
+def _print_driver_validation_table(results: dict):
+    """
+    Prints the driver validation results in a table format with fixed-width columns.
+    """
+    print("\nDriver Installation Validation:\n")
+    print(f"{'Component':<20} | {'Status':<10} | {'Details'}")
+    print("-" * 60)
+
+    for section, result in results.items():
+        component = section.replace("_", " ").title()
+        status = "PASS" if result["success"] else "FAIL"
+        message = result["message"]
+        print(f"{component:<20} | {status:<10} | {message}")
+
+def install_hostdriver(version: str, internal: bool = False):
+    """
+    Install PCIe host driver on supported platforms.
+
+    This function is only valid on PCIe host machines. It downloads the appropriate image
+    package and installs the host driver script if present.
+
+    Args:
+        version (str): Firmware version string (e.g., "1.6.0").
+        internal (bool): Whether to use internal sources for the download.
+
+    Raises:
+        RuntimeError: If the platform is not supported or the driver script is missing.
+    """
+    if not is_pcie_host():
+        click.echo("❌ This command is only supported on PCIe host Linux machines.")
+        sys.exit(1)
+
+    try:
+        # Step 1: Install system dependencies
+        click.echo("🔧 Installing required system packages...")
+        try:
+            subprocess.run([
+                "sudo", "apt-get", "update"
+            ], check=True)
+            subprocess.run([
+                "sudo", "apt-get", "install", "-y",
+                "make", "cmake", "gcc", "g++", "dkms", "doxygen",
+                "libjson-c-dev", "libjsoncpp-dev", "build-essential", "linux-headers-generic"
+            ], check=True)
+            click.echo("✅ Dependencies installed successfully.")
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"❌ Failed to install dependencies: {e}")
+
+        # Step 2: Download driver package which is part of the firmware release.
+        click.echo(f"⬇️  Downloading host driver package for version {version}...")
+        extracted_files = download_image(version_or_url=version, board="davinci", swtype="yocto", internal=internal)
+
+        # Find the host driver script in extracted files
+        script_path = next((f for f in extracted_files if f.endswith("sima_pcie_host_pkg.sh")), None)
+
+        if not script_path or not os.path.isfile(script_path):
+            raise RuntimeError("sima_pcie_host_pkg.sh not found in the downloaded package.")
+
+        click.echo(f"📦 Host driver script found: {script_path}")
+        click.confirm("⚠️  This will install drivers on your system using sudo. Continue?", abort=True)
+
+        # Make sure the script is executable
+        os.chmod(script_path, 0o755)
+
+        # Run the script with sudo
+        subprocess.run(["sudo", script_path], check=True)
+
+        click.echo("✅ Host driver installation completed.")
+
+        results = _check_driver_installation()
+        _print_driver_validation_table(results)
+
+    except Exception as e:
+        raise RuntimeError(f"❌ Failed to install host driver: {e}")
+

sima_cli/install/optiview.py

@@ -0,0 +1,80 @@
+import sys
+import platform
+import click
+import urllib
+import json
+import tempfile
+import tarfile
+import os
+import subprocess
+from pathlib import Path
+from sima_cli.download import download_file_from_url
+from sima_cli.utils.env import is_sima_board
+from sima_cli.utils.config_loader import load_resource_config
+
+def install_optiview():
+    try:
+        # Special path for SiMa DevKit
+        if is_sima_board():
+            click.echo("🛠 Detected SiMa DevKit. Cleaning up existing installation...")
+            subprocess.run(["sudo", "pip3", "uninstall", "-y", "optiview"], check=True)
+            click.echo("📦 Installing Optiview via pip...")
+            subprocess.run(["sudo", "pip3", "install", "optiview"], check=True)
+            click.echo("✅ Optiview installed successfully on DevKit.")
+            return
+
+        cfg = load_resource_config()
+        download_url_base = cfg.get('public').get('download').get('download_url')
+
+        # Normal flow for other platforms
+        click.echo("📥 Fetching Optiview version info...")
+        version_url = f"{download_url_base}optiview/metadata.json"
+        downloads_dir = Path.home() / "Downloads" / "optiview-installer"
+        downloads_dir.mkdir(parents=True, exist_ok=True)
+        metadata_path = download_file_from_url(version_url, dest_folder=downloads_dir, internal=False)
+
+        with open(metadata_path, "r") as f:
+            version_data = json.load(f)
+            latest_version = version_data.get("latest")
+
+        if not latest_version:
+            raise Exception("Unable to retrieve latest version info.")
+
+        # Determine architecture
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+
+        if system == "darwin" and machine == "arm64":
+            arch = "aarch64"
+        else:
+            arch = "x86_64"
+
+        pkg_url = f"{download_url_base}optiview/optiview-installation-{arch}-{latest_version}.tar.gz"
+        click.echo(f"🌐 Downloading Optiview ({arch} v{latest_version})...")
+
+        archive_path = download_file_from_url(pkg_url, dest_folder=downloads_dir)
+
+        click.echo(f"📦 Extracting to {downloads_dir}...")
+        with tarfile.open(archive_path, "r:gz") as tar:
+            tar.extractall(path=downloads_dir)
+
+        install_script = "install.bat" if system == "windows" else "install.sh"
+        script_path = os.path.join(downloads_dir, install_script)
+
+        if not os.path.isfile(script_path):
+            raise Exception(f"Installation script not found: {script_path}")
+
+        click.echo(f"🚀 Running installer: {install_script}")
+        if system == "windows":
+            subprocess.run(["cmd", "/c", os.path.basename(script_path)], check=True, cwd=downloads_dir)
+        else:
+            subprocess.run(["bash", os.path.basename(script_path)], check=True, cwd=downloads_dir)
+
+        click.echo(f"✅ Optiview installed successfully. Run {downloads_dir}/run.sh to start optiview")
+
+    except Exception as e:
+        click.echo(f"❌ Installation failed: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    install_optiview()

sima_cli/install/palette.py

@@ -0,0 +1,87 @@
+import sys
+import platform
+import click
+import json
+import tarfile
+import os
+import subprocess
+from pathlib import Path
+from sima_cli.download import download_file_from_url
+from sima_cli.utils.env import is_sima_board
+from sima_cli.utils.config_loader import load_resource_config
+
+def build_internal_url(download_url_base, latest_filename):
+    """Build the URL for internal Palette package."""
+    return f"{download_url_base}palette/{latest_filename}"
+
+def build_external_url(download_url_base, latest_filename, version):
+    """Build the URL for external Palette package from SDKx.y.z folder."""
+    return f"{download_url_base}palette/SDK{version}/{latest_filename}"
+
+def install_palette(internal=False):
+    try:
+        # Check for unsupported platforms
+        system = platform.system().lower()
+        if is_sima_board():
+            click.echo("❌ Palette installation is not supported on SiMa DevKit, please install on Ubuntu 22.04 or Windows 10/11.")
+            sys.exit(1)
+        if system == "darwin":
+            click.echo("❌ Palette installation is not supported on macOS, please install on Ubuntu 22.04 or Windows 10/11.")
+            sys.exit(1)
+
+        # Load configuration for resources
+        cfg = load_resource_config()
+        download_url_base = cfg.get('internal' if internal else 'public').get('download').get('download_url')
+
+        # Fetch Palette version info
+        click.echo(f"📥 Fetching Palette version info ({'internal' if internal else 'external'})...")
+        version_url = f"{download_url_base}palette/metadata.json"
+        downloads_dir = Path.home() / "Downloads" / "palette-installer"
+        downloads_dir.mkdir(parents=True, exist_ok=True)
+        metadata_path = download_file_from_url(version_url, dest_folder=downloads_dir, internal=internal)
+
+        # Read version data
+        with open(metadata_path, "r") as f:
+            version_data = json.load(f)
+            latest_filename = version_data.get("latest")
+
+        if not latest_filename:
+            raise Exception("Unable to retrieve latest filename info.")
+
+        # Extract version from filename (assuming format like palette-installation-<arch>-x.y.z.tar.gz)
+        version = latest_filename.split('-')[-1].replace('.tar.gz', '')
+
+        # Build package URL based on internal or external
+        pkg_url = build_internal_url(download_url_base, latest_filename) if internal else build_external_url(download_url_base, latest_filename, version)
+        click.echo(f"🌐 Downloading Palette ({'internal' if internal else 'external'}: {latest_filename})...")
+
+        # Download the package
+        archive_path = download_file_from_url(pkg_url, dest_folder=downloads_dir, internal=internal)
+
+        # Extract the package
+        click.echo(f"📦 Extracting to {downloads_dir}...")
+        with tarfile.open(archive_path, "r:gz") as tar:
+            tar.extractall(path=downloads_dir)
+
+        # Determine installation script based on platform
+        install_script = "install.bat" if system == "windows" else "install.sh"
+        script_path = os.path.join(downloads_dir, install_script)
+
+        if not os.path.isfile(script_path):
+            raise Exception(f"Installation script not found: {script_path}")
+
+        # Run the installer
+        click.echo(f"🚀 Running installer: {install_script}")
+        if system == "windows":
+            subprocess.run(["cmd", "/c", os.path.basename(script_path)], check=True, cwd=downloads_dir)
+        else:
+            subprocess.run(["bash", os.path.basename(script_path)], check=True, cwd=downloads_dir)
+
+        click.echo(f"✅ Palette installed successfully ({'internal' if internal else 'external'}). Run {downloads_dir}/run.sh to start palette")
+
+    except Exception as e:
+        click.echo(f"❌ {'Internal' if internal else 'External'} installation failed: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    install_palette(internal=False)

sima_cli/update/bmaptool.py

@@ -0,0 +1,137 @@
+import subprocess
+import sys
+import os
+import urllib.request
+import tarfile
+import tempfile
+import json
+import shutil
+
+def run_command(command, check=True, shell=False, cwd=None):
+    """Run a shell command and return its output or raise an exception if it fails."""
+    try:
+        result = subprocess.run(
+            command,
+            check=check,
+            shell=shell,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            cwd=cwd
+        )
+        return result.stdout.strip(), result.stderr.strip()
+    except subprocess.CalledProcessError as e:
+        if check:
+            print(f"Error running command {command}: {e.stderr}")
+            raise
+        return "", str(e)
+
+def is_bmaptool_installed():
+    """Check if bmaptool is installed and callable from the shell."""
+    try:
+        result = subprocess.run(
+            ["bmaptool", "--version"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=5
+        )
+        if result.returncode == 0:
+            print(f"✅ bmaptool is installed: {result.stdout.strip()}")
+            return True
+        else:
+            print(f"⚠️ bmaptool returned non-zero exit: {result.stderr.strip()}")
+            return False
+    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+        print(f"❌ bmaptool is not installed or not in PATH: {e}")
+        return False
+
+def clone_bmaptool_repo(temp_dir, branch_or_tag="main"):
+    """Clone the bmaptool repository to a temporary directory."""
+    repo_url = "https://github.com/yoctoproject/bmaptool.git"
+    print(f"Cloning bmaptool from {repo_url} (branch/tag: {branch_or_tag})...")
+    try:
+        subprocess.run(
+            ["git", "clone", "--depth", "1", "--branch", branch_or_tag, repo_url, temp_dir],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        print(f"Cloned bmaptool to {temp_dir}")
+        return temp_dir
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to clone repository: {e.stderr}")
+        sys.exit(1)
+
+def get_python_and_pip_bins():
+    """Get the Python and pip binaries from the active virtual environment or system."""
+    if "VIRTUAL_ENV" in os.environ:
+        venv_dir = os.environ["VIRTUAL_ENV"]
+        print(f"Using existing virtual environment: {venv_dir}")
+        if sys.platform == "win32":
+            python_bin = os.path.join(venv_dir, "Scripts", "python.exe")
+            pip_bin = os.path.join(venv_dir, "Scripts", "pip.exe")
+        else:
+            python_bin = os.path.join(venv_dir, "bin", "python3")
+            pip_bin = os.path.join(venv_dir, "bin", "pip3")
+    else:
+        print("No virtual environment detected; using system Python.")
+        python_bin = shutil.which("python3") or sys.executable
+        pip_bin = shutil.which("pip3") or "pip3"
+    return python_bin, pip_bin
+
+def install_bmaptool(temp_dir):
+    """Install bmaptool from the cloned repository."""
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", temp_dir],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        print("Installed bmaptool successfully")
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to install bmaptool: {e.stderr}")
+        sys.exit(1)
+
+def verify_installation(python_bin):
+    """Verify bmaptool installation by running python -m bmaptool --version."""
+    stdout, stderr = run_command([python_bin, "-m", "bmaptool", "--version"])
+    if stdout:
+        print(f"bmaptool installation verified: {stdout}")
+    else:
+        print(f"Verification failed: {stderr}")
+        sys.exit(1)
+
+def check_bmap_and_install():
+    # Get Python and pip binaries from the active virtual environment or system
+    python_bin, _ = get_python_and_pip_bins()
+    
+    # Check if bmaptool is already installed
+    if is_bmaptool_installed():
+        return
+    
+    # Create a temporary directory
+    temp_dir = "bmaptool_temp"
+    with tempfile.TemporaryDirectory() as temp_dir:            
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+        os.makedirs(temp_dir)
+        
+        clone_bmaptool_repo(temp_dir, branch_or_tag="main")  # Or specify a tag like "v3.8"
+        install_bmaptool(temp_dir)
+        
+        # Verify installation
+        verify_installation(python_bin)
+        
+        # Provide usage instructions
+        if "VIRTUAL_ENV" in os.environ:
+            print(f"\nbmaptool is installed in the virtual environment at {os.environ['VIRTUAL_ENV']}")
+            print("The virtual environment is already active.")
+            print("Run 'bmaptool --help' to see available commands.")
+        else:
+            print("\nbmaptool is installed in the system Python environment.")
+            print("Run 'bmaptool --help' to see available commands.")
+
+if __name__ == "__main__":
+    check_bmap_and_install()

sima_cli/update/bootimg.py

@@ -0,0 +1,339 @@
+import click
+import platform
+import subprocess
+import sys
+import os
+import select
+import time
+import re
+try:
+    from tqdm import tqdm
+except ImportError:
+    tqdm = None
+from sima_cli.update.updater import download_image
+
+
+def list_removable_devices():
+    system = platform.system()
+
+    if system == "Linux":
+        return get_linux_removable()
+    elif system == "Darwin":
+        return get_macos_removable()
+    elif system == "Windows":
+        return get_windows_removable()
+    else:
+        click.echo(f"❌ Unsupported platform: {system}")
+        return []
+
+# Linux: Use lsblk to find removable drives
+def get_linux_removable():
+    try:
+        output = subprocess.check_output(["lsblk", "-o", "NAME,RM,SIZE,MOUNTPOINT", "-J"]).decode()
+        import json
+        data = json.loads(output)
+        devices = []
+        for block in data['blockdevices']:
+            if block.get('rm') == True and block.get('mountpoint') is None:
+                devices.append({
+                    "name": block['name'],
+                    "size": block['size'],
+                    "path": f"/dev/{block['name']}"
+                })
+        return devices
+    except Exception:
+        return []
+
+# macOS: Use diskutil
+def get_macos_removable():
+    try:
+        output = subprocess.check_output(["diskutil", "list"], text=True)
+        devices = []
+
+        candidate_disks = [
+            line.split()[0]
+            for line in output.splitlines()
+            if line.startswith("/dev/disk")
+        ]
+
+        for disk in candidate_disks:
+            info = subprocess.check_output(["diskutil", "info", disk], text=True)
+            is_removable = False
+            is_disk_image = False
+            size = "Unknown"
+            device_name = ''
+
+            for info_line in info.splitlines():
+                if "Secure Digital" in info_line or "USB" in info_line:
+                    is_removable = True
+                elif "Disk Size" in info_line and "(" in info_line:
+                    size = info_line.split("(")[1].split()[0] 
+                elif "Volume Name" in info_line:
+                    volume_name = info_line.split(":")[-1].strip() or "Unknown"
+                elif "Device / Media Name" in info_line:
+                    is_disk_image = ('Disk Image' in info_line)
+                    device_name = info_line.split(":")[-1].strip() or "Unknown"
+
+            # switch to raw device to speed up dd performance
+            if is_removable and not is_disk_image:
+                devices.append({
+                    "name": device_name,
+                    "size": round(int(size) / (1024 ** 3), 0),
+                    "path": disk.replace('/disk', '/rdisk')
+                })
+
+        return devices
+    except Exception as e:
+        click.echo(f"Failed to detect removable devices on macOS: {e}")
+        return []
+
+# Windows: Use wmic or powershell
+def get_windows_removable():
+    try:
+        output = subprocess.check_output(
+            ['powershell', '-Command',
+             'Get-WmiObject Win32_DiskDrive | Where { $_.MediaType -match "Removable" } | '
+             'Select-Object DeviceID,Model,Size | ConvertTo-Json']
+        ).decode()
+        import json
+        parsed = json.loads(output)
+        if not isinstance(parsed, list):
+            parsed = [parsed]
+        devices = []
+        for d in parsed:
+            size_gb = int(d.get("Size", 0)) // (1024 ** 3)
+            devices.append({
+                "name": d.get("Model", "Removable Drive"),
+                "size": f"{size_gb} GB",
+                "path": d["DeviceID"]
+            })
+        return devices
+    except Exception:
+        return []
+
+def check_dd_installed():
+    """Check if dd is installed on the system."""
+    try:
+        subprocess.run(["which", "dd"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def unmount_device(device_path):
+    """Unmount the device using platform-specific commands."""
+    system = platform.system()
+    try:
+        if system == "Darwin":  # macOS
+            subprocess.run(["diskutil", "unmountDisk", device_path], check=True, capture_output=True, text=True)
+            click.echo(f"✅ Unmounted {device_path} on macOS")
+        elif system == "Linux":
+            result = subprocess.run(["umount", device_path], capture_output=True, text=True)
+            if result.returncode == 0:
+                click.echo(f"✅ Unmounted {device_path} on Linux")
+            elif "not mounted" in result.stderr.lower():
+                click.echo(f"ℹ️ {device_path} was not mounted. Continuing.")
+            else:
+                click.echo(f"❌ Failed to unmount {device_path}: {result.stderr.strip()}")
+                sys.exit(1)
+        else:
+            click.echo(f"❌ Unsupported platform: {system}. Cannot unmount {device_path}.")
+            sys.exit(1)
+    except Exception as e:
+        click.echo(f"❌ Unexpected error while unmounting {device_path}: {e}")
+        sys.exit(1)
+
+def _require_sudo():
+    try:
+        # This will prompt for password if necessary and cache it for a few minutes
+        click.echo("✅ Running this command requires sudo access.")
+        subprocess.run(["sudo", "-v"], check=True)
+    except subprocess.CalledProcessError:
+        click.echo("❌ Sudo authentication failed.")
+        sys.exit(1)
+
+def copy_image_to_device(image_path, device_path):
+    """Copy the image file to the device using dd with 16M block size."""
+    # Get file size for progress calculation
+    file_size = os.path.getsize(image_path)
+    click.echo(f"ℹ️  Running 'sudo dd' to copy {image_path} to {device_path}")
+
+    # Debug: Log raw dd output to a file for diagnosis
+    debug_log = "dd_output.log"
+    click.echo(f"ℹ️  Logging raw dd output to {debug_log} for debugging.")
+    _require_sudo()
+
+    dd_command = ["sudo", "dd", f"if={image_path}", f"of={device_path}", "bs=16M", "status=progress"]
+    try:
+        # Start dd process with unbuffered output
+        process = subprocess.Popen(
+            dd_command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+            errors="replace" 
+        )
+
+        # Regex to parse dd progress (more robust to handle variations)
+        pattern = re.compile(
+            r"(?:(?:dd: )?(\d+)\s+bytes(?:.*?)copied)|(?:^(\d+)\s+bytes\s+transferred)",
+            re.IGNORECASE
+        )
+
+        # Initialize tqdm progress bar
+        with tqdm(total=file_size, unit="B", unit_scale=True, desc="Copying", ncols=100) as pbar:
+            with open(debug_log, "w") as log_file:
+                while process.poll() is None:
+                    rlist, _, _ = select.select([process.stdout, process.stderr], [], [], 0.1)
+                    for stream in rlist:
+                        line = stream.readline().strip()
+                        if line:
+                            log_file.write(f"{line}\n")
+                            log_file.flush()
+                            match = pattern.search(line)
+                            if match:
+                                bytes_transferred = int(match.group(1))
+                                pbar.n = min(bytes_transferred, file_size)
+                                pbar.refresh()
+                            elif line:
+                                click.echo(f"⚠️  dd: {line}")  # Show other messages (e.g., errors)
+
+        # Capture remaining output and check for errors
+        stdout, stderr = process.communicate()
+        with open(debug_log, "a") as log_file:
+            if stdout.strip():
+                log_file.write(f"Final stdout: {stdout.strip()}\n")
+            if stderr.strip():
+                log_file.write(f"Final stderr: {stderr.strip()}\n")
+
+        if process.returncode != 0:
+            click.echo(f"❌ Failed to copy {image_path} to {device_path}: {stderr}")
+            click.echo(f"ℹ️  Check {debug_log} for raw dd output.")
+            sys.exit(1)
+
+        click.echo(f"✅ Successfully copied {image_path} to {device_path}")
+        subprocess.run(["sync"], check=True)
+        click.echo("✅ Synced data to device")
+    except subprocess.CalledProcessError as e:
+        click.echo(f"❌ Failed to copy {image_path} to {device_path}: {e.stderr}")
+        click.echo(f"ℹ️  Check {debug_log} for raw dd output.")
+        sys.exit(1)
+    except FileNotFoundError:
+        click.echo("❌ 'dd' not found. Ensure both are installed and accessible.")
+        sys.exit(1)
+
+def write_bootimg(image_path):
+    """Write a boot image to a removable device."""
+    # Step 1: Validate image file
+    if not os.path.isfile(image_path):
+        click.echo(f"❌ Image file {image_path} does not exist.")
+        sys.exit(1)
+
+    click.echo(f"✅ Valid image file: {image_path}")
+
+    # Step 2: Check if dd is installed
+    if not check_dd_installed():
+        click.echo("⚠️  'dd' is not installed on this system.")
+        if platform.system() == "Darwin":
+            click.echo("ℹ️  On macOS, 'dd' is included by default. Check your PATH or system configuration.")
+        elif platform.system() == "Linux":
+            click.echo("ℹ️  On Linux, install 'dd' using your package manager (e.g., 'sudo apt install coreutils' on Debian/Ubuntu).")
+        else:
+            click.echo("ℹ️  Please install 'dd' for your system.")
+        sys.exit(1)
+    click.echo("✅ 'dd' is installed")
+
+    # Step 3: Detect removable devices
+    devices = list_removable_devices()  # Assumes this function exists
+    if not devices:
+        click.echo("⚠️  No removable devices detected. Please plug in your USB drive or SD card.")
+        sys.exit(1)
+
+    # Step 4: Display devices
+    click.echo("\n🔍 Detected removable devices:")
+    for i, dev in enumerate(devices):
+        click.echo(f"  [{i}] Name: {dev['name']}, Size: {dev['size']} GB, Path: {dev['path']}")
+
+    # Step 5: Select device
+    selected_device = None
+    if len(devices) == 1:
+        confirm = input(f"\n✅ Do you want to use device {devices[0]['path']}? (y/N): ").strip().lower()
+        if confirm == 'y':
+            selected_device = devices[0]
+        else:
+            click.echo("❌ Operation cancelled by user.")
+            sys.exit(0)
+    else:
+        try:
+            selection = int(input("\n🔢 Multiple devices found. Enter the number of the device to use: ").strip())
+            if 0 <= selection < len(devices):
+                selected_device = devices[selection]
+            else:
+                click.echo("❌ Invalid selection.")
+                sys.exit(1)
+        except ValueError:
+            click.echo("❌ Invalid input. Please enter a number.")
+            sys.exit(1)
+
+    click.echo(f"\n🚀 Proceeding with device: {selected_device['path']}")
+
+    # Step 6: Unmount the selected device
+    unmount_device(selected_device['path'])
+
+    # Step 7: Copy the image to the device
+    copy_image_to_device(image_path, selected_device['path'])
+
+    # Step 8: Eject the device (platform-dependent)
+    try:
+        if platform.system() == "Darwin":
+            subprocess.run(["diskutil", "eject", selected_device['path']], check=True, capture_output=True, text=True)
+            click.echo(f"✅ Ejected {selected_device['path']} on macOS")
+        elif platform.system() == "Linux":
+            click.echo("ℹ️  Linux does not require explicit eject. Device is ready.")
+        else:
+            click.echo("ℹ️  Please manually eject the device if required.")
+    except subprocess.CalledProcessError as e:
+        click.echo(f"⚠️  Failed to eject {selected_device['path']}: {e.stderr}")
+        click.echo("ℹ️  Please manually eject the device.")
+
+
+def write_image(version: str, board: str, swtype: str, internal: bool = False):
+    """
+    Download and write a bootable firmware image to a removable storage device.
+
+    Parameters:
+        version (str): Firmware version to download (e.g., "1.6.0").
+        board (str): Target board type, e.g., "modalix" or "mlsoc".
+        swtype (str): Software image type, e.g., "yocto" or "exlr".
+        internal (bool): Whether to use internal download sources. Defaults to False.
+
+    Raises:
+        RuntimeError: If the download or write process fails.
+    """
+    try:
+        click.echo(f"⬇️  Downloading boot image for version: {version}, board: {board}, swtype: {swtype}")
+        file_list = download_image(version, board, swtype, internal, update_type='bootimg')
+        if not isinstance(file_list, list):
+            raise ValueError("Expected list of extracted files, got something else.")
+
+        wic_file = next((f for f in file_list if f.endswith(".wic")), None)
+        if not wic_file:
+            raise FileNotFoundError("No .wic image file found after extraction.")
+
+    except Exception as e:
+        raise RuntimeError(f"❌ Failed to download image: {e}")
+
+    try:
+        click.echo(f"📝 Writing image to removable media: {wic_file}")
+        write_bootimg(wic_file)
+    except Exception as e:
+        raise RuntimeError(f"❌ Failed to write image: {e}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        click.echo("❌ Usage: python write_bootimg.py <image_file>")
+        sys.exit(1)
+    
+    write_image('1.7.0', 'modalix', 'davinci', True)

sima_cli/update/remote.py

@@ -83,7 +83,8 @@ def get_remote_board_info(ip: str, passwd: str = DEFAULT_PASSWORD) -> Tuple[str,
 
         return board_type, build_version
 
-    except Exception:
+    except Exception as e:
+        click.echo(f"Unable to retrieve board info {e}")
         return "", ""
 
 

sima_cli/update/updater.py

@@ -4,7 +4,9 @@ import re
 import time
 import tempfile
 import tarfile
+import gzip
 import subprocess
+import shutil
 from InquirerPy import inquirer
 from urllib.parse import urlparse
 from typing import List
@@ -12,8 +14,17 @@ from sima_cli.utils.env import get_environment_type
 from sima_cli.download import download_file_from_url
 from sima_cli.utils.config_loader import load_resource_config
 from sima_cli.update.remote import push_and_update_remote_board, get_remote_board_info, reboot_remote_board
-from sima_cli.update.local import get_local_board_info, push_and_update_local_board
 from sima_cli.update.query import list_available_firmware_versions
+from sima_cli.utils.env import is_sima_board
+
+if is_sima_board():
+    from sima_cli.update import local
+    get_local_board_info = local.get_local_board_info
+    push_and_update_local_board = local.push_and_update_local_board
+else:
+    get_local_board_info = None
+    push_and_update_local_board = None
+
 
 def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = False) -> str:
     """
@@ -56,31 +67,35 @@ def _pick_from_available_versions(board: str, version_or_url: str, internal: boo
 
     available_versions = list_available_firmware_versions(board, version_or_url, internal)
 
-    if len(available_versions) > 1:
-        click.echo("Multiple firmware versions found matching your input:")
+    try:
+        if len(available_versions) > 1:
+            click.echo("Multiple firmware versions found matching your input:")
 
-        selected_version = inquirer.fuzzy(
-            message="Select a version:",
-            choices=available_versions,
-            max_height="70%",  # scrollable
-            instruction="(Use ↑↓ to navigate, / to search, Enter to select)"
-        ).execute()
+            selected_version = inquirer.fuzzy(
+                message="Select a version:",
+                choices=available_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)
+            if not selected_version:
+                click.echo("No selection made. Exiting.", err=True)
+                raise SystemExit(1)
 
-        return selected_version
+            return selected_version
 
-    elif len(available_versions) == 1:
-        return available_versions[0]
+        elif len(available_versions) == 1:
+            return available_versions[0]
 
-    else:
-        click.echo(
-            f"No firmware versions found matching keyword '{version_or_url}' for board '{board}'.",
-            err=True
-        )
-        raise SystemExit(1)
+        else:
+            click.echo(
+                f"No firmware versions found matching keyword '{version_or_url}' for board '{board}'.",
+                err=True
+            )
+            raise SystemExit(1)
+    except:
+        click.echo("Unable to determine available versions")
+        exit(0)
 
 def _sanitize_url_to_filename(url: str) -> str:
     """
@@ -98,22 +113,23 @@ def _sanitize_url_to_filename(url: str) -> str:
     return safe_name
 
 
-def _extract_required_files(tar_path: str, board: str) -> list:
+def _extract_required_files(tar_path: str, board: str, update_type: str = 'standard') -> list:
     """
     Extract required files from a .tar.gz or .tar archive into the same folder
     and return the full paths to the extracted files (with subfolder if present).
-    Skips files that already exist.
+    Skips files that already exist. If a .wic.gz file is extracted, it will be decompressed,
+    unless the decompressed .wic file already exists.
 
     Args:
         tar_path (str): Path to the downloaded or provided firmware archive.
         board (str): Board type ('davinci' or 'modalix').
+        update_type (str): Update type ('standard' or 'bootimg').
 
     Returns:
         list: List of full paths to extracted files.
     """
     extract_dir = os.path.dirname(tar_path)
 
-    # Define required filenames (not full paths)
     target_filenames = {
         "troot-upgrade-simaai-ev.swu",
         f"simaai-image-palette-upgrade-{board}.swu"
@@ -123,6 +139,12 @@ def _extract_required_files(tar_path: str, board: str) -> list:
     if env_type == "host" and _os == "linux":
         target_filenames.add("sima_pcie_host_pkg.sh")
 
+    if update_type == 'bootimg':
+        target_filenames = {
+            f"simaai-image-palette-{board}.wic.gz",
+            f"simaai-image-palette-{board}.wic.bmap"
+        }
+
     extracted_paths = []
 
     try:
@@ -140,14 +162,29 @@ def _extract_required_files(tar_path: str, board: str) -> list:
                     if os.path.exists(full_dest_path):
                         click.echo(f"⚠️  Skipping existing file: {full_dest_path}")
                         extracted_paths.append(full_dest_path)
-                        continue
+                    else:
+                        os.makedirs(os.path.dirname(full_dest_path), exist_ok=True)
+                        tar.extract(member, path=extract_dir)
+                        click.echo(f"✅ Extracted: {full_dest_path}")
+                        extracted_paths.append(full_dest_path)
 
-                    # Ensure directory structure exists
-                    os.makedirs(os.path.dirname(full_dest_path), exist_ok=True)
+                    # If it's a .wic.gz file, decompress it now
+                    if full_dest_path.endswith(".wic.gz"):
+                        uncompressed_path = full_dest_path[:-3]  # remove .gz
 
-                    tar.extract(member, path=extract_dir)
-                    extracted_paths.append(full_dest_path)
-                    click.echo(f"✅ Extracted: {full_dest_path}")
+                        if os.path.exists(uncompressed_path):
+                            click.echo(f"⚠️  Skipping decompression: {uncompressed_path} already exists")
+                            extracted_paths.append(uncompressed_path)
+                            continue
+
+                        try:
+                            with gzip.open(full_dest_path, 'rb') as f_in:
+                                with open(uncompressed_path, 'wb') as f_out:
+                                    shutil.copyfileobj(f_in, f_out)
+                            click.echo(f"📦 Decompressed: {uncompressed_path}")
+                            extracted_paths.append(uncompressed_path)
+                        except Exception as decomp_err:
+                            click.echo(f"❌ Failed to decompress {full_dest_path}: {decomp_err}")
 
         if not extracted_paths:
             click.echo("⚠️  No matching files were found or extracted.")
@@ -158,7 +195,8 @@ def _extract_required_files(tar_path: str, board: str) -> list:
         click.echo(f"❌ Failed to extract files from archive: {e}")
         return []
 
-def _download_image(version_or_url: str, board: str, internal: bool = False):
+    
+def _download_image(version_or_url: str, board: str, internal: bool = False, update_type: str = 'standard'):
     """
     Download or use a firmware image for the specified board and version or file path.
 
@@ -176,7 +214,7 @@ def _download_image(version_or_url: str, board: str, internal: bool = False):
         # Case 1: Local file provided
         if os.path.exists(version_or_url) and os.path.isfile(version_or_url):
             click.echo(f"📁 Using local firmware file: {version_or_url}")
-            return _extract_required_files(version_or_url, board)
+            return _extract_required_files(version_or_url, board, update_type)
 
         # Case 2: Treat as custom full URL
         if version_or_url.startswith("http://") or version_or_url.startswith("https://"):
@@ -198,7 +236,7 @@ def _download_image(version_or_url: str, board: str, internal: bool = False):
         firmware_path = download_file_from_url(image_url, dest_path, internal=internal)
 
         click.echo(f"📦 Firmware downloaded to: {firmware_path}")
-        return _extract_required_files(firmware_path, board)
+        return _extract_required_files(firmware_path, board, update_type)
 
     except Exception as e:
         click.echo(f"❌ Host update failed: {e}")
@@ -328,6 +366,27 @@ def _update_remote(extracted_paths: List[str], ip: str, board: str, passwd: str,
 
     return script_path
 
+def download_image(version_or_url: str, board: str, swtype: str, internal: bool = False, update_type: str = 'standard'):
+    """
+    Download and extract a firmware image for a specified board.
+
+    Args:
+        version_or_url (str): Either a version string (e.g., "1.6.0") or a direct URL or local file path to the image.
+        board (str): The board type (e.g., "mlsoc", "modalix").
+        swtype (str): The software type (default to 'davinci', possible values: `davinci`, `modalix`): not supported for now
+        internal (bool): Whether to use internal download paths (e.g., Artifactory).
+        update_type (str): Whether this is standard update or writing boot image.
+
+    Returns:
+        List[str]: Paths to the extracted image files.
+    """
+    
+    if 'http' not in version_or_url and not os.path.exists(version_or_url): 
+        version_or_url = _pick_from_available_versions(board, version_or_url, internal)
+
+    extracted_paths = _download_image(version_or_url, board, internal, update_type) 
+    return extracted_paths
+
 def perform_update(version_or_url: str, ip: str = None, internal: bool = False, passwd: str = "edgeai", auto_confirm: bool = False):
     r"""
     Update the system based on environment and input.

sima_cli/utils/env.py

@@ -36,14 +36,13 @@ def is_pcie_host() -> bool:
     """
     Detect if running from a PCIe host (typically a Linux or macOS dev machine).
 
-    This assumes a PCIe host is not a SiMa board and is running on a standard
-    Unix-based OS like Linux or macOS (Darwin).
+    This assumes a PCIe host is not a SiMa board and is running on a standard Linux platform.
 
     Returns:
         bool: True if likely a PCIe host, False otherwise.
     """
     import platform
-    return not is_sima_board() and platform.system() in ["Linux", "Darwin"]
+    return not is_sima_board() and platform.system() in ["Linux"]
 
 def get_sima_board_type() -> str:
     """

{sima_cli-0.0.18.dist-info → sima_cli-0.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sima-cli
-Version: 0.0.18
+Version: 0.0.19
 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.18.dist-info → sima_cli-0.0.19.dist-info}/RECORD

@@ -1,33 +1,39 @@
 sima_cli/__init__.py,sha256=Nb2jSg9-CX1XvSc1c21U9qQ3atINxphuNkNfmR-9P3o,332
 sima_cli/__main__.py,sha256=ehzD6AZ7zGytC2gLSvaJatxeD0jJdaEvNJvwYeGsWOg,69
-sima_cli/__version__.py,sha256=8-9gPM1y6DdoYBg3txOjyT5ldXc4k9e8BvBxlen4c6g,49
-sima_cli/cli.py,sha256=EZkY0FaGLc2krp5Rf0AuUT8t3qktoE5h9vIY8-wkHKk,8263
+sima_cli/__version__.py,sha256=2xNp40YbbA9TjpFNNqUbe-Cjo-Xe8LvBbe2706ROs3k,49
+sima_cli/cli.py,sha256=k4w4NB6yfqjTrNBEv338yQTBWIMZ-ul7W-0vo7y01dc,11326
 sima_cli/app_zoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/app_zoo/app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/auth/basic_auth.py,sha256=pcocI6v496vC7v5MLYPZq3AEgD-2DdkzNFZiKsbx3eQ,4290
-sima_cli/auth/login.py,sha256=e9wBEeo_60qplODHBeK84R7zusT3K07kdFoZC1mkSrQ,3778
+sima_cli/auth/login.py,sha256=yCYXWgrfbP4jSTZ3hITfxlgHkdVQVzsd8hQKpqaqCKs,3780
 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=pHfqcg_ujBQjds_EkcRV85M2mRYGrysoZaiR-FIrpf4,5161
+sima_cli/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sima_cli/install/hostdriver.py,sha256=kAWDLebs60mbWIyTbUxmNrChcKW1uD5r7FtWNSUVUE4,5852
+sima_cli/install/optiview.py,sha256=VT8C1_EX-DW-n7DuxI9d0vPb87JBX-Rg9Bw9JHh1aeo,3108
+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/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/sdk/syscheck.py,sha256=h9zCULW67y4i2hqiGc-hc1ucBDShA5FAe9NxwBGq-fM,4575
 sima_cli/update/__init__.py,sha256=0P-z-rSaev40IhfJXytK3AFWv2_sdQU4Ry6ei2sEus0,66
+sima_cli/update/bmaptool.py,sha256=KrhUGShBwY4Wzz50QiuMYAxxPgEy1nz5C68G-0a4qF4,4988
+sima_cli/update/bootimg.py,sha256=iMe8b42JK0KF-udSB6Kl044XUJtNgMUmBNxyuWneAkU,13387
 sima_cli/update/local.py,sha256=CyUFLs5Lz5w4VyM6ip4wndKBBLz3_KZ-3scEvSiOrcg,3299
 sima_cli/update/query.py,sha256=cVkUMLZkONJ2XMEwqEC-JqLVB38hOqfWM2hB2ehBK6Y,3272
-sima_cli/update/remote.py,sha256=wMS39qhXV99fjkeh_0C5dDx1RdE8ooGniEHl_W6v3MA,8877
-sima_cli/update/updater.py,sha256=8CxRcIRnCYRx80Xy2zBJ_Ni5dYejASQvgSV6KWXCDTk,15613
+sima_cli/update/remote.py,sha256=DvcvUX1ydpyF4DwUsVXagb7My6H2MNoGiCQfGfO06iI,8939
+sima_cli/update/updater.py,sha256=SprOcvSzRSwViGd2dYTtyTQfiwdLQcqZoS3KBQpxz4s,18466
 sima_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/utils/artifactory.py,sha256=6YyVpzVm8ATy7NEwT9nkWx-wptkXrvG7Wl_zDT6jmLs,2390
 sima_cli/utils/config.py,sha256=wE-cPQqY_gOqaP8t01xsRHD9tBUGk9MgBUm2GYYxI3E,1616
 sima_cli/utils/config_loader.py,sha256=7I5we1yiCai18j9R9jvhfUzAmT3OjAqVK35XSLuUw8c,2005
-sima_cli/utils/env.py,sha256=INOAVfCFwh0BHeqSMmEHXfpIyepNha4-SMI1iOOplOo,5795
+sima_cli/utils/env.py,sha256=Jrb062EnpMBr1jGMotBlI2j9LEH6W1Z5Tgt6LHY7yYQ,5753
 sima_cli/utils/network.py,sha256=UvqxbqbWUczGFyO-t1SybG7Q-x9kjUVRNIn_D6APzy8,1252
-sima_cli-0.0.18.dist-info/licenses/LICENSE,sha256=a260OFuV4SsMZ6sQCkoYbtws_4o2deFtbnT9kg7Rfd4,1082
+sima_cli-0.0.19.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
@@ -36,8 +42,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.18.dist-info/METADATA,sha256=8o5Si6o1A3Nja7M4V3mTfY97TiEY12U7z-mCrQOpf-Q,3631
-sima_cli-0.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sima_cli-0.0.18.dist-info/entry_points.txt,sha256=xRYrDq1nCs6R8wEdB3c1kKuimxEjWJkHuCzArQPT0Xk,47
-sima_cli-0.0.18.dist-info/top_level.txt,sha256=FtrbAUdHNohtEPteOblArxQNwoX9_t8qJQd59fagDlc,15
-sima_cli-0.0.18.dist-info/RECORD,,
+sima_cli-0.0.19.dist-info/METADATA,sha256=7_B7RJl70GRcQOHvMQRrxhjvQhuQD9pqX3FUQvKRr1M,3631
+sima_cli-0.0.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sima_cli-0.0.19.dist-info/entry_points.txt,sha256=xRYrDq1nCs6R8wEdB3c1kKuimxEjWJkHuCzArQPT0Xk,47
+sima_cli-0.0.19.dist-info/top_level.txt,sha256=FtrbAUdHNohtEPteOblArxQNwoX9_t8qJQd59fagDlc,15
+sima_cli-0.0.19.dist-info/RECORD,,