celestialflow 3.0.6__tar.gz → 3.0.7__tar.gz

{celestialflow-3.0.6 → celestialflow-3.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celestialflow
-Version: 3.0.6
+Version: 3.0.7
 Summary: A flexible GRAPH-based task orchestration framework.
 Author-email: Mr-xiaotian <mingxiaomingtian@gmail.com>
 License: MIT
@@ -326,7 +326,7 @@ flowchart TD
 - 12/12/2024-12/16/2024: 在原有链式结构基础上允许节点有复数下级节点, 实现Tree结构; 将原有TaskChain改名为TaskTree
 - 3/16/2025: 支持Web端任务完成情况可视化
 - 6/9/2025: 支持节点拥有复数上级节点, 脱离纯Tree结构, 为之后循环图做准备
-- 6/11/2025: 自[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)项目instances.inst_task迁入
+- 6/11/2025: 自[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)项目instances.inst_task迁出
 - 6/12/2025: 支持循环图, 下级节点可指向上级节点
 - 6/13/2025: 支持loop结构, 即节点可指向自己
 - 6/14/2025: 支持forest结构, 即可有多个根节点
@@ -335,6 +335,7 @@ flowchart TD
 - 3.0.4: 新增一个抽象结构TaskQueue, 用于表示节点的所有"入边"与"出边"; 恢复未消费任务的保存功能
 - 3.0.5: 删除原有的TaskRedisTransfer节点, 并增添三种新的redis交互节点TaskRedisSink TaskRedisSource TaskRedisAck, 用于跨语言 跨进程 跨设备处理任务; 并在Web页面添加展示拓扑信息的卡片
 - 3.0.6: 添加对[CelestialTree](https://github.com/Mr-xiaotian/CelestialTree)系统的支持, 现在可以追踪单个任务的流向
+- 3.0.7: 将TaskStage从TaskManager中单独抽出来作为一个子类; 增加新节点TaskRouter, 可以将传入的任务选择的传给不同的下游节点, 而不是进行广播
 
 ## Star 历史趋势（Star History）
 

{celestialflow-3.0.6 → celestialflow-3.0.7}/README.md

@@ -301,7 +301,7 @@ flowchart TD
 - 12/12/2024-12/16/2024: 在原有链式结构基础上允许节点有复数下级节点, 实现Tree结构; 将原有TaskChain改名为TaskTree
 - 3/16/2025: 支持Web端任务完成情况可视化
 - 6/9/2025: 支持节点拥有复数上级节点, 脱离纯Tree结构, 为之后循环图做准备
-- 6/11/2025: 自[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)项目instances.inst_task迁入
+- 6/11/2025: 自[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)项目instances.inst_task迁出
 - 6/12/2025: 支持循环图, 下级节点可指向上级节点
 - 6/13/2025: 支持loop结构, 即节点可指向自己
 - 6/14/2025: 支持forest结构, 即可有多个根节点
@@ -310,6 +310,7 @@ flowchart TD
 - 3.0.4: 新增一个抽象结构TaskQueue, 用于表示节点的所有"入边"与"出边"; 恢复未消费任务的保存功能
 - 3.0.5: 删除原有的TaskRedisTransfer节点, 并增添三种新的redis交互节点TaskRedisSink TaskRedisSource TaskRedisAck, 用于跨语言 跨进程 跨设备处理任务; 并在Web页面添加展示拓扑信息的卡片
 - 3.0.6: 添加对[CelestialTree](https://github.com/Mr-xiaotian/CelestialTree)系统的支持, 现在可以追踪单个任务的流向
+- 3.0.7: 将TaskStage从TaskManager中单独抽出来作为一个子类; 增加新节点TaskRouter, 可以将传入的任务选择的传给不同的下游节点, 而不是进行广播
 
 ## Star 历史趋势（Star History）
 

{celestialflow-3.0.6 → celestialflow-3.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "celestialflow"                   
-version = "3.0.6"                         
+version = "3.0.7"                         
 description = "A flexible GRAPH-based task orchestration framework."
 readme = "README.md"               
 license = { text = "MIT" }    

{celestialflow-3.0.6 → celestialflow-3.0.7}/src/celestialflow/__init__.py

@@ -1,10 +1,12 @@
 from .task_graph import TaskGraph
 from .task_manage import TaskManager
+from .task_stage import TaskStage
 from .task_nodes import (
     TaskSplitter,
     TaskRedisSink,
     TaskRedisSource,
     TaskRedisAck,
+    TaskRouter,
 )
 from .task_structure import (
     TaskChain,
@@ -33,10 +35,12 @@ __all__ = [
     "TaskWheel",
     "TaskGrid",
     "TaskManager",
+    "TaskStage",
     "TaskSplitter",
     "TaskRedisSink",
     "TaskRedisSource",
     "TaskRedisAck",
+    "TaskRouter",
     "TerminationSignal",
     "TaskWebServer",
     "CelestialTreeClient",

{celestialflow-3.0.6 → celestialflow-3.0.7}/src/celestialflow/adapters/celestialtree/client.py

@@ -9,8 +9,8 @@ class Client:
     Python client for CelestialTree HTTP API.
     """
 
-    def __init__(self, base_url: str, timeout: float = 5.0):
-        self.base_url = base_url.rstrip("/")
+    def __init__(self, host: str = "127.0.0.1", port: int = 7777, timeout: float = 5.0):
+        self.base_url = f"http://{host}:{port}"
         self.timeout = timeout
 
     def init_session(self):
@@ -60,7 +60,9 @@ class Client:
             data=json.dumps(body),
             timeout=self.timeout,
         )
-        r.raise_for_status()
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
         return r.json()["id"]
 
     def get_event(self, event_id: int) -> Dict[str, Any]:
@@ -70,7 +72,9 @@ class Client:
             f"{self.base_url}/event/{event_id}",
             timeout=self.timeout,
         )
-        r.raise_for_status()
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
         return r.json()
 
     def children(self, event_id: int) -> List[int]:
@@ -80,7 +84,9 @@ class Client:
             f"{self.base_url}/children/{event_id}",
             timeout=self.timeout,
         )
-        r.raise_for_status()
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
         return r.json()["children"]
 
     def descendants(self, event_id: int) -> Dict[str, Any]:
@@ -90,7 +96,9 @@ class Client:
             f"{self.base_url}/descendants/{event_id}",
             timeout=self.timeout,
         )
-        r.raise_for_status()
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
         return r.json()
 
     def heads(self) -> List[int]:
@@ -100,17 +108,21 @@ class Client:
             f"{self.base_url}/heads",
             timeout=self.timeout,
         )
-        r.raise_for_status()
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
         return r.json()["heads"]
 
     def health(self) -> bool:
         self.init_session()
-
-        r = self.session.get(
-            f"{self.base_url}/healthz",
-            timeout=self.timeout,
-        )
-        return r.status_code == 200
+        try:
+            r = self.session.get(
+                f"{self.base_url}/healthz",
+                timeout=self.timeout,
+            )
+            return r.status_code == 200
+        except Exception:
+            return False
 
     def version(self) -> Dict[str, Any]:
         self.init_session()
@@ -119,7 +131,9 @@ class Client:
             f"{self.base_url}/version",
             timeout=self.timeout,
         )
-        r.raise_for_status()
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
         return r.json()
 
     # ---------- SSE Subscribe ----------

{celestialflow-3.0.6 → celestialflow-3.0.7}/src/celestialflow/adapters/celestialtree/tools.py

@@ -10,7 +10,12 @@ def format_tree(node: dict, prefix: str = "", is_last: bool = True) -> str:
     lines = []
 
     connector = "└── " if is_last else "├── "
-    lines.append(f"{prefix}{connector}{node['id']}")
+
+    label = str(node["id"])
+    if node.get("is_ref"):
+        label += " (ref)"
+
+    lines.append(f"{prefix}{connector}{label}")
 
     children = node.get("children", [])
     if children:

{celestialflow-3.0.6 → celestialflow-3.0.7}/src/celestialflow/task_graph.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from multiprocessing import Queue as MPQueue
 from typing import Any, Dict, List
 
-from .task_manage import TaskManager
+from .task_stage import TaskStage
 from .task_report import TaskReporter, NullTaskReporter
 from .task_logging import LogListener, TaskLogger
 from .task_queue import TaskQueue
@@ -32,16 +32,16 @@ from .adapters.celestialtree import (
 
 
 class TaskGraph:
-    def __init__(self, root_stages: List[TaskManager], layout_mode: str = "process"):
+    def __init__(self, root_stages: List[TaskStage], layout_mode: str = "process"):
         """
         初始化 TaskGraph 实例。
 
-        TaskGraph 表示一组 TaskManager 节点所构成的任务图，可用于构建并行、串行、
+        TaskGraph 表示一组 TaskStage 节点所构成的任务图，可用于构建并行、串行、
         分层等多种形式的任务执行流程。通过分析图结构和调度布局策略，实现灵活的
         DAG 任务调度控制。
 
-        :param root_stages : List[TaskManager]
-            根节点 TaskManager 列表，用于构建任务图的入口节点。
+        :param root_stages : List[TaskStage]
+            根节点 TaskStage 列表，用于构建任务图的入口节点。
             支持多根节点（森林结构），系统将自动构建整个任务依赖图。
 
         :param layout_mode : str, optional, default = 'process'
@@ -130,7 +130,7 @@ class TaskGraph:
             queue.extend(stage.next_stages)
 
         for stage_tag in self.stages_status_dict:
-            stage: TaskManager = self.stages_status_dict[stage_tag]["stage"]
+            stage: TaskStage = self.stages_status_dict[stage_tag]["stage"]
             in_queue: TaskQueue = self.stages_status_dict[stage_tag]["in_queue"]
 
             # 遍历每个前驱，创建边队列
@@ -162,7 +162,7 @@ class TaskGraph:
         """
         self.structure_json = build_structure_graph(self.root_stages)
 
-    def set_root_stages(self, root_stages: List[TaskManager]):
+    def set_root_stages(self, root_stages: List[TaskStage]):
         """
         设置根节点
 
@@ -212,8 +212,10 @@ class TaskGraph:
         self._ctree_port = port
 
         if use_ctree:
-            base_url = f"http://{host}:{port}"
-            self.ctree_client = CelestialTreeClient(base_url)
+            self.ctree_client = CelestialTreeClient(host=host, port=port)
+            if not self.ctree_client.health():
+                self._use_ctree = False
+                self.ctree_client = NullCelestialTreeClient()
         else:
             self.ctree_client = NullCelestialTreeClient()
 
@@ -225,7 +227,7 @@ class TaskGraph:
         :param execution_mode: 节点内部执行模式, 可选值为 'serial' 或 'thread''
         """
 
-        def set_subsequent_stage_mode(stage: TaskManager):
+        def set_subsequent_stage_mode(stage: TaskStage):
             stage.set_stage_mode(stage_mode)
             stage.set_execution_mode(execution_mode)
             visited_stages.add(stage)
@@ -248,7 +250,7 @@ class TaskGraph:
         :param put_termination_signal: 是否放入终止信号
         """
         for tag, tasks in tasks_dict.items():
-            stage: TaskManager = self.stages_status_dict[tag]["stage"]
+            stage: TaskStage = self.stages_status_dict[tag]["stage"]
             in_queue: TaskQueue = self.stages_status_dict[tag]["in_queue"]
 
             for task in tasks:
@@ -324,7 +326,7 @@ class TaskGraph:
 
                 processes = []
                 for stage_tag in layer:
-                    stage: TaskManager = self.stages_status_dict[stage_tag]["stage"]
+                    stage: TaskStage = self.stages_status_dict[stage_tag]["stage"]
                     self._execute_stage(stage)
                     if stage.stage_mode == "process":
                         processes.append(self.processes[-1])  # 最新的进程
@@ -337,7 +339,7 @@ class TaskGraph:
 
                 self.task_logger.end_layer(layer, time.time() - start_time)
 
-    def _execute_stage(self, stage: TaskManager):
+    def _execute_stage(self, stage: TaskStage):
         """
         执行单个节点
 
@@ -497,7 +499,7 @@ class TaskGraph:
         interval = self.reporter.interval
 
         for tag, stage_status_dict in self.stages_status_dict.items():
-            stage: TaskManager = stage_status_dict["stage"]
+            stage: TaskStage = stage_status_dict["stage"]
             last_stage_status_dict: dict = self.last_status_dict.get(tag, {})
 
             status = stage_status_dict.get("status", StageStatus.NOT_STARTED)

{celestialflow-3.0.6 → celestialflow-3.0.7}/src/celestialflow/task_logging.py

@@ -163,6 +163,13 @@ class TaskLogger:
             f"In '{func_name}', Task {task_info} has split into {split_count} parts. Used {use_time:.2f} seconds.",
         )
 
+    # ==== router ====
+    def router_success(self, func_name, task_info, target_node, use_time):
+        self._log(
+            "SUCCESS",
+            f"In '{func_name}', Task {task_info} has routed to {target_node}. Used {use_time:.2f} seconds.",
+        )
+
     # ==== queue ====
     def put_source(self, source, queue_tag, stage_tag, direction):
         if isinstance(source, TerminationSignal):

{celestialflow-3.0.6 → celestialflow-3.0.7}/src/celestialflow/task_manage.py

@@ -9,7 +9,6 @@ from multiprocessing import Value as MPValue
 from multiprocessing import Queue as MPQueue
 from queue import Queue as ThreadQueue
 from threading import Event, Lock
-from typing import List
 
 from .task_progress import ProgressManager, NullProgress
 from .task_logging import LogListener, TaskLogger
@@ -71,10 +70,6 @@ class TaskManager:
         self.thread_pool = None
         self.process_pool = None
 
-        self.next_stages: List[TaskManager] = []
-        self.prev_stages: List[TaskManager] = []
-        self.set_stage_name()
-
         self.retry_exceptions = tuple()  # 需要重试的异常类型
         self.ctree_client = NullCelestialTreeClient()
 
@@ -163,14 +158,14 @@ class TaskManager:
             [queue_map[self.execution_mode]()],
             [None],
             self.logger_queue,
-            self.get_stage_tag(),
+            self.get_manager_tag(),
             "in",
         )
         self.result_queues: TaskQueue = result_queues or TaskQueue(
             [queue_map[self.execution_mode]()],
             [None],
             self.logger_queue,
-            self.get_stage_tag(),
+            self.get_manager_tag(),
             "out",
         )
         self.fail_queue: ThreadQueue | MPQueue | AsyncQueue = (
@@ -217,69 +212,6 @@ class TaskManager:
             else "serial"
         )
 
-    def set_graph_context(
-        self,
-        next_stages: List[TaskManager] = None,
-        stage_mode: str = None,
-        stage_name: str = None,
-    ):
-        """
-        设置链式上下文(仅限组成graph时)
-
-        :param next_stages: 后续节点列表
-        :param stage_mode: 当前节点执行模式, 可以是 'serial'（串行）或 'process'（并行）
-        :param name: 当前节点名称
-        """
-        self.set_next_stages(next_stages)
-        self.set_stage_mode(stage_mode)
-        self.set_stage_name(stage_name)
-
-    def set_next_stages(self, next_stages: List[TaskManager]):
-        """
-        设置后续节点列表, 并为后续节点添加本节点为前置节点
-
-        :param next_stages: 后续节点列表
-        """
-        self.next_stages = next_stages
-        for next_stage in self.next_stages:
-            next_stage.add_prev_stages(self)
-
-    def set_stage_mode(self, stage_mode: str):
-        """
-        设置当前节点在graph中的执行模式, 可以是 'serial'（串行）或 'process'（并行）
-
-        :param stage_mode: 当前节点执行模式
-        """
-        self.stage_mode = stage_mode if stage_mode == "process" else "serial"
-
-    def set_stage_name(self, name: str = None):
-        """
-        设置当前节点名称
-
-        :param name: 当前节点名称
-        """
-        self.stage_name = name or id(self)
-
-    def add_prev_stages(self, prev_stage: TaskManager):
-        """
-        添加前置节点
-
-        :param prev_stage: 前置节点
-        """
-        from .task_nodes import TaskSplitter
-
-        if prev_stage in self.prev_stages:
-            return
-        self.prev_stages.append(prev_stage)
-
-        if prev_stage is None:
-            return
-
-        if isinstance(prev_stage, TaskSplitter):
-            self.task_counter.add_counter(prev_stage.split_output_counter)
-        else:
-            self.task_counter.add_counter(prev_stage.success_counter)
-
     def set_ctree(self, host="127.0.0.1", port=7777):
         """
         设置CelestialTreeClient
@@ -287,8 +219,9 @@ class TaskManager:
         :param host: CelestialTreeClient host
         :param port: CelestialTreeClient port
         """
-        base_url = f"http://{host}:{port}"
-        self.ctree_client = CelestialTreeClient(base_url)
+        self.ctree_client = CelestialTreeClient(host=host, port=port)
+        if not self.ctree_client.health():
+            self.ctree_client = NullCelestialTreeClient()
 
     def reset_counter(self):
         """
@@ -304,34 +237,6 @@ class TaskManager:
         if isinstance(self, TaskSplitter):
             self.split_output_counter.value = 0
 
-    def get_stage_tag(self) -> str:
-        """
-        获取当前节点在graph中的标签
-
-        :return: 当前节点标签
-        """
-        if hasattr(self, "_stage_tag"):
-            return self._stage_tag
-        self._stage_tag = f"{self.stage_name}[{self.func.__name__}]"
-        return self._stage_tag
-
-    def get_stage_summary(self) -> dict:
-        """
-        获取当前节点的状态快照
-
-        :return: 当前节点状态快照
-        """
-        return {
-            "stage_mode": self.stage_mode,
-            "execution_mode": (
-                self.execution_mode
-                if self.execution_mode == "serial"
-                else f"{self.execution_mode}-{self.worker_limit}"
-            ),
-            "func_name": self.get_stage_tag(),
-            "class_name": self.__class__.__name__,
-        }
-
     def get_func_name(self) -> str:
         """
         获取当前节点函数名
@@ -340,6 +245,17 @@ class TaskManager:
         """
         return self.func.__name__
 
+    def get_manager_tag(self) -> str:
+        """
+        获取当前节点管理器标签
+
+        :return: 当前节点管理器标签
+        """
+        if hasattr(self, "_manager_tag"):
+            return self._manager_tag
+        self._manager_tag = f"Manager[{self.func.__name__}]"
+        return self._manager_tag
+
     def add_retry_exceptions(self, *exceptions):
         """
         添加需要重试的异常类型
@@ -356,16 +272,14 @@ class TaskManager:
         """
         progress_num = 0
         for task in task_source:
-            task_id = self.ctree_client.emit(
-                "task.input", message=f"In '{self.get_stage_tag()}'"
-            )
+            task_id = self.ctree_client.emit("task.input")
             envelope = TaskEnvelope.wrap(task, task_id)
             self.task_queues.put_first(envelope)
             self.update_task_counter()
             self.task_logger.task_inject(
                 self.get_func_name(),
                 self.get_task_info(task),
-                self.get_stage_tag(),
+                self.get_manager_tag(),
                 f"[{task_id}]",
             )
 
@@ -382,16 +296,14 @@ class TaskManager:
         """
         progress_num = 0
         for task in task_source:
-            task_id = self.ctree_client.emit(
-                "task.input", message=f"In '{self.get_stage_tag()}'"
-            )
+            task_id = self.ctree_client.emit("task.input")
             envelope = TaskEnvelope.wrap(task, task_id)
             await self.task_queues.put_first_async(envelope)
             self.update_task_counter()
             self.task_logger.task_inject(
                 self.get_func_name(),
                 self.get_task_info(task),
-                self.get_stage_tag(),
+                self.get_manager_tag(),
                 f"[{task_id}]",
             )
 
@@ -409,7 +321,6 @@ class TaskManager:
         """
         self.fail_queue.put(
             {
-                "stage_tag": self.get_stage_tag(),
                 "task": str(task),
                 "error_info": f"{type(error).__name__}({error})",
                 "timestamp": time.time(),
@@ -425,7 +336,6 @@ class TaskManager:
         """
         await self.fail_queue.put(
             {
-                "stage_tag": self.get_stage_tag(),
                 "task": str(task),
                 "error_info": f"{type(error).__name__}({error})",
                 "timestamp": time.time(),
@@ -577,9 +487,7 @@ class TaskManager:
         if self.enable_result_cache:
             self.success_dict[task] = processed_result
 
-        result_id = self.ctree_client.emit(
-            "task.success", parents=[task_id], message=f"In '{self.get_stage_tag()}'"
-        )
+        result_id = self.ctree_client.emit("task.success", parents=[task_id])
         result_envelope = TaskEnvelope.wrap(result, result_id)
 
         # ✅ 清理 retry_time_dict
@@ -614,9 +522,7 @@ class TaskManager:
         if self.enable_result_cache:
             self.success_dict[task] = processed_result
 
-        result_id = self.ctree_client.emit(
-            "task.success", parents=[task_id], message=f"In '{self.get_stage_tag()}'"
-        )
+        result_id = self.ctree_client.emit("task.success", parents=[task_id])
         result_envelope = TaskEnvelope.wrap(result, result_id)
 
         # ✅ 清理 retry_time_dict
@@ -660,7 +566,6 @@ class TaskManager:
             retry_id = self.ctree_client.emit(
                 f"task.retry.{self.retry_time_dict[task_hash]}",
                 parents=[task_id],
-                message=f"In '{self.get_stage_tag()}'",
             )
 
             self.task_logger.task_retry(
@@ -675,9 +580,7 @@ class TaskManager:
             if self.enable_result_cache:
                 self.error_dict[task] = exception
 
-            error_id = self.ctree_client.emit(
-                "task.error", parents=[task_id], message=f"In '{self.get_stage_tag()}'"
-            )
+            error_id = self.ctree_client.emit("task.error", parents=[task_id])
 
             # ✅ 清理 retry_time_dict
             self.retry_time_dict.pop(task_hash, None)
@@ -722,7 +625,6 @@ class TaskManager:
             retry_id = self.ctree_client.emit(
                 f"task.retry.{self.retry_time_dict[task_hash]}",
                 parents=[task_id],
-                message=f"In '{self.get_stage_tag()}'",
             )
 
             self.task_logger.task_retry(
@@ -737,9 +639,7 @@ class TaskManager:
             if self.enable_result_cache:
                 self.error_dict[task] = exception
 
-            error_id = self.ctree_client.emit(
-                "task.error", parents=[task_id], message=f"In '{self.get_stage_tag()}'"
-            )
+            error_id = self.ctree_client.emit("task.error", parents=[task_id])
 
             # ✅ 清理 retry_time_dict
             self.retry_time_dict.pop(task_hash, None)
@@ -764,7 +664,6 @@ class TaskManager:
         duplicate_id = self.ctree_client.emit(
             "task.duplicate",
             parents=[task_envelope.id],
-            message=f"In '{self.get_stage_tag()}'",
         )
         self.task_logger.task_duplicate(
             self.get_func_name(),
@@ -854,48 +753,6 @@ class TaskManager:
         )
         self.log_listener.stop()
 
-    def start_stage(
-        self,
-        input_queues: List[MPQueue],
-        output_queues: List[MPQueue],
-        fail_queue: MPQueue,
-        logger_queue: MPQueue,
-    ):
-        """
-        根据 start_type 的值，选择串行、并行执行任务
-
-        :param input_queues: 输入队列
-        :param output_queue: 输出队列
-        :param fail_queue: 失败队列
-        """
-        start_time = time.time()
-        self.active = True
-        self.init_progress()
-        self.init_env(input_queues, output_queues, fail_queue, logger_queue)
-        self.task_logger.start_stage(
-            self.get_stage_tag(), self.execution_mode, self.worker_limit
-        )
-
-        # 根据模式运行对应的任务处理函数
-        if self.execution_mode == "thread":
-            self.run_with_executor(self.thread_pool)
-        else:
-            self.run_in_serial()
-
-        # cleanup_mpqueue(input_queues) # 会影响之后finalize_nodes
-        self.release_pool()
-        self.result_queues.put(TERMINATION_SIGNAL)
-
-        self.progress_manager.close()
-        self.task_logger.end_stage(
-            self.get_stage_tag(),
-            self.execution_mode,
-            time.time() - start_time,
-            self.success_counter.value,
-            self.error_counter.value,
-            self.duplicate_counter.value,
-        )
-
     def run_in_serial(self):
         """
         串行地执行任务
@@ -925,9 +782,7 @@ class TaskManager:
         self.task_queues.reset()
 
         if not self.is_tasks_finished():
-            self.task_logger._log(
-                "DEBUG", f"Retrying tasks for '{self.get_stage_tag()}'"
-            )
+            self.task_logger._log("DEBUG", f"Retrying tasks")
             self.task_queues.put(TERMINATION_SIGNAL)
             self.run_in_serial()
 
@@ -1003,9 +858,7 @@ class TaskManager:
         self.task_queues.reset()
 
         if not self.is_tasks_finished():
-            self.task_logger._log(
-                "DEBUG", f"Retrying tasks for '{self.get_stage_tag()}'"
-            )
+            self.task_logger._log("DEBUG", f"Retrying tasks")
             self.task_queues.put(TERMINATION_SIGNAL)
             self.run_with_executor(executor)
 
@@ -1052,9 +905,7 @@ class TaskManager:
         self.task_queues.reset()
 
         if not self.is_tasks_finished():
-            self.task_logger._log(
-                "DEBUG", f"Retrying tasks for '{self.get_stage_tag()}'"
-            )
+            self.task_logger._log("DEBUG", f"Retrying tasks")
             await self.task_queues.put_async(TERMINATION_SIGNAL)
             await self.run_in_async()