ni.datastore 0.1.0.dev1__tar.gz → 0.1.0.dev2__tar.gz

{ni_datastore-0.1.0.dev1 → ni_datastore-0.1.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ni.datastore
-Version: 0.1.0.dev1
+Version: 0.1.0.dev2
 Summary: APIs for publishing and retrieving data from the NI Measurement Data Store
 License: MIT
 Keywords: datastore
@@ -34,7 +34,6 @@ Description-Content-Type: text/markdown
 # Table of Contents
 
 - [Table of Contents](#table-of-contents)
-- [Measurement ]
 - [About](#about)
   - [Operating System Support](#operating-system-support)
   - [Python Version Support](#python-version-support)

{ni_datastore-0.1.0.dev1 → ni_datastore-0.1.0.dev2}/README.md

@@ -1,7 +1,6 @@
 # Table of Contents
 
 - [Table of Contents](#table-of-contents)
-- [Measurement ]
 - [About](#about)
   - [Operating System Support](#operating-system-support)
   - [Python Version Support](#python-version-support)

{ni_datastore-0.1.0.dev1 → ni_datastore-0.1.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ni.datastore"
-version = "0.1.0-dev1"
+version = "0.1.0-dev2"
 license = "MIT"
 description = "APIs for publishing and retrieving data from the NI Measurement Data Store"
 authors = [{name = "NI", email = "opensource@ni.com"}]

ni_datastore-0.1.0.dev2/src/ni/datastore/__init__.py

@@ -0,0 +1 @@
+"""Public API for accessing the NI Data/Metadata Stores."""

ni_datastore-0.1.0.dev2/src/ni/datastore/data/__init__.py

@@ -0,0 +1,30 @@
+"""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._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",
+    "ErrorInformation",
+    "Moniker",
+    "Outcome",
+    "PublishedCondition",
+    "PublishedMeasurement",
+    "Step",
+    "TestResult",
+]
+
+# Hide that it was not defined in this top-level package
+DataStoreClient.__module__ = __name__
+ErrorInformation.__module__ = __name__
+Moniker.__module__ = __name__
+Outcome.__module__ = __name__
+PublishedCondition.__module__ = __name__
+PublishedMeasurement.__module__ = __name__
+Step.__module__ = __name__
+TestResult.__module__ = __name__

ni_datastore-0.1.0.dev2/src/ni/datastore/data/_data_store_client.py

@@ -0,0 +1,302 @@
+"""Data store client for publishing and reading data."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterable
+from threading import Lock
+from typing import Type, TypeVar, overload
+from urllib.parse import urlparse
+
+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,
+    populate_publish_condition_request_value,
+    populate_publish_measurement_batch_request_values,
+    populate_publish_measurement_request_value,
+    unpack_and_convert_from_protobuf_any,
+)
+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,
+    GetStepRequest,
+    GetTestResultRequest,
+    PublishConditionBatchRequest,
+    PublishConditionRequest,
+    PublishMeasurementBatchRequest,
+    PublishMeasurementRequest,
+    QueryConditionsRequest,
+    QueryMeasurementsRequest,
+    QueryStepsRequest,
+)
+from ni.protobuf.types.precision_timestamp_conversion import (
+    hightime_datetime_to_protobuf,
+)
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+TRead = TypeVar("TRead")
+
+_logger = logging.getLogger(__name__)
+
+
+class DataStoreClient:
+    """Data store client for publishing and reading data."""
+
+    __slots__ = (
+        "_discovery_client",
+        "_grpc_channel",
+        "_grpc_channel_pool",
+        "_data_store_client",
+        "_data_store_client_lock",
+        "_moniker_clients_by_service_location",
+        "_moniker_clients_lock",
+    )
+
+    _discovery_client: DiscoveryClient | None
+    _grpc_channel: Channel | None
+    _grpc_channel_pool: GrpcChannelPool | None
+    _data_store_client: DataStoreServiceClient | None
+    _moniker_clients_by_service_location: dict[str, MonikerClient]
+    _data_store_client_lock: Lock
+    _moniker_clients_lock: Lock
+
+    def __init__(
+        self,
+        discovery_client: DiscoveryClient | None = None,
+        grpc_channel: Channel | None = None,
+        grpc_channel_pool: GrpcChannelPool | None = None,
+    ) -> None:
+        """Initialize the DataStoreClient.
+
+        Args:
+            discovery_client: An optional discovery client (recommended).
+
+            grpc_channel: An optional data store gRPC channel. Providing this channel will bypass
+                discovery service resolution of the data store. (Note: Reading data from a moniker
+                will still always use a channel corresponding to the service location specified by
+                that moniker.)
+
+            grpc_channel_pool: An optional gRPC channel pool (recommended).
+        """
+        self._discovery_client = discovery_client
+        self._grpc_channel = grpc_channel
+        self._grpc_channel_pool = grpc_channel_pool
+
+        self._data_store_client = None
+        self._moniker_clients_by_service_location = {}
+
+        self._data_store_client_lock = Lock()
+        self._moniker_clients_lock = Lock()
+
+    def publish_condition(
+        self,
+        condition_name: str,
+        type: str,
+        value: object,
+        step_id: str,
+    ) -> PublishedCondition:
+        """Publish a condition value to the data store."""
+        publish_request = PublishConditionRequest(
+            condition_name=condition_name,
+            type=type,
+            step_id=step_id,
+        )
+        populate_publish_condition_request_value(publish_request, value)
+        publish_response = self._get_data_store_client().publish_condition(publish_request)
+        return PublishedCondition.from_protobuf(publish_response.published_condition)
+
+    def publish_condition_batch(
+        self, condition_name: str, type: str, values: object, step_id: str
+    ) -> PublishedCondition:
+        """Publish a batch of N values for a condition to the data store."""
+        publish_request = PublishConditionBatchRequest(
+            condition_name=condition_name,
+            type=type,
+            step_id=step_id,
+        )
+        populate_publish_condition_batch_request_values(publish_request, values)
+        publish_response = self._get_data_store_client().publish_condition_batch(publish_request)
+        return PublishedCondition.from_protobuf(publish_response.published_condition)
+
+    def publish_measurement(
+        self,
+        measurement_name: str,
+        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,
+        error_information: ErrorInformation | None = None,
+        hardware_item_ids: Iterable[str] = tuple(),
+        test_adapter_ids: Iterable[str] = tuple(),
+        software_item_ids: Iterable[str] = tuple(),
+        notes: str = "",
+    ) -> PublishedMeasurement:
+        """Publish a measurement value to the data store."""
+        publish_request = PublishMeasurementRequest(
+            measurement_name=measurement_name,
+            step_id=step_id,
+            outcome=outcome,
+            error_information=error_information,
+            hardware_item_ids=hardware_item_ids,
+            test_adapter_ids=test_adapter_ids,
+            software_item_ids=software_item_ids,
+            notes=notes,
+        )
+        populate_publish_measurement_request_value(publish_request, value)
+        publish_request.timestamp.CopyFrom(
+            get_publish_measurement_timestamp(publish_request, timestamp)
+        )
+        publish_response = self._get_data_store_client().publish_measurement(publish_request)
+        return PublishedMeasurement.from_protobuf(publish_response.published_measurement)
+
+    def publish_measurement_batch(
+        self,
+        measurement_name: str,
+        values: object,
+        step_id: str,
+        timestamps: Iterable[ht.datetime] = tuple(),
+        outcomes: Iterable[Outcome.ValueType] = tuple(),
+        error_information: Iterable[ErrorInformation] = tuple(),
+        hardware_item_ids: Iterable[str] = tuple(),
+        test_adapter_ids: Iterable[str] = tuple(),
+        software_item_ids: Iterable[str] = tuple(),
+    ) -> Iterable[PublishedMeasurement]:
+        """Publish a batch of N values of a measurement to the data store."""
+        publish_request = PublishMeasurementBatchRequest(
+            measurement_name=measurement_name,
+            step_id=step_id,
+            timestamp=[hightime_datetime_to_protobuf(ts) for ts in timestamps],
+            outcome=outcomes,
+            error_information=error_information,
+            hardware_item_ids=hardware_item_ids,
+            test_adapter_ids=test_adapter_ids,
+            software_item_ids=software_item_ids,
+        )
+        populate_publish_measurement_batch_request_values(publish_request, values)
+        publish_response = self._get_data_store_client().publish_measurement_batch(publish_request)
+        return [
+            PublishedMeasurement.from_protobuf(pm) for pm in publish_response.published_measurements
+        ]
+
+    @overload
+    def read_data(
+        self,
+        moniker_source: Moniker | PublishedMeasurement | PublishedCondition,
+        expected_type: Type[TRead],
+    ) -> TRead: ...
+
+    @overload
+    def read_data(
+        self,
+        moniker_source: Moniker | PublishedMeasurement | PublishedCondition,
+    ) -> object: ...
+
+    def read_data(
+        self,
+        moniker_source: Moniker | PublishedMeasurement | PublishedCondition,
+        expected_type: Type[TRead] | None = None,
+    ) -> TRead | object:
+        """Read data published to the data store."""
+        if isinstance(moniker_source, Moniker):
+            moniker = moniker_source
+        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
+        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_client = self._get_moniker_client(moniker.service_location)
+        read_result = moniker_client.read_from_moniker(moniker)
+        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)}")
+        return converted_data
+
+    def create_step(self, step: Step) -> str:
+        """Create a step in the data store."""
+        create_request = CreateStepRequest(step=step.to_protobuf())
+        create_response = self._get_data_store_client().create_step(create_request)
+        return create_response.step_id
+
+    def get_step(self, step_id: str) -> Step:
+        """Get a step from the data store."""
+        get_request = GetStepRequest(step_id=step_id)
+        get_response = self._get_data_store_client().get_step(get_request)
+        return Step.from_protobuf(get_response.step)
+
+    def create_test_result(self, test_result: TestResult) -> str:
+        """Create a test result in the data store."""
+        create_request = CreateTestResultRequest(test_result=test_result.to_protobuf())
+        create_response = self._get_data_store_client().create_test_result(create_request)
+        return create_response.test_result_id
+
+    def get_test_result(self, test_result_id: str) -> TestResult:
+        """Get a test result from the data store."""
+        get_request = GetTestResultRequest(test_result_id=test_result_id)
+        get_response = self._get_data_store_client().get_test_result(get_request)
+        return TestResult.from_protobuf(get_response.test_result)
+
+    def query_conditions(self, odata_query: str) -> Iterable[PublishedCondition]:
+        """Query conditions from the data store."""
+        query_request = QueryConditionsRequest(odata_query=odata_query)
+        query_response = self._get_data_store_client().query_conditions(query_request)
+        return [
+            PublishedCondition.from_protobuf(published_condition)
+            for published_condition in query_response.published_conditions
+        ]
+
+    def query_measurements(self, odata_query: str) -> Iterable[PublishedMeasurement]:
+        """Query measurements from the data store."""
+        query_request = QueryMeasurementsRequest(odata_query=odata_query)
+        query_response = self._get_data_store_client().query_measurements(query_request)
+        return [
+            PublishedMeasurement.from_protobuf(published_measurement)
+            for published_measurement in query_response.published_measurements
+        ]
+
+    def query_steps(self, odata_query: str) -> Iterable[Step]:
+        """Query steps from the data store."""
+        query_request = QueryStepsRequest(odata_query=odata_query)
+        query_response = self._get_data_store_client().query_steps(query_request)
+        return [Step.from_protobuf(step) for step in query_response.steps]
+
+    def _get_data_store_client(self) -> DataStoreServiceClient:
+        if self._data_store_client is None:
+            with self._data_store_client_lock:
+                if self._data_store_client is None:
+                    self._data_store_client = DataStoreServiceClient(
+                        discovery_client=self._discovery_client,
+                        grpc_channel=self._grpc_channel,
+                        grpc_channel_pool=self._grpc_channel_pool,
+                    )
+        return self._data_store_client
+
+    def _get_moniker_client(self, service_location: str) -> MonikerClient:
+        parsed_service_location = urlparse(service_location).netloc
+        if parsed_service_location not in self._moniker_clients_by_service_location:
+            with self._moniker_clients_lock:
+                if parsed_service_location not in self._moniker_clients_by_service_location:
+                    self._moniker_clients_by_service_location[parsed_service_location] = (
+                        MonikerClient(
+                            service_location=parsed_service_location,
+                            grpc_channel_pool=self._grpc_channel_pool,
+                        )
+                    )
+        return self._moniker_clients_by_service_location[parsed_service_location]

ni_datastore-0.1.0.dev1/src/ni/datastore/grpc_conversion.py → ni_datastore-0.1.0.dev2/src/ni/datastore/data/_grpc_conversion.py

@@ -2,19 +2,23 @@
 
 from __future__ import annotations
 
+import datetime as std_datetime
 import logging
-from typing import MutableMapping
+from typing import Iterable, cast
 
+import hightime as ht
 import numpy as np
 from google.protobuf.any_pb2 import Any
-from google.protobuf.internal.containers import MessageMap
 from ni.measurements.data.v1.data_store_service_pb2 import (
     PublishConditionBatchRequest,
     PublishConditionRequest,
     PublishMeasurementBatchRequest,
     PublishMeasurementRequest,
 )
-from ni.measurements.metadata.v1.metadata_store_pb2 import ExtensionValue
+from ni.protobuf.types.precision_timestamp_conversion import (
+    hightime_datetime_to_protobuf,
+)
+from ni.protobuf.types.precision_timestamp_pb2 import PrecisionTimestamp
 from ni.protobuf.types.scalar_conversion import scalar_to_protobuf
 from ni.protobuf.types.vector_conversion import vector_from_protobuf, vector_to_protobuf
 from ni.protobuf.types.vector_pb2 import Vector as VectorProto
@@ -73,9 +77,19 @@ def populate_publish_condition_batch_request_values(
     publish_request: PublishConditionBatchRequest, values: object
 ) -> None:
     """Assign a value to the scalar_values vector member of PublishConditionBatchRequest."""
-    # TODO: Determine whether we wish to support primitive types such as a list of float
     if isinstance(values, Vector):
         publish_request.scalar_values.CopyFrom(vector_to_protobuf(values))
+    elif isinstance(values, Iterable):
+        if not values:
+            raise ValueError("Cannot publish an empty Iterable.")
+        try:
+            vector = Vector(values)
+        except (TypeError, ValueError):
+            raise TypeError(
+                f"Unsupported iterable: {values}. Subtype must be bool, float, int, or string."
+            )
+
+        publish_request.scalar_values.CopyFrom(vector_to_protobuf(vector))
     else:
         raise TypeError(
             f"Unsupported condition values type: {type(values)}. Please consult the documentation."
@@ -123,6 +137,17 @@ def populate_publish_measurement_request_value(
             raise TypeError(f"Unsupported Spectrum dtype: {value.dtype}")
     elif isinstance(value, DigitalWaveform):
         publish_request.digital_waveform.CopyFrom(digital_waveform_to_protobuf(value))
+    elif isinstance(value, Iterable):
+        if not value:
+            raise ValueError("Cannot publish an empty Iterable.")
+        try:
+            vector = Vector(value)
+        except (TypeError, ValueError):
+            raise TypeError(
+                f"Unsupported iterable: {value}. Subtype must be bool, float, int, or string."
+            )
+
+        publish_request.vector.CopyFrom(vector_to_protobuf(vector))
     else:
         raise TypeError(
             f"Unsupported measurement value type: {type(value)}. Please consult the documentation."
@@ -134,9 +159,19 @@ def populate_publish_measurement_batch_request_values(
     publish_request: PublishMeasurementBatchRequest, values: object
 ) -> None:
     """Assign a value to the appropriate field of the PublishMeasurementBatchRequest object."""
-    # TODO: Determine whether we wish to support primitive types such as a list of float
     if isinstance(values, Vector):
         publish_request.scalar_values.CopyFrom(vector_to_protobuf(values))
+    elif isinstance(values, Iterable):
+        if not values:
+            raise ValueError("Cannot publish an empty Iterable.")
+        try:
+            vector = Vector(values)
+        except (TypeError, ValueError):
+            raise TypeError(
+                f"Unsupported iterable: {values}. Subtype must be bool, float, int, or string."
+            )
+
+        publish_request.scalar_values.CopyFrom(vector_to_protobuf(vector))
     else:
         raise TypeError(
             f"Unsupported measurement values type: {type(values)}. Please consult the documentation."
@@ -185,29 +220,37 @@ def unpack_and_convert_from_protobuf_any(read_value: Any) -> object:
         raise TypeError(f"Unsupported data type Name: {value_type}")
 
 
-def populate_extension_value_message_map(
-    destination: MessageMap[str, ExtensionValue],
-    source: MutableMapping[str, str],
-) -> None:
-    """Populate a gRPC message map of string keys to ExtensionValue.
-
-    The input is a mapping of string keys to string values.
-    """
-    for key, value in source.items():
-        destination[key].string_value = value
+def get_publish_measurement_timestamp(
+    publish_request: PublishMeasurementRequest, client_provided_timestamp: ht.datetime | None
+) -> PrecisionTimestamp:
+    """Determine the correct timestamp to use for publishing a measurement."""
+    no_client_timestamp_provided = client_provided_timestamp is None
+    if no_client_timestamp_provided:
+        publish_time = hightime_datetime_to_protobuf(ht.datetime.now(std_datetime.timezone.utc))
+    else:
+        publish_time = hightime_datetime_to_protobuf(cast(ht.datetime, client_provided_timestamp))
 
+    waveform_t0: PrecisionTimestamp | None = None
+    value_case = publish_request.WhichOneof("value")
+    if value_case == "double_analog_waveform":
+        waveform_t0 = publish_request.double_analog_waveform.t0
+    elif value_case == "i16_analog_waveform":
+        waveform_t0 = publish_request.i16_analog_waveform.t0
+    elif value_case == "double_complex_waveform":
+        waveform_t0 = publish_request.double_complex_waveform.t0
+    elif value_case == "i16_complex_waveform":
+        waveform_t0 = publish_request.i16_complex_waveform.t0
+    elif value_case == "digital_waveform":
+        waveform_t0 = publish_request.digital_waveform.t0
 
-def populate_from_extension_value_message_map(
-    destination: MutableMapping[str, str],
-    source: MessageMap[str, ExtensionValue],
-) -> None:
-    """Populate a mapping of string keys to stringvalues.
-
-    The input is a gRPC message map of string keys to ExtensionValue.
-    """
-    for key, extension_value in source.items():
-        value_case = extension_value.WhichOneof("metadata")
-        if value_case == "string_value":
-            destination[key] = extension_value.string_value
-        else:
-            raise TypeError(f"Unsupported ExtensionValue type for key '{key}': {value_case}")
+    # If an initialized waveform t0 value is present
+    if waveform_t0 is not None and waveform_t0 != PrecisionTimestamp():
+        if no_client_timestamp_provided:
+            # If the client did not provide a timestamp, use the waveform t0 value
+            publish_time = waveform_t0
+        elif publish_time != waveform_t0:
+            raise ValueError(
+                "The provided timestamp does not match the waveform t0. Please provide a matching timestamp or "
+                "omit the timestamp to use the waveform t0."
+            )
+    return publish_time

ni_datastore-0.1.0.dev2/src/ni/datastore/data/_types/__init__.py

@@ -0,0 +1 @@
+"""Types for use in accessing the NI Data Store."""

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/data}/_types/_published_measurement.py

@@ -6,7 +6,7 @@ from typing import Iterable
 
 import hightime as ht
 from ni.datamonikers.v1.data_moniker_pb2 import Moniker
-from ni.datastore._types._published_condition import PublishedCondition
+from ni.datastore.data._types._published_condition import PublishedCondition
 from ni.measurements.data.v1.data_store_pb2 import (
     ErrorInformation,
     Outcome,

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/data}/_types/_step.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from typing import MutableMapping
 
 import hightime as ht
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/data}/_types/_test_result.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from typing import Iterable, MutableMapping
 
 import hightime as ht
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

ni_datastore-0.1.0.dev2/src/ni/datastore/metadata/__init__.py

@@ -0,0 +1,46 @@
+"""Public API for accessing the NI Metadata Store."""
+
+from ni.datastore.metadata._metadata_store_client import MetadataStoreClient
+from ni.datastore.metadata._types._alias import Alias
+from ni.datastore.metadata._types._extension_schema import ExtensionSchema
+from ni.datastore.metadata._types._hardware_item import HardwareItem
+from ni.datastore.metadata._types._operator import Operator
+from ni.datastore.metadata._types._software_item import SoftwareItem
+from ni.datastore.metadata._types._test import Test
+from ni.datastore.metadata._types._test_adapter import TestAdapter
+from ni.datastore.metadata._types._test_description import TestDescription
+from ni.datastore.metadata._types._test_station import TestStation
+from ni.datastore.metadata._types._uut import Uut
+from ni.datastore.metadata._types._uut_instance import UutInstance
+from ni.measurements.metadata.v1.metadata_store_pb2 import AliasTargetType
+
+__all__ = [
+    "Alias",
+    "AliasTargetType",
+    "ExtensionSchema",
+    "HardwareItem",
+    "MetadataStoreClient",
+    "Operator",
+    "SoftwareItem",
+    "Test",
+    "TestAdapter",
+    "TestDescription",
+    "TestStation",
+    "Uut",
+    "UutInstance",
+]
+
+# Hide that it was not defined in this top-level package
+Alias.__module__ = __name__
+AliasTargetType.__module__ = __name__
+ExtensionSchema.__module__ = __name__
+HardwareItem.__module__ = __name__
+MetadataStoreClient.__module__ = __name__
+Operator.__module__ = __name__
+SoftwareItem.__module__ = __name__
+Test.__module__ = __name__
+TestAdapter.__module__ = __name__
+TestDescription.__module__ = __name__
+TestStation.__module__ = __name__
+Uut.__module__ = __name__
+UutInstance.__module__ = __name__

ni_datastore-0.1.0.dev2/src/ni/datastore/metadata/_grpc_conversion.py

@@ -0,0 +1,39 @@
+"""Helper methods to convert between python and protobuf types."""
+
+from __future__ import annotations
+
+import logging
+from typing import MutableMapping
+
+from google.protobuf.internal.containers import MessageMap
+from ni.measurements.metadata.v1.metadata_store_pb2 import ExtensionValue
+
+_logger = logging.getLogger(__name__)
+
+
+def populate_extension_value_message_map(
+    destination: MessageMap[str, ExtensionValue],
+    source: MutableMapping[str, str],
+) -> None:
+    """Populate a gRPC message map of string keys to ExtensionValue.
+
+    The input is a mapping of string keys to string values.
+    """
+    for key, value in source.items():
+        destination[key].string_value = value
+
+
+def populate_from_extension_value_message_map(
+    destination: MutableMapping[str, str],
+    source: MessageMap[str, ExtensionValue],
+) -> None:
+    """Populate a mapping of string keys to stringvalues.
+
+    The input is a gRPC message map of string keys to ExtensionValue.
+    """
+    for key, extension_value in source.items():
+        value_case = extension_value.WhichOneof("metadata")
+        if value_case == "string_value":
+            destination[key] = extension_value.string_value
+        else:
+            raise TypeError(f"Unsupported ExtensionValue type for key '{key}': {value_case}")

ni_datastore-0.1.0.dev1/src/ni/datastore/_client.py → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata/_metadata_store_client.py

@@ -1,60 +1,26 @@
-"""Datastore client for publishing and reading data."""
+"""Metadata store client for publishing and reading metadata."""
 
 from __future__ import annotations
 
-import datetime as std_datetime
 import logging
 from collections.abc import Iterable
+from pathlib import Path
 from threading import Lock
-from typing import Type, TypeVar, cast, overload
-from urllib.parse import urlparse
 
-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._types._alias import Alias
-from ni.datastore._types._extension_schema import ExtensionSchema
-from ni.datastore._types._hardware_item import HardwareItem
-from ni.datastore._types._operator import Operator
-from ni.datastore._types._published_condition import PublishedCondition
-from ni.datastore._types._published_measurement import PublishedMeasurement
-from ni.datastore._types._software_item import SoftwareItem
-from ni.datastore._types._step import Step
-from ni.datastore._types._test import Test
-from ni.datastore._types._test_adapter import TestAdapter
-from ni.datastore._types._test_description import TestDescription
-from ni.datastore._types._test_result import TestResult
-from ni.datastore._types._test_station import TestStation
-from ni.datastore._types._uut import Uut
-from ni.datastore._types._uut_instance import UutInstance
-from ni.datastore.grpc_conversion import (
-    populate_publish_condition_batch_request_values,
-    populate_publish_condition_request_value,
-    populate_publish_measurement_batch_request_values,
-    populate_publish_measurement_request_value,
-    unpack_and_convert_from_protobuf_any,
-)
+from ni.datastore.metadata._types._alias import Alias
+from ni.datastore.metadata._types._extension_schema import ExtensionSchema
+from ni.datastore.metadata._types._hardware_item import HardwareItem
+from ni.datastore.metadata._types._operator import Operator
+from ni.datastore.metadata._types._software_item import SoftwareItem
+from ni.datastore.metadata._types._test import Test
+from ni.datastore.metadata._types._test_adapter import TestAdapter
+from ni.datastore.metadata._types._test_description import TestDescription
+from ni.datastore.metadata._types._test_station import TestStation
+from ni.datastore.metadata._types._uut import Uut
+from ni.datastore.metadata._types._uut_instance import UutInstance
 from ni.measurementlink.discovery.v1.client import DiscoveryClient
-from ni.measurements.data.v1.client import DataStoreClient
-from ni.measurements.data.v1.data_store_pb2 import (
-    ErrorInformation,
-    Outcome,
-)
-from ni.measurements.data.v1.data_store_service_pb2 import (
-    CreateStepRequest,
-    CreateTestResultRequest,
-    GetStepRequest,
-    GetTestResultRequest,
-    PublishConditionBatchRequest,
-    PublishConditionRequest,
-    PublishMeasurementBatchRequest,
-    PublishMeasurementRequest,
-    QueryConditionsRequest,
-    QueryMeasurementsRequest,
-    QueryStepsRequest,
-)
-from ni.measurements.metadata.v1.client import MetadataStoreClient
+from ni.measurements.metadata.v1.client import MetadataStoreClient as MetadataStoreServiceClient
 from ni.measurements.metadata.v1.metadata_store_service_pb2 import (
     CreateAliasRequest,
     CreateHardwareItemRequest,
@@ -90,41 +56,27 @@ from ni.measurements.metadata.v1.metadata_store_service_pb2 import (
     QueryUutsRequest,
     RegisterSchemaRequest,
 )
-from ni.protobuf.types.precision_timestamp_conversion import (
-    hightime_datetime_to_protobuf,
-)
-from ni.protobuf.types.precision_timestamp_pb2 import PrecisionTimestamp
 from ni_grpc_extensions.channelpool import GrpcChannelPool
 
-TRead = TypeVar("TRead")
-
 _logger = logging.getLogger(__name__)
 
 
-class Client:
-    """Datastore client for publishing and reading data."""
+class MetadataStoreClient:
+    """Metadata store client for publishing and reading metadata."""
 
     __slots__ = (
         "_discovery_client",
         "_grpc_channel",
         "_grpc_channel_pool",
-        "_data_store_client",
-        "_data_store_client_lock",
         "_metadata_store_client",
         "_metadata_store_client_lock",
-        "_moniker_clients_by_service_location",
-        "_moniker_clients_lock",
     )
 
     _discovery_client: DiscoveryClient | None
     _grpc_channel: Channel | None
     _grpc_channel_pool: GrpcChannelPool | None
-    _data_store_client: DataStoreClient | None
-    _metadata_store_client: MetadataStoreClient | None
-    _moniker_clients_by_service_location: dict[str, MonikerClient]
-    _data_store_client_lock: Lock
+    _metadata_store_client: MetadataStoreServiceClient | None
     _metadata_store_client_lock: Lock
-    _moniker_clients_lock: Lock
 
     def __init__(
         self,
@@ -132,15 +84,13 @@ class Client:
         grpc_channel: Channel | None = None,
         grpc_channel_pool: GrpcChannelPool | None = None,
     ) -> None:
-        """Initialize the Client.
+        """Initialize the MetadataStoreClient.
 
         Args:
             discovery_client: An optional discovery client (recommended).
 
-            grpc_channel: An optional data store gRPC channel. Providing this channel will bypass
-            discovery service resolution of the data store. (Note: Reading data from a moniker
-            will still always use a channel corresponding to the service location specified by
-            that moniker.)
+            grpc_channel: An optional metadata store gRPC channel. Providing this channel
+                will bypass discovery service resolution of the metadata store.
 
             grpc_channel_pool: An optional gRPC channel pool (recommended).
         """
@@ -148,188 +98,8 @@ class Client:
         self._grpc_channel = grpc_channel
         self._grpc_channel_pool = grpc_channel_pool
 
-        self._data_store_client = None
         self._metadata_store_client = None
-        self._moniker_clients_by_service_location = {}
-
-        self._data_store_client_lock = Lock()
         self._metadata_store_client_lock = Lock()
-        self._moniker_clients_lock = Lock()
-
-    def publish_condition(
-        self,
-        condition_name: str,
-        type: str,
-        value: object,
-        step_id: str,
-    ) -> PublishedCondition:
-        """Publish a condition value to the data store."""
-        publish_request = PublishConditionRequest(
-            condition_name=condition_name,
-            type=type,
-            step_id=step_id,
-        )
-        populate_publish_condition_request_value(publish_request, value)
-        publish_response = self._get_data_store_client().publish_condition(publish_request)
-        return PublishedCondition.from_protobuf(publish_response.published_condition)
-
-    def publish_condition_batch(
-        self, condition_name: str, type: str, values: object, step_id: str
-    ) -> PublishedCondition:
-        """Publish a batch of N values for a condition to the data store."""
-        publish_request = PublishConditionBatchRequest(
-            condition_name=condition_name,
-            type=type,
-            step_id=step_id,
-        )
-        populate_publish_condition_batch_request_values(publish_request, values)
-        publish_response = self._get_data_store_client().publish_condition_batch(publish_request)
-        return PublishedCondition.from_protobuf(publish_response.published_condition)
-
-    def publish_measurement(
-        self,
-        measurement_name: str,
-        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,
-        error_information: ErrorInformation | None = None,
-        hardware_item_ids: Iterable[str] = tuple(),
-        test_adapter_ids: Iterable[str] = tuple(),
-        software_item_ids: Iterable[str] = tuple(),
-        notes: str = "",
-    ) -> PublishedMeasurement:
-        """Publish a measurement value to the data store."""
-        publish_request = PublishMeasurementRequest(
-            measurement_name=measurement_name,
-            step_id=step_id,
-            outcome=outcome,
-            error_information=error_information,
-            hardware_item_ids=hardware_item_ids,
-            test_adapter_ids=test_adapter_ids,
-            software_item_ids=software_item_ids,
-            notes=notes,
-        )
-        populate_publish_measurement_request_value(publish_request, value)
-        publish_request.timestamp.CopyFrom(
-            self._get_publish_measurement_timestamp(publish_request, timestamp)
-        )
-        publish_response = self._get_data_store_client().publish_measurement(publish_request)
-        return PublishedMeasurement.from_protobuf(publish_response.published_measurement)
-
-    def publish_measurement_batch(
-        self,
-        measurement_name: str,
-        values: object,
-        step_id: str,
-        timestamps: Iterable[ht.datetime] = tuple(),
-        outcomes: Iterable[Outcome.ValueType] = tuple(),
-        error_information: Iterable[ErrorInformation] = tuple(),
-        hardware_item_ids: Iterable[str] = tuple(),
-        test_adapter_ids: Iterable[str] = tuple(),
-        software_item_ids: Iterable[str] = tuple(),
-    ) -> Iterable[PublishedMeasurement]:
-        """Publish a batch of N values of a measurement to the data store."""
-        publish_request = PublishMeasurementBatchRequest(
-            measurement_name=measurement_name,
-            step_id=step_id,
-            timestamp=[hightime_datetime_to_protobuf(ts) for ts in timestamps],
-            outcome=outcomes,
-            error_information=error_information,
-            hardware_item_ids=hardware_item_ids,
-            test_adapter_ids=test_adapter_ids,
-            software_item_ids=software_item_ids,
-        )
-        populate_publish_measurement_batch_request_values(publish_request, values)
-        publish_response = self._get_data_store_client().publish_measurement_batch(publish_request)
-        return [
-            PublishedMeasurement.from_protobuf(pm) for pm in publish_response.published_measurements
-        ]
-
-    @overload
-    def read_data(
-        self,
-        moniker_source: Moniker | PublishedMeasurement | PublishedCondition,
-        expected_type: Type[TRead],
-    ) -> TRead: ...
-
-    @overload
-    def read_data(
-        self,
-        moniker_source: Moniker | PublishedMeasurement | PublishedCondition,
-    ) -> object: ...
-
-    def read_data(
-        self,
-        moniker_source: Moniker | PublishedMeasurement | PublishedCondition,
-        expected_type: Type[TRead] | None = None,
-    ) -> TRead | object:
-        """Read data published to the data store."""
-        if isinstance(moniker_source, Moniker):
-            moniker = moniker_source
-        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
-        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_client = self._get_moniker_client(moniker.service_location)
-        read_result = moniker_client.read_from_moniker(moniker)
-        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)}")
-        return converted_data
-
-    def create_step(self, step: Step) -> str:
-        """Create a step in the datastore."""
-        create_request = CreateStepRequest(step=step.to_protobuf())
-        create_response = self._get_data_store_client().create_step(create_request)
-        return create_response.step_id
-
-    def get_step(self, step_id: str) -> Step:
-        """Get a step from the data store."""
-        get_request = GetStepRequest(step_id=step_id)
-        get_response = self._get_data_store_client().get_step(get_request)
-        return Step.from_protobuf(get_response.step)
-
-    def create_test_result(self, test_result: TestResult) -> str:
-        """Create a test result in the data store."""
-        create_request = CreateTestResultRequest(test_result=test_result.to_protobuf())
-        create_response = self._get_data_store_client().create_test_result(create_request)
-        return create_response.test_result_id
-
-    def get_test_result(self, test_result_id: str) -> TestResult:
-        """Get a test result from the data store."""
-        get_request = GetTestResultRequest(test_result_id=test_result_id)
-        get_response = self._get_data_store_client().get_test_result(get_request)
-        return TestResult.from_protobuf(get_response.test_result)
-
-    def query_conditions(self, odata_query: str) -> Iterable[PublishedCondition]:
-        """Query conditions from the data store."""
-        query_request = QueryConditionsRequest(odata_query=odata_query)
-        query_response = self._get_data_store_client().query_conditions(query_request)
-        return [
-            PublishedCondition.from_protobuf(published_condition)
-            for published_condition in query_response.published_conditions
-        ]
-
-    def query_measurements(self, odata_query: str) -> Iterable[PublishedMeasurement]:
-        """Query measurements from the data store."""
-        query_request = QueryMeasurementsRequest(odata_query=odata_query)
-        query_response = self._get_data_store_client().query_measurements(query_request)
-        return [
-            PublishedMeasurement.from_protobuf(published_measurement)
-            for published_measurement in query_response.published_measurements
-        ]
-
-    def query_steps(self, odata_query: str) -> Iterable[Step]:
-        """Query steps from the data store."""
-        query_request = QueryStepsRequest(odata_query=odata_query)
-        query_response = self._get_data_store_client().query_steps(query_request)
-        return [Step.from_protobuf(step) for step in query_response.steps]
 
     def create_uut_instance(self, uut_instance: UutInstance) -> str:
         """Create a UUT instance in the metadata store."""
@@ -510,10 +280,31 @@ class Client:
             TestAdapter.from_protobuf(test_adapter) for test_adapter in query_response.test_adapters
         ]
 
-    # TODO: Also support providing a file path?
-    def register_schema(self, schema: str) -> str:
-        """Register a schema in the metadata store."""
-        register_request = RegisterSchemaRequest(schema=schema)
+    def register_schema_from_file(self, schema_file_path: Path | str) -> str:
+        """Register a schema obtained from the specified file in the metadata store.
+
+        Args:
+            schema_file_path: The path at which the schema file is located
+
+        Raises:
+            FileNotFoundError: If the schema file does not exist.
+        """
+        if isinstance(schema_file_path, str):
+            schema_file_path = Path(schema_file_path)
+
+        if not schema_file_path.exists():
+            raise FileNotFoundError(f"Schema file not found: {schema_file_path}")
+
+        schema_contents = schema_file_path.read_text(encoding="utf-8-sig")
+        return self.register_schema(schema_contents=schema_contents)
+
+    def register_schema(self, schema_contents: str) -> str:
+        """Register a schema in the metadata store.
+
+        Args:
+            schema_contents: The contents of the schema to register
+        """
+        register_request = RegisterSchemaRequest(schema=schema_contents)
         register_response = self._get_metadata_store_client().register_schema(register_request)
         return register_response.schema_id
 
@@ -579,74 +370,13 @@ class Client:
         query_response = self._get_metadata_store_client().query_aliases(query_request)
         return [Alias.from_protobuf(alias) for alias in query_response.aliases]
 
-    def _get_data_store_client(self) -> DataStoreClient:
-        if self._data_store_client is None:
-            with self._data_store_client_lock:
-                if self._data_store_client is None:
-                    self._data_store_client = DataStoreClient(
-                        discovery_client=self._discovery_client,
-                        grpc_channel=self._grpc_channel,
-                        grpc_channel_pool=self._grpc_channel_pool,
-                    )
-        return self._data_store_client
-
-    def _get_metadata_store_client(self) -> MetadataStoreClient:
+    def _get_metadata_store_client(self) -> MetadataStoreServiceClient:
         if self._metadata_store_client is None:
             with self._metadata_store_client_lock:
                 if self._metadata_store_client is None:
-                    self._metadata_store_client = MetadataStoreClient(
+                    self._metadata_store_client = MetadataStoreServiceClient(
                         discovery_client=self._discovery_client,
                         grpc_channel=self._grpc_channel,
                         grpc_channel_pool=self._grpc_channel_pool,
                     )
         return self._metadata_store_client
-
-    def _get_moniker_client(self, service_location: str) -> MonikerClient:
-        parsed_service_location = urlparse(service_location).netloc
-        if parsed_service_location not in self._moniker_clients_by_service_location:
-            with self._moniker_clients_lock:
-                if parsed_service_location not in self._moniker_clients_by_service_location:
-                    self._moniker_clients_by_service_location[parsed_service_location] = (
-                        MonikerClient(
-                            service_location=parsed_service_location,
-                            grpc_channel_pool=self._grpc_channel_pool,
-                        )
-                    )
-        return self._moniker_clients_by_service_location[parsed_service_location]
-
-    @staticmethod
-    def _get_publish_measurement_timestamp(
-        publish_request: PublishMeasurementRequest, client_provided_timestamp: ht.datetime | None
-    ) -> PrecisionTimestamp:
-        no_client_timestamp_provided = client_provided_timestamp is None
-        if no_client_timestamp_provided:
-            publish_time = hightime_datetime_to_protobuf(ht.datetime.now(std_datetime.timezone.utc))
-        else:
-            publish_time = hightime_datetime_to_protobuf(
-                cast(ht.datetime, client_provided_timestamp)
-            )
-
-        waveform_t0: PrecisionTimestamp | None = None
-        value_case = publish_request.WhichOneof("value")
-        if value_case == "double_analog_waveform":
-            waveform_t0 = publish_request.double_analog_waveform.t0
-        elif value_case == "i16_analog_waveform":
-            waveform_t0 = publish_request.i16_analog_waveform.t0
-        elif value_case == "double_complex_waveform":
-            waveform_t0 = publish_request.double_complex_waveform.t0
-        elif value_case == "i16_complex_waveform":
-            waveform_t0 = publish_request.i16_complex_waveform.t0
-        elif value_case == "digital_waveform":
-            waveform_t0 = publish_request.digital_waveform.t0
-
-        # If an initialized waveform t0 value is present
-        if waveform_t0 is not None and waveform_t0 != PrecisionTimestamp():
-            if no_client_timestamp_provided:
-                # If the client did not provide a timestamp, use the waveform t0 value
-                publish_time = waveform_t0
-            elif publish_time != waveform_t0:
-                raise ValueError(
-                    "The provided timestamp does not match the waveform t0. Please provide a matching timestamp or "
-                    "omit the timestamp to use the waveform t0."
-                )
-        return publish_time

ni_datastore-0.1.0.dev2/src/ni/datastore/metadata/_types/__init__.py

@@ -0,0 +1 @@
+"""Types for use in accessing the NI Metadata Store."""

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_hardware_item.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_operator.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_software_item.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_test.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_test_adapter.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_test_description.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_test_station.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_uut.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Iterable, MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

{ni_datastore-0.1.0.dev1/src/ni/datastore → ni_datastore-0.1.0.dev2/src/ni/datastore/metadata}/_types/_uut_instance.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import MutableMapping
 
-from ni.datastore.grpc_conversion import (
+from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
     populate_from_extension_value_message_map,
 )

ni_datastore-0.1.0.dev1/src/ni/datastore/__init__.py

@@ -1,66 +0,0 @@
-"""Public API for accessing the NI Data Store Service."""
-
-from ni.datamonikers.v1.data_moniker_pb2 import Moniker
-from ni.datastore._client import Client
-from ni.datastore._types._alias import Alias
-from ni.datastore._types._extension_schema import ExtensionSchema
-from ni.datastore._types._hardware_item import HardwareItem
-from ni.datastore._types._operator import Operator
-from ni.datastore._types._published_condition import PublishedCondition
-from ni.datastore._types._published_measurement import PublishedMeasurement
-from ni.datastore._types._software_item import SoftwareItem
-from ni.datastore._types._step import Step
-from ni.datastore._types._test import Test
-from ni.datastore._types._test_adapter import TestAdapter
-from ni.datastore._types._test_description import TestDescription
-from ni.datastore._types._test_result import TestResult
-from ni.datastore._types._test_station import TestStation
-from ni.datastore._types._uut import Uut
-from ni.datastore._types._uut_instance import UutInstance
-from ni.measurements.data.v1.data_store_pb2 import ErrorInformation, Outcome
-from ni.measurements.metadata.v1.metadata_store_pb2 import AliasTargetType
-
-__all__ = [
-    "Client",
-    "Alias",
-    "AliasTargetType",
-    "ErrorInformation",
-    "ExtensionSchema",
-    "HardwareItem",
-    "Moniker",
-    "Operator",
-    "Outcome",
-    "PublishedCondition",
-    "PublishedMeasurement",
-    "SoftwareItem",
-    "Step",
-    "Test",
-    "TestAdapter",
-    "TestDescription",
-    "TestResult",
-    "TestStation",
-    "Uut",
-    "UutInstance",
-]
-
-# Hide that it was not defined in this top-level package
-Client.__module__ = __name__
-Alias.__module__ = __name__
-AliasTargetType.__module__ = __name__
-ErrorInformation.__module__ = __name__
-ExtensionSchema.__module__ = __name__
-HardwareItem.__module__ = __name__
-Moniker.__module__ = __name__
-Operator.__module__ = __name__
-Outcome.__module__ = __name__
-PublishedCondition.__module__ = __name__
-PublishedMeasurement.__module__ = __name__
-SoftwareItem.__module__ = __name__
-Step.__module__ = __name__
-Test.__module__ = __name__
-TestAdapter.__module__ = __name__
-TestDescription.__module__ = __name__
-TestResult.__module__ = __name__
-TestStation.__module__ = __name__
-Uut.__module__ = __name__
-UutInstance.__module__ = __name__

ni_datastore-0.1.0.dev1/src/ni/datastore/_types/__init__.py

@@ -1 +0,0 @@
-"""Types for use in accessing the NI Data Store Service."""