Refactor: reformat all code for lefthook using ruff and gofmt (#16585)

sdk/python/ragflow_sdk/__init__.py

@@ -15,6 +15,7 @@
 #
 
 from beartype.claw import beartype_this_package
+
 beartype_this_package()
 
 import importlib.metadata
@@ -30,13 +31,4 @@ from .modules.memory import Memory
 
 __version__ = importlib.metadata.version("ragflow_sdk")
 
-__all__ = [
-    "RAGFlow",
-    "DataSet",
-    "Chat",
-    "Session",
-    "Document",
-    "Chunk",
-    "Agent",
-    "Memory"
-]
+__all__ = ["RAGFlow", "DataSet", "Chat", "Session", "Document", "Chunk", "Agent", "Memory"]

sdk/python/ragflow_sdk/modules/__init__.py

@@ -12,4 +12,4 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
-#
+#

sdk/python/ragflow_sdk/modules/agent.py

@@ -20,7 +20,7 @@ from .session import Session
 
 class Agent(Base):
     def __init__(self, rag, res_dict):
-        self.id  = None
+        self.id = None
         self.avatar = None
         self.canvas_type = None
         self.description = None
@@ -30,42 +30,17 @@ class Agent(Base):
     class Dsl(Base):
         def __init__(self, rag, res_dict):
             self.answer = []
-            self.components = {
-                "begin": {
-                    "downstream": ["Answer:China"],
-                    "obj": {
-                        "component_name": "Begin",
-                        "params": {}
-                    },
-                    "upstream": []
-                }
-            }
+            self.components = {"begin": {"downstream": ["Answer:China"], "obj": {"component_name": "Begin", "params": {}}, "upstream": []}}
             self.graph = {
                 "edges": [],
-                "nodes": [
-                    {
-                        "data": {
-                            "label": "Begin",
-                            "name": "begin"
-                        },
-                        "id": "begin",
-                        "position": {
-                            "x": 50,
-                            "y": 200
-                        },
-                        "sourcePosition": "left",
-                        "targetPosition": "right",
-                        "type": "beginNode"
-                    }
-                ]
+                "nodes": [{"data": {"label": "Begin", "name": "begin"}, "id": "begin", "position": {"x": 50, "y": 200}, "sourcePosition": "left", "targetPosition": "right", "type": "beginNode"}],
             }
-            self.history =  []
-            self.messages =  []
-            self.path =  []
+            self.history = []
+            self.messages = []
+            self.path = []
             self.reference = []
             super().__init__(rag, res_dict)
 
-    
     def create_session(self, **kwargs) -> Session:
         res = self.post(f"/agents/{self.id}/sessions", json=kwargs)
         res = res.json()
@@ -73,11 +48,8 @@ class Agent(Base):
             return Session(self.rag, res.get("data"))
         raise Exception(res.get("message"))
 
-    
-    def list_sessions(self, page: int = 1, page_size: int = 30, orderby: str = "create_time", desc: bool = True,
-                      id: str = None) -> list[Session]:
-        res = self.get(f"/agents/{self.id}/sessions",
-                       {"page": page, "page_size": page_size, "orderby": orderby, "desc": desc, "id": id})
+    def list_sessions(self, page: int = 1, page_size: int = 30, orderby: str = "create_time", desc: bool = True, id: str = None) -> list[Session]:
+        res = self.get(f"/agents/{self.id}/sessions", {"page": page, "page_size": page_size, "orderby": orderby, "desc": desc, "id": id})
         res = res.json()
         if res.get("code") == 0:
             result_list = []
@@ -86,7 +58,7 @@ class Agent(Base):
                 result_list.append(temp_agent)
             return result_list
         raise Exception(res.get("message"))
-    
+
     def delete_sessions(self, ids: list[str] | None = None, delete_all: bool = False):
         payload = {"ids": ids}
         if delete_all:

sdk/python/ragflow_sdk/modules/chunk.py

@@ -16,6 +16,7 @@
 
 from .base import Base
 
+
 class ChunkUpdateError(Exception):
     def __init__(self, code=None, message=None, details=None):
         self.code = code
@@ -23,6 +24,7 @@ class ChunkUpdateError(Exception):
         self.details = details
         super().__init__(message)
 
+
 class Chunk(Base):
     def __init__(self, rag, res_dict):
         self.id = ""
@@ -48,17 +50,12 @@ class Chunk(Base):
                 res_dict.pop(k)
         super().__init__(rag, res_dict)
 
-        #for backward compatibility
+        # for backward compatibility
         if not self.document_name:
             self.document_name = self.document_keyword
 
-
     def update(self, update_message: dict):
         res = self.patch(f"/datasets/{self.dataset_id}/documents/{self.document_id}/chunks/{self.id}", update_message)
         res = res.json()
         if res.get("code") != 0:
-            raise ChunkUpdateError(
-                code=res.get("code"),
-                message=res.get("message"),
-                details=res.get("details")
-            )
+            raise ChunkUpdateError(code=res.get("code"), message=res.get("message"), details=res.get("details"))

sdk/python/ragflow_sdk/modules/dataset.py

@@ -113,18 +113,21 @@ class DataSet(Base):
 
     def _get_documents_status(self, document_ids):
         import time
+
         terminal_states = {"DONE", "FAIL", "CANCEL"}
         interval_sec = 1
         pending = set(document_ids)
         finished = []
         while pending:
             for doc_id in list(pending):
+
                 def fetch_doc(doc_id: str) -> Document | None:
                     try:
                         docs = self.list_documents(id=doc_id)
                         return docs[0] if docs else None
                     except Exception:
                         return None
+
                 doc = fetch_doc(doc_id)
                 if doc is None:
                     continue
@@ -137,13 +140,12 @@ class DataSet(Base):
             if pending:
                 time.sleep(interval_sec)
         return finished
-    
+
     def async_parse_documents(self, document_ids):
         res = self.post(f"/datasets/{self.id}/chunks", {"document_ids": document_ids})
         res = res.json()
         if res.get("code") != 0:
             raise Exception(res.get("message"))
-        
 
     def parse_documents(self, document_ids):
         try:
@@ -151,9 +153,8 @@ class DataSet(Base):
             self._get_documents_status(document_ids)
         except KeyboardInterrupt:
             self.async_cancel_parse_documents(document_ids)
-            
-        return self._get_documents_status(document_ids)
 
+        return self._get_documents_status(document_ids)
 
     def async_cancel_parse_documents(self, document_ids):
         res = self.rm(f"/datasets/{self.id}/chunks", {"document_ids": document_ids})

sdk/python/ragflow_sdk/modules/memory.py

@@ -18,7 +18,6 @@ from .base import Base
 
 
 class Memory(Base):
-
     def __init__(self, rag, res_dict):
         self.id = ""
         self.name = ""
@@ -33,7 +32,7 @@ class Memory(Base):
         self.description = ""
         self.memory_size = 5 * 1024 * 1024
         self.forgetting_policy = "FIFO"
-        self.temperature = 0.5,
+        self.temperature = (0.5,)
         self.system_prompt = ""
         self.user_prompt = ""
         for k in list(res_dict.keys()):
@@ -57,13 +56,8 @@ class Memory(Base):
         self._update_from_dict(self.rag, res.get("data", {}))
         return self
 
-    def list_memory_messages(self, agent_id: str | list[str]=None, keywords: str=None, page: int=1, page_size: int=50):
-        params = {
-            "agent_id": agent_id,
-            "keywords": keywords,
-            "page": page,
-            "page_size": page_size
-        }
+    def list_memory_messages(self, agent_id: str | list[str] = None, keywords: str = None, page: int = 1, page_size: int = 50):
+        params = {"agent_id": agent_id, "keywords": keywords, "page": page, "page_size": page_size}
         res = self.get(f"/memories/{self.id}", params)
         res = res.json()
         if res.get("code") != 0:
@@ -78,9 +72,7 @@ class Memory(Base):
         return True
 
     def update_message_status(self, message_id: int, status: bool):
-        update_message = {
-            "status": status
-        }
+        update_message = {"status": status}
         res = self.put(f"/messages/{self.id}:{message_id}", update_message)
         res = res.json()
         if res.get("code") != 0:

sdk/python/ragflow_sdk/modules/session.py

@@ -36,7 +36,6 @@ class Session(Base):
                 self.__session_type = "agent"
         super().__init__(rag, res_dict)
 
-
     def ask(
         self,
         question="",
@@ -89,8 +88,7 @@ class Session(Base):
 
         if inputs is not None or release is not None or return_trace is not None:
             logger.debug(
-                "Session.ask explicit-params session_type=%s session_id=%s "
-                "input_keys=%s release=%s return_trace=%s",
+                "Session.ask explicit-params session_type=%s session_id=%s input_keys=%s release=%s return_trace=%s",
                 self.__session_type,
                 getattr(self, "id", None),
                 list(inputs.keys()) if isinstance(inputs, dict) else None,
@@ -111,7 +109,7 @@ class Session(Base):
                     continue  # Skip empty lines
                 line = line.strip()
                 if line.startswith("data:"):
-                    content = line[len("data:"):].strip()
+                    content = line[len("data:") :].strip()
                     if content == "[DONE]":
                         break  # End of stream
                 else:
@@ -122,14 +120,11 @@ class Session(Base):
                 except json.JSONDecodeError:
                     continue  # Skip lines that are not valid JSON
 
-                event = json_data.get("event",None)
+                event = json_data.get("event", None)
                 if event and event != "message":
                     continue
 
-                if (
-                    (self.__session_type == "agent" and event == "message_end")
-                    or (self.__session_type == "chat" and json_data.get("data") is True)
-                ):
+                if (self.__session_type == "agent" and event == "message_end") or (self.__session_type == "chat" and json_data.get("data") is True):
                     return
                 if self.__session_type == "agent":
                     yield self._structure_answer(json_data)
@@ -141,7 +136,6 @@ class Session(Base):
             except ValueError:
                 raise Exception(f"Invalid response {res}")
             yield self._structure_answer(json_data["data"])
-        
 
     def _structure_answer(self, json_data):
         answer = ""
@@ -150,10 +144,7 @@ class Session(Base):
         elif self.__session_type == "chat":
             answer = json_data["answer"]
         reference = json_data.get("reference", {})
-        temp_dict = {
-            "content": answer,
-            "role": "assistant"
-        }
+        temp_dict = {"content": answer, "role": "assistant"}
         if reference and "chunks" in reference:
             chunks = reference["chunks"]
             temp_dict["reference"] = chunks
@@ -163,8 +154,7 @@ class Session(Base):
     def _ask_chat(self, question: str, stream: bool, **kwargs):
         json_data = {"question": question, "stream": stream, "session_id": self.id}
         json_data.update(kwargs)
-        res = self.post(f"/chats/{self.chat_id}/completions",
-                        json_data, stream=stream)
+        res = self.post(f"/chats/{self.chat_id}/completions", json_data, stream=stream)
         return res
 
     def _ask_agent(self, question: str, stream: bool, **kwargs):
@@ -180,8 +170,7 @@ class Session(Base):
         return res
 
     def update(self, update_message):
-        res = self.patch(f"/chats/{self.chat_id}/sessions/{self.id}",
-                         update_message)
+        res = self.patch(f"/chats/{self.chat_id}/sessions/{self.id}", update_message)
         res = res.json()
         if res.get("code") != 0:
             raise Exception(res.get("message"))

sdk/python/ragflow_sdk/ragflow.py

@@ -196,7 +196,7 @@ class RAGFlow:
         top_k=1024,
         rerank_id: str | None = None,
         keyword: bool = False,
-        cross_languages: list[str]|None = None,
+        cross_languages: list[str] | None = None,
         metadata_condition: dict | None = None,
         use_kg: bool = False,
         toc_enhance: bool = False,
@@ -217,7 +217,7 @@ class RAGFlow:
             "cross_languages": cross_languages,
             "metadata_condition": metadata_condition,
             "use_kg": use_kg,
-            "toc_enhance": toc_enhance
+            "toc_enhance": toc_enhance,
         }
         # Send a POST request to the backend service (using requests library as an example, actual implementation may vary)
         res = self.post("/retrieval", json=data_json)
@@ -331,7 +331,7 @@ class RAGFlow:
                 "memory_type": memory_type,
                 "storage_type": storage_type,
                 "keywords": keywords,
-            }
+            },
         )
         res = res.json()
         if res.get("code") != 0:
@@ -339,12 +339,7 @@ class RAGFlow:
         result_list = []
         for data in res["data"]["memory_list"]:
             result_list.append(Memory(self, data))
-        return {
-            "code": res.get("code", 0),
-            "message": res.get("message"),
-            "memory_list": result_list,
-            "total_count": res["data"]["total_count"]
-        }
+        return {"code": res.get("code", 0), "message": res.get("message"), "memory_list": result_list, "total_count": res["data"]["total_count"]}
 
     def delete_memory(self, memory_id: str):
         res = self.delete(f"/memories/{memory_id}", {})
@@ -354,21 +349,24 @@ class RAGFlow:
 
     def add_message(self, memory_id: list[str], agent_id: str, session_id: str, user_input: str, agent_response: str, user_id: str = "") -> str:
         """Append messages to memories; ``user_id`` is forwarded only for API-key auth (external subject)."""
-        payload = {
-            "memory_id": memory_id,
-            "agent_id": agent_id,
-            "session_id": session_id,
-            "user_input": user_input,
-            "agent_response": agent_response,
-            "user_id": user_id
-        }
+        payload = {"memory_id": memory_id, "agent_id": agent_id, "session_id": session_id, "user_input": user_input, "agent_response": agent_response, "user_id": user_id}
         res = self.post("/messages", payload)
         res = res.json()
         if res.get("code") != 0:
             raise Exception(res["message"])
         return res["message"]
 
