micantis 1.2.2__tar.gz → 1.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micantis
-Version: 1.2.2
+Version: 1.2.3
 Summary: Package to simplify Micantis API usage
 Author-email: Mykela DeLuca <mykela.deluca@micantis.io>
 License-Expression: MIT
@@ -13,6 +13,9 @@ Requires-Dist: msal
 Requires-Dist: azure-identity
 Provides-Extra: parquet
 Requires-Dist: pyarrow>=16.0.0; extra == "parquet"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-mock>=3; extra == "test"
 Dynamic: license-file
 
 # Micantis API Wrapper
@@ -499,27 +502,31 @@ combined_df.head()
 
 ## Write Cell Metadata
 Micantis lets you programmatically assign or update metadata for each cell using either:
-- the human-readable field name (e.g., "Technician", "Weight (g)")
+- the built-in field `"name"` (renames the cell) or `"dataSourceKey"`
+- the human-readable field name of a user-defined property (e.g., "Technician", "Weight (g)")
 - or the internal propertyDefinitionId (UUID)
 
+**Per-entity atomic:** all changes targeting a single cell commit or rollback together. If any change for a cell fails, none of that cell's changes persist; other cells are unaffected. The call returns a `BatchUpdateResult`:
+
+- `result.success` — `True` if every cell committed
+- `result.errors` — list of `{itemId, error}` dicts for the cells whose changes were rolled back
+- `if result:` — truthy iff full success (use `.success` or truthiness, not `result == True`)
+
 #### 📘 Examples
 
 ```python
-# Example 1: Update the technician field for a cell
+# Example 1: Rename a cell and update its dataSourceKey + a user property
 changes = [
-    {
-        "id": "your-cell-test-guid-here",  # cell test GUID
-        "field": "Technician",
-        "value": "Mykela"
-    },
-    {
-        "id": "your-cell-test-guid-here",
-        "field": "Weight (g)",
-        "value": 98.7
-    }
+    {"id": "your-cell-test-guid-here", "field": "name", "value": "A-EVE-15P-Cell-04"},
+    {"id": "your-cell-test-guid-here", "field": "dataSourceKey", "value": "Formation"},
+    {"id": "your-cell-test-guid-here", "field": "Technician", "value": "Mykela"},
+    {"id": "your-cell-test-guid-here", "field": "Weight (g)", "value": 98.7},
 ]
 
-api.write_cell_metadata(changes=changes)
+result = api.write_cell_metadata(changes=changes)
+if not result:
+    for e in result.errors:
+        print(f"{e['itemId']}: {e['error']}")
 
 # Verify the changes
 api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
@@ -535,12 +542,12 @@ changes = [
     }
 ]
 
-api.write_cell_metadata(changes=changes)
-
-# Verify the changes
-api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
+result = api.write_cell_metadata(changes=changes)
+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.
+
 ## 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.2/PKG-INFO → micantis-1.2.3/README.md

@@ -1,20 +1,3 @@
-Metadata-Version: 2.4
-Name: micantis
-Version: 1.2.2
-Summary: Package to simplify Micantis API usage
-Author-email: Mykela DeLuca <mykela.deluca@micantis.io>
-License-Expression: MIT
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests
-Requires-Dist: pandas
-Requires-Dist: msal
-Requires-Dist: azure-identity
-Provides-Extra: parquet
-Requires-Dist: pyarrow>=16.0.0; extra == "parquet"
-Dynamic: license-file
-
 # Micantis API Wrapper
 
 A lightweight Python wrapper for interacting with the Micantis API plus some helpful utilities.  
@@ -499,27 +482,31 @@ combined_df.head()
 
 ## Write Cell Metadata
 Micantis lets you programmatically assign or update metadata for each cell using either:
-- the human-readable field name (e.g., "Technician", "Weight (g)")
+- the built-in field `"name"` (renames the cell) or `"dataSourceKey"`
+- the human-readable field name of a user-defined property (e.g., "Technician", "Weight (g)")
 - or the internal propertyDefinitionId (UUID)
 
+**Per-entity atomic:** all changes targeting a single cell commit or rollback together. If any change for a cell fails, none of that cell's changes persist; other cells are unaffected. The call returns a `BatchUpdateResult`:
+
+- `result.success` — `True` if every cell committed
+- `result.errors` — list of `{itemId, error}` dicts for the cells whose changes were rolled back
+- `if result:` — truthy iff full success (use `.success` or truthiness, not `result == True`)
+
 #### 📘 Examples
 
 ```python
