SDKs
Python SDK (Beta) v1.X
Data API
Write Operations
Delete Data

Delete Data

The SDK deletes records by Entry ID. For large ID lists, requests are batched automatically using deletePageSize / delete_concurrency from config; HTTP via intapp-rest-client.

Delete by Entry ID

from dealcloud_sdk import DealCloud, DealCloudConfig
 
config = DealCloudConfig(
    siteUrl="yoursite.dealcloud.com",
    clientId=12345,
    clientSecret="your-secret",
)
dc = DealCloud.from_config_object(config)
 
# Delete specific records
entry_ids = [12345, 12346, 12347]
result = dc.delete_data("Company", entry_ids)

Delete Methods

MethodPurposeUse Case
delete_data()Delete by Entry IDsSpecific records

delete_data()

Delete specific records by their Entry IDs:

# Delete by IDs
result = dc.delete_data("Company", [12345, 12346])
 
# Check result
for record in result:
    print(f"Deleted: EntryId {record['entryId']}")

Finding Entry IDs to Delete

# Read then delete
inactive = dc.read_data(
    "Company",
    output="list",
    fields=["EntryId"],
    query="{Status: 'Inactive'}"
)
 
ids_to_delete = [r["EntryId"] for r in inactive]
 
if ids_to_delete:
    dc.delete_data("Company", ids_to_delete)
    print(f"Deleted {len(ids_to_delete)} inactive companies")

Parameters

delete_data()

ParameterTypeDescription
object_idstr | intObject API name or ID
recordsList[int]Entry IDs to delete

Return Value

result = dc.delete_data("Company", [12345, 12346])
 
# Result structure
print(result)
# [
#     {'entryId': 12345, 'fieldId': 0, 'rowId': 4935650, 'isNoData': False},
#     {'entryId': 12346, 'fieldId': 0, 'rowId': 4935651, 'isNoData': False}
# ]

Batch Deletion

For large deletions, the SDK handles batching automatically:

# Delete 10,000 records - batched automatically
large_id_list = list(range(10000, 20000))
dc.delete_data("TestObject", large_id_list)

With Progress Tracking

def delete_with_progress(dc, object_id, entry_ids, batch_size=1000):
    """Delete with progress reporting."""
    total = len(entry_ids)
    deleted = 0
    
    for i in range(0, total, batch_size):
        batch = entry_ids[i:i + batch_size]
        dc.delete_data(object_id, batch)
        deleted += len(batch)
        print(f"Deleted {deleted}/{total}")
    
    return deleted

Soft Delete Pattern

Instead of deleting, mark records as inactive:

def soft_delete(dc, object_id, entry_ids, status_field="Status", deleted_status=999):
    """Mark records as deleted instead of removing."""
    updates = [{"EntryId": eid, status_field: deleted_status} for eid in entry_ids]
    dc.update_data(object_id, updates)
    return len(updates)
 
# Usage
soft_delete(dc, "Company", [12345, 12346])

Cleanup Workflow

Complete cleanup workflow with safety checks:

from dealcloud_sdk import DealCloud, DealCloudConfig
from datetime import datetime, timedelta
 
config = DealCloudConfig(
    siteUrl="yoursite.dealcloud.com",
    clientId=12345,
    clientSecret="your-secret",
)
dc = DealCloud.from_config_object(config)
 
def cleanup_old_records(object_id: str, days_old: int = 90, dry_run: bool = True):
    """Delete records older than specified days."""
    
    cutoff = (datetime.now() - timedelta(days=days_old)).strftime("%Y-%m-%d")
    
    # Find old records
    old_records = dc.read_data(
        object_id,
        output="list",
        fields=["EntryId", "CreatedDate"],
        query=f"{{CreatedDate: {{$lt: '{cutoff}'}}}}"
    )
    
    print(f"Found {len(old_records)} records older than {days_old} days")
    
    if dry_run:
        print("DRY RUN - no records deleted")
        return 0
    
    if old_records:
        ids = [r["EntryId"] for r in old_records]
        dc.delete_data(object_id, ids)
        print(f"Deleted {len(ids)} records")
        return len(ids)
    
    return 0
 
# Preview first
cleanup_old_records("AuditLog", days_old=180, dry_run=True)
 
# Then execute
# cleanup_old_records("AuditLog", days_old=180, dry_run=False)

Error Handling

delete_data supports raise_on_row_errors and populates BatchResult.row_errors when error_handling=ErrorHandling.COLLECT.

from dealcloud_sdk import ErrorHandling, DealCloudValidationError
 
# Default: return API body (may include rows with "Errors")
result = dc.delete_data("Company", [12345, 99999])
 
# Strict row errors
try:
    dc.delete_data("Company", entry_ids, raise_on_row_errors=True)
except DealCloudValidationError as e:
    print(e.row_errors)
 
# COLLECT transport + row errors
batch = dc.delete_data(
    "Company",
    entry_ids,
    error_handling=ErrorHandling.COLLECT,
)
print(batch.row_errors, batch.errors)

Transport failures (HTTP 4xx/5xx) raise or appear in BatchResult.errors depending on error_handling.

Non-Existent IDs

Attempting to delete non-existent IDs typically doesn't raise an error but returns empty results for those IDs.

Best Practices

  1. Always verify before deleting large sets of records — Preview what will be deleted
  2. Scope deletes with read_data — Use a view_id or query to list EntryIds, then pass those IDs to delete_data()
  3. Consider soft delete - Often preferable to hard delete
  4. Backup before large deletes - Use request_backup() first
  5. Use dry-run patterns - Test logic before executing

Related

Upsert DataID Mapping