holoscan-cli 2.9.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

holoscan_cli/__main__.py

@@ -20,7 +20,6 @@ import os
 from pathlib import Path
 from typing import Optional, Union
 
-from .common.enum_types import Platform, PlatformConfiguration
 
 logging.getLogger("docker.api.build").setLevel(logging.WARNING)
 logging.getLogger("docker.auth").setLevel(logging.WARNING)
@@ -97,14 +96,6 @@ def parse_args(argv: Optional[list[str]] = None) -> argparse.Namespace:
         parser.print_help()
         parser.exit()
 
-    if args.command == "package":
-        if args.platform[0] == Platform.X64Workstation:
-            args.platform_config = PlatformConfiguration.dGPU
-        elif args.platform_config is None:
-            parser.error(
-                f"'--platform-config' is required for '{args.platform[0].value}'"
-            )
-
     return args
 
 

holoscan_cli/common/argparse_types.py

@@ -15,7 +15,6 @@
 import argparse
 import os
 from pathlib import Path
-
 from .constants import SDK
 from .enum_types import Platform, PlatformConfiguration, SdkType
 
@@ -107,6 +106,7 @@ def valid_platforms(platforms_str: str) -> list[Platform]:
     platforms = platforms_str.lower().split(",")
     platform_enums = []
     for platform in platforms:
+        platform = platform.strip()
         if platform not in SDK.PLATFORMS:
             raise argparse.ArgumentTypeError(
                 f"{platform} is not a valid option for --platforms."
@@ -128,7 +128,7 @@ def valid_platform_config(platform_config_str: str) -> PlatformConfiguration:
         Otherwise, raises argparse.ArgumentTypeError.
     """
 
-    platform_config_str = platform_config_str.lower()
+    platform_config_str = platform_config_str.lower().strip()
     if platform_config_str not in SDK.PLATFORM_CONFIGS:
         raise argparse.ArgumentTypeError(
             f"{platform_config_str} is not a valid option for --platform-config."
@@ -149,8 +149,23 @@ def valid_sdk_type(sdk_str: str) -> SdkType:
         Otherwise, raises argparse.ArgumentTypeError.
     """
 
-    sdk_str = sdk_str.lower()
+    sdk_str = sdk_str.lower().strip()
     if sdk_str not in SDK.SDKS:
         raise argparse.ArgumentTypeError(f"{sdk_str} is not a valid option for --sdk.")
 
     return SdkType(sdk_str)
+
+
+def valid_host_ip(host_ip: str) -> str:
+    """Helper type checking and type converting method for ArgumentParser.add_argument
+    to convert check valid host:ip format.
+
+    Args:
+        host_ip: host ip string
+    """
+
+    host, ip = host_ip.split(":")
+    if host == "" or ip == "":
+        raise argparse.ArgumentTypeError(f"Invalid valid for --add-host: '{host_ip}'")
+
+    return host_ip

holoscan_cli/common/artifact_sources.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 import json
 import logging
+import os
 from typing import Any, Optional
 
 import requests
@@ -36,8 +37,9 @@ class ArtifactSources:
     HoloscanVersion = None
     ManifestFileUrl = None
 
-    def __init__(self) -> None:
+    def __init__(self, cuda_version: int) -> None:
         self._logger = logging.getLogger("common")
+        self._cuda_version = cuda_version
         try:
             ArtifactSources.HoloscanVersion = ".".join(
                 str(i) for i in Version(__version__).release[0:3]
@@ -48,7 +50,10 @@ class ArtifactSources:
                 "a Holoscan SDK version to use."
             ) from ex
 
-        ArtifactSources.ManifestFileUrl = f"https://raw.githubusercontent.com/nvidia-holoscan/holoscan-cli/refs/heads/main/releases/{ArtifactSources.HoloscanVersion}/artifacts.json"  # noqa: E501
+        if self._cuda_version == 12:
+            ArtifactSources.ManifestFileUrl = f"https://raw.githubusercontent.com/nvidia-holoscan/holoscan-cli/refs/heads/main/releases/{ArtifactSources.HoloscanVersion}/artifacts-cu12.json"  # noqa: E501
+        else:
+            ArtifactSources.ManifestFileUrl = f"https://raw.githubusercontent.com/nvidia-holoscan/holoscan-cli/refs/heads/main/releases/{ArtifactSources.HoloscanVersion}/artifacts.json"  # noqa: E501
 
     @property
     def holoscan_versions(self) -> list[str]:
@@ -82,6 +87,12 @@ class ArtifactSources:
                 "Downloading manifest files from non-HTTPS servers is not supported."
             )
         else:
