micantis 1.2.3__tar.gz → 1.2.4__tar.gz

{micantis-1.2.3 → micantis-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micantis
-Version: 1.2.3
+Version: 1.2.4
 Summary: Package to simplify Micantis API usage
 Author-email: Mykela DeLuca <mykela.deluca@micantis.io>
 License-Expression: MIT
@@ -548,6 +548,55 @@ assert result.success, result.errors
 
 > **Rename rules:** CellTest names must be unique and may only contain letters, digits, and `_ - . ( ) space`. CellData names must be unique; renaming a CellData also auto-updates the owning CellTest's DataSourceKey.
 
+## Write Data Metadata
+Assign or update metadata on a **data set** (CellData record), the same way as cells, using either:
+- the built-in field `"name"` (renames the data set) or `"dataSourceKey"`
+- the human-readable field name of a user-defined property (e.g., "Active Cycle Test?")
+- or the internal propertyDefinitionId (UUID)
+
+User-defined property names are resolved against the data-set metadata definitions, which you can list with `api.list_data_metadata_definitions()`.
+
+**Per-entity atomic:** all changes targeting a single data set commit or rollback together; other data sets are unaffected. Returns a `BatchUpdateResult` with `.success` and `.errors`, identical to `write_cell_metadata`.
+
+#### 📘 Examples
+
+```python
+# Example 1: Set a user-defined property on specific data sets
+changes = [
+    {"id": "your-cell-data-guid-here", "field": "Active Cycle Test?", "value": True},
+]
+
+result = api.write_data_metadata(changes=changes)
+if not result:
+    for e in result.errors:
+        print(f"{e['itemId']}: {e['error']}")
+```
+
+```python
+# Example 2: Rename a data set and update its dataSourceKey
+changes = [
+    {"id": "your-cell-data-guid-here", "field": "name", "value": "Formation_Run_42"},
+    {"id": "your-cell-data-guid-here", "field": "dataSourceKey", "value": "Formation"},
+]
+
+result = api.write_data_metadata(changes=changes)
+assert result.success, result.errors
+```
+
+```python
+# Example 3: Update using propertyDefinitionId (advanced)
+changes = [
+    {
+        "id": "your-cell-data-guid-here",
+        "propertyDefinitionId": "your-property-definition-guid",
+        "value": "true"
+    }
+]
+
+result = api.write_data_metadata(changes=changes)
+assert result.success, result.errors
+```
+
 ## Stitch Data
 Combine multiple data sets into a single stitched data set. This is useful for creating continuous test data from multiple separate test runs.
 

{micantis-1.2.3 → micantis-1.2.4}/README.md

@@ -528,6 +528,55 @@ assert result.success, result.errors
 
 > **Rename rules:** CellTest names must be unique and may only contain letters, digits, and `_ - . ( ) space`. CellData names must be unique; renaming a CellData also auto-updates the owning CellTest's DataSourceKey.
 
+## Write Data Metadata
+Assign or update metadata on a **data set** (CellData record), the same way as cells, using either:
+- the built-in field `"name"` (renames the data set) or `"dataSourceKey"`
+- the human-readable field name of a user-defined property (e.g., "Active Cycle Test?")
+- or the internal propertyDefinitionId (UUID)
+
+User-defined property names are resolved against the data-set metadata definitions, which you can list with `api.list_data_metadata_definitions()`.
+
+**Per-entity atomic:** all changes targeting a single data set commit or rollback together; other data sets are unaffected. Returns a `BatchUpdateResult` with `.success` and `.errors`, identical to `write_cell_metadata`.
+
+#### 📘 Examples
+
+```python
+# Example 1: Set a user-defined property on specific data sets
+changes = [
+    {"id": "your-cell-data-guid-here", "field": "Active Cycle Test?", "value": True},
+]
+
+result = api.write_data_metadata(changes=changes)
+if not result:
+    for e in result.errors:
+        print(f"{e['itemId']}: {e['error']}")
+```
+
+```python
+# Example 2: Rename a data set and update its dataSourceKey
+changes = [
+    {"id": "your-cell-data-guid-here", "field": "name", "value": "Formation_Run_42"},
+    {"id": "your-cell-data-guid-here", "field": "dataSourceKey", "value": "Formation"},
+]
+
+result = api.write_data_metadata(changes=changes)
+assert result.success, result.errors
+```
+
+```python
+# Example 3: Update using propertyDefinitionId (advanced)
+changes = [
+    {
+        "id": "your-cell-data-guid-here",
+        "propertyDefinitionId": "your-property-definition-guid",
+        "value": "true"
+    }
+]
+
+result = api.write_data_metadata(changes=changes)
+assert result.success, result.errors
+```
+
 ## Stitch Data
 Combine multiple data sets into a single stitched data set. This is useful for creating continuous test data from multiple separate test runs.
 

{micantis-1.2.3 → micantis-1.2.4}/micantis/api_wrapper.py

@@ -884,6 +884,59 @@ class MicantisAPI:
         except requests.exceptions.RequestException as e:
             raise self._format_request_error(e)
 
+    def list_data_metadata_definitions(self, return_format='df', timeout: int = 30):
+        """
+        Returns a list of cell data metadata types.
+
+        Parameters
+        ----------
+        return_format : str, optional
+            Return format: 'df' for DataFrame (default), anything else for raw list.
+        timeout : int, optional
+            Request timeout in seconds. Default: 30.
+        """
+        try:
+            return self._retry_on_auth_failure(
+                self._list_data_metadata_definitions, return_format, timeout
+            )
+        except Exception as e:
+            print(f"⚠️ list_data_metadata_definitions failed: {e}")
+            return None
+
+    def _list_data_metadata_definitions(self, return_format: str, timeout: int):
+        """
+        Internal helper for list_data_metadata_definitions. Does not handle retries or printing.
+
+        Raises
+        ------
+        RuntimeError
+            If the request fails or authentication is missing.
+        """
+        if not self.headers:
+            raise RuntimeError("Authentication required. Call authenticate() first.")
+
+        self._refresh_token_if_needed()
+
+        try:
+            # Make the GET request
+            response = self.session.get(
+                f"{self.service_url}/publicapi/v1/metadata/list/data",
+                headers=self.headers,
+                timeout=timeout,
+            )
+            response.raise_for_status()
+
+            item = response.json()
+            if return_format == 'df':
+                df = pd.DataFrame(item)
+                return df
+
+            else:
+                return item
+
+        except requests.exceptions.RequestException as e:
+            raise self._format_request_error(e)
+
     def get_cell_metadata(self, cell_ids: list, metadata: list = None, return_images: bool = False, timeout: int = 30):
         """
         Fetch metadata for specific cells, using either metadata names or IDs.
@@ -1144,9 +1197,14 @@ class MicantisAPI:
         """
         Wrapper for POST /data/updatemetadata endpoint.
 
-        Updates built-in metadata fields on cell data records. Supported built-in
-        fields are "name" and "dataSourceKey". User-defined metadata properties on
-        cell data are not yet supported via the public API.
+        Each change targets either a built-in field (supported: "name",
+        "dataSourceKey") or a user-defined metadata property. For user-defined
+        properties, pass either a human-readable 'field' name (resolved via
+        metadata definitions) or a 'propertyDefinitionId' UUID.
+
+        Built-in field names take precedence over user-defined names; if you have a
+        user-defined property literally named "name" or "dataSourceKey", use
+        propertyDefinitionId to disambiguate.
 
         Renaming a data set ("name" field) enforces name-uniqueness; the change is
         rejected if another data set already has the target name. The owning
@@ -1166,7 +1224,10 @@ class MicantisAPI:
         changes : list of dict
             A list of metadata change dictionaries. Each dictionary must contain:
             - "id": str (cell data GUID)
-            - "field": "name" or "dataSourceKey"
+            - One of:
+                - "field": "name" or "dataSourceKey" (built-in fields)
+                - "field": "<metadata name>" (user-defined, e.g. "Active Cycle Test?")
+                - "propertyDefinitionId": "<UUID>" (user-defined)
             - "value": any (will be cast to str)
 
         timeout : int, optional
@@ -1184,8 +1245,9 @@ class MicantisAPI:
         Examples
         --------
         >>> result = api.write_data_metadata([
-        ...     {"id": cell_data_id, "field": "name",          "value": "Formation_Run_42"},
-        ...     {"id": cell_data_id, "field": "dataSourceKey", "value": "Formation"},
+        ...     {"id": cell_data_id, "field": "name",               "value": "Formation_Run_42"},
+        ...     {"id": cell_data_id, "field": "dataSourceKey",      "value": "Formation"},
+        ...     {"id": cell_data_id, "field": "Active Cycle Test?", "value": True},
         ... ])
         >>> if not result:
         ...     for e in result.errors:
@@ -1203,20 +1265,35 @@ class MicantisAPI:
 
         self._refresh_token_if_needed()
 
+        # Only look up user-property definitions if at least one change uses a 'field' that
+        # isn't a built-in (lookup is a separate round-trip and unnecessary otherwise).
+        needs_lookup = any(
+            "field" in change and change["field"] not in self._BUILTIN_DATA_METADATA_FIELDS
+            for change in changes
+        )
+        if needs_lookup:
+            metadata_df = self._list_data_metadata_definitions('df', timeout)
+            name_to_id = dict(zip(metadata_df['name'], metadata_df['id']))
+        else:
+            name_to_id = {}
+
         formatted_changes = []
         for change in changes:
-            field = change.get("field")
-            if field not in self._BUILTIN_DATA_METADATA_FIELDS:
-                supported = ", ".join(f'"{f}"' for f in sorted(self._BUILTIN_DATA_METADATA_FIELDS))
-                raise RuntimeError(
-                    f"write_data_metadata only supports built-in fields ({supported}). "
-                    f"Got field={field!r}."
-                )
-            formatted_changes.append({
-                "id": change["id"],
-                "field": field,
-                "value": str(change["value"]),
-            })
+            item = {"id": change["id"], "value": str(change["value"])}
+
+            if "field" in change and change["field"] in self._BUILTIN_DATA_METADATA_FIELDS:
+                item["field"] = change["field"]
+            elif "propertyDefinitionId" in change:
+                item["propertyDefinitionId"] = change["propertyDefinitionId"]
+            elif "field" in change:
+                field_name = change["field"]
+                if field_name not in name_to_id:
+                    raise RuntimeError(f"Field name '{field_name}' not found in metadata definitions.")
+                item["propertyDefinitionId"] = name_to_id[field_name]
+            else:
+                raise RuntimeError("Each change must include either 'field' or 'propertyDefinitionId'.")
+
+            formatted_changes.append(item)
 
         payload = {"changes": formatted_changes}
 
@@ -2213,6 +2290,111 @@ class MicantisAPI:
                                cycle, step_kind, step_index)
         return action
 
