From 1c5a22e226243ad0f9ab04c07f54c2d3ba0ca2ae Mon Sep 17 00:00:00 2001 From: Wang Qi Date: Tue, 21 Jul 2026 20:18:20 +0800 Subject: [PATCH] Enrich the ragflow_client.py (#17189) --- admin/client/ragflow_client.py | 754 +++++++++++++++++++++------------ 1 file changed, 479 insertions(+), 275 deletions(-) diff --git a/admin/client/ragflow_client.py b/admin/client/ragflow_client.py index a41e8926eb..0a59a497e4 100644 --- a/admin/client/ragflow_client.py +++ b/admin/client/ragflow_client.py @@ -107,25 +107,28 @@ class RAGFlowClient: print(f"Register user: {nickname}, email: {username}, password: ******") payload = {"email": username, "nickname": nickname, "password": enc_password} response = self.http_client.request(method="POST", path="/users", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json["code"] == 0: self._print_table_simple(res_json["data"]) else: print(f"Fail to register user {username}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to register user {username}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to register user {username}, code: {response.status_code}, body: {response.text}") def list_services(self): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/services", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to get all services, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to get all services, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to get all services, code: {response.status_code}, body: {response.text}") pass def show_service(self, command): @@ -135,23 +138,26 @@ class RAGFlowClient: service_id: int = command["number"] response = self.http_client.request("GET", f"/admin/services/{service_id}", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - res_data = res_json["data"] - if "status" in res_data and res_data["status"] == "alive": - print(f"Service {res_data['service_name']} is alive, ") - res_message = res_data["message"] - if res_message is None: - return - elif isinstance(res_message, str): - print(res_message) + res_json = response.json() + if res_json["code"] == 0: + res_data = res_json["data"] + if "status" in res_data and res_data["status"] == "alive": + print(f"Service {res_data['service_name']} is alive, ") + res_message = res_data["message"] + if res_message is None: + return + elif isinstance(res_message, str): + print(res_message) + else: + data = self._format_service_detail_table(res_message) + self._print_table_simple(data) else: - data = self._format_service_detail_table(res_message) - self._print_table_simple(data) + print(f"Service {res_data['service_name']} is down, {res_data['message']}") else: - print(f"Service {res_data['service_name']} is down, {res_data['message']}") + print(f"Fail to show service, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to show service, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to show service, code: {response.status_code}, body: {response.text}") def restart_service(self, command): if self.server_type != "admin": @@ -179,11 +185,14 @@ class RAGFlowClient: print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/users", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to get all users, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to get all users, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to get all users, code: {response.status_code}, body: {response.text}") def show_user(self, command): if self.server_type != "admin": @@ -193,13 +202,16 @@ class RAGFlowClient: user_name: str = username_tree.children[0].strip("'\"") print(f"Showing user: {user_name}") response = self.http_client.request("GET", f"/admin/users/{user_name}", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - table_data = res_json["data"][0] - table_data.pop("avatar") - self._print_table_simple(table_data) + res_json = response.json() + if res_json["code"] == 0: + table_data = res_json["data"][0] + table_data.pop("avatar") + self._print_table_simple(table_data) + else: + print(f"Fail to get user {user_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to get user {user_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to get user {user_name}, code: {response.status_code}, body: {response.text}") def drop_user(self, command): if self.server_type != "admin": @@ -209,11 +221,14 @@ class RAGFlowClient: user_name: str = username_tree.children[0].strip("'\"") print(f"Drop user: {user_name}") response = self.http_client.request("DELETE", f"/admin/users/{user_name}", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print(res_json["message"]) + res_json = response.json() + if res_json["code"] == 0: + print(res_json["message"]) + else: + print(f"Fail to drop user, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to drop user, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to drop user, code: {response.status_code}, body: {response.text}") def alter_user(self, command): if self.server_type != "admin": @@ -225,11 +240,14 @@ class RAGFlowClient: password: str = password_tree.children[0].strip("'\"") print(f"Alter user: {user_name}, password: ******") response = self.http_client.request("PUT", f"/admin/users/{user_name}/password", json_body={"new_password": encrypt_password(password)}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print(res_json["message"]) + res_json = response.json() + if res_json["code"] == 0: + print(res_json["message"]) + else: + print(f"Fail to alter password, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to alter password, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to alter password, code: {response.status_code}, body: {response.text}") def create_user(self, command): if self.server_type != "admin": @@ -244,11 +262,14 @@ class RAGFlowClient: # enpass1 = encrypt(password) enc_password = encrypt_password(password) response = self.http_client.request(method="POST", path="/admin/users", json_body={"username": user_name, "password": enc_password, "role": role}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to create user {user_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to create user {user_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to create user {user_name}, code: {response.status_code}, body: {response.text}") def activate_user(self, command): if self.server_type != "admin": @@ -261,11 +282,14 @@ class RAGFlowClient: if activate_status.lower() in ["on", "off"]: print(f"Alter user {user_name} activate status, turn {activate_status.lower()}.") response = self.http_client.request("PUT", f"/admin/users/{user_name}/activate", json_body={"activate_status": activate_status}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print(res_json["message"]) + res_json = response.json() + if res_json["code"] == 0: + print(res_json["message"]) + else: + print(f"Fail to alter activate status, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to alter activate status, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to alter activate status, code: {response.status_code}, body: {response.text}") else: print(f"Unknown activate status: {activate_status}.") @@ -276,11 +300,14 @@ class RAGFlowClient: user_name_tree: Tree = command["user_name"] user_name: str = user_name_tree.children[0].strip("'\"") response = self.http_client.request("PUT", f"/admin/users/{user_name}/admin", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print(res_json["message"]) + res_json = response.json() + if res_json["code"] == 0: + print(res_json["message"]) + else: + print(f"Fail to grant {user_name} admin authorization, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to grant {user_name} admin authorization, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to grant {user_name} admin authorization, code: {response.status_code}, body: {response.text}") def revoke_admin(self, command): if self.server_type != "admin": @@ -289,11 +316,14 @@ class RAGFlowClient: user_name_tree: Tree = command["user_name"] user_name: str = user_name_tree.children[0].strip("'\"") response = self.http_client.request("DELETE", f"/admin/users/{user_name}/admin", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print(res_json["message"]) + res_json = response.json() + if res_json["code"] == 0: + print(res_json["message"]) + else: + print(f"Fail to revoke {user_name} admin authorization, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to revoke {user_name} admin authorization, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to revoke {user_name} admin authorization, code: {response.status_code}, body: {response.text}") def create_role(self, command): if self.server_type != "admin": @@ -308,11 +338,14 @@ class RAGFlowClient: print(f"create role name: {role_name}, description: {desc_str}") response = self.http_client.request("POST", "/admin/roles", json_body={"role_name": role_name, "description": desc_str}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to create role {role_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to create role {role_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to create role {role_name}, code: {response.status_code}, body: {response.text}") def drop_role(self, command): if self.server_type != "admin": @@ -322,11 +355,14 @@ class RAGFlowClient: role_name: str = role_name_tree.children[0].strip("'\"") print(f"drop role name: {role_name}") response = self.http_client.request("DELETE", f"/admin/roles/{role_name}", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to drop role {role_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to drop role {role_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to drop role {role_name}, code: {response.status_code}, body: {response.text}") def alter_role(self, command): if self.server_type != "admin": @@ -339,22 +375,28 @@ class RAGFlowClient: print(f"alter role name: {role_name}, description: {desc_str}") response = self.http_client.request("PUT", f"/admin/roles/{role_name}", json_body={"description": desc_str}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to update role {role_name} with description: {desc_str}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to update role {role_name} with description: {desc_str}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to update role {role_name} with description: {desc_str}, code: {response.status_code}, body: {response.text}") def list_roles(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/roles", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to list roles, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list roles, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list roles, code: {response.status_code}, body: {response.text}") def show_role(self, command): if self.server_type != "admin": @@ -364,11 +406,14 @@ class RAGFlowClient: role_name: str = role_name_tree.children[0].strip("'\"") print(f"show role: {role_name}") response = self.http_client.request("GET", f"/admin/roles/{role_name}/permission", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to list roles, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list roles, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list roles, code: {response.status_code}, body: {response.text}") def grant_permission(self, command): if self.server_type != "admin": @@ -385,11 +430,14 @@ class RAGFlowClient: actions.append(action_str) print(f"grant role_name: {role_name_str}, resource: {resource_str}, actions: {actions}") response = self.http_client.request("POST", f"/admin/roles/{role_name_str}/permission", json_body={"actions": actions, "resource": resource_str}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to grant role {role_name_str} with {actions} on {resource_str}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to grant role {role_name_str} with {actions} on {resource_str}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to grant role {role_name_str} with {actions} on {resource_str}, code: {response.status_code}, body: {response.text}") def revoke_permission(self, command): if self.server_type != "admin": @@ -406,11 +454,14 @@ class RAGFlowClient: actions.append(action_str) print(f"revoke role_name: {role_name_str}, resource: {resource_str}, actions: {actions}") response = self.http_client.request("DELETE", f"/admin/roles/{role_name_str}/permission", json_body={"actions": actions, "resource": resource_str}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to revoke role {role_name_str} with {actions} on {resource_str}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to revoke role {role_name_str} with {actions} on {resource_str}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to revoke role {role_name_str} with {actions} on {resource_str}, code: {response.status_code}, body: {response.text}") def alter_user_role(self, command): if self.server_type != "admin": @@ -422,11 +473,14 @@ class RAGFlowClient: user_name_str: str = user_name_tree.children[0].strip("'\"") print(f"alter_user_role user_name: {user_name_str}, role_name: {role_name_str}") response = self.http_client.request("PUT", f"/admin/users/{user_name_str}/role", json_body={"role_name": role_name_str}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to alter user: {user_name_str} to role {role_name_str}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to alter user: {user_name_str} to role {role_name_str}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to alter user: {user_name_str} to role {role_name_str}, code: {response.status_code}, body: {response.text}") def show_user_permission(self, command): if self.server_type != "admin": @@ -436,11 +490,14 @@ class RAGFlowClient: user_name_str: str = user_name_tree.children[0].strip("'\"") print(f"show_user_permission user_name: {user_name_str}") response = self.http_client.request("GET", f"/admin/users/{user_name_str}/permission", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to show user: {user_name_str} permission, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to show user: {user_name_str} permission, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to show user: {user_name_str} permission, code: {response.status_code}, body: {response.text}") def generate_key(self, command: dict[str, Any]) -> None: if self.server_type != "admin": @@ -450,11 +507,14 @@ class RAGFlowClient: user_name: str = username_tree.children[0].strip("'\"") print(f"Generating API key for user: {user_name}") response = self.http_client.request("POST", f"/admin/users/{user_name}/keys", use_api_base=True, auth_kind="admin") - res_json: dict[str, Any] = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json: dict[str, Any] = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Failed to generate key for user {user_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Failed to generate key for user {user_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Failed to generate key for user {user_name}, code: {response.status_code}, body: {response.text}") def list_keys(self, command: dict[str, Any]) -> None: if self.server_type != "admin": @@ -464,11 +524,14 @@ class RAGFlowClient: user_name: str = username_tree.children[0].strip("'\"") print(f"Listing API keys for user: {user_name}") response = self.http_client.request("GET", f"/admin/users/{user_name}/keys", use_api_base=True, auth_kind="admin") - res_json: dict[str, Any] = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json: dict[str, Any] = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Failed to list keys for user {user_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Failed to list keys for user {user_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Failed to list keys for user {user_name}, code: {response.status_code}, body: {response.text}") def drop_key(self, command: dict[str, Any]) -> None: if self.server_type != "admin": @@ -482,11 +545,14 @@ class RAGFlowClient: # URL encode the key to handle special characters encoded_key: str = urllib.parse.quote(key, safe="") response = self.http_client.request("DELETE", f"/admin/users/{user_name}/keys/{encoded_key}", use_api_base=True, auth_kind="admin") - res_json: dict[str, Any] = response.json() if response.status_code == 200: - print(res_json["message"]) + res_json: dict[str, Any] = response.json() + if res_json["code"] == 0: + print(res_json["message"]) + else: + print(f"Failed to drop key for user {user_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Failed to drop key for user {user_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Failed to drop key for user {user_name}, code: {response.status_code}, body: {response.text}") def set_variable(self, command): if self.server_type != "admin": @@ -495,11 +561,14 @@ class RAGFlowClient: var_name = _strip_tree_value(command["var_name"]) var_value = _strip_tree_value(command["var_value"]) response = self.http_client.request("PUT", "/admin/variables", json_body={"var_name": var_name, "var_value": var_value}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print(res_json["message"]) + res_json = response.json() + if res_json["code"] == 0: + print(res_json["message"]) + else: + print(f"Fail to set variable {var_name} to {var_value}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to set variable {var_name} to {var_value}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to set variable {var_name} to {var_value}, code: {response.status_code}, body: {response.text}") def show_variable(self, command): if self.server_type != "admin": @@ -507,65 +576,83 @@ class RAGFlowClient: var_name = _strip_tree_value(command["var_name"]) response = self.http_client.request(method="GET", path="/admin/variables", json_body={"var_name": var_name}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to get variable {var_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to get variable {var_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to get variable {var_name}, code: {response.status_code}, body: {response.text}") def list_variables(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/variables", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to list variables, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list variables, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list variables, code: {response.status_code}, body: {response.text}") def list_configs(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/configs", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to list variables, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list variables, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list variables, code: {response.status_code}, body: {response.text}") def list_environments(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/environments", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to list variables, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list variables, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list variables, code: {response.status_code}, body: {response.text}") def show_fingerprint(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/fingerprint", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to show fingerprint, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to show fingerprint, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to show fingerprint, code: {response.status_code}, body: {response.text}") def set_license(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") license = command["license"] response = self.http_client.request("POST", "/admin/license", json_body={"license": license}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print("Set license successfully") + res_json = response.json() + if res_json["code"] == 0: + print("Set license successfully") + else: + print(f"Fail to set license, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to set license, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to set license, code: {response.status_code}, body: {response.text}") def set_license_config(self, command): if self.server_type != "admin": @@ -573,35 +660,47 @@ class RAGFlowClient: value1 = command["value1"] value2 = command["value2"] response = self.http_client.request("POST", "/admin/license/config", json_body={"value1": value1, "value2": value2}, use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print("Set license successfully") + res_json = response.json() + if res_json["code"] == 0: + print("Set license successfully") + else: + print(f"Fail to set license, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to set license, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to set license, code: {response.status_code}, body: {response.text}") def show_license(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/license", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to show license, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to show license, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to show license, code: {response.status_code}, body: {response.text}") def check_license(self, command): if self.server_type != "admin": print("This command is only allowed in ADMIN mode") response = self.http_client.request("GET", "/admin/license?check=true", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - print(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + print(res_json["data"]) + else: + print(f"Fail to show license, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to show license, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to show license, code: {response.status_code}, body: {response.text}") def list_server_configs(self, command): """List server configs by calling /system/configs API and flattening the JSON response.""" response = self.http_client.request("GET", "/system/configs", use_api_base=False, auth_kind="web") + if response.status_code != 200: + print(f"Fail to list server configs, code: {response.status_code}, body: {response.text}") + return res_json = response.json() if res_json.get("code") != 0: print(f"Fail to list server configs, code: {res_json.get('code')}, message: {res_json.get('message')}") @@ -644,14 +743,17 @@ class RAGFlowClient: print(f"Listing all datasets of user: {user_name}") response = self.http_client.request("GET", f"/admin/users/{user_name}/datasets", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - table_data = res_json["data"] - for t in table_data: - t.pop("avatar") - self._print_table_simple(table_data) + res_json = response.json() + if res_json["code"] == 0: + table_data = res_json["data"] + for t in table_data: + t.pop("avatar") + self._print_table_simple(table_data) + else: + print(f"Fail to get all datasets of {user_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to get all datasets of {user_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to get all datasets of {user_name}, code: {response.status_code}, body: {response.text}") def handle_list_agents(self, command): if self.server_type != "admin": @@ -661,14 +763,17 @@ class RAGFlowClient: user_name: str = username_tree.children[0].strip("'\"") print(f"Listing all agents of user: {user_name}") response = self.http_client.request("GET", f"/admin/users/{user_name}/agents", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - table_data = res_json["data"] - for t in table_data: - t.pop("avatar") - self._print_table_simple(table_data) + res_json = response.json() + if res_json["code"] == 0: + table_data = res_json["data"] + for t in table_data: + t.pop("avatar") + self._print_table_simple(table_data) + else: + print(f"Fail to get all agents of {user_name}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to get all agents of {user_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to get all agents of {user_name}, code: {response.status_code}, body: {response.text}") def show_current_user(self, command): if self.server_type != "user": @@ -685,29 +790,37 @@ class RAGFlowClient: # Step 1: Add provider provider_payload = {"provider_name": provider_name} provider_response = self.http_client.request("PUT", "/providers", json_body=provider_payload, use_api_base=True, auth_kind="web") - provider_res = provider_response.json() - if provider_response.status_code == 200 and provider_res.get("code") == 0: - print(f"Success to add provider {provider_name}") - else: - msg = provider_res.get("message", "") - if "duplicated" in msg.lower() or "already exist" in msg.lower(): - print(f"Note: provider {provider_name} already exists, continuing to add instance") + if provider_response.status_code == 200: + provider_res = provider_response.json() + if provider_res.get("code") == 0: + print(f"Success to add provider {provider_name}") else: - print(f"Fail to add provider {provider_name}, code: {provider_res.get('code')}, message: {msg}") - return + msg = provider_res.get("message", "") + if "duplicated" in msg.lower() or "already exist" in msg.lower(): + print(f"Note: provider {provider_name} already exists, continuing to add instance") + else: + print(f"Fail to add provider {provider_name}, code: {provider_res.get('code')}, message: {msg}") + return + else: + print(f"Fail to add provider {provider_name}, code: {provider_response.status_code}, body: {provider_response.text}") + return # Step 2: Add instance instance_payload = {"instance_name": "default", "api_key": api_key, "region": "default", "base_url": ""} instance_response = self.http_client.request("POST", f"/providers/{provider_name}/instances", json_body=instance_payload, use_api_base=True, auth_kind="web") - instance_res = instance_response.json() - if instance_response.status_code == 200 and instance_res.get("code") == 0: - print(f"Success to add instance for provider {provider_name}") - else: - msg = instance_res.get("message", "") - if "already exist" in msg.lower(): - print(f"Note: instance for provider {provider_name} already exists, skipping") + if instance_response.status_code == 200: + instance_res = instance_response.json() + if instance_res.get("code") == 0: + print(f"Success to add instance for provider {provider_name}") else: - print(f"Fail to add instance for provider {provider_name}, code: {instance_res.get('code')}, message: {msg}") + msg = instance_res.get("message", "") + if "already exist" in msg.lower(): + print(f"Note: instance for provider {provider_name} already exists, skipping") + else: + print(f"Fail to add instance for provider {provider_name}, code: {instance_res.get('code')}, message: {msg}") + + else: + print(f"Fail to add instance for provider {provider_name}, code: {instance_response.status_code}, body: {instance_response.text}") def drop_model_provider(self, command): if self.server_type != "user": @@ -715,11 +828,15 @@ class RAGFlowClient: return provider_name: str = command["provider_name"] response = self.http_client.request("DELETE", f"/providers/{provider_name}", use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json.get("code") == 0: - print(f"Success to drop model provider {provider_name}") + if response.status_code == 200: + res_json = response.json() + if res_json.get("code") == 0: + print(f"Success to drop model provider {provider_name}") + else: + print(f"Fail to drop model provider {provider_name}, code: {res_json.get('code')}, message: {res_json.get('message')}") + else: - print(f"Fail to drop model provider {provider_name}, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to drop model provider {provider_name}, code: {response.status_code}, body: {response.text}") # Mapping from legacy model_type keys to API model_type values _MODEL_TYPE_MAP = { @@ -753,11 +870,15 @@ class RAGFlowClient: "model_name": model_name, } response = self.http_client.request("PATCH", "/models/default", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json.get("code") == 0: - print(f"Success to set default {model_type} to {model_id}") + if response.status_code == 200: + res_json = response.json() + if res_json.get("code") == 0: + print(f"Success to set default {model_type} to {model_id}") + else: + print(f"Fail to set default {model_type}, code: {res_json.get('code')}, message: {res_json.get('message')}") + else: - print(f"Fail to set default {model_type}, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to set default {model_type}, code: {response.status_code}, body: {response.text}") def reset_default_model(self, command): if self.server_type != "user": @@ -772,11 +893,15 @@ class RAGFlowClient: payload = {"model_type": model_type} response = self.http_client.request("PATCH", "/models/default", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json.get("code") == 0: - print(f"Success to reset default {model_type}") + if response.status_code == 200: + res_json = response.json() + if res_json.get("code") == 0: + print(f"Success to reset default {model_type}") + else: + print(f"Fail to reset default {model_type}, code: {res_json.get('code')}, message: {res_json.get('message')}") + else: - print(f"Fail to reset default {model_type}, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to reset default {model_type}, code: {response.status_code}, body: {response.text}") @staticmethod def _parse_model_id(model_id: str): @@ -805,11 +930,14 @@ class RAGFlowClient: return response else: response = self.http_client.request("GET", "/datasets", use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to list datasets, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list datasets, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list datasets, code: {response.status_code}, body: {response.text}") return None def create_user_dataset(self, command): @@ -821,11 +949,14 @@ class RAGFlowClient: if "pipeline" in command: payload["pipeline_id"] = command["pipeline"] response = self.http_client.request("POST", "/datasets", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to create datasets, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to create datasets, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to create datasets, code: {response.status_code}, body: {response.text}") def drop_user_dataset(self, command): if self.server_type != "user": @@ -837,11 +968,14 @@ class RAGFlowClient: return payload = {"ids": [dataset_id]} response = self.http_client.request("DELETE", "/datasets", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code == 200: - print(f"Drop dataset {dataset_name} successfully") + res_json = response.json() + if res_json["code"] == 0: + print(f"Drop dataset {dataset_name} successfully") + else: + print(f"Fail to drop datasets, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to drop datasets, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to drop datasets, code: {response.status_code}, body: {response.text}") def list_user_dataset_files(self, command_dict): if self.server_type != "user": @@ -917,11 +1051,14 @@ class RAGFlowClient: dataset_ids = [dataset_id for _, dataset_id in valid_datasets] kb_ids_param = ",".join(dataset_ids) response = self.http_client.request("GET", f"/kb/get_meta?kb_ids={kb_ids_param}", use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code != 200: - print(f"Fail to get metadata, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to get metadata, code: {response.status_code}, body: {response.text}") return + res_json = response.json() + if res_json.get("code") != 0: + print(f"Fail to get metadata, code: {res_json.get('code')}, message: {res_json.get('message')}") + return meta = res_json.get("data", {}) if not meta: print("No metadata found") @@ -949,42 +1086,48 @@ class RAGFlowClient: if doc_ids: payload["doc_ids"] = doc_ids response = self.http_client.request("POST", "/document/metadata/summary", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: - summary = res_json.get("data", {}).get("summary", {}) - if not summary: + res_json = response.json() + if res_json["code"] == 0: + summary = res_json.get("data", {}).get("summary", {}) + if not summary: + if doc_ids: + print(f"No metadata summary found for documents: {', '.join(doc_ids)}") + else: + print(f"No metadata summary found in dataset {dataset_name}") + return if doc_ids: - print(f"No metadata summary found for documents: {', '.join(doc_ids)}") + print(f"Metadata summary for document(s): {', '.join(doc_ids)}") else: - print(f"No metadata summary found in dataset {dataset_name}") - return - if doc_ids: - print(f"Metadata summary for document(s): {', '.join(doc_ids)}") + print(f"Metadata summary for all documents in dataset: {dataset_name}") + print("-" * 60) + for field_name, field_info in summary.items(): + field_type = field_info.get("type", "unknown") + values = field_info.get("values", []) + print(f"\nField: {field_name} (type: {field_type})") + print(f" Total unique values: {len(values)}") + if values: + print(" Values:") + for value, count in values: + print(f" {value}: {count}") else: - print(f"Metadata summary for all documents in dataset: {dataset_name}") - print("-" * 60) - for field_name, field_info in summary.items(): - field_type = field_info.get("type", "unknown") - values = field_info.get("values", []) - print(f"\nField: {field_name} (type: {field_type})") - print(f" Total unique values: {len(values)}") - if values: - print(" Values:") - for value, count in values: - print(f" {value}: {count}") + print(f"Fail to get metadata summary, code: {res_json.get('code')}, message: {res_json.get('message')}") else: - print(f"Fail to get metadata summary, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to get metadata summary, code: {response.status_code}, body: {response.text}") def list_user_agents(self, command): if self.server_type != "user": print("This command is only allowed in USER mode") response = self.http_client.request("GET", "/canvas/list", use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + self._print_table_simple(res_json["data"]) + else: + print(f"Fail to list datasets, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list datasets, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list datasets, code: {response.status_code}, body: {response.text}") def list_user_chats(self, command): if self.server_type != "user": @@ -1038,11 +1181,15 @@ class RAGFlowClient: use_api_base=True, auth_kind="web", ) - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - print(f"Success to create chat: {chat_name}") + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + print(f"Success to create chat: {chat_name}") + else: + print(f"Fail to create chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + else: - print(f"Fail to create chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to create chat {chat_name}, code: {response.status_code}, body: {response.text}") def create_dataset_table(self, command): if self.server_type != "user": @@ -1061,11 +1208,15 @@ class RAGFlowClient: payload = {"kb_id": dataset_id, "vector_size": vector_size} # Call API response = self.http_client.request("POST", "/kb/doc_engine_table", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json.get("code") == 0: - print(f"Success to create table for dataset: {dataset_name}") + if response.status_code == 200: + res_json = response.json() + if res_json.get("code") == 0: + print(f"Success to create table for dataset: {dataset_name}") + else: + print(f"Fail to create table for dataset {dataset_name}, code: {res_json.get('code')}, message: {res_json.get('message')}") + else: - print(f"Fail to create table for dataset {dataset_name}, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to create table for dataset {dataset_name}, code: {response.status_code}, body: {response.text}") def drop_dataset_table(self, command): if self.server_type != "user": @@ -1079,11 +1230,15 @@ class RAGFlowClient: # Call API to delete table payload = {"kb_id": dataset_id} response = self.http_client.request("DELETE", "/kb/doc_engine_table", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json.get("code") == 0: - print(f"Success to drop table for dataset: {dataset_name}") + if response.status_code == 200: + res_json = response.json() + if res_json.get("code") == 0: + print(f"Success to drop table for dataset: {dataset_name}") + else: + print(f"Fail to drop table for dataset {dataset_name}, code: {res_json.get('code')}, message: {res_json.get('message')}") + else: - print(f"Fail to drop table for dataset {dataset_name}, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to drop table for dataset {dataset_name}, code: {response.status_code}, body: {response.text}") def create_metadata_table(self, command): if self.server_type != "user": @@ -1091,11 +1246,15 @@ class RAGFlowClient: return # Call API to create metadata table response = self.http_client.request("POST", "/tenant/doc_engine_metadata_table", use_api_base=False, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json.get("code") == 0: - print("Success to create metadata table") + if response.status_code == 200: + res_json = response.json() + if res_json.get("code") == 0: + print("Success to create metadata table") + else: + print(f"Fail to create metadata table, code: {res_json.get('code')}, message: {res_json.get('message')}") + else: - print(f"Fail to create metadata table, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to create metadata table, code: {response.status_code}, body: {response.text}") def drop_metadata_table(self, command): if self.server_type != "user": @@ -1103,11 +1262,15 @@ class RAGFlowClient: return # Call API to delete metadata table response = self.http_client.request("DELETE", "/tenant/doc_engine_metadata_table", use_api_base=False, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json.get("code") == 0: - print("Success to drop metadata table") + if response.status_code == 200: + res_json = response.json() + if res_json.get("code") == 0: + print("Success to drop metadata table") + else: + print(f"Fail to drop metadata table, code: {res_json.get('code')}, message: {res_json.get('message')}") + else: - print(f"Fail to drop metadata table, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to drop metadata table, code: {response.status_code}, body: {response.text}") def drop_user_chat(self, command): if self.server_type != "user": @@ -1126,11 +1289,15 @@ class RAGFlowClient: use_api_base=True, auth_kind="web", ) - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - print(f"Success to drop chat: {chat_name}") + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + print(f"Success to drop chat: {chat_name}") + else: + print(f"Fail to drop chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + else: - print(f"Fail to drop chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to drop chat {chat_name}, code: {response.status_code}, body: {response.text}") def _get_chat_id_by_name(self, chat_name): """Get chat (dialog) ID by name.""" @@ -1146,12 +1313,16 @@ class RAGFlowClient: def _list_chat_sessions(self, dialog_id): """List all sessions (conversations) for a given dialog.""" response = self.http_client.request("GET", f"/chats/{dialog_id}/conversations", use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - return res_json["data"] + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + return res_json["data"] + else: + print(f"Fail to list chat sessions, code: {res_json['code']}, message: {res_json['message']}") + return None + else: - print(f"Fail to list chat sessions, code: {res_json['code']}, message: {res_json['message']}") - return None + print(f"Fail to list chat sessions, code: {response.status_code}, body: {response.text}") def create_chat_session(self, command): if self.server_type != "user": @@ -1162,11 +1333,15 @@ class RAGFlowClient: return payload = {"name": "New conversation"} response = self.http_client.request("POST", f"/chats/{dialog_id}/conversations", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - print(f"Success to create chat session for chat: {chat_name}") + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + print(f"Success to create chat session for chat: {chat_name}") + else: + print(f"Fail to create chat session for chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + else: - print(f"Fail to create chat session for chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to create chat session for chat {chat_name}, code: {response.status_code}, body: {response.text}") def drop_chat_session(self, command): if self.server_type != "user": @@ -1188,11 +1363,15 @@ class RAGFlowClient: return payload = {"ids": to_drop_session_ids} response = self.http_client.request("DELETE", f"/chats/{dialog_id}/conversations", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - print(f"Success to drop chat session '{session_id}' from chat: {chat_name}") + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + print(f"Success to drop chat session '{session_id}' from chat: {chat_name}") + else: + print(f"Fail to drop chat session '{session_id}' from chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + else: - print(f"Fail to drop chat session '{session_id}' from chat {chat_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to drop chat session '{session_id}' from chat {chat_name}, code: {response.status_code}, body: {response.text}") def list_chat_sessions(self, command): if self.server_type != "user": @@ -1260,14 +1439,17 @@ class RAGFlowClient: print("This command is only allowed in USER mode") response = self.http_client.request("GET", "/llm/my_llms", use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: - new_input = [] - for key, value in res_json["data"].items(): - new_input.append({"model provider": key, "models": value}) - self._print_table_simple(new_input) + res_json = response.json() + if res_json["code"] == 0: + new_input = [] + for key, value in res_json["data"].items(): + new_input.append({"model provider": key, "models": value}) + self._print_table_simple(new_input) + else: + print(f"Fail to list model provider, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list model provider, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list model provider, code: {response.status_code}, body: {response.text}") def list_user_default_models(self, command): if self.server_type != "user": @@ -1327,11 +1509,15 @@ class RAGFlowClient: payload = {"doc_ids": document_ids, "run": 1} response = self.http_client.request("POST", "/documents/ingest", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - print(f"Success to parse {to_parse_doc_names} of {dataset_name}") + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + print(f"Success to parse {to_parse_doc_names} of {dataset_name}") + else: + print(f"Fail to parse documents {res_json.get('data', {}).get('docs')}, code: {res_json['code']}, message: {res_json['message']}") + else: - print(f"Fail to parse documents {res_json['data']['docs']}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to parse documents, code: {response.status_code}, body: {response.text}") def parse_dataset(self, command_dict): if self.server_type != "user": @@ -1351,12 +1537,15 @@ class RAGFlowClient: payload = {"doc_ids": document_ids, "run": 1} response = self.http_client.request("POST", "/documents/ingest", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - pass - else: - print(f"Fail to parse dataset {dataset_name}, code: {res_json['code']}, message: {res_json['message']}") + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + pass + else: + print(f"Fail to parse dataset {dataset_name}, code: {res_json['code']}, message: {res_json['message']}") + else: + print(f"Fail to parse dataset {dataset_name}, code: {response.status_code}, body: {response.text}") if command_dict["method"] == "async": print(f"Success to start parse dataset {dataset_name}") return @@ -1429,14 +1618,14 @@ class RAGFlowClient: return response else: response = self.http_client.request("POST", "/retrieval", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json["code"] == 0: self._print_table_simple(res_json["data"]["chunks"]) else: print(f"Fail to search datasets: {dataset_names}, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to search datasets: {dataset_names}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to search datasets: {dataset_names}, code: {response.status_code}, body: {response.text}") def get_chunk(self, command_dict): if self.server_type != "user": @@ -1445,14 +1634,14 @@ class RAGFlowClient: chunk_id = command_dict["chunk_id"] response = self.http_client.request("GET", f"/chunk/get?chunk_id={chunk_id}", use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json["code"] == 0: self._print_key_value(res_json["data"]) else: print(f"Fail to get chunk, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to get chunk, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to get chunk, code: {response.status_code}, body: {response.text}") # Internal def insert_dataset_from_file(self, command_dict): @@ -1463,8 +1652,8 @@ class RAGFlowClient: file_path = command_dict["file_path"] payload = {"file_path": file_path} response = self.http_client.request("POST", "/kb/insert_from_file", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json["code"] == 0: print(f"Success to insert dataset from file: {file_path}") if res_json.get("data"): @@ -1472,7 +1661,7 @@ class RAGFlowClient: else: print(f"Fail to insert dataset from file, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to insert dataset from file, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to insert dataset from file, code: {response.status_code}, body: {response.text}") # Internal def insert_metadata_from_file(self, command_dict): @@ -1483,8 +1672,8 @@ class RAGFlowClient: file_path = command_dict["file_path"] payload = {"file_path": file_path} response = self.http_client.request("POST", "/tenant/insert_metadata_from_file", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json["code"] == 0: print(f"Success to insert metadata from file: {file_path}") if res_json.get("data"): @@ -1492,7 +1681,7 @@ class RAGFlowClient: else: print(f"Fail to insert metadata from file, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to insert metadata from file, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to insert metadata from file, code: {response.status_code}, body: {response.text}") def update_chunk(self, command_dict): if self.server_type != "user": @@ -1510,11 +1699,11 @@ class RAGFlowClient: # Get doc_id from chunk_id via GET /chunk/get response = self.http_client.request("GET", f"/chunk/get?chunk_id={chunk_id}", use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code != 200: - print(f"Fail to get chunk info, code: {res_json.get('code')}, message: {res_json.get('message')}") + print(f"Fail to get chunk info, code: {response.status_code}, body: {response.text}") return + res_json = response.json() doc_id = None if res_json.get("code") == 0 and res_json.get("data"): doc_id = res_json["data"].get("doc_id") @@ -1537,14 +1726,14 @@ class RAGFlowClient: # Call POST /v1/chunk/update response = self.http_client.request("POST", "/chunk/update", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json.get("code") == 0: print(f"Success to update chunk: {chunk_id}") else: print(f"Fail to update chunk, code: {res_json.get('code')}, message: {res_json.get('message')}") else: - print(f"Fail to update chunk, HTTP {response.status_code}") + print(f"Fail to update chunk, code: {response.status_code}, body: {response.text}") def _get_documents_by_ids(self, ids: list[str]): response = self.http_client.request("POST", "/document/infos", json_body={"doc_ids": ids}, use_api_base=False, auth_kind="web") @@ -1601,14 +1790,14 @@ class RAGFlowClient: response = self.http_client.request("PATCH", f"/datasets/{dataset_id}/documents/{doc_id}", json_body=payload, use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json.get("code") == 0: print(f"Success to set metadata for document: {doc_id}") else: print(f"Fail to set metadata, code: {res_json.get('code')}, message: {res_json.get('message')}") else: - print(f"Fail to set metadata, HTTP {response.status_code}: {res_json.get('message', 'no message')}") + print(f"Fail to set metadata, code: {response.status_code}, body: {response.text}") def remove_tags(self, command_dict): if self.server_type != "user": @@ -1628,8 +1817,8 @@ class RAGFlowClient: } response = self.http_client.request("POST", f"/kb/{dataset_id}/rm_tags", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json.get("code") == 0: print(f"Success to remove tags from dataset: {dataset_name}") else: @@ -1651,8 +1840,8 @@ class RAGFlowClient: payload["chunk_ids"] = command_dict["chunk_ids"] response = self.http_client.request("POST", "/chunk/rm", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json.get("code") == 0: deleted_count = res_json.get("data", 0) print(f"Success to remove chunks from document {doc_id}: {deleted_count} chunks deleted") @@ -1682,8 +1871,8 @@ class RAGFlowClient: payload["available_int"] = command_dict["available_int"] response = self.http_client.request("POST", "/chunk/list", json_body=payload, use_api_base=False, auth_kind="web") - res_json = response.json() if response.status_code == 200: + res_json = response.json() if res_json["code"] == 0: chunks = res_json["data"]["chunks"] if chunks: @@ -1696,7 +1885,7 @@ class RAGFlowClient: else: print(f"Fail to list chunks, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to list chunks, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list chunks, code: {response.status_code}, body: {response.text}") def show_version(self, command): if self.server_type == "admin": @@ -1704,14 +1893,17 @@ class RAGFlowClient: else: response = self.http_client.request("GET", "/system/version", use_api_base=True, auth_kind="admin") - res_json = response.json() if response.status_code == 200: - if self.server_type == "admin": - self._print_table_simple(res_json["data"]) + res_json = response.json() + if res_json["code"] == 0: + if self.server_type == "admin": + self._print_table_simple(res_json["data"]) + else: + self._print_table_simple({"version": res_json["data"]}) else: - self._print_table_simple({"version": res_json["data"]}) + print(f"Fail to show version, code: {res_json['code']}, message: {res_json['message']}") else: - print(f"Fail to show version, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to show version, code: {response.status_code}, body: {response.text}") def _wait_parse_done(self, dataset_name: str, dataset_id: str): start = time.monotonic() @@ -1734,19 +1926,25 @@ class RAGFlowClient: def _list_documents(self, dataset_name: str, dataset_id: str): # Use the new RESTful API: GET /api/v1/datasets//documents response = self.http_client.request("GET", f"/datasets/{dataset_id}/documents", use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code != 200: - print(f"Fail to list files from dataset {dataset_name}, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list files from dataset {dataset_name}, code: {response.status_code}, body: {response.text}") + return None + res_json = response.json() + if res_json.get("code") != 0: + print(f"Fail to list files from dataset {dataset_name}, code: {res_json.get('code')}, message: {res_json.get('message')}") return None return res_json["data"]["docs"] def _get_dataset_id(self, dataset_name: str): response = self.http_client.request("GET", "/datasets", use_api_base=True, auth_kind="web") - res_json = response.json() if response.status_code != 200: - print(f"Fail to list datasets, code: {res_json['code']}, message: {res_json['message']}") + print(f"Fail to list datasets, code: {response.status_code}, body: {response.text}") return None + res_json = response.json() + if res_json.get("code") != 0: + print(f"Fail to list datasets, code: {res_json.get('code')}, message: {res_json.get('message')}") + return None dataset_list = res_json["data"] dataset_id: str = "" for dataset in dataset_list: @@ -1777,12 +1975,16 @@ class RAGFlowClient: auth_kind="web", iterations=iterations, ) - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - return res_json["data"]["chats"] + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + return res_json["data"]["chats"] + else: + print(f"Fail to list chats, code: {res_json['code']}, message: {res_json['message']}") + return None + else: - print(f"Fail to list chats, code: {res_json['code']}, message: {res_json['message']}") - return None + print(f"Fail to list chats, code: {response.status_code}, body: {response.text}") def _format_service_detail_table(self, data): if isinstance(data, list): @@ -2118,9 +2320,10 @@ def run_benchmark(client: RAGFlowClient, command_dict: dict): if response.status_code == 200: success_count += 1 case _: - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - success_count += 1 + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + success_count += 1 total_duration = result["duration"] qps = iterations / total_duration if total_duration > 0 else None @@ -2146,9 +2349,10 @@ def run_benchmark(client: RAGFlowClient, command_dict: dict): if response.status_code == 200: success_count += 1 case _: - res_json = response.json() - if response.status_code == 200 and res_json["code"] == 0: - success_count += 1 + if response.status_code == 200: + res_json = response.json() + if res_json["code"] == 0: + success_count += 1 total_duration = end_time - start_time total_command_count = iterations * concurrency