celestialflow 3.0.5__tar.gz → 3.0.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celestialflow
-Version: 3.0.5
+Version: 3.0.7
 Summary: A flexible GRAPH-based task orchestration framework.
 Author-email: Mr-xiaotian <mingxiaomingtian@gmail.com>
 License: MIT
@@ -36,10 +36,17 @@ Requires-Dist: jinja2
   <a href="https://pypi.org/project/celestialflow/"><img src="https://img.shields.io/pypi/pyversions/celestialflow.svg"></a>
 </p>
 
-**CelestialFlow** 是一个轻量级但功能完全体的任务流框架，适合需要“灵活拓扑 + 多执行模式 + 可视化监控”的中/大型 Python 任务系统。
+<p align="center">
+  <img src="https://img.shields.io/badge/Task%20Graph-DAG-blueviolet">
+  <img src="https://img.shields.io/badge/Workflow-Orchestrator-7c3aed">
+  <img src="https://img.shields.io/badge/IPC-Redis%20Ready-red">
+  <img src="https://img.shields.io/badge/Distributed-Worker%20Friendly-orange">
+</p>
+
+**CelestialFlow** 是一个轻量级但功能完全的任务流框架，适合需要 **复杂依赖关系**、**灵活执行模型**、**跨设备运行**与**实时可视化监控** 的中/大型 Python 任务系统。
 
 - 相比 Airflow/Dagster 更轻、更快开始
-- 相比 multiprocessing/threading 更结构化，可直接表达 loop / complete graph 等复杂依赖
+- 相比 multiprocessing/threading 更结构化，可直接表达 loop / complete graph 等复杂依赖模式
 
 框架的基本单元为 **TaskStage**（由 `TaskManager` 派生），每个 stage 内部绑定一个独立的执行函数，并支持四种运行模式：
 
@@ -48,16 +55,16 @@ Requires-Dist: jinja2
 * **多进程（process）**
 * **协程（async）**
 
-每个 stage 均可独立运行，也可作为节点互相连接，形成具有上游与下游依赖关系的任务图（**TaskGraph**）。下游 stage 会自动接收上游执行完成的结果作为输入，从而实现数据的流动与传递。
+每个 stage 均可独立运行，也可作为节点互相连接，形成具有上游与下游依赖关系的任务图（**TaskGraph**）。下游 stage 会自动接收上游执行完成的结果作为输入，从而形成明确的数据流。
 
-在图级别上，TaskGraph 支持两种布局模式：
+在图级别上，每个 Stage 支持两种上下文模式：
 
-* **线性执行（serial layout）**：前一节点执行完毕后再启动下一节点（下游节点可提前接收任务但不会立即执行）。
-* **并行执行（process layout）**：所有节点同时启动运行，由队列自动协调任务传递与依赖顺序。
+* **线性执行（serial layout）**：当前节点执行完毕再启动下一节点（下游节点可提前接收任务但不会立即执行）。
+* **并行执行（process layout）**：当前节点启动后立刻前去启动下一节点。
 
-TaskGraph 能构建完整的 **有向图结构（Directed Graph）**，不仅支持传统的有向无环图（DAG），也能灵活表达 **环形（loop）** 与 **复杂交叉** 的任务依赖。
+TaskGraph 能构建完整的 **有向图结构（Directed Graph）**，不仅支持传统的有向无环图（DAG），也能灵活表达 **树形（Tree）**、**环形（loop）** 乃至于 **完全图(Complete Graph)** 形式的任务依赖。
 
-在此基础上项目支持 Web 可视化与通过 Redis 外接go代码，弥补 Python 在cpu密集任务上速度过慢的问题。
+在此基础上，CelestialFlow 支持 Web 可视化监控，并可通过 Redis 实现跨进程、跨设备协作；同时引入基于 Go 的外部 worker（通过 Redis 通信），用于承载 CPU 密集型任务，弥补 Python 在该场景下的性能瓶颈。
 
 ## 项目结构（Project Structure）
 
@@ -313,21 +320,26 @@ flowchart TD
 
 ## 更新日志（Change Log）
 
