clean up changes

Author: Max Wang

README.md

@@ -6,6 +6,7 @@ A Python package allowing developers to connect to Dataverse environments for DD
 - OData CRUD — Unified methods `create(logical_name, record|records)`, `update(logical_name, id|ids, patch|patches)`, `delete(logical_name, id|ids)` plus `get` with record id or filters and `delete_async` for better multi-record delete performance.
 - Bulk create — Pass a list of records to `create(...)` to invoke the bound `CreateMultiple` action; returns `list[str]` of GUIDs. If any payload omits `@odata.type` the SDK resolves and stamps it (cached).
 - Bulk update — Provide a list of IDs with a single patch (broadcast) or a list of per‑record patches to `update(...)`; internally uses the bound `UpdateMultiple` action; returns nothing. Each record must include the primary key attribute when sent to UpdateMultiple.
+- Bulk delete - Provide a list of IDs to `delete(...)` or `delete_async(...)`. `delete` internally uses `DeleteMultiple` for elastic tables, for standard tables it is a loop over single-record delete. `delete_async` interally uses async BulkDelete.
 - Retrieve multiple (paging) — Generator-based `get(...)` that yields pages, supports `$top` and Prefer: `odata.maxpagesize` (`page_size`).
 - Upload files — Call `upload_file(logical_name, ...)` and an upload method will be auto picked (you can override the mode). See https://learn.microsoft.com/en-us/power-apps/developer/data-platform/file-column-data?tabs=sdk#upload-files
 - Metadata helpers — Create/inspect/delete tables and create/delete columns (EntityDefinitions + Attributes).
@@ -145,7 +146,7 @@ print({"multi_update": "ok"})
 # Delete (single)
 client.delete("account", account_id)
 
-# Delete multiple sequentially
+# Delete (multiple)
 client.delete("account", ids)
 
 # Or queue a async bulk delete job

examples/quickstart.py

@@ -33,10 +33,6 @@
 # Create a credential we can reuse (for DataverseClient)
 credential = InteractiveBrowserCredential()
 client = DataverseClient(base_url=base_url, credential=credential)
-elastic_table_schema = "new_ElasticDeleteDemo"
-elastic_table_created_this_run = False
-elastic_table_logical_name: Optional[str] = None
-elastic_table_metadata_id: Optional[str] = None
 
 # Small helpers: call logging and step pauses
 def log_call(call: str) -> None:
@@ -73,129 +69,6 @@ def backoff_retry(op, *, delays=(0, 2, 5, 10, 20), retry_http_statuses=(400, 403
 			break
 	if last_exc:
 		raise last_exc
-
-def run_elastic_delete_demo() -> None:
-	global elastic_table_created_this_run, elastic_table_logical_name, elastic_table_metadata_id
-	print("Elastic DeleteMultiple demo (elastic table setup):")
-	odata_client = client._get_odata()
-	schema_name = elastic_table_schema
-	publisher_prefix = schema_name.split("_", 1)[0] if "_" in schema_name else schema_name
-	primary_attr = f"{publisher_prefix}_Name"
-	count_attr = f"{publisher_prefix}_Count"
-	flag_attr = f"{publisher_prefix}_Flag"
-
-	def _fetch_metadata() -> Optional[dict]:
-		url = f"{odata_client.api}/EntityDefinitions"
-		params = {
-			"$select": "MetadataId,LogicalName,EntitySetName,SchemaName,TableType",
-			"$filter": f"SchemaName eq '{schema_name}'",
-		}
-		r = odata_client._request("get", url, params=params)
-		try:
-			body = r.json() if r.text else {}
-		except ValueError:
-			return None
-		items = body.get("value") if isinstance(body, dict) else None
-		if isinstance(items, list) and items:
-			md = items[0]
-			return md if isinstance(md, dict) else None
-		return None
-
-	try:
-		metadata = _fetch_metadata()
-		if metadata and str(metadata.get("TableType", "")).lower() != "elastic":
-			print({
-				"elastic_table": schema_name,
-				"skipped": True,
-				"reason": "Existing table is not elastic; DeleteMultiple demo not run",
-				"table_type": metadata.get("TableType"),
-			})
-			return
-		if not metadata:
-			log_call(f"POST EntityDefinitions (TableType=Elastic) for {schema_name}")
-			attributes = [
-				odata_client._attribute_payload(primary_attr, "string", is_primary_name=True),
-				odata_client._attribute_payload(count_attr, "int"),
-				odata_client._attribute_payload(flag_attr, "bool"),
-			]
-			attrs = [a for a in attributes if a]
-			payload = {
-				"@odata.type": "Microsoft.Dynamics.CRM.EntityMetadata",
-				"SchemaName": schema_name,
-				"DisplayName": odata_client._label("Elastic Delete Demo"),
-				"DisplayCollectionName": odata_client._label("Elastic Delete Demos"),
-				"Description": odata_client._label("Elastic table for DeleteMultiple quickstart validation"),
-				"OwnershipType": "UserOwned",
-				"HasActivities": False,
-				"HasNotes": True,
-				"IsEnabledForCharts": False,
-				"IsVirtualEntityReportingEnabled": False,
-				"IsActivity": False,
-				"TableType": "Elastic",
-				"Attributes": attrs,
-			}
-			def _create_elastic():
-				odata_client._request("post", f"{odata_client.api}/EntityDefinitions", json=payload)
-				return True
-			try:
-				backoff_retry(_create_elastic)
-			except Exception as create_exc:
-				print({
-					"elastic_table": schema_name,
-					"skipped": True,
-					"reason": "Elastic table creation failed",
-					"error": str(create_exc),
-				})
-				return
-			ready = backoff_retry(lambda: odata_client._wait_for_entity_ready(schema_name), retry_http_statuses=())
-			if not ready or not ready.get("MetadataId"):
-				raise RuntimeError("Elastic demo table metadata not ready")
-			metadata = _fetch_metadata()
-			elastic_table_created_this_run = True
-		if not metadata:
-			print({"elastic_table": schema_name, "skipped": True, "reason": "Metadata unavailable"})
-			return
-		elastic_table_logical_name = metadata.get("LogicalName")
-		elastic_table_metadata_id = metadata.get("MetadataId")
-		odata_client._elastic_table_cache.pop(elastic_table_logical_name, None)
-		odata_client._logical_to_entityset_cache.pop(elastic_table_logical_name, None)
-		odata_client._logical_primaryid_cache.pop(elastic_table_logical_name, None)
-		is_elastic = odata_client._is_elastic_table(elastic_table_logical_name) if elastic_table_logical_name else False
-		print({
-			"elastic_table": schema_name,
-			"logical_name": elastic_table_logical_name,
-			"table_type_reported": metadata.get("TableType"),
-			"is_elastic": bool(is_elastic),
-		})
-		logical = elastic_table_logical_name
-		if not logical:
-			print({"elastic_table": schema_name, "skipped": True, "reason": "Logical name missing"})
-			return
-		prefix = logical.split("_", 1)[0] if "_" in logical else logical
-		name_key = f"{prefix}_name"
-		count_key = f"{prefix}_count"
-		flag_key = f"{prefix}_flag"
-		records = [
-			{name_key: "Elastic Demo A", count_key: 10, flag_key: True},
-			{name_key: "Elastic Demo B", count_key: 11, flag_key: False},
-			{name_key: "Elastic Demo C", count_key: 12, flag_key: True},
-		]
-		log_call(f"client.create('{logical}', <{len(records)} elastic records>)")
-		created_ids = backoff_retry(lambda: client.create(logical, records))
-		valid_ids = [rid for rid in created_ids if isinstance(rid, str)] if isinstance(created_ids, list) else []
-		if not valid_ids:
-			raise RuntimeError("Elastic demo record creation returned no GUIDs")
-		print({"elastic_create_ids": valid_ids})
-		log_call(f"client.delete('{logical}', <{len(valid_ids)} elastic ids>)")
-		backoff_retry(lambda: client.delete(logical, valid_ids))
-		print({
-			"elastic_delete_multiple": {
-				"requested": len(valid_ids),
-				"succeeded": True,
-			}
-		})
-	except Exception as exc:
-		print({"elastic_demo_error": str(exc)})
 
 # Enum demonstrating local option set creation with multilingual labels (for French labels to work, enable French language in the environment first)
 class Status(IntEnum):
@@ -215,10 +88,6 @@ class Status(IntEnum):
 		}
 	}
 
-pause("Run elastic DeleteMultiple demo")
-run_elastic_delete_demo()
-sys.exit(0)
-
 print("Ensure custom table exists (Metadata):")
 table_info = None
 created_this_run = False

src/dataverse_sdk/client.py

@@ -11,6 +11,7 @@
 from .config import DataverseConfig
 from .odata import ODataClient
 
+
 class DataverseClient:
     """
     High-level client for Microsoft Dataverse operations.
@@ -219,9 +220,6 @@ def delete(
         :raises TypeError: If ``ids`` is not str or list[str].
         :raises HttpError: If the underlying Web API delete request fails.
 
-        :return: ``None`` once the requested records have been deleted sequentially.
-        :rtype: None
-
         Example:
             Delete a single record::
 

src/dataverse_sdk/odata.py

@@ -288,7 +288,20 @@ def _update_by_ids(self, logical_name: str, ids: List[str], changes: Union[Dict[
         return None
 
     def _delete_multiple(self, logical_name: str, ids: List[str]) -> None:
-        """Delete many records synchronously via the DeleteMultiple collection action."""
+        """Delete records using the collection-bound DeleteMultiple action.
+
+        Parameters
+        ----------
+        logical_name : str
+            Singular logical entity name.
+        ids : list[str]
+            GUIDs for the records to remove.
+
+        Returns
+        -------
+        None
+            No representation is returned.
+        """
         entity_set = self._entity_set_from_logical(logical_name)
         pk_attr = self._primary_id_attr(logical_name)
         targets: List[Dict[str, Any]] = []