celestialflow 3.1.4__tar.gz → 3.1.5__tar.gz

{celestialflow-3.1.4 → celestialflow-3.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celestialflow
-Version: 3.1.4
+Version: 3.1.5
 Summary: A flexible GRAPH-based task orchestration framework.
 Author-email: Mr-xiaotian <mingxiaomingtian@gmail.com>
 License: MIT
@@ -254,35 +254,28 @@ 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.1.4</em>
+  <em>celestial-flow 3.1.5</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
 
 ## 版本日志（Version Log）
-- 3.1.4:
-  - feat:
-    - 添加前端设置文件config.json, 包含主题(白天与黑夜), 刷新时间, 历史长度, 卡片种类, 仪表盘布局;
-    - 完善对termination_signal在ctree上的事件管理;
-    - 新添termination_*系日志, 同时优化部分原有日志;
-    - 在前端的错误数字上(包括单个stage的卡片与summary卡片)绑定跳转事件, 可以跳转到ErrorLog页面, 并显示对应的错误;
-    - 修复部分原有的文档错误, 并添加新的前端代码文档;
-  - refactor:
-    - fail_sinker.task_error中不必再传时间, 方法会自己补充;
-    - 将所有counter放入TaskMetrics管理, 断绝对TAskExecutor的调用依赖;
-    - 将run_*函数分离并移入TaskRunner类, 同时将pool管理也迁入; 
-    - 将TaskQueue分离为更具体的TaskInQueue与TaskOutQueue, 同时TAskInQueue只接受一个MPQueue以避免原有的轮询逻辑, 减少CPU运算消耗;
-    - 前端代码换用ts;
-    - 重命名所有代码文件, 现在用core_与util_前缀来区分核心代码与辅助代码;
-    - 将history数据从status中移出, 使用单独的/api/*_history端口;
-  - fix:
-    - TaskRedisTransport节点在mermaid中没有展示为parallelogram;
+- 3.1.5
+  - feat
+    - 大幅修改节点状态卡片的色彩视觉设计. 包括: 取消原本的悬浮设计, 改为平面化设计; 让进度条更直接的显示不同任务完成状态的比例; 使用左边框来显示节点是否在运行中. 而非原本的badge;
+    - 前端的error数据拉取不再每次都全量拉取, 而是只拉取自己当前没有的数据;
+  - refactor
+    - 大幅重构前端代码中的色彩管理, 现在色彩的一致性更好;
+    - 修改前端代码中的数据更新判断, 现在相关判断交给serve.py;
+  - fix
+    - 修复节点已运行时间在节点完成后显示为0的问题
+    - 修复在最新fastapi版本下TemplateResponse参数改变导致的问题
 
 ## Star 历史趋势（Star History）
 
 如果对项目感兴趣的话，欢迎star。如果有问题或者建议的话, 欢迎提交[Issues](https://github.com/Mr-xiaotian/CelestialFlow/issues)或者在[Discussion](https://github.com/Mr-xiaotian/CelestialFlow/discussions)中告诉我。
 
-[![Star History Chart](https://api.star-history.com/svg?repos=Mr-xiaotian/CelestialFlow&type=Date)](https://star-history.com/#Mr-xiaotian/CelestialFlow&Date)
+![Star History Chart](https://api.star-history.com/svg?repos=Mr-xiaotian/CelestialFlow&type=Date)
 
 ## 许可（License）
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

{celestialflow-3.1.4 → celestialflow-3.1.5}/README.md

@@ -229,35 +229,28 @@ 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.1.4</em>
+  <em>celestial-flow 3.1.5</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
 
 ## 版本日志（Version Log）
-- 3.1.4:
-  - feat:
-    - 添加前端设置文件config.json, 包含主题(白天与黑夜), 刷新时间, 历史长度, 卡片种类, 仪表盘布局;
-    - 完善对termination_signal在ctree上的事件管理;
-    - 新添termination_*系日志, 同时优化部分原有日志;
-    - 在前端的错误数字上(包括单个stage的卡片与summary卡片)绑定跳转事件, 可以跳转到ErrorLog页面, 并显示对应的错误;
-    - 修复部分原有的文档错误, 并添加新的前端代码文档;
-  - refactor:
-    - fail_sinker.task_error中不必再传时间, 方法会自己补充;
-    - 将所有counter放入TaskMetrics管理, 断绝对TAskExecutor的调用依赖;
-    - 将run_*函数分离并移入TaskRunner类, 同时将pool管理也迁入; 
-    - 将TaskQueue分离为更具体的TaskInQueue与TaskOutQueue, 同时TAskInQueue只接受一个MPQueue以避免原有的轮询逻辑, 减少CPU运算消耗;
-    - 前端代码换用ts;
-    - 重命名所有代码文件, 现在用core_与util_前缀来区分核心代码与辅助代码;
-    - 将history数据从status中移出, 使用单独的/api/*_history端口;
-  - fix:
-    - TaskRedisTransport节点在mermaid中没有展示为parallelogram;
+- 3.1.5
+  - feat
+    - 大幅修改节点状态卡片的色彩视觉设计. 包括: 取消原本的悬浮设计, 改为平面化设计; 让进度条更直接的显示不同任务完成状态的比例; 使用左边框来显示节点是否在运行中. 而非原本的badge;
+    - 前端的error数据拉取不再每次都全量拉取, 而是只拉取自己当前没有的数据;
+  - refactor
+    - 大幅重构前端代码中的色彩管理, 现在色彩的一致性更好;
+    - 修改前端代码中的数据更新判断, 现在相关判断交给serve.py;
+  - fix
+    - 修复节点已运行时间在节点完成后显示为0的问题
+    - 修复在最新fastapi版本下TemplateResponse参数改变导致的问题
 
 ## Star 历史趋势（Star History）
 
 如果对项目感兴趣的话，欢迎star。如果有问题或者建议的话, 欢迎提交[Issues](https://github.com/Mr-xiaotian/CelestialFlow/issues)或者在[Discussion](https://github.com/Mr-xiaotian/CelestialFlow/discussions)中告诉我。
 
-[![Star History Chart](https://api.star-history.com/svg?repos=Mr-xiaotian/CelestialFlow&type=Date)](https://star-history.com/#Mr-xiaotian/CelestialFlow&Date)
+![Star History Chart](https://api.star-history.com/svg?repos=Mr-xiaotian/CelestialFlow&type=Date)
 
 ## 许可（License）
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

{celestialflow-3.1.4 → celestialflow-3.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "celestialflow"                   
-version = "3.1.4"
+version = "3.1.5"
 description = "A flexible GRAPH-based task orchestration framework."
 readme = "README.md"               
 license = { text = "MIT" }    
@@ -43,10 +43,9 @@ license-files = []
 
 [tool.setuptools.package-data]
 celestialflow = [
-    "web/templates/*.html",
     "web/templates/**/*.html",
-    "web/static/*",
     "web/static/**/*",
+    "web/config.json"
 ]
 
 [tool.pytest.ini_options]

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/graph/core_graph.py

