Wrap additional gRPC types to remove them from our API (#65)

* Add ErrorInformation wrapper

* Add the Moniker wrapper class

* Add Outcome wrapper

* Update test file style

* Add AliasTargetType wrapper

* Unit tests for wrapper classes

* Fix ni-python-styleguide errors

* Remove GrpcMoniker (was for backwards compatibility)

* Fix mypy errors

* Fix nps errors

* PR feedback

* Fix notebooks with respect to Outcome

---------

Co-authored-by: Joel Dixon <joel.dixon@emerson.com>

Author: dixonjoel

examples/notebooks/query/publish_sample_data.ipynb

@@ -286,9 +286,9 @@
     "        # Publish measurement using Scalar values\n",
     "        # Insert some random failures\n",
     "        random_number = random.random()\n",
-    "        outcome = Outcome.OUTCOME_PASSED if random_number > 0.4 else Outcome.OUTCOME_FAILED\n",
+    "        outcome = Outcome.PASSED if random_number > 0.4 else Outcome.FAILED\n",
     "        data_store_client.publish_measurement(measurement_name, Scalar(value, unit), step_id, outcome=outcome)\n",
-    "        print (f\"  🧪 Created measurement '{measurement_name}' - {'✅ Passed' if outcome == Outcome.OUTCOME_PASSED else '❌ Failed'}\")\n",
+    "        print (f\"  🧪 Created measurement '{measurement_name}' - {'✅ Passed' if outcome == Outcome.PASSED else '❌ Failed'}\")\n",
     "        total_measurements += 1\n",
     "    \n",
     "    # Add test conditions for each power supply step\n",
@@ -392,7 +392,7 @@
     "        \n",
     "        # Publish measurement using Scalar values\n",
     "        random_number = random.random()\n",
-    "        outcome = Outcome.OUTCOME_PASSED if random_number > 0.4 else Outcome.OUTCOME_FAILED\n",
+    "        outcome = Outcome.PASSED if random_number > 0.4 else Outcome.FAILED\n",
     "        data_store_client.publish_measurement(measurement_name, Scalar(value, unit), step_id, outcome=outcome)\n",
     "        amplifier_measurements += 1\n",
     "\n",
@@ -452,7 +452,7 @@
     "            \n",
     "        # Publish measurement using Scalar values\n",
     "        random_number = random.random()\n",
-    "        outcome = Outcome.OUTCOME_PASSED if random_number > 0.4 else Outcome.OUTCOME_FAILED\n",
+    "        outcome = Outcome.PASSED if random_number > 0.4 else Outcome.FAILED\n",
     "        data_store_client.publish_measurement(measurement_name, Scalar(value, unit), step_id, outcome=outcome)\n",
     "    \n",
     "    # Add test conditions for the quick verification\n",

examples/notebooks/query/query_measurements.ipynb

@@ -86,8 +86,8 @@
     "\n",
     "def print_measurement_with_outcome(measurement) -> str:\n",
     "    name = measurement.name or \"Unnamed Measurement\"\n",
-    "    passed = measurement.outcome == Outcome.OUTCOME_PASSED\n",
-    "    failed = measurement.outcome == Outcome.OUTCOME_FAILED\n",
+    "    passed = measurement.outcome == Outcome.PASSED\n",
+    "    failed = measurement.outcome == Outcome.FAILED\n",
     "    return f\"{name} - {'✅ (Passed)' if passed else '❌ (Failed)' if failed else '❓ (Unknown)'}\"\n",
     "\n",
     "print(\"\\n=== Voltage Measurements ===\")\n",

src/ni/datastore/data/__init__.py

@@ -1,12 +1,13 @@
 """Public API for accessing the NI Data Store."""
 
-from ni.datamonikers.v1.data_moniker_pb2 import Moniker
 from ni.datastore.data._data_store_client import DataStoreClient
+from ni.datastore.data._types._error_information import ErrorInformation
+from ni.datastore.data._types._moniker import Moniker
+from ni.datastore.data._types._outcome import Outcome
 from ni.datastore.data._types._published_condition import PublishedCondition
 from ni.datastore.data._types._published_measurement import PublishedMeasurement
 from ni.datastore.data._types._step import Step
 from ni.datastore.data._types._test_result import TestResult
-from ni.measurements.data.v1.data_store_pb2 import ErrorInformation, Outcome
 
 __all__ = [
     "DataStoreClient",

src/ni/datastore/data/_data_store_client.py

@@ -13,7 +13,6 @@
 import hightime as ht
 from grpc import Channel
 from ni.datamonikers.v1.client import MonikerClient
-from ni.datamonikers.v1.data_moniker_pb2 import Moniker
 from ni.datastore.data._grpc_conversion import (
     get_publish_measurement_timestamp,
     populate_publish_condition_batch_request_values,
@@ -22,16 +21,15 @@
     populate_publish_measurement_request_value,
     unpack_and_convert_from_protobuf_any,
 )
+from ni.datastore.data._types._error_information import ErrorInformation
+from ni.datastore.data._types._moniker import Moniker
+from ni.datastore.data._types._outcome import Outcome
 from ni.datastore.data._types._published_condition import PublishedCondition
 from ni.datastore.data._types._published_measurement import PublishedMeasurement
 from ni.datastore.data._types._step import Step
 from ni.datastore.data._types._test_result import TestResult
 from ni.measurementlink.discovery.v1.client import DiscoveryClient
 from ni.measurements.data.v1.client import DataStoreClient as DataStoreServiceClient
-from ni.measurements.data.v1.data_store_pb2 import (
-    ErrorInformation,
-    Outcome,
-)
 from ni.measurements.data.v1.data_store_service_pb2 import (
     CreateStepRequest,
     CreateTestResultRequest,
@@ -227,7 +225,7 @@ def publish_measurement(
         value: object,  # More strongly typed Union[bool, AnalogWaveform] can be used if needed
         step_id: str,
         timestamp: ht.datetime | None = None,
-        outcome: Outcome.ValueType = Outcome.OUTCOME_UNSPECIFIED,
+        outcome: Outcome = Outcome.UNSPECIFIED,
         error_information: ErrorInformation | None = None,
         hardware_item_ids: Iterable[str] = tuple(),
         test_adapter_ids: Iterable[str] = tuple(),
@@ -291,8 +289,10 @@ def publish_measurement(
         publish_request = PublishMeasurementRequest(
             measurement_name=measurement_name,
             step_id=step_id,
-            outcome=outcome,
-            error_information=error_information,
+            outcome=outcome.to_protobuf(),
+            error_information=(
+                error_information.to_protobuf() if error_information is not None else None
+            ),
             hardware_item_ids=hardware_item_ids,
             test_adapter_ids=test_adapter_ids,
             software_item_ids=software_item_ids,
@@ -311,7 +311,7 @@ def publish_measurement_batch(
         values: object,
         step_id: str,
         timestamps: Iterable[ht.datetime] = tuple(),
-        outcomes: Iterable[Outcome.ValueType] = tuple(),
+        outcomes: Iterable[Outcome] = tuple(),
         error_information: Iterable[ErrorInformation] = tuple(),
         hardware_item_ids: Iterable[str] = tuple(),
         test_adapter_ids: Iterable[str] = tuple(),
@@ -372,8 +372,10 @@ def publish_measurement_batch(
             measurement_name=measurement_name,
             step_id=step_id,
             timestamps=[hightime_datetime_to_protobuf(ts) for ts in timestamps],
-            outcomes=outcomes,
-            error_information=error_information,
+            outcomes=[outcome.to_protobuf() for outcome in outcomes],
+            error_information=(
+                [ei.to_protobuf() for ei in (error_information or [])] if error_information else []
+            ),
             hardware_item_ids=hardware_item_ids,
             test_adapter_ids=test_adapter_ids,
             software_item_ids=software_item_ids,
@@ -407,7 +409,7 @@ def read_data(
 
         Args:
             moniker_source: The source from which to read data. Can be:
-                - A Moniker directly
+                - A Moniker (wrapper type) directly
                 - A PublishedMeasurement (uses its moniker)
                 - A PublishedCondition (uses its moniker)
 
@@ -428,19 +430,25 @@ def read_data(
             TypeError: If expected_type is provided and the actual data type
                 doesn't match.
         """
+        from ni.datamonikers.v1.data_moniker_pb2 import Moniker as MonikerProto
+
+        moniker_proto: MonikerProto
+
         if isinstance(moniker_source, Moniker):
-            moniker = moniker_source
+            moniker_proto = moniker_source.to_protobuf()
         elif isinstance(moniker_source, PublishedMeasurement):
             if moniker_source.moniker is None:
                 raise ValueError("PublishedMeasurement must have a Moniker to read data")
-            moniker = moniker_source.moniker
+            moniker_proto = moniker_source.moniker.to_protobuf()
         elif isinstance(moniker_source, PublishedCondition):
             if moniker_source.moniker is None:
                 raise ValueError("PublishedCondition must have a Moniker to read data")
-            moniker = moniker_source.moniker
+            moniker_proto = moniker_source.moniker.to_protobuf()
+        else:
+            raise TypeError(f"Unsupported moniker_source type: {type(moniker_source)}")
 
-        moniker_client = self._get_moniker_client(moniker.service_location)
-        read_result = moniker_client.read_from_moniker(moniker)
+        moniker_client = self._get_moniker_client(moniker_proto.service_location)
+        read_result = moniker_client.read_from_moniker(moniker_proto)
         converted_data = unpack_and_convert_from_protobuf_any(read_result.value)
         if expected_type is not None and not isinstance(converted_data, expected_type):
             raise TypeError(f"Expected type {expected_type}, got {type(converted_data)}")

src/ni/datastore/data/_types/_error_information.py

@@ -0,0 +1,73 @@
+"""Error Information data type for the Data Store Client."""
+
+from __future__ import annotations
+
+from ni.measurements.data.v1.data_store_pb2 import (
+    ErrorInformation as ErrorInformationProto,
+)
+
+
+class ErrorInformation:
+    """Represents error or exception information in case of measurement failure.
+
+    An ErrorInformation contains an error code, descriptive message, and
+    source information to help identify and diagnose issues during measurement
+    execution.
+    """
+
+    __slots__ = (
+        "error_code",
+        "message",
+        "source",
+    )
+
+    def __init__(
+        self,
+        *,
+        error_code: int = 0,
+        message: str = "",
+        source: str = "",
+    ) -> None:
+        """Initialize an ErrorInformation instance.
+
+        Args:
+            error_code: The numeric error code associated with the error.
+            message: A descriptive message explaining the error.
+            source: The source or location where the error occurred.
+        """
+        self.error_code = error_code
+        self.message = message
+        self.source = source
+
+    @staticmethod
+    def from_protobuf(
+        error_information_proto: ErrorInformationProto,
+    ) -> "ErrorInformation":
+        """Create an ErrorInformation instance from a protobuf ErrorInformation message."""
+        return ErrorInformation(
+            error_code=error_information_proto.error_code,
+            message=error_information_proto.message,
+            source=error_information_proto.source,
+        )
+
+    def to_protobuf(self) -> ErrorInformationProto:
+        """Convert this ErrorInformation instance to a protobuf ErrorInformation message."""
+        return ErrorInformationProto(
+            error_code=self.error_code,
+            message=self.message,
+            source=self.source,
+        )
+
+    def __eq__(self, other: object) -> bool:
+        """Determine equality."""
+        if not isinstance(other, ErrorInformation):
+            return NotImplemented
+        return (
+            self.error_code == other.error_code
+            and self.message == other.message
+            and self.source == other.source
+        )
+
+    def __str__(self) -> str:
+        """Return a string representation of the ErrorInformation."""
+        return str(self.to_protobuf())

src/ni/datastore/data/_types/_moniker.py

@@ -0,0 +1,69 @@
+"""Moniker data type for the Data Store Client."""
+
+from __future__ import annotations
+
+from ni.datamonikers.v1.data_moniker_pb2 import Moniker as MonikerProto
+
+
+class Moniker:
+    """Represents a data moniker for retrieving published data.
+
+    A moniker provides the necessary information to locate and retrieve data
+    from the data store, including the service location, data source, and
+    data instance identifiers.
+    """
+
+    __slots__ = (
+        "service_location",
+        "data_source",
+        "data_instance",
+    )
+
+    def __init__(
+        self,
+        *,
+        service_location: str = "",
+        data_source: str = "",
+        data_instance: int = 0,
+    ) -> None:
+        """Initialize a Moniker instance.
+
+        Args:
+            service_location: The location of the service that stores the data.
+            data_source: The identifier for the data source.
+            data_instance: The instance number of the data.
+        """
+        self.service_location = service_location
+        self.data_source = data_source
+        self.data_instance = data_instance
+
+    @staticmethod
+    def from_protobuf(moniker_proto: MonikerProto) -> "Moniker":
+        """Create a Moniker instance from a protobuf Moniker message."""
+        return Moniker(
+            service_location=moniker_proto.service_location,
+            data_source=moniker_proto.data_source,
+            data_instance=moniker_proto.data_instance,
+        )
+
+    def to_protobuf(self) -> MonikerProto:
+        """Convert this Moniker instance to a protobuf Moniker message."""
+        return MonikerProto(
+            service_location=self.service_location,
+            data_source=self.data_source,
+            data_instance=self.data_instance,
+        )
+
+    def __eq__(self, other: object) -> bool:
+        """Determine equality."""
+        if not isinstance(other, Moniker):
+            return NotImplemented
+        return (
+            self.service_location == other.service_location
+            and self.data_source == other.data_source
+            and self.data_instance == other.data_instance
+        )
+
+    def __str__(self) -> str:
+        """Return a string representation of the Moniker."""
+        return str(self.to_protobuf())

src/ni/datastore/data/_types/_outcome.py

@@ -0,0 +1,53 @@
+"""Outcome data type for the Data Store Client."""
+
+from __future__ import annotations
+
+from enum import IntEnum
+
+from ni.measurements.data.v1.data_store_pb2 import Outcome as OutcomeProto
+
+
+class Outcome(IntEnum):
+    """Represents the outcome of a measurement or test operation.
+
+    The Outcome enum indicates whether a measurement or test passed, failed,
+    or had an indeterminate result.
+    """
+
+    UNSPECIFIED = OutcomeProto.OUTCOME_UNSPECIFIED
+    """The outcome is not specified or unknown."""
+
+    PASSED = OutcomeProto.OUTCOME_PASSED
+    """The measurement or test passed successfully."""
+
+    FAILED = OutcomeProto.OUTCOME_FAILED
+    """The measurement or test failed."""
+
+    INDETERMINATE = OutcomeProto.OUTCOME_INDETERMINATE
+    """The measurement or test result is indeterminate or inconclusive."""
+
+    @classmethod
+    def from_protobuf(cls, outcome_proto: OutcomeProto.ValueType) -> "Outcome":
+        """Create an Outcome instance from a protobuf Outcome value.
+
+        Args:
+            outcome_proto: The protobuf Outcome value.
+
+        Returns:
+            The corresponding Outcome enum value.
+
+        Raises:
+            ValueError: If the protobuf value doesn't correspond to a known Outcome.
+        """
+        try:
+            return cls(outcome_proto)
+        except ValueError as e:
+            raise ValueError(f"Unknown outcome value: {outcome_proto}") from e
+
+    def to_protobuf(self) -> OutcomeProto.ValueType:
+        """Convert this Outcome instance to a protobuf Outcome value.
+
+        Returns:
+            The corresponding protobuf Outcome value.
+        """
+        return OutcomeProto.ValueType(self.value)

src/ni/datastore/data/_types/_published_condition.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from ni.datamonikers.v1.data_moniker_pb2 import Moniker
+from ni.datastore.data._types._moniker import Moniker
 from ni.measurements.data.v1.data_store_pb2 import (
     PublishedCondition as PublishedConditionProto,
 )
@@ -61,7 +61,7 @@ def from_protobuf(published_condition_proto: PublishedConditionProto) -> "Publis
         """Create a PublishedCondition instance from a protobuf PublishedCondition message."""
         return PublishedCondition(
             moniker=(
-                published_condition_proto.moniker
+                Moniker.from_protobuf(published_condition_proto.moniker)
                 if published_condition_proto.HasField("moniker")
                 else None
             ),
@@ -75,7 +75,7 @@ def from_protobuf(published_condition_proto: PublishedConditionProto) -> "Publis
     def to_protobuf(self) -> PublishedConditionProto:
         """Convert this PublishedCondition instance to a protobuf PublishedCondition message."""
         return PublishedConditionProto(
-            moniker=self.moniker,
+            moniker=self.moniker.to_protobuf() if self.moniker is not None else None,
             id=self.id,
             name=self.name,
             type=self.type,