ascript 1.3.27__py3-none-win_amd64.whl

ascript/windows/system/env.py

@@ -0,0 +1,492 @@
+import os
+import shutil
+import threading
+import subprocess
+import sys
+import ctypes
+import psutil
+import time
+import zipfile
+from email.parser import Parser
+
+from .pip import Pip
+
+
+CREATE_NEW_CONSOLE = 0x00000010
+CREATE_NO_WINDOW = 0x08000000
+
+# 这些环境变量如果泄漏进 venv 的 python.exe, 会让它去加载用户机器上
+# 另一个 Python 安装的 stdlib / site-packages, ABI 不匹配直接 SEH 崩溃, 表现就是
+# "Python 已停止工作" 弹窗 (无 stderr, 无退出码可追). 调用 venv 子进程前一律剥掉.
+_PYTHON_ENV_VARS_TO_STRIP = (
+    "PYTHONHOME",
+    "PYTHONPATH",
+    "PYTHONSTARTUP",
+    "PYTHONUSERBASE",
+    "PYTHONEXECUTABLE",
+    "__PYVENV_LAUNCHER__",
+)
+
+
+def _clean_env() -> dict:
+    env = os.environ.copy()
+    for k in _PYTHON_ENV_VARS_TO_STRIP:
+        env.pop(k, None)
+    return env
+
+
+# 进程全局: 让子进程崩溃以退出码体现, 而不是 Windows 接管弹"调试/关闭程序"对话框
+# (那对话框会把 stderr 一并埋掉). SetErrorMode 影响整个进程, 在模块加载时设一次即可.
+if sys.platform == "win32":
+    # SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX
+    ctypes.windll.kernel32.SetErrorMode(0x0001 | 0x0002 | 0x8000)
+
+
+class EnvManager:
+    """用户虚拟环境管理器。
+
+    负责为每个用户创建独立的 Python 虚拟环境，支持 wheel 包的自动部署、
+    应用启动与停止、运行状态监控等功能。每个用户通过 user_id 隔离环境。
+    """
+
+    def __init__(self, root_path=None):
+        """初始化环境管理器。
+
+        Args:
+            root_path: 环境根目录路径，默认为当前工作目录下的 "user_envs" 文件夹。
+                所有用户的虚拟环境和模块将存放在此目录下。
+        """
+        self.root_path = root_path or os.path.abspath(os.path.join(os.getcwd(), "user_envs"))
+        self.module_dir = os.path.join(self.root_path, "module")
+        if not os.path.exists(self.root_path):
+            os.makedirs(self.root_path)
+
+        if not os.path.exists(self.module_dir):
+            os.makedirs(self.module_dir)
+
+    def _get_pkg_name(self, wheel_path):
+        """从 wheel 文件中提取 Python 包名。
+
+        Args:
+            wheel_path: .whl 文件的路径。
+
+        Returns:
+            str | None: 提取到的包名，失败时返回 None。
+        """
+        try:
+            with zipfile.ZipFile(wheel_path) as wheel:
+                metadata_path = next(
+                    (name for name in wheel.namelist() if name.endswith(".dist-info/METADATA")),
+                    None,
+                )
+                if metadata_path is None:
+                    return None
+                metadata = Parser().parsestr(wheel.read(metadata_path).decode("utf-8", errors="replace"))
+                return metadata.get("Name")
+        except Exception as e:
+            print(f"提取包名失败: {e}")
+            return None
+
+    def get_env_dir(self, user_id):
+        """获取指定用户的虚拟环境目录路径。
+
+        Args:
+            user_id: 用户唯一标识。
+
+        Returns:
+            str: 虚拟环境目录的绝对路径。
+        """
+        return os.path.join(self.root_path, str(user_id))
+
+    def get_model_dir(self, user_id):
+        """获取指定用户的模块目录路径。
+
+        Args:
+            user_id: 用户唯一标识。
+
+        Returns:
+            str: 模块目录的绝对路径。
+        """
+        return os.path.join(self.module_dir, str(user_id))
+
+    def get_python_exe(self, user_id):
+        """获取指定用户虚拟环境中的 Python 可执行文件路径。
+
+        Args:
+            user_id: 用户唯一标识。
+
+        Returns:
+            str: Python 可执行文件的绝对路径。
+        """
+        base = self.get_env_dir(user_id)
+        suffix = "Scripts\\python.exe" if sys.platform == "win32" else "bin/python"
+        return os.path.join(base, suffix)
+
+    def get_pip_exe(self, user_id):
+        """获取指定用户虚拟环境中的 pip 可执行文件路径。
+
+        Args:
+            user_id: 用户唯一标识。
+
+        Returns:
+            str: pip 可执行文件的绝对路径。
+        """
+        base = self.get_env_dir(user_id)
+        suffix = "Scripts\\pip.exe" if sys.platform == "win32" else "bin/pip"
+        return os.path.join(base, suffix)
+
+    def get_create_cmd(self, env_dir):
+        """生成创建虚拟环境的命令字符串。
+
+        Args:
+            env_dir: 虚拟环境目标目录路径。
+
+        Returns:
+            str: 用于创建虚拟环境的 shell 命令。
+        """
+        return f'"{sys.executable}" -m virtualenv "{env_dir}"'
+
+    def smart_deploy(self, user_id, wheel_path, file_md5, show_console=True):
+        """智能部署用户环境。
+
+        根据 MD5 校验判断环境是否已存在且完整，若匹配则跳过部署；
+        否则清理旧环境并重新创建虚拟环境、安装 wheel 包。
+
+        Args:
+            user_id: 用户唯一标识。
+            wheel_path: .whl 安装包的文件路径。
+            file_md5: wheel 文件的 MD5 校验值，用于判断环境是否需要更新。
+            show_console: 是否显示安装过程的控制台窗口，默认 True。
+
+        Returns:
+            bool: 部署成功返回 True，失败返回 False。
+        """
+        env_dir = self.get_env_dir(user_id)
+        md5_file = os.path.join(env_dir, "env_identity.md5")
+        name_info_file = os.path.join(env_dir, "pkg_name.info")  # 记录包名的文件
+        python_exe = self.get_python_exe(user_id)
+
+        # wheel_path = r"D:\workspace\python\ascript-windows\apps\module\1085\8bb2a42175a3d4f473f58333020aebda\ascriptproject2-0.1.0-py3-none-any.whl"
+
+        is_ready = False
+        # 增加对 pkg_name.info 的存在性检查
+        if os.path.exists(md5_file) and os.path.exists(python_exe) and os.path.exists(name_info_file):
+            try:
+                with open(md5_file, "r", encoding="utf-8") as f:
+                    saved_md5 = f.read().strip()
+                if saved_md5 == file_md5:
+                    is_ready = True
+            except Exception:
+                is_ready = False
+
+        if is_ready:
+            print(f"[{user_id}] 环境匹配且完整。")
+            return True
+
+        print(f"[{user_id}] 环境重建中...")
+
+        # 提前提取包名
+        current_pkg_name = self._get_pkg_name(wheel_path)
+        if not current_pkg_name:
+            self._show_error_box(f"无法从文件解析包名: {wheel_path}", "部署异常")
+            return False
+
+        try:
+            if os.path.exists(env_dir):
+                self.stop_app(user_id)
+                time.sleep(0.8)
+
+            if os.path.exists(env_dir):
+                shutil.rmtree(env_dir, ignore_errors=True)
+
+            os.makedirs(self.root_path, exist_ok=True)
+
+            # 执行安装
+            self._execute_combined_install(user_id, wheel_path, env_dir, show_console)
+
+            # 写入校验信息
+            with open(md5_file, "w", encoding="utf-8") as f:
+                f.write(file_md5)
+            # 关键修改：持久化包名，供 run_app 使用
+            with open(name_info_file, "w", encoding="utf-8") as f:
+                f.write(current_pkg_name)
+
+            return True
+
+        except RuntimeError as re:
+            error_text = str(re)
+            print(f"[{user_id}] 部署中断: {error_text}")
+            log_path = os.path.join(self.root_path, f"deploy_error_{user_id}.log")
+            try:
+                with open(log_path, "w", encoding="utf-8") as f:
+                    f.write(error_text)
+            except Exception:
+                log_path = None
+
+            # MessageBox 没有滚动条，只展示末尾最有价值的部分；完整内容保存在日志中。
+            display_text = error_text[-3000:]
+            if log_path:
+                display_text += f"\n\n完整日志：{log_path}"
+            self._show_error_box(display_text, f"插件 {user_id} 部署失败")
+            if os.path.exists(env_dir):
+                shutil.rmtree(env_dir, ignore_errors=True)
+            return False
+        except Exception as e:
+            self._show_error_box(f"用户 {user_id} 部署失败！\n原因: {str(e)}", "环境部署中断")
+            if os.path.exists(env_dir):
+                shutil.rmtree(env_dir, ignore_errors=True)
+            return False
+
+    def _execute_combined_install(self, user_id, wheel_path, env_dir, show_console):
+        """分三步部署: 创建 venv → 自检 venv python.exe → pip 安装 wheel。
+
+        关键是把曾经的 "cmd /s /c virtualenv && pip install" 拆开 —— 那种串法任一步
+        崩了 stderr 都会被外层 cmd 吞掉, 用户只看到 "Python 已停止工作" 这种无法定位
+        的提示。拆开后每一步独立 subprocess + capture, 用户能拿到具体退出码 + stderr。
+
+        Raises:
+            RuntimeError: 任一步骤失败，message 含退出码和完整输出。
+        """
+        abs_env_dir = os.path.abspath(env_dir)
+        abs_wheel_path = os.path.abspath(wheel_path)
+        venv_python = self.get_python_exe(user_id)
+        env = _clean_env()
+
+        r = subprocess.run(
+            [sys.executable, "-m", "virtualenv", abs_env_dir],
+            env=env, capture_output=True, text=True,
+            creationflags=CREATE_NO_WINDOW,
+        )
+        if r.returncode != 0:
+            raise RuntimeError(
+                f"虚拟环境创建失败 (exit {r.returncode}):\n"
+                f"{(r.stderr or r.stdout).strip() or '(no output)'}"
+            )
+
+        # 把"看不见的 SEH 崩溃"变成"看得见的退出码", 让用户能据此自查或截屏反馈。
+        r = subprocess.run(
+            [venv_python, "-c", "import sys; print(sys.version)"],
+            env=env, capture_output=True, text=True, timeout=15,
+        )
+        if r.returncode != 0:
+            code_hex = f"0x{r.returncode & 0xFFFFFFFF:08X}"
+            hints = {
+                "0xC0000142": "进程初始化失败。常见原因: 安装路径在网络盘 / 外置盘 / OneDrive 同步盘, 或被企业 EDR 拦截。",
+                "0xC0000135": "缺少必要 DLL。请检查 VC++ 运行库或安全软件是否隔离了 python.exe 的依赖。",
+                "0xC0000005": "访问违例。常见于安全软件 (Defender ASR / 360 / 火绒) 拦截了进程启动。",
+                "0xC000007B": "DLL 位数错配。系统 PATH 上可能存在与 AScript 自带 Python 冲突的同名 DLL。",
+            }
+            hint = hints.get(code_hex, "请把以上完整信息发给开发者排查。")
+            raise RuntimeError(
+                f"虚拟环境自检失败 (exit {code_hex}):\n"
+                f"  路径: {venv_python}\n"
+                f"  stdout: {r.stdout.strip() or '(empty)'}\n"
+                f"  stderr: {r.stderr.strip() or '(empty)'}\n"
+                f"  提示: {hint}"
+            )
+
+        index_url = Pip.get_best_index()
+        print(f"[{user_id}] 自动择源完成，选用: {index_url}")
+        timeout = getattr(self, 'config', {}).get('timeout', 15)
+        pip_args = [
+            # 使用已经通过自检的 python.exe 启动 pip，避开 pip.exe 启动器静默崩溃。
+            venv_python, "-m", "pip", "install", "--no-cache-dir",
+            "-i", index_url,
+            "--default-timeout", str(timeout),
+            abs_wheel_path,
+        ]
+
+        r = subprocess.run(
+            pip_args,
+            env=env,
+            capture_output=True,
+            text=True,
+            errors="replace",
+            creationflags=CREATE_NO_WINDOW,
+        )
+        output = "\n".join(part for part in (r.stdout, r.stderr) if part).strip()
+        if r.returncode != 0:
+            detail = output or "(pip 未输出任何错误信息)"
+            raise RuntimeError(
+                f"插件依赖安装失败 (exit {r.returncode}):\n{detail}"
+            )
+        if output:
+            print(output)
+
+    def run_app(self, user_id, entry_module="main", cwd=None, show_console=False):
+        """启动用户应用程序。
+
+        在指定用户的虚拟环境中运行应用入口模块，自动从环境配置中
+        读取包名。启动后会创建后台监控线程跟踪进程状态。
+
+        Args:
+            user_id: 用户唯一标识。
+            entry_module: 入口模块名，默认 "main"。
+            cwd: 工作目录，默认为用户环境目录。
+            show_console: 是否显示控制台窗口，默认 False。
+
+        Returns:
+            int | None: 启动成功返回进程 PID，失败返回 None。
+        """
+        python_exe = self.get_python_exe(user_id)
+        env_dir = self.get_env_dir(user_id)
+        name_info_file = os.path.join(env_dir, "pkg_name.info")
+
+        # 自动获取包名
+        if not os.path.exists(name_info_file):
+            self._show_error_box("找不到环境包名配置，请重新部署环境。", "启动失败")
+            return None
+
+        with open(name_info_file, "r", encoding="utf-8") as f:
+            package_name = f.read().strip()
+
+        work_dir = cwd or env_dir
+        last_error_log = os.path.join(env_dir, "last_error.log")
+
+        if os.path.exists(last_error_log):
+            try:
+                os.remove(last_error_log)
+            except:
+                pass
+
+        target_module = f"{package_name}.{entry_module}"
+        cmd = [python_exe, "-u", "-m", target_module]
+        pid_file = os.path.join(env_dir, "app.pid")
+
+        try:
+            flags = 0 if show_console else CREATE_NO_WINDOW
+            with open(last_error_log, "w", encoding="utf-8") as f_err:
+                process = subprocess.Popen(
+                    cmd,
+                    cwd=work_dir,
+                    creationflags=flags,
+                    stdout=subprocess.DEVNULL,
+                    stderr=f_err,
+                    text=True,
+                    encoding='utf-8',
+                    env=_clean_env(),
+                )
+
+            with open(pid_file, "w") as f:
+                f.write(str(process.pid))
+
+            monitor_thread = threading.Thread(
+                target=self._wait_and_handle_error,
+                args=(process, user_id, package_name, pid_file, show_console, last_error_log),
+                daemon=True
+            )
+            monitor_thread.start()
+            return process.pid
+        except Exception as e:
+            self._show_error_box(f"启动失败: {str(e)}", "致命错误")
+            return None
+
+    def _wait_and_handle_error(self, process, user_id, name, pid_file, show_console, log_path):
+        """等待进程结束并处理异常退出。
+
+        作为后台监控线程的目标函数运行，在进程异常退出时
+        读取错误日志并弹出错误提示框。
+
+        Args:
+            process: subprocess.Popen 进程对象。
+            user_id: 用户唯一标识。
+            name: 包名称，用于错误提示。
+            pid_file: PID 文件路径，用于判断是否为手动停止。
+            show_console: 是否显示了控制台窗口。
+            log_path: 错误日志文件路径。
+        """
+        try:
+            process.wait()
+            is_manual_stop = not os.path.exists(pid_file)
+            if process.returncode != 0 and not show_console and not is_manual_stop:
+                stderr_content = ""
+                if os.path.exists(log_path):
+                    with open(log_path, "r", encoding="utf-8") as f:
+                        stderr_content = f.read()
+                self._handle_runtime_error(name, stderr_content, process.returncode)
+        finally:
+            if os.path.exists(pid_file):
+                try:
+                    os.remove(pid_file)
+                except:
+                    pass
+
+    def _handle_runtime_error(self, name, stderr, code):
+        """处理运行时错误：记录崩溃日志并弹出错误提示。
+
+        Args:
+            name: 模块/包名称。
+            stderr: 标准错误输出内容。
+            code: 进程退出码。
+        """
+        if not stderr: stderr = f"进程异常退出，退出码: {code}"
+        lines = [line.strip() for line in stderr.splitlines() if line.strip()]
+        error_summary = "\n".join(lines[-10:])
+        try:
+            log_path = os.path.join(os.getcwd(), f"crash_{int(time.time())}.log")
+            with open(log_path, "w", encoding="utf-8") as f:
+                f.write(f"Time: {time.ctime()}\nModule: {name}\nCode: {code}\n{stderr}")
+        except:
+            pass
+        self._show_error_box(f"【代码崩溃】核心摘要:\n{error_summary}", f"运行异常 - {name}")
+
+    def _show_error_box(self, content, title):
+        """在 Windows 上弹出错误消息框。
+
+        Args:
+            content: 消息框内容文本。
+            title: 消息框标题。
+        """
+        if sys.platform == "win32":
+            ctypes.windll.user32.MessageBoxW(0, content, title, 16)
+
+    def is_running(self, user_id):
+        """检查指定用户的应用是否正在运行。
+
+        通过 PID 文件和进程信息双重验证运行状态。
+
+        Args:
+            user_id: 用户唯一标识。
+
+        Returns:
+            bool: 应用正在运行返回 True，否则返回 False。
+        """
+        env_dir = self.get_env_dir(user_id)
+        pid_file = os.path.join(env_dir, "app.pid")
+        if not os.path.exists(pid_file): return False
+        try:
+            with open(pid_file, "r") as f:
+                saved_pid = int(f.read().strip())
+            if not psutil.pid_exists(saved_pid):
+                if os.path.exists(pid_file): os.remove(pid_file)
+                return False
+            proc = psutil.Process(saved_pid)
+            expected_python = os.path.normcase(os.path.normpath(self.get_python_exe(user_id)))
+            actual_python = os.path.normcase(os.path.normpath(proc.exe()))
+            return expected_python == actual_python
+        except Exception:
+            return False
+
+    def stop_app(self, user_id):
+        """停止指定用户的应用进程。
+
+        先删除 PID 文件（标记为手动停止），然后使用 taskkill 强制终止进程树。
+
+        Args:
+            user_id: 用户唯一标识。
+        """
+        pid_file = os.path.join(self.get_env_dir(user_id), "app.pid")
+        if not os.path.exists(pid_file): return
+        try:
+            with open(pid_file, "r") as f:
+                pid = int(f.read().strip())
+            if os.path.exists(pid_file):
+                try:
+                    os.remove(pid_file)
+                except:
+                    pass
+            if psutil.pid_exists(pid):
+                subprocess.run(["taskkill", "/F", "/T", "/PID", str(pid)], creationflags=CREATE_NO_WINDOW,
+                               capture_output=True)
+        except:
+            pass