+    @staticmethod
+    def rename_column(source_column_index, new_name, name=None):
+        """Build a rename-column action for clean_data (MetadataEdit mode).
+
+        Rename a column's display Name — what graphs, tables, and reports look up
+        by YAxisName. Targets the ORIGINAL source column index; action order does
+        not shift index meaning.
+
+        Parameters
+        ----------
+        source_column_index : int
+            0-based index into the ORIGINAL source column list.
+        new_name : str
+            New display name. Preserve exact spacing / punctuation expected by
+            downstream lookups (e.g. "Temp  1 (C)" with two spaces).
+        name : str, optional
+            Descriptive name for this action.
+        """
+        action = {"$type": "rename",
+                  "sourceColumnIndex": int(source_column_index),
+                  "newName": new_name}
+        if name is not None:
+            action["name"] = name
+        return action
+
+    @staticmethod
+    def change_column_kind(source_column_index, new_kind, name=None):
+        """Build a change-column-kind action for clean_data (MetadataEdit mode).
+
+        Change a column's YAxisKind (cycle-tester aux) or ImportItemKind (logger)
+        — controls which kind-based lookups match the column. Targets the ORIGINAL
+        source column index.
+
+        Parameters
+        ----------
+        source_column_index : int
+            0-based index into the ORIGINAL source column list.
+        new_kind : str
+            Exact enum value name (e.g. 'Voltage', 'AuxTemperature').
+        name : str, optional
+            Descriptive name for this action.
+        """
+        action = {"$type": "kind",
+                  "sourceColumnIndex": int(source_column_index),
+                  "newKind": new_kind}
+        if name is not None:
+            action["name"] = name
+        return action
+
+    @staticmethod
+    def reorder_columns(source_column_indices, name=None):
+        """Build a reorder-columns action for clean_data (MetadataEdit mode).
+
+        Declarative final column layout: source columns appear in the cleaned
+        output in the order listed; any source index not listed is dropped.
+        Combines drop + reorder in one action. At most one per definition.
+
+        Parameters
+        ----------
+        source_column_indices : list[int]
+            Ordered list of 0-based source column indices to keep. Omit an index
+            to drop that column. Example: [0, 1, 3, 4, 5] drops source column 2.
+        name : str, optional
+            Descriptive name for this action.
+        """
+        action = {"$type": "reorderColumns",
+                  "sourceColumnIndices": [int(i) for i in source_column_indices]}
+        if name is not None:
+            action["name"] = name
+        return action
+
+    @staticmethod
+    def edit_logger_step(line=None, lines=None, columns=None, name=None):
+        """Build an edit-logger-timestep action for clean_data (logger-data analog of modify_step/bulk_modify).
+
+        Edit column values by 0-based column index on rows matched by ``line`` and/or
+        ``lines`` (union). Use on DataLoggerData sources only; for cycle-tester data
+        use modify_step / bulk_modify.
+
+        Parameters
+        ----------
+        line : int, optional
+            Single line number to edit.
+        lines : list of (int, int) tuples, optional
+            Line number ranges to edit, e.g. [(100, 200)]. End may be None for open-ended.
+        columns : dict of {int: float}
+            Column edits as {column_index: value}. Column index is 0-based and
+            must refer to a valid column in the source ImportDefinition.
+        name : str, optional
+            Descriptive name for this action.
+        """
+        if line is None and not lines:
+            raise ValueError("edit_logger_step requires either line or lines.")
+        if not columns:
+            raise ValueError("edit_logger_step requires columns.")
+        action = {"$type": "editLogger"}
+        if name is not None:
+            action["name"] = name
+        if line is not None:
+            action["lineNumber"] = line
+        if lines:
+            action["lineNumberRanges"] = _ranges(lines)
+        action["columns"] = [{"columnIndex": int(k), "value": float(v)} for k, v in columns.items()]
+        return action
+
     def clean_data(self,
                    source_ids: list,
                    mode: str = 'CycleAutoFixup',
@@ -2231,14 +2413,19 @@ class MicantisAPI:
         source_ids : list of str
             List of cell data IDs (GUIDs) to clean.
         mode : str, optional
-            Cleaning mode. One of 'CycleAutoFixup', 'FilterCycles', 'Parametric'.
-            Default: 'CycleAutoFixup'. Auto-set to 'Parametric' when actions is provided.
+            Cleaning mode. One of 'CycleAutoFixup', 'FilterCycles', 'Parametric', 'MetadataEdit'.
+            Default: 'CycleAutoFixup'. When ``actions`` is provided and mode is still the default,
+            it auto-sets to 'Parametric'. For 'MetadataEdit', pass mode explicitly.
         filter_cycles_definition : dict, optional
             Required when mode is 'FilterCycles'. Definition for filtering cycles.
         actions : list, optional
-            List of action dicts built with api.remove_steps(),
-            api.modify_step(), and/or api.bulk_modify().
-            Auto-sets mode to 'Parametric'. Example::
+            For Parametric mode: list of dicts from api.remove_steps(), api.modify_step(),
+            api.bulk_modify(), api.edit_logger_step().
+            For MetadataEdit mode: list of dicts from api.rename_column(),
+            api.change_column_kind(), api.reorder_columns().
+            Actions are applied in the order given.
+
+            Parametric example (cycle-tester)::
 
                 api.clean_data(
                     source_ids=[id],
@@ -2248,6 +2435,29 @@ class MicantisAPI:
                         api.bulk_modify(lines=[(100, 5000)], cycle=1),
                     ]
                 )