+            if os.path.isdir(uri):
+                if self._cuda_version == 12:
+                    uri = os.path.join(uri, "artifacts-cu12.json")
+                else:
+                    uri = os.path.join(uri, "artifacts.json")
+
             self._logger.info(f"Using CLI manifest file from {uri}...")
             with open(uri) as file:
                 temp = json.load(file)
@@ -116,7 +127,7 @@ class ArtifactSources:
         )
 
     def _download_manifest_internal(self, url, headers=None):
-        self._logger.info("Downloading CLI manifest file...")
+        self._logger.info(f"Downloading CLI manifest file from {url}...")
         manifest = requests.get(url, headers=headers)
 
         try:

holoscan_cli/common/constants.py

@@ -69,6 +69,9 @@ class Constants:
 
     RESOURCE_SHARED_MEMORY_KEY = "sharedMemory"
 
+    # Include "holoscan" for backward compatibility; remove post 3.7.0 release
+    PYPI_PACKAGE_NAMES = ["holoscan-cu12", "holoscan-cu13", "holoscan"]
+
 
 class SDK:
     """
@@ -77,19 +80,21 @@ class SDK:
     """
 
     # Platform to architecture mappings
-    PLATFORM_MAPPINGS = {
-        Platform.IGXOrinDevIt: Arch.arm64,
-        Platform.JetsonAgxOrinDevKit: Arch.arm64,
+    PLATFORM_ARCH_MAPPINGS = {
+        Platform.Jetson: Arch.arm64,
+        Platform.IGX_iGPU: Arch.arm64,
+        Platform.IGX_dGPU: Arch.arm64,
         Platform.SBSA: Arch.arm64,
-        Platform.X64Workstation: Arch.amd64,
+        Platform.x86_64: Arch.amd64,
     }
 
     # Values of all platforms supported by the Packager
     PLATFORMS = [
-        Platform.IGXOrinDevIt.value,
-        Platform.JetsonAgxOrinDevKit.value,
+        Platform.Jetson.value,
+        Platform.IGX_iGPU.value,
+        Platform.IGX_dGPU.value,
         Platform.SBSA.value,
-        Platform.X64Workstation.value,
+        Platform.x86_64.value,
     ]
 
     # Values of all platform configurations supported by the Packager
@@ -98,6 +103,14 @@ class SDK:
         PlatformConfiguration.dGPU.value,
     ]
 
+    INTERNAL_PLATFORM_MAPPINGS = {
+        Platform.Jetson: (Platform.JetsonAgxOrinDevKit, PlatformConfiguration.iGPU),
+        Platform.IGX_iGPU: (Platform.IGXOrinDevIt, PlatformConfiguration.iGPU),
+        Platform.IGX_dGPU: (Platform.IGXOrinDevIt, PlatformConfiguration.dGPU),
+        Platform.SBSA: (Platform.SBSA, PlatformConfiguration.dGPU),
+        Platform.x86_64: (Platform.X64Workstation, PlatformConfiguration.dGPU),
+    }
+
     # Values of SDKs supported by the Packager
     SDKS = [SdkType.Holoscan.value, SdkType.MonaiDeploy.value]
 

holoscan_cli/common/dockerutils.py

