ni.datastore 0.1.0.dev5__tar.gz → 0.1.0.dev6__tar.gz

{ni_datastore-0.1.0.dev5 → ni_datastore-0.1.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ni.datastore
-Version: 0.1.0.dev5
+Version: 0.1.0.dev6
 Summary: APIs for publishing and retrieving data from NI Measurement Data Services
 License: MIT
 Keywords: datastore
@@ -25,8 +25,8 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: hightime (>=0.3.0.dev0)
 Requires-Dist: ni-datamonikers-v1-client (>=0.1.0.dev1)
-Requires-Dist: ni-measurements-data-v1-client (>=0.2.0.dev1)
-Requires-Dist: ni-measurements-metadata-v1-client (>=0.2.0.dev1)
+Requires-Dist: ni-measurements-data-v1-client (>=0.2.0.dev4)
+Requires-Dist: ni-measurements-metadata-v1-client (>=0.2.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.dev5 → ni_datastore-0.1.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ni.datastore"
-version = "0.1.0.dev5"
+version = "0.1.0.dev6"
 license = "MIT"
 description = "APIs for publishing and retrieving data from NI Measurement Data Services"
 authors = [{name = "NI", email = "opensource@ni.com"}]
@@ -38,8 +38,8 @@ requires-poetry = '>=2.1,<3.0'
 python = "^3.10"
 protobuf = {version=">=4.21"}
 ni-datamonikers-v1-client = { version = ">=0.1.0.dev1", allow-prereleases = true }
-ni-measurements-data-v1-client = { version = ">=0.2.0.dev1", allow-prereleases = true }
-ni-measurements-metadata-v1-client = { version = ">=0.2.0.dev1", allow-prereleases = true }
+ni-measurements-data-v1-client = { version = ">=0.2.0.dev4", allow-prereleases = true }
+ni-measurements-metadata-v1-client = { version = ">=0.2.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 }
 
@@ -50,7 +50,7 @@ ipykernel = ">=6.0"
 plotly = ">=5.0"
 nbformat = ">=4.2.0"
 ipython = ">=7.0"
-jupyter = ">=1.0" 
+jupyter = ">=1.0"
 
 [tool.poetry.group.lint.dependencies]
 bandit = { version = ">=1.7", extras = ["toml"] }
@@ -92,7 +92,7 @@ skips = [
 extend_exclude = "docs,examples"
 
 [tool.black]
-extend-exclude = 'docs/|_pb2(_grpc)?\.(py|pyi)$'
+extend-exclude = 'docs/|examples/|_pb2(_grpc)?\.(py|pyi)$'
 line-length = 100
 
 [tool.mypy]
@@ -101,7 +101,7 @@ files = "."
 namespace_packages = true
 strict = true
 explicit_package_bases = true
-exclude = ["docs"]
+exclude = ["docs", "examples"]
 
 [tool.pyright]
 include = ["src/", "tests/"]

{ni_datastore-0.1.0.dev5 → ni_datastore-0.1.0.dev6}/src/ni/datastore/data/_data_store_client.py

@@ -33,6 +33,8 @@ from ni.measurements.data.v1.client import DataStoreClient as DataStoreServiceCl
 from ni.measurements.data.v1.data_store_service_pb2 import (
     CreateStepRequest,
     CreateTestResultRequest,
+    GetConditionRequest,
+    GetMeasurementRequest,
     GetStepRequest,
     GetTestResultRequest,
     PublishConditionBatchRequest,
@@ -74,7 +76,10 @@ 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."
+    _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
@@ -144,18 +149,18 @@ class DataStoreClient:
 
     def publish_condition(
         self,
-        condition_name: str,
-        type: str,
+        name: str,
+        condition_type: str,
         value: object,
         step_id: str,
-    ) -> PublishedCondition:
+    ) -> str:
         """Publish a condition value to the data store.
 
         Args:
-            condition_name: An identifier describing the condition value.
+            name: An identifier describing the condition value.
                 For example, "Voltage" or "Temperature".
 
-            type: The type of this condition. For example, "Upper Limit",
+            condition_type: The type of this condition. For example, "Upper Limit",
                 "Environment", or "Setup".
 
             value: The single value for this condition to publish on the test
@@ -166,32 +171,28 @@ class DataStoreClient:
                 value is expected to be a parsable GUID.
 
         Returns:
-            PublishedCondition: The published condition containing:
-                - A moniker for retrieving the condition data (returns a
-                  Vector)
-                - The unique ID of the condition for referencing in queries
-                - Metadata including condition name, type, step ID and test
-                  result ID
+            str: The condition id - the unique ID of the condition for
+                referencing in queries
         """
         publish_request = PublishConditionRequest(
-            condition_name=condition_name,
-            type=type,
+            name=name,
+            condition_type=condition_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)
+        return publish_response.condition_id
 
     def publish_condition_batch(
-        self, condition_name: str, type: str, values: object, step_id: str
-    ) -> PublishedCondition:
+        self, name: str, condition_type: str, values: object, step_id: str
+    ) -> str:
         """Publish a batch of N values for a condition to the data store.
 
         Args:
-            condition_name: An identifier describing the condition values.
+            name: An identifier describing the condition values.
                 For example, "Voltage" or "Temperature".
 
-            type: The type of this condition. For example, "Upper Limit",
+            condition_type: The type of this condition. For example, "Upper Limit",
                 "Environment", or "Setup".
 
             values: The values for this condition across all publishes on the
@@ -201,27 +202,21 @@ class DataStoreClient:
                 values. This value is expected to be a parsable GUID.
 
         Returns:
-            PublishedCondition: Represents all the values published with
-                this call, containing:
-
-                - A moniker for retrieving the condition data (returns a
-                  Vector)
-                - The unique ID of the condition for referencing in queries
-                - Metadata including condition name, type, step ID and test
-                  result ID
+            str: The condition id - the unique ID of the condition for
+                referencing in queries
         """
         publish_request = PublishConditionBatchRequest(
-            condition_name=condition_name,
-            type=type,
+            name=name,
+            condition_type=condition_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)
+        return publish_response.condition_id
 
     def publish_measurement(
         self,
-        measurement_name: str,
+        name: str,
         value: object,  # More strongly typed Union[bool, AnalogWaveform] can be used if needed
         step_id: str,
         timestamp: ht.datetime | None = None,
@@ -231,11 +226,11 @@ class DataStoreClient:
         test_adapter_ids: Iterable[str] = tuple(),
         software_item_ids: Iterable[str] = tuple(),
         notes: str = "",
-    ) -> PublishedMeasurement:
+    ) -> str:
         """Publish a single measurement value associated with a test step.
 
         Args:
-            measurement_name: The name used for associating/grouping
+            name: The name used for associating/grouping
                 conceptually alike measurements across multiple publish
                 iterations. For example, "Temperature" can be used for
                 associating temperature readings across multiple iterations.
@@ -279,15 +274,10 @@ class DataStoreClient:
             notes: Any notes to be associated with the captured measurement.
 
         Returns:
-            PublishedMeasurement: The moniker of the published measurement and
-                its metadata, including:
-                - A moniker for retrieving the measurement data
-                - Associated conditions from the test step
-                - Measurement metadata (name, type, timestamps, outcome)
-                - Associated hardware, software, and test adapter IDs
+            str: The published measurement id.
         """
         publish_request = PublishMeasurementRequest(
-            measurement_name=measurement_name,
+            name=name,
             step_id=step_id,
             outcome=outcome.to_protobuf(),
             error_information=(
@@ -303,11 +293,11 @@ class DataStoreClient:
             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)
+        return publish_response.measurement_id
 
     def publish_measurement_batch(
         self,
-        measurement_name: str,
+        name: str,
         values: object,
         step_id: str,
         timestamps: Iterable[ht.datetime] = tuple(),
@@ -317,11 +307,11 @@ class DataStoreClient:
         test_adapter_ids: Iterable[str] = tuple(),
         software_item_ids: Iterable[str] = tuple(),
         notes: str = "",
-    ) -> Sequence[PublishedMeasurement]:
+    ) -> Sequence[str]:
         """Publish multiple scalar measurements at once for parametric sweeps.
 
         Args:
-            measurement_name: The name used for associating/grouping
+            name: The name used for associating/grouping
                 conceptually alike measurements across multiple publish
                 iterations. For example, "Temperature" can be used for
                 associating temperature readings across multiple iterations.
@@ -362,14 +352,13 @@ class DataStoreClient:
             notes: Any notes to be associated with the published measurements.
 
         Returns:
-            Sequence[PublishedMeasurement]: The monikers of the published
-                measurements and their corresponding metadata. NOTE: Using
-                a Sequence is for future flexibility. This sequence
-                will currently always have a single PublishedMeasurement
+            Sequence[str]: The ids of the published measurement ids.
+                NOTE: Using a Sequence is for future flexibility.
+                This sequence will currently always have a single measurement id
                 returned.
         """
         publish_request = PublishMeasurementBatchRequest(
-            measurement_name=measurement_name,
+            name=name,
             step_id=step_id,
             timestamps=[hightime_datetime_to_protobuf(ts) for ts in timestamps],
             outcomes=[outcome.to_protobuf() for outcome in outcomes],
@@ -383,9 +372,7 @@ class DataStoreClient:
         )
         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
-        ]
+        return publish_response.measurement_ids
 
     @overload
     def read_data(
@@ -484,6 +471,32 @@ class DataStoreClient:
         get_response = self._get_data_store_client().get_step(get_request)
         return Step.from_protobuf(get_response.step)
 
+    def get_measurement(self, measurement_id: str) -> PublishedMeasurement:
+        """Get the measurement associated with the given identifier.
+
+        Args:
+            measurement_id: The identifier of the desired measurement.
+
+        Returns:
+            PublishedMeasurement: The metadata of the requested measurement.
+        """
+        get_request = GetMeasurementRequest(measurement_id=measurement_id)
+        get_response = self._get_data_store_client().get_measurement(get_request)
+        return PublishedMeasurement.from_protobuf(get_response.published_measurement)
+
+    def get_condition(self, condition_id: str) -> PublishedCondition:
+        """Get the condition associated with the given identifier.
+
+        Args:
+            condition_id: The identifier of the desired condition.
+
+        Returns:
+            PublishedCondition: The metadata of the requested condition.
+        """
+        get_request = GetConditionRequest(condition_id=condition_id)
+        get_response = self._get_data_store_client().get_condition(get_request)
+        return PublishedCondition.from_protobuf(get_response.published_condition)
+
     def create_test_result(self, test_result: TestResult) -> str:
         """Create a test result object for publishing measurements.
 

{ni_datastore-0.1.0.dev5 → ni_datastore-0.1.0.dev6}/src/ni/datastore/metadata/__init__.py

@@ -5,6 +5,7 @@ from ni.datastore.metadata._types._alias import Alias
 from ni.datastore.metadata._types._alias_target_type import AliasTargetType
 from ni.datastore.metadata._types._extension_schema import ExtensionSchema
 from ni.datastore.metadata._types._hardware_item import HardwareItem
+from ni.datastore.metadata._types._metadata_items import MetadataItems
 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
@@ -19,6 +20,7 @@ __all__ = [
     "AliasTargetType",
     "ExtensionSchema",
     "HardwareItem",
+    "MetadataItems",
     "MetadataStoreClient",
     "Operator",
     "SoftwareItem",
@@ -35,6 +37,7 @@ Alias.__module__ = __name__
 AliasTargetType.__module__ = __name__
 ExtensionSchema.__module__ = __name__
 HardwareItem.__module__ = __name__
+MetadataItems.__module__ = __name__
 MetadataStoreClient.__module__ = __name__
 Operator.__module__ = __name__
 SoftwareItem.__module__ = __name__

{ni_datastore-0.1.0.dev5 → ni_datastore-0.1.0.dev6}/src/ni/datastore/metadata/_metadata_store_client.py

@@ -14,6 +14,7 @@ from grpc import Channel
 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._metadata_items import MetadataItems
 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
@@ -28,6 +29,7 @@ from ni.measurements.metadata.v1.client import (
 )
 from ni.measurements.metadata.v1.metadata_store_service_pb2 import (
     CreateAliasRequest,
+    CreateFromJsonDocumentRequest,
     CreateHardwareItemRequest,
     CreateOperatorRequest,
     CreateSoftwareItemRequest,
@@ -84,7 +86,10 @@ 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."
+    _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
@@ -525,6 +530,34 @@ class MetadataStoreClient:
         list_response = self._get_metadata_store_client().list_schemas(list_request)
         return [ExtensionSchema.from_protobuf(schema) for schema in list_response.schemas]
 
+    def get_alias(self, alias_name: str) -> Alias:
+        """Get an alias and its target (the underlying metadata it represents).
+
+        Args:
+            alias_name: The name of the alias to retrieve.
+
+        Returns:
+            Alias: The alias containing the alias name, target type, and
+                target ID of the underlying metadata.
+        """
+        get_request = GetAliasRequest(alias_name=alias_name)
+        get_response = self._get_metadata_store_client().get_alias(get_request)
+        return Alias.from_protobuf(get_response.alias)
+
+    def query_aliases(self, odata_query: str = "") -> Sequence[Alias]:
+        """Perform an OData query on the registered aliases.
+
+        Args:
+            odata_query: An OData query string. Example: "$filter=name eq
+                'Value'". $expand is not supported.
+
+        Returns:
+            Sequence[Alias]: The list of aliases that match the query.
+        """
+        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 create_alias(
         self,
         alias_name: str,
@@ -580,20 +613,6 @@ class MetadataStoreClient:
         response = self._get_metadata_store_client().create_alias(create_request)
         return Alias.from_protobuf(response.alias)
 
-    def get_alias(self, alias_name: str) -> Alias:
-        """Get an alias and its target (the underlying metadata it represents).
-
-        Args:
-            alias_name: The name of the alias to retrieve.
-
-        Returns:
-            Alias: The alias containing the alias name, target type, and
-                target ID of the underlying metadata.
-        """
-        get_request = GetAliasRequest(alias_name=alias_name)
-        get_response = self._get_metadata_store_client().get_alias(get_request)
-        return Alias.from_protobuf(get_response.alias)
-
     def delete_alias(self, alias_name: str) -> bool:
         """Remove a registered alias.
 
@@ -608,19 +627,41 @@ class MetadataStoreClient:
         delete_response = self._get_metadata_store_client().delete_alias(delete_request)
         return delete_response.unregistered
 
-    def query_aliases(self, odata_query: str = "") -> Sequence[Alias]:
-        """Perform an OData query on the registered aliases.
+    def create_from_json_file(self, metadata_file_path: Path | str) -> MetadataItems:
+        """Create metadata items from a JSON file.
 
         Args:
-            odata_query: An OData query string. Example: "$filter=name eq
-                'Value'". $expand is not supported.
+            metadata_file_path: The path to the JSON file containing metadata definitions.
 
         Returns:
-            Sequence[Alias]: The list of aliases that match the query.
+            MetadataItems: A collection of metadata items created from the JSON document.
+
+        Raises:
+            FileNotFoundError: If the JSON file does not exist.
         """
-        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]
+        if isinstance(metadata_file_path, str):
+            metadata_file_path = Path(metadata_file_path)
+
+        if not metadata_file_path.exists():
+            raise FileNotFoundError(f"Metadata file not found: {metadata_file_path}")
+
+        metadata_contents = metadata_file_path.read_text(encoding="utf-8-sig")
+        return self.create_from_json(metadata_contents)
+
+    def create_from_json(self, metadata_file_contents: str) -> MetadataItems:
+        """Create metadata items from a JSON document.
+
+        Args:
+            metadata_file_contents: The JSON document content containing metadata definitions.
+
+        Returns:
+            MetadataItems: A collection of metadata items created from the JSON document.
+        """
+        create_request = CreateFromJsonDocumentRequest(json_document=metadata_file_contents)
+        create_response = self._get_metadata_store_client().create_from_json_document(
+            create_request
+        )
+        return MetadataItems.from_protobuf(create_response)
 
     def _get_metadata_store_client(self) -> MetadataStoreServiceClient:
         if self._closed:

ni_datastore-0.1.0.dev6/src/ni/datastore/metadata/_types/_metadata_items.py

@@ -0,0 +1,155 @@
+"""MetadataItems data type for the Data Store Client."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+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_service_pb2 import (
+    CreateFromJsonDocumentResponse,
+)
+
+
+class MetadataItems:
+    """Represents a collection of metadata items created from a JSON document.
+
+    This class contains the results of creating metadata items from a JSON document,
+    organizing them by type for easy access.
+    """
+
+    __slots__ = (
+        "uut_instances",
+        "uuts",
+        "operators",
+        "test_descriptions",
+        "tests",
+        "test_stations",
+        "hardware_items",
+        "software_items",
+        "test_adapters",
+    )
+
+    def __init__(
+        self,
+        *,
+        uut_instances: Sequence[UutInstance] = (),
+        uuts: Sequence[Uut] = (),
+        operators: Sequence[Operator] = (),
+        test_descriptions: Sequence[TestDescription] = (),
+        tests: Sequence[Test] = (),
+        test_stations: Sequence[TestStation] = (),
+        hardware_items: Sequence[HardwareItem] = (),
+        software_items: Sequence[SoftwareItem] = (),
+        test_adapters: Sequence[TestAdapter] = (),
+    ) -> None:
+        """Initialize a MetadataItems instance.
+
+        Args:
+            uut_instances: A sequence of UUT instances created from the JSON document.
+            uuts: A sequence of UUTs created from the JSON document.
+            operators: A sequence of operators created from the JSON document.
+            test_descriptions: A sequence of test descriptions created from the JSON document.
+            tests: A sequence of tests created from the JSON document.
+            test_stations: A sequence of test stations created from the JSON document.
+            hardware_items: A sequence of hardware items created from the JSON document.
+            software_items: A sequence of software items created from the JSON document.
+            test_adapters: A sequence of test adapters created from the JSON document.
+        """
+        self.uut_instances = uut_instances
+        self.uuts = uuts
+        self.operators = operators
+        self.test_descriptions = test_descriptions
+        self.tests = tests
+        self.test_stations = test_stations
+        self.hardware_items = hardware_items
+        self.software_items = software_items
+        self.test_adapters = test_adapters
+
+    @staticmethod
+    def from_protobuf(response: CreateFromJsonDocumentResponse) -> "MetadataItems":
+        """Create a MetadataItems instance from a protobuf CreateFromJsonDocumentResponse.
+
+        Args:
+            response: The protobuf response containing the created metadata items.
+
+        Returns:
+            MetadataItems: A new MetadataItems instance with all the created items.
+        """
+        return MetadataItems(
+            uut_instances=[
+                UutInstance.from_protobuf(uut_instance) for uut_instance in response.uut_instances
+            ],
+            uuts=[Uut.from_protobuf(uut) for uut in response.uuts],
+            operators=[Operator.from_protobuf(operator) for operator in response.operators],
+            test_descriptions=[
+                TestDescription.from_protobuf(test_description)
+                for test_description in response.test_descriptions
+            ],
+            tests=[Test.from_protobuf(test) for test in response.tests],
+            test_stations=[
+                TestStation.from_protobuf(test_station) for test_station in response.test_stations
+            ],
+            hardware_items=[
+                HardwareItem.from_protobuf(hardware_item)
+                for hardware_item in response.hardware_items
+            ],
+            software_items=[
+                SoftwareItem.from_protobuf(software_item)
+                for software_item in response.software_items
+            ],
+            test_adapters=[
+                TestAdapter.from_protobuf(test_adapter) for test_adapter in response.test_adapters
+            ],
+        )
+
+    def __eq__(self, other: object) -> bool:
+        """Determine equality between MetadataItems instances."""
+        if not isinstance(other, MetadataItems):
+            return False
+
+        return (
+            list(self.uut_instances) == list(other.uut_instances)
+            and list(self.uuts) == list(other.uuts)
+            and list(self.operators) == list(other.operators)
+            and list(self.test_descriptions) == list(other.test_descriptions)
+            and list(self.tests) == list(other.tests)
+            and list(self.test_stations) == list(other.test_stations)
+            and list(self.hardware_items) == list(other.hardware_items)
+            and list(self.software_items) == list(other.software_items)
+            and list(self.test_adapters) == list(other.test_adapters)
+        )
+
+    def __str__(self) -> str:
+        """Return a string representation of the MetadataItems."""
+        counts = []
+        if self.uut_instances:
+            counts.append(f"{len(self.uut_instances)} UUT instances")
+        if self.uuts:
+            counts.append(f"{len(self.uuts)} UUTs")
+        if self.operators:
+            counts.append(f"{len(self.operators)} operators")
+        if self.test_descriptions:
+            counts.append(f"{len(self.test_descriptions)} test descriptions")
+        if self.tests:
+            counts.append(f"{len(self.tests)} tests")
+        if self.test_stations:
+            counts.append(f"{len(self.test_stations)} test stations")
+        if self.hardware_items:
+            counts.append(f"{len(self.hardware_items)} hardware items")
+        if self.software_items:
+            counts.append(f"{len(self.software_items)} software items")
+        if self.test_adapters:
+            counts.append(f"{len(self.test_adapters)} test adapters")
+
+        if counts:
+            return f"MetadataItems({', '.join(counts)})"
+        else:
+            return "MetadataItems(empty)"