holoscan-cli 2.9.0__py3-none-any.whl

holoscan_cli/common/sdk_utils.py

@@ -0,0 +1,195 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import importlib.metadata
+import logging
+import sys
+from pathlib import Path
+from typing import Optional
+
+from packaging.version import Version
+
+from .artifact_sources import ArtifactSources
+from .enum_types import SdkType
+from .exceptions import FailedToDetectSDKVersionError, InvalidSdkError
+
+logger = logging.getLogger("common")
+
+
+def validate_holoscan_sdk_version(
+    artifact_sources: ArtifactSources, version: str
+) -> None:
+    """
+    Validates specified Holoscan version with supported versions.
+
+    Args:
+        artifact_sources (ArtifactSources): ArtifactSources object to retrieve supported versions from
+        version (str): Holoscan SDK version from user input.
+
+    Raises:
+        InvalidSdkError: If specified SDK version is not supported.
+
+    Returns:
+        str: SDK version
+    """
+    sdk_version = Version(version)
+    if sdk_version.base_version not in artifact_sources.holoscan_versions:
+        raise InvalidSdkError(
+            f"Invalid SDK version specified ({version}): valid values are: "
+            f"{', '.join(artifact_sources.holoscan_versions)}"
+        )
+
+
+def detect_sdk(sdk: Optional[SdkType] = None) -> SdkType:
+    """
+    Use user specified SDK or detects the SDK to use based on the executing command name.
+
+    Args:
+        sdk (Optional[SdkType]): User specified SDK.
+
+    Returns:
+        SDK (SdkType): SDK for building the application
+
+    Raises:
+        InvalidSdkError: when failed to detect SDK version.
+    """
+
+    if sdk is not None:
+        if not isinstance(sdk, SdkType):
+            raise ValueError("sdk must be of type SdkType")
+        return sdk
+
+    command = None
+    try:
+        # For Python 3.10+, this check is to support use of the holoscan cli bash script bundled
+        # with the Debian package.
+        # Since the Debian package bundles with 3.10, we don't need to handle 3.9 but
+        # we still need to check if `orig_argv` is supported to avoid breaking unit test.
+        if (
+            getattr(sys, "orig_argv", None)
+            and len(sys.orig_argv) >= 3
+            and sys.orig_argv[0] == "python3"
+            and sys.orig_argv[2] == "holoscan_cli"
+        ):
+            command = "holoscan"
+        else:
+            command = Path(sys.argv[0]).name.lower()
+        return SdkType(command)
+    except Exception as ex:
+        raise InvalidSdkError(f"Invalid SDK value provided: {command}") from ex
+
+
+def detect_sdk_version(
+    sdk: SdkType,
+    sdk_version: Optional[Version] = None,
+) -> tuple[str, Optional[str]]:
+    """
+    Detects SDK version to use based on installed PyPI package or user input.
+    For Holoscan SDK(Type), detect only the Holoscan version with optional user-provided version.
+    For MONAI Deploy SDK(Type), detect both Holoscan and MONAI Deploy App SDK versions but assume
+    the sdk_version provided by the user is for MONAI Deploy App SDK.
+
+    Args:
+        sdk (SdkType): SDK Type.
+        sdk_version (Optional[str]): SDK version to be used for building the package.
+
+    Returns:
+        Tuple[str, Optional[str]]:  Version of the Holoscan SDK and version of MONAI Deploy SDK to
+            use
+
+    Raises:
+        FailedToDetectSDKVersionError: When unable to detect the installed Holoscan PyPI package.
+    """
+    if sdk is SdkType.Holoscan:
+        return [detect_holoscan_version(sdk_version), None]
+    else:
+        return [
+            detect_holoscan_version(None),
+            detect_monaideploy_version(sdk_version),
+        ]
+
+
+def detect_holoscan_version(sdk_version: Optional[Version] = None) -> str:
+    """
+    Validates Holoscan version if specified. Otherwise, attempt to detect the Holoscan PyPI
+    package installed.
+
+    Args:
+        sdk_version (Optional[str], optional): SDK version from user input. Defaults to None.
+
+    Raises:
+        FailedToDetectSDKVersionError: When unable to detect the installed Holoscan PyPI package.
+
+    Returns:
+        str: SDK version
+    """
+    if sdk_version is not None:
+        return sdk_version.base_version
+    else:
+        try:
+            ver_str = importlib.metadata.version("holoscan-cli").title()
+            ver = Version(ver_str)
+            ver_str = ".".join(str(i) for i in ver.release)
+
+            if len(ver.release) == 1 and ver.major == ver.release[0]:
+                ver_str = ver_str + ".0.0"
+            elif (
+                len(ver.release) == 2
+                and ver.major == ver.release[0]
+                and ver.minor == ver.release[1]
+            ):
+                ver_str = ver_str + ".0"
+            elif (
+                len(ver.release) == 4
+                and ver.major == ver.release[0]
+                and ver.minor == ver.release[1]
+                and ver.micro == ver.release[2]
+            ):
+                ver_str = f"{ver.release[0]}.{ver.release[1]}.{ver.release[2]}"
+
+            return ver_str
+        except Exception as ex:
+            raise FailedToDetectSDKVersionError(
+                "Failed to detect installed Holoscan PyPI version.", ex
+            ) from ex
+
+
+def detect_monaideploy_version(sdk_version: Optional[Version] = None) -> str:
+    """
+    Validates MONAI Deploy version if specified. Otherwise, attempt to detect the MONAI Deploy
+    PyPI package installed.
+
+    Args:
+        sdk_version (Optional[str], optional): SDK version from user input. Defaults to None.
+
+    Raises:
+        FailedToDetectSDKVersionError: When unable to detect the installed MONAI Deploy PyPI
+                                       package.
+
+    Returns:
+        str: SDK version
+    """
+
+    if sdk_version is not None:
+        return sdk_version.base_version
+    else:
+        try:
+            ver_str = importlib.metadata.version("monai-deploy-app-sdk").title()
+            ver = Version(ver_str)
+
+            return ver.base_version
+        except Exception as ex:
+            raise FailedToDetectSDKVersionError(
+                "Failed to detect installed MONAI Deploy App SDK PyPI version.", ex
+            ) from ex