-- [2021] 建立一个支持多线程与单线程处理函数的类
-- [2023] 在GPT4帮助下添加多进程与携程运行模式 
-- [5/9/2024] 将原有的处理类抽象为节点, 添加TaskChain类, 可以线性连接多个节点, 并设定节点在Chain中的运行模式, 支持serial和process两种, 后者Chain所有节点同时运行
-- [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/12/2025] 支持循环图, 下级节点可指向上级节点
-- [6/13/2025] 支持loop结构, 即节点可指向自己
-- [6/14/2025] 支持forest结构, 即可有多个根节点
-- [6/16/2025] 多轮评测后, 当前框架已支持完整有向图结构, 故将TaskTree改名为TaskGraph
+- 2021: 建立一个支持多线程与单线程处理函数的类
+- 2023: 在GPT4帮助下添加多进程与携程运行模式 
+- 5/9/2024: 将原有的处理类抽象为节点, 添加TaskChain类, 可以线性连接多个节点, 并设定节点在Chain中的运行模式, 支持serial和process两种, 后者Chain所有节点同时运行
+- 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/12/2025: 支持循环图, 下级节点可指向上级节点
+- 6/13/2025: 支持loop结构, 即节点可指向自己
+- 6/14/2025: 支持forest结构, 即可有多个根节点
+- 6/16/2025: 多轮评测后, 当前框架已支持完整有向图结构, 将TaskTree改名为TaskGraph
+- 3.0.1: 上线Pypi, 可喜可贺
+- 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）
 
-如果对项目感兴趣的话，还请star。
+如果对项目感兴趣的话，欢迎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)
 

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

@@ -11,10 +11,17 @@
   <a href="https://pypi.org/project/celestialflow/"><img src="https://img.shields.io/pypi/pyversions/celestialflow.svg"></a>
 </p>
 
-**CelestialFlow** 是一个轻量级但功能完全体的任务流框架，适合需要“灵活拓扑 + 多执行模式 + 可视化监控”的中/大型 Python 任务系统。
+<p align="center">
+  <img src="https://img.shields.io/badge/Task%20Graph-DAG-blueviolet">
+  <img src="https://img.shields.io/badge/Workflow-Orchestrator-7c3aed">
+  <img src="https://img.shields.io/badge/IPC-Redis%20Ready-red">
+  <img src="https://img.shields.io/badge/Distributed-Worker%20Friendly-orange">
+</p>
+
+**CelestialFlow** 是一个轻量级但功能完全的任务流框架，适合需要 **复杂依赖关系**、**灵活执行模型**、**跨设备运行**与**实时可视化监控** 的中/大型 Python 任务系统。
 
 - 相比 Airflow/Dagster 更轻、更快开始
-- 相比 multiprocessing/threading 更结构化，可直接表达 loop / complete graph 等复杂依赖
+- 相比 multiprocessing/threading 更结构化，可直接表达 loop / complete graph 等复杂依赖模式
 
 框架的基本单元为 **TaskStage**（由 `TaskManager` 派生），每个 stage 内部绑定一个独立的执行函数，并支持四种运行模式：
 
@@ -23,16 +30,16 @@
 * **多进程（process）**
 * **协程（async）**
 
-每个 stage 均可独立运行，也可作为节点互相连接，形成具有上游与下游依赖关系的任务图（**TaskGraph**）。下游 stage 会自动接收上游执行完成的结果作为输入，从而实现数据的流动与传递。
+每个 stage 均可独立运行，也可作为节点互相连接，形成具有上游与下游依赖关系的任务图（**TaskGraph**）。下游 stage 会自动接收上游执行完成的结果作为输入，从而形成明确的数据流。
 
-在图级别上，TaskGraph 支持两种布局模式：
+在图级别上，每个 Stage 支持两种上下文模式：
 
-* **线性执行（serial layout）**：前一节点执行完毕后再启动下一节点（下游节点可提前接收任务但不会立即执行）。
-* **并行执行（process layout）**：所有节点同时启动运行，由队列自动协调任务传递与依赖顺序。
+* **线性执行（serial layout）**：当前节点执行完毕再启动下一节点（下游节点可提前接收任务但不会立即执行）。
+* **并行执行（process layout）**：当前节点启动后立刻前去启动下一节点。
 
