celestialflow 3.2.2__tar.gz → 3.2.3__tar.gz

{celestialflow-3.2.2 → celestialflow-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celestialflow
-Version: 3.2.2
+Version: 3.2.3
 Summary: A flexible GRAPH-based task orchestration framework.
 Author-email: Mr-xiaotian <mingxiaomingtian@gmail.com>
 License: MIT
@@ -12,7 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Framework :: FastAPI
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: tqdm
 Requires-Dist: fastapi
@@ -21,7 +21,7 @@ Requires-Dist: requests
 Requires-Dist: networkx
 Requires-Dist: redis
 Requires-Dist: jinja2
-Requires-Dist: celestialtree>=0.1.2
+Requires-Dist: celestialtree>=0.1.3
 
 # CelestialFlow ——一个轻量级、可并行、基于图结构的 Python 任务调度框架
 
@@ -240,12 +240,12 @@ flowchart TD
 
 ## 环境要求（Requirements）
 
-**CelestialFlow** 基于 Python 3.11+，并依赖以下核心组件。
+**CelestialFlow** 基于 Python 3.12+，并依赖以下核心组件。
 请确保你的环境能够正常安装这些依赖（`pip install celestialflow` 会自动安装）。
 
 | 依赖包           | 说明 |
 | ----------------- | ---- |
-| **Python ≥ 3.11**  | 运行环境，建议使用 3.11 及以上版本 |
+| **Python ≥ 3.12**  | 运行环境，建议使用 3.12 及以上版本 |
 | **fastapi**       | Web 服务接口框架（用于任务可视化与远程控制） |
 | **uvicorn**       | FastAPI 的高性能 ASGI 服务器 |
 | **requests**      | HTTP 客户端库，用于任务状态上报与远程调用 |
@@ -260,31 +260,61 @@ flowchart TD
 <p align="center">
   <img src="https://raw.githubusercontent.com/Mr-xiaotian/CelestialFlow/main/img/file_structure.svg" alt="FileStructure" />
   <br/>
-  <em>celestial-flow 3.2.2</em>
+  <em>celestial-flow 3.2.3</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
 
 ## 版本日志（Version Log）
-- 3.2.2
+- 3.2.3
   - feat:
-    - `core_server` 中添加数据锁, 避免并发访问导致的错误状态
-    - 优化前端设置面板的显示, 现在只显示全局设置与当前页相关设置
-    - 在设置面板中添加全局设置中的 "是否自动更新" 选项与错误日志页面中的 "排序方式" 两项
+    - **[IMPORTANT]** 前端仪表盘设置面板中新添 `节点等待使用全局估计` 开关, 开启后节点卡片中原 `等待` 量将被替换为 `全局等待`, 并在卡片中显示 `全局剩余时间`
+      - 这个功能非常有趣, 开启前后能看到数值大幅波动
+    - **[IMPORTANT]** 重写任务注入页面, 现在实用性远远高于之前版本
+      - 可以给每个节点单独配置注入任务列表, 在一起发送
+    - **[IMPORTANT]** 移除 `TaskExecutor` 中 `get_args` 与 `process_result` 两个方法, 以及 `unpack_task_args` 属性
+      - 这是为引入泛型必要的修改
+      - `process_result` 功能很简单, 对func输出的result进行再次处理, 但事实上在输入func前对齐进行包装也能达到一样的效果
+      - `get_args` 功能更为复杂, 可以直接将前一节点提供的 `result` 转为当前节点所需的 `task` 类型, 非常灵活; 但问题在于太过灵活, 导致使用心智负担很大
+      - `unpack_task_args` 就是 `get_args` 带来的一项心智负担, 默认 `get_args` 会把 `task` 进行 `(task, )` 包裹后发送给func, 开启 `unpack_task_args` 后则直接发送
+    - **[IMPORTANT]** `graph` 的init参数中添加 `name`, 以与 `executor` `stage` 一致
+      - 破坏接口破坏性更新
+      - 在日志的 `start_graph` `end_graph` 与web端的 `graph_anaylysis` 中都有显示
+    - 彻底移除前后端通信中的 `graph_summary` , 原本残余的 `全局剩余时间` 现在拆为各个节点的 `全局等待` 与 `全局剩余时间`
+      - 这里所说的 `全局` 意为根据图论关系, 由上游剩余的任务数估算下游总共能获得多少任务
+      - 例如: 图关系 `A -> B`, A已处理任务2, 未处理任务3, B已处理任务4, 未处理任务2. 这意味着A成功的2个任务为B带来总共了6个任务, 那么我们可以据此估计B总功能获取"3/2*6=9"个任务, 因此B的 `等待` 任务数量为2, 但 `全局等待` 任务数量为5
+    - 前端中添加部分提示气泡, 鼠标放上去后可以介绍相关信息, 例如本次新加入的节点 `全局等待` 的含义
+    - 移除前端中节点卡片的拖拽功能
+      - 这个功能是在最早加入web页面时添加的, 当时感觉很帅, 但现在有点玩腻了
+    - 前端错误日志页面添加 `任务注入` 按钮, 可以把选定任务直接添加到任务注入页面中节点的代注入任务列表中
+    - 在 `TaskSplitter` 中添加 `split_item` 方法, 可自由定义
+      - 原本的 `splitter` 非常依赖于 `get_args`, 现在通过 `split_item` 方法稍微弥补其缺失的灵活性
   - refactor:
-    - 删除前后端通讯中的 `summary` , 节点的总体预期结束时间由各个节点的 `status` 分别传递, 并由前端计算整体的预期结束时间
-    - 修改 `structure_graph`(原 `structure_json`) 字段的内容, 现在更为简洁, 避免信息冗余, 同时方便后续拓展
+    - **[IMPORTANT]** 引入泛型, 同时强制性要求py版本>=3.12
+      - 泛型的引入使得代码更加类型安全, 同时也提高了代码的可读性
+      - 3.12版本对泛型的表述非常直观
+    - 移除前端代码中所有对 `localStorage` 的使用
+      - 在已经有config配置文件的情况下意义不大, 反而会带来困扰
+    - 将任务队列的drain操作从graph层移至stage层
+      - 之前不能这样做是因为节点的 `stage_mode` 可能为 `process`, 此时在主进程持有的节点非真实运行的节点
+      - 算是3.2.0版本带来的持久影响之一
+    - 优化 `TaskMetric` 中对锁的使用
+    - 移除 `TaskEnvelope` 中的 `change_id()` 方法, 现在默认envelope不可变, 同时 `emit_retry_envelope` 中不再把原有的envelope的id修改后继续提交给worker, 而是直接使用新生成的envelope
+    - 移除错误日志中的 `error` `error_repr` `task_repr` 字段
+    - 修改前后端通信中任务注入数据的格式, 以方便同时提交多个节点的任务数据
+    - 前端代码中开启strict检查
+    - 将前端中 `injection.css` 文件拆分成多个文件
+    - 修改 `config.json` 的数据格式, 现在按照生效区域进行分类
+    - 收紧前端中的数据类型
+    - 添加 `ReportTaskGraph` 类型, 专门用于给reporter做类型声明
   - fix:
-    - 修复指标折线图中指标选择失效的问题
-    - 修改 `report.stop` 中_refresh_all的执行顺序, 避免与thread中的刷新冲突
-    - 在 `graph._finalize_nodes` 中添加对thread未终止的防御性检查
-    - 修复 `stage` 中 `start_time` 在未定义前被 `report` 调用的问题
-    - 修复 `TaskRedisTransport._transport` 中使用 `id()` 来计算task_id导致的问题
-    - 修复部分任务无法被hash导致的panic问题
+    - i18n本地化在部分字段上失效的问题
+    - 直接点击仪表盘中错误数字跳转到错误日志页后, 设置面板显示的还是仪表盘页面的设置
+    - 前端中为各项仪表盘请求添加 `RequestSeq`, 以避免前后发送两个请求, 但因为延迟关系, 先发送的请求的返回覆盖掉后发送请求的返回
+    - 修复前端中各项空字段需要在第一次refresh才显示的问题, 体感上会导致"加载"很慢
   - chore:
-    - 删除所有的 `type: ignore`
-      - 好看不少
-    - 在 `start_*` 函数的doc-string中标注该函数为一次性调用函数
+    - 将文档更新翻译为英/日两语
+      - 这项操作太耗token了
 
 更多过往日志可看:
 

{celestialflow-3.2.2 → celestialflow-3.2.3}/README.md

@@ -215,12 +215,12 @@ flowchart TD
 
 ## 环境要求（Requirements）
 
-**CelestialFlow** 基于 Python 3.11+，并依赖以下核心组件。
+**CelestialFlow** 基于 Python 3.12+，并依赖以下核心组件。
 请确保你的环境能够正常安装这些依赖（`pip install celestialflow` 会自动安装）。
 
 | 依赖包           | 说明 |
 | ----------------- | ---- |
-| **Python ≥ 3.11**  | 运行环境，建议使用 3.11 及以上版本 |
+| **Python ≥ 3.12**  | 运行环境，建议使用 3.12 及以上版本 |
 | **fastapi**       | Web 服务接口框架（用于任务可视化与远程控制） |
 | **uvicorn**       | FastAPI 的高性能 ASGI 服务器 |
 | **requests**      | HTTP 客户端库，用于任务状态上报与远程调用 |
@@ -235,31 +235,61 @@ flowchart TD
 <p align="center">
   <img src="https://raw.githubusercontent.com/Mr-xiaotian/CelestialFlow/main/img/file_structure.svg" alt="FileStructure" />
   <br/>
-  <em>celestial-flow 3.2.2</em>
+  <em>celestial-flow 3.2.3</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
 
 ## 版本日志（Version Log）
-- 3.2.2
+- 3.2.3
   - feat:
-    - `core_server` 中添加数据锁, 避免并发访问导致的错误状态
-    - 优化前端设置面板的显示, 现在只显示全局设置与当前页相关设置
-    - 在设置面板中添加全局设置中的 "是否自动更新" 选项与错误日志页面中的 "排序方式" 两项
+    - **[IMPORTANT]** 前端仪表盘设置面板中新添 `节点等待使用全局估计` 开关, 开启后节点卡片中原 `等待` 量将被替换为 `全局等待`, 并在卡片中显示 `全局剩余时间`
+      - 这个功能非常有趣, 开启前后能看到数值大幅波动
+    - **[IMPORTANT]** 重写任务注入页面, 现在实用性远远高于之前版本
+      - 可以给每个节点单独配置注入任务列表, 在一起发送
+    - **[IMPORTANT]** 移除 `TaskExecutor` 中 `get_args` 与 `process_result` 两个方法, 以及 `unpack_task_args` 属性
+      - 这是为引入泛型必要的修改
+      - `process_result` 功能很简单, 对func输出的result进行再次处理, 但事实上在输入func前对齐进行包装也能达到一样的效果
+      - `get_args` 功能更为复杂, 可以直接将前一节点提供的 `result` 转为当前节点所需的 `task` 类型, 非常灵活; 但问题在于太过灵活, 导致使用心智负担很大
+      - `unpack_task_args` 就是 `get_args` 带来的一项心智负担, 默认 `get_args` 会把 `task` 进行 `(task, )` 包裹后发送给func, 开启 `unpack_task_args` 后则直接发送
+    - **[IMPORTANT]** `graph` 的init参数中添加 `name`, 以与 `executor` `stage` 一致
+      - 破坏接口破坏性更新
+      - 在日志的 `start_graph` `end_graph` 与web端的 `graph_anaylysis` 中都有显示
+    - 彻底移除前后端通信中的 `graph_summary` , 原本残余的 `全局剩余时间` 现在拆为各个节点的 `全局等待` 与 `全局剩余时间`
+      - 这里所说的 `全局` 意为根据图论关系, 由上游剩余的任务数估算下游总共能获得多少任务
+      - 例如: 图关系 `A -> B`, A已处理任务2, 未处理任务3, B已处理任务4, 未处理任务2. 这意味着A成功的2个任务为B带来总共了6个任务, 那么我们可以据此估计B总功能获取"3/2*6=9"个任务, 因此B的 `等待` 任务数量为2, 但 `全局等待` 任务数量为5
+    - 前端中添加部分提示气泡, 鼠标放上去后可以介绍相关信息, 例如本次新加入的节点 `全局等待` 的含义
+    - 移除前端中节点卡片的拖拽功能
+      - 这个功能是在最早加入web页面时添加的, 当时感觉很帅, 但现在有点玩腻了
+    - 前端错误日志页面添加 `任务注入` 按钮, 可以把选定任务直接添加到任务注入页面中节点的代注入任务列表中
+    - 在 `TaskSplitter` 中添加 `split_item` 方法, 可自由定义
+      - 原本的 `splitter` 非常依赖于 `get_args`, 现在通过 `split_item` 方法稍微弥补其缺失的灵活性
   - refactor:
-    - 删除前后端通讯中的 `summary` , 节点的总体预期结束时间由各个节点的 `status` 分别传递, 并由前端计算整体的预期结束时间
-    - 修改 `structure_graph`(原 `structure_json`) 字段的内容, 现在更为简洁, 避免信息冗余, 同时方便后续拓展
+    - **[IMPORTANT]** 引入泛型, 同时强制性要求py版本>=3.12
+      - 泛型的引入使得代码更加类型安全, 同时也提高了代码的可读性
+      - 3.12版本对泛型的表述非常直观
+    - 移除前端代码中所有对 `localStorage` 的使用
+      - 在已经有config配置文件的情况下意义不大, 反而会带来困扰
+    - 将任务队列的drain操作从graph层移至stage层
+      - 之前不能这样做是因为节点的 `stage_mode` 可能为 `process`, 此时在主进程持有的节点非真实运行的节点
+      - 算是3.2.0版本带来的持久影响之一
+    - 优化 `TaskMetric` 中对锁的使用
+    - 移除 `TaskEnvelope` 中的 `change_id()` 方法, 现在默认envelope不可变, 同时 `emit_retry_envelope` 中不再把原有的envelope的id修改后继续提交给worker, 而是直接使用新生成的envelope
+    - 移除错误日志中的 `error` `error_repr` `task_repr` 字段
+    - 修改前后端通信中任务注入数据的格式, 以方便同时提交多个节点的任务数据
+    - 前端代码中开启strict检查
+    - 将前端中 `injection.css` 文件拆分成多个文件
+    - 修改 `config.json` 的数据格式, 现在按照生效区域进行分类
+    - 收紧前端中的数据类型
+    - 添加 `ReportTaskGraph` 类型, 专门用于给reporter做类型声明
   - fix:
-    - 修复指标折线图中指标选择失效的问题
-    - 修改 `report.stop` 中_refresh_all的执行顺序, 避免与thread中的刷新冲突
-    - 在 `graph._finalize_nodes` 中添加对thread未终止的防御性检查
-    - 修复 `stage` 中 `start_time` 在未定义前被 `report` 调用的问题
-    - 修复 `TaskRedisTransport._transport` 中使用 `id()` 来计算task_id导致的问题
-    - 修复部分任务无法被hash导致的panic问题
+    - i18n本地化在部分字段上失效的问题
+    - 直接点击仪表盘中错误数字跳转到错误日志页后, 设置面板显示的还是仪表盘页面的设置
+    - 前端中为各项仪表盘请求添加 `RequestSeq`, 以避免前后发送两个请求, 但因为延迟关系, 先发送的请求的返回覆盖掉后发送请求的返回
+    - 修复前端中各项空字段需要在第一次refresh才显示的问题, 体感上会导致"加载"很慢
   - chore:
-    - 删除所有的 `type: ignore`
-      - 好看不少
-    - 在 `start_*` 函数的doc-string中标注该函数为一次性调用函数
+    - 将文档更新翻译为英/日两语
+      - 这项操作太耗token了
 
 更多过往日志可看:
 

{celestialflow-3.2.2 → celestialflow-3.2.3}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "celestialflow"
-version = "3.2.2"
+version = "3.2.3"
 description = "A flexible GRAPH-based task orchestration framework."
 readme = "README.md"
 license = { text = "MIT" }
 authors = [{ name = "Mr-xiaotian", email = "mingxiaomingtian@gmail.com" }]
 keywords = ["workflow", "task", "graph", "async", "CelestialFlow"]
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 
 dependencies = [
     "tqdm",
@@ -20,7 +20,7 @@ dependencies = [
     "networkx",
     "redis",
     "jinja2",
-    "celestialtree>=0.1.2",
+    "celestialtree>=0.1.3",
 ]
 
 classifiers = [
@@ -79,14 +79,11 @@ include = ["src"]
 ignore = ["tests", "**/tests/**", "typings", "demo", "bench", "experiments", "examples", "temp"]
 
 typeCheckingMode = "strict"
-reportExplicitAny = "none"
-reportAny = "none"
-reportUnannotatedClassAttribute = "none"
 reportUnusedFunction = "none"
 reportImplicitOverride = "none"
 
 [tool.ruff]
-target-version = "py311"
+target-version = "py312"
 exclude = ["tests", "typings", "demo", "bench", "experiments", "examples", "temp"]
 
 [tool.ruff.lint]

{celestialflow-3.2.2 → celestialflow-3.2.3}/src/celestialflow/graph/core_graph.py

@@ -20,24 +20,21 @@ from ..observability import NullTaskReporter, TaskReporter
 from ..persistence import FailInlet, FailSpout, LogInlet, LogSpout
 from ..persistence.util_jsonl import load_task_by_error, load_task_by_stage
 from ..runtime import TaskInQueue, TaskOutQueue
+from ..runtime.util_constant import LEVEL_DICT, STAGE_STYLE
 from ..runtime.util_errors import (
     CelestialTreeConnectionError,
     DuplicateNodeError,
+    LogLevelError,
     RuntimeStateError,
     ScheduleModeError,
-    UnconsumedError,
 )
 from ..runtime.util_estimators import (
     calc_elapsed,
-    calc_global_remain_equal_pred,
+    calc_global_pending,
     calc_remaining,
 )
-from ..runtime.util_types import (
-    STAGE_STYLE,
-    CTreeEvent,
-    TerminationSignal,
-)
-from ..stage import TaskStage
+from ..runtime.util_types import TerminationSignal
+from ..stage.util_types import AnyTaskStage
 from ..utils.util_collections import cluster_by_value_sorted
 from ..utils.util_format import format_avg_time
 from .util_analysis import (
@@ -62,6 +59,7 @@ class TaskGraph:
 
     def __init__(
         self,
+        name: str,
         schedule_mode: str = "eager",
         log_level: str = "INFO",
     ) -> None:
@@ -77,6 +75,7 @@ class TaskGraph:
         - 完成一次 start_graph() 后，不应复用同一实例再次启动。
         - 如需重复执行，请重新构建新的 TaskGraph 与节点对象。
 
+        :param name: 任务图名称
         :param schedule_mode: str, optional, default = 'eager'
             控制任务图的调度布局模式，支持以下两种策略：
             - 'eager'：
@@ -97,6 +96,7 @@ class TaskGraph:
             - 'ERROR'
             - 'CRITICAL'
         """
+        self._set_name(name)
         self._set_log_level(log_level)
         self._set_schedule_mode(schedule_mode)
         self.set_reporter()
@@ -119,7 +119,7 @@ class TaskGraph:
         # 用于保存所有子线程的引用
         self.threads: list[threading.Thread] = []
         # 用于保存每个节点的运行信息
-        self.stage_dict: dict[str, TaskStage] = {}
+        self.stage_dict: dict[str, AnyTaskStage] = {}
         # 用于保存每个节点的上一次collect_runtime_snapshot()的状态信息
         self.status_dict: dict[str, dict[str, Any]] = defaultdict(dict)
         # 用于保存最近一次状态快照对应的统一时间戳
@@ -127,10 +127,12 @@ class TaskGraph:
         # 用于保存每个节点的输入任务ID集合
         self.input_ids: dict[str, set[int]] = defaultdict(set)
         # 用于保存源节点列表（由 _build_analysis 自动计算）
-        self.source_stages: list[TaskStage] = []
+        self.source_stages: list[AnyTaskStage] = []
         # 用于保存图结构的邻接表
         self.out_edges: dict[str, list[str]] = defaultdict(list)
         self.in_edges: dict[str, list[str]] = defaultdict(list)
+        # 用于保存任务图启动时间
+        self.start_time: float = 0.0
 
     def _init_spout(self) -> None:
         """
@@ -148,7 +150,7 @@ class TaskGraph:
 
     # ==== 建图 ====
 
-    def set_stages(self, stages: list[TaskStage]) -> None:
+    def set_stages(self, stages: list[AnyTaskStage]) -> None:
         """
         添加节点到任务图中
 
@@ -167,7 +169,11 @@ class TaskGraph:
 
             stage.set_inlet(fail_queue, log_queue)
 
-    def connect(self, from_stages: list[TaskStage], to_stages: list[TaskStage]) -> None:
+    def connect(
+        self,
+        from_stages: list[AnyTaskStage],
+        to_stages: list[AnyTaskStage],
+    ) -> None:
         """
         建立超边连接：from_stages 中的每个节点连接到 to_stages 中的每个节点。
 
@@ -181,6 +187,14 @@ class TaskGraph:
 
     # ==== 配置 ====
 
+    def _set_name(self, name: str) -> None:
+        """
+        设置任务图名称
+
+        :param name: 任务图名称
+        """
+        self.name = name
+
     def _set_schedule_mode(self, schedule_mode: str) -> None:
         """
         设置任务链的执行模式
@@ -202,6 +216,8 @@ class TaskGraph:
         :param level: 日志级别, 默认为 "INFO"
         """
         self.log_level = level.upper()
+        if self.log_level not in LEVEL_DICT:
+            raise LogLevelError(self.log_level)
 
     def set_reporter(
         self, is_report: bool = False, host: str = "127.0.0.1", port: int = 5000
@@ -283,15 +299,15 @@ class TaskGraph:
             if not self.in_edges[stage_name]:  # 如果没有前驱
                 continue
 
-            in_queue: TaskInQueue = current_stage.task_queue
-            prev_stages: list[TaskStage] = []
+            in_queue: TaskInQueue[Any] = current_stage.task_queue
+            prev_stages: list[AnyTaskStage] = []
 
             # 遍历每个前驱，创建边队列
             for prev_stage_name in self.in_edges[stage_name]:
                 in_queue.add_source_name(prev_stage_name)
 
                 prev_stage = self.stage_dict[prev_stage_name]
-                prev_out_queue: TaskOutQueue = prev_stage.result_queue
+                prev_out_queue: TaskOutQueue[Any] = prev_stage.result_queue
                 prev_out_queue.add_queue(in_queue.queue, stage_name)
                 prev_stages.append(prev_stage)
 
@@ -328,7 +344,7 @@ class TaskGraph:
         for name, tasks in tasks_dict.items():
             if name not in self.stage_dict:
                 continue
-            stage: TaskStage = self.stage_dict[name]
+            stage: AnyTaskStage = self.stage_dict[name]
 
             for task in tasks:
                 if isinstance(task, TerminationSignal):
@@ -374,13 +390,14 @@ class TaskGraph:
                 RuntimeWarning,
                 stacklevel=2,
             )
-        start_time = time.perf_counter()
+        _start = time.perf_counter()
+        self.start_time = time.time()
 
         try:
             self.fail_spout.start()
             self.log_spout.start()
-            self.log_inlet.start_graph(self.get_structure_list())
-            self.fail_inlet.start_graph(self.get_structure_graph())
+            self.log_inlet.start_graph(self.name, self.get_structure_list())
+            self.fail_inlet.start_graph(self.name, self.get_structure_graph())
             self.reporter.start()
 
             self.put_stage_queue(init_tasks_dict, put_termination_signal)
@@ -390,7 +407,7 @@ class TaskGraph:
             self._finalize_nodes()
 
             self.reporter.stop()
-            self.log_inlet.end_graph(time.perf_counter() - start_time)
+            self.log_inlet.end_graph(self.name, time.perf_counter() - _start)
             self.fail_spout.stop()
             self.log_spout.stop()
 
@@ -413,7 +430,7 @@ class TaskGraph:
 
                 threads: list[threading.Thread] = []
                 for stage_name in layer:
-                    stage: TaskStage = self.stage_dict[stage_name]
+                    stage: AnyTaskStage = self.stage_dict[stage_name]
                     self._execute_stage(stage)
                     if stage.stage_mode == "thread":
                         threads.append(self.threads[-1])
@@ -424,7 +441,7 @@ class TaskGraph:
 
                 self.log_inlet.end_layer(layer, time.perf_counter() - start_time)
 
-    def _execute_stage(self, stage: TaskStage) -> None:
+    def _execute_stage(self, stage: AnyTaskStage) -> None:
         """
         执行单个节点
 
@@ -474,33 +491,8 @@ class TaskGraph:
             stage.mark_stopped()
 
         # 收集并持久化每个 stage 中未消费的任务
-        for stage_name, stage in self.stage_dict.items():
-            in_queue: TaskInQueue = stage.task_queue
-
-            remaining_sources = in_queue.drain()
-            stage.metrics.add_error_count(len(remaining_sources))
-
-            # 持久化逻辑
-            for source in remaining_sources:
-                task: Any = source.task
-                task_id: int = source.id
-                error_id: int = self.ctree_client.emit(
-                    CTreeEvent.TASK_ERROR,
-                    [task_id],
-                    payload=stage.get_summary(),
-                )
-
-                self.fail_inlet.task_error(
-                    stage_name, error_id, UnconsumedError(), task
-                )
-
-                self.log_inlet.task_error(
-                    stage.get_func_name(),
-                    stage.get_task_repr(task),
-                    UnconsumedError(),
-                    task_id,
-                    error_id,
-                )
+        for stage in self.stage_dict.values():
+            stage.drain_task_queue()
 
         self.collect_runtime_snapshot()
 
@@ -508,10 +500,10 @@ class TaskGraph:
 
     def _snapshot_one_stage(
         self,
-        stage: TaskStage,
+        stage: AnyTaskStage,
         last_status: dict[str, Any],
         interval: float,
-    ) -> tuple[dict[str, Any], tuple[int, int, float, float]]:
+    ) -> tuple[dict[str, Any], tuple[int, int]]:
         """
         计算单个 stage 的运行时快照
         :param stage: 节点实例
@@ -547,37 +539,30 @@ class TaskGraph:
 
         processed = int(stage_counts["tasks_processed"] or 0)
         pending = int(stage_counts["tasks_pending"] or 0)
-        elapsed_f = float(elapsed or 0.0)
-        remaining_f = float(remaining or 0.0)
 
-        return snapshot, (processed, pending, elapsed_f, remaining_f)
+        return snapshot, (processed, pending)
 
-    def _calc_graph_remain(
+    def _calc_graph_pending(
         self,
         running_processed_map: dict[str, int],
         running_pending_map: dict[str, int],
-        running_elapsed_map: dict[str, float],
-        running_remaining_map: dict[str, float],
-    ) -> dict[str, float]:
+    ) -> dict[str, int]:
         """
-        根据 DAG/非 DAG 策略计算全局预计剩余时间
+        根据 DAG/非 DAG 策略计算全局预计待处理任务数量
 
         :param running_processed_map: 各节点已处理任务数
         :param running_pending_map: 各节点待处理任务数
-        :param running_elapsed_map: 各节点已用时间
-        :param running_remaining_map: 各节点预计剩余时间
-        :return: 全局预计剩余时间（秒）
+        :return: 全局预计待处理任务数量
         """
         if not self.is_dag:
-            return running_remaining_map
+            return running_pending_map
 
-        total_remaining_map = calc_global_remain_equal_pred(
+        total_pending_map = calc_global_pending(
             self.networkx_graph,
             running_processed_map,
             running_pending_map,
-            running_elapsed_map,
         )
-        return total_remaining_map
+        return total_pending_map
 
     def collect_runtime_snapshot(self) -> None:
         """
@@ -587,39 +572,36 @@ class TaskGraph:
         now = time.time()
         interval = self.reporter.interval
 
-        # 为全局预计 remaining 收集
-        running_elapsed_map: dict[str, float] = {}
+        # 为全局预计 tasks_pending 收集数据
         running_processed_map: dict[str, int] = {}
         running_pending_map: dict[str, int] = {}
-        running_remaining_map: dict[str, float] = {}
 
         for stage_name, stage in self.stage_dict.items():
             last_status = self.status_dict.get(stage_name, {})
 
-            snapshot, (processed, pending, elapsed, remaining) = (
-                self._snapshot_one_stage(
-                    stage,
-                    last_status,
-                    interval,
-                )
+            snapshot, (processed, pending) = self._snapshot_one_stage(
+                stage,
+                last_status,
+                interval,
             )
 
             status_dict[stage_name] = snapshot
 
+            # 更新各节点的 processed, pending, remaining 数据
             running_processed_map[stage_name] = processed
             running_pending_map[stage_name] = pending
-            running_elapsed_map[stage_name] = elapsed
-            running_remaining_map[stage_name] = remaining
 
-        total_remaining_map = self._calc_graph_remain(
+        total_pending_map = self._calc_graph_pending(
             running_processed_map,
             running_pending_map,
-            running_elapsed_map,
-            running_remaining_map,
         )
-
         for stage_name, stage_status in status_dict.items():
-            stage_status["total_remaining_time"] = total_remaining_map[stage_name]
+            stage_status["total_tasks_pending"] = total_pending_map[stage_name]
+            stage_status["total_remaining_time"] = calc_remaining(
+                stage_status["tasks_processed"],
+                stage_status["total_tasks_pending"],
+                stage_status["elapsed_time"],
+            )
 
         self.status_dict = status_dict
         self.status_timestamp = now
@@ -669,12 +651,14 @@ class TaskGraph:
         """
         获取任务图的分析信息
 
-        :return: 包含 is_dag, schedule_mode, class_name, layers_dict 的字典
+        :return: 包含 name, startTime, is_dag, schedule_mode, class_name, layers_dict 的字典
         """
         return {
+            "name": self.name,
+            "startTime": self.start_time,
+            "className": self.__class__.__name__,
             "isDAG": self.is_dag,
             "scheduleMode": self.schedule_mode,
-            "className": self.__class__.__name__,
             "layersDict": self.layers_dict,
         }
 
@@ -728,7 +712,7 @@ class TaskGraph:
             return ""
         return format_descendants_forest(descendants, STAGE_STYLE)
 
-    def get_source_stages(self) -> list[TaskStage]:
+    def get_source_stages(self) -> list[AnyTaskStage]:
         """
         获取源节点列表