holoscan_cli/common/utils.py

@@ -0,0 +1,137 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import json
+import logging
+import re
+import socket
+import subprocess
+from typing import List, Optional
+
+import psutil
+from packaging import version
+
+logger = logging.getLogger("common")
+
+
+def print_manifest_json(manifest, filename):
+    logger.debug(
+        f"""
+=============== Begin {filename} ===============
+{json.dumps(manifest, indent=4)}
+================ End {filename} ================
+                 """
+    )
+
+
+def get_requested_gpus(pkg_info: dict) -> int:
+    """Gets requested number of gpus in the package manifest
+
+    Args:
+        pkg_info: package manifest as a python dict
+
+    Returns:
+        int: requested number of gpus in the package manifest
+    """
+    num_gpu: int = pkg_info.get("resources", {}).get("gpu", 0)
+    return num_gpu
+
+
+def get_gpu_count():
+    return len(run_cmd_output(["nvidia-smi", "-L"]).splitlines())
+
+
+def run_cmd(cmd: str) -> int:
+    """
+    Executes command and return the returncode of the executed command.
+
+    Redirects stderr of the executed command to stdout.
+
+    Args:
+        cmd: command to execute.
+
+    Returns:
+        output: child process returncode after the command has been executed.
+    """
+    proc = subprocess.Popen(cmd, universal_newlines=True, shell=False)
+    return proc.wait()
+
+
+def run_cmd_output(cmd: List[str], grep: Optional[str] = None) -> str:
+    """
+    Executes command and returns the output.
+
+    Args:
+        cmd: command to execute.
+        grep: string to search for matching line. The first match is returned.
+
+    Returns:
+        output: command output.
+    """
+    proc = subprocess.run(cmd, capture_output=True, text=True, shell=False)
+
+    if grep:
+        lines = proc.stdout.splitlines()
+        for line in lines:
+            if re.search(grep, line):
+                return line
+
+    return proc.stdout
+
+
+def compare_versions(version1, version2):
+    """
+    Compares two version strings.
+
+    Args:
+        version1(str)
+        version2(str)
+
+    Returns:
+        1: when version1 is greater than version2
+        -1: when version1 is less than version2
+        0: when two version strings are equal
+    """
+    v1 = version.parse(version1)
+    v2 = version.parse(version2)
+
+    if v1 < v2:
+        return -1
+    elif v1 > v2:
+        return 1
+    else:
+        return 0
+
+
+def get_host_ip_addresses() -> tuple[list[tuple[str, str]], list[tuple[str, str]]]:
+    """
+    Returns a tuple containing interface name and its IPv4 address as the first item
+    and another item with interface name and its IPv6 address.
+
+    Returns:
+        (Tuple[List[Tuple[str, str]], List[Tuple[str, str]]]): where the item contains a list of
+        tuples of network interface names and its IPv4 address. The second item is similar but
+        contains IPv6 addresses.
+    """
+    ipv4 = []
+    ipv6 = []
+
+    for interface, snics in psutil.net_if_addrs().items():
+        for snic in snics:
+            if snic.family == socket.AF_INET:
+                ipv4.append((interface, snic.address))
+            elif snic.family == socket.AF_INET6:
+                ipv6.append((interface, snic.address))
+
+    return (ipv4, ipv6)

