ascript 1.3.27__py3-none-win_amd64.whl

ascript/windows/hardware/mouse.py

@@ -0,0 +1,308 @@
+"""Native Windows mouse input based on the standard-library ctypes module."""
+
+import ctypes
+import math
+import random
+import threading
+import time
+from ctypes import wintypes
+from typing import Callable, Optional, Tuple
+
+_INPUT_MOUSE = 0
+_MOUSEEVENTF_MOVE = 0x0001
+_MOUSEEVENTF_LEFTDOWN = 0x0002
+_MOUSEEVENTF_LEFTUP = 0x0004
+_MOUSEEVENTF_RIGHTDOWN = 0x0008
+_MOUSEEVENTF_RIGHTUP = 0x0010
+_MOUSEEVENTF_MIDDLEDOWN = 0x0020
+_MOUSEEVENTF_MIDDLEUP = 0x0040
+_MOUSEEVENTF_WHEEL = 0x0800
+_MOUSEEVENTF_HWHEEL = 0x1000
+_MOUSEEVENTF_VIRTUALDESK = 0x4000
+_MOUSEEVENTF_ABSOLUTE = 0x8000
+_SM_SWAPBUTTON = 23
+_SM_XVIRTUALSCREEN = 76
+_SM_YVIRTUALSCREEN = 77
+_SM_CXVIRTUALSCREEN = 78
+_SM_CYVIRTUALSCREEN = 79
+_WHEEL_DELTA = 120
+
+
+class MouseFailSafeError(RuntimeError):
+    """Raised when the pointer reaches a virtual-screen corner."""
+
+
+class _MOUSEINPUT(ctypes.Structure):
+    _fields_ = [("dx", wintypes.LONG), ("dy", wintypes.LONG),
+                ("mouseData", wintypes.DWORD), ("dwFlags", wintypes.DWORD),
+                ("time", wintypes.DWORD), ("dwExtraInfo", ctypes.c_size_t)]
+
+
+class _INPUTUNION(ctypes.Union):
+    _fields_ = [("mi", _MOUSEINPUT)]
+
+
+class _INPUT(ctypes.Structure):
+    _anonymous_ = ("union",)
+    _fields_ = [("type", wintypes.DWORD), ("union", _INPUTUNION)]
+
+
+class _POINT(ctypes.Structure):
+    _fields_ = [("x", wintypes.LONG), ("y", wintypes.LONG)]
+
+
+_user32 = ctypes.windll.user32
+_send_input = _user32.SendInput
+_send_input.argtypes = (wintypes.UINT, ctypes.c_void_p, ctypes.c_int)
+_send_input.restype = wintypes.UINT
+_get_cursor_pos = _user32.GetCursorPos
+_get_cursor_pos.argtypes = (ctypes.POINTER(_POINT),)
+_get_cursor_pos.restype = wintypes.BOOL
+_get_system_metrics = _user32.GetSystemMetrics
+_get_system_metrics.argtypes = (ctypes.c_int,)
+_get_system_metrics.restype = ctypes.c_int
+
+
+def _linear(value: float) -> float:
+    return value
+
+
+class Mouse:
+    """Chainable mouse controller using the same SendInput path as PyDirectInput."""
+
+    LEFT = "left"
+    MIDDLE = "middle"
+    RIGHT = "right"
+    PRIMARY = "primary"
+    SECONDARY = "secondary"
+    DEFAULT_MOVE_DURATION = 0.1
+    FAILSAFE = True
+    MINIMUM_SLEEP = 1.0 / 120.0
+    _lock = threading.RLock()
+    _dpi_initialized = False
+
+    @classmethod
+    def _initialize_dpi(cls) -> None:
+        if cls._dpi_initialized:
+            return
+        cls._dpi_initialized = True
+        try:
+            setter = _user32.SetProcessDpiAwarenessContext
+            setter.argtypes = (ctypes.c_void_p,)
+            setter.restype = wintypes.BOOL
+            setter(ctypes.c_void_p(-4))  # DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
+            return
+        except (AttributeError, OSError):
+            pass
+        try:
+            ctypes.windll.shcore.SetProcessDpiAwareness(2)
+        except (AttributeError, OSError):
+            try:
+                _user32.SetProcessDPIAware()
+            except (AttributeError, OSError):
+                pass
+
+    @staticmethod
+    def _validate_pair(x: Optional[int], y: Optional[int], name: str = "coordinates") -> None:
+        if (x is None) != (y is None):
+            raise ValueError(f"{name}: x and y must be provided together")
+        if x is not None and (not isinstance(x, int) or isinstance(x, bool) or
+                              not isinstance(y, int) or isinstance(y, bool)):
+            raise TypeError(f"{name}: x and y must be integers")
+
+    @staticmethod
+    def _duration(value: float, name: str) -> float:
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise TypeError(f"{name} must be a number")
+        value = float(value)
+        if value < 0 or not math.isfinite(value):
+            raise ValueError(f"{name} must be finite and non-negative")
+        return value
+
+    @classmethod
+    def _virtual_screen(cls) -> Tuple[int, int, int, int]:
+        cls._initialize_dpi()
+        result = (_get_system_metrics(_SM_XVIRTUALSCREEN),
+                  _get_system_metrics(_SM_YVIRTUALSCREEN),
+                  _get_system_metrics(_SM_CXVIRTUALSCREEN),
+                  _get_system_metrics(_SM_CYVIRTUALSCREEN))
+        if result[2] <= 0 or result[3] <= 0:
+            raise OSError("Windows did not report a valid virtual screen")
+        return result
+
+    @classmethod
+    def position(cls) -> Tuple[int, int]:
+        cls._initialize_dpi()
+        point = _POINT()
+        if not _get_cursor_pos(ctypes.byref(point)):
+            raise ctypes.WinError(ctypes.get_last_error())
+        return int(point.x), int(point.y)
+
+    @classmethod
+    def _fail_safe_check(cls) -> None:
+        if not cls.FAILSAFE:
+            return
+        left, top, width, height = cls._virtual_screen()
+        right, bottom = left + width - 1, top + height - 1
+        if cls.position() in ((left, top), (right, top), (left, bottom), (right, bottom)):
+            raise MouseFailSafeError("Mouse fail-safe triggered at a virtual-screen corner")
+
+    @classmethod
+    def _emit(cls, flags: int, data: int = 0, dx: int = 0, dy: int = 0, check: bool = True) -> None:
+        if check:
+            cls._fail_safe_check()
+        event = _INPUT(type=_INPUT_MOUSE, mi=_MOUSEINPUT(
+            dx=dx, dy=dy, mouseData=ctypes.c_uint32(data).value,
+            dwFlags=flags, time=0, dwExtraInfo=0))
+        if _send_input(1, ctypes.byref(event), ctypes.sizeof(_INPUT)) != 1:
+            raise ctypes.WinError(ctypes.get_last_error())
+
+    @classmethod
+    def _button_flags(cls, button: str) -> Tuple[int, int]:
+        if not isinstance(button, str):
+            raise TypeError("button must be a string")
+        button = button.lower()
+        swapped = bool(_get_system_metrics(_SM_SWAPBUTTON))
+        if button == cls.PRIMARY:
+            button = cls.RIGHT if swapped else cls.LEFT
+        elif button == cls.SECONDARY:
+            button = cls.LEFT if swapped else cls.RIGHT
+        mapping = {cls.LEFT: (_MOUSEEVENTF_LEFTDOWN, _MOUSEEVENTF_LEFTUP),
+                   cls.MIDDLE: (_MOUSEEVENTF_MIDDLEDOWN, _MOUSEEVENTF_MIDDLEUP),
+                   cls.RIGHT: (_MOUSEEVENTF_RIGHTDOWN, _MOUSEEVENTF_RIGHTUP)}
+        if button not in mapping:
+            raise ValueError("button must be left, middle, right, primary or secondary")
+        return mapping[button]
+
+    @classmethod
+    def _move_immediately(cls, x: int, y: int, check: bool = True) -> None:
+        left, top, width, height = cls._virtual_screen()
+        x = min(max(x, left), left + width - 1)
+        y = min(max(y, top), top + height - 1)
+        normalized_x = round((x - left) * 65535 / max(1, width - 1))
+        normalized_y = round((y - top) * 65535 / max(1, height - 1))
+        cls._emit(_MOUSEEVENTF_MOVE | _MOUSEEVENTF_ABSOLUTE | _MOUSEEVENTF_VIRTUALDESK,
+                  dx=normalized_x, dy=normalized_y, check=check)
+
+    @classmethod
+    def mouse_move(cls, x: int, y: int, move_duration: float = DEFAULT_MOVE_DURATION,
+                   tween: Callable[[float], float] = _linear):
+        cls._validate_pair(x, y)
+        duration = cls._duration(move_duration, "move_duration")
+        if not callable(tween):
+            raise TypeError("tween must be callable")
+        with cls._lock:
+            cls._fail_safe_check()
+            if duration == 0:
+                cls._move_immediately(x, y, check=False)
+                return cls
+            start_x, start_y = cls.position()
+            steps = max(1, int(duration / cls.MINIMUM_SLEEP))
+            started = time.perf_counter()
+            for step in range(1, steps + 1):
+                progress = min(1.0, max(0.0, float(tween(step / steps))))
+                cls._fail_safe_check()
+                cls._move_immediately(round(start_x + (x - start_x) * progress),
+                                      round(start_y + (y - start_y) * progress), check=False)
+                delay = started + duration * step / steps - time.perf_counter()
+                if delay > 0:
+                    time.sleep(delay)
+            cls._move_immediately(x, y, check=False)
+        return cls
+
+    @classmethod
+    def mouse_down(cls, x: Optional[int] = None, y: Optional[int] = None,
+                   button: str = PRIMARY, move_duration: float = 0.0):
+        cls._validate_pair(x, y)
+        with cls._lock:
+            if x is not None:
+                cls.mouse_move(x, y, move_duration)
+            cls._emit(cls._button_flags(button)[0])
+        return cls
+
+    @classmethod
+    def mouse_up(cls, x: Optional[int] = None, y: Optional[int] = None,
+                 button: str = PRIMARY, move_duration: float = 0.0):
+        cls._validate_pair(x, y)
+        with cls._lock:
+            if x is not None:
+                cls.mouse_move(x, y, move_duration)
+            cls._emit(cls._button_flags(button)[1])
+        return cls
+
+    @classmethod
+    def click(cls, x: Optional[int] = None, y: Optional[int] = None, clicks: int = 1,
+              interval: float = 0.1, button: str = PRIMARY, move_duration: float = 0.0,
+              duration: float = 0.0, offset: int = 0):
+        cls._validate_pair(x, y)
+        if not isinstance(clicks, int) or isinstance(clicks, bool):
+            raise TypeError("clicks must be an integer")
+        if clicks < 1:
+            raise ValueError("clicks must be at least one")
+        interval = cls._duration(interval, "interval")
+        duration = cls._duration(duration, "duration")
+        if not isinstance(offset, int) or isinstance(offset, bool):
+            raise TypeError("offset must be an integer")
+        if offset < 0:
+            raise ValueError("offset must be non-negative")
+        with cls._lock:
+            if x is not None:
+                if offset:
+                    left, top, width, height = cls._virtual_screen()
+                    x = min(max(x + random.randint(-offset, offset), left), left + width - 1)
+                    y = min(max(y + random.randint(-offset, offset), top), top + height - 1)
+                cls.mouse_move(x, y, move_duration)
+            down, up = cls._button_flags(button)
+            for index in range(clicks):
+                cls._emit(down)
+                try:
+                    if duration:
+                        time.sleep(duration)
+                finally:
+                    cls._emit(up, check=False)
+                if index + 1 < clicks and interval:
+                    time.sleep(interval)
+        return cls
+
+    @classmethod
+    def long_press(cls, x: Optional[int] = None, y: Optional[int] = None,
+                   press_duration: float = 2.0, button: str = PRIMARY,
+                   move_duration: float = 0.0):
+        return cls.click(x, y, button=button, move_duration=move_duration, duration=press_duration)
+
+    @classmethod
+    def scroll(cls, lines: int, x: Optional[int] = None, y: Optional[int] = None,
+               direction: str = "v"):
+        cls._validate_pair(x, y)
+        if not isinstance(lines, int) or isinstance(lines, bool):
+            raise TypeError("lines must be an integer")
+        if direction not in ("v", "h"):
+            raise ValueError("direction must be 'v' or 'h'")
+        with cls._lock:
+            if x is not None:
+                cls.mouse_move(x, y, 0.0)
+            cls._emit(_MOUSEEVENTF_WHEEL if direction == "v" else _MOUSEEVENTF_HWHEEL,
+                      lines * _WHEEL_DELTA)
+        return cls
+
+    @classmethod
+    def drag(cls, to_x: int, to_y: int, from_x: Optional[int] = None,
+             from_y: Optional[int] = None, move_duration: float = 0.5,
+             button: str = PRIMARY, tween: Callable[[float], float] = _linear):
+        cls._validate_pair(to_x, to_y, "destination")
+        cls._validate_pair(from_x, from_y, "origin")
+        with cls._lock:
+            if from_x is not None:
+                cls.mouse_move(from_x, from_y, 0.0)
+            down, up = cls._button_flags(button)
+            cls._emit(down)
+            try:
+                cls.mouse_move(to_x, to_y, move_duration, tween)
+            finally:
+                cls._emit(up, check=False)
+        return cls
+
+    @classmethod
+    def wait(cls, seconds: float):
+        time.sleep(cls._duration(seconds, "seconds"))
+        return cls

