remove wait and add 2 modes for multi record delete

Author: Max Wang

README.md

@@ -39,7 +39,7 @@ Auth:
 | `update` | `update(logical_name, list[id], patch)` | `None` | Broadcast; same patch applied to all IDs (UpdateMultiple). |
 | `update` | `update(logical_name, list[id], list[patch])` | `None` | 1:1 patches; lengths must match (UpdateMultiple). |
 | `delete` | `delete(logical_name, id)` | `None` | Delete one record. |
-| `delete` | `delete(logical_name, list[id], ..., wait_poll_interval_seconds=2.0)` | `Optional[str]` | Delete many with async BulkDelete. |
+| `delete` | `delete(logical_name, list[id], use_bulk_delete=True)` | `Optional[str]` | Delete many with async BulkDelete or sequential single-record delete. |
 | `query_sql` | `query_sql(sql)` | `list[dict]` | Constrained read-only SELECT via `?sql=`. |
 | `create_table` | `create_table(tablename, schema, solution_unique_name=None)` | `dict` | Creates custom table + columns. Friendly name (e.g. `SampleItem`) becomes schema `new_SampleItem`; explicit schema name (contains `_`) used as-is. Pass `solution_unique_name` to attach the table to a specific solution instead of the default solution. |
 | `create_column` | `create_column(tablename, columns)` | `list[str]` | Adds columns using a `{name: type}` mapping (same shape as `create_table` schema). Returns schema names for the created columns. |
@@ -56,8 +56,8 @@ Guidelines:
 - `create` always returns a list of GUIDs (1 for single, N for bulk).
 - `update` always returns `None`.
 - Bulk update chooses broadcast vs per-record by the type of `changes` (dict vs list).
-- `delete` returns `None` for single-record delete and the BulkDelete async job ID for multi-record delete.
-- By default multi-record delete doesn't wait for the async job to complete. User can optionally wait for the job to complete.,klmmm 
+- `delete` returns `None` for single-record delete and sequential multi-record delete, and the BulkDelete async job ID for multi-record BulkDelete.
+- BulkDelete doesn't wait for the delete job to complete. It returns once the async delete job is scheduled.
 - Paging and SQL operations never mutate inputs.
 - Metadata lookups for logical name stamping cached per entity set (in-memory).
 
@@ -339,7 +339,8 @@ client.delete_table("SampleItem")       # delete table (friendly name or explici
 
 Notes:
 - `create` always returns a list of GUIDs (length 1 for single input).
-- `update` returns `None`. `delete` returns `None` for single-record delete and the BulkDelete async job ID for multi-record delete.
+- `update` returns `None`.
+- `delete` returns `None` for single-record delete/sequential multi-record delete, and the BulkDelete async job ID for BulkDelete.
 - Passing a list of payloads to `create` triggers bulk create and returns `list[str]` of IDs.
 - `get` supports single record retrieval with record id or paging through result sets (prefer `select` to limit columns).
 - For CRUD methods that take a record id, pass the GUID string (36-char hyphenated). Parentheses around the GUID are accepted but not required.

examples/quickstart.py

@@ -494,52 +494,48 @@ def run_paging_demo(label: str, *, top: Optional[int], page_size: Optional[int])
 		single_error: Optional[str] = None
 		bulk_job_id: Optional[str] = None
 		bulk_error: Optional[str] = None
-		bulk_wait_job_id: Optional[str] = None
-		bulk_wait_error: Optional[str] = None
-		async_targets: list[str] = []
-		wait_targets: list[str] = []
 
 		try:
 			log_call(f"client.delete('{logical}', '{single_target}')")
 			backoff_retry(lambda: client.delete(logical, single_target))
 		except Exception as ex:
 			single_error = str(ex)
 
