ni.measurementlink.discovery.v1.client 0.1.0.dev0__tar.gz

ni_measurementlink_discovery_v1_client-0.1.0.dev0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.3
+Name: ni.measurementlink.discovery.v1.client
+Version: 0.1.0.dev0
+Summary: gRPC Client for NI Discovery Service
+License: MIT
+Keywords: discovery,client
+Author: NI
+Author-email: opensource@ni.com
+Maintainer: Brad Keryan
+Maintainer-email: brad.keryan@emerson.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Dist: grpcio (>=1.49.0,<2.0)
+Requires-Dist: ni-grpc-extensions (>=0.1.0.dev0)
+Requires-Dist: ni-measurementlink-discovery-v1-proto (>=0.1.0.dev0)
+Requires-Dist: pywin32 (>=303) ; sys_platform == "win32"
+Project-URL: Repository, https://github.com/ni/ni-apis-python
+Description-Content-Type: text/markdown
+
+# Table of Contents
+
+- [Table of Contents](#table-of-contents)
+- [About](#about)
+  - [Operating System Support](#operating-system-support)
+  - [Python Version Support](#python-version-support)
+
+# About
+
+`ni.measurementlink.discovery.v1.client` is a Python package that provides a gRPC client for the
+NI Discovery Service, version 1. The corresponding service is defined in the
+[ni.measurementlink.discovery.v1.proto package](https://github.com/ni/ni-apis/tree/main/ni/measurementlink/discovery/v1).
+
+NI created and supports this package.
+
+## Operating System Support
+
+`ni.measurementlink.discovery.v1.client` supports Windows operating systems.
+
+## Python Version Support
+
+`ni.measurementlink.discovery.v1.client` supports CPython 3.9+.
+
+## Installation
+
+You can directly install the `ni.measurementlink.discovery.v1.client` package using `pip` or by listing it as a
+dependency in your project's `pyproject.toml` file.

ni_measurementlink_discovery_v1_client-0.1.0.dev0/README.md

@@ -0,0 +1,27 @@
+# Table of Contents
+
+- [Table of Contents](#table-of-contents)
+- [About](#about)
+  - [Operating System Support](#operating-system-support)
+  - [Python Version Support](#python-version-support)
+
+# About
+
+`ni.measurementlink.discovery.v1.client` is a Python package that provides a gRPC client for the
+NI Discovery Service, version 1. The corresponding service is defined in the
+[ni.measurementlink.discovery.v1.proto package](https://github.com/ni/ni-apis/tree/main/ni/measurementlink/discovery/v1).
+
+NI created and supports this package.
+
+## Operating System Support
+
+`ni.measurementlink.discovery.v1.client` supports Windows operating systems.
+
+## Python Version Support
+
+`ni.measurementlink.discovery.v1.client` supports CPython 3.9+.
+
+## Installation
+
+You can directly install the `ni.measurementlink.discovery.v1.client` package using `pip` or by listing it as a
+dependency in your project's `pyproject.toml` file.

ni_measurementlink_discovery_v1_client-0.1.0.dev0/pyproject.toml

@@ -0,0 +1,99 @@
+[tool.poetry]
+name = "ni.measurementlink.discovery.v1.client"
+version = "0.1.0-dev0"
+license = "MIT"
+description = "gRPC Client for NI Discovery Service"
+authors = ["NI <opensource@ni.com>"]
+maintainers = [
+  "Brad Keryan <brad.keryan@emerson.com>",
+  "Joe Friedrichsen <joe.friedrichsen@emerson.com>",
+]
+readme = "README.md"
+repository = "https://github.com/ni/ni-apis-python"
+keywords = ["discovery", "client"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Manufacturing",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: Implementation :: CPython",
+]
+packages = [{include = "ni", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+grpcio = {version=">=1.49.0,<2.0"}
+ni-grpc-extensions = { version = ">=0.1.0.dev0", allow-prereleases = true }
+ni-measurementlink-discovery-v1-proto = { version = ">=0.1.0.dev0", allow-prereleases = true }
+pywin32 = { version = ">=303", platform = "win32" }
+
+[tool.poetry.group.dev.dependencies]
+types-grpcio = ">=1.0"
+types-pywin32 = ">=304"
+
+[tool.poetry.group.lint.dependencies]
+bandit = { version = ">=1.7", extras = ["toml"] }
+ni-python-styleguide = ">=0.4.1"
+mypy = ">=1.0"
+pyright = { version = ">=1.1.400", extras = ["nodejs"] }
+
+[tool.poetry.group.test.dependencies]
+pytest = ">=7.2"
+pytest-cov = ">=4.0"
+pytest-doctestplus = ">=1.4"
+pytest-mock = ">=3.0"
+
+[tool.poetry.group.docs]
+optional = true
+
+[tool.poetry.group.docs.dependencies]
+# The latest Sphinx requires a recent Python version.
+Sphinx = { version = ">=8.2", python = "^3.11" }
+sphinx-rtd-theme = ">=1.0.0"
+sphinx-autoapi = ">=1.8.4"
+m2r2 = ">=0.3.2"
+toml = ">=0.10.2"
+
+[build-system]
+requires = ["poetry-core>=1.8"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.bandit]
+skips = [
+  "B101", # assert_used
+]
+
+[tool.ni-python-styleguide]
+extend_exclude = "docs"
+
+[tool.black]
+extend-exclude = 'docs/'
+line-length = 100
+
+[tool.mypy]
+mypy_path = "src"
+files = "."
+namespace_packages = true
+strict = true
+explicit_package_bases = true
+exclude = ["docs"]
+
+[tool.pyright]
+include = ["src/", "tests/"]
+# Turn off this check to avoid pyright warnings for pywin32 and pywin32-types
+# when pyright runs for the win32 platform on a Linux build agent.
+reportMissingModuleSource = false
+
+[tool.pytest.ini_options]
+addopts = "--doctest-modules --doctest-plus --strict-markers"
+testpaths = ["tests"]

ni_measurementlink_discovery_v1_client-0.1.0.dev0/src/ni/measurementlink/discovery/v1/client/__init__.py

@@ -0,0 +1,10 @@
+"""Public API for accessing the NI Discovery Service."""
+
+from ni.measurementlink.discovery.v1.client._client import DiscoveryClient
+from ni.measurementlink.discovery.v1.client._types import (
+    ComputeNodeDescriptor,
+    ServiceInfo,
+    ServiceLocation,
+)
+
+__all__ = ["DiscoveryClient", "ServiceLocation", "ComputeNodeDescriptor", "ServiceInfo"]

ni_measurementlink_discovery_v1_client-0.1.0.dev0/src/ni/measurementlink/discovery/v1/client/_client.py

@@ -0,0 +1,277 @@
+"""Client for accessing the NI Discovery Service."""
+
+from __future__ import annotations
+
+import logging
+import threading
+from collections.abc import Sequence
+
+import grpc
+from ni.measurementlink.discovery.v1 import discovery_service_pb2, discovery_service_pb2_grpc
+from ni_grpc_extensions.channelpool import GrpcChannelPool  # type: ignore[import-untyped]
+
+from ni.measurementlink.discovery.v1.client._support import (
+    _get_discovery_service_address,
+)
+from ni.measurementlink.discovery.v1.client._types import (
+    ComputeNodeDescriptor,
+    ServiceInfo,
+    ServiceLocation,
+)
+
+SERVICE_PROGRAMMINGLANGUAGE_KEY = "ni/service.programminglanguage"
+_logger = logging.getLogger(__name__)
+
+
+class DiscoveryClient:
+    """Client for accessing the NI Discovery Service."""
+
+    __slots__ = [
+        "_initialization_lock",
+        "_grpc_channel_pool",
+        "_stub",
+        "__weakref__",
+    ]
+
+    _initialization_lock: threading.Lock
+    _grpc_channel_pool: GrpcChannelPool | None
+    _stub: discovery_service_pb2_grpc.DiscoveryServiceStub | None
+
+    def __init__(
+        self,
+        stub: discovery_service_pb2_grpc.DiscoveryServiceStub | None = None,
+        *,
+        grpc_channel_pool: GrpcChannelPool | None = None,
+    ) -> None:
+        """Initialize the discovery client.
+
+        Args:
+            stub: An optional discovery service gRPC stub for unit testing.
+
+            grpc_channel_pool: An optional gRPC channel pool (recommended).
+        """
+        self._initialization_lock = threading.Lock()
+        self._grpc_channel_pool = grpc_channel_pool
+        self._stub = stub
+
+    def _get_stub(self) -> discovery_service_pb2_grpc.DiscoveryServiceStub:
+        if self._stub is None:
+            with self._initialization_lock:
+                if self._grpc_channel_pool is None:
+                    _logger.debug("Creating unshared GrpcChannelPool.")
+                    self._grpc_channel_pool = GrpcChannelPool()
+                if self._stub is None:
+                    address = _get_discovery_service_address()
+                    channel = self._grpc_channel_pool.get_channel(address)
+                    self._stub = discovery_service_pb2_grpc.DiscoveryServiceStub(channel)
+        return self._stub
+
+    def register_service(self, service_info: ServiceInfo, service_location: ServiceLocation) -> str:
+        """Register the specified service with the discovery service.
+
+        Args:
+            service_info: Information describing the service.
+
+            service_location: The location of the service on the network.
+
+        Returns:
+            ID that can be used to unregister the service.
+        """
+        annotations = service_info.annotations.copy()
+        annotations[SERVICE_PROGRAMMINGLANGUAGE_KEY] = "Python"
+        try:
+            grpc_service_description = discovery_service_pb2.ServiceDescriptor(
+                display_name=service_info.display_name,
+                description_url=service_info.description_url,
+                provided_interfaces=service_info.provided_interfaces,
+                service_class=service_info.service_class,
+                annotations=annotations,
+                versions=service_info.versions,
+            )
+
+            grpc_service_location = discovery_service_pb2.ServiceLocation(
+                location=service_location.location,
+                insecure_port=service_location.insecure_port,
+                ssl_authenticated_port=service_location.ssl_authenticated_port,
+            )
+
+            request = discovery_service_pb2.RegisterServiceRequest(
+                service_description=grpc_service_description,
+                location=grpc_service_location,
+            )
+
+            response = self._get_stub().RegisterService(request)
+            _logger.info("Successfully registered with discovery service.")
+            return response.registration_id
+        except grpc.RpcError as e:
+            if e.code() == grpc.StatusCode.UNAVAILABLE:
+                _logger.error(
+                    "Unable to register with discovery service. Possible reason: discovery service not available."
+                )
+            else:
+                _logger.exception("Error in registering with discovery service.")
+            raise
+        except FileNotFoundError:
+            _logger.error(
+                "Unable to register with discovery service. Possible reason: discovery service not running."
+            )
+            raise
+        except Exception:
+            _logger.exception("Error in registering with discovery service.")
+            raise
+
+    def unregister_service(self, registration_id: str) -> bool:
+        """Unregisters the specified service from the discovery service.
+
+        This method should be called before the service exits.
+
+        Args:
+            registration_id: The registration ID returned from register_service.
+                This argument should be omitted after calling the deprecated
+                register_measurement_service method.
+
+        Returns:
+            Boolean indicating whether the service was unregistered.
+        """
+        try:
+            if not registration_id:
+                _logger.info("Not registered with discovery service.")
+                return False
+
+            request = discovery_service_pb2.UnregisterServiceRequest(
+                registration_id=registration_id
+            )
+
+            _ = self._get_stub().UnregisterService(request)
+            _logger.info("Successfully unregistered with discovery service.")
+
+            return True
+        except grpc.RpcError as e:
+            if e.code() == grpc.StatusCode.UNAVAILABLE:
+                _logger.error(
+                    "Unable to unregister with discovery service. Possible reason: discovery service not available."
+                )
+            else:
+                _logger.exception("Error in unregistering with discovery service.")
+            raise
+        except FileNotFoundError:
+            _logger.error(
+                "Unable to unregister with discovery service. Possible reason: discovery service not running."
+            )
+            raise
+        except Exception:
+            _logger.exception("Error in unregistering with discovery service.")
+            raise
+
+    def resolve_service(
+        self,
+        provided_interface: str,
+        service_class: str = "",
+        deployment_target: str = "",
+        version: str = "",
+    ) -> ServiceLocation:
+        """Resolve the location of a service.
+
+        Given a description of a service, returns information that can be used to establish
+        communication with that service. If necessary, the service will be started by the
+        discovery service if it has not already been started.
+
+        Args:
+            provided_interface: The gRPC full name of the service.
+            service_class: The service "class" that should be matched. If the value is not
+                specified and there is more than one matching service registered, an error
+                is returned.
+            deployment_target: The deployment target from which the service should be resolved.
+                Callers should pass either the url string from a :class:`ComputeNodeSpecifier`
+                or a blank string for local execution.
+            version: The version of the service to resolve. If not specified, the latest version
+                will be resolved.
+
+        Returns:
+            The service location.
+        """
+        request = discovery_service_pb2.ResolveServiceRequest(
+            provided_interface=provided_interface,
+            service_class=service_class,
+            deployment_target=deployment_target,
+            version=version,
+        )
+
+        response = self._get_stub().ResolveService(request)
+
+        return ServiceLocation._from_grpc(response)
+
+    def resolve_service_with_information(
+        self,
+        provided_interface: str,
+        service_class: str = "",
+        deployment_target: str = "",
+        version: str = "",
+    ) -> tuple[ServiceLocation, ServiceInfo]:
+        """Resolve the location of a service along with its information.
+
+        Given a description of a service, returns information for the service in addition to
+        the location of the service. If necessary, the service will be started by the discovery
+        service if it has not already been started.
+
+        Args:
+            provided_interface: The gRPC full name of the service.
+            service_class: The service "class" that should be matched. If the value is not
+                specified and there is more than one matching service registered, an error
+                is returned.
+            deployment_target: The deployment target from which the service should be resolved.
+                Callers should pass either the url string from a :class:`ComputeNodeSpecifier`
+                or a blank string for local execution.
+            version: The version of the service to resolve. If not specified, the latest version
+                will be resolved.
+
+        Returns:
+            A tuple containing the service location and service information.
+        """
+        request = discovery_service_pb2.ResolveServiceWithInformationRequest(
+            provided_interface=provided_interface,
+            service_class=service_class,
+            deployment_target=deployment_target,
+            version=version,
+        )
+
+        response = self._get_stub().ResolveServiceWithInformation(request)
+
+        return (
+            ServiceLocation._from_grpc(response.service_location),
+            ServiceInfo._from_grpc(response.service_descriptor),
+        )
+
+    def enumerate_services(self, provided_interface: str) -> Sequence[ServiceInfo]:
+        """Enumerates all the services for the provided interface.
+
+        Args:
+            provided_interface: The gRPC full name of the services.
+
+        Returns:
+            The list of information describing the services.
+        """
+        request = discovery_service_pb2.EnumerateServicesRequest(
+            provided_interface=provided_interface
+        )
+
+        response = self._get_stub().EnumerateServices(request)
+
+        return [ServiceInfo._from_grpc(service) for service in response.available_services]
+
+    def enumerate_compute_nodes(self) -> Sequence[ComputeNodeDescriptor]:
+        """Enumerates all the compute nodes registered with the discovery service.
+
+        Returns:
+            The list of information describing the compute nodes.
+        """
+        request = discovery_service_pb2.EnumerateComputeNodesRequest()
+
+        try:
+            response = self._get_stub().EnumerateComputeNodes(request)
+        except grpc.RpcError as e:
+            if e.code() == grpc.StatusCode.UNIMPLEMENTED:
+                return []
+            raise
+
+        return [ComputeNodeDescriptor._from_grpc(node) for node in response.compute_nodes]

ni_measurementlink_discovery_v1_client-0.1.0.dev0/src/ni/measurementlink/discovery/v1/client/_support.py

@@ -0,0 +1,192 @@
+"""Support functions for the NI Discovery Service."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import pathlib
+import subprocess  # nosec: B404
+import sys
+import time
+import typing
+from typing import Any
+
+from ni.measurementlink.discovery.v1 import (
+    discovery_service_pb2,
+)
+
+if sys.platform == "win32":
+    import msvcrt
+    import winreg
+
+    import win32con
+    import win32file
+
+_logger = logging.getLogger(__name__)
+# Save Popen object to avoid "ResourceWarning: subprocess N is still running"
+_discovery_service_subprocess: subprocess.Popen[Any] | None = None
+
+_START_SERVICE_TIMEOUT = 30.0
+_START_SERVICE_POLLING_INTERVAL = 100e-3
+
+
+def _get_discovery_service_address() -> str:
+    key_file_path = _get_key_file_path()
+    _ensure_discovery_service_started(key_file_path)
+    _logger.debug("Discovery service key file path: %s", key_file_path)
+    with _open_key_file(str(key_file_path)) as key_file:
+        key_json = json.load(key_file)
+        return "localhost:" + str(key_json["InsecurePort"])
+
+
+def _ensure_discovery_service_started(key_file_path: pathlib.Path) -> None:
+    """Check whether discovery service already running, if not start the discovery service."""
+    if _service_already_running(key_file_path):
+        return
+
+    exe_file_path = _get_discovery_service_location()
+    global _discovery_service_subprocess  # save Popen object to avoid ResourceWarning
+    _discovery_service_subprocess = _start_service(exe_file_path, key_file_path)
+
+
+def _get_discovery_service_location() -> pathlib.PurePath:
+    """Gets the location of the discovery service process executable."""
+    registration_json_path = _get_registration_json_file_path()
+    registration_json_obj = json.loads(registration_json_path.read_text())
+    return registration_json_path.parent / str(registration_json_obj["discovery"]["path"])
+
+
+def _get_registration_json_file_path() -> pathlib.Path:
+    if sys.platform == "win32":
+        json_path = _get_nipath("NISHAREDDIR64") / "Services" / "NIServices.json"
+        if not json_path.exists():
+            json_path = (
+                _get_nipath("NISHAREDDIR64") / "MeasurementLink" / "MeasurementLinkServices.json"
+            )
+        return json_path
+    else:
+        raise NotImplementedError(
+            f"Platform not supported: {sys.platform}. Supported platforms: win32."
+        )
+
+
+def _key_file_exists(key_file_path: pathlib.Path) -> bool:
+    return key_file_path.is_file() and key_file_path.stat().st_size > 0
+
+
+def _start_service(
+    exe_file_path: pathlib.PurePath, key_file_path: pathlib.Path
+) -> subprocess.Popen[Any]:
+    """Starts the service at the specified path and wait for the service to get up and running."""
+    kwargs: dict[str, Any] = {}
+    if sys.platform == "win32":
+        # Terminating the measurement service should not terminate the discovery service.
+        kwargs["creationflags"] = subprocess.CREATE_BREAKAWAY_FROM_JOB | subprocess.DETACHED_PROCESS
+    # The EXE file path comes from the registration JSON, which is installed in
+    # a trusted location (e.g. NISHAREDDIR64).
+    discovery_service_subprocess = subprocess.Popen(  # nosec: B603
+        [exe_file_path],
+        cwd=exe_file_path.parent,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        **kwargs,
+    )
+
+    # After the execution of process, check for key file existence in the path
+    # stop checking after 30 seconds have elapsed and throw error
+    timeout_time = time.time() + _START_SERVICE_TIMEOUT
+    while True:
+        try:
+            with _open_key_file(str(key_file_path)) as _:
+                return discovery_service_subprocess  # pyright: ignore[reportReturnType]
+        except OSError:
+            pass
+        if time.time() >= timeout_time:
+            raise TimeoutError("Timed out waiting for discovery service to start")
+        time.sleep(_START_SERVICE_POLLING_INTERVAL)
+
+
+def _service_already_running(key_file_path: pathlib.Path) -> bool:
+    try:
+        _delete_existing_key_file(key_file_path)
+    except OSError:
+        return True
+    return False
+
+
+def _delete_existing_key_file(key_file_path: pathlib.Path) -> None:
+    if _key_file_exists(key_file_path):
+        with key_file_path.open("w") as _:
+            pass
+        key_file_path.unlink()
+
+
+def _get_key_file_path(cluster_id: str | None = None) -> pathlib.Path:
+    if cluster_id is not None:
+        return _get_key_file_directory() / f"DiscoveryService_{cluster_id}.json"
+    return _get_key_file_directory() / "DiscoveryService.json"
+
+
+def _get_key_file_directory() -> pathlib.Path:
+    package = typing.cast(str, discovery_service_pb2.DESCRIPTOR.package)
+    version = package.split(".")[-1]
+    if sys.platform == "win32":
+        return _get_nipath("NIPUBAPPDATADIR") / "MeasurementLink" / "Discovery" / version
+    else:
+        raise NotImplementedError(
+            f"Platform not supported: {sys.platform}. Supported platforms: win32."
+        )
+
+
+def _open_key_file(path: str) -> typing.TextIO:
+    if sys.platform == "win32":
+        # Use the Win32 API to specify the share mode. Otherwise, opening the file throws
+        # PermissionError due to a sharing violation. This is a workaround for
+        # https://github.com/python/cpython/issues/59449
+        # (Support for opening files with FILE_SHARE_DELETE on Windows).
+        try:
+            win32_file_handle = win32file.CreateFile(
+                path,
+                win32file.GENERIC_READ,
+                win32file.FILE_SHARE_READ
+                | win32file.FILE_SHARE_WRITE
+                | win32file.FILE_SHARE_DELETE,
+                None,
+                win32con.OPEN_EXISTING,
+                0,
+                None,
+            )
+        except win32file.error as e:
+            raise OSError(None, e.strerror, path, e.winerror) from e
+
+        # The CRT file descriptor takes ownership of the Win32 file handle.
+        # os.O_TEXT is unnecessary because Python handles newline conversion.
+        crt_file_descriptor = msvcrt.open_osfhandle(win32_file_handle.handle, os.O_RDONLY)
+        win32_file_handle.Detach()
+
+        # The Python file object takes ownership of the CRT file descriptor. Closing the Python
+        # file object closes the underlying Win32 file handle.
+        return os.fdopen(crt_file_descriptor, "r", encoding="utf-8-sig")
+    else:
+        return open(path)
+
+
+def _get_nipath(name: str) -> pathlib.Path:
+    if sys.platform == "win32":
+        access: int = winreg.KEY_READ
+        if "64" in name:
+            access |= winreg.KEY_WOW64_64KEY
+        with winreg.OpenKey(
+            winreg.HKEY_LOCAL_MACHINE,
+            r"SOFTWARE\National Instruments\Common\Installer",
+            access=access,
+        ) as key:
+            value, type = winreg.QueryValueEx(key, name)
+            assert type == winreg.REG_SZ
+            return pathlib.Path(value)
+    else:
+        raise NotImplementedError(
+            f"Platform not supported: {sys.platform}. Supported platforms: win32."
+        )

ni_measurementlink_discovery_v1_client-0.1.0.dev0/src/ni/measurementlink/discovery/v1/client/_types.py

@@ -0,0 +1,111 @@
+"""Data types for the NI Discovery Service."""
+
+from __future__ import annotations
+
+import typing
+from typing import NamedTuple
+
+from ni.measurementlink.discovery.v1 import (
+    discovery_service_pb2,
+)
+
+
+class ServiceInfo(NamedTuple):
+    """A named tuple providing information about a registered service.
+
+    This class is used with the NI Discovery Service when registering and enumerating services.
+    """
+
+    service_class: str
+    """"The "class" of a service. The value of this field should be unique for all services.
+    In effect, the ``.proto`` service declaration defines the interface, and this field
+    defines a class or concrete type of the interface."""
+
+    description_url: str
+    """The URL of a web page that provides a description of the service."""
+
+    provided_interfaces: list[str] = ["ni.measurementlink.measurement.v1.MeasurementService"]
+    """The service interfaces provided by the service. These are gRPC full names for the service."""
+
+    annotations: dict[str, str] = {}
+    """Represents a set of annotations on the service.
+
+    Well-known annotations:
+
+    - Description
+       - Key: "ni/service.description"
+          - Expected format: string
+          - Example: "Measure inrush current with a shorted load and validate results against
+            configured limits."
+    - Collection
+       - Key: "ni/service.collection"
+          - Expected format: "." delimited namespace/hierarchy case-insensitive string
+          - Example: "CurrentTests.Inrush"
+    - Tags
+        - Key: "ni/service.tags"
+           - Expected format: serialized JSON string of an array of strings
+           - Example: "[\"powerup\", \"current\"]"
+    """
+
+    display_name: str = ""
+    """The service display name for clients to display to users."""
+
+    versions: list[str] = []
+    """The list of versions associated with this service in
+     the form major.minor.build[.revision] (e.g. 1.0.0)."""
+
+    @classmethod
+    def _from_grpc(cls, other: discovery_service_pb2.ServiceDescriptor) -> ServiceInfo:
+        return ServiceInfo(
+            service_class=other.service_class,
+            description_url=other.description_url,
+            provided_interfaces=list(other.provided_interfaces),
+            annotations=dict(other.annotations),
+            display_name=other.display_name,
+            versions=list(other.versions),
+        )
+
+
+class ServiceLocation(typing.NamedTuple):
+    """Represents the location of a service."""
+
+    location: str
+    insecure_port: str
+    ssl_authenticated_port: str
+
+    @property
+    def insecure_address(self) -> str:
+        """Get the service's insecure address in the format host:port."""
+        return f"{self.location}:{self.insecure_port}"
+
+    @property
+    def ssl_authenticated_address(self) -> str:
+        """Get the service's SSL-authenticated address in the format host:port."""
+        return f"{self.location}:{self.ssl_authenticated_port}"
+
+    @classmethod
+    def _from_grpc(cls, other: discovery_service_pb2.ServiceLocation) -> ServiceLocation:
+        return ServiceLocation(
+            location=other.location,
+            insecure_port=other.insecure_port,
+            ssl_authenticated_port=other.ssl_authenticated_port,
+        )
+
+
+class ComputeNodeDescriptor(typing.NamedTuple):
+    """Represents a compute node."""
+
+    url: str
+    """The resolvable name (URL) of the compute node."""
+
+    is_local: bool
+    """Indicates whether the compute node is local node."""
+
+    @classmethod
+    def _from_grpc(
+        cls, other: discovery_service_pb2.ComputeNodeDescriptor
+    ) -> ComputeNodeDescriptor:
+        return ComputeNodeDescriptor(
+            url=other.url,
+            is_local=other.is_local,
+        )