-TaskGraph 能构建完整的 **有向图结构（Directed Graph）**，不仅支持传统的有向无环图（DAG），也能灵活表达 **环形（loop）** 与 **复杂交叉** 的任务依赖。
+TaskGraph 能构建完整的 **有向图结构（Directed Graph）**，不仅支持传统的有向无环图（DAG），也能灵活表达 **树形（Tree）**、**环形（loop）** 乃至于 **完全图(Complete Graph)** 形式的任务依赖。
 
-在此基础上项目支持 Web 可视化与通过 Redis 外接go代码，弥补 Python 在cpu密集任务上速度过慢的问题。
+在此基础上，CelestialFlow 支持 Web 可视化监控，并可通过 Redis 实现跨进程、跨设备协作；同时引入基于 Go 的外部 worker（通过 Redis 通信），用于承载 CPU 密集型任务，弥补 Python 在该场景下的性能瓶颈。
 
 ## 项目结构（Project Structure）
 
@@ -288,21 +295,26 @@ flowchart TD
 
 ## 更新日志（Change Log）
 
-- [2021] 建立一个支持多线程与单线程处理函数的类
-- [2023] 在GPT4帮助下添加多进程与携程运行模式 
-- [5/9/2024] 将原有的处理类抽象为节点, 添加TaskChain类, 可以线性连接多个节点, 并设定节点在Chain中的运行模式, 支持serial和process两种, 后者Chain所有节点同时运行
-- [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/12/2025] 支持循环图, 下级节点可指向上级节点
-- [6/13/2025] 支持loop结构, 即节点可指向自己
-- [6/14/2025] 支持forest结构, 即可有多个根节点
-- [6/16/2025] 多轮评测后, 当前框架已支持完整有向图结构, 故将TaskTree改名为TaskGraph
+- 2021: 建立一个支持多线程与单线程处理函数的类
+- 2023: 在GPT4帮助下添加多进程与携程运行模式 
+- 5/9/2024: 将原有的处理类抽象为节点, 添加TaskChain类, 可以线性连接多个节点, 并设定节点在Chain中的运行模式, 支持serial和process两种, 后者Chain所有节点同时运行
+- 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/12/2025: 支持循环图, 下级节点可指向上级节点
+- 6/13/2025: 支持loop结构, 即节点可指向自己
+- 6/14/2025: 支持forest结构, 即可有多个根节点
+- 6/16/2025: 多轮评测后, 当前框架已支持完整有向图结构, 将TaskTree改名为TaskGraph
+- 3.0.1: 上线Pypi, 可喜可贺
+- 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）
 
-如果对项目感兴趣的话，还请star。
+如果对项目感兴趣的话，欢迎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)
 

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

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