holoscan_cli/logging.json

@@ -0,0 +1,37 @@
+{
+    "version": 1,
+    "disable_existing_loggers": false,
+    "formatters": {
+        "single": {
+            "format": "%(message)s"
+        },
+        "simple": {
+            "format": "[%(asctime)s] [%(levelname)s] (%(name)s) - %(message)s"
+        }
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "formatter": "simple"
+        },
+        "runner_console": {
+            "class": "logging.StreamHandler",
+            "formatter": "single"
+        }
+    },
+    "root": {
+        "level": "INFO",
+        "propagate": false,
+        "handlers": [
+            "console"
+        ]
+    },
+    "loggers": {
+        "app_runner": {
+            "propagate": false,
+            "handlers": [
+                "runner_console"
+            ]
+        }
+    }
+}

holoscan_cli/nics/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .nics import execute_nics_command  # noqa: F401

holoscan_cli/nics/nics.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import logging
+import sys
+from argparse import Namespace
+
+from ..common.utils import get_host_ip_addresses
+
+logger = logging.getLogger("nics")
+
+
+def execute_nics_command(args: Namespace):
+    try:
+        ipv4, ipv6 = get_host_ip_addresses()
+        ip_addresses = ipv4 if ipv4 else ipv6
+        strs = [f"\n\t{item[0]:<15} : {item[1]}" for item in ip_addresses]
+        print(f"Available network interface cards/IP addresses: \n{''.join(strs)}")
+    except Exception as ex:
+        logging.error("Error executing nics command.")
+        logger.debug(ex)
+        sys.exit(4)

holoscan_cli/package-source.json

@@ -0,0 +1,32 @@
+{
+  "2.6.0": {
+    "holoscan": {
+      "debian-version": "2.6.0.1-1",
+      "wheel-version": "2.6.0",
+      "base-images": {
+        "dgpu": "nvcr.io/nvidia/cuda:12.6.0-runtime-ubuntu22.04",
+        "igpu": "nvcr.io/nvidia/tensorrt:24.08-py3-igpu"
+      },
+      "build-images": {
+        "igpu": {
+          "jetson-agx-orin-devkit": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-igpu",
+          "igx-orin-devkit": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-igpu",
+          "sbsa": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-igpu"
+        },
+        "dgpu": {
+          "x64-workstation": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-dgpu",
+          "igx-orin-devkit": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-dgpu",
+          "sbsa": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-dgpu",
+          "clara-agx-devkit": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-dgpu"
+        },
+        "cpu": {
+          "x64-workstation": "nvcr.io/nvidia/clara-holoscan/holoscan:v2.3.0-dgpu"
+        }
+      }
+    },
+    "health-probes": {
+      "linux/amd64": "https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/v0.4.19/grpc_health_probe-linux-amd64",
+      "linux/arm64": "https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/v0.4.19/grpc_health_probe-linux-arm64"
+    }
+  }
+}

holoscan_cli/packager/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .packager import execute_package_command  # noqa: F401

holoscan_cli/packager/arguments.py