@@ -172,6 +172,7 @@ def docker_run(
     platform_config: str,
     shared_memory_size: str = "1GB",
     is_root: bool = False,
+    remove: bool = False,
 ):
     """Creates and runs a Docker container
 
@@ -351,6 +352,7 @@ def docker_run(
             ulimits,
             devices,
             group_adds,
+            remove,
         )
     else:
         _start_container(
@@ -368,6 +370,7 @@ def docker_run(
             ulimits,
             devices,
             group_adds,
+            remove,
         )
 
 
@@ -386,6 +389,7 @@ def _start_container(
     ulimits,
     devices,
     group_adds,
+    remove,
 ):
     container = docker.container.create(
         image_name,
@@ -394,7 +398,7 @@ def _start_container(
         hostname=name,
         name=name,
         networks=[network],
-        remove=True,
+        remove=False,
         shm_size=shared_memory_size,
         user=user,
         volumes=volumes,
@@ -441,7 +445,18 @@ def _start_container(
             except Exception:
                 print(str(log[1]))
 
-    logger.info(f"Container '{container_name}'({container_id}) exited.")
+    exit_code = container.state.exit_code
+    logger.info(
+        f"Container '{container_name}'({container_id}) exited with code {exit_code}."
+    )
+
+    if remove:
+        container.remove()
+
+    if exit_code != 0:
+        raise RuntimeError(
+            f"Container '{container_name}'({container_id}) exited with code {exit_code}."
+        )
 
 
 def _enter_terminal(
@@ -457,6 +472,7 @@ def _enter_terminal(
     ulimits,
     devices,
     group_adds,
+    remove,
 ):
     print("\n\nEntering terminal...")
     print(
@@ -475,7 +491,7 @@ def _enter_terminal(
         interactive=True,
         name=name,
         networks=[network],
-        remove=True,
+        remove=remove,
         shm_size=shared_memory_size,
         tty=True,
         user=user,

holoscan_cli/common/enum_types.py

@@ -37,10 +37,18 @@ class Arch(Enum):
 
 
 class Platform(Enum):
+    # User values - when a new value is added, please also update SDK.PLATFORMS
+    Jetson = "jetson"
+    IGX_iGPU = "igx-igpu"
+    IGX_dGPU = "igx-dgpu"
+    SBSA = "sbsa"
+    x86_64 = "x86_64"
+
+    # Internal use only - for mapping actual platform with platform configuration
+    #  as defined in SDK.INTERNAL_PLATFORM_MAPPINGS.
     IGXOrinDevIt = "igx-orin-devkit"
     JetsonAgxOrinDevKit = "jetson-agx-orin-devkit"
     X64Workstation = "x64-workstation"
-    SBSA = "sbsa"
 
 
 class PlatformConfiguration(Enum):

holoscan_cli/common/sdk_utils.py

@@ -21,6 +21,7 @@ from typing import Optional
 from packaging.version import Version
 
 from .artifact_sources import ArtifactSources
+from .constants import Constants
 from .enum_types import SdkType
 from .exceptions import FailedToDetectSDKVersionError, InvalidSdkError
 
@@ -72,19 +73,7 @@ def detect_sdk(sdk: Optional[SdkType] = None) -> SdkType:
 
     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()
+        command = Path(sys.argv[0]).name.lower()
         return SdkType(command)
     except Exception as ex:
         raise InvalidSdkError(f"Invalid SDK value provided: {command}") from ex
@@ -137,32 +126,37 @@ def detect_holoscan_version(sdk_version: Optional[Version] = None) -> str:
     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:
+        # Scan for installed packages with prefix "holoscan"
+        holoscan_pkgs = [
+            dist.metadata["Name"]
+            for dist in importlib.metadata.distributions()
+            if dist.metadata["Name"].lower() in Constants.PYPI_PACKAGE_NAMES
+        ]
+        if not holoscan_pkgs:
             raise FailedToDetectSDKVersionError(
-                "Failed to detect installed Holoscan PyPI version.", ex
-            ) from ex
+                "No installed Holoscan PyPI package found."
+            )
+        ver_str = importlib.metadata.version(holoscan_pkgs[0]).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
 
 
 def detect_monaideploy_version(sdk_version: Optional[Version] = None) -> str:
@@ -193,3 +187,17 @@ def detect_monaideploy_version(sdk_version: Optional[Version] = None) -> str:
             raise FailedToDetectSDKVersionError(
                 "Failed to detect installed MONAI Deploy App SDK PyPI version.", ex
             ) from ex
+
+
+def detect_holoscan_cli_version() -> str:
+    """
+    Detects Holoscan CLI version to use based on installed PyPI package.
+    """
+    try:
+        ver_str = importlib.metadata.version("holoscan-cli").title()
+        ver = Version(ver_str)
+        return ver.base_version
+    except Exception as ex:
+        raise FailedToDetectSDKVersionError(
+            "Failed to detect installed Holoscan CLI PyPI version.", ex
+        ) from ex

holoscan_cli/nics/nics.py

@@ -28,6 +28,6 @@ def execute_nics_command(args: Namespace):
         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.error("Error executing nics command.")
         logger.debug(ex)
         sys.exit(4)

holoscan_cli/packager/arguments.py

@@ -54,7 +54,7 @@ class PackagingArguments:
 
         self._platforms: list[PlatformParameters]
         self._build_parameters = PackageBuildParameters()
-        self._artifact_sources = ArtifactSources()
+        self._artifact_sources = ArtifactSources(args.cuda)
 
         if args.source is not None:
             self._artifact_sources.load(args.source)
@@ -76,6 +76,8 @@ class PackagingArguments:
         self.build_parameters.cmake_args = args.cmake_args
         self.build_parameters.includes = args.includes
         self.build_parameters.additional_libs = args.additional_libs
+        self.build_parameters.add_hosts = args.add_hosts
+        self.build_parameters.input_data = args.input_data
 
         models = Models()
         platform = Platform(self._artifact_sources)
@@ -127,7 +129,9 @@ class PackagingArguments:
                 self.build_parameters.monai_deploy_app_sdk_version
             )
 
-        self._package_manifest.platform_config = args.platform_config.value
+        self._package_manifest.platform_config = self._platforms[
+            0
+        ].platform_config.value
 
     def _read_application_config_file(self, config_file_path: Path):
         self._logger.info(

holoscan_cli/packager/container_builder.py

@@ -27,7 +27,10 @@ from ..common.dockerutils import (
     create_and_get_builder,
     docker_export_tarball,
 )
-from ..common.exceptions import WrongApplicationPathError
+from ..common.exceptions import (
+    IncompatiblePlatformConfigurationError,
+    WrongApplicationPathError,
+)
 from .parameters import PackageBuildParameters, PlatformBuildResults, PlatformParameters
 
 
@@ -58,6 +61,8 @@ class BuilderBase:
         self._copy_model_files()
         self._copy_docs()
         self._copy_libs()
+        self._copy_input_data()
+
         _ = self._write_dockerignore()
         _ = self._copy_script()
 
@@ -88,7 +93,6 @@ class BuilderBase:
         Returns:
             PlatformBuildResults: build results
         """
