ni.datastore 0.1.0.dev2__tar.gz → 0.1.0.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ni.datastore
-Version: 0.1.0.dev2
+Version: 0.1.0.dev3
 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.dev1)
+Requires-Dist: ni-measurements-metadata-v1-client (>=0.1.0.dev1)
+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.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ni.datastore"
-version = "0.1.0-dev2"
+version = "0.1.0-dev3"
 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.dev1", allow-prereleases = true }
+ni-measurements-metadata-v1-client = { version = ">=0.1.0.dev1", 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.dev3}/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
@@ -48,6 +50,12 @@ from ni.protobuf.types.precision_timestamp_conversion import (
 )
 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 +65,7 @@ class DataStoreClient:
     """Data store client for publishing and reading data."""
 
     __slots__ = (
+        "_closed",
         "_discovery_client",
         "_grpc_channel",
         "_grpc_channel_pool",
@@ -66,6 +75,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 +114,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 +215,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 +294,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 +303,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 +312,44 @@ class DataStoreClient:
             for published_measurement in query_response.published_measurements
         ]
 
-    def query_steps(self, odata_query: str) -> Iterable[Step]:
+    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.dev3}/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.dev3}/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_conditions",
         "published_measurement_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,6 +40,26 @@ 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,
         *,
@@ -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.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
@@ -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_conditions == other.published_conditions
             and self.published_measurement_id == other.published_measurement_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.dev3}/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 (
@@ -32,7 +32,7 @@ class Step:
         "_start_date_time",
         "_end_date_time",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
@@ -46,6 +46,11 @@ 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,
         *,
@@ -57,7 +62,7 @@ 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."""
@@ -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

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Iterable, MutableMapping
+from typing import Iterable, Mapping, MutableMapping, MutableSequence
 
 import hightime as ht
 from ni.datastore.metadata._grpc_conversion import (
@@ -28,15 +28,15 @@ class TestResult:
         "operator_id",
         "test_station_id",
         "test_description_id",
-        "software_item_ids",
-        "hardware_item_ids",
-        "test_adapter_ids",
+        "_software_item_ids",
+        "_hardware_item_ids",
+        "_test_adapter_ids",
         "test_result_name",
         "_start_date_time",
         "_end_date_time",
         "_outcome",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
@@ -55,6 +55,26 @@ class TestResult:
         """Get the outcome of the test execution."""
         return self._outcome
 
+    @property
+    def software_item_ids(self) -> MutableSequence[str]:
+        """The software item IDs associated with the test result."""
+        return self._software_item_ids
+
+    @property
+    def hardware_item_ids(self) -> MutableSequence[str]:
+        """The hardware item IDs associated with the test result."""
+        return self._hardware_item_ids
+
+    @property
+    def test_adapter_ids(self) -> MutableSequence[str]:
+        """The test adapter IDs associated with the test result."""
+        return self._test_adapter_ids
+
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the test result."""
+        return self._extensions
+
     def __init__(
         self,
         *,
@@ -68,7 +88,7 @@ class TestResult:
         test_adapter_ids: Iterable[str] | None = None,
         test_result_name: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a TestResult instance."""
@@ -77,18 +97,20 @@ class TestResult:
         self.operator_id = operator_id
         self.test_station_id = test_station_id
         self.test_description_id = test_description_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.test_result_name = test_result_name
         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
@@ -164,9 +186,9 @@ class TestResult:
             and self.operator_id == other.operator_id
             and self.test_station_id == other.test_station_id
             and self.test_description_id == other.test_description_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.test_result_name == other.test_result_name
             and self.start_date_time == other.start_date_time
             and self.end_date_time == other.end_date_time

{ni_datastore-0.1.0.dev2 → ni_datastore-0.1.0.dev3}/src/ni/datastore/metadata/_metadata_store_client.py

@@ -3,9 +3,12 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Iterable
+import sys
+from collections.abc import Sequence
 from pathlib import Path
 from threading import Lock
+from types import TracebackType
+from typing import TYPE_CHECKING
 
 from grpc import Channel
 from ni.datastore.metadata._types._alias import Alias
@@ -20,7 +23,9 @@ 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.metadata.v1.client import MetadataStoreClient as MetadataStoreServiceClient
+from ni.measurements.metadata.v1.client import (
+    MetadataStoreClient as MetadataStoreServiceClient,
+)
 from ni.measurements.metadata.v1.metadata_store_service_pb2 import (
     CreateAliasRequest,
     CreateHardwareItemRequest,
@@ -58,6 +63,12 @@ from ni.measurements.metadata.v1.metadata_store_service_pb2 import (
 )
 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
+
 _logger = logging.getLogger(__name__)
 
 
@@ -65,6 +76,7 @@ class MetadataStoreClient:
     """Metadata store client for publishing and reading metadata."""
 
     __slots__ = (
+        "_closed",
         "_discovery_client",
         "_grpc_channel",
         "_grpc_channel_pool",
@@ -72,6 +84,9 @@ class MetadataStoreClient:
         "_metadata_store_client_lock",
     )
 
+    _METADATA_STORE_CLIENT_CLOSED_ERROR = "This MetadataStoreClient has been closed. Create a new MetadataStoreClient for further interaction with the metadata store."
+
+    _closed: bool
     _discovery_client: DiscoveryClient | None
     _grpc_channel: Channel | None
     _grpc_channel_pool: GrpcChannelPool | None
@@ -101,6 +116,30 @@ class MetadataStoreClient:
         self._metadata_store_client = None
         self._metadata_store_client_lock = Lock()
 
+        self._closed = False
+
+    def __enter__(self) -> Self:
+        """Enter the runtime context of the metadata 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 metadata store client."""
+        self.close()
+
+    def close(self) -> None:
+        """Close the metadata store client and clean up resources that it owns."""
+        self._closed = True
+
+        with self._metadata_store_client_lock:
+            if self._metadata_store_client is not None:
+                self._metadata_store_client.close()
+                self._metadata_store_client = None
+
     def create_uut_instance(self, uut_instance: UutInstance) -> str:
         """Create a UUT instance in the metadata store."""
         create_request = CreateUutInstanceRequest(uut_instance=uut_instance.to_protobuf())
@@ -113,7 +152,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_uut_instance(get_request)
         return UutInstance.from_protobuf(get_response.uut_instance)
 
-    def query_uut_instances(self, odata_query: str) -> Iterable[UutInstance]:
+    def query_uut_instances(self, odata_query: str = "") -> Sequence[UutInstance]:
         """Query UUT instances from the metadata store."""
         query_request = QueryUutInstancesRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_uut_instances(query_request)
@@ -133,7 +172,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_uut(get_request)
         return Uut.from_protobuf(get_response.uut)
 
-    def query_uuts(self, odata_query: str) -> Iterable[Uut]:
+    def query_uuts(self, odata_query: str = "") -> Sequence[Uut]:
         """Query UUTs from the metadata store."""
         query_request = QueryUutsRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_uuts(query_request)
@@ -151,7 +190,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_operator(get_request)
         return Operator.from_protobuf(get_response.operator)
 
-    def query_operators(self, odata_query: str) -> Iterable[Operator]:
+    def query_operators(self, odata_query: str = "") -> Sequence[Operator]:
         """Query operators from the metadata store."""
         query_request = QueryOperatorsRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_operators(query_request)
@@ -171,7 +210,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_test_description(get_request)
         return TestDescription.from_protobuf(get_response.test_description)
 
-    def query_test_descriptions(self, odata_query: str) -> Iterable[TestDescription]:
+    def query_test_descriptions(self, odata_query: str = "") -> Sequence[TestDescription]:
         """Query test descriptions from the metadata store."""
         query_request = QueryTestDescriptionsRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_test_descriptions(query_request)
@@ -192,7 +231,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_test(get_request)
         return Test.from_protobuf(get_response.test)
 
-    def query_tests(self, odata_query: str) -> Iterable[Test]:
+    def query_tests(self, odata_query: str = "") -> Sequence[Test]:
         """Query tests from the metadata store."""
         query_request = QueryTestsRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_tests(query_request)
@@ -210,7 +249,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_test_station(get_request)
         return TestStation.from_protobuf(get_response.test_station)
 
-    def query_test_stations(self, odata_query: str) -> Iterable[TestStation]:
+    def query_test_stations(self, odata_query: str = "") -> Sequence[TestStation]:
         """Query test stations from the metadata store."""
         query_request = QueryTestStationsRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_test_stations(query_request)
@@ -230,7 +269,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_hardware_item(get_request)
         return HardwareItem.from_protobuf(get_response.hardware_item)
 
-    def query_hardware_items(self, odata_query: str) -> Iterable[HardwareItem]:
+    def query_hardware_items(self, odata_query: str = "") -> Sequence[HardwareItem]:
         """Query hardware items from the metadata store."""
         query_request = QueryHardwareItemsRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_hardware_items(query_request)
@@ -251,7 +290,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_software_item(get_request)
         return SoftwareItem.from_protobuf(get_response.software_item)
 
-    def query_software_items(self, odata_query: str) -> Iterable[SoftwareItem]:
+    def query_software_items(self, odata_query: str = "") -> Sequence[SoftwareItem]:
         """Query software items from the metadata store."""
         query_request = QuerySoftwareItemsRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_software_items(query_request)
@@ -272,7 +311,7 @@ class MetadataStoreClient:
         get_response = self._get_metadata_store_client().get_test_adapter(get_request)
         return TestAdapter.from_protobuf(get_response.test_adapter)
 
-    def query_test_adapters(self, odata_query: str) -> Iterable[TestAdapter]:
+    def query_test_adapters(self, odata_query: str = "") -> Sequence[TestAdapter]:
         """Query test adapters from the metadata store."""
         query_request = QueryTestAdaptersRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_test_adapters(query_request)
@@ -308,7 +347,7 @@ class MetadataStoreClient:
         register_response = self._get_metadata_store_client().register_schema(register_request)
         return register_response.schema_id
 
-    def list_schemas(self) -> Iterable[ExtensionSchema]:
+    def list_schemas(self) -> Sequence[ExtensionSchema]:
         """List all schemas in the metadata store."""
         list_request = ListSchemasRequest()
         list_response = self._get_metadata_store_client().list_schemas(list_request)
@@ -364,19 +403,25 @@ class MetadataStoreClient:
         delete_response = self._get_metadata_store_client().delete_alias(delete_request)
         return delete_response.unregistered
 
-    def query_aliases(self, odata_query: str) -> Iterable[Alias]:
+    def query_aliases(self, odata_query: str = "") -> Sequence[Alias]:
         """Query aliases from the metadata store."""
         query_request = QueryAliasesRequest(odata_query=odata_query)
         query_response = self._get_metadata_store_client().query_aliases(query_request)
         return [Alias.from_protobuf(alias) for alias in query_response.aliases]
 
     def _get_metadata_store_client(self) -> MetadataStoreServiceClient:
+        if self._closed:
+            raise RuntimeError(self._METADATA_STORE_CLIENT_CLOSED_ERROR)
+
         if self._metadata_store_client is None:
             with self._metadata_store_client_lock:
                 if self._metadata_store_client is None:
-                    self._metadata_store_client = MetadataStoreServiceClient(
-                        discovery_client=self._discovery_client,
-                        grpc_channel=self._grpc_channel,
-                        grpc_channel_pool=self._grpc_channel_pool,
-                    )
+                    self._metadata_store_client = self._instantiate_metadata_store_client()
         return self._metadata_store_client
+
+    def _instantiate_metadata_store_client(self) -> MetadataStoreServiceClient:
+        return MetadataStoreServiceClient(
+            discovery_client=self._discovery_client,
+            grpc_channel=self._grpc_channel,
+            grpc_channel_pool=self._grpc_channel_pool,
+        )

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -24,10 +24,15 @@ class HardwareItem:
         "asset_identifier",
         "calibration_due_date",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the hardware item."""
+        return self._extensions
+
     def __init__(
         self,
         *,
@@ -38,7 +43,7 @@ class HardwareItem:
         asset_identifier: str = "",
         calibration_due_date: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a HardwareItem instance."""
@@ -49,7 +54,9 @@ class HardwareItem:
         self.asset_identifier = asset_identifier
         self.calibration_due_date = calibration_due_date
         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
 
     @staticmethod

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -20,24 +20,31 @@ class Operator:
         "operator_name",
         "role",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the operator."""
+        return self._extensions
+
     def __init__(
         self,
         *,
         operator_name: str = "",
         role: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize an Operator instance."""
         self.operator_name = operator_name
         self.role = role
         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
 
     @staticmethod

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -20,24 +20,31 @@ class SoftwareItem:
         "product",
         "version",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the software item."""
+        return self._extensions
+
     def __init__(
         self,
         *,
         product: str = "",
         version: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a SoftwareItem instance."""
         self.product = product
         self.version = version
         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
 
     @staticmethod

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -20,24 +20,31 @@ class Test:
         "test_name",
         "description",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the test."""
+        return self._extensions
+
     def __init__(
         self,
         *,
         test_name: str = "",
         description: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a Test instance."""
         self.test_name = test_name
         self.description = description
         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
 
     @staticmethod

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -25,10 +25,15 @@ class TestAdapter:
         "asset_identifier",
         "calibration_due_date",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the test adapter."""
+        return self._extensions
+
     def __init__(
         self,
         *,
@@ -40,7 +45,7 @@ class TestAdapter:
         asset_identifier: str = "",
         calibration_due_date: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a TestAdapter instance."""
@@ -52,7 +57,9 @@ class TestAdapter:
         self.asset_identifier = asset_identifier
         self.calibration_due_date = calibration_due_date
         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
 
     @staticmethod

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -20,24 +20,31 @@ class TestDescription:
         "uut_id",
         "test_description_name",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the test description."""
+        return self._extensions
+
     def __init__(
         self,
         *,
         uut_id: str = "",
         test_description_name: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a TestDescription instance."""
         self.uut_id = uut_id
         self.test_description_name = test_description_name
         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
 
     @staticmethod

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -20,24 +20,31 @@ class TestStation:
         "test_station_name",
         "asset_identifier",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the test station."""
+        return self._extensions
+
     def __init__(
         self,
         *,
         test_station_name: str = "",
         asset_identifier: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a TestStation instance."""
         self.test_station_name = test_station_name
         self.asset_identifier = asset_identifier
         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
 
     @staticmethod

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Iterable, MutableMapping
+from typing import Iterable, Mapping, MutableMapping, MutableSequence
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -19,13 +19,23 @@ class Uut:
     __slots__ = (
         "model_name",
         "family",
-        "manufacturers",
+        "_manufacturers",
         "part_number",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def manufacturers(self) -> MutableSequence[str]:
+        """The manufacturers of the UUT."""
+        return self._manufacturers
+
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the UUT."""
+        return self._extensions
+
     def __init__(
         self,
         *,
@@ -34,16 +44,20 @@ class Uut:
         manufacturers: Iterable[str] | None = None,
         part_number: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a Uut instance."""
         self.model_name = model_name
         self.family = family
-        self.manufacturers: Iterable[str] = manufacturers if manufacturers is not None else []
+        self._manufacturers: MutableSequence[str] = (
+            list(manufacturers) if manufacturers is not None else []
+        )
         self.part_number = part_number
         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
 
     @staticmethod
@@ -80,7 +94,7 @@ class Uut:
         return (
             self.model_name == other.model_name
             and self.family == other.family
-            and list(self.manufacturers) == list(other.manufacturers)
+            and self.manufacturers == other.manufacturers
             and self.part_number == other.part_number
             and self.link == other.link
             and self.extensions == other.extensions

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import Mapping, MutableMapping
 
 from ni.datastore.metadata._grpc_conversion import (
     populate_extension_value_message_map,
@@ -23,10 +23,15 @@ class UutInstance:
         "firmware_version",
         "hardware_version",
         "link",
-        "extensions",
+        "_extensions",
         "schema_id",
     )
 
+    @property
+    def extensions(self) -> MutableMapping[str, str]:
+        """The extensions of the UUT instance."""
+        return self._extensions
+
     def __init__(
         self,
         *,
@@ -36,7 +41,7 @@ class UutInstance:
         firmware_version: str = "",
         hardware_version: str = "",
         link: str = "",
-        extensions: MutableMapping[str, str] | None = None,
+        extensions: Mapping[str, str] | None = None,
         schema_id: str = "",
     ) -> None:
         """Initialize a UutInstance instance."""
@@ -46,7 +51,9 @@ class UutInstance:
         self.firmware_version = firmware_version
         self.hardware_version = hardware_version
         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
 
     @staticmethod