ni.datastore 0.1.0.dev2__tar.gz → 0.1.0.dev4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ni.datastore
-Version: 0.1.0.dev2
+Version: 0.1.0.dev4
 Summary: APIs for publishing and retrieving data from the NI Measurement Data Store
 License: MIT
 Keywords: datastore
@@ -24,10 +24,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: hightime (>=0.3.0.dev0)
-Requires-Dist: ni-datamonikers-v1-client (>=0.1.0.dev0)
-Requires-Dist: ni-measurements-data-v1-client (>=0.1.0.dev0)
-Requires-Dist: ni-measurements-metadata-v1-client (>=0.1.0.dev0)
-Requires-Dist: ni-protobuf-types (>=0.1.0.dev3)
+Requires-Dist: ni-datamonikers-v1-client (>=0.1.0.dev1)
+Requires-Dist: ni-measurements-data-v1-client (>=0.1.0.dev2)
+Requires-Dist: ni-measurements-metadata-v1-client (>=0.1.0.dev2)
+Requires-Dist: ni-protobuf-types (>=1.0.1.dev0)
 Requires-Dist: protobuf (>=4.21)
 Description-Content-Type: text/markdown
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "ni.datastore"
-version = "0.1.0-dev2"
+version = "0.1.0.dev4"
 license = "MIT"
 description = "APIs for publishing and retrieving data from the NI Measurement Data Store"
 authors = [{name = "NI", email = "opensource@ni.com"}]
@@ -37,10 +37,10 @@ requires-poetry = '>=2.1,<3.0'
 [tool.poetry.dependencies]
 python = "^3.9"
 protobuf = {version=">=4.21"}
-ni-datamonikers-v1-client = { version = ">=0.1.0.dev0", allow-prereleases = true }
-ni-measurements-data-v1-client = { version = ">=0.1.0.dev0", allow-prereleases = true }
-ni-measurements-metadata-v1-client = { version = ">=0.1.0.dev0", allow-prereleases = true }
-ni-protobuf-types = { version = ">=0.1.0.dev3", allow-prereleases = true }
+ni-datamonikers-v1-client = { version = ">=0.1.0.dev1", allow-prereleases = true }
+ni-measurements-data-v1-client = { version = ">=0.1.0.dev2", allow-prereleases = true }
+ni-measurements-metadata-v1-client = { version = ">=0.1.0.dev2", allow-prereleases = true }
+ni-protobuf-types = { version = ">=1.0.1.dev0", allow-prereleases = true }
 hightime = { version = ">=0.3.0.dev0", allow-prereleases = true }
 
 [tool.poetry.group.dev.dependencies]

{ni_datastore-0.1.0.dev2 → ni_datastore-0.1.0.dev4}/src/ni/datastore/data/_data_store_client.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Iterable
+import sys
+from collections.abc import Iterable, Sequence
 from threading import Lock
-from typing import Type, TypeVar, overload
+from types import TracebackType
+from typing import TYPE_CHECKING, Type, TypeVar, overload
 from urllib.parse import urlparse
 
 import hightime as ht
@@ -42,12 +44,19 @@ from ni.measurements.data.v1.data_store_service_pb2 import (
     QueryConditionsRequest,
     QueryMeasurementsRequest,
     QueryStepsRequest,
+    QueryTestResultsRequest,
 )
 from ni.protobuf.types.precision_timestamp_conversion import (
     hightime_datetime_to_protobuf,
 )
 from ni_grpc_extensions.channelpool import GrpcChannelPool
 
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        from typing_extensions import Self
+
 TRead = TypeVar("TRead")
 
 _logger = logging.getLogger(__name__)
@@ -57,6 +66,7 @@ class DataStoreClient:
     """Data store client for publishing and reading data."""
 
     __slots__ = (
+        "_closed",
         "_discovery_client",
         "_grpc_channel",
         "_grpc_channel_pool",
@@ -66,6 +76,9 @@ class DataStoreClient:
         "_moniker_clients_lock",
     )
 
