celestialflow 3.1.2__tar.gz → 3.1.3__tar.gz

{celestialflow-3.1.2 → celestialflow-3.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celestialflow
-Version: 3.1.2
+Version: 3.1.3
 Summary: A flexible GRAPH-based task orchestration framework.
 Author-email: Mr-xiaotian <mingxiaomingtian@gmail.com>
 License: MIT
@@ -15,14 +15,13 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: tqdm
-Requires-Dist: loguru
 Requires-Dist: fastapi
 Requires-Dist: uvicorn
 Requires-Dist: requests
 Requires-Dist: networkx
 Requires-Dist: redis
 Requires-Dist: jinja2
-Requires-Dist: celestialtree
+Requires-Dist: celestialtree>=0.1.2
 
 # CelestialFlow ——一个轻量级、可并行、基于图结构的 Python 任务调度框架
 
@@ -240,9 +239,8 @@ flowchart TD
 
 | 依赖包           | 说明 |
 | ----------------- | ---- |
-| **Python ≥ 3.8**  | 运行环境，建议使用 3.10 及以上版本 |
+| **Python ≥ 3.10**  | 运行环境，建议使用 3.10 及以上版本 |
 | **tqdm**          | 控制台进度条显示，用于任务执行可视化 |
-| **loguru**        | 高性能日志系统，支持多进程安全输出 |
 | **fastapi**       | Web 服务接口框架（用于任务可视化与远程控制） |
 | **uvicorn**       | FastAPI 的高性能 ASGI 服务器 |
 | **requests**      | HTTP 客户端库，用于任务状态上报与远程调用 |
@@ -256,7 +254,7 @@ 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.1</em>
+  <em>celestial-flow 3.1.3</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
@@ -276,7 +274,7 @@ flowchart TD
 - 6/16/2025: 多轮评测后, 当前框架已支持完整有向图结构, 将TaskTree改名为TaskGraph
 - 3.0.1: 上线Pypi, 可喜可贺
 - 3.0.4: 新增一个抽象结构TaskQueue, 用于表示节点的所有"入边"与"出边"; 恢复未消费任务的保存功能
-- 3.0.5: 删除原有的TaskRedisTransfer节点, 并增添三种新的redis交互节点TaskRedisSink TaskRedisSource TaskRedisAck, 用于跨语言 跨进程 跨设备处理任务; 并在Web页面添加展示拓扑信息的卡片
+- 3.0.5: 删除原有的TaskRedisTransfer节点, 并增添三种新的redis交互节点TaskRedisTransport TaskRedisSource TaskRedisAck, 用于跨语言 跨进程 跨设备处理任务; 并在Web页面添加展示拓扑信息的卡片
 - 3.0.6: 添加对[CelestialTree](https://github.com/Mr-xiaotian/CelestialTree)系统的支持, 现在可以追踪单个任务的流向
 - 3.0.7: 将TaskStage从TaskExecutor中单独抽出来作为一个子类; 增加新节点TaskRouter, 可以将传入的任务选择的传给不同的下游节点, 而不是进行广播
 - 3.0.8: 在ctree逻辑上将"任务重试"事件后的"任务成功/失败/重试"事件视为因果关系, 而非之前的并行关系; 重构错误搜集部分逻辑; 修复大量3.0.6与3.07版本引入的bug; 优化部分log表现
@@ -319,6 +317,15 @@ flowchart TD
   - fix
     - 修复前端renderNodeList中参数设置错误;
     - 修复其他微小bug;
+- 3.1.3
+  - feat:
+    - 抽象出BaseListener与BaseSinker;
+    - 移除loguru, 完全由LogListener和LogSinker实现log记录; 
+    - 将bench相关代码从TaskExecutor和TaskGraph中抽离, 不再作为方法, 而是单独bench函数; 
+    - 重构TaskExecutor部分代码, 以尽量瘦身; 
+    - 优化log处理代码中对时间戳的处理, 现在更加准确;
+  - fix:
+    - 修复一些影响性能的小问题;
 
 ## Star 历史趋势（Star History）
 

{celestialflow-3.1.2 → celestialflow-3.1.3}/README.md

@@ -214,9 +214,8 @@ flowchart TD
 
 | 依赖包           | 说明 |
 | ----------------- | ---- |
-| **Python ≥ 3.8**  | 运行环境，建议使用 3.10 及以上版本 |
+| **Python ≥ 3.10**  | 运行环境，建议使用 3.10 及以上版本 |
 | **tqdm**          | 控制台进度条显示，用于任务执行可视化 |
-| **loguru**        | 高性能日志系统，支持多进程安全输出 |
 | **fastapi**       | Web 服务接口框架（用于任务可视化与远程控制） |
 | **uvicorn**       | FastAPI 的高性能 ASGI 服务器 |
 | **requests**      | HTTP 客户端库，用于任务状态上报与远程调用 |
@@ -230,7 +229,7 @@ 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.1</em>
+  <em>celestial-flow 3.1.3</em>
 </p>
 
 (该视图由我的另一个项目[CelestialVault](https://github.com/Mr-xiaotian/CelestialVault)中inst_file.FileTree.print_tree()生成。转换为图片则借助[Carbon](https://carbon.now.sh)。)
@@ -250,7 +249,7 @@ flowchart TD
 - 6/16/2025: 多轮评测后, 当前框架已支持完整有向图结构, 将TaskTree改名为TaskGraph
 - 3.0.1: 上线Pypi, 可喜可贺
 - 3.0.4: 新增一个抽象结构TaskQueue, 用于表示节点的所有"入边"与"出边"; 恢复未消费任务的保存功能
-- 3.0.5: 删除原有的TaskRedisTransfer节点, 并增添三种新的redis交互节点TaskRedisSink TaskRedisSource TaskRedisAck, 用于跨语言 跨进程 跨设备处理任务; 并在Web页面添加展示拓扑信息的卡片
+- 3.0.5: 删除原有的TaskRedisTransfer节点, 并增添三种新的redis交互节点TaskRedisTransport TaskRedisSource TaskRedisAck, 用于跨语言 跨进程 跨设备处理任务; 并在Web页面添加展示拓扑信息的卡片
 - 3.0.6: 添加对[CelestialTree](https://github.com/Mr-xiaotian/CelestialTree)系统的支持, 现在可以追踪单个任务的流向
 - 3.0.7: 将TaskStage从TaskExecutor中单独抽出来作为一个子类; 增加新节点TaskRouter, 可以将传入的任务选择的传给不同的下游节点, 而不是进行广播
 - 3.0.8: 在ctree逻辑上将"任务重试"事件后的"任务成功/失败/重试"事件视为因果关系, 而非之前的并行关系; 重构错误搜集部分逻辑; 修复大量3.0.6与3.07版本引入的bug; 优化部分log表现
@@ -293,6 +292,15 @@ flowchart TD
   - fix
     - 修复前端renderNodeList中参数设置错误;
     - 修复其他微小bug;
+- 3.1.3
+  - feat:
+    - 抽象出BaseListener与BaseSinker;
+    - 移除loguru, 完全由LogListener和LogSinker实现log记录; 
+    - 将bench相关代码从TaskExecutor和TaskGraph中抽离, 不再作为方法, 而是单独bench函数; 
+    - 重构TaskExecutor部分代码, 以尽量瘦身; 
+    - 优化log处理代码中对时间戳的处理, 现在更加准确;
+  - fix:
+    - 修复一些影响性能的小问题;
 
 ## Star 历史趋势（Star History）
 

{celestialflow-3.1.2 → celestialflow-3.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "celestialflow"                   
-version = "3.1.2"                         
+version = "3.1.3"
 description = "A flexible GRAPH-based task orchestration framework."
 readme = "README.md"               
 license = { text = "MIT" }    
@@ -14,14 +14,13 @@ requires-python = ">=3.10"
 
 dependencies = [
     "tqdm",
-    "loguru",
     "fastapi",
     "uvicorn",
     "requests",
     "networkx",
     "redis",
     "jinja2",
-    "celestialtree",
+    "celestialtree>=0.1.2",
 ]
 
 classifiers = [

{celestialflow-3.1.2 → celestialflow-3.1.3}/src/celestialflow/__init__.py

@@ -3,7 +3,7 @@ from .stage import (
     TaskExecutor,
     TaskStage,
     TaskSplitter,
-    TaskRedisSink,
+    TaskRedisTransport,
     TaskRedisSource,
     TaskRedisAck,
     TaskRouter,
@@ -17,14 +17,15 @@ from .graph import (
     TaskWheel,
     TaskGrid,
 )
-from .runtime.types import TerminationSignal
-from .runtime.hash import make_hashable
-from .utils.format import format_table
 from .persistence.jsonl import (
     load_jsonl_logs,
     load_task_by_stage,
     load_task_by_error,
 )
+from .runtime.types import TerminationSignal
+from .runtime.hash import make_hashable
+from .utils.format import format_table
+from .utils.benchmark import benchmark_graph, benchmark_executor
 from .web.server import TaskWebServer
 
 __all__ = [
@@ -38,7 +39,7 @@ __all__ = [
     "TaskExecutor",
     "TaskStage",
     "TaskSplitter",
-    "TaskRedisSink",
+    "TaskRedisTransport",
     "TaskRedisSource",
     "TaskRedisAck",
     "TaskRouter",
@@ -49,4 +50,6 @@ __all__ = [
     "load_task_by_error",
     "make_hashable",
     "format_table",
+    "benchmark_graph",
+    "benchmark_executor",
 ]

{celestialflow-3.1.2 → celestialflow-3.1.3}/src/celestialflow/graph/analysis.py

@@ -15,11 +15,11 @@ def format_networkx_graph(structure_graph: List[Dict[str, Any]]) -> nx.DiGraph:
     G = nx.DiGraph()
 
     def add_node_and_edges(node: Dict[str, Any]):
-        node_id = f'{node["stage_name"]}[{node["func_name"]}]'
+        node_id = f'{node["name"]}[{node["func_name"]}]'
         G.add_node(node_id, **{"mode": node.get("stage_mode")})
 
         for child in node.get("next_stages", []):
-            child_id = f'{child["stage_name"]}[{child["func_name"]}]'
+            child_id = f'{child["name"]}[{child["func_name"]}]'
             G.add_edge(node_id, child_id)
             # 递归添加子节点
             add_node_and_edges(child)

{celestialflow-3.1.2 → celestialflow-3.1.3}/src/celestialflow/graph/graph.py

@@ -4,7 +4,7 @@ import warnings
 import multiprocessing
 from collections import defaultdict, deque
 from multiprocessing import Queue as MPQueue
-from typing import Any, Dict, List
+from typing import Dict, List
 
 from celestialtree import (
     Client as CelestialTreeClient,
@@ -13,7 +13,7 @@ from celestialtree import (
     format_provenance_forest,
 )
 
-from ..runtime import TaskQueue
+from ..runtime import TaskQueue, TaskEnvelope
 from ..runtime.estimators import (
     calc_elapsed,
     calc_remaining,
@@ -21,7 +21,6 @@ from ..runtime.estimators import (
 )
 from ..runtime.errors import UnconsumedError
 from ..runtime.types import (
-    TaskEnvelope,
     StageStatus,
     TerminationSignal,
     STAGE_STYLE,
@@ -228,6 +227,9 @@ class TaskGraph:
         :param host: 报告器主机地址
         :param port: 报告器端口
         """
+        self._is_report = is_report
+        self._report_host = host
+        self._report_port = port
         if is_report:
             self.reporter = TaskReporter(
                 host=host,
@@ -239,7 +241,12 @@ class TaskGraph:
             self.reporter = NullTaskReporter()
 
     def set_ctree(
-        self, use_ctree=False, host="127.0.0.1", http_port=7777, grpc_port=7778
+        self,
+        use_ctree=False,
+        host="127.0.0.1",
+        http_port=7777,
+        grpc_port=7778,
+        transport="grpc",
     ):
         """
         设定事件树客户端
@@ -252,10 +259,11 @@ class TaskGraph:
         self._ctree_host = host
         self._CTREE_HTTP_PORT = http_port
         self._ctree_grpc_port = grpc_port
+        self._ctree_transport = transport
 
         if use_ctree:
             self.ctree_client = CelestialTreeClient(
-                host=host, http_port=http_port, grpc_port=grpc_port, transport="grpc"
+                host=host, http_port=http_port, grpc_port=grpc_port, transport=transport
             )
             if not self.ctree_client.health():
                 raise Exception("CelestialTreeClient is not available")
@@ -362,7 +370,7 @@ class TaskGraph:
             )
 
         try:
-            start_time = time.time()
+            start_time = time.perf_counter()
             self.fail_listener.start()
             self.log_listener.start()
             self.log_sinker.start_graph(self.get_structure_list())
@@ -377,7 +385,7 @@ class TaskGraph:
 
             self.reporter.stop()
             self.release_resources()
-            self.log_sinker.end_graph(time.time() - start_time)
+            self.log_sinker.end_graph(time.perf_counter() - start_time)
             self.fail_listener.stop()
             self.log_listener.stop()
 
@@ -393,11 +401,11 @@ class TaskGraph:
             for p in self.processes:
                 p.join()
                 self.log_sinker.process_exit(p.name, p.exitcode)
-        else:
+        elif self.schedule_mode == "staged":
             # staged schedule_mode：一层层地顺序执行
             for layer_level, layer in self.layers_dict.items():
                 self.log_sinker.start_layer(layer, layer_level)
-                start_time = time.time()
+                start_time = time.perf_counter()
 
                 processes = []
                 for stage_tag in layer:
@@ -411,7 +419,7 @@ class TaskGraph:
                     p.join()
                     self.log_sinker.process_exit(p.name, p.exitcode)
 
-                self.log_sinker.end_layer(layer, time.time() - start_time)
+                self.log_sinker.end_layer(layer, time.perf_counter() - start_time)
 
     def _execute_stage(self, stage: TaskStage):
         """
@@ -603,9 +611,11 @@ class TaskGraph:
         if not self.isDAG:
             totals["total_remain"] = max(running_remaining_map.values(), default=0.0)
         else:
-            G = self.get_networkx_graph()
             expected_pending_map = calc_global_remain_equal_pred(
-                G, running_processed_map, running_pending_map, running_elapsed_map
+                self.networkx_graph,
+                running_processed_map,
+                running_pending_map,
+                running_elapsed_map,
             )
             totals["total_remain"] = max(expected_pending_map.values(), default=0.0)
 
@@ -613,10 +623,10 @@ class TaskGraph:
         self.graph_summary = dict(totals)
 
     def get_fail_by_stage_dict(self):
-        return load_task_by_stage(self.fail_listener.fallback_path)
+        return load_task_by_stage(self.fail_listener.jsonl_path)
 
     def get_fail_by_error_dict(self):
-        return load_task_by_error(self.fail_listener.fallback_path)
+        return load_task_by_error(self.fail_listener.jsonl_path)
 
     def get_status_dict(self) -> Dict[str, dict]:
         """
@@ -647,6 +657,9 @@ class TaskGraph:
         return format_structure_list_from_graph(self.structure_json)
 
     def get_networkx_graph(self):
+        """
+        获取任务图的 networkx 有向图（DiGraph）
+        """
         return format_networkx_graph(self.structure_json)
 
     def get_fallback_path(self) -> str:
@@ -668,55 +681,10 @@ class TaskGraph:
         """
         分析任务图，计算 DAG 属性和层级信息
         """
-        networkx_graph = self.get_networkx_graph()
+        self.networkx_graph = self.get_networkx_graph()
         self.layers_dict = {}
 
-        self.isDAG = is_directed_acyclic_graph(networkx_graph)
+        self.isDAG = is_directed_acyclic_graph(self.networkx_graph)
         if self.isDAG:
-            stage_level_dict = compute_node_levels(networkx_graph)
+            stage_level_dict = compute_node_levels(self.networkx_graph)
             self.layers_dict = cluster_by_value_sorted(stage_level_dict)
-
-    def test_methods(
-        self,
-        init_tasks_dict: Dict[str, List],
-        stage_modes: list = None,
-        execution_modes: list = None,
-    ) -> Dict[str, Any]:
-        """
-        测试 TaskGraph 在 'serial' 和 'process' 模式下的执行时间。
-
-        :param init_tasks_dict: 初始化任务字典
-        :param stage_modes: 阶段模式列表，默认为 ['serial', 'process']
-        :param execution_modes: 执行模式列表，默认为 ['serial', 'thread']
-        :return: 包含两种执行模式下的执行时间的字典
-        """
-        results = {}
-        test_table_list = []
-        fail_by_error_dict = {}
-        fail_by_stage_dict = {}
-
-        stage_modes = stage_modes or ["serial", "process"]
-        execution_modes = execution_modes or ["serial", "thread"]
-        for stage_mode in stage_modes:
-            time_list = []
-            for execution_mode in execution_modes:
-                start_time = time.time()
-                self.init_env()
-                self.set_graph_mode(stage_mode, execution_mode)
-                self.start_graph(init_tasks_dict)
-                fail_by_stage_dict.update(self.get_fail_by_stage_dict())
-                fail_by_error_dict.update(self.get_fail_by_error_dict())
-
-                time_list.append(time.time() - start_time)
-
-            test_table_list.append(time_list)
-
-        results["Time table"] = (
-            test_table_list,
-            stage_modes,
-            execution_modes,
-            r"stage\execution",
-        )
-        results["Fail stage dict"] = fail_by_stage_dict
-        results["Fail error dict"] = fail_by_error_dict
-        return results

{celestialflow-3.1.2 → celestialflow-3.1.3}/src/celestialflow/graph/serialize.py

@@ -59,7 +59,7 @@ def format_structure_list_from_graph(root_roots: List[Dict] = None) -> List[str]
 
     def node_label(node: Dict) -> str:
         visited_note = " [Ref]" if node.get("is_ref") else ""
-        N = node.get("actor_name", "?")  # N
+        N = node.get("name", "?")  # N
         F = node.get("func_name", "?")  # F
         S = node.get("stage_mode", "?")  # S
         E = node.get("execution_mode", "?")  # E

{celestialflow-3.1.2 → celestialflow-3.1.3}/src/celestialflow/persistence/__init__.py

@@ -1,8 +1,11 @@
 # persistence/__init__.py
+from .base import BaseListener, BaseSinker
 from .fail import FailListener, FailSinker
 from .log import LogListener, LogSinker
 
 __all__ = [
+    "BaseListener",
+    "BaseSinker",
     "FailListener",
     "FailSinker",
     "LogListener",

celestialflow-3.1.3/src/celestialflow/persistence/base.py

@@ -0,0 +1,61 @@
+# persistence/base.py
+from __future__ import annotations
+
+from multiprocessing import Queue as MPQueue
+from queue import Empty
+from threading import Thread
+
+from ..runtime.tools import cleanup_mpqueue
+from ..runtime.types import TerminationSignal, TERMINATION_SIGNAL
+
+
+class BaseListener:
+    def __init__(self):
+        self.queue = MPQueue()
+        self._thread: Thread | None = None
+
+    def _before_start(self):
+        return None
+
+    def _handle_record(self, record):
+        raise NotImplementedError
+
+    def _after_stop(self):
+        return None
+
+    def start(self):
+        self._before_start()
+        if self._thread is None or not self._thread.is_alive():
+            self._thread = Thread(target=self._listen, daemon=True)
+            self._thread.start()
+
+    def _listen(self):
+        while True:
+            try:
+                record = self.queue.get(timeout=0.5)
+                if isinstance(record, TerminationSignal):
+                    break
+                self._handle_record(record)
+            except Empty:
+                continue
+
+    def get_queue(self):
+        return self.queue
+
+    def stop(self):
+        if self._thread is None:
+            return
+
+        self.queue.put(TERMINATION_SIGNAL)
+        self._thread.join()
+        self._thread = None
+        cleanup_mpqueue(self.queue)
+        self._after_stop()
+
+
+class BaseSinker:
+    def __init__(self, queue):
+        self.queue: MPQueue = queue
+
+    def _sink(self, record):
+        self.queue.put(record)

{celestialflow-3.1.2 → celestialflow-3.1.3}/src/celestialflow/persistence/fail.py

@@ -1,77 +1,63 @@
 # persistence/fail.py
-import os
+import json
+from pathlib import Path
 from datetime import datetime
-from multiprocessing import Queue as MPQueue
-from queue import Empty
-from threading import Lock, Thread
 
-from ..runtime.tools import cleanup_mpqueue
-from ..runtime.types import TerminationSignal, TERMINATION_SIGNAL
 from ..utils.format import format_repr
-from .jsonl import append_jsonl_log
+from .base import BaseListener, BaseSinker
 
 
-class FailListener:
+class FailListener(BaseListener):
     def __init__(self, error_source: str):
+        super().__init__()
+
         self.error_source = error_source
-        self.fail_queue = MPQueue()
-        self._thread = None
-        self.fallback_path = ""
+        self.fail_queue = self.queue
+        self.jsonl_path: Path | None = None
+
         self.total_error_num = 0
-        self._counter_lock = Lock()
+        self._file = None
 
-    def start(self):
+    def _before_start(self):
+        # 创建 fallback 目录
         now = datetime.now()
         date_str = now.strftime("%Y-%m-%d")
         time_str = now.strftime("%H-%M-%S-%f")[:-3]
-        self.fallback_path = (
+        self.jsonl_path = Path(
             f"./fallback/{date_str}/{self.error_source}({time_str}).jsonl"
         )
-        self.total_error_num = 0
+        self.jsonl_path.parent.mkdir(parents=True, exist_ok=True)
 
-        if self._thread is None or not self._thread.is_alive():
-            self._thread = Thread(target=self._listen, daemon=True)
-            self._thread.start()
+        # 打开失败记录文件
+        self._file = self.jsonl_path.open("a", encoding="utf-8")
 
-    def _listen(self):
-        while True:
-            try:
-                record = self.fail_queue.get(timeout=0.5)
-                if isinstance(record, TerminationSignal):
-                    break
-                append_jsonl_log(record, self.fallback_path)
-                if isinstance(record, dict) and record.get("error_id") is not None:
-                    with self._counter_lock:
-                        self.total_error_num += 1
-            except Empty:
-                continue
+        # 初始化错误计数器
+        self.total_error_num = 0
 
-    def get_queue(self):
-        return self.fail_queue
+    def _handle_record(self, record):
+        jsonl_record = json.dumps(record, ensure_ascii=False)
 
-    def get_fallback_path(self) -> str:
-        return os.path.abspath(self.fallback_path)
+        self._file.write(f"{jsonl_record}\n")
+        self._file.flush()
 
-    def stop(self):
-        if self._thread is None:
-            return
+        if isinstance(record, dict) and record.get("error_id") is not None:
+            self.total_error_num += 1
 
-        self.fail_queue.put(TERMINATION_SIGNAL)
-        self._thread.join()
-        self._thread = None
-        cleanup_mpqueue(self.fail_queue)
+    def _after_stop(self):
+        if self._file:
+            self._file.flush()
+            self._file.close()
+            self._file = None
 
 
-class FailSinker:
+class FailSinker(BaseSinker):
     """
     多进程安全失败记录包装类，所有失败记录通过队列发送到监听进程写入
     """
 
     def __init__(self, fail_queue):
-        self.fail_queue: MPQueue = fail_queue
-
-    def _sink(self, record: dict):
-        self.fail_queue.put(record)
+        super().__init__(fail_queue)
+        self.fail_queue = self.queue
 
     def start_graph(self, structure_json):
         """

{celestialflow-3.1.2 → celestialflow-3.1.3}/src/celestialflow/persistence/jsonl.py

@@ -1,57 +1,10 @@
 # persistence/jsonl.py
 import json
 import ast
-from pathlib import Path
-from collections.abc import Iterable
 from collections import defaultdict
 from typing import Dict, Any, List, Optional
 
-
 # ======== jsonl文件处理 ========
-def append_jsonl_log(log_data: dict, file_path: str, logger=None):
-    """
-    将日志字典写入指定目录下的 JSONL 文件。
-
-    :param log_data: 要写入的日志项（字典）
-    :param start_time: 运行开始时间，用于构造路径
-    :param base_path: 基础路径，例如 './fallback'
-    :param prefix: 文件名前缀，例如 'realtime_errors'
-    :param logger: 可选的日志对象用于记录失败信息
-    """
-    try:
-        file_path: Path = Path(file_path)
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(file_path, "a", encoding="utf-8") as f:
-            f.write(json.dumps(log_data, ensure_ascii=False) + "\n")
-    except Exception as e:
-        if logger:
-            logger._log("WARNING", f"[Persist] 写入日志失败: {e}")
-
-
-def append_jsonl_logs(log_items: Iterable[dict], file_path: str, logger=None):
-    """
-    将多条日志一次性写入 JSONL 文件（batch 追加）。
-
-    :param log_items: Iterable[dict]，每个元素写成一行 JSON
-    :param file_path: JSONL 文件路径
-    :param logger: 可选日志对象
-    """
-    try:
-        if not isinstance(log_items, Iterable):
-            raise TypeError("log_items must be an iterable of dict")
-
-        file_path: Path = Path(file_path)
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(file_path, "a", encoding="utf-8") as f:
-            for item in log_items:
-                if not isinstance(item, dict):
-                    raise TypeError(f"each log item must be dict, got {type(item)}")
-                f.write(json.dumps(item, ensure_ascii=False) + "\n")
-    except Exception as e:
-        if logger:
-            logger._log("WARNING", f"[Persist] 批量写入日志失败: {e}")
 
 
 def load_jsonl_logs(