@@ -0,0 +1,148 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import logging
+from argparse import Namespace
+from pathlib import Path
+
+from ..common.artifact_sources import ArtifactSources
+from ..common.constants import DefaultValues
+from ..common.enum_types import SdkType
+from .config_reader import ApplicationConfiguration
+from .manifest_files import ApplicationManifest, PackageManifest
+from .models import Models
+from .parameters import PackageBuildParameters, PlatformParameters
+from .platforms import Platform
+
+
+class PackagingArguments:
+    """Processes input arguments for packager"""
+
+    @property
+    def platforms(self) -> list[PlatformParameters]:
+        return self._platforms
+
+    @property
+    def build_parameters(self) -> PackageBuildParameters:
+        return self._build_parameters
+
+    @property
+    def application_manifest(self) -> ApplicationManifest:
+        return self._application_manifest
+
+    @property
+    def package_manifest(self) -> PackageManifest:
+        return self._package_manifest
+
+    def __init__(self, args: Namespace, temp_dir: str) -> None:
+        """
+        Args:
+            args (Namespace): Input arguments for Packager from CLI
+        """
+        self._logger = logging.getLogger("packager")
+
+        self._platforms: list[PlatformParameters]
+        self._build_parameters = PackageBuildParameters()
+        self._artifact_sources = ArtifactSources()
+
+        if args.source is not None:
+            self._artifact_sources.load(args.source)
+        else:
+            self._artifact_sources.download_manifest()
+
+        self.build_parameters.username = args.username
+        self.build_parameters.uid = args.uid
+        self.build_parameters.gid = args.gid
+        self.build_parameters.build_cache = args.build_cache
+        self.build_parameters.app_config_file_path = args.config
+        self.build_parameters.timeout = (
+            args.timeout if args.timeout else DefaultValues.TIMEOUT
+        )
+        self.build_parameters.docs = args.docs if args.docs else None
+        self.build_parameters.application = args.application
+        self.build_parameters.no_cache = args.no_cache
+        self.build_parameters.tarball_output = args.output
+        self.build_parameters.cmake_args = args.cmake_args
+        self.build_parameters.includes = args.includes
+        self.build_parameters.additional_libs = args.additional_libs
+
+        models = Models()
+        platform = Platform(self._artifact_sources)
+        if args.models is not None:
+            self.build_parameters.models = models.build(args.models)
+
+        self._read_application_config_file(args.config)
+        self.build_parameters.version = (
+            args.version if args.version else self.application_manifest.version
+        )
+        (
+            self.build_parameters.sdk,
+            self.build_parameters.holoscan_sdk_version,
+            self.build_parameters.monai_deploy_app_sdk_version,
+            self._platforms,
+        ) = platform.configure_platforms(
+            args,
+            temp_dir,
+            self.build_parameters.version,
+            self.build_parameters.application_type,
+        )
+
+        if self.build_parameters.sdk == SdkType.Holoscan:
+            self.application_manifest.readiness = {
+                "type": "command",
+                "command": ["/bin/grpc_health_probe", "-addr", ":8765"],
+                "initialDelaySeconds": 1,
+                "periodSeconds": 10,
+                "timeoutSeconds": 1,
+                "failureThreshold": 3,
+            }
+            self.application_manifest.liveness = {
+                "type": "command",
+                "command": ["/bin/grpc_health_probe", "-addr", ":8765"],
+                "initialDelaySeconds": 1,
+                "periodSeconds": 10,
+                "timeoutSeconds": 1,
+                "failureThreshold": 3,
+            }
+
+        self.application_manifest.sdk = self.build_parameters.sdk.value
+
+        if self.build_parameters.sdk == SdkType.Holoscan:
+            self.application_manifest.sdk_version = (
+                self.build_parameters.holoscan_sdk_version
+            )
+        else:
+            self.application_manifest.sdk_version = (
+                self.build_parameters.monai_deploy_app_sdk_version
+            )
+
+        self._package_manifest.platform_config = args.platform_config.value
+
+    def _read_application_config_file(self, config_file_path: Path):
+        self._logger.info(
+            f"Reading application configuration from {config_file_path}..."
+        )
+        app_config = ApplicationConfiguration()
+        app_config.read(config_file_path)
+        self.build_parameters.title = app_config.title()
+        self.build_parameters.pip_packages = app_config.pip_packages()
+
+        self._logger.info("Generating app.json...")
+        self._application_manifest = app_config.populate_app_manifest(
+            self.build_parameters
+        )
+        self._logger.info("Generating pkg.json...")
+        self._package_manifest = app_config.populate_package_manifest(
+            self.build_parameters
+        )