-    def search_message(self, query: str, memory_id: list[str], agent_id: str=None, session_id: str=None, user_id: str=None, similarity_threshold: float=0.2, keywords_similarity_weight: float=0.7, top_n: int=10) -> list[dict]:
+    def search_message(
+        self,
+        query: str,
+        memory_id: list[str],
+        agent_id: str = None,
+        session_id: str = None,
+        user_id: str = None,
+        similarity_threshold: float = 0.2,
+        keywords_similarity_weight: float = 0.7,
+        top_n: int = 10,
+    ) -> list[dict]:
         params = {
             "query": query,
             "memory_id": memory_id,
@@ -377,7 +375,7 @@ class RAGFlow:
             "user_id": user_id,
             "similarity_threshold": similarity_threshold,
             "keywords_similarity_weight": keywords_similarity_weight,
-            "top_n": top_n
+            "top_n": top_n,
         }
         res = self.get("/messages/search", params)
         res = res.json()
@@ -385,13 +383,8 @@ class RAGFlow:
             raise Exception(res["message"])
         return res["data"]
 
-    def get_recent_messages(self, memory_id: list[str], agent_id: str=None, session_id: str=None, limit: int=10) -> list[dict]:
-        params = {
-            "memory_id": memory_id,
-            "agent_id": agent_id,
-            "session_id": session_id,
-            "limit": limit
-        }
+    def get_recent_messages(self, memory_id: list[str], agent_id: str = None, session_id: str = None, limit: int = 10) -> list[dict]:
+        params = {"memory_id": memory_id, "agent_id": agent_id, "session_id": session_id, "limit": limit}
         res = self.get("/messages", params)
         res = res.json()
         if res.get("code") != 0: