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

holoscan_cli/packager/package_command.py

@@ -19,10 +19,10 @@ from argparse import ArgumentParser, _SubParsersAction
 from packaging.version import Version
 
 from ..common.argparse_types import (
+    valid_host_ip,
     valid_dir_path,
     valid_existing_dir_path,
     valid_existing_path,
-    valid_platform_config,
     valid_platforms,
     valid_sdk_type,
 )
@@ -44,6 +44,14 @@ def create_package_parser(
         help="Holoscan application path: Python application directory with __main__.py, "
         "Python file, C++ source directory with CMakeLists.txt, or path to an executable.",
     )
+
+    parser.add_argument(
+        "--add",
+        action="append",
+        dest="additional_libs",
+        type=valid_existing_dir_path,
+        help="include additional library files, python files into the application directory.",
+    )
     parser.add_argument(
         "--config",
         "-c",
@@ -51,6 +59,14 @@ def create_package_parser(
         type=valid_existing_path,
         help="Holoscan application configuration file (.yaml)",
     )
+    parser.add_argument(
+        "--cuda",
+        type=int,
+        default=13,
+        choices=[12, 13],
+        help="set the version of the CUDA that is used to build the application. "
+        "Valid values: 12, 13. (default: 13)",
+    )
     parser.add_argument(
         "--docs",
         "-d",
@@ -70,19 +86,6 @@ def create_package_parser(
         help="target platform(s) for the build output separated by comma. "
         f"Valid values: {str.join(', ', SDK.PLATFORMS)}.",
     )
-    parser.add_argument(
-        "--platform-config",
-        type=valid_platform_config,
-        help="target platform configuration for the build output. "
-        f"Valid values: {str.join(', ', SDK.PLATFORM_CONFIGS)}.",
-    )
-    parser.add_argument(
-        "--add",
-        action="append",
-        dest="additional_libs",
-        type=valid_existing_dir_path,
-        help="include additional library files, python files into the application directory.",
-    )
     parser.add_argument(
         "--timeout", type=int, help="override default application timeout"
     )
@@ -91,6 +94,13 @@ def create_package_parser(
     )
 
     advanced_group = parser.add_argument_group(title="advanced build options")
+    advanced_group.add_argument(
+        "--add-host",
+        action="append",
+        dest="add_hosts",
+        type=valid_host_ip,
+        help="Add a custom host-to-IP mapping (format: host:ip).",
+    )
     advanced_group.add_argument(
         "--base-image",
         type=str,
@@ -101,13 +111,6 @@ def create_package_parser(
         type=str,
         help="container image name for building the C++ application.",
     )
-    advanced_group.add_argument(
-        "--includes",
-        nargs="*",
-        default=[],
-        choices=["debug", "holoviz", "torch", "onnx"],
-        help="additional packages to include in the container.",
-    )
     advanced_group.add_argument(
         "--build-cache",
         type=valid_dir_path,
@@ -126,6 +129,18 @@ def create_package_parser(
         "If not specified, the packager downloads "
         "the SDK file from the internet based on the SDK version.",
     )
+    advanced_group.add_argument(
+        "--includes",
+        nargs="*",
+        default=[],
+        choices=["debug", "holoviz", "torch", "onnx"],
+        help="additional packages to include in the container.",
+    )
+    advanced_group.add_argument(
+        "--input-data",
+        type=valid_dir_path,
+        help="sample input data to be embedded in the container.",
+    )
     advanced_group.add_argument(
         "--monai-deploy-sdk-file",
         type=valid_existing_path,
@@ -146,18 +161,18 @@ def create_package_parser(
         help="SDK for building the application: Holoscan or MONAI-Deploy. "
         f"Valid values: {str.join(', ', SDK.SDKS)}.",
     )
-    advanced_group.add_argument(
-        "--source",
-        type=str,
-        help="override Debian package, build container image and run container image from a "
-        "JSON formatted file or a secured web server (HTTPS).",
-    )
     advanced_group.add_argument(
         "--sdk-version",
         type=Version,
         help="set the version of the SDK that is used to build and package the application. "
         "If not specified, the packager attempts to detect the installed version.",
     )
+    advanced_group.add_argument(
+        "--source",
+        type=str,
+        help="override Debian package, build container image and run container image from a "
+        "JSON formatted file or a secured web server (HTTPS).",
+    )
 
     output_group = parser.add_argument_group(title="output options")
     output_group.add_argument(

holoscan_cli/packager/packager.py

@@ -103,7 +103,7 @@ def _package_application(args: Namespace):
                     f"""\nPlatform: {result.parameters.platform.value}/{result.parameters.platform_config.value}
     Status:     Succeeded
     Docker Tag: {result.docker_tag if result.docker_tag is not None else "N/A"}
-    Tarball:    {result.tarball_filenaem}"""  # noqa: E501
+    Tarball:    {result.tarball_filename}"""  # noqa: E501
                 )
             else:
                 print(

holoscan_cli/packager/parameters.py

@@ -16,7 +16,7 @@ import logging
 import os
 import platform
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, List, Optional
 
 from ..common.constants import SDK, Constants, DefaultValues
 from ..common.dockerutils import parse_docker_image_name_and_tag
@@ -34,14 +34,16 @@ class PlatformParameters:
     def __init__(
         self,
         platform: Platform,
-        platform_config: PlatformConfiguration,
         tag: str,
         version: str,
+        cuda_version: int = 13,
     ) -> None:
         self._logger = logging.getLogger("platform.parameters")
-        self._platform: Platform = platform
-        self._platform_config: PlatformConfiguration = platform_config
-        self._arch: Arch = SDK.PLATFORM_MAPPINGS[platform]
+        self._platform = SDK.INTERNAL_PLATFORM_MAPPINGS[platform][0]
+        self._platform_config: PlatformConfiguration = SDK.INTERNAL_PLATFORM_MAPPINGS[
+            platform
+        ][1]
+        self._arch: Arch = SDK.PLATFORM_ARCH_MAPPINGS[platform]
         self._tag_prefix: Optional[str]
         self._version: Optional[str]
 
@@ -66,6 +68,7 @@ class PlatformParameters:
         self._data["custom_base_image"] = False
         self._data["custom_holoscan_sdk"] = False
         self._data["custom_monai_deploy_sdk"] = False
+        self._data["cuda_version"] = cuda_version
         self._data["target_arch"] = "aarch64" if self._arch == Arch.arm64 else "x86_64"
         self._data["cuda_deb_arch"] = "sbsa" if self._arch == Arch.arm64 else "x86_64"
         self._data["holoscan_deb_arch"] = (
@@ -127,6 +130,10 @@ class PlatformParameters:
     def build_image(self, value: str):
         self._data["build_image"] = value
 
+    @property
+    def cuda_version(self) -> int:
+        return self._data["cuda_version"]
+
     @property
     def holoscan_sdk_file(self) -> Optional[Path]:
         return self._data["holoscan_sdk_file"]
@@ -204,7 +211,7 @@ class PlatformBuildResults:
     def __init__(self, parameters: PlatformParameters):
         self._parameters = parameters
         self._docker_tag: Optional[str] = None
-        self._tarball_filenaem: Optional[str] = None
+        self._tarball_filename: Optional[str] = None
         self._succeeded = False
         self._error: Optional[str] = None
 
@@ -229,12 +236,12 @@ class PlatformBuildResults:
         self._docker_tag = value
 
     @property
-    def tarball_filenaem(self) -> Optional[str]:
-        return self._tarball_filenaem
+    def tarball_filename(self) -> Optional[str]:
+        return self._tarball_filename
 
-    @tarball_filenaem.setter
-    def tarball_filenaem(self, value: Optional[str]):
-        self._tarball_filenaem = value
+    @tarball_filename.setter
+    def tarball_filename(self, value: Optional[str]):
+        self._tarball_filename = value
 
     @property
     def succeeded(self) -> bool:
@@ -276,8 +283,9 @@ class PackageBuildParameters:
         self._data["tarball_output"] = None
         self._data["cmake_args"] = ""
         self._data["includes"] = []
+        self._data["input_data"] = None
         self._data["additional_lib_paths"] = ""
-
+        self._data["add_hosts"] = []
         self._data["application_directory"] = None
         self._data["application_type"] = None
         self._data["application"] = None
@@ -528,6 +536,14 @@ class PackageBuildParameters:
     def monai_deploy_app_sdk_version(self, value: str):
         self._data["monai_deploy_app_sdk_version"] = value
 
+    @property
+    def add_hosts(self) -> List[str]:
+        return self._data["add_hosts"]
+
+    @add_hosts.setter
+    def add_hosts(self, value: List[str]):
+        self._data["add_hosts"] = value
+
     @property
     def includes(self) -> str:
         return self._data["includes"]
@@ -536,6 +552,14 @@ class PackageBuildParameters:
     def includes(self, value: str):
         self._data["includes"] = value
 
+    @property
+    def input_data(self) -> Path:
+        return self._data["input_data"]
+
+    @input_data.setter
+    def input_data(self, value: Path):
+        self._data["input_data"] = value
+
     @property
     def additional_lib_paths(self) -> str:
         """

holoscan_cli/packager/platforms.py

@@ -76,10 +76,8 @@ class Platform:
 
         platforms = []
         for platform in args.platform:
-            platform_config = args.platform_config
-
             platform_parameters = PlatformParameters(
-                platform, platform_config, args.tag, version
+                platform, args.tag, version, args.cuda
             )
 
             (
@@ -94,6 +92,7 @@ class Platform:
                 holoscan_sdk_version,
                 application_type,
                 args.build_image,
+                platform_parameters.cuda_version,
             )
 
             (
@@ -191,7 +190,10 @@ class Platform:
                 f"""No base image found for the selected configuration:
                         Platform: {platform_parameters.platform}
                         Configuration: {platform_parameters.platform_config}
-                        Version: {sdk_version}"""
+                        Version: {sdk_version}
+                        CUDA Version: {platform_parameters.cuda_version}
+                    Try to use a different CUDA version with '--cuda' option.
+                    """
             ) from ex
 
     def _find_build_image(
@@ -200,6 +202,7 @@ class Platform:
         sdk_version: str,
         application_type: ApplicationType,
         build_image: Optional[str] = None,
+        cuda_version: int = 13,
     ) -> Optional[str]:
         """
         Ensure user provided build image exists or locate the build image to use based on the
@@ -210,6 +213,7 @@ class Platform:
             sdk_version (str): SDK version
             application_type (ApplicationType): application type
             build_image (Optional[str]): user provided build image
+            cuda_version (int): CUDA version
 
         Returns:
             (str): build image for building the image based on the given platform and SDK version.
@@ -233,6 +237,8 @@ class Platform:
                     f"\n   Platform: {platform_parameters.platform.value}"
                     f"\n   Configuration: {platform_parameters.platform_config.value}"
                     f"\n   Version: {sdk_version}"
+                    f"\n   CUDA Version: {cuda_version}"
+                    "\n Try to use a different CUDA version with '--cuda' option."
                 ) from ex
         else:
             return None