youngkingdom/ragflow
1
0
Fork 0
mirror of https://github.com/infiniflow/ragflow.git synced 2026-05-04 17:27:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

Feat: add delete all support for delete operations (#13530)

Browse Source 
### What problem does this PR solve?

Add delete all support for delete operations.

### Type of change

- [x] New Feature (non-breaking change which adds functionality)
- [x] Documentation Update

---------

Co-authored-by: writinwaters <cai.keith@gmail.com>
This commit is contained in:
Yongteng Lei
2026-03-12 09:47:42 +08:00
committed by GitHub
parent d201a81db7
commit e1b632a7bb
19 changed files with 1042 additions and 975 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
test/testcases/test_http_api/common.py
View File

@ -59,20 +59,7 @@ def delete_datasets(auth, payload=None, *, headers=HEADERS, data=None):
def delete_all_datasets(auth, *, page_size=1000):
# Dataset DELETE now treats null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
dataset_ids = []
while True:
res = list_datasets(auth, {"page": page, "page_size": page_size})
data = res.get("data") or []
dataset_ids.extend(dataset["id"] for dataset in data)
if len(data) < page_size:
break
page += 1
if not dataset_ids:
return {"code": 0, "message": ""}
return delete_datasets(auth, {"ids": dataset_ids})
return delete_datasets(auth, {"ids": None, "delete_all": True})
def batch_create_datasets(auth, num):
@ -146,20 +133,7 @@ def delete_documents(auth, dataset_id, payload=None):
def delete_all_documents(auth, dataset_id, *, page_size=1000):
# Document DELETE now treats missing/null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
document_ids = []
while True:
res = list_documents(auth, dataset_id, {"page": page, "page_size": page_size})
docs = (res.get("data") or {}).get("docs") or []
document_ids.extend(doc["id"] for doc in docs)
if len(docs) < page_size:
break
page += 1
if not document_ids:
return {"code": 0, "message": ""}
return delete_documents(auth, dataset_id, {"ids": document_ids})
return delete_documents(auth, dataset_id, {"ids": None, "delete_all": True})
def parse_documents(auth, dataset_id, payload=None):
@ -212,20 +186,7 @@ def delete_chunks(auth, dataset_id, document_id, payload=None):
def delete_all_chunks(auth, dataset_id, document_id, *, page_size=1000):
# Chunk DELETE now treats missing/null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
chunk_ids = []
while True:
res = list_chunks(auth, dataset_id, document_id, {"page": page, "page_size": page_size})
chunks = (res.get("data") or {}).get("chunks") or []
chunk_ids.extend(chunk["id"] for chunk in chunks)
if len(chunks) < page_size:
break
page += 1
if not chunk_ids:
return {"code": 0, "message": ""}
return delete_chunks(auth, dataset_id, document_id, {"chunk_ids": chunk_ids})
return delete_chunks(auth, dataset_id, document_id, {"chunk_ids": None, "delete_all": True})
def retrieval_chunks(auth, payload=None):
@ -268,20 +229,7 @@ def delete_chat_assistants(auth, payload=None):
def delete_all_chat_assistants(auth, *, page_size=1000):
# Chat DELETE now treats null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
chat_ids = []
while True:
res = list_chat_assistants(auth, {"page": page, "page_size": page_size})
data = res.get("data") or []
chat_ids.extend(chat["id"] for chat in data)
if len(data) < page_size:
break
page += 1
if not chat_ids:
return {"code": 0, "message": ""}
return delete_chat_assistants(auth, {"ids": chat_ids})
return delete_chat_assistants(auth, {"ids": None, "delete_all": True})
def batch_create_chat_assistants(auth, num):
@ -318,20 +266,7 @@ def delete_session_with_chat_assistants(auth, chat_assistant_id, payload=None):
def delete_all_sessions_with_chat_assistant(auth, chat_assistant_id, *, page_size=1000):
# Session DELETE now treats missing/null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
session_ids = []
while True:
res = list_session_with_chat_assistants(auth, chat_assistant_id, {"page": page, "page_size": page_size})
data = res.get("data") or []
session_ids.extend(session["id"] for session in data)
if len(data) < page_size:
break
page += 1
if not session_ids:
return {"code": 0, "message": ""}
return delete_session_with_chat_assistants(auth, chat_assistant_id, {"ids": session_ids})
return delete_session_with_chat_assistants(auth, chat_assistant_id, {"ids": None, "delete_all": True})
def batch_add_sessions_with_chat_assistant(auth, chat_assistant_id, num):
@ -439,20 +374,7 @@ def delete_agent_sessions(auth, agent_id, payload=None):
def delete_all_agent_sessions(auth, agent_id, *, page_size=1000):
# Agent session DELETE now treats missing/null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
session_ids = []
while True:
res = list_agent_sessions(auth, agent_id, {"page": page, "page_size": page_size})
data = res.get("data") or []
session_ids.extend(session["id"] for session in data)
if len(data) < page_size:
break
page += 1
if not session_ids:
return {"code": 0, "message": ""}
return delete_agent_sessions(auth, agent_id, {"ids": session_ids})
return delete_agent_sessions(auth, agent_id, {"ids": None, "delete_all": True})
def agent_completions(auth, agent_id, payload=None):

65
test/testcases/test_sdk_api/common.py
View File

@ -26,33 +26,11 @@ def batch_create_datasets(client: RAGFlow, num: int) -> list[DataSet]:
def delete_all_datasets(client: RAGFlow, *, page_size: int = 1000) -> None:
# Dataset DELETE now treats null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
dataset_ids: list[str] = []
while True:
datasets = client.list_datasets(page=page, page_size=page_size)
dataset_ids.extend(dataset.id for dataset in datasets)
if len(datasets) < page_size:
break
page += 1
if dataset_ids:
client.delete_datasets(ids=dataset_ids)
client.delete_datasets(delete_all=True)
def delete_all_chats(client: RAGFlow, *, page_size: int = 1000) -> None:
# Chat DELETE now treats null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
chat_ids: list[str] = []
while True:
chats = client.list_chats(page=page, page_size=page_size)
chat_ids.extend(chat.id for chat in chats)
if len(chats) < page_size:
break
page += 1
if chat_ids:
client.delete_chats(ids=chat_ids)
client.delete_chats(delete_all=True)
# FILE MANAGEMENT WITHIN DATASET
@ -68,48 +46,15 @@ def bulk_upload_documents(dataset: DataSet, num: int, tmp_path: Path) -> list[Do
def delete_all_documents(dataset: DataSet, *, page_size: int = 1000) -> None:
# Document DELETE now treats missing/null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
document_ids: list[str] = []
while True:
documents = dataset.list_documents(page=page, page_size=page_size)
document_ids.extend(document.id for document in documents)
if len(documents) < page_size:
break
page += 1
if document_ids:
dataset.delete_documents(ids=document_ids)
dataset.delete_documents(delete_all=True)
def delete_all_sessions(chat_assistant: Chat, *, page_size: int = 1000) -> None:
# Session DELETE now treats missing/null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
session_ids: list[str] = []
while True:
sessions = chat_assistant.list_sessions(page=page, page_size=page_size)
session_ids.extend(session.id for session in sessions)
if len(sessions) < page_size:
break
page += 1
if session_ids:
chat_assistant.delete_sessions(ids=session_ids)
chat_assistant.delete_sessions(delete_all=True)
def delete_all_chunks(document: Document, *, page_size: int = 1000) -> None:
# Chunk DELETE now treats missing/null/empty ids as a no-op, so cleanup must enumerate explicit ids.
page = 1
chunk_ids: list[str] = []
while True:
chunks = document.list_chunks(page=page, page_size=page_size)
chunk_ids.extend(chunk.id for chunk in chunks)
if len(chunks) < page_size:
break
page += 1
if chunk_ids:
document.delete_chunks(ids=chunk_ids)
document.delete_chunks(delete_all=True)
# CHUNK MANAGEMENT WITHIN DATASET