+    _DATA_STORE_CLIENT_CLOSED_ERROR = "This DataStoreClient has been closed. Create a new DataStoreClient for further interaction with the data store."
+
+    _closed: bool
     _discovery_client: DiscoveryClient | None
     _grpc_channel: Channel | None
     _grpc_channel_pool: GrpcChannelPool | None
@@ -102,6 +115,35 @@ class DataStoreClient:
         self._data_store_client_lock = Lock()
         self._moniker_clients_lock = Lock()
 
+        self._closed = False
+
+    def __enter__(self) -> Self:
+        """Enter the runtime context of the data store client."""
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Exit the runtime context of the data store client."""
+        self.close()
+
+    def close(self) -> None:
+        """Close the data store client and clean up resources that it owns."""
+        self._closed = True
+
+        with self._data_store_client_lock:
+            if self._data_store_client is not None:
+                self._data_store_client.close()
+                self._data_store_client = None
+
+        with self._moniker_clients_lock:
+            for _, moniker_client in self._moniker_clients_by_service_location.items():
+                moniker_client.close()
+            self._moniker_clients_by_service_location.clear()
+
     def publish_condition(
         self,
         condition_name: str,
@@ -174,7 +216,7 @@ class DataStoreClient:
         hardware_item_ids: Iterable[str] = tuple(),
         test_adapter_ids: Iterable[str] = tuple(),
         software_item_ids: Iterable[str] = tuple(),
-    ) -> Iterable[PublishedMeasurement]:
+    ) -> Sequence[PublishedMeasurement]:
         """Publish a batch of N values of a measurement to the data store."""
         publish_request = PublishMeasurementBatchRequest(
             measurement_name=measurement_name,
@@ -253,7 +295,7 @@ class DataStoreClient:
         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]:
+    def query_conditions(self, odata_query: str = "") -> Sequence[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)
@@ -262,7 +304,7 @@ class DataStoreClient:
             for published_condition in query_response.published_conditions
         ]
 
-    def query_measurements(self, odata_query: str) -> Iterable[PublishedMeasurement]:
+    def query_measurements(self, odata_query: str = "") -> Sequence[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)
@@ -271,32 +313,52 @@ class DataStoreClient:
             for published_measurement in query_response.published_measurements
         ]
 
-    def query_steps(self, odata_query: str) -> Iterable[Step]:
+    def query_test_results(self, odata_query: str = "") -> Sequence[TestResult]:
+        """Query test results from the data store."""
+        query_request = QueryTestResultsRequest(odata_query=odata_query)
+        query_response = self._get_data_store_client().query_test_results(query_request)
+        return [
+            TestResult.from_protobuf(test_result) for test_result in query_response.test_results
+        ]
+
+    def query_steps(self, odata_query: str = "") -> Sequence[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._closed:
+            raise RuntimeError(self._DATA_STORE_CLIENT_CLOSED_ERROR)
+
         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,
-                    )
+                    self._data_store_client = self._instantiate_data_store_client()
         return self._data_store_client
 
+    def _instantiate_data_store_client(self) -> DataStoreServiceClient:
+        return DataStoreServiceClient(
+            discovery_client=self._discovery_client,
+            grpc_channel=self._grpc_channel,
+            grpc_channel_pool=self._grpc_channel_pool,
+        )
+
     def _get_moniker_client(self, service_location: str) -> MonikerClient:
+        if self._closed:
+            raise RuntimeError(self._DATA_STORE_CLIENT_CLOSED_ERROR)
+
         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,
-                        )
+                        self._instantiate_moniker_client(parsed_service_location)
                     )
         return self._moniker_clients_by_service_location[parsed_service_location]
+
+    def _instantiate_moniker_client(self, parsed_service_location: str) -> MonikerClient:
+        return MonikerClient(
+            service_location=parsed_service_location,
+            grpc_channel_pool=self._grpc_channel_pool,
+        )

{ni_datastore-0.1.0.dev2 → ni_datastore-0.1.0.dev4}/src/ni/datastore/data/_grpc_conversion.py

@@ -44,11 +44,16 @@ from ni.protobuf.types.waveform_pb2 import (
     I16AnalogWaveform,
     I16ComplexWaveform,
 )
+from ni.protobuf.types.xydata_conversion import (
+    float64_xydata_from_protobuf,
+    float64_xydata_to_protobuf,
+)
 from ni.protobuf.types.xydata_pb2 import DoubleXYData
 from nitypes.complex import ComplexInt32DType
 from nitypes.scalar import Scalar
 from nitypes.vector import Vector
 from nitypes.waveform import AnalogWaveform, ComplexWaveform, DigitalWaveform, Spectrum
+from nitypes.xy_data import XYData
 
 _logger = logging.getLogger(__name__)
 
@@ -137,6 +142,11 @@ 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, XYData):
+        if value.dtype == np.float64:
+            publish_request.x_y_data.CopyFrom(float64_xydata_to_protobuf(value))
+        else:
+            raise TypeError(f"Unsupported XYData dtype: {value.dtype}")
     elif isinstance(value, Iterable):
         if not value:
             raise ValueError("Cannot publish an empty Iterable.")
@@ -152,7 +162,6 @@ def populate_publish_measurement_request_value(
         raise TypeError(
             f"Unsupported measurement value type: {type(value)}. Please consult the documentation."
         )
-    # TODO: Implement conversion from proper XYData type
 
 
 def populate_publish_measurement_batch_request_values(
@@ -208,10 +217,7 @@ def unpack_and_convert_from_protobuf_any(read_value: Any) -> object:
     elif value_type == DoubleXYData.DESCRIPTOR.full_name:
         xydata = DoubleXYData()
         read_value.Unpack(xydata)
-        _logger.warning(
-            "DoubleXYData conversion is not yet implemented. Returning the raw protobuf object."
-        )
-        return xydata
+        return float64_xydata_from_protobuf(xydata)
     elif value_type == VectorProto.DESCRIPTOR.full_name:
         vector = VectorProto()
         read_value.Unpack(vector)

{ni_datastore-0.1.0.dev2 → ni_datastore-0.1.0.dev4}/src/ni/datastore/data/_types/_published_condition.py

@@ -13,7 +13,7 @@ class PublishedCondition:
 
     __slots__ = (
         "moniker",
-        "published_condition_id",
+        "id",
         "condition_name",
         "condition_type",
         "step_id",
@@ -24,7 +24,7 @@ class PublishedCondition:
         self,
         *,
         moniker: Moniker | None = None,
-        published_condition_id: str = "",
+        id: str = "",
         condition_name: str = "",
         condition_type: str = "",
         step_id: str = "",
@@ -32,7 +32,7 @@ class PublishedCondition:
     ) -> None:
         """Initialize a PublishedCondition instance."""
         self.moniker = moniker
-        self.published_condition_id = published_condition_id
+        self.id = id
         self.condition_name = condition_name
         self.condition_type = condition_type
         self.step_id = step_id
@@ -47,7 +47,7 @@ class PublishedCondition:
                 if published_condition_proto.HasField("moniker")
                 else None
             ),
-            published_condition_id=published_condition_proto.published_condition_id,
+            id=published_condition_proto.id,
             condition_name=published_condition_proto.condition_name,
             condition_type=published_condition_proto.condition_type,
             step_id=published_condition_proto.step_id,
@@ -58,7 +58,7 @@ class PublishedCondition:
         """Convert this PublishedCondition instance to a protobuf PublishedCondition message."""
         return PublishedConditionProto(
             moniker=self.moniker,
-            published_condition_id=self.published_condition_id,
+            id=self.id,
             condition_name=self.condition_name,
             condition_type=self.condition_type,
             step_id=self.step_id,
@@ -71,7 +71,7 @@ class PublishedCondition:
             return NotImplemented
         return (
             self.moniker == other.moniker
-            and self.published_condition_id == other.published_condition_id
+            and self.id == other.id
             and self.condition_name == other.condition_name
             and self.condition_type == other.condition_type
             and self.step_id == other.step_id

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Iterable
+from typing import Iterable, MutableSequence
 
 import hightime as ht
 from ni.datamonikers.v1.data_moniker_pb2 import Moniker
@@ -23,13 +23,13 @@ class PublishedMeasurement:
 
     __slots__ = (
         "moniker",
-        "published_conditions",
-        "published_measurement_id",
+        "_published_conditions",
+        "id",
         "test_result_id",
         "step_id",
-        "software_item_ids",
-        "hardware_item_ids",
-        "test_adapter_ids",
+        "_software_item_ids",
+        "_hardware_item_ids",
+        "_test_adapter_ids",
         "measurement_name",
         "data_type",
         "measurement_notes",
@@ -40,12 +40,32 @@ class PublishedMeasurement:
         "error_information",
     )
 
+    @property
+    def published_conditions(self) -> MutableSequence[PublishedCondition]:
+        """The published conditions associated with the published measurement."""
+        return self._published_conditions
+
+    @property
+    def software_item_ids(self) -> MutableSequence[str]:
+        """The software item IDs associated with the published measurement."""
+        return self._software_item_ids
+
+    @property
+    def hardware_item_ids(self) -> MutableSequence[str]:
+        """The hardware item IDs associated with the published measurement."""
+        return self._hardware_item_ids
+
+    @property
+    def test_adapter_ids(self) -> MutableSequence[str]:
+        """The test adapter IDs associated with the published measurement."""
+        return self._test_adapter_ids
+
     def __init__(
         self,
         *,
         moniker: Moniker | None = None,
         published_conditions: Iterable[PublishedCondition] | None = None,
-        published_measurement_id: str = "",
+        id: str = "",
         test_result_id: str = "",
         step_id: str = "",
         software_item_ids: Iterable[str] | None = None,
@@ -62,20 +82,20 @@ class PublishedMeasurement:
     ) -> None:
         """Initialize a PublishedMeasurement instance."""
         self.moniker = moniker
-        self.published_conditions: Iterable[PublishedCondition] = (
-            published_conditions if published_conditions is not None else []
+        self._published_conditions: MutableSequence[PublishedCondition] = (
+            list(published_conditions) if published_conditions is not None else []
         )
-        self.published_measurement_id = published_measurement_id
+        self.id = id
         self.test_result_id = test_result_id
         self.step_id = step_id
-        self.software_item_ids: Iterable[str] = (
-            software_item_ids if software_item_ids is not None else []
+        self._software_item_ids: MutableSequence[str] = (
+            list(software_item_ids) if software_item_ids is not None else []
         )
-        self.hardware_item_ids: Iterable[str] = (
-            hardware_item_ids if hardware_item_ids is not None else []
+        self._hardware_item_ids: MutableSequence[str] = (
+            list(hardware_item_ids) if hardware_item_ids is not None else []
         )
-        self.test_adapter_ids: Iterable[str] = (
-            test_adapter_ids if test_adapter_ids is not None else []
+        self._test_adapter_ids: MutableSequence[str] = (
+            list(test_adapter_ids) if test_adapter_ids is not None else []
         )
         self.measurement_name = measurement_name
         self.data_type = data_type
@@ -101,7 +121,7 @@ class PublishedMeasurement:
                 PublishedCondition.from_protobuf(cond)
                 for cond in published_measurement_proto.published_conditions
             ],
-            published_measurement_id=published_measurement_proto.published_measurement_id,
+            id=published_measurement_proto.id,
             test_result_id=published_measurement_proto.test_result_id,
             step_id=published_measurement_proto.step_id,
             software_item_ids=published_measurement_proto.software_item_ids,
@@ -136,7 +156,7 @@ class PublishedMeasurement:
             published_conditions=[
                 condition.to_protobuf() for condition in self.published_conditions
             ],
-            published_measurement_id=self.published_measurement_id,
+            id=self.id,
             test_result_id=self.test_result_id,
             step_id=self.step_id,
             software_item_ids=self.software_item_ids,
@@ -166,13 +186,13 @@ class PublishedMeasurement:
             return NotImplemented
         return (
             self.moniker == other.moniker
-            and list(self.published_conditions) == list(other.published_conditions)
-            and self.published_measurement_id == other.published_measurement_id
+            and self.published_conditions == other.published_conditions
+            and self.id == other.id
             and self.test_result_id == other.test_result_id
             and self.step_id == other.step_id
-            and list(self.software_item_ids) == list(other.software_item_ids)
-            and list(self.hardware_item_ids) == list(other.hardware_item_ids)
-            and list(self.test_adapter_ids) == list(other.test_adapter_ids)
+            and self.software_item_ids == other.software_item_ids
+            and self.hardware_item_ids == other.hardware_item_ids
+            and self.test_adapter_ids == other.test_adapter_ids
             and self.measurement_name == other.measurement_name
             and self.data_type == other.data_type
             and self.measurement_notes == other.measurement_notes

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 import hightime as ht
 from ni.datastore.metadata._grpc_conversion import (
@@ -22,7 +22,7 @@ class Step:
     """Information about a step into which measurements and conditions are published."""
 
     __slots__ = (
-        "step_id",
+        "id",
         "parent_step_id",
         "test_result_id",
         "test_id",
@@ -32,7 +32,7 @@ class Step:
         "_start_date_time",
         "_end_date_time",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
@@ -46,10 +46,15 @@ class Step:
         """Get the end date and time of the step execution."""
         return self._end_date_time
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the step."""
+        return self._extensions
+
     def __init__(
         self,
         *,
-        step_id: str = "",
+        id: str = "",
         parent_step_id: str = "",
         test_result_id: str = "",
         test_id: str = "",
@@ -57,11 +62,11 @@ class Step:
         step_type: str = "",
         notes: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a Step instance."""
-        self.step_id = step_id
+        self.id = id
         self.parent_step_id = parent_step_id
         self.test_result_id = test_result_id
         self.test_id = test_id
@@ -69,7 +74,9 @@ class Step:
         self.step_type = step_type
         self.notes = notes
         self.link = link
-        self.extensions: MutableMapping[str, str] = extensions if extensions is not None else {}
+        self._extensions: MutableMapping[str, str] = (
+            dict(extensions) if extensions is not None else {}
+        )
         self.schema_id = schema_id
 
         self._start_date_time: ht.datetime | None = None
@@ -79,7 +86,7 @@ class Step:
     def from_protobuf(step_proto: StepProto) -> "Step":
         """Create a Step instance from a protobuf Step message."""
         step = Step(
-            step_id=step_proto.step_id,
+            id=step_proto.id,
             parent_step_id=step_proto.parent_step_id,
             test_result_id=step_proto.test_result_id,
             test_id=step_proto.test_id,
@@ -105,7 +112,7 @@ class Step:
     def to_protobuf(self) -> StepProto:
         """Convert this Step to a protobuf Step message."""
         step_proto = StepProto(
-            step_id=self.step_id,
+            id=self.id,
             parent_step_id=self.parent_step_id,
             test_result_id=self.test_result_id,
             test_id=self.test_id,
@@ -131,7 +138,7 @@ class Step:
         if not isinstance(other, Step):
             return NotImplemented
         return (
-            self.step_id == other.step_id
+            self.id == other.id
             and self.parent_step_id == other.parent_step_id
             and self.test_result_id == other.test_result_id
             and self.test_id == other.test_id