ascript/windows/system/exception/__init__.py

@@ -0,0 +1 @@
+

ascript/windows/system/key_value.py

@@ -0,0 +1,145 @@
+import json
+import os
+import pathlib
+import threading
+
+class KeyValueMeta(type):
+    """KeyValue 的元类，支持类级别的索引操作。
+
+    通过该元类，可以直接使用 KeyValue["key"] 语法进行键值的
+    读取、设置和删除操作。
+    """
+
+    def __getitem__(cls, key):
+        """通过索引语法获取值。
+
+        Args:
+            key: 键名。
+
+        Returns:
+            对应键的值，不存在时返回 None。
+        """
+        return cls.get(key)
+
+    def __setitem__(cls, key, value):
+        """通过索引语法设置值。
+
+        Args:
+            key: 键名。
+            value: 要保存的值。
+        """
+        cls.save(key, value)
+
+    def __delitem__(cls, key):
+        """通过索引语法删除键值对。
+
+        Args:
+            key: 要删除的键名。
+        """
+        cls.remove(key)
+
+
+class KeyValue(metaclass=KeyValueMeta):
+    """基于 JSON 文件的持久化键值存储。
+
+    提供线程安全的键值对读写操作，数据自动持久化到 JSON 文件。
+    支持类级别的索引操作（如 KeyValue["key"] = value）。
+
+    Attributes:
+        FILENAME: 存储文件名，默认为 "config.json"。
+    """
+    _data = None
+    _file_path = None
+    _lock = threading.Lock()  # 线程锁，防止并发写入冲突
+    FILENAME = "config.json"
+
+    @classmethod
+    def _initialize(cls):
+        """延迟初始化：确定存储路径并加载已有数据。
+
+        首次访问时自动调用，确保数据文件路径和内存数据已就绪。
+        """
+        with cls._lock:
+            if cls._data is None:
+                cls._file_path = cls._determine_path()
+                cls._data = cls._load_data()
+
+    @classmethod
+    def _determine_path(cls):
+        """确定配置文件的存储路径。
+
+        优先使用当前工作目录，若无写权限则回退到用户家目录下的隐藏文件夹。
+
+        Returns:
+            pathlib.Path: 配置文件的完整路径。
+        """
+        # 1. 尝试根目录
+        root_path = pathlib.Path(os.getcwd())
+        if os.access(root_path, os.W_OK):
+            return root_path / cls.FILENAME
+
+        # 2. 回退到用户家目录 (隐藏文件夹)
+        home_dir = pathlib.Path.home() / ".app_data"
+        home_dir.mkdir(parents=True, exist_ok=True)
+        return home_dir / cls.FILENAME
+
+    @classmethod
+    def _load_data(cls):
+        """从 JSON 文件加载数据到内存。
+
+        Returns:
+            dict: 解析后的键值数据字典，文件不存在或解析失败时返回空字典。
+        """
+        if cls._file_path.exists():
+            try:
+                return json.loads(cls._file_path.read_text(encoding='utf-8'))
+            except:
+                return {}
+        return {}
+
+    @classmethod
+    def _commit(cls):
+        """将内存数据持久化写入 JSON 文件（线程安全）。"""
+        with cls._lock:
+            cls._file_path.write_text(
+                json.dumps(cls._data, indent=4, ensure_ascii=False),
+                encoding='utf-8'
+            )
+
+    @classmethod
+    def save(cls, key, value):
+        """保存键值对并持久化到文件。
+
+        Args:
+            key: 键名。
+            value: 要保存的值，需可 JSON 序列化。
+        """
+        cls._initialize()
+        cls._data[key] = value
+        cls._commit()
+
+    @classmethod
+    def get(cls, key, default=None):
+        """获取指定键的值。
+
+        Args:
+            key: 键名。
+            default: 键不存在时的默认返回值，默认 None。
+
+        Returns:
+            对应键的值，不存在时返回 default。
+        """
+        cls._initialize()
+        return cls._data.get(key, default)
+
+    @classmethod
+    def remove(cls, key):
+        """删除指定键值对并持久化更新。
+
+        Args:
+            key: 要删除的键名。若键不存在则不执行任何操作。
+        """
+        cls._initialize()
+        if key in cls._data:
+            del cls._data[key]
+            cls._commit()