celestialflow 3.2.8__tar.gz → 3.2.9__tar.gz

{celestialflow-3.2.8/src/celestialflow.egg-info → celestialflow-3.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celestialflow
-Version: 3.2.8
+Version: 3.2.9
 Summary: A flexible GRAPH-based task orchestration framework.
 Author-email: Mr-xiaotian <mingxiaomingtian@gmail.com>
 License: MIT
@@ -258,125 +258,122 @@ flowchart TD
 ## 文件结构（File Structure）
 
 ```
-📁 CelestialFlow	(587MB 684KB 313B)
-    📁 bench           	(296KB 842B)
+📁 CelestialFlow	(588MB 419KB 930B)
+    📁 bench           	(296KB 806B)
         📁 [1项排除的目录]                  	(194KB 222B)
         🐍 bench_datastructures.py          	(6KB 690B)
-        🐍 bench_execution_mode.py          	(2KB 831B)
+        🐍 bench_execution_mode.py          	(2KB 707B)
         🐍 bench_futures_memory.py          	(2KB 269B)
-        🐍 bench_gil_vs_nogil.py            	(10KB 7B)
+        🐍 bench_gil_vs_nogil.py            	(10KB 121B)
         🐍 bench_graph_mode.py              	(7KB 450B)
         🐍 bench_hash.py                    	(7KB 67B)
         🐍 bench_hash_container.py          	(3KB 1009B)
         🐍 bench_hash_memory.py             	(3KB 642B)
-        🐍 bench_http_grpc.py               	(2KB 608B)
+        🐍 bench_http_grpc.py               	(2KB 521B)
         🐍 bench_ipc_queue.py               	(7KB 104B)
         🐍 bench_lock_overhead.py           	(9KB 421B)
         🐍 bench_mpqueue_vs_shared_memory.py	(13KB 127B)
         🐍 bench_observer.py                	(7KB 860B)
-        🐍 bench_persistence_spout.py       	(4KB 279B)
+        🐍 bench_persistence_spout.py       	(4KB 340B)
         🐍 bench_queue.py                   	(5KB 857B)
         🐍 bench_requests.py                	(6KB 813B)
         🐍 bench_tqdm.py                    	(1KB 235B)
         🐍 bench_utils.py                   	(543B)
-    📁 demo            	(147KB 87B)
+    📁 demo            	(145KB 1012B)
         📁 [1项排除的目录]  	(100KB 9B)
         🐍 demo_executor.py 	(1KB 495B)
         🐍 demo_funnel.py   	(2KB 289B)
-        🐍 demo_graph.py    	(3KB 565B)
-        🐍 demo_network.py  	(3KB 879B)
+        🐍 demo_graph.py    	(3KB 227B)
+        🐍 demo_network.py  	(3KB 729B)
         🐍 demo_observer.py 	(4KB 270B)
-        🐍 demo_redis.py    	(9KB 144B)
-        🐍 demo_stages.py   	(4KB 336B)
-        🐍 demo_structure.py	(12KB 24B)
+        🐍 demo_redis.py    	(9KB 81B)
+        🐍 demo_stages.py   	(4KB 219B)
+        🐍 demo_structure.py	(11KB 593B)
         🐍 demo_utils.py    	(6KB 148B)
-    📁 dist            	(147KB 48B)
+    📁 dist            	(302KB 861B)
         ❓ .gitignore                          	(1B)
         ❓ celestialflow-3.2.7-py3-none-any.whl	(79KB 235B)
         📦 celestialflow-3.2.7.tar.gz          	(67KB 836B)
-    📁 docs            	(1MB 722KB 21B)
+        ❓ celestialflow-3.2.8-py3-none-any.whl	(83KB 244B)
+        📦 celestialflow-3.2.8.tar.gz          	(72KB 569B)
+    📁 docs            	(1MB 756KB 830B)
         📁 en[已折叠]   	(568KB 991B)
         📁 ja[已折叠]   	(642KB 383B)
-        📁 zh-CN[已折叠]	(534KB 695B)
-    📁 experiments     	(2KB 1015B)
-        🐍 experiment_networkx.py	(1KB 878B)
+        📁 zh-CN[已折叠]	(569KB 480B)
+    📁 experiments     	(2KB 1021B)
+        🐍 experiment_networkx.py	(1KB 884B)
         🐍 experiment_tqdm.py    	(1KB 137B)
     📁 img             	(5MB 871KB 242B)
         📷 file_structure.svg  	(4MB 918KB 1000B)
         📷 logo(old).png       	(836KB 542B)
         📷 logo.png            	(122KB 747B)
         📷 scc_condensation.svg	(17KB 1B)
-    📁 src             	(1MB 858KB 89B)
-        📁 celestialflow[已折叠]         	(1MB 839KB 629B)
-        📁 celestialflow.egg-info[已折叠]	(18KB 484B)
-    📁 tests           	(4MB 167KB 552B)
-        📁 benchmark[已折叠]    	(38KB 197B)
+    📁 src             	(1MB 873KB 44B)
+        📁 celestialflow[已折叠]         	(1MB 852KB 902B)
+        📁 celestialflow.egg-info[已折叠]	(20KB 166B)
+    📁 tests           	(4MB 170KB 251B)
+        📁 benchmark[已折叠]    	(39KB 852B)
         📁 funnel[已折叠]       	(96KB 363B)
-        📁 graph[已折叠]        	(721KB 564B)
-        📁 observability[已折叠]	(189KB 236B)
-        📁 persistence[已折叠]  	(388KB 426B)
-        📁 runtime[已折叠]      	(1MB 295KB 529B)
-        📁 stage[已折叠]        	(382KB 155B)
+        📁 graph[已折叠]        	(724KB 404B)
+        📁 observability[已折叠]	(189KB 230B)
+        📁 persistence[已折叠]  	(387KB 877B)
+        📁 runtime[已折叠]      	(1MB 295KB 264B)
+        📁 stage[已折叠]        	(381KB 203B)
         📁 utils[已折叠]        	(639KB 527B)
         📁 [1项排除的目录]      	(487KB 589B)
         🐍 conftest.py          	(1KB 38B)
         🐍 __init__.py          	(0B)
-    📁 [12项排除的目录]	(573MB 420KB 160B)
+    📁 [12项排除的目录]	(573MB 949KB 913B)
     ❓ .env            	(468B)
-    ❓ .gitignore      	(1KB 314B)
-    📝 AGENTS.md       	(1KB 173B)
+    ❓ .gitignore      	(1KB 315B)
+    📝 AGENTS.md       	(1KB 434B)
     ❓ LICENSE         	(1KB 65B)
     ❓ Makefile        	(155B)
     ⚙️ pyproject.toml  	(2KB 668B)
-    📝 README.md       	(19KB 24B)
-    🔒 uv.lock         	(97KB 510B)
+    📝 README.md       	(17KB 465B)
+    🔒 uv.lock         	(121KB 572B)
 ```
 <p align="center">
-  <em>celestial-flow 3.2.8</em>
+  <em>celestial-flow 3.2.9</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
 
 ## 版本日志（Version Log）
-- 3.2.8
+- 3.2.9
   - feat:
-    - [IMPORTANT] 添加 `TaskGraph.run_async`, 现在可以直接进行图级别的异步
-      - 根据 `bench_graph_mode.py` 最新测试, 在I/O密集型任务中, `serial`+`async`（6.05s），比 `serial`+`serial`（69.04s）快 **11.4x**
-    - 在 `core_structure` 中添加报错校验
-    - 不再允许设置 `execution_mode=async` 时调用 `TashExecutor.start`(如今的`TashExecutor.run`), 只能调用 `TashExecutor.run_async`
-    - 另外调用 `TashExecutor.run_async` 时也会进行模式检查, 不是 `execution_mode=async` 就会抛出异常
-    - 在 `BaseObserver` 中添加 `observer_error`, 用于处理 `BaseObserver.on_*` 函数的报错
-    - 在 `TaskGraph._finish_start_graph` `TaskExecutor._finish_start` 中对所有执行步骤进行 `try-except`, 以使收尾步骤尽量全部完成
-    - 添加 `core_scope`, 用于独立控制 `funnel` 的生命周期, 并用于 `TaskGraph.run/run_async` `TaskExecutor.run/run_async`
-  - refactor:
-    - [IMPORTANT] 原 `TaskGraph.start_graph/start_graph_async` `TaskExecutor.start/start_async` 已被重命名为 `TaskGraph.run/run_async` `TaskExecutor.run/run_async`
+    - [IMPORTANT] 移除 `stage` 中 `stage_mode`，并添加 `graph_mode`
       - 破坏性更新
-      - 其底层缘由是为了合并 `TaskStage.start_stage/start_stage_async` 与 `TaskExecutor.start/start_async` 而做出的一系列重构之一
-      - 现在的 `TaskGraph.start/start_async` `TaskExecutor.start/start_async` 不再接受任务, 而是专注于处理现有任务列表中的任务
-    - [IMPORTANT] 将funnel从 `TaskGraph` `TaskExecutor` 中的显性调用与显性传递, 改为所有使用端均从独立文件中import
-      - 一来是因为原先的传递链太丑了, 二来是为了简化 `TaskExecutor.start/start_async` 逻辑, 为其与 `TaskStage.start_stage/start_stage_async` 的合并做准备
-    - 移动部分文件以解决部分模块级的循环引用问题
-      - 原先并非文件级循环引用, 在使用上并无问题
-    - 修改 `TaskDispatch.dispatch_thread` 中处理已完成future的逻辑, 避免cpu浪费
-    - 删除 `util_errors` 中一些不必要的错误类
-    - 将 `TaskGraph._finalize_stages` 进行拆分, 删除不必要的机制, 将剩余机制移至其他方法
-    - 修改 `TaskGraph.set_reporter` 的逻辑, 使其与 `set_ctree` 保持一致
-    - 将 `TaskOutQueue` 中的 `queue_list|target_name|_name_to_idx` 改为 `_queues`, 并删除 `put_channel`
-      - 我有些困惑为什么最初我没有这么做
-    - 在 `TaskExecutor` 中合并 `_get_task_repr` and `_get_result_repr`
-      - 这两个方法原先差异巨大, 但后来经过多次其他部分的重构, 现在逻辑已经一致
-    - 将 `TaskStage` 中的 `_status` 交给 `TaskMetrics` 维护
-      - 依旧是为了合并 `TaskExecutor.start/start_async` 与 `TaskStage.start_stage/start_stage_async`
-    - 移除 `TaskGraph` 中的 `put_stage_queue`
-      - 任务输入完全使用 `TaskExecutor` 中的 `put_task` `put_signal` 方法
+      - `stage_mode` 可以细粒度的控制每个 `TaskStage` 在图中的模式，但经过多年使用，我认为这种细粒度的控制并无必要，反而无谓的增加理解成本
+      - `graph_mode` 则提供了更粗粒度的控制，用于统一控制所有 `TaskStage` 在图中是串行/多线程/并发运行，适用于大多数场景
+      - 同时完善了 `graph_mode`(serial/thread/async) * `execution_mode`(serial/thread/async) 总共 9 种组合模式
+    - 移除 `schedule_mode`
+      - 破坏性更新
+      - 这个模式带来了许多复杂度，但没有与原先的 `stage_mode / execution_mode` 产生明显的组合优势
+    - 在 `get_graph_analysis` 中添加 `graph_mode`
+      - 这个函数主要用于给web端提供信息
+      - web端代码已经同步修改
+    - 添加新的 `warning` 项，当图不是 dag 且 `graph_mode=serial` 时触发
+    - 移除 `task_executor` 中的参数 `persist_result`
+      - 这是为了简化代码逻辑，同时也使所有任务的最终状态（包括：成功/失败/未执行）都能被统一存储
+    - 将 `task.retry` 事件降级，不再申请单独事件ID，不再在 `lifecycle` 中留痕
+  - reafactor:
+    - 合并 `benchmark` 相关函数对 sync 与 async 两种模式的执行
+      - 性能无差异，代码好看一些
+    - 将原本的 `fallback` 改名为 `lifecycle`
+      - 早在重构原本的 `fail` 时就想起个更恰当的名字，这个版本才实现
+    - 将 `graph.source_lists` 改为 `graph.source_names`
+      - `graph.source_lists` 直接存储节点的引用，而 `graph.source_names` 存储节点的名称
+    - 所有的 `log` / `lifecycle` 文件统一改名为 `flow_log` / `flow_lifecycle`
+    - 删除 `graph` 中的 `out_edges` `in_edges`
+      - 现在由 `OrderGraph` 负责管理边关系
+    - 在 `tarjan_scc` 中使用 DFS 取代原先的递归逻辑
+    - 将 `util_graph` 改名为 `util_order_graph`
   - fix:
-    - 在 `TaskDispatch.worker/worker_async` 中添加错误捕捉, 捕捉为 `CRITICAL` 级错误
-      - 避免 `worker` 级出错导致计数错误, 永远无法退出
-    - 在 `spout` 与 `reporter` 的 `stop` 操作中添加对于线程没有成功 `join` 的报错
-    - 修复 `TaskGraph.restore_db` 与 `TaskExecutor.restore_db` 中开启 `filter_by_error_type=Ture` 时跳过 `status=pending` 任务记录的问题
-    - 修复 `TaskGraph` 中部分 `get_*` 方法依赖 `_build_analysis` 的产物, 但 `_build_analysis` 未执行导致的问题
-    - 修复 `TaskMetrics` 中 `get_counts` 与 `is_tasks_finished` 中可能导致死锁的问题
-    - 修复 `TaskReporter` 中 `stop` 里进行的最后一次 `_refresh_all` 没有错误捕捉, 导致后续收尾未完成的问题
+    - 修复最后一次 report 无法正常上传的问题
+    - 修复 `graph.run` / `graph.run_async` 中 `is_put_signal` 参数没有生效的问题
+  - chore：
+    - 更新文档
 
 更多过往日志可看:
 

{celestialflow-3.2.8 → celestialflow-3.2.9}/README.md

@@ -239,125 +239,122 @@ flowchart TD
 ## 文件结构（File Structure）
 
 ```
-📁 CelestialFlow	(587MB 684KB 313B)
-    📁 bench           	(296KB 842B)
+📁 CelestialFlow	(588MB 419KB 930B)
+    📁 bench           	(296KB 806B)
         📁 [1项排除的目录]                  	(194KB 222B)
         🐍 bench_datastructures.py          	(6KB 690B)
-        🐍 bench_execution_mode.py          	(2KB 831B)
+        🐍 bench_execution_mode.py          	(2KB 707B)
         🐍 bench_futures_memory.py          	(2KB 269B)
-        🐍 bench_gil_vs_nogil.py            	(10KB 7B)
+        🐍 bench_gil_vs_nogil.py            	(10KB 121B)
         🐍 bench_graph_mode.py              	(7KB 450B)
         🐍 bench_hash.py                    	(7KB 67B)
         🐍 bench_hash_container.py          	(3KB 1009B)
         🐍 bench_hash_memory.py             	(3KB 642B)
-        🐍 bench_http_grpc.py               	(2KB 608B)
+        🐍 bench_http_grpc.py               	(2KB 521B)
         🐍 bench_ipc_queue.py               	(7KB 104B)
         🐍 bench_lock_overhead.py           	(9KB 421B)
         🐍 bench_mpqueue_vs_shared_memory.py	(13KB 127B)
         🐍 bench_observer.py                	(7KB 860B)
-        🐍 bench_persistence_spout.py       	(4KB 279B)
+        🐍 bench_persistence_spout.py       	(4KB 340B)
         🐍 bench_queue.py                   	(5KB 857B)
         🐍 bench_requests.py                	(6KB 813B)
         🐍 bench_tqdm.py                    	(1KB 235B)
         🐍 bench_utils.py                   	(543B)
-    📁 demo            	(147KB 87B)
+    📁 demo            	(145KB 1012B)
         📁 [1项排除的目录]  	(100KB 9B)
         🐍 demo_executor.py 	(1KB 495B)
         🐍 demo_funnel.py   	(2KB 289B)
-        🐍 demo_graph.py    	(3KB 565B)
-        🐍 demo_network.py  	(3KB 879B)
+        🐍 demo_graph.py    	(3KB 227B)
+        🐍 demo_network.py  	(3KB 729B)
         🐍 demo_observer.py 	(4KB 270B)
-        🐍 demo_redis.py    	(9KB 144B)
-        🐍 demo_stages.py   	(4KB 336B)
-        🐍 demo_structure.py	(12KB 24B)
+        🐍 demo_redis.py    	(9KB 81B)
+        🐍 demo_stages.py   	(4KB 219B)
+        🐍 demo_structure.py	(11KB 593B)
         🐍 demo_utils.py    	(6KB 148B)
-    📁 dist            	(147KB 48B)
+    📁 dist            	(302KB 861B)
         ❓ .gitignore                          	(1B)
         ❓ celestialflow-3.2.7-py3-none-any.whl	(79KB 235B)
         📦 celestialflow-3.2.7.tar.gz          	(67KB 836B)
-    📁 docs            	(1MB 722KB 21B)
+        ❓ celestialflow-3.2.8-py3-none-any.whl	(83KB 244B)
+        📦 celestialflow-3.2.8.tar.gz          	(72KB 569B)
+    📁 docs            	(1MB 756KB 830B)
         📁 en[已折叠]   	(568KB 991B)
         📁 ja[已折叠]   	(642KB 383B)
-        📁 zh-CN[已折叠]	(534KB 695B)
-    📁 experiments     	(2KB 1015B)
-        🐍 experiment_networkx.py	(1KB 878B)
+        📁 zh-CN[已折叠]	(569KB 480B)
+    📁 experiments     	(2KB 1021B)
+        🐍 experiment_networkx.py	(1KB 884B)
         🐍 experiment_tqdm.py    	(1KB 137B)
     📁 img             	(5MB 871KB 242B)
         📷 file_structure.svg  	(4MB 918KB 1000B)
         📷 logo(old).png       	(836KB 542B)
         📷 logo.png            	(122KB 747B)
         📷 scc_condensation.svg	(17KB 1B)
-    📁 src             	(1MB 858KB 89B)
-        📁 celestialflow[已折叠]         	(1MB 839KB 629B)
-        📁 celestialflow.egg-info[已折叠]	(18KB 484B)
-    📁 tests           	(4MB 167KB 552B)
-        📁 benchmark[已折叠]    	(38KB 197B)
+    📁 src             	(1MB 873KB 44B)
+        📁 celestialflow[已折叠]         	(1MB 852KB 902B)
+        📁 celestialflow.egg-info[已折叠]	(20KB 166B)
+    📁 tests           	(4MB 170KB 251B)
+        📁 benchmark[已折叠]    	(39KB 852B)
         📁 funnel[已折叠]       	(96KB 363B)
-        📁 graph[已折叠]        	(721KB 564B)
-        📁 observability[已折叠]	(189KB 236B)
-        📁 persistence[已折叠]  	(388KB 426B)
-        📁 runtime[已折叠]      	(1MB 295KB 529B)
-        📁 stage[已折叠]        	(382KB 155B)
+        📁 graph[已折叠]        	(724KB 404B)
+        📁 observability[已折叠]	(189KB 230B)
+        📁 persistence[已折叠]  	(387KB 877B)
+        📁 runtime[已折叠]      	(1MB 295KB 264B)
+        📁 stage[已折叠]        	(381KB 203B)
         📁 utils[已折叠]        	(639KB 527B)
         📁 [1项排除的目录]      	(487KB 589B)
         🐍 conftest.py          	(1KB 38B)
         🐍 __init__.py          	(0B)
-    📁 [12项排除的目录]	(573MB 420KB 160B)
+    📁 [12项排除的目录]	(573MB 949KB 913B)
     ❓ .env            	(468B)
-    ❓ .gitignore      	(1KB 314B)
-    📝 AGENTS.md       	(1KB 173B)
+    ❓ .gitignore      	(1KB 315B)
+    📝 AGENTS.md       	(1KB 434B)
     ❓ LICENSE         	(1KB 65B)
     ❓ Makefile        	(155B)
     ⚙️ pyproject.toml  	(2KB 668B)
-    📝 README.md       	(19KB 24B)
-    🔒 uv.lock         	(97KB 510B)
+    📝 README.md       	(17KB 465B)
+    🔒 uv.lock         	(121KB 572B)
 ```
 <p align="center">
-  <em>celestial-flow 3.2.8</em>
+  <em>celestial-flow 3.2.9</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
 
 ## 版本日志（Version Log）
-- 3.2.8
+- 3.2.9
   - feat:
-    - [IMPORTANT] 添加 `TaskGraph.run_async`, 现在可以直接进行图级别的异步
-      - 根据 `bench_graph_mode.py` 最新测试, 在I/O密集型任务中, `serial`+`async`（6.05s），比 `serial`+`serial`（69.04s）快 **11.4x**
-    - 在 `core_structure` 中添加报错校验
-    - 不再允许设置 `execution_mode=async` 时调用 `TashExecutor.start`(如今的`TashExecutor.run`), 只能调用 `TashExecutor.run_async`
-    - 另外调用 `TashExecutor.run_async` 时也会进行模式检查, 不是 `execution_mode=async` 就会抛出异常
-    - 在 `BaseObserver` 中添加 `observer_error`, 用于处理 `BaseObserver.on_*` 函数的报错
-    - 在 `TaskGraph._finish_start_graph` `TaskExecutor._finish_start` 中对所有执行步骤进行 `try-except`, 以使收尾步骤尽量全部完成
-    - 添加 `core_scope`, 用于独立控制 `funnel` 的生命周期, 并用于 `TaskGraph.run/run_async` `TaskExecutor.run/run_async`
-  - refactor:
-    - [IMPORTANT] 原 `TaskGraph.start_graph/start_graph_async` `TaskExecutor.start/start_async` 已被重命名为 `TaskGraph.run/run_async` `TaskExecutor.run/run_async`
+    - [IMPORTANT] 移除 `stage` 中 `stage_mode`，并添加 `graph_mode`
       - 破坏性更新
-      - 其底层缘由是为了合并 `TaskStage.start_stage/start_stage_async` 与 `TaskExecutor.start/start_async` 而做出的一系列重构之一
-      - 现在的 `TaskGraph.start/start_async` `TaskExecutor.start/start_async` 不再接受任务, 而是专注于处理现有任务列表中的任务
-    - [IMPORTANT] 将funnel从 `TaskGraph` `TaskExecutor` 中的显性调用与显性传递, 改为所有使用端均从独立文件中import
-      - 一来是因为原先的传递链太丑了, 二来是为了简化 `TaskExecutor.start/start_async` 逻辑, 为其与 `TaskStage.start_stage/start_stage_async` 的合并做准备
-    - 移动部分文件以解决部分模块级的循环引用问题
-      - 原先并非文件级循环引用, 在使用上并无问题
-    - 修改 `TaskDispatch.dispatch_thread` 中处理已完成future的逻辑, 避免cpu浪费
-    - 删除 `util_errors` 中一些不必要的错误类
-    - 将 `TaskGraph._finalize_stages` 进行拆分, 删除不必要的机制, 将剩余机制移至其他方法
-    - 修改 `TaskGraph.set_reporter` 的逻辑, 使其与 `set_ctree` 保持一致
-    - 将 `TaskOutQueue` 中的 `queue_list|target_name|_name_to_idx` 改为 `_queues`, 并删除 `put_channel`
-      - 我有些困惑为什么最初我没有这么做
-    - 在 `TaskExecutor` 中合并 `_get_task_repr` and `_get_result_repr`
-      - 这两个方法原先差异巨大, 但后来经过多次其他部分的重构, 现在逻辑已经一致
-    - 将 `TaskStage` 中的 `_status` 交给 `TaskMetrics` 维护
-      - 依旧是为了合并 `TaskExecutor.start/start_async` 与 `TaskStage.start_stage/start_stage_async`
-    - 移除 `TaskGraph` 中的 `put_stage_queue`
-      - 任务输入完全使用 `TaskExecutor` 中的 `put_task` `put_signal` 方法
+      - `stage_mode` 可以细粒度的控制每个 `TaskStage` 在图中的模式，但经过多年使用，我认为这种细粒度的控制并无必要，反而无谓的增加理解成本
+      - `graph_mode` 则提供了更粗粒度的控制，用于统一控制所有 `TaskStage` 在图中是串行/多线程/并发运行，适用于大多数场景
+      - 同时完善了 `graph_mode`(serial/thread/async) * `execution_mode`(serial/thread/async) 总共 9 种组合模式
+    - 移除 `schedule_mode`
+      - 破坏性更新
+      - 这个模式带来了许多复杂度，但没有与原先的 `stage_mode / execution_mode` 产生明显的组合优势
+    - 在 `get_graph_analysis` 中添加 `graph_mode`
+      - 这个函数主要用于给web端提供信息
+      - web端代码已经同步修改
+    - 添加新的 `warning` 项，当图不是 dag 且 `graph_mode=serial` 时触发
+    - 移除 `task_executor` 中的参数 `persist_result`
+      - 这是为了简化代码逻辑，同时也使所有任务的最终状态（包括：成功/失败/未执行）都能被统一存储
+    - 将 `task.retry` 事件降级，不再申请单独事件ID，不再在 `lifecycle` 中留痕
+  - reafactor:
+    - 合并 `benchmark` 相关函数对 sync 与 async 两种模式的执行
+      - 性能无差异，代码好看一些
+    - 将原本的 `fallback` 改名为 `lifecycle`
+      - 早在重构原本的 `fail` 时就想起个更恰当的名字，这个版本才实现
+    - 将 `graph.source_lists` 改为 `graph.source_names`
+      - `graph.source_lists` 直接存储节点的引用，而 `graph.source_names` 存储节点的名称
+    - 所有的 `log` / `lifecycle` 文件统一改名为 `flow_log` / `flow_lifecycle`
+    - 删除 `graph` 中的 `out_edges` `in_edges`
+      - 现在由 `OrderGraph` 负责管理边关系
+    - 在 `tarjan_scc` 中使用 DFS 取代原先的递归逻辑
+    - 将 `util_graph` 改名为 `util_order_graph`
   - fix:
-    - 在 `TaskDispatch.worker/worker_async` 中添加错误捕捉, 捕捉为 `CRITICAL` 级错误
-      - 避免 `worker` 级出错导致计数错误, 永远无法退出
-    - 在 `spout` 与 `reporter` 的 `stop` 操作中添加对于线程没有成功 `join` 的报错
-    - 修复 `TaskGraph.restore_db` 与 `TaskExecutor.restore_db` 中开启 `filter_by_error_type=Ture` 时跳过 `status=pending` 任务记录的问题
-    - 修复 `TaskGraph` 中部分 `get_*` 方法依赖 `_build_analysis` 的产物, 但 `_build_analysis` 未执行导致的问题
-    - 修复 `TaskMetrics` 中 `get_counts` 与 `is_tasks_finished` 中可能导致死锁的问题
-    - 修复 `TaskReporter` 中 `stop` 里进行的最后一次 `_refresh_all` 没有错误捕捉, 导致后续收尾未完成的问题
+    - 修复最后一次 report 无法正常上传的问题
+    - 修复 `graph.run` / `graph.run_async` 中 `is_put_signal` 参数没有生效的问题
+  - chore：
+    - 更新文档
 
 更多过往日志可看:
 

{celestialflow-3.2.8 → celestialflow-3.2.9}/pyproject.toml

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

celestialflow-3.2.9/src/celestialflow/benchmark/util_benchmark.py

@@ -0,0 +1,129 @@
+# benchmark/util_benchmark.py
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+from ..graph import TaskGraph
+from ..runtime.util_format import format_table
+from ..stage import TaskExecutor
+from .util_clone import clone_executor, clone_graph
+
+type AnyTaskExecutor = TaskExecutor[Any, Any]
+
+
+async def benchmark_executor(
+    sync_executor: AnyTaskExecutor,
+    async_executor: AnyTaskExecutor,
+    task_source: Iterable[Any],
+    execution_modes: list[str] | None = None,
+) -> dict[str, Any]:
+    """
+    对执行器进行基准测试
+
+    :param sync_executor: 同步执行器模板（用于 serial/thread execution_mode）
+    :param async_executor: 异步执行器模板（用于 async execution_mode）
+    :param task_source: 任务源，用于生成任务列表
+    :param execution_modes: 执行模式列表，默认 ["serial", "thread", "async"]
+    :return: 包含测试结果的字典
+    """
+    task_list: list[Any] = list(task_source)
+    execution_modes = execution_modes or ["serial", "thread", "async"]
+
+    use_time: list[list[float]] = []
+    for mode in execution_modes:
+        if mode == "async":
+            cloned_executor = clone_executor(async_executor)
+        else:
+            cloned_executor = clone_executor(sync_executor)
+        cloned_executor.set_execution_mode(mode)
+
+        start = time.perf_counter()
+        if mode == "async":
+            await cloned_executor.run_async(task_list)
+        else:
+            cloned_executor.run(task_list)
+        use_time.append([time.perf_counter() - start])
+
+    use_time_table: str = format_table(use_time, execution_modes, ["Time"])
+    print(f"Use time:\n{use_time_table}\n")
+
+    return {
+        "use_time": use_time,
+        "execution_modes": execution_modes,
+        "table": use_time_table,
+    }
+
+
+async def benchmark_graph(
+    sync_graph: TaskGraph,
+    async_graph: TaskGraph,
+    init_tasks_dict: Mapping[str, Iterable[Any]],
+    graph_modes: list[str] | None = None,
+    execution_modes: list[str] | None = None,
+) -> dict[str, Any]:
+    """
+    对任务图进行基准测试，覆盖 ``graph_mode × execution_mode`` 的全部组合。
+
+    - ``sync_graph`` 用于 ``execution_mode in {"serial", "thread"}`` 的单元格；
+    - ``async_graph`` 用于 ``execution_mode == "async"`` 的单元格；
+    - ``graph_mode`` 决定当前单元格使用 ``run()`` 还是 ``run_async()`` 启动。
+
+    :param sync_graph: 同步任务图模板（用于 serial/thread execution_mode）
+    :param async_graph: 异步任务图模板（用于 async execution_mode）
+    :param init_tasks_dict: 初始任务字典，键为任务标签，值为任务列表
+    :param graph_modes: 要测试的图执行模式列表，默认包括 "serial", "thread", "async"
+    :param execution_modes: 执行模式列表，默认 ["serial", "thread", "async"]
+    :return: 包含测试结果的字典
+    """
+    graph_modes = graph_modes or ["serial", "thread", "async"]
+    execution_modes = execution_modes or ["serial", "thread", "async"]
+
+    base_tasks: dict[str, list[Any]] = {
+        stage_name: list(tasks) for stage_name, tasks in init_tasks_dict.items()
+    }
+
+    test_table_list: list[list[float]] = []
+
+    for graph_mode in graph_modes:
+        time_list: list[float] = []
+
+        for execution_mode in execution_modes:
+            cloned_graph = (
+                clone_graph(async_graph)
+                if execution_mode == "async"
+                else clone_graph(sync_graph)
+            )
+            cloned_graph.set_graph_mode(graph_mode)
+            cloned_graph.set_stage_execution_mode(execution_mode)
+
+            run_tasks: dict[str, Iterable[Any]] = {
+                stage_name: list(tasks) for stage_name, tasks in base_tasks.items()
+            }
+            start_time = time.perf_counter()
+            if graph_mode == "async":
+                await cloned_graph.run_async(run_tasks)
+            else:
+                if execution_mode == "async":
+                    await asyncio.to_thread(cloned_graph.run, run_tasks)
+                else:
+                    cloned_graph.run(run_tasks)
+            time_list.append(time.perf_counter() - start_time)
+
+        test_table_list.append(time_list)
+
+    time_table: str = format_table(
+        test_table_list,
+        graph_modes,
+        execution_modes,
+        "graph/execution",
+    )
+    print(f"Time table:\n{time_table}")
+    return {
+        "use_time": test_table_list,
+        "table": time_table,
+        "graph_modes": graph_modes,
+        "execution_modes": execution_modes,
+    }

{celestialflow-3.2.8 → celestialflow-3.2.9}/src/celestialflow/benchmark/util_clone.py

@@ -31,7 +31,6 @@ def _get_clone_init_kwargs[T, R](
         "max_retries": executor.max_retries,
         "max_info": executor.max_info,
         "enable_duplicate_check": executor.enable_duplicate_check,
-        "persist_result": executor.persist_result,
     }
 
 
@@ -59,7 +58,6 @@ def clone_stage[T, R](
     :return: 克隆节点
     """
     kwargs: dict[str, Any] = _get_clone_init_kwargs(stage)
-    kwargs["stage_mode"] = stage.get_stage_mode()
 
     stage_cls = type(stage)
     init_params = set(inspect.signature(stage_cls.__init__).parameters.keys()) - {
@@ -106,10 +104,12 @@ def clone_graph(graph: TaskGraph) -> TaskGraph:
     :param graph: 要克隆的任务图
     :return: 克隆任务图
     """
-    # 通过广度优先遍历收集所有节点（沿用任务图出边表的顺序）
+    # 通过广度优先遍历收集所有节点（沿用任务图有序图的出边顺序）
     visited: set[str] = set()
     ordered_stages: list[AnyTaskStage] = []
-    queue: deque[AnyTaskStage] = deque(graph.get_source_stages())
+    queue: deque[AnyTaskStage] = deque(
+        graph.stage_dict[source_name] for source_name in graph.get_source_names()
+    )
     while queue:
         stage: AnyTaskStage = queue.popleft()
         stage_name: str = stage.get_name()
@@ -117,7 +117,7 @@ def clone_graph(graph: TaskGraph) -> TaskGraph:
             continue
         visited.add(stage_name)
         ordered_stages.append(stage)
-        for next_stage_name in graph.out_edges.get(stage_name, []):
+        for next_stage_name in graph.order_graph.out_edges.get(stage_name, []):
             next_stage: AnyTaskStage = graph.stage_dict[next_stage_name]
             queue.append(next_stage)
 
@@ -129,14 +129,11 @@ def clone_graph(graph: TaskGraph) -> TaskGraph:
     # 构建新的任务图
     all_cloned_stages: list[AnyTaskStage] = list(name_map.values())
 
-    cloned_graph: TaskGraph = TaskGraph(
-        name=graph.name,
-        schedule_mode=graph.schedule_mode,
-    )
+    cloned_graph: TaskGraph = TaskGraph(name=graph.name, graph_mode=graph.graph_mode)
     cloned_graph.set_stages(all_cloned_stages)
 
     # 重建连接
-    for from_name, to_names in graph.out_edges.items():
+    for from_name, to_names in graph.order_graph.out_edges.items():
         if not to_names:
             continue
         cloned_from: AnyTaskStage = name_map[from_name]