-		if rest_targets:
-			half = len(rest_targets) // 2
-			async_targets = rest_targets[:half]
-			wait_targets = rest_targets[half:]
+		half = max(1, len(rest_targets) // 2)
+		bulk_targets = rest_targets[:half]
+		sequential_targets = rest_targets[half:]
+		bulk_error = None
+		sequential_error = None
 
-			try:
-				log_call(f"client.delete('{logical}', <{len(async_targets)} ids>) [fire-and-forget]")
-				bulk_job_id = client.delete(logical, async_targets)
-			except Exception as ex:
-				bulk_error = str(ex)
-			try:
-				log_call(f"client.delete('{logical}', <{len(wait_targets)} ids>, wait=True)")
-				bulk_wait_job_id = client.delete(
-					logical,
-					wait_targets,
-					wait=True,
-				)
-			except Exception as ex:
-				bulk_wait_error = str(ex)
+		# Fire-and-forget bulk delete for the first portion
+		try:
+			log_call(f"client.delete('{logical}', <{len(bulk_targets)} ids>, use_bulk_delete=True)")
+			bulk_job_id = client.delete(logical, bulk_targets)
+		except Exception as ex:
+			bulk_error = str(ex)
+
+		# Sequential deletes for the remainder
+		try:
+			log_call(f"client.delete('{logical}', <{len(sequential_targets)} ids>, use_bulk_delete=False)")
+			for rid in sequential_targets:
+				backoff_retry(lambda rid=rid: client.delete(logical, rid, use_bulk_delete=False))
+		except Exception as ex:
+			sequential_error = str(ex)
 
 		print({
 			"entity": logical,
 			"delete_single": {
 				"id": single_target,
 				"error": single_error,
 			},
-			"delete_bulk_fire_and_forget": {
-				"count": len(async_targets) if rest_targets else 0,
+			"delete_bulk": {
+				"count": len(bulk_targets),
 				"job_id": bulk_job_id,
 				"error": bulk_error,
 			},
-			"delete_bulk_wait": {
-				"count": len(wait_targets) if rest_targets else 0,
-				"job_id": bulk_wait_job_id,
-				"error": bulk_wait_error,
+			"delete_sequential": {
+				"count": len(sequential_targets),
+				"error": sequential_error,
 			},
 		})
 	else:

src/dataverse_sdk/client.py

@@ -205,9 +205,7 @@ def delete(
         self,
         logical_name: str,
         ids: Union[str, List[str]],
-        wait: bool = False,
-        wait_timeout_seconds: Optional[int] = 300,
-        wait_poll_interval_seconds: float = 2.0,
+        use_bulk_delete: bool = True,
     ) -> Optional[str]:
         """
         Delete one or more records by GUID.
@@ -216,16 +214,14 @@ def delete(
         :type logical_name: str
         :param ids: Single GUID string or list of GUID strings to delete.
         :type ids: str or list[str]
-        :param wait: When deleting multiple records, wait for the background job to complete. Ignored for single deletes.
-        :type wait: bool
-        :param wait_timeout_seconds: Optional timeout applied when ``wait`` is True. ``None`` or
-            values ``<= 0`` wait indefinitely. Defaults to 300 seconds.
-        :type wait_timeout_seconds: int or None
-        :param wait_poll_interval_seconds: Poll interval used while waiting for job completion.
-        :type wait_poll_interval_seconds: float
+        :param use_bulk_delete: When ``True`` (default) and ``ids`` is a list, execute the BulkDelete action and
+            return its async job identifier. When ``False`` each record is deleted sequentially.
+        :type use_bulk_delete: bool
+
         :raises TypeError: If ``ids`` is not str or list[str].
+        :raises HttpError: If the underlying Web API delete request fails.
         
-        :return: BulkDelete job ID when deleting multiple records; otherwise ``None``.
+        :return: BulkDelete job ID when deleting multiple records via BulkDelete; otherwise ``None``.
         :rtype: str or None
 
         Example:
@@ -243,13 +239,15 @@ def delete(
             return None
         if not isinstance(ids, list):
             raise TypeError("ids must be str or list[str]")
-        return od._delete_multiple(
-            logical_name,
-            ids,
-            wait=wait,
-            timeout_seconds=wait_timeout_seconds,
-            poll_interval_seconds=wait_poll_interval_seconds,
-        )
+        if not ids:
+            return None
+        if not all(isinstance(rid, str) for rid in ids):
+            raise TypeError("ids must contain string GUIDs")
+        if use_bulk_delete:
+            return od._delete_multiple(logical_name, ids)
+        for rid in ids:
+            od._delete(logical_name, rid)
+        return None
 
     def get(
         self,

src/dataverse_sdk/odata.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, List, Union, Iterable, Tuple
+from typing import Any, Dict, Optional, List, Union, Iterable
 from enum import Enum
 import unicodedata
 import time
@@ -286,14 +286,10 @@ def _delete_multiple(
         self,
         logical_name: str,
         ids: List[str],
-        wait: bool = False,
-        timeout_seconds: Optional[int] = 300,
-        poll_interval_seconds: float = 2.0,
     ) -> Optional[str]:
         """Delete many records by GUID list.
 
-        Returns the asynchronous job identifier. When ``wait`` is True the call blocks until the
-        async operation completes or the timeout elapses.
+        Returns the asynchronous job identifier reported by the BulkDelete action.
         """
         if not isinstance(ids, list):
             raise TypeError("ids must be list[str]")
@@ -308,8 +304,6 @@ def _delete_multiple(
         timestamp = datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
         job_label = f"Bulk delete {logical_name} records @ {timestamp}"
 
-        when_utc = timestamp
-
         query = {
             "@odata.type": "Microsoft.Dynamics.CRM.QueryExpression",
             "EntityName": logical_name,
@@ -338,7 +332,7 @@ def _delete_multiple(
             "ToRecipients": [],
             "CCRecipients": [],
             "RecurrencePattern": "",
-            "StartDateTime": when_utc,
+            "StartDateTime": timestamp,
             "QuerySet": [query],
         }
 
@@ -353,116 +347,8 @@ def _delete_multiple(
         if isinstance(body, dict):
             job_id = body.get("JobId")
 
-        if wait and job_id:
-            payload, succeeded = self._wait_for_async_job(
-                job_id,
-                timeout_seconds=timeout_seconds,
-                poll_interval=poll_interval_seconds,
-            )
-            if not succeeded:
-                state = payload.get("statecode")
-                status = payload.get("statuscode")
-                message = payload.get("message")
-                raise RuntimeError(
-                    f"Bulk delete async job '{job_id}' did not succeed (state={state}, status={status})."
-                    + (f" Message: {message}" if message else "")
-                )
-
         return job_id
 
-    def _wait_for_async_job(
-        self,
-        job_id: str,
-        timeout_seconds: Optional[int] = 300,
-        poll_interval: float = 2.0,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """Poll the asyncoperation record until completion or timeout.
-
-        Returns the last payload and a boolean indicating success.
-        """
-        if not job_id:
-            return {}, False
-
-        interval = poll_interval if poll_interval and poll_interval > 0 else 2.0
-        deadline = None
-        if timeout_seconds is not None and timeout_seconds > 0:
-            deadline = time.time() + timeout_seconds
-
-        url = f"{self.api}/asyncoperations({job_id})"
-        params = {"$select": "statecode,statuscode,name,message"}
-        last_payload: Dict[str, Any] = {}
-
-        while True:
-            now = time.time()
-            if deadline and now >= deadline:
-                message = last_payload.get("message") if last_payload else None
-                raise TimeoutError(
-                    f"Timed out waiting for async job '{job_id}' to complete."
-                    + (f" Last message: {message}" if message else "")
-                )
-
-            try:
-                response = self._request("get", url, params=params)
-                try:
-                    payload = response.json() if response.text else {}
-                except ValueError:
-                    payload = {}
-                if isinstance(payload, dict):
-                    last_payload = payload
-                else:
-                    last_payload = {}
-            except HttpError as err:
-                if getattr(err, "status_code", None) == 404:
-                    # The job record might not be immediately available yet; retry until timeout.
-                    time.sleep(interval)
-                    continue
-                raise
-
-            state = last_payload.get("statecode")
-            status = last_payload.get("statuscode")
-            finished, succeeded = self._interpret_async_job_state(state, status)
-            if finished:
-                return last_payload, succeeded
-
-            time.sleep(interval)
-
-    @staticmethod
-    def _interpret_async_job_state(state_raw: Any, status_raw: Any) -> Tuple[bool, bool]:
-        """Return (finished, succeeded) flags for an asyncoperation state/status."""
-
-        def _norm(val: Any) -> str:
-            if val is None:
-                return ""
-            if isinstance(val, str):
-                return val.strip().lower()
-            return str(val).strip().lower()
-
-        state_norm = _norm(state_raw)
-        status_norm = _norm(status_raw)
-
-        finished = False
-        succeeded = False
-
-        if state_norm in {"3", "completed", "complete", "succeeded"}:
-            finished = True
-
-        if status_norm in {"30", "succeeded", "success", "completed"}:
-            finished = True
-            succeeded = True
-        elif status_norm in {"31", "failed", "failure"}:
-            finished = True
-            succeeded = False
-        elif status_norm in {"32", "33", "canceled", "cancelled"}:
-            finished = True
-            succeeded = False
-        elif status_norm.isdigit():
-            code = int(status_norm)
-            if code >= 30:
-                finished = True
-                succeeded = (code == 30)
-
-        return finished, succeeded
-
     def _format_key(self, key: str) -> str:
         k = key.strip()
         if k.startswith("(") and k.endswith(")"):