+
+            Parametric example (DataLoggerData)::
+
+                api.clean_data(
+                    source_ids=[logger_id],
+                    actions=[
+                        api.remove_steps(lines=[(1, 3)]),
+                        api.edit_logger_step(line=10, columns={0: 1.5}),
+                    ]
+                )
+
+            MetadataEdit example (rename + drop — works on both CT and logger)::
+
+                api.clean_data(
+                    source_ids=[id],
+                    mode='MetadataEdit',
+                    actions=[
+                        api.rename_column(source_column_index=3, new_name='Temp  1 (C)'),
+                        api.rename_column(source_column_index=4, new_name='Temp  2 (C)'),
+                        api.rename_column(source_column_index=5, new_name='Temp  3 (C)'),
+                        api.reorder_columns([0, 1, 3, 4, 5]),  # drops source column 2
+                    ]
+                )
         allow_async : bool, optional
             If True, runs asynchronously and returns job ID. Default: False.
         timeout : int, optional
@@ -2260,7 +2470,8 @@ class MicantisAPI:
             If allow_async is True: {'job_id': str}
             Returns None if an error occurs.
         """
-        if actions is not None:
+        # Auto-set mode only if the caller left the default; preserves explicit 'MetadataEdit' etc.
+        if actions is not None and mode == 'CycleAutoFixup':
             mode = 'Parametric'
 
         try:
@@ -2291,8 +2502,10 @@ class MicantisAPI:
 
         if mode == 'Parametric' and not actions:
             raise ValueError("actions is required when mode is 'Parametric'.")
+        if mode == 'MetadataEdit' and not actions:
+            raise ValueError("actions is required when mode is 'MetadataEdit'.")
 
-        _mode_map = {'CycleAutoFixup': 1, 'Parametric': 2, 'FilterCycles': 4}
+        _mode_map = {'CycleAutoFixup': 1, 'Parametric': 2, 'FilterCycles': 4, 'MetadataEdit': 5}
         if mode not in _mode_map:
             raise ValueError(f"mode must be one of {list(_mode_map)}, got '{mode}'")
 
@@ -2304,7 +2517,10 @@ class MicantisAPI:
         if filter_cycles_definition is not None:
             payload["filterCyclesDefinition"] = filter_cycles_definition
         if actions is not None:
-            payload["parametricDefinition"] = {"actions": actions}
+            if mode == 'MetadataEdit':
+                payload["metadataEditDefinition"] = {"actions": actions}
+            else:
+                payload["parametricDefinition"] = {"actions": actions}
 
         url = f"{self.service_url}/publicapi/v1/data/clean"
         if allow_async:

{micantis-1.2.3 → micantis-1.2.4}/micantis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micantis
-Version: 1.2.3
+Version: 1.2.4
 Summary: Package to simplify Micantis API usage
 Author-email: Mykela DeLuca <mykela.deluca@micantis.io>
 License-Expression: MIT
@@ -548,6 +548,55 @@ assert result.success, result.errors
 
 > **Rename rules:** CellTest names must be unique and may only contain letters, digits, and `_ - . ( ) space`. CellData names must be unique; renaming a CellData also auto-updates the owning CellTest's DataSourceKey.
 
+## Write Data Metadata
+Assign or update metadata on a **data set** (CellData record), the same way as cells, using either:
+- the built-in field `"name"` (renames the data set) or `"dataSourceKey"`
+- the human-readable field name of a user-defined property (e.g., "Active Cycle Test?")
+- or the internal propertyDefinitionId (UUID)
+
+User-defined property names are resolved against the data-set metadata definitions, which you can list with `api.list_data_metadata_definitions()`.
+
+**Per-entity atomic:** all changes targeting a single data set commit or rollback together; other data sets are unaffected. Returns a `BatchUpdateResult` with `.success` and `.errors`, identical to `write_cell_metadata`.
+
+#### 📘 Examples
+
+```python
+# Example 1: Set a user-defined property on specific data sets
+changes = [
+    {"id": "your-cell-data-guid-here", "field": "Active Cycle Test?", "value": True},
+]
+
+result = api.write_data_metadata(changes=changes)
+if not result:
+    for e in result.errors:
+        print(f"{e['itemId']}: {e['error']}")
+```
+
+```python
+# Example 2: Rename a data set and update its dataSourceKey
+changes = [
+    {"id": "your-cell-data-guid-here", "field": "name", "value": "Formation_Run_42"},
+    {"id": "your-cell-data-guid-here", "field": "dataSourceKey", "value": "Formation"},
+]
+
+result = api.write_data_metadata(changes=changes)
+assert result.success, result.errors
+```
+
+```python
+# Example 3: Update using propertyDefinitionId (advanced)
+changes = [
+    {
+        "id": "your-cell-data-guid-here",
+        "propertyDefinitionId": "your-property-definition-guid",
+        "value": "true"
+    }
+]
+
+result = api.write_data_metadata(changes=changes)
+assert result.success, result.errors
+```
+
 ## Stitch Data
 Combine multiple data sets into a single stitched data set. This is useful for creating continuous test data from multiple separate test runs.
 

{micantis-1.2.3 → micantis-1.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "micantis"
-version = "1.2.3"
+version = "1.2.4"
 description = "Package to simplify Micantis API usage"
 authors = [
     { name = "Mykela DeLuca", email = "mykela.deluca@micantis.io" }

{micantis-1.2.3 → micantis-1.2.4}/tests/test_batch_update_result.py

@@ -6,12 +6,14 @@ Mocks the HTTP layer so it can run anywhere without a live server. Exercises:
 - 207 Multi-Status → BatchUpdateResult(success=False, errors=[...])
 - 400 Bad Request → BatchUpdateResult(success=False, errors=[...])
 - Truthiness (`if result:` works)
-- Rejection of unknown fields (client-side validation)
+- User-property name resolution and propertyDefinitionId pass-through
 
 Run:  pytest
 """
 from unittest.mock import MagicMock
 