ascript/windows/license/__init__.py

@@ -0,0 +1,16 @@
+"""许可证加密模块。
+
+提供基于 AES 加密的许可证验证功能，包括加密通信和数据填充工具。
+
+Exports:
+    achttp: 加密 HTTP 通信模块。
+    AES: AES 加密算法。
+    pad: PKCS7 数据填充函数。
+    unpad: PKCS7 数据去填充函数。
+"""
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+from . import achttp
+
+__all__ = ['achttp', "AES", "pad", "unpad"]

ascript/windows/resources/templates/__init__py.win.template

@@ -0,0 +1,51 @@
+import time
+import sys
+from ascript.windows.system import R  # 程序上下文与资源路由
+from ascript.windows.ui import LicenseWindow  # 安全验证组件
+from ascript.windows.ui import FloatScriptWindow  # 脚本控制台组件
+
+# 初始化控制台：支持自启动 (auto_start) 与 多进程隔离 (use_process)
+app = FloatScriptWindow(R.img("logo.ico"), title="AScript 自动化助手", auto_start=True)
+
+@app.on('start')
+def task_start():
+    # ---------------------------------------------------------
+    # 入口程序 (Entry Point)
+    # ---------------------------------------------------------
+    """
+    [业务逻辑入口]
+    当用户点击启动按钮或触发自启动时，此函数将在独立的子进程中运行。
+    """
+    print(">>> [系统] 业务进程已建立，开始执行自动化任务...")
+
+
+@app.on('stop')
+def task_stop():
+    """
+    [善后处理回调]
+    当用户手动停止或任务结束时触发。
+    注意：您有约 3 秒的时间进行资源释放（如关闭文件、数据库断开等）。
+    即使此处存在死循环，系统也会在超时后强制回收进程资源。
+    """
+    print(">>> [系统] 接收到停止信号，正在释放系统资源...")
+    # 模拟保存数据逻辑
+    time.sleep(1)
+    print(">>> [系统] 资源释放完毕，安全退出。")
+
+
+
+
+if __name__ == '__main__':
+    # 1. 软件授权验证 (前往开发者后台获取程序 ID)
+    # 验证窗口会阻塞主线程，直到验证通过或用户关闭
+    license_manager = LicenseWindow("1085")
+
+    if license_manager.show():
+        print("✅ [认证] 授权验证成功")
+
+        # 2. 启动悬浮控制台
+        # 参数说明：is_debug=True 可开启调试模式，width/height 可自定义窗口尺寸
+        app.show(title="AScript_Control_Panel")
+    else:
+        print("❌ [认证] 验证被取消或失败，程序即将退出")
+        sys.exit()

