pyxllib 0.3.143__tar.gz → 0.3.147__tar.gz

{pyxllib-0.3.143/pyxllib.egg-info → pyxllib-0.3.147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyxllib
-Version: 0.3.143
+Version: 0.3.147
 Summary: 厦门理工模式识别团队通用python代码工具库
 Home-page: https://github.com/XLPRUtils/pyxllib
 Author: code4101
@@ -38,33 +38,33 @@ Requires-Dist: Jinja2
 Requires-Dist: pandas>=0.23.4
 Requires-Dist: pillow
 Provides-Extra: xlcv
-Requires-Dist: opencv-python; extra == "xlcv"
-Requires-Dist: pillow; extra == "xlcv"
 Requires-Dist: opsdroid-get-image-size; extra == "xlcv"
+Requires-Dist: pillow; extra == "xlcv"
+Requires-Dist: opencv-python; extra == "xlcv"
 Provides-Extra: xlai
-Requires-Dist: opsdroid-get-image-size; extra == "xlai"
-Requires-Dist: opencv-python; extra == "xlai"
-Requires-Dist: pillow; extra == "xlai"
 Requires-Dist: pynvml; extra == "xlai"
 Requires-Dist: visdom; extra == "xlai"
+Requires-Dist: pillow; extra == "xlai"
+Requires-Dist: opsdroid-get-image-size; extra == "xlai"
+Requires-Dist: opencv-python; extra == "xlai"
 Provides-Extra: xlall
-Requires-Dist: flask-cors; extra == "xlall"
-Requires-Dist: fastapi; extra == "xlall"
-Requires-Dist: flask-jwt-extended; extra == "xlall"
 Requires-Dist: ujson; extra == "xlall"
+Requires-Dist: flask; extra == "xlall"
+Requires-Dist: html2text; extra == "xlall"
 Requires-Dist: zhconv; extra == "xlall"
-Requires-Dist: opsdroid-get-image-size; extra == "xlall"
-Requires-Dist: openai2; extra == "xlall"
-Requires-Dist: opencv-python; extra == "xlall"
 Requires-Dist: arts; extra == "xlall"
-Requires-Dist: pillow; extra == "xlall"
-Requires-Dist: html2text; extra == "xlall"
-Requires-Dist: sentencepiece; extra == "xlall"
+Requires-Dist: xlrd; extra == "xlall"
+Requires-Dist: flask-cors; extra == "xlall"
 Requires-Dist: flask-restful; extra == "xlall"
 Requires-Dist: flask-wtf; extra == "xlall"
+Requires-Dist: fastapi; extra == "xlall"
+Requires-Dist: pillow; extra == "xlall"
+Requires-Dist: sentencepiece; extra == "xlall"
 Requires-Dist: uvicorn; extra == "xlall"
-Requires-Dist: xlrd; extra == "xlall"
-Requires-Dist: flask; extra == "xlall"
+Requires-Dist: flask-jwt-extended; extra == "xlall"
+Requires-Dist: opsdroid-get-image-size; extra == "xlall"
+Requires-Dist: openai2; extra == "xlall"
+Requires-Dist: opencv-python; extra == "xlall"
 
 # 1 install
 

{pyxllib-0.3.143 → pyxllib-0.3.147}/pyxllib/autogui/uiautolib.py

@@ -9,13 +9,16 @@
 """
 
 import os
+import sys
 import textwrap
 import time
 from typing import Iterable, Callable, List
+import subprocess
 
 import psutil
 import pandas as pd
 
+from loguru import logger
 # ui组件大多是树形组织结构，auto库自带树形操作太弱。没有专业的树形结构库，能搞个毛线。
 from anytree import NodeMixin
 
@@ -236,22 +239,32 @@ class UiCtrlNode(NodeMixin):
         ctrl = find_ctrl(class_name=class_name, name=name, **kwargs)
         return cls(ctrl, build_depth=build_depth)
 
-    def activate(self):
+    def activate(self, check_seconds=2):
         """ 激活当前窗口
-
-        todo 修改的更稳定些？多些判断，重复测试，等待？
         """
-        if hwnd := win32gui.FindWindow(self.ctrl.ClassName, self.text):
-            # 恢复窗口
-            win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
-            # 检查窗口是否已在前
+        while True:
+            hwnd = win32gui.FindWindow(self.ctrl.ClassName, self.text)
+            # logger.info(hwnd)
+            if not hwnd:
+                return
+
             if win32gui.GetForegroundWindow() != hwnd:
-                # 尝试将窗口置前
+                win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
+
                 try:
-                    win32gui.SetForegroundWindow(hwnd)
+                    # 在这里执行SetForegroundWindow，只有程序的第1次运行有效，之后就会被很多全屏类的应用占用最前置，覆盖不了了
+                    # 为了解决这问题，就只能暴力每次都新开一个程序来执行这个SetForegroundWindow操作
+                    subprocess.run(
+                        [sys.executable, "-c", f"import win32gui; win32gui.SetForegroundWindow({hwnd})"],
+                        stdout=subprocess.PIPE,
+                    )
                 except Exception as e:
                     pass
-                    # print(f"尝试将窗口置前时出错: {e}")
+                # 理论上并不需要等待，但加个等待，有助于稳定性检测，如果当前窗口在check_seconds秒内频繁切换，
+                #   使用activate虽然激活了，但并不安全，只有check_seconds秒内维持稳定在这个窗口，再进行下游任务会更好
+                time.sleep(check_seconds)
+            else:
+                break
 
     def build_children(self, build_depth=-1, child_node_class=None):
         """ 创建并添加子节点到树中 """

{pyxllib-0.3.143 → pyxllib-0.3.147}/pyxllib/autogui/wechat.py

@@ -41,7 +41,7 @@ class WeChatConfig:
     WINDOW_CLASSNAME = 'WeChatMainWndForPC'
 
 
-WeChat = WeChatConfig
+# WeChat = WeChatConfig
 
 
 class IntervalConfig:
@@ -496,8 +496,8 @@ class WxOperation:
 
     def locate_wechat_window(self):
         if not self.visible_flag:
-            wake_up_window(class_name=WeChat.WINDOW_CLASSNAME, name=WeChat.WINDOW_NAME)
-            self.wx_window = auto.WindowControl(Name=WeChat.WINDOW_NAME, ClassName=WeChat.WINDOW_CLASSNAME)
+            wake_up_window(class_name=WeChatConfig.WINDOW_CLASSNAME, name=WeChatConfig.WINDOW_NAME)
+            self.wx_window = auto.WindowControl(Name=WeChatConfig.WINDOW_NAME, ClassName=WeChatConfig.WINDOW_CLASSNAME)
             if not self.wx_window.Exists(Interval.MAX_SEARCH_SECOND,
                                          searchIntervalSeconds=Interval.MAX_SEARCH_INTERVAL):
                 raise Exception('微信似乎并没有登录!')

pyxllib-0.3.147/pyxllib/prog/filelock.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2024/11/13
+
+import os
+import time
+import platform
+import tempfile
+
+if platform.system() == 'Windows':
+    import msvcrt
+else:
+    import fcntl
+
+
+class FileLock:
+    """
+    文件锁类，用于在不同进程之间实现互斥锁，确保同一时间只有一个程序实例可以访问共享资源。
+
+    适用于以下场景：
+    - 防止多个独立程序同时操作同一资源（如文件、窗口、数据库等）。
+    - 解决多个自动化脚本并发访问相同应用程序时的冲突问题。
+    - 跨平台支持：在 Windows 上使用 `msvcrt`，在 Unix 系统上使用 `fcntl`。
+
+    使用方式：
+    1. 作为上下文管理器：
+        >> with FileLock('wechat.lock'):
+        >>     # 执行独占的操作
+        >>     print("操作微信...")
+
+    2. 手动调用 acquire() 和 release()：
+        >> lock = FileLock('wechat.lock')
+        >> try:
+        >>     lock.acquire()
+        >>     print("正在执行任务...")
+        >> finally:
+        >>     lock.release()
+
+    属性：
+    :param bool locked: 指示当前是否已获得文件锁。
+
+    异常：
+    - TimeoutError: 如果在指定的超时时间内无法获取锁，则抛出此异常。
+    """
+
+    def __init__(self, lock_file='lockfile.lock', timeout=10, check_interval=0.1):
+        """
+
+        :param str lock_file: 锁文件的路径，默认值为 'lockfile.lock'。
+        :param int timeout: 获取锁的超时时间，单位为秒，默认值为 10 秒。
+        :param float check_interval: 重试获取锁的时间间隔，单位为秒，默认值为 0.1 秒。
+        """
+        # 如果 lock_file 没有提供绝对路径，则将其存储在临时目录下
+        if not os.path.isabs(lock_file):
+            lock_file = os.path.join(tempfile.gettempdir(), lock_file)
+
+        self.lock_file = lock_file
+        self.timeout = timeout
+        self.check_interval = check_interval
+        self.locked = False
+        self.file = None
+
+    def acquire(self):
+        """
+        手动获取文件锁。
+
+        如果文件已被其他进程锁定，则会阻塞，直到成功获取锁或者超时。
+        如果在指定的超时时间内无法获取锁，则抛出 TimeoutError。
+
+        Raises:
+            TimeoutError: 如果在指定的超时时间内无法获取锁。
+        """
+        start_time = time.time()
+        while True:
+            try:
+                self.file = open(self.lock_file, 'w')
+                if platform.system() == 'Windows':
+                    # Windows 系统使用 msvcrt.locking() 实现文件锁
+                    msvcrt.locking(self.file.fileno(), msvcrt.LK_NBLCK, 1)
+                else:
+                    # Unix 系统使用 fcntl.flock() 实现文件锁
+                    fcntl.flock(self.file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                self.locked = True
+                break
+            except (BlockingIOError, OSError):
+                if time.time() - start_time > self.timeout:
+                    raise TimeoutError(f"无法在 {self.timeout} 秒内获取文件锁：{self.lock_file}")
+                time.sleep(self.check_interval)
+
+    def release(self):
+        """
+        手动释放文件锁。
+
+        如果锁已被获取，则解锁并关闭文件句柄。
+        """
+        if self.locked and self.file:
+            if platform.system() == 'Windows':
+                # Windows 系统释放锁
+                msvcrt.locking(self.file.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                # Unix 系统释放锁
+                fcntl.flock(self.file, fcntl.LOCK_UN)
+            self.file.close()
+            self.locked = False
+
+    def __enter__(self):
+        """
+        进入上下文管理器时自动获取文件锁。
+
+        Returns:
+            self: 返回当前 FileLock 实例。
+        """
+        self.acquire()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        退出上下文管理器时自动释放文件锁。
+        """
+        self.release()
+
+
+# 示例：如何使用 FileLock 类
+if __name__ == '__main__':
+    # 使用上下文管理器
+    with FileLock('wechat.lock') as lock:
+        print("通过上下文管理器获取锁，正在操作微信...")
+        time.sleep(3)
+        print("操作完成")
+
+    # 手动调用 acquire 和 release
+    lock = FileLock('wechat.lock')
+    try:
+        lock.acquire()
+        print("手动获取锁，正在执行任务...")
+        time.sleep(3)
+    finally:
+        lock.release()
+        print("任务完成并已释放锁")

{pyxllib-0.3.143 → pyxllib-0.3.147}/pyxllib/prog/multiprogs.py

@@ -4,6 +4,7 @@
 # @Email  : 877362867@qq.com
 # @Date   : 2024/11/12
 
+from collections import defaultdict
 from types import SimpleNamespace
 from unittest.mock import Mock
 import ctypes
@@ -13,13 +14,20 @@ import socketserver
 import subprocess
 import sys
 import time
-import re
+import textwrap
+import threading
 
 from deprecated import deprecated
 from loguru import logger
 from croniter import croniter
+import pandas as pd
+
+from fastapi import FastAPI
+from fastapi.responses import PlainTextResponse
 
 from pyxllib.prog.specialist import parse_datetime
+from pyxllib.algo.stat import print_full_dataframe
+from pyxllib.file.specialist import XlPath
 
 
 def __1_定时工具():
@@ -202,10 +210,18 @@ class ProgramWorker(SimpleNamespace):
             proc.pid = None
             proc.poll.return_value = 'tag'
             self.program = proc
-        elif sys.platform == 'win32':
-            self.program = subprocess.Popen(self.cmd, shell=self.shell)
+            return self.program
+
+        kwargs = {}
+        for name in ['stdin', 'stdout', 'stderr']:
+            if hasattr(self, name):
+                kwargs[name] = getattr(self, name)
+
+        if sys.platform == 'win32':
+            self.program = subprocess.Popen(self.cmd, shell=self.shell, **kwargs)
         else:
-            self.program = subprocess.Popen(self.cmd, shell=self.shell, preexec_fn=self._set_pdeathsig())
+            self.program = subprocess.Popen(self.cmd, shell=self.shell, **kwargs,
+                                            preexec_fn=self._set_pdeathsig())
 
         return self.program
 
@@ -249,6 +265,7 @@ class MultiProgramLauncher:
 
     def init_scheduler(self):
         from apscheduler.schedulers.background import BackgroundScheduler
+        # from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
         if self.scheduler is None:
             self.scheduler = BackgroundScheduler()
@@ -320,9 +337,9 @@ class MultiProgramLauncher:
         elif isinstance(schedule, str):
             from apscheduler.triggers.cron import CronTrigger
             cron_parts = schedule.split()
-            # 如果是 5 个字段，则补齐 "秒" 字段为 '*'
+            # 如果是 5 个字段，则补齐 "秒" 字段为 '0'
             if len(cron_parts) == 5:
-                cron_parts.insert(0, '*')
+                cron_parts.insert(0, '0')
             # 检查是否为有效的 6 字段 cron 表达式
             if len(cron_parts) == 6:
                 # 统一处理为 6 字段格式
@@ -389,9 +406,6 @@ class MultiProgramLauncher:
 
         return worker
 
-    def __2_各种添加进程的机制(self):
-        pass
-
     def add_program_cmd2(self, cmd, ports=1, name=None, **kwargs):
         """
         增强版 add_program_cmd，支持 ports 的处理
@@ -452,6 +466,9 @@ class MultiProgramLauncher:
 
         return workers
 
+    def __2_各种添加进程的机制(self):
+        pass
+
     def add_program_python(self, py_file, args='',
                            ports=None, locations=None,
                            name=None, shell=False, executer=None,
@@ -487,11 +504,152 @@ class MultiProgramLauncher:
             cmd.append(args)
         else:
             cmd += list(args)
+        if name is None:
+            name = module
         return self.add_program_cmd3(cmd, ports=ports, name=name, locations=locations, shell=shell, **kwargs)
 
-    def __3_多程序管理(self):
+    def add_prog(self, prog, extcmds='',
+                 ports=None, locations=None, *,
+                 name=None, devices=None,
+                 executer=None,
+                 run=True,
+                 schedule=None,
+                 ):
+        """
+        :param int|list ports:
+        :param str|list extcmds:
+        """
+        if locations is None:
+            locations = f'/api/{prog.split('.')[-1]}'
+        self.add_program_python_module(prog,
+                                       extcmds,
+                                       ports=ports, locations=locations,
+                                       name=name, devices=devices,
+                                       executer=executer,
+                                       run=run,
+                                       schedule=schedule,
+                                       )
+
+    def add_server(self, prog, ports=None, locations=None, *args, **kwargs):
+        """ 我自己部署的服务，基本都有特定的start_server启动函数 """
+        self.add_prog(prog, extcmds='start_server', ports=ports, locations=locations, *args, **kwargs)
+
+    def add_os_command_task(self,
+                            script_content,
+                            extension=None,
+                            shell=False,
+                            run=True,
+                            name=None,
+                            schedule=None,
+                            **kwargs):
+        """
+        添加一个操作系统命令或脚本（如 .bat、.sh、.ps1 等）并启动。
+
+        :param script_content: 脚本的内容（字符串）
+        :param extension: 脚本文件的扩展名（如 .bat, .sh, .ps1）；如果为 None 则根据操作系统自动选择
+        :param shell: 是否使用 shell 执行
+        :param run: 是否立即启动
+        :param name: 程序名称
+        :param schedule: 定时任务配置
+        """
+        # 1 自动选择脚本文件扩展名
+        if extension is None:
+            if sys.platform == 'win32':
+                extension = '.ps1'  # Windows 默认使用 PowerShell
+            else:
+                extension = '.sh'  # Linux 和 macOS 默认使用 Bash
+
+        # 2 添加编码配置到脚本内容
+        if extension == '.bat':
+            # 为 .bat 文件添加 UTF-8 支持
+            script_content = f"chcp 65001 >nul\n{script_content}"
+        elif extension == '.ps1':
+            # 为 .ps1 文件添加 UTF-8 支持
+            script_content = f"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8\n" \
+                             f"[Console]::InputEncoding = [System.Text.Encoding]::UTF8\n{script_content}"
+
+        # 3 创建临时脚本文件
+        script_file = XlPath.create_tempfile_path(extension)
+        script_file.write_text(script_content)
+
+        # 4 根据文件扩展名和操作系统选择执行命令
+        if extension == '.sh':
+            cmd = ['bash', str(script_file)]
+        elif extension == '.ps1':
+            if sys.platform == 'win32':
+                cmd = ['powershell', '-ExecutionPolicy', 'Bypass', '-File', str(script_file)]
+            else:
+                raise ValueError("PowerShell 脚本仅在 Windows 系统上受支持")
+        elif extension == '.bat':
+            cmd = [str(script_file)]  # 直接运行 .bat 文件
+        else:
+            raise ValueError(f"不支持的脚本类型: {extension}")
+
+        # 5 使用 add_program_cmd3 启动脚本
+        return self.add_program_cmd3(
+            cmd=cmd,
+            name=name or f"command_{script_file.stem}",
+            shell=shell,
+            run=run,
+            schedule=schedule,
+            **kwargs
+        )
+
+    def __3_nginx相关(self):
+        pass
+
+    def get_all_locations(self):
+        locations = defaultdict(list)
+        for worker in self.workers:
+            if not worker.locations:
+                continue
+            for x in worker.locations:
+                for dst, src in x.items():
+                    locations[dst].append(f'localhost:{worker.port}{src}')
+        return locations
+
+    def configure_nginx(self, nginx_template, locations=None):
+        if locations is None:
+            locations = self.get_all_locations()
+
+        upstreams = []  # 外部的配置
+        servers = [nginx_template.rstrip()]  # 内部的配置
+
+        for dst, srcs in locations.items():
+            if len(srcs) == 1:  # 只有1个不开负载
+                server = f'location {dst} {{\n\tproxy_pass http://{srcs[0]};\n}}\n'
+            else:  # 有多个端口功能则开负载
+                hosts = '\n'.join([f'\tserver {src.split("/")[0]};' for src in srcs])
+                upstream_name = 'upstream' + str(len(upstreams) + 1)
+                upstreams.append(f'upstream {upstream_name} {{\n{hosts}\n}}\n')
+                sub_urls = [src.split('/', maxsplit=1)[1] for src in srcs]
+                assert len(set(sub_urls)) == 1, f'负载均衡的子url必须一致 {sub_urls}'
+                server = f'location {dst} {{\n\tproxy_pass http://{upstream_name}/{sub_urls[0]};\n}}\n'
+            servers.append(server)
+
+        content = '\n'.join(upstreams) + '\nserver {\n' + textwrap.indent('\n'.join(servers), '\t') + '}'
+        return content
+
+    def __4_多程序管理(self):
         pass
 
+    def count_running(self):
+        return sum(1 for worker in self.workers if worker.is_running())
+
+    def list_workers(self):
+        """返回所有任务的状态 DataFrame"""
+        ls = []
+        for worker in self.workers:
+            ls.append({
+                'name': worker.name,
+                'pid': worker.program.pid if worker.program else None,
+                'poll': worker.program.poll() if worker.program else None,
+                'args': worker.raw_cmd,
+                'port': worker.port,
+                'locations': worker.locations,
+            })
+        return pd.DataFrame(ls)
+
     def cleanup_finished(self, exit_code=None):
         """
         清除已运行完的程序
@@ -522,47 +680,51 @@ class MultiProgramLauncher:
             worker.terminate()
         self.workers = []
 
-    def run_endless(self):
+    def proc_cmd(self, cmd):
+        if cmd == 'kill':
+            self.stop_all()
+            return False
+        elif cmd == 'count':
+            print(f'有{self.count_running()}个程序正在运行')
+        elif cmd.startswith('cleanup'):
+            args = cmd.split()
+            exit_code = int(args[1]) if len(args) > 1 else None
+            self.cleanup_finished(exit_code)
+            print("清理完成")
+        elif cmd == 'list':  # 列出所有程序（转df查看）
+            df = self.list_workers()
+            print_full_dataframe(df)
+        return True
+
+    def run_endless(self, cmd=True, wait_seconds=1, *, port=None):
         """
         一直运行，直到用户输入 kill 命令或 Ctrl+C
 
-		poll：
+        :param bool cmd: 是否支持命令行input输入指令监控状态的模式
+            默认支持，但在有scheduler调度的情况不建议开启，有input阻塞其他子程的风险
+        :param int|float wait_seconds: 每次循环之间停顿秒数，用来给其他子程等运行时间，避免阻塞
+        :param int port: 是否要开一个后端服务，支持查询程序运行状态
+
+    	poll：
             如果进程仍在运行，poll()方法返回None。
             如果进程已经结束，poll()方法返回进程的退出码（exit code）。
                 如果进程正常结束，退出码通常为0。
                 如果进程异常结束，退出码通常是一个非零值，表示异常的类型或错误码。
-		"""
-        import pandas as pd
-        from pyxllib.algo.stat import print_full_dataframe
-
+    	"""
         if self.scheduler:  # 如果有定时任务，启动调度器
             self.scheduler.start()
 
+        if port:
+            dashboard = LauncherDashboard(self)
+            threading.Thread(target=lambda: dashboard.run(port), daemon=True).start()
+
         try:
             while True:
-                cmd = input('>>>')
-                if cmd == 'kill':
-                    self.stop_all()
-                    break
-                elif cmd == 'count':
-                    # 需要实际检查现有程序
-                    m = sum([1 for worker in self.workers if worker.is_running()])
-                    print(f'有{m}个程序正在运行')
-                elif cmd.startswith('cleanup'):
-                    # 获取 exit_code 参数
-                    args = cmd.split()
-                    if len(args) > 1:  # 支持跟一个参数，删除制定状态的程序
-                        exit_code = int(args[1])
-                    else:
-                        exit_code = None
-                    self.cleanup_finished(exit_code)
-                    print("清理完成")
-                elif cmd == 'list':  # 列出所有程序（转df查看）
-                    ls = []
-                    for worker in self.workers:
-                        ls.append([worker.name, worker.program.pid, worker.program.poll(), worker.raw_cmd])
-                    df = pd.DataFrame(ls, columns=['name', 'pid', 'poll', 'args'])
-                    print_full_dataframe(df)
+                if cmd:
+                    _cmd = input(">>> ")
+                    if not self.proc_cmd(_cmd):
+                        break
+                time.sleep(wait_seconds)
         except KeyboardInterrupt:
             print("\n检测到 Ctrl+C，正在终止所有程序...")
             self.stop_all()
@@ -579,6 +741,78 @@ class MultiProcessLauncher(MultiProgramLauncher):
     pass
 
 
+class LauncherDashboard:
+    def __init__(self, launcher):
+        self.launcher = launcher
+        self.app = FastAPI()
+        self.setup_routes()
+
+    def setup_routes(self):
+        @self.app.get("/", response_class=PlainTextResponse)
+        async def home():
+            """主页，展示所有任务状态"""
+            df = self.launcher.list_workers()
+            return self.render_text(df)
+
+        @self.app.get("/count", response_class=PlainTextResponse)
+        async def get_count():
+            """返回正在运行的任务数量"""
+            count = self.launcher.count_running()
+            return f"正在运行的任务数量: {count}\n"
+
+        @self.app.post("/stop", response_class=PlainTextResponse)
+        async def stop_all():
+            """停止所有任务"""
+            self.launcher.stop_all()
+            return "所有任务已停止。\n"
+
+        @self.app.post("/cleanup", response_class=PlainTextResponse)
+        async def cleanup(exit_code: int = None):
+            """清理已完成的任务"""
+            self.launcher.cleanup_finished(exit_code)
+            return "清理完成。\n"
+
+    def render_text(self, df):
+        """生成纯文本格式的任务状态"""
+        if df.empty:
+            return "没有任务正在运行。\n"
+
+        # 调整表头以显示新的属性：port 和 locations
+        output = ["当前任务状态:\n"]
+        output.append(f"{'编号':<5} {'名称':<15} {'PID':<10} {'状态':<10} {'端口':<10} {'位置':<20} {'命令'}")
+        output.append("-" * 120)
+
+        for idx, (_, row) in enumerate(df.iterrows(), start=1):
+            name = row['name']
+
+            # 更鲁棒地处理 pid，考虑 NaN 情况
+            pid = "N/A" if pd.isna(row['pid']) else int(row['pid'])
+
+            # 获取任务状态
+            status = "运行中" if row['poll'] is None else "已结束"
+
+            # 处理 args，确保路径展示更清晰
+            args = [a for a in row['args'] if a] if isinstance(row['args'], list) else []
+            args_str = "[" + ", ".join(
+                repr(arg).replace("\\\\", "\\") if '\\' in arg else repr(arg) for arg in args
+            ) + "]"
+
+            # 处理 port 和 locations
+            port = row['port'] if not pd.isna(row['port']) else "N/A"
+            locations = ", ".join(row['locations']) if isinstance(row['locations'], list) else "N/A"
+
+            # 格式化输出
+            output.append(f"{idx:<5} {name:<15} {pid:<10} {status:<10} {port:<10} {locations:<20} {args_str}")
+
+        output.append("\n")
+        return "\n".join(output)
+
+    def run(self, port=8080):
+        """启动 FastAPI 服务"""
+        import uvicorn
+        uvicorn.run(self.app, host="0.0.0.0", port=port, log_level="warning")
+
+
 def __3_装饰器工具():
     pass