@@ -22,7 +22,6 @@ from ..runtime.util_errors import UnconsumedError
 from ..runtime.util_types import (
     StageStatus,
     TerminationSignal,
-    NullPrevStage,
     STAGE_STYLE,
     NULL_PREV_STAGE,
 )
@@ -585,9 +584,7 @@ class TaskGraph:
             start_time = stage_runtime.get("start_time", 0)
             last_elapsed = last_stage_status_dict.get("elapsed_time", 0)
             last_pending = last_stage_status_dict.get("tasks_pending", 0)
-            elapsed = calc_elapsed(
-                status, start_time, last_elapsed, last_pending, interval
-            )
+            elapsed = calc_elapsed(status, last_elapsed, last_pending, interval)
 
             # 估算剩余时间
             remaining = calc_remaining(

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/graph/core_structure.py

@@ -17,6 +17,7 @@ class TaskChain(TaskGraph):
 
         :param stages: TaskStage 列表, 每个 TaskStage 节点将连接到下一个节点
         :param chain_mode: 控制任务链中各节点同时运行(process), 亦或者依次运行(serial)
+        :param log_level: 日志级别
         """
         for num, stage in enumerate(stages):
             stage_name = f"Stage {num + 1}"
@@ -24,7 +25,9 @@ class TaskChain(TaskGraph):
             stage.set_graph_context(next_stages, chain_mode, stage_name)
 
         root_stage = stages[0]
-        super().__init__(root_stages=[root_stage], log_level=log_level)
+        super().__init__(
+            root_stages=[root_stage], schedule_mode="eager", log_level=log_level
+        )
 
     def start_chain(
         self, init_tasks_dict: dict, put_termination_signal: bool = True
@@ -53,8 +56,8 @@ class TaskCross(TaskGraph):
         :param layers:
             按层划分的任务节点列表。每个子列表代表一层，列表中的 TaskStage 将并行执行。
             相邻层之间的所有节点将建立全连接依赖（即每个上一层节点都连接到下一层所有节点）。
-        :param schedule_mode:
-            控制任务图的调度布局模式
+        :param schedule_mode: 控制任务图的调度布局模式
+        :param log_level: 日志级别
         """
         for i in range(len(layers)):
             curr_layer = layers[i]
@@ -98,6 +101,7 @@ class TaskGrid(TaskGraph):
             任务网格，每个子列表代表一行，列表中的 TaskStage 将按行并行执行。
             每个节点将连接到其右侧和下方的节点。
         :param schedule_mode: 控制任务图的调度布局模式
+        :param log_level: 日志级别
         """
         rows, cols = len(grid), len(grid[0])
         for i in range(rows):
@@ -133,6 +137,7 @@ class TaskLoop(TaskGraph):
         由于环的结构特性, 强制使用 'eager' 节点模式
 
         :param stages: TaskStage 列表, 每个 TaskStage 节点将连接到下一个节点, 形成一个闭环
+        :param log_level: 日志级别
         """
         for num, stage in enumerate(stages):
             stage_name = f"Stage {num + 1}"
@@ -163,6 +168,7 @@ class TaskWheel(TaskGraph):
 
         :param center: 中心节点
         :param ring: 环节点
+        :param log_level: 日志级别
         """
         # 中心连向环
         center.set_graph_context(ring, "process", "Center")
@@ -190,6 +196,7 @@ class TaskComplete(TaskGraph):
         TaskComplete: 完全图结构，每个节点都连向除自己以外的所有其他节点
 
         :param stages: 所有 TaskStage 节点
+        :param log_level: 日志级别
         """
         for i, stage in enumerate(stages):
             next_stages = [s for j, s in enumerate(stages) if i != j]

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/observability/core_report.py

@@ -44,6 +44,7 @@ class TaskReporter:
         self._stop_flag = Event()
         self._thread = None
         self._push_errors_mode = "meta"
+        self._session = requests.Session()
 
         self.interval = 5
         self.history_limit = 20
@@ -62,6 +63,7 @@ class TaskReporter:
             self._stop_flag.set()
             self._thread.join(timeout=2)
             self._thread = None
+            self._session.close()
             self.log_sinker.stop_reporter()
 
     def _pull_timeout(self) -> float:
@@ -88,6 +90,9 @@ class TaskReporter:
         self._pull_history_limit()
         self._pull_and_inject_tasks()
 
+        # 收集最新的任务图状态快照，确保推送的数据是最新的
+        self.task_graph.collect_runtime_snapshot()
+
         # 推送逻辑
         self._push_errors()
         self._push_status()
@@ -99,7 +104,7 @@ class TaskReporter:
     def _pull_interval(self) -> None:
         """从远程服务拉取上报间隔配置"""
         try:
-            res = requests.get(
+            res = self._session.get(
                 f"{self.base_url}/api/pull_interval", timeout=self._pull_timeout()
             )
             if res.ok:
@@ -111,7 +116,7 @@ class TaskReporter:
     def _pull_history_limit(self) -> None:
         """从远程服务拉取历史记录限制配置"""
         try:
-            res = requests.get(
+            res = self._session.get(
                 f"{self.base_url}/api/pull_history_limit", timeout=self._pull_timeout()
             )
             if res.ok:
@@ -123,7 +128,7 @@ class TaskReporter:
     def _pull_and_inject_tasks(self) -> None:
         """从远程服务拉取任务注入信息并注入任务"""
         try:
-            res = requests.get(
+            res = self._session.get(
                 f"{self.base_url}/api/pull_task_injection", timeout=self._pull_timeout()
             )
             if res.ok:
@@ -178,7 +183,7 @@ class TaskReporter:
             "jsonl_path": jsonl_path,
             "rev": rev,
         }
-        response = requests.post(
+        response = self._session.post(
             f"{self.base_url}/api/push_errors_meta",
             json=payload,
             timeout=self._push_timeout(),
@@ -192,14 +197,14 @@ class TaskReporter:
 
         error_store = load_jsonl_logs(
             path=jsonl_path,
-            keys=["ts", "error_id", "error_repr", "stage", "task_repr"],
+            keys=["ts", "error_id", "error_repr", "error", "stage", "task_repr"],
         )
         payload = {
             "errors": error_store,
             "jsonl_path": jsonl_path,
             "rev": rev,
         }
-        response = requests.post(
+        response = self._session.post(
             f"{self.base_url}/api/push_errors_content",
             json=payload,
             timeout=self._push_timeout(),
@@ -209,10 +214,9 @@ class TaskReporter:
     def _push_status(self) -> None:
         """推送状态信息"""
         try:
-            self.task_graph.collect_runtime_snapshot()
             status_data = self.task_graph.get_status_dict()
             payload = {"status": status_data}
-            requests.post(
+            self._session.post(
                 f"{self.base_url}/api/push_status",
                 json=payload,
                 timeout=self._push_timeout(),
@@ -225,7 +229,7 @@ class TaskReporter:
         try:
             structure = self.task_graph.get_structure_json()
             payload = {"items": structure}
-            requests.post(
+            self._session.post(
                 f"{self.base_url}/api/push_structure",
                 json=payload,
                 timeout=self._push_timeout(),
@@ -238,7 +242,7 @@ class TaskReporter:
         try:
             topology = self.task_graph.get_graph_topology()
             payload = {"topology": topology}
-            requests.post(
+            self._session.post(
                 f"{self.base_url}/api/push_topology",
                 json=payload,
                 timeout=self._push_timeout(),
@@ -251,7 +255,7 @@ class TaskReporter:
         try:
             summary = self.task_graph.get_graph_summary()
             payload = {"summary": summary}
-            requests.post(
+            self._session.post(
                 f"{self.base_url}/api/push_summary",
                 json=payload,
                 timeout=self._push_timeout(),
@@ -264,7 +268,7 @@ class TaskReporter:
         try:
             history = self.task_graph.get_stage_history()
             payload = {"history": history}
-            requests.post(
+            self._session.post(
                 f"{self.base_url}/api/push_history",
                 json=payload,
                 timeout=self._push_timeout(),

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/persistence/core_log.py

@@ -87,9 +87,9 @@ class LogSinker(BaseSinker):
 
     # ==== stage ====
     def start_stage(
-        self, stage_tag: str, stage_mode: str, execution_mode: str, worker_limit: int
+        self, stage_tag: str, stage_mode: str, execution_mode: str, max_workers: int
     ) -> None:
-        worker_repr = f"({worker_limit} workers)" if execution_mode != "serial" else ""
+        worker_repr = f"({max_workers} workers)" if execution_mode != "serial" else ""
         text = f"'{stage_tag}' start in {stage_mode}; execute tasks by {execution_mode}{worker_repr}."
         self._sink("INFO", text)
 

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/runtime/core_runner.py

@@ -15,17 +15,17 @@ if TYPE_CHECKING:
 
 
 class TaskRunner:
-    def __init__(self, task_executor: TaskExecutor, func, worker_limit: int):
+    def __init__(self, task_executor: TaskExecutor, func, max_workers: int):
         """
         初始化任务运行器
 
         :param task_executor: 任务执行器
         :param func: 任务函数
-        :param worker_limit: 工作线程或进程数量限制
+        :param max_workers: 工作线程或进程数量限制
         """
         self.task_executor = task_executor
         self.func = func
-        self.worker_limit = worker_limit
+        self.max_workers = max_workers
 
         self._pool: ThreadPoolExecutor | ProcessPoolExecutor | None = None
 
@@ -37,9 +37,9 @@ class TaskRunner:
         """
         # 可以复用的线程池或进程池
         if execution_mode == "thread" and self._pool is None:
-            self._pool = ThreadPoolExecutor(max_workers=self.worker_limit)
+            self._pool = ThreadPoolExecutor(max_workers=self.max_workers)
         elif execution_mode == "process" and self._pool is None:
-            self._pool = ProcessPoolExecutor(max_workers=self.worker_limit)
+            self._pool = ProcessPoolExecutor(max_workers=self.max_workers)
 
     def process_termination_signal(
         self, termination_pool: TerminationIdPool
@@ -206,7 +206,7 @@ class TaskRunner:
         """
         while True:
             semaphore = asyncio.Semaphore(
-                self.task_executor.worker_limit
+                self.task_executor.max_workers
             )  # 限制并发数量
 
             async def sem_task(envelope: TaskEnvelope):

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/runtime/util_estimators.py

@@ -6,6 +6,10 @@ from .util_types import StageStatus
 
 # ==== calculate ====
 def calc_remaining(processed: int, pending: int, elapsed: float) -> float:
+    """
+    基于已处理任务,剩余任务以及已消耗时间来计算剩余时间.
+    不要瞧不起均值,在大规模数据下它可能是最有效的.
+    """
     if processed and pending:
         return pending / processed * elapsed
     return 0
@@ -13,15 +17,15 @@ def calc_remaining(processed: int, pending: int, elapsed: float) -> float:
 
 def calc_elapsed(
     status: StageStatus,
-    start_time: float,
     last_elapsed: float,
     last_pending: int,
     interval: float,
 ) -> float:
-    """更新时间消耗（仅在 RUNNING 且 pending 非 0 时刷新）"""
-    if status == StageStatus.RUNNING and start_time:
+    """
+    更新时间消耗
+    """
+    if status in (StageStatus.RUNNING, StageStatus.STOPPED):
         elapsed = last_elapsed
-        # 如果上一次是 pending，则累计时间
         if last_pending:
             # 如果上一次活跃, 那么无论当前状况，累计一次更新时间
             elapsed += interval
@@ -121,7 +125,7 @@ def calc_global_remain_equal_pred(
                 total_v += obs_each * scale.get(u, 1.0)
 
         scale[v] = total_v / max(1.0, proc_v)  # 下游放大系数
-        expect_pend_v = max(0.0, total_v - proc_v)
+        expect_pend_v = max(0.0, total_v - proc_v)  # 理论上expect_pend_v >= pend_v
 
         # 时间估算：需要 avg time（秒/任务）
         expected_pending_map[v] = calc_remaining(proc_v, expect_pend_v, elapsed_v)

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/stage/core_executor.py

@@ -42,7 +42,7 @@ class TaskExecutor:
         self,
         func,
         execution_mode="serial",
-        worker_limit=20,
+        max_workers=20,
         max_retries=1,
         max_info=50,
         unpack_task_args=False,
@@ -58,7 +58,7 @@ class TaskExecutor:
 
         :param func: 可调用对象
         :param execution_mode: 执行模式，可选 'serial', 'thread', 'process', 'async' (组合为 'TaskGraph' 时不可用 'process' 和 'async' 模式)
-        :param worker_limit: 同时处理数量
+        :param max_workers: 同时处理数量
         :param max_retries: 任务的最大重试次数
         :param max_info: 日志中每条信息的最大长度
         :param unpack_task_args: 是否将任务参数解包
@@ -80,7 +80,7 @@ class TaskExecutor:
 
         self.set_func(func)
         self.set_execution_mode(execution_mode)
-        self.worker_limit = worker_limit
+        self.max_workers = max_workers
         self.max_retries = max_retries
         self.max_info = max_info
 
@@ -177,7 +177,7 @@ class TaskExecutor:
         """
         初始化任务运行器
         """
-        self.runner = TaskRunner(self, self.func, self.worker_limit)
+        self.runner = TaskRunner(self, self.func, self.max_workers)
 
     def init_listener(self) -> None:
         """
@@ -198,7 +198,7 @@ class TaskExecutor:
             return
 
         extra_desc = (
-            f"{self.execution_mode}-{self.worker_limit}"
+            f"{self.execution_mode}-{self.max_workers}"
             if self.execution_mode != "serial"
             else "serial"
         )
@@ -307,7 +307,7 @@ class TaskExecutor:
         return (
             self.execution_mode
             if self.execution_mode == "serial"
-            else f"{self.execution_mode}-{self.worker_limit}"
+            else f"{self.execution_mode}-{self.max_workers}"
         )
 
     def get_summary(self) -> dict:

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/stage/core_stage.py

@@ -218,7 +218,7 @@ class TaskStage(TaskExecutor):
         self.init_progress()
         self.init_env(input_queues, output_queues, fail_queue, log_queue)
         self.log_sinker.start_stage(
-            self.get_tag(), self.stage_mode, self.execution_mode, self.worker_limit
+            self.get_tag(), self.stage_mode, self.execution_mode, self.max_workers
         )
         self.mark_running()
 

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/stage/core_stages.py

@@ -25,12 +25,15 @@ class TaskSplitter(TaskStage):
         self.init_extra_counter()
 
     def init_extra_counter(self) -> None:
+        """初始化额外的计数器"""
         self.split_counter = MPValue("i", 0)
 
     def reset_extra_counter(self) -> None:
+        """重置额外的计数器"""
         self.split_counter.value = 0
 
     def update_split_counter(self, add_value: int) -> None:
+        """更新 split 计数器"""
         self.split_counter.value += add_value
 
     def _split(self, *task: Any) -> tuple:
@@ -40,6 +43,13 @@ class TaskSplitter(TaskStage):
         return task
 
     def put_split_result(self, result: tuple, task_id: int) -> int:
+        """
+        将 split 结果放入队列，并发出对应事件
+
+        :param result: split 的结果，必须是一个可迭代对象
+        :param task_id: 原始任务 ID，用于事件关联
+        :return: split 的子任务数量
+        """
         split_count = len(result)
         for idx, item in enumerate(result):
             split_id = self.ctree_client.emit(
@@ -94,6 +104,7 @@ class TaskSplitter(TaskStage):
 
 class TaskRouter(TaskStage):
     def __init__(self):
+        """初始化 TaskRouter"""
         super().__init__(
             func=self._route,
             execution_mode="serial",
@@ -103,14 +114,17 @@ class TaskRouter(TaskStage):
         self.init_extra_counter()
 
     def init_extra_counter(self) -> None:
+        """初始化额外的计数器"""
         # 每个 target_tag 一个计数器：用于让不同下游 stage 的 task_counter 统计正确
         self.route_counters: dict = {}
 
     def reset_extra_counter(self) -> None:
+        """重置额外的计数器"""
         for counter in self.route_counters.values():
             counter.value = 0
 
     def update_route_counter(self, target: str) -> None:
+        """更新 route 计数器"""
         self.route_counters[target].value += 1
 
     def _route(self, routed: tuple) -> tuple:
@@ -189,7 +203,7 @@ class TaskRedisTransport(TaskStage):
         super().__init__(
             func=self._transport,
             execution_mode="thread",
-            worker_limit=4,  # 允许 1~2 个线程偶发阻塞，但不会导致整体阻塞
+            max_workers=4,  # 允许 1~2 个线程偶发阻塞，但不会导致整体阻塞
             unpack_task_args=unpack_task_args,
         )
         self.key = key

{celestialflow-3.1.4 → celestialflow-3.1.5}/src/celestialflow/utils/util_clone.py

@@ -17,7 +17,7 @@ def _get_clone_init_kwargs(executor: TaskExecutor) -> dict:
     return {
         "func": executor.func,
         "execution_mode": executor.execution_mode,
-        "worker_limit": executor.worker_limit,
+        "max_workers": executor.max_workers,
         "max_retries": executor.max_retries,
         "max_info": executor.max_info,
         "unpack_task_args": executor.unpack_task_args,

celestialflow-3.1.5/src/celestialflow/web/config.json

@@ -0,0 +1,35 @@
+{
+    "theme": "dark",
+    "refreshInterval": 2000,
+    "historyLimit": 20,
+    "dashboard": {
+        "left": [
+            "mermaid",
+            "topology"
+        ],
+        "middle": [
+            "status"
+        ],
+        "right": [
+            "progress",
+            "summary"
+        ]
+    },
+    "cards": {
+        "mermaid": {
+            "title": "任务结构图"
+        },
+        "topology": {
+            "title": "图拓扑信息"
+        },
+        "status": {
+            "title": "节点运行状态"
+        },
+        "progress": {
+            "title": "节点完成走向"
+        },
+        "summary": {
+            "title": "总体状态摘要"
+        }
+    }
+}