-        self.print_build_info(platform_parameters)
         builder = create_and_get_builder(Constants.LOCAL_BUILDX_BUILDER_NAME)
 
         build_result = PlatformBuildResults(platform_parameters)
@@ -117,9 +121,15 @@ class BuilderBase:
             "tags": [platform_parameters.tag],
         }
 
+        if self._build_parameters.add_hosts:
+            builds["add_hosts"] = {}
+            for host in self._build_parameters.add_hosts:
+                host_name, host_ip = host.split(":")
+                builds["add_hosts"][host_name] = host_ip
+
         export_to_tar_ball = False
         if self._build_parameters.tarball_output is not None:
-            build_result.tarball_filenaem = str(
+            build_result.tarball_filename = str(
                 self._build_parameters.tarball_output
                 / f"{platform_parameters.tag}{Constants.TARBALL_FILE_EXTENSION}"
             ).replace(":", "-")
@@ -134,7 +144,7 @@ class BuilderBase:
                 builds["output"] = {
                     # type=oci cannot be loaded by docker: https://github.com/docker/buildx/issues/59
                     "type": "docker",
-                    "dest": build_result.tarball_filenaem,
+                    "dest": build_result.tarball_filename,
                 }
             else:
                 build_result.succeeded = False
@@ -155,21 +165,24 @@ class BuilderBase:
             f"Building Holoscan Application Package: tag={platform_parameters.tag}"
         )
 