-# Example 1: Update the technician field for a cell
+# Example 1: Rename a cell and update its dataSourceKey + a user property
 changes = [
-    {
-        "id": "your-cell-test-guid-here",  # cell test GUID
-        "field": "Technician",
-        "value": "Mykela"
-    },
-    {
-        "id": "your-cell-test-guid-here",
-        "field": "Weight (g)",
-        "value": 98.7
-    }
+    {"id": "your-cell-test-guid-here", "field": "name", "value": "A-EVE-15P-Cell-04"},
+    {"id": "your-cell-test-guid-here", "field": "dataSourceKey", "value": "Formation"},
+    {"id": "your-cell-test-guid-here", "field": "Technician", "value": "Mykela"},
+    {"id": "your-cell-test-guid-here", "field": "Weight (g)", "value": 98.7},
 ]
 
-api.write_cell_metadata(changes=changes)
+result = api.write_cell_metadata(changes=changes)
+if not result:
+    for e in result.errors:
+        print(f"{e['itemId']}: {e['error']}")
 
 # Verify the changes
 api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
@@ -535,12 +522,12 @@ changes = [
     }
 ]
 
-api.write_cell_metadata(changes=changes)
-
-# Verify the changes
-api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
+result = api.write_cell_metadata(changes=changes)
+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.
+
 ## 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.2 → micantis-1.2.3}/micantis/api_wrapper.py

