holoscan 2.6.0__cp312-cp312-manylinux_2_35_aarch64.whl

holoscan-2.6.0.data/purelib/holoscan/cli/common/exceptions.py

@@ -0,0 +1,130 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2023-2024 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.
+"""  # noqa: E501
+
+
+class HoloscanSdkError(Exception):
+    """Base class for exceptions in this module."""
+
+    pass
+
+
+class WrongApplicationPathError(HoloscanSdkError):
+    """Raise when wrong application path is specified."""
+
+    pass
+
+
+class UnknownApplicationTypeError(HoloscanSdkError):
+    """Raise when wrong application path is specified."""
+
+    pass
+
+
+class InvalidSdkError(HoloscanSdkError):
+    """Raise when the SDK version or SDK file is not supported."""
+
+    pass
+
+
+class FailedToDetectSDKVersionError(HoloscanSdkError):
+    """Raise when unable to detect the SDK version."""
+
+    pass
+
+
+class InvalidApplicationConfigurationError(HoloscanSdkError):
+    """
+    Raise when required configuration value cannot be found
+    in the application configuration files."""
+
+    pass
+
+
+class IncompatiblePlatformConfigurationError(HoloscanSdkError):
+    """
+    Raise when the platforms given by the user are incompatible."""
+
+    pass
+
+
+class RunContainerError(HoloscanSdkError):
+    """
+    Raise when an error is encountered while running the container image."""
+
+    pass
+
+
+class InvalidManifestError(HoloscanSdkError):
+    """
+    Raise when the manifest is invalid."""
+
+    pass
+
+
+class ManifestReadError(HoloscanSdkError):
+    """
+    Raise when the manifest is invalid."""
+
+
+class ExternalAssetDownloadError(HoloscanSdkError):
+    """
+    Raise when the manifest is invalid."""
+
+
+class InvalidSourceFileError(HoloscanSdkError):
+    """
+    Raise when the provided artifact source file is invalid."""
+
+    pass
+
+
+class InvalidTagValueError(HoloscanSdkError):
+    """
+    Raise when the Docker tag is invalid."""
+
+    pass
+
+
+class InvalidSharedMemoryValueError(HoloscanSdkError):
+    """
+    Raise when the shared memory value is invalid."""
+
+    pass
+
+
+class ManifestDownloadError(HoloscanSdkError):
+    """
+    Raise when the failed to download manifest file."""
+
+    pass
+
+
+class UnmatchedDeviceError(HoloscanSdkError):
+    """
+    Raise when the shared memory value is invalid."""
+
+    def __init__(self, unmatched_devices: list[str], *args: object) -> None:
+        super().__init__(
+            f"The following devices cannot be found in /dev/: {str.join(',', unmatched_devices)}"
+        )
+
+
+class GpuResourceError(HoloscanSdkError):
+    """
+    Raise when the available GPUs are less than requetsed."""
+
+    pass

holoscan-2.6.0.data/purelib/holoscan/cli/common/sdk_utils.py

@@ -0,0 +1,180 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2023-2024 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.
+"""  # noqa: E501
+
+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 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:
+        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, artifact_sources: ArtifactSources, 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:
+        InvalidSdkError: when failed to detect SDK version.
+    """
+    if sdk is SdkType.Holoscan:
+        return [detect_holoscan_version(artifact_sources, sdk_version), None]
+    else:
+        return [
+            detect_holoscan_version(artifact_sources, None),
+            detect_monaideploy_version(artifact_sources, sdk_version),
+        ]
+
+
+def detect_holoscan_version(
+    artifact_sources: ArtifactSources, sdk_version: Optional[Version] = None
+) -> str:
+    """
+    Validates Holoscan version if specified. Otherwise, attempt to detect the Holoscan PyPI
+    package installed.
+
+    Args:
+        sdk (SdkType): SDK for building the application
+        sdk_version (Optional[str], optional): SDK version from user input. Defaults to None.
+
+    Raises:
+        InvalidSdkError: If specified SDK version is not supported.
+        FailedToDetectSDKVersionError: When unable to detect the installed Holoscan PyPI package.
+
+    Returns:
+        str: SDK version
+    """
+    if sdk_version is not None:
+        if sdk_version.base_version not in artifact_sources.holoscan_versions:
+            raise InvalidSdkError(
+                "Invalid SDK version specified: valid values are: "
+                f"{', '.join(artifact_sources.holoscan_versions)}"
+            )
+
+        return sdk_version.base_version
+    else:
+        try:
+            ver_str = importlib.metadata.version("holoscan").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]}"
+
+            if ver_str not in artifact_sources.holoscan_versions:
+                raise InvalidSdkError(
+                    f"Something must be wrong as we've detect Holoscan SDK v{ver_str}"
+                    f" which is not supported. Please reinstall Holoscan SDK."
+                )
+            return ver_str
+        except Exception as ex:
+            raise FailedToDetectSDKVersionError(
+                "Failed to detect installed Holoscan PyPI version.", ex
+            ) from ex
+
+
+def detect_monaideploy_version(
+    artifact_sources: ArtifactSources, sdk_version: Optional[Version] = None
+) -> str:
+    """
+    Validates MONAI Deploy version if specified. Otherwise, attempt to detect the MONAI Deploy
+    PyPI package installed.
+
+    Args:
+        sdk (SdkType): SDK for building the application
+        sdk_version (Optional[str], optional): SDK version from user input. Defaults to None.
+
+    Raises:
+        InvalidSdkError: If specified SDK version is not supported.
+        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-2.6.0.data/purelib/holoscan/cli/common/utils.py

@@ -0,0 +1,130 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2023-2024 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.
+"""  # noqa: E501
+
+import json
+import logging
+import socket
+import subprocess
+
+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=True)
+    return proc.wait()
+
+
+def run_cmd_output(cmd: str) -> str:
+    """
+    Executes command and returns the output.
+
+    Args:
+        cmd: command to execute.
+
+    Returns:
+        output: command output.
+    """
+    proc = subprocess.run(cmd, capture_output=True, text=True, shell=True)
+    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-2.6.0.data/purelib/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-2.6.0.data/purelib/holoscan/cli/nics/__init__.py

@@ -0,0 +1,18 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2023-2024 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.
+"""  # noqa: E501
+
+from .nics import execute_nics_command  # noqa: F401

holoscan-2.6.0.data/purelib/holoscan/cli/nics/nics.py

@@ -0,0 +1,34 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2023-2024 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.
+"""  # noqa: E501
+
+import logging
+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)

holoscan-2.6.0.data/purelib/holoscan/cli/packager/__init__.py

@@ -0,0 +1,18 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2023-2024 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.
+"""  # noqa: E501
+
+from .packager import execute_package_command  # noqa: F401

holoscan-2.6.0.data/purelib/holoscan/cli/packager/arguments.py

@@ -0,0 +1,137 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2023-2024 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.
+"""  # noqa: E501
+
+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
+
+        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", ":8777"],
+                "initialDelaySeconds": 1,
+                "periodSeconds": 10,
+                "timeoutSeconds": 1,
+                "failureThreshold": 3,
+            }
+            self.application_manifest.liveness = {
+                "type": "command",
+                "command": ["/bin/grpc_health_probe", "-addr", ":8777"],
+                "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)