+        self.print_build_info(platform_parameters)
+
         try:
             build_docker_image(**builds)
             build_result.succeeded = True
             if export_to_tar_ball:
                 try:
                     self._logger.info(
-                        f"Saving {platform_parameters.tag} to {build_result.tarball_filenaem}..."
+                        f"Saving {platform_parameters.tag} to {build_result.tarball_filename}..."
                     )
                     docker_export_tarball(
-                        build_result.tarball_filenaem, platform_parameters.tag
+                        build_result.tarball_filename, platform_parameters.tag
                     )
                 except Exception as ex:
                     build_result.error = f"Error saving tarball: {ex}"
                     build_result.succeeded = False
-        except Exception:
+        except Exception as e:
+            print(e)
             build_result.succeeded = False
             build_result.error = (
                 "Error building image: see Docker output for additional details."
@@ -177,6 +190,13 @@ class BuilderBase:
 
         return build_result
 
+    def _copy_input_data(self):
+        """Copy input data to temporary location"""
+        if self._build_parameters.input_data is not None:
+            shutil.copytree(
+                self._build_parameters.input_data, os.path.join(self._temp_dir, "input")
+            )
+
     def print_build_info(self, platform_parameters):
         """Print build information for the platform."""
         self._logger.info(
@@ -186,6 +206,7 @@ Building image for:                 {platform_parameters.platform.value}
     Architecture:                   {platform_parameters.platform_arch.value}
     Base Image:                     {platform_parameters.base_image}
     Build Image:                    {platform_parameters.build_image if platform_parameters.build_image is not None else "N/A"}
+    CUDA Version:                   {platform_parameters.cuda_version}
     Cache:                          {'Disabled' if self._build_parameters.no_cache else 'Enabled'}
     Configuration:                  {platform_parameters.platform_config.value}
     Holoscan SDK Package:           {platform_parameters.holoscan_sdk_file if platform_parameters.holoscan_sdk_file is not None else "N/A"}
@@ -337,7 +358,15 @@ Building image for:                 {platform_parameters.platform.value}
 """
         )
 
-        jinja_template = jinja_env.get_template("Dockerfile.jinja2")
+        if platform_parameters.cuda_version == 12:
+            jinja_template = jinja_env.get_template("Dockerfile-cu12.jinja2")
+        elif platform_parameters.cuda_version == 13:
+            jinja_template = jinja_env.get_template("Dockerfile.jinja2")
+        else:
+            raise IncompatiblePlatformConfigurationError(
+                f"Invalid CUDA version: {platform_parameters.cuda_version}"
+            )
+
         return jinja_template.render(
             {
                 **self._build_parameters.to_jinja,
@@ -377,18 +406,28 @@ class PythonAppBuilder(BuilderBase):
         pip_folder = os.path.join(self._temp_dir, "pip")
         os.makedirs(pip_folder, exist_ok=True)
         pip_requirements_path = os.path.join(pip_folder, "requirements.txt")
+
+        # Build requirements content first
+        requirements_content = []
+        if self._build_parameters.requirements_file_path is not None:
+            with open(self._build_parameters.requirements_file_path) as lr:
+                requirements_content.extend(lr)
+            requirements_content.append("")
+
+        if self._build_parameters.pip_packages:
+            requirements_content.extend(self._build_parameters.pip_packages)
+
+        # Write all content at once
         with open(pip_requirements_path, "w") as requirements_file:
-            # Use local requirements.txt packages if provided, otherwise use sdk provided packages
-            if self._build_parameters.requirements_file_path is not None:
-                with open(self._build_parameters.requirements_file_path) as lr:
-                    for line in lr:
-                        requirements_file.write(line)
-                requirements_file.writelines("\n")
-
-            if self._build_parameters.pip_packages:
-                requirements_file.writelines(
-                    "\n".join(self._build_parameters.pip_packages)
-                )
+            requirements_file.writelines(requirements_content)
+            self._logger.debug(
+                "================ Begin requirements.txt ================"
+            )
+            for req in requirements_content:
+                self._logger.debug(f"  {req.strip()}")
+            self._logger.debug(
+                "================ End requirements.txt =================="
+            )
 
     def _copy_sdk_file(self, sdk_file: Optional[Path]):
         if sdk_file is not None and os.path.isfile(sdk_file):