@@ -43,6 +43,34 @@ def _apply_field_overrides(action, voltage, current, charge_capacity,
             action[key] = val
 
 
+class BatchUpdateResult:
+    """
+    Result of a batch metadata update call (`write_cell_metadata` / `write_data_metadata`).
+
+    Truthy iff every entity's changes were applied. On partial or full failure, inspect
+    `errors` for per-entity details; successful entities' changes are already persisted.
+
+    Attributes
+    ----------
+    success : bool
+        True iff every entity's changes committed (HTTP 204).
+    errors : list of dict
+        Per-entity errors. Each dict has keys `itemId` (str) and `error` (str).
+        Empty list when `success` is True.
+    """
+    def __init__(self, success: bool, errors: list = None):
+        self.success = success
+        self.errors = errors or []
+
+    def __bool__(self):
+        return self.success
+
+    def __repr__(self):
+        if self.success:
+            return "BatchUpdateResult(success=True)"
+        return f"BatchUpdateResult(success=False, errors={self.errors!r})"
+
+
 class MicantisAPI:
     """
     A client for interacting with the Micantis API.
@@ -967,30 +995,74 @@ class MicantisAPI:
         except requests.exceptions.RequestException as e:
             raise self._format_request_error(e)
 
+    # Built-in fields that the public /cells/updatemetadata endpoint understands directly
+    # (i.e. mapped to an OrderByColumn on the server side, not to a UserPropertyDefinition).
+    _BUILTIN_CELL_METADATA_FIELDS = {"dataSourceKey", "name"}
+
+    # Built-in fields that the public /data/updatemetadata endpoint understands directly.
+    _BUILTIN_DATA_METADATA_FIELDS = {"dataSourceKey", "name"}
+
     def write_cell_metadata(self, changes: list, timeout: int = 30):
         """
         Wrapper for POST /cells/updatemetadata endpoint.
-        Accepts either a metadata 'field' (human-readable name) or 'propertyDefinitionId'.
+
+        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 cell ("name" field) enforces name-uniqueness and a character
+        whitelist (letters, digits, `_ - . ( ) space`); renames that fail these
+        checks return an error without applying the change.
+
+        **Per-entity atomicity:** all changes targeting the same cell commit or
+        rollback together. Across cells, each entity is independent — if one
+        cell's changes fail, others still persist. The result indicates which
+        cells failed; successful cells' changes are already saved.
 
         Automatically reauthenticates if the session is expired or missing.
-        Prints an error message and returns None if the request ultimately fails.
+        Prints a message and returns None if the network request fails entirely.
 
         Parameters
         ----------
         changes : list of dict
             A list of metadata change dictionaries. Each dictionary must contain:
-            - "id": str
-            - "field": str (human-readable name, e.g., "Weight (g)") OR
-            - "propertyDefinitionId": str (UUID)
-            - "value": any (will be cast to str)
+            - "id": str (cell test GUID)
+            - One of:
+                - "field": "name" or "dataSourceKey" (built-in fields)
+                - "field": "<metadata name>" (user-defined, e.g. "Weight (g)")
+                - "propertyDefinitionId": "<UUID>" (user-defined)
+            - "value": any (will be cast to str). For multi-valued CellTest
+              DataSourceKeys, pass a comma-separated string (e.g. "Formation,CycleLife").
 
         timeout : int, optional
             Timeout in seconds for the request. Default is 30.
 
         Returns
         -------
-        bool or None
-            True if successful (204 No Content), or None if an error occurs.
+        BatchUpdateResult or None
+            A `BatchUpdateResult` whose `.success` is True iff every entity
+            committed (HTTP 204). On partial (207) or full failure (400), the
+            result is falsy and `.errors` lists the per-entity failures as
+            dicts with keys `itemId` and `error`. Returns None on a network-
+            level error.
+
+        Examples
+        --------
+        >>> result = api.write_cell_metadata([
+        ...     {"id": cell_id, "field": "name",          "value": "A-EVE-15P-Cell-04"},
+        ...     {"id": cell_id, "field": "dataSourceKey", "value": "Formation"},
+        ...     {"id": cell_id, "field": "Technician",    "value": "Alice"},
+        ... ])
+        >>> if result:
+        ...     print("all good")
+        ... else:
+        ...     for e in result.errors:
+        ...         print(f"{e['itemId']}: {e['error']}")
         """
         try:
             return self._retry_on_auth_failure(self._write_cell_metadata, changes, timeout)
@@ -1012,8 +1084,12 @@ class MicantisAPI:
 
         self._refresh_token_if_needed()
 
-        # Build lookup: field name -> propertyDefinitionId (only if any change uses field names)
-        needs_lookup = any("field" in change for change in changes)
+        # 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_CELL_METADATA_FIELDS
+            for change in changes
+        )
         if needs_lookup:
             metadata_df = self._list_cell_metadata_definitions('df', timeout)
             name_to_id = dict(zip(metadata_df['name'], metadata_df['id']))
@@ -1022,37 +1098,148 @@ class MicantisAPI:
 
         formatted_changes = []
         for change in changes:
-            if "propertyDefinitionId" in change:
-                property_id = change["propertyDefinitionId"]
+            item = {"id": change["id"], "value": str(change["value"])}
+
+            if "field" in change and change["field"] in self._BUILTIN_CELL_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.")
-                property_id = name_to_id[field_name]
+                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}
+
+        try:
+            response = self.session.post(
+                f"{self.service_url}/publicapi/v1/cells/updatemetadata",
+                headers=self.headers,
+                json=payload,
+                timeout=timeout
+            )
+
+            if response.status_code == 204:
+                print("✅ Metadata update successful!")
+                return BatchUpdateResult(success=True)
+            if response.status_code in (207, 400):
+                body = response.json()
+                errors = body.get("errors", []) if isinstance(body, dict) else []
+                if response.status_code == 207:
+                    print(f"⚠️ Metadata update partial: {len(errors)} of {len(formatted_changes)} entities failed.")
+                else:
+                    print(f"⚠️ Metadata update failed for all entities.")
+                return BatchUpdateResult(success=False, errors=errors)
+            raise RuntimeError(f"Metadata update failed: {response.status_code} - {response.text}")
+
+        except requests.exceptions.RequestException as e:
+            raise self._format_request_error(e)
+
+    def write_data_metadata(self, changes: list, timeout: int = 30):
+        """
+        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.
+
+        Renaming a data set ("name" field) enforces name-uniqueness; the change is
+        rejected if another data set already has the target name. The owning
+        CellTest's DataSourceKey is updated automatically to match the new name
+        where applicable.
+
+        **Per-entity atomicity:** all changes targeting the same data set commit
+        or rollback together. Across data sets, each entity is independent — if
+        one data set's changes fail, others still persist. The result indicates
+        which data sets failed; successful ones are already saved.
+
+        Automatically reauthenticates if the session is expired or missing.
+        Prints a message and returns None if the network request fails entirely.
+
+        Parameters
+        ----------
+        changes : list of dict
+            A list of metadata change dictionaries. Each dictionary must contain:
+            - "id": str (cell data GUID)
+            - "field": "name" or "dataSourceKey"
+            - "value": any (will be cast to str)
+
+        timeout : int, optional
+            Timeout in seconds for the request. Default is 30.
+
+        Returns
+        -------
+        BatchUpdateResult or None
+            A `BatchUpdateResult` whose `.success` is True iff every entity
+            committed (HTTP 204). On partial (207) or full failure (400), the
+            result is falsy and `.errors` lists the per-entity failures as
+            dicts with keys `itemId` and `error`. Returns None on a network-
+            level error.
+
+        Examples
+        --------
+        >>> result = api.write_data_metadata([
+        ...     {"id": cell_data_id, "field": "name",          "value": "Formation_Run_42"},
+        ...     {"id": cell_data_id, "field": "dataSourceKey", "value": "Formation"},
+        ... ])
+        >>> if not result:
+        ...     for e in result.errors:
+        ...         print(f"{e['itemId']}: {e['error']}")
+        """
+        try:
+            return self._retry_on_auth_failure(self._write_data_metadata, changes, timeout)
+        except Exception as e:
+            print(f"⚠️ write_data_metadata failed: {e}")
+            return None
+
+    def _write_data_metadata(self, changes: list, timeout: int):
+        if not self.headers:
+            raise RuntimeError("Authentication required. Call authenticate() first.")
+
+        self._refresh_token_if_needed()
+
+        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"],
-                "propertyDefinitionId": property_id,
-                "value": str(change["value"])
+                "field": field,
+                "value": str(change["value"]),
             })
 
         payload = {"changes": formatted_changes}
 
         try:
             response = self.session.post(
-                f"{self.service_url}/publicapi/v1/cells/updatemetadata",
+                f"{self.service_url}/publicapi/v1/data/updatemetadata",
                 headers=self.headers,
                 json=payload,
                 timeout=timeout
             )
 
             if response.status_code == 204:
-                print("✅ Metadata update successful!")
-                return True
-            else:
-                raise RuntimeError(f"Metadata update failed: {response.status_code} - {response.text}")
+                print("✅ Data metadata update successful!")
+                return BatchUpdateResult(success=True)
+            if response.status_code in (207, 400):
+                body = response.json()
+                errors = body.get("errors", []) if isinstance(body, dict) else []
+                if response.status_code == 207:
+                    print(f"⚠️ Data metadata update partial: {len(errors)} of {len(formatted_changes)} entities failed.")
+                else:
+                    print(f"⚠️ Data metadata update failed for all entities.")
+                return BatchUpdateResult(success=False, errors=errors)
+            raise RuntimeError(f"Data metadata update failed: {response.status_code} - {response.text}")
 
         except requests.exceptions.RequestException as e:
             raise self._format_request_error(e)
@@ -2026,110 +2213,6 @@ 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 Column1..Column10 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 (0-9).
-        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',
@@ -2148,19 +2231,14 @@ 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', 'MetadataEdit'.
-            Default: 'CycleAutoFixup'. When ``actions`` is provided and mode is still the default,
-            it auto-sets to 'Parametric'. For 'MetadataEdit', pass mode explicitly.
+            Cleaning mode. One of 'CycleAutoFixup', 'FilterCycles', 'Parametric'.
+            Default: 'CycleAutoFixup'. Auto-set to 'Parametric' when actions is provided.
         filter_cycles_definition : dict, optional
             Required when mode is 'FilterCycles'. Definition for filtering cycles.
         actions : list, optional
-            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)::
+            List of action dicts built with api.remove_steps(),
+            api.modify_step(), and/or api.bulk_modify().
+            Auto-sets mode to 'Parametric'. Example::
 
                 api.clean_data(
                     source_ids=[id],
@@ -2170,29 +2248,6 @@ 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
@@ -2205,8 +2260,7 @@ class MicantisAPI:
             If allow_async is True: {'job_id': str}
             Returns None if an error occurs.
         """
-        # Auto-set mode only if the caller left the default; preserves explicit 'MetadataEdit' etc.
-        if actions is not None and mode == 'CycleAutoFixup':
+        if actions is not None:
             mode = 'Parametric'
 
         try:
@@ -2237,10 +2291,8 @@ 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, 'MetadataEdit': 5}
+        _mode_map = {'CycleAutoFixup': 1, 'Parametric': 2, 'FilterCycles': 4}
         if mode not in _mode_map:
             raise ValueError(f"mode must be one of {list(_mode_map)}, got '{mode}'")
 