ascript/windows/resources/templates/build.as.win.template

@@ -0,0 +1,14 @@
+{
+    "name": "AScriptProject",
+    "version": "1.0.0",
+    "entry": "__init__.py",
+    "parameters": [
+        "-m", "PyInstaller",
+        "--onefile",
+        "--clean",
+        "--noconsole",
+        "--icon", "res/img/logo.ico",
+        "--collect-all", "ascript",
+        "--add-data", "res;res"
+    ]
+}

ascript/windows/resources/templates/build.py

@@ -0,0 +1,71 @@
+import subprocess
+import sys
+import os
+import shutil
+
+
+def auto_build(entry_file, project_name):
+    """使用 Nuitka 将 Python 项目打包为独立的 Windows 可执行文件。
+
+    自动构造 Nuitka 编译命令，实时输出编译日志到控制台，
+    并在完成后报告编译结果。
+
+    Args:
+        entry_file: Python 入口文件路径（如 'main.py'）
+        project_name: 输出的可执行文件名称（不含 .exe 后缀）
+    """
+    # 1. 确保入口文件存在
+    if not os.path.exists(entry_file):
+        print(f"❌ 错误: 找不到入口文件 {entry_file}")
+        return
+
+    # 2. 构造 Nuitka 命令
+    build_cmd = [
+        sys.executable, "-m", "nuitka",
+        "--standalone",
+        "--onefile",
+        "--enable-plugin=tk-inter",
+        "--include-package=Crypto",  # 强制包含 Crypto 模块
+        # "--windows-disable-console", # 先注掉，我们要看控制台报错
+        "--include-package=ascript",
+        "--output-dir=out",
+        f"--output-filename={project_name}",
+        entry_file
+    ]
+
+    # 3. 针对 Windows 下可能存在的路径空格问题进行处理
+    # Popen 传入 list 格式在 Windows 下通常能很好处理空格
+
+    print(f"🚀 Nuitka 开始编译 [{project_name}]，这可能需要几分钟...")
+
+    # 执行打包
+    process = subprocess.Popen(
+        build_cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        encoding='utf-8',
+        bufsize=1  # 行缓冲，实时获取输出
+    )
+
+    # 4. 实时输出给 IDE 的控制台
+    try:
+        for line in process.stdout:
+            # 过滤掉一些极其冗长的编译信息，只留关键进度
+            clean_line = line.strip()
+            if clean_line:
+                print(f"[Nuitka]: {clean_line}")
+    except Exception as e:
+        print(f"读取日志异常: {e}")
+
+    process.wait()
+
+    if process.returncode == 0:
+        print(f"✨ 打包成功！文件位于: out/{project_name}.exe")
+    else:
+        print(f"💥 打包失败，退出码: {process.returncode}")
+
+
+if __name__ == "__main__":
+    # 假设开发者的主程序是 main.py
+    auto_build("windows/main.py", "AScriptApp")

