micantis 1.2.2__tar.gz → 1.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micantis
-Version: 1.2.2
+Version: 1.2.4
 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,10 +542,59 @@ changes = [
     }
 ]
 
-api.write_cell_metadata(changes=changes)
+result = api.write_cell_metadata(changes=changes)
+assert result.success, result.errors
+```
 
-# Verify the changes
-api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
+> **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

micantis-1.2.2/PKG-INFO → micantis-1.2.4/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,10 +522,59 @@ changes = [
     }
 ]
 
-api.write_cell_metadata(changes=changes)
+result = api.write_cell_metadata(changes=changes)
+assert result.success, result.errors
+```
 
-# Verify the changes
-api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
+> **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

{micantis-1.2.2 → micantis-1.2.4}/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.
@@ -856,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.
@@ -967,30 +1048,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 +1137,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,21 +1151,21 @@ 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({
-                "id": change["id"],
-                "propertyDefinitionId": property_id,
-                "value": str(change["value"])
-            })
+            formatted_changes.append(item)
 
         payload = {"changes": formatted_changes}
 
@@ -1050,9 +1179,144 @@ class MicantisAPI:
 
             if response.status_code == 204:
                 print("✅ Metadata update successful!")
-                return True
+                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.
+
+        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
+        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)
+            - 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
+            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"},
+        ...     {"id": cell_data_id, "field": "Active Cycle Test?", "value": True},
+        ... ])
+        >>> 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()
+
+        # 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:
+            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(f"Metadata update failed: {response.status_code} - {response.text}")
+                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/data/updatemetadata",
+                headers=self.headers,
+                json=payload,
+                timeout=timeout
+            )
+
+            if response.status_code == 204:
+                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)
@@ -2101,9 +2365,9 @@ class MicantisAPI:
     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.
+        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
         ----------
@@ -2112,7 +2376,8 @@ class MicantisAPI:
         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).
+            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.
         """

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

@@ -1,3 +1,23 @@
+Metadata-Version: 2.4
+Name: micantis
+Version: 1.2.4
+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,10 +542,59 @@ changes = [
     }
 ]
 
-api.write_cell_metadata(changes=changes)
+result = api.write_cell_metadata(changes=changes)
+assert result.success, result.errors
+```
 
-# Verify the changes
-api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
+> **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

{micantis-1.2.2 → micantis-1.2.4}/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.4}/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.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "micantis"
-version = "1.2.2"
+version = "1.2.4"
 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.4/tests/test_batch_update_result.py

@@ -0,0 +1,174 @@
+"""
+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)
+- 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
+
+
+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_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": "Nonexistent Property", "value": "foo"}], timeout=5,
+        )
+    except RuntimeError as e:
+        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 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():
+    # 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