+import pandas as pd
+
 from micantis.api_wrapper import MicantisAPI, BatchUpdateResult
 
 
@@ -115,18 +117,55 @@ def test_write_data_207_returns_partial():
     print("PASS: data/updatemetadata 207 → partial")
 
 
-def test_write_data_rejects_unknown_field():
+def test_write_data_unknown_property_name_raises():
+    # A non-built-in field is treated as a user-property name and resolved against the
+    # CellData metadata definitions; a name with no matching definition raises.
     api = _make_api()
+    api._list_data_metadata_definitions = lambda return_format, timeout: pd.DataFrame(
+        {"name": ["Active Cycle Test?"], "id": ["def-1"]}
+    )
     try:
         api._write_data_metadata(
-            [{"id": "x", "field": "Technician", "value": "foo"}], timeout=5,
+            [{"id": "x", "field": "Nonexistent Property", "value": "foo"}], timeout=5,
         )
     except RuntimeError as e:
-        assert "Technician" in str(e)
-        assert "name" in str(e) and "dataSourceKey" in str(e)
-        print("PASS: data/updatemetadata rejects unknown field client-side")
+        assert "Nonexistent Property" in str(e)
+        assert "not found in metadata definitions" in str(e)
+        print("PASS: data/updatemetadata raises on unknown user-property name")
         return