ascript/windows/resources/templates/windows/main.py

@@ -0,0 +1,50 @@
+"""AScript Windows 应用模板的入口程序。
+
+演示如何使用 FloatScriptWindow 创建带有启动/停止控制的自动化脚本应用。
+"""
+import multiprocessing
+import time
+import sys
+from ascript.windows.system import R  # 程序上下文与资源路由
+from ascript.windows.ui import LicenseWindow  # 安全验证组件
+from ascript.windows.ui import FloatScriptWindow  # 脚本控制台组件
+
+# 初始化控制台：支持自启动 (auto_start) 与 多进程隔离 (use_process)
+app = FloatScriptWindow(R.img("logo.ico"), title="我的程序", auto_start=True)
+
+@app.on('start')
+def task_start():
+    """业务逻辑入口函数。
+
+    当用户点击启动按钮或触发自启动时，此函数将在独立的子进程中运行。
+    在此函数中编写自动化任务的核心业务逻辑。
+    """
+    print(">>> [系统] 业务进程已建立，开始执行自动化任务...")
+    i= 0
+
+    # 模拟耗时逻辑操作
+    while True:
+        print(i)
+        time.sleep(0.5)
+        i += 1
+
+
+@app.on('stop')
+def task_stop():
+    """任务停止时的善后处理回调。
+
+    当用户手动停止或任务结束时触发。可在此执行资源释放操作，
+    如关闭文件句柄、断开数据库连接等。注意约有 3 秒的执行时限，
+    超时后系统会强制回收进程资源。
+    """
+    print(">>> [系统] 接收到停止信号，正在释放系统资源...")
+    # 模拟保存数据逻辑
+    time.sleep(1)
+    print(">>> [系统] 资源释放完毕，安全退出。")
+
+
+
+
+if __name__ == '__main__':
+    # 解决打包后子进程重复启动问题
+    app.show()