@@ -2252,10 +2304,7 @@ class MicantisAPI:
         if filter_cycles_definition is not None:
             payload["filterCyclesDefinition"] = filter_cycles_definition
         if actions is not None:
-            if mode == 'MetadataEdit':
-                payload["metadataEditDefinition"] = {"actions": actions}
-            else:
-                payload["parametricDefinition"] = {"actions": actions}
+            payload["parametricDefinition"] = {"actions": actions}
 
         url = f"{self.service_url}/publicapi/v1/data/clean"
         if allow_async:

micantis-1.2.2/README.md → micantis-1.2.3/micantis.egg-info/PKG-INFO

@@ -1,3 +1,23 @@
+Metadata-Version: 2.4
+Name: micantis
+Version: 1.2.3
+Summary: Package to simplify Micantis API usage
+Author-email: Mykela DeLuca <mykela.deluca@micantis.io>
+License-Expression: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: pandas
+Requires-Dist: msal
+Requires-Dist: azure-identity
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=16.0.0; extra == "parquet"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-mock>=3; extra == "test"
+Dynamic: license-file
+
 # Micantis API Wrapper
 
 A lightweight Python wrapper for interacting with the Micantis API plus some helpful utilities.  
@@ -482,27 +502,31 @@ combined_df.head()
 
 ## Write Cell Metadata
 Micantis lets you programmatically assign or update metadata for each cell using either:
-- the human-readable field name (e.g., "Technician", "Weight (g)")
+- the built-in field `"name"` (renames the cell) or `"dataSourceKey"`
+- the human-readable field name of a user-defined property (e.g., "Technician", "Weight (g)")
 - or the internal propertyDefinitionId (UUID)
 
+**Per-entity atomic:** all changes targeting a single cell commit or rollback together. If any change for a cell fails, none of that cell's changes persist; other cells are unaffected. The call returns a `BatchUpdateResult`:
+
+- `result.success` — `True` if every cell committed
+- `result.errors` — list of `{itemId, error}` dicts for the cells whose changes were rolled back
+- `if result:` — truthy iff full success (use `.success` or truthiness, not `result == True`)
+
 #### 📘 Examples
 
 ```python
-# Example 1: Update the technician field for a cell
+# Example 1: Rename a cell and update its dataSourceKey + a user property
 changes = [
-    {
-        "id": "your-cell-test-guid-here",  # cell test GUID
-        "field": "Technician",
-        "value": "Mykela"
-    },
-    {
-        "id": "your-cell-test-guid-here",
-        "field": "Weight (g)",
-        "value": 98.7
-    }
+    {"id": "your-cell-test-guid-here", "field": "name", "value": "A-EVE-15P-Cell-04"},
+    {"id": "your-cell-test-guid-here", "field": "dataSourceKey", "value": "Formation"},
+    {"id": "your-cell-test-guid-here", "field": "Technician", "value": "Mykela"},
+    {"id": "your-cell-test-guid-here", "field": "Weight (g)", "value": 98.7},
 ]
 
-api.write_cell_metadata(changes=changes)
+result = api.write_cell_metadata(changes=changes)
+if not result:
+    for e in result.errors:
+        print(f"{e['itemId']}: {e['error']}")
 
 # Verify the changes
 api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
@@ -518,12 +542,12 @@ changes = [
     }
 ]
 
-api.write_cell_metadata(changes=changes)
-
-# Verify the changes
-api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
+result = api.write_cell_metadata(changes=changes)
+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.
+
 ## 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.2 → micantis-1.2.3}/micantis.egg-info/SOURCES.txt

@@ -8,4 +8,5 @@ micantis.egg-info/PKG-INFO
 micantis.egg-info/SOURCES.txt
 micantis.egg-info/dependency_links.txt
 micantis.egg-info/requires.txt
-micantis.egg-info/top_level.txt
+micantis.egg-info/top_level.txt
+tests/test_batch_update_result.py

{micantis-1.2.2 → micantis-1.2.3}/micantis.egg-info/requires.txt

@@ -5,3 +5,7 @@ azure-identity
 
 [parquet]
 pyarrow>=16.0.0
+
+[test]
+pytest>=7
+pytest-mock>=3

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

@@ -1,6 +1,6 @@
 [project]
 name = "micantis"
-version = "1.2.2"
+version = "1.2.3"
 description = "Package to simplify Micantis API usage"
 authors = [
     { name = "Mykela DeLuca", email = "mykela.deluca@micantis.io" }
@@ -18,4 +18,14 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-parquet = ["pyarrow>=16.0.0"]
+parquet = ["pyarrow>=16.0.0"]
+test = [
+    "pytest>=7",
+    "pytest-mock>=3",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]

micantis-1.2.3/tests/test_batch_update_result.py

@@ -0,0 +1,135 @@
+"""
+Unit tests for BatchUpdateResult parsing in write_cell_metadata / write_data_metadata.
+
+Mocks the HTTP layer so it can run anywhere without a live server. Exercises:
+- 204 No Content → BatchUpdateResult(success=True)
+- 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)
+
+Run:  pytest
+"""
+from unittest.mock import MagicMock
+
+from micantis.api_wrapper import MicantisAPI, BatchUpdateResult
+
+
+def _make_api():
+    api = MicantisAPI.__new__(MicantisAPI)
+    api.service_url = "https://fake.test"
+    api.headers = {"Authorization": "Bearer fake"}
+    api.session = MagicMock()
+    api._refresh_token_if_needed = lambda: None
+    return api
+
+
+def _mock_response(status_code, body=None):
+    resp = MagicMock()
+    resp.status_code = status_code
+    resp.json = MagicMock(return_value=body or {})
+    resp.text = str(body) if body else ""
+    return resp
+
+
+def test_batch_update_result_truthiness():
+    r_ok = BatchUpdateResult(success=True)
+    assert bool(r_ok) is True
+    assert r_ok.errors == []
+    assert "success=True" in repr(r_ok)
+
+    r_fail = BatchUpdateResult(success=False, errors=[{"itemId": "x", "error": "e"}])
+    assert bool(r_fail) is False
+    assert len(r_fail.errors) == 1
+    assert r_fail.errors[0]["itemId"] == "x"
+    assert "success=False" in repr(r_fail)
+    print("PASS: BatchUpdateResult truthiness + attributes")
+
+
+def test_write_cell_204_returns_success():
+    api = _make_api()
+    api.session.post.return_value = _mock_response(204)
+    result = api._write_cell_metadata(
+        [{"id": "a", "field": "name", "value": "new"}], timeout=5,
+    )
+    assert isinstance(result, BatchUpdateResult)
+    assert result.success is True
+    assert bool(result) is True
+    assert result.errors == []
+    print("PASS: 204 → BatchUpdateResult(success=True)")
+
+
+def test_write_cell_207_returns_partial():
+    api = _make_api()
+    body = {"errors": [{"itemId": "a", "error": "name exists"}]}
+    api.session.post.return_value = _mock_response(207, body)
+    result = api._write_cell_metadata(
+        [
+            {"id": "a", "field": "name", "value": "collision"},
+            {"id": "b", "field": "name", "value": "fresh"},
+        ],
+        timeout=5,
+    )
+    assert isinstance(result, BatchUpdateResult)
+    assert result.success is False
+    assert bool(result) is False
+    assert len(result.errors) == 1
+    assert result.errors[0]["itemId"] == "a"
+    assert "name exists" in result.errors[0]["error"]
+    print("PASS: 207 → BatchUpdateResult(success=False, errors=[...])")
+
+
+def test_write_cell_400_returns_failure():
+    api = _make_api()
+    body = {"errors": [{"itemId": "a", "error": "name exists"}]}
+    api.session.post.return_value = _mock_response(400, body)
+    result = api._write_cell_metadata(
+        [{"id": "a", "field": "name", "value": "collision"}], timeout=5,
+    )
+    assert isinstance(result, BatchUpdateResult)
+    assert result.success is False
+    assert len(result.errors) == 1
+    print("PASS: 400 → BatchUpdateResult(success=False, errors=[...])")
+
+
+def test_write_data_204_returns_success():
+    api = _make_api()
+    api.session.post.return_value = _mock_response(204)
+    result = api._write_data_metadata(
+        [{"id": "x", "field": "name", "value": "new"}], timeout=5,
+    )
+    assert isinstance(result, BatchUpdateResult)
+    assert result.success is True
+    print("PASS: data/updatemetadata 204 → success")
+
+
+def test_write_data_207_returns_partial():
+    api = _make_api()
+    body = {"errors": [{"itemId": "x", "error": "name exists"}]}
+    api.session.post.return_value = _mock_response(207, body)
+    result = api._write_data_metadata(
+        [{"id": "x", "field": "name", "value": "collision"}], timeout=5,
+    )
+    assert result.success is False
+    assert result.errors[0]["itemId"] == "x"
+    print("PASS: data/updatemetadata 207 → partial")
+
+
+def test_write_data_rejects_unknown_field():
+    api = _make_api()
+    try:
+        api._write_data_metadata(
+            [{"id": "x", "field": "Technician", "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")
+        return
+    raise AssertionError("expected RuntimeError on unknown field")
+
+
+def test_name_is_accepted_as_builtin():
+    # Ensure the previously-missing client-side allowlist now accepts "name"
+    assert "name" in MicantisAPI._BUILTIN_CELL_METADATA_FIELDS
+    assert "name" in MicantisAPI._BUILTIN_DATA_METADATA_FIELDS