{celestialflow-3.0.5 → 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,
@@ -22,6 +24,7 @@ from .task_tools import (
     format_table,
 )
 from .task_web import TaskWebServer
+from .adapters.celestialtree import Client as CelestialTreeClient, format_tree_root
 
 __all__ = [
     "TaskGraph",
@@ -32,12 +35,16 @@ __all__ = [
     "TaskWheel",
     "TaskGrid",
     "TaskManager",
+    "TaskStage",
     "TaskSplitter",
     "TaskRedisSink",
     "TaskRedisSource",
     "TaskRedisAck",
+    "TaskRouter",
     "TerminationSignal",
     "TaskWebServer",
+    "CelestialTreeClient",
+    "format_tree_root",
     "load_task_by_stage",
     "load_task_by_error",
     "make_hashable",

celestialflow-3.0.7/src/celestialflow/adapters/celestialtree/__init__.py

@@ -0,0 +1,2 @@
+from .client import Client, NullClient
+from .tools import format_tree_root

celestialflow-3.0.7/src/celestialflow/adapters/celestialtree/client.py

@@ -0,0 +1,198 @@
+import json
+import threading
+import requests
+from typing import List, Optional, Dict, Any, Callable
+
+
+class Client:
+    """
+    Python client for CelestialTree HTTP API.
+    """
+
+    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):
+        if hasattr(self, "session"):
+            return
+
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            }
+        )
+
+    # ---------- Core APIs ----------
+
+    def emit(
+        self,
+        type_: str,
+        parents: Optional[List[int]] = None,
+        message: Optional[str] = None,
+        payload: Optional[bytes | dict] = None,
+    ) -> int:
+        """
+        Emit a new event into CelestialTree.
+        """
+        self.init_session()
+
+        body = {
+            "type": type_,
+            "parents": parents or [],
+        }
+
+        if message is not None:
+            body["message"] = message
+
+        if payload is not None:
+            if isinstance(payload, (dict, list)):
+                body["payload"] = json.dumps(payload).encode("utf-8")
+            elif isinstance(payload, (bytes, bytearray)):
+                body["payload"] = payload
+            else:
+                raise TypeError("payload must be bytes or dict")
+
+        r = self.session.post(
+            f"{self.base_url}/emit",
+            data=json.dumps(body),
+            timeout=self.timeout,
+        )
+
+        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]:
+        self.init_session()
+
+        r = self.session.get(
+            f"{self.base_url}/event/{event_id}",
+            timeout=self.timeout,
+        )
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
+        return r.json()
+
+    def children(self, event_id: int) -> List[int]:
+        self.init_session()
+
+        r = self.session.get(
+            f"{self.base_url}/children/{event_id}",
+            timeout=self.timeout,
+        )
+
+        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]:
+        self.init_session()
+
+        r = self.session.get(
+            f"{self.base_url}/descendants/{event_id}",
+            timeout=self.timeout,
+        )
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
+        return r.json()
+
+    def heads(self) -> List[int]:
+        self.init_session()
+
+        r = self.session.get(
+            f"{self.base_url}/heads",
+            timeout=self.timeout,
+        )
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
+        return r.json()["heads"]
+
+    def health(self) -> bool:
+        self.init_session()
+        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()
+
+        r = self.session.get(
+            f"{self.base_url}/version",
+            timeout=self.timeout,
+        )
+
+        if not (200 <= r.status_code < 300):
+            raise RuntimeError(r.json()["error"])
+        return r.json()
+
+    # ---------- SSE Subscribe ----------
+
+    def subscribe(
+        self,
+        on_event: Callable[[Dict[str, Any]], None],
+        daemon: bool = True,
+    ) -> threading.Thread:
+        """
+        Subscribe to SSE stream.
+        on_event will be called for each emitted Event.
+        """
+
+        def _run():
+            with self.session.get(
+                f"{self.base_url}/subscribe",
+                stream=True,
+                timeout=None,
+            ) as r:
+                r.raise_for_status()
+                buf = ""
+                for line in r.iter_lines(decode_unicode=True):
+                    if not line:
+                        continue
+
+                    if line.startswith("data:"):
+                        data = line[len("data:") :].strip()
+                        try:
+                            ev = json.loads(data)
+                            on_event(ev)
+                        except Exception:
+                            pass
+
+        self.init_session()
+
+        t = threading.Thread(target=_run, daemon=daemon)
+        t.start()
+        return t
+
+
+class NullClient:
+    event_id = 0
+
+    def emit(self, *args, **kwargs):
+        self.event_id += 1
+        return self.event_id
+
+    def get_event(self, *args, **kwargs):
+        return None
+
+    def children(self, *args, **kwargs):
+        return []
+
+    def descendants(self, *args, **kwargs):
+        return None
+
+    def heads(self):
+        return []
+
+    def subscribe(self, *args, **kwargs):
+        return None

celestialflow-3.0.7/src/celestialflow/adapters/celestialtree/tools.py

@@ -0,0 +1,41 @@
+def format_tree(node: dict, prefix: str = "", is_last: bool = True) -> str:
+    """
+    将 {"id": x, "children": [...]} 结构格式化为树状文本。
+
+    :param node: 当前节点
+    :param prefix: 前缀（递归用）
+    :param is_last: 是否是同级最后一个节点
+    :return: 树状字符串
+    """
+    lines = []
+
+    connector = "└── " if is_last else "├── "
+
+    label = str(node["id"])
+    if node.get("is_ref"):
+        label += " (ref)"
+
+    lines.append(f"{prefix}{connector}{label}")
+
+    children = node.get("children", [])
+    if children:
+        next_prefix = prefix + ("    " if is_last else "│   ")
+        for i, child in enumerate(children):
+            last = i == len(children) - 1
+            lines.append(format_tree(child, next_prefix, last))
+
+    return "\n".join(lines)
+
+
+def format_tree_root(tree: dict) -> str:
+    """
+    格式化整棵树（根节点无连接符）
+    """
+    lines = [str(tree["id"])]
+
+    children = tree.get("children", [])
+    for i, child in enumerate(children):
+        last = i == len(children) - 1
+        lines.append(format_tree(child, "", last))
+
+    return "\n".join(lines)

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