ascript/windows/resources/templates/windows/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "_project_name_"
+version = "0.1.0"
+description = "Ascript Project Template"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+dependencies = [
+    "ascript",
+#    "rapidocr==3.5.0",
+#    "onnxruntime==1.23.2"
+]
+
+[tool.setuptools]
+# 【硬映射核心】
+# 这里的含义是：创建一个名为 "_project_name_" 的虚拟包，
+# 并告诉系统它的源代码就在当前根目录 "."
+package-dir = {"_project_name_" = "."}
+packages = ["_project_name_"]
+
+include-package-data = true
+
+[tool.setuptools.package-data]
+# 这里的 key 必须和上面 packages 里的名字一致
+"_project_name_" = ["res/**/*", "config.json", "build.as","pyarmor_runtime_000000/**/*"]
+
+[tool.setuptools.exclude-package-data]
+"_project_name_" = ["sercert/**/*"]
+
+[tool.ascript.pack]
+# 文件夹排除列表：这些文件夹及其内容不会被打包
+exclude-dirs = [
+    ".venv", "venv", ".idea", ".vscode", "__pycache__",
+    "build", "dist", ".git", ".pytest_cache"
+]
+
+# 文件后缀排除列表：匹配这些后缀的文件不会被打包
+exclude-exts = [
+    ".pyc", ".pyo", ".pyd", ".DS_Store", ".log", "Thumbs.db"
+]

ascript/windows/screen/__init__.py

@@ -0,0 +1,13 @@
+from .screen_core import Screen
+from .find_images import FindImages
+from .find_colors import FindColors
+from .color_algorithms import Colors, CompareColors, FindBlock
+from .canny import Canny
+from .code_scanner import CodeScanner
+from .ocr import Ocr, OCRItem, NullOCRItem
+from .ocrx import OcrX, OcrXResult
+
+__all__ = [
+    'Screen', 'FindImages', 'FindColors', 'CompareColors', 'Colors', 'FindBlock',
+    'Ocr', 'OCRItem', 'NullOCRItem', 'OcrX', 'OcrXResult', 'Canny', 'CodeScanner',
+]