holoscan 2.6.0__cp312-cp312-manylinux_2_35_x86_64.whl

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

@@ -0,0 +1,133 @@
+"""
+SPDX-FileCopyrightText: Copyright (c) 2022-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
+
+# We import cli, core and gxf to make sure they're available before other modules that rely on them
+from . import cli, core, gxf
+
+
+def _set_version():
+    try:
+        return importlib.metadata.version("holoscan")
+    except ImportError:
+        return "unknown version"
+
+
+__all__ = ["__version__", "as_tensor", "cli", "core", "gxf"]
+__version__ = _set_version()
+
+
+def as_tensor(obj):
+    if hasattr(obj, "__cuda_array_interface__") or hasattr(obj, "__array_interface__"):
+        # Workaround for bug in CuPy<13.0.0a1 where strides of ndarray with all but 1 dimension a
+        # singleton, could become order='F' strides instead of the expected order='C' strides.
+        # See:
+        #   https://github.com/cupy/cupy/pull/7438
+        #   https://github.com/cupy/cupy/pull/7457
+        #   https://forums.developer.nvidia.com/t/known-issue-in-cupy-affecting-tensor-interop/244423
+        #
+        # Here we force any array that is both C and F contiguous to have C-ordered strides
+        # We do this for both NumPy and CuPy arrays for consistency.
+
+        # nd-array, but with only 1 non-singleton dimension
+        nd_singleton = (obj.ndim > 1) and (sum(tuple(s > 1 for s in obj.shape)) == 1)
+        if nd_singleton and obj.flags.forc:
+            # determine expected strides for a C-contiguous array
+            expected_strides = [
+                1,
+            ] * obj.ndim
+            expected_strides[obj.ndim - 1] = obj.itemsize
+            for i in range(obj.ndim - 2, -1, -1):
+                expected_strides[i] = expected_strides[i + 1] * obj.shape[i + 1]
+            expected_strides = tuple(expected_strides)
+
+            # make a copy to force stride update if they do not match
+            if obj.strides != expected_strides:
+                if hasattr(obj, "__cuda_array_interface__"):
+                    try:
+                        import cupy as cp
+
+                        if isinstance(obj, cp.ndarray):
+                            # use as_strided to avoid a copy
+                            obj = cp.lib.stride_tricks.as_strided(
+                                obj, shape=obj.shape, strides=expected_strides
+                            )
+                            return core.Tensor.as_tensor(obj)
+                    except ImportError:
+                        pass
+                elif hasattr(obj, "__array_interface__"):
+                    try:
+                        import numpy as np
+
+                        if isinstance(obj, np.ndarray):
+                            # use as_strided to avoid a copy
+                            obj = np.lib.stride_tricks.as_strided(
+                                obj, shape=obj.shape, strides=expected_strides
+                            )
+                            return core.Tensor.as_tensor(obj)
+                    except ImportError:
+                        pass
+                # update strides by making an explicit copy
+                try:
+                    obj = obj.copy(order="C")
+                except (AttributeError, TypeError):
+                    import warnings
+
+                    warnings.warn(
+                        "Unexpected strides encountered during call to `as_tensor` and no copy "
+                        "method was available. Leaving the strides unchanged.",
+                        stacklevel=2,
+                    )
+
+    return core.Tensor.as_tensor(obj)
+
+
+as_tensor.__doc__ = core.Tensor.as_tensor.__doc__
+
+
+# Other modules are exposed to the public API but will only be lazily loaded
+_EXTRA_MODULES = [
+    "conditions",
+    "decorator",
+    "executors",
+    "graphs",
+    "logger",
+    "operators",
+    "resources",
+    "schedulers",
+]
+__all__.extend(_EXTRA_MODULES)
+
+
+# Autocomplete
+def __dir__():
+    return __all__
+
+
+# Lazily load extra modules
+def __getattr__(name):
+    import importlib
+    import sys
+
+    if name in _EXTRA_MODULES:
+        module_name = f"{__name__}.{name}"
+        module = importlib.import_module(module_name)  # import
+        sys.modules[module_name] = module  # cache
+        return module
+    else:
+        raise AttributeError(f"module {__name__} has no attribute {name}")

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

@@ -0,0 +1,32 @@
+# 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 undwer the License.
+"""
+.. autosummary::
+    :toctree: _autosummary
+
+    common
+    packager
+    runner
+    version
+"""
+
+import os
+import sys
+
+__title__ = "holoscan.cli"
+_current_dir = os.path.abspath(os.path.dirname(__file__))
+if sys.path and os.path.abspath(sys.path[0]) != _current_dir:
+    sys.path.insert(0, _current_dir)
+del _current_dir

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

@@ -0,0 +1,159 @@
+"""
+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 argparse
+import json
+import logging
+import logging.config
+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)
+logging.getLogger("docker.utils.config").setLevel(logging.WARNING)
+logging.getLogger("urllib3.connectionpool").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+LOG_CONFIG_FILENAME = "logging.json"
+
+
+def parse_args(argv: Optional[list[str]] = None) -> argparse.Namespace:
+    from .packager.package_command import create_package_parser
+    from .runner.run_command import create_run_parser
+
+    if argv is None:
+        import sys
+
+        argv = sys.argv
+    argv = list(argv)  # copy argv for manipulation to avoid side-effects
+
+    # We have intentionally not set the default using `default="INFO"` here so that the default
+    # value from here doesn't override the value in `LOG_CONFIG_FILENAME` unless the user indends
+    # to do so. If the user doesn't use this flag to set log level, this argument is set to "None"
+    # and the logging level specified in `LOG_CONFIG_FILENAME` is used.
+
+    command_name = os.path.basename(argv[0])
+    program_name = "holoscan" if command_name == "__main__.py" else command_name
+    parent_parser = argparse.ArgumentParser()
+
+    parent_parser.add_argument(
+        "-l",
+        "--log-level",
+        dest="log_level",
+        type=str.upper,
+        choices=["DEBUG", "INFO", "WARN", "ERROR", "CRITICAL"],
+        help="set the logging level (default: INFO)",
+    )
+
+    parser = argparse.ArgumentParser(
+        parents=[parent_parser],
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        add_help=False,
+        prog=program_name,
+    )
+
+    subparser = parser.add_subparsers(dest="command")
+
+    # Parser for `package` command
+    create_package_parser(subparser, "package", parents=[parent_parser])
+
+    # Parser for `run` command
+    create_run_parser(subparser, "run", parents=[parent_parser])
+
+    # Parser for `version` command
+    subparser.add_parser(
+        "version", formatter_class=argparse.HelpFormatter, parents=[parent_parser], add_help=False
+    )
+
+    # Parser for `nics` command
+    subparser.add_parser(
+        "nics", formatter_class=argparse.HelpFormatter, parents=[parent_parser], add_help=False
+    )
+    args = parser.parse_args(argv[1:])
+    args.argv = argv  # save argv for later use in runpy
+
+    # Print help if no command is specified
+    if args.command is None:
+        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
+
+
+def set_up_logging(level: Optional[str], config_path: Union[str, Path] = LOG_CONFIG_FILENAME):
+    """Initializes the logger and sets up logging level.
+
+    Args:
+        level (str): A logging level (DEBUG, INFO, WARN, ERROR, CRITICAL).
+        log_config_path (str): A path to logging config file.
+    """
+    # Default log config path
+    log_config_path = Path(__file__).absolute().parent / LOG_CONFIG_FILENAME
+
+    config_path = Path(config_path)
+
+    # If a logging config file that is specified by `log_config_path` exists in the current folder,
+    # it overrides the default one
+    if config_path.exists():
+        log_config_path = config_path
+
+    config_dict = json.loads(log_config_path.read_bytes())
+
+    if level is not None and "root" in config_dict:
+        config_dict["root"]["level"] = level
+    logging.config.dictConfig(config_dict)
+
+
+def main(argv: Optional[list[str]] = None):
+    args = parse_args(argv)
+
+    set_up_logging(args.log_level)
+
+    if args.command == "package":
+        from .packager.packager import execute_package_command
+
+        execute_package_command(args)
+
+    elif args.command == "run":
+        from .runner.runner import execute_run_command
+
+        execute_run_command(args)
+
+    elif args.command == "version":
+        from .common.artifact_sources import ArtifactSources
+        from .version.version import execute_version_command
+
+        artifact_sources = ArtifactSources()
+        execute_version_command(args, artifact_sources)
+
+    elif args.command == "nics":
+        from .nics.nics import execute_nics_command
+
+        execute_nics_command(args)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,153 @@
+"""
+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 argparse
+import os
+from pathlib import Path
+
+from .constants import SDK
+from .enum_types import Platform, PlatformConfiguration, SdkType
+
+
+def valid_dir_path(path: str, create_if_not_exists: bool = True) -> Path:
+    """Helper type checking and type converting method for ArgumentParser.add_argument
+    to convert string input to pathlib.Path if the given path exists and it is a directory path.
+    If directory does not exist, create the directory and convert string input to pathlib.Path.
+
+    Args:
+        path: string input path
+
+    Returns:
+        If path exists and is a directory, return absolute path as a pathlib.Path object.
+
+        If path exists and is not a directory, raises argparse.ArgumentTypeError.
+
+        If path doesn't exist, create the directory and return absolute path as a pathlib.Path
+        object.
+    """
+    path = os.path.expanduser(path)
+    dir_path = Path(path).absolute()
+    if dir_path.exists():
+        if dir_path.is_dir():
+            return dir_path
+        else:
+            raise argparse.ArgumentTypeError(
+                f"Expected directory path: '{dir_path}' is not a directory"
+            )
+
+    if create_if_not_exists:
+        # create directory
+        dir_path.mkdir(parents=True)
+        return dir_path
+
+    raise argparse.ArgumentTypeError(f"No such directory: '{dir_path}'")
+
+
+def valid_existing_dir_path(path: str) -> Path:
+    """Helper type checking and type converting method for ArgumentParser.add_argument
+    to convert string input to pathlib.Path if the given path exists and it is a directory path.
+
+    Args:
+        path: string input path
+
+    Returns:
+        If path exists and is a directory, return absolute path as a pathlib.Path object.
+
+        If path doesn't exist or it is not a directory, raises argparse.ArgumentTypeError.
+    """
+    return valid_dir_path(path, False)
+
+
+def valid_existing_path(path: str) -> Path:
+    """Helper type checking and type converting method for ArgumentParser.add_argument
+    to convert string input to pathlib.Path if the given file/folder path exists.
+
+    Args:
+        path: string input path
+
+    Returns:
+        If path exists, return absolute path as a pathlib.Path object.
+
+        If path doesn't exist, raises argparse.ArgumentTypeError.
+    """
+    path = os.path.expanduser(path)
+    file_path = Path(path).absolute()
+    if file_path.exists():
+        return file_path
+    raise argparse.ArgumentTypeError(f"No such file/folder: '{file_path}'")
+
+
+def valid_platforms(platforms_str: str) -> list[Platform]:
+    """Helper type checking and type converting method for ArgumentParser.add_argument
+    to convert platform strings to Platform enum if values are valid.
+
+    Args:
+        platforms_str: string comma separated platforms values
+    Returns:
+        If all values are valid, convert all values to Platform enum.
+
+        Otherwise, raises argparse.ArgumentTypeError.
+    """
+
+    platforms = platforms_str.lower().split(",")
+    platform_enums = []
+    for platform in platforms:
+        if platform not in SDK.PLATFORMS:
+            raise argparse.ArgumentTypeError(f"{platform} is not a valid option for --platforms.")
+        platform_enums.append(Platform(platform))
+
+    return platform_enums
+
+
+def valid_platform_config(platform_config_str: str) -> PlatformConfiguration:
+    """Helper type checking and type converting method for ArgumentParser.add_argument
+    to convert platform configuration string to PlatformConfigurations enum if value is valid.
+
+    Args:
+        platform_config_str: a platforms configuration value
+    Returns:
+        If the value is valid, convert the value to PlatformConfigurations enum.
+
+        Otherwise, raises argparse.ArgumentTypeError.
+    """
+
+    platform_config_str = platform_config_str.lower()
+    if platform_config_str not in SDK.PLATFORM_CONFIGS:
+        raise argparse.ArgumentTypeError(
+            f"{platform_config_str} is not a valid option for --platform-config."
+        )
+
+    return PlatformConfiguration(platform_config_str)
+
+
+def valid_sdk_type(sdk_str: str) -> SdkType:
+    """Helper type checking and type converting method for ArgumentParser.add_argument
+    to convert sdk string to SdkType enum if value is valid.
+
+    Args:
+        sdk_str: sdk string
+    Returns:
+        If the value is valid, convert the value to SdkType enum.
+
+        Otherwise, raises argparse.ArgumentTypeError.
+    """
+
+    sdk_str = sdk_str.lower()
+    if sdk_str not in SDK.SDKS:
+        raise argparse.ArgumentTypeError(f"{sdk_str} is not a valid option for --sdk.")
+
+    return SdkType(sdk_str)

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

@@ -0,0 +1,149 @@
+"""
+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
+from typing import Any, Optional
+
+import requests
+from packaging.version import Version
+
+from holoscan import __version__ as holoscan_version_string
+
+from .enum_types import PlatformConfiguration, SdkType
+from .exceptions import InvalidSourceFileError, ManifestDownloadError
+
+
+class ArtifactSources:
+    """Provides default artifact source URLs with the ability to override."""
+
+    SectionWheelVersion = "wheel-version"
+    SectionDebianVersion = "debian-version"
+    SectionBaseImages = "base-images"
+    SectionBuildImages = "build-images"
+    SectionHealthProbe = "health-probes"
+    EdgeROToken = "eyJ2ZXIiOiIyIiwidHlwIjoiSldUIiwiYWxnIjoiUlMyNTYiLCJraWQiOiJLcXV1ZVdTTlRjSkhqTFhGLTJCSnctX0lkRnY0eVhqREJyNEdWMU5Gc2NJIn0.eyJzdWIiOiJqZnJ0QDAxZHRqNnF0ZWNmcnB6MXJrNmg2cjAwd2FkXC91c2Vyc1wvc3ZjLWhvbG9zY2FuLWNsaS1wdWJsaWMtcm8iLCJzY3AiOiJtZW1iZXItb2YtZ3JvdXBzOnN2Yy1ob2xvc2Nhbi1jbGktcHVibGljLWdyb3VwIiwiYXVkIjoiamZydEAwMWR0ajZxdGVjZnJwejFyazZoNnIwMHdhZCIsImlzcyI6ImpmcnRAMDFkdGo2cXRlY2ZycHoxcms2aDZyMDB3YWRcL3VzZXJzXC9ycGFsYW5pc3dhbXkiLCJpYXQiOjE3MDY1NzA1NjUsImp0aSI6IjlmNmEyMmM1LTk5ZTItNGRlMi1hMDhiLTQxZjg2NzIyYmJjNyJ9.Y0gfyW2F0kxiKnMhGzNCyRRE2DNrDW6CUj5ozrQiIvAbSbhohskFcFmP836PU4p3ZQTzbYk9-bBwrqoPDUaZf8p9AW9GZ3mvlU2BxK0EQ-F4oKxA1_Z7agZ0KKcmcrfWnE4Ffy53qAD8PTk5vdcznpYOBpJtF4i16j2QcXvhVGGEqUyGa7_sONdK0sevb3ZztiEoupi4gD2wPTRn30rjpGIiFSDKiswAQwoyF_SqMCQWOBEeXMISp8hkEggUpvPrESv2lbpjgaKuEJ1CikbivYTJCcoqpgH7E72FXr1sB9jfwrFD8pkjtRpGGDxN43waXy4f3Ctr8_rpbmCvwSa9iw"  # noqa: E501
+    HoloscanVersion = None
+    ManifestFileUrl = None
+
+    def __init__(self) -> None:
+        ArtifactSources.HoloscanVersion = ".".join(
+            str(i) for i in Version(holoscan_version_string).release[0:3]
+        )
+        ArtifactSources.ManifestFileUrl = f"https://edge.urm.nvidia.com/artifactory/sw-holoscan-cli-generic/{ArtifactSources.HoloscanVersion}/artifacts.json"
+        self._logger = logging.getLogger("common")
+        self._supported_holoscan_versions = ["2.6.0"]
+
+    @property
+    def holoscan_versions(self) -> list[str]:
+        # logic to dynamically fetch the supported versions
+        return self._supported_holoscan_versions  # for now, return the hardcoded value
+
+    def base_image(self, version) -> str:
+        return self._data[version][SdkType.Holoscan.value][ArtifactSources.SectionBaseImages]
+
+    def build_images(self, version) -> dict[Any, str]:
+        return self._data[version][SdkType.Holoscan.value][ArtifactSources.SectionBuildImages]
+
+    def health_probe(self, version) -> dict[Any, str]:
+        return self._data[version][ArtifactSources.SectionHealthProbe]
+
+    def load(self, uri: str):
+        """Overrides the default values from a given JSON file.
+           Validates top-level attributes to ensure the file is valid
+
+        Args:
+            file (Path): Path to JSON file
+        """
+        if uri.startswith("https"):
+            self._download_manifest_internal(uri)
+        elif uri.startswith("http"):
+            raise ManifestDownloadError(
+                "Downloading manifest files from non-HTTPS servers is not supported."
+            )
+        else:
+            self._logger.info(f"Using CLI manifest file from {uri}...")
+            with open(uri) as file:
+                temp = json.load(file)
+
+            try:
+                self.validate(temp)
+                self._data = temp
+            except Exception as ex:
+                raise InvalidSourceFileError(f"{uri} is missing required data: {ex}") from ex
+
+    def validate(self, data: Any):
+        self._logger.debug("Validating CLI manifest file...")
+
+        for key in data:
+            item = data[key]
+            assert SdkType.Holoscan.value in item
+            holoscan = item[SdkType.Holoscan.value]
+
+            assert ArtifactSources.SectionWheelVersion in holoscan
+            assert ArtifactSources.SectionDebianVersion in holoscan
+            assert ArtifactSources.SectionBaseImages in holoscan
+            assert ArtifactSources.SectionBuildImages in holoscan
+
+            for config in PlatformConfiguration:
+                assert config.value in holoscan[ArtifactSources.SectionBuildImages]
+
+    def download_manifest(self):
+        self._download_manifest_internal(
+            ArtifactSources.ManifestFileUrl,
+            {"Authorization": f"Bearer {ArtifactSources.EdgeROToken}"},
+        )
+
+    def _download_manifest_internal(self, url, headers=None):
+        self._logger.info("Downloading CLI manifest file...")
+        manifest = requests.get(url, headers=headers)
+
+        try:
+            manifest.raise_for_status()
+        except Exception as ex:
+            raise ManifestDownloadError(
+                f"Error downloading manifest file from {url}: {manifest.reason}"
+            ) from ex
+        else:
+            self._data = manifest.json()
+            self.validate(self._data)
+
+    def debian_package_version(self, version: str) -> Optional[str]:
+        """Gets the version of the Debian package based on the version of Holoscan.
+
+        Args:
+            version (str): version of Holoscan
+
+        Returns:
+            Optional[str]: Debian package version
+        """
+        return (
+            self._data[version][SdkType.Holoscan.value][ArtifactSources.SectionDebianVersion]
+            if version in self._data
+            else None
+        )
+
+    def wheel_package_version(self, version: str) -> Optional[str]:
+        """Gets the version of the PyPI package based on the version of Holoscan.
+
+        Args:
+            version (str): version of Holoscan
+
+        Returns:
+            Optional[str]: PyPI package version
+        """
+        return self._data[version][SdkType.Holoscan.value][ArtifactSources.SectionWheelVersion]