@@ -5,16 +5,15 @@ from datetime import datetime
 from multiprocessing import Queue as MPQueue
 from typing import Any, Dict, List
 
-from .task_manage import TaskManager
-from .task_report import TaskReporter
+from .task_stage import TaskStage
+from .task_report import TaskReporter, NullTaskReporter
 from .task_logging import LogListener, TaskLogger
 from .task_queue import TaskQueue
-from .task_types import StageStatus, TerminationSignal, TERMINATION_SIGNAL
+from .task_types import TaskEnvelope, StageStatus, TerminationSignal, TERMINATION_SIGNAL
 from .task_tools import (
     format_duration,
     format_timestamp,
     cleanup_mpqueue,
-    make_hashable,
     build_structure_graph,
     format_structure_list_from_graph,
     append_jsonl_log,
@@ -26,19 +25,23 @@ from .task_tools import (
     load_task_by_error,
     format_repr,
 )
+from .adapters.celestialtree import (
+    Client as CelestialTreeClient,
+    NullClient as NullCelestialTreeClient,
+)
 
 
 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'
@@ -61,6 +64,7 @@ class TaskGraph:
         self.analyze_graph()
         self.set_layout_mode(layout_mode)
         self.set_reporter()
+        self.set_ctree()
 
     def init_env(self):
         """
@@ -126,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"]
 
             # 遍历每个前驱，创建边队列
@@ -158,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]):
         """
         设置根节点
 
@@ -188,8 +192,32 @@ class TaskGraph:
         :param host: 报告器主机地址
         :param port: 报告器端口
         """
-        self.is_report = is_report
-        self.reporter = TaskReporter(self, self.log_listener.get_queue(), host, port)
+        if is_report:
+            self.reporter = TaskReporter(
+                self, self.log_listener.get_queue(), host, port
+            )
+        else:
+            self.reporter = NullTaskReporter()
+
+    def set_ctree(self, use_ctree=False, host="127.0.0.1", port=7777):
+        """
+        设定事件树客户端
+
+        :param use_ctree: 是否使用事件树
+        :param host: 事件树主机地址
+        :param port: 事件树端口
+        """
+        self._use_ctree = use_ctree
+        self._ctree_host = host
+        self._ctree_port = port
+
+        if use_ctree:
+            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()
 
     def set_graph_mode(self, stage_mode: str, execution_mode: str):
         """
@@ -199,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)
@@ -222,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:
@@ -230,8 +258,18 @@ class TaskGraph:
                     in_queue.put(TERMINATION_SIGNAL)
                     continue
 
-                in_queue.put_first(make_hashable(task))
+                task_id = self.ctree_client.emit(
+                    "task.input", message=f"In '{stage.get_stage_tag()}'"
+                )
+                envelope = TaskEnvelope.wrap(task, task_id)
+                in_queue.put_first(envelope)
                 stage.task_counter.add_init_value(1)
+                self.task_logger.task_inject(
+                    stage.get_func_name(),
+                    stage.get_task_info(task),
+                    stage.get_stage_tag(),
+                    f"[{task_id}]",
+                )
 
         if put_termination_signal:
             for root_stage in self.root_stages:
@@ -253,7 +291,7 @@ class TaskGraph:
             self.start_time = time.time()
             self.task_logger.start_graph(self.get_structure_list())
             self._persist_structure_metadata()
-            self.reporter.start() if self.is_report else None
+            self.reporter.start()
 
             self.put_stage_queue(init_tasks_dict, put_termination_signal)
             self._excute_stages()
@@ -288,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])  # 最新的进程
@@ -301,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):
         """
         执行单个节点
 
@@ -318,6 +356,9 @@ class TaskGraph:
         self.stages_status_dict[stage_tag]["status"] = StageStatus.RUNNING
         self.stages_status_dict[stage_tag]["start_time"] = time.time()
 
+        if self._use_ctree:
+            stage.set_ctree(self._ctree_host, self._ctree_port)
+
         if stage.stage_mode == "process":
             p = multiprocessing.Process(
                 target=stage.start_stage,
@@ -458,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)