-    raise AssertionError("expected RuntimeError on unknown field")
+    raise AssertionError("expected RuntimeError on unknown property name")
+
+
+def test_write_data_resolves_property_name():
+    # A user-property name is resolved to its definition ID and sent as propertyDefinitionId.
+    api = _make_api()
+    api._list_data_metadata_definitions = lambda return_format, timeout: pd.DataFrame(
+        {"name": ["Active Cycle Test?"], "id": ["def-1"]}
+    )
+    api.session.post.return_value = _mock_response(204)
+    result = api._write_data_metadata(
+        [{"id": "x", "field": "Active Cycle Test?", "value": True}], timeout=5,
+    )
+    assert result.success is True
+    sent = api.session.post.call_args.kwargs["json"]["changes"][0]
+    assert sent == {"id": "x", "value": "True", "propertyDefinitionId": "def-1"}
+    print("PASS: data/updatemetadata resolves user-property name → propertyDefinitionId")
+
+
+def test_write_data_accepts_property_definition_id():
+    # A propertyDefinitionId is forwarded directly, with no definitions lookup.
+    api = _make_api()
+    api._list_data_metadata_definitions = MagicMock(
+        side_effect=AssertionError("should not look up definitions when an id is supplied")
+    )
+    api.session.post.return_value = _mock_response(204)
+    result = api._write_data_metadata(
+        [{"id": "x", "propertyDefinitionId": "def-9", "value": "true"}], timeout=5,
+    )
+    assert result.success is True
+    sent = api.session.post.call_args.kwargs["json"]["changes"][0]
+    assert sent == {"id": "x", "value": "true", "propertyDefinitionId": "def-9"}
+    print("PASS: data/updatemetadata forwards propertyDefinitionId directly")
 
 
 def test_name_is_accepted_as_builtin():