ascript 1.3.27__py3-none-win_amd64.whl

ascript/__init__.py

@@ -0,0 +1,8 @@
+import sys
+
+# 1. 操作系统检查
+if sys.platform != "win32":
+    raise ImportError(f"Package 'your_package' is Windows-only. Current: {sys.platform}")
+
+# 2. 导出版本号（方便用户查看）
+__version__ = "1.3.27"

ascript/hooks/hook-ascript.py

@@ -0,0 +1,2 @@
+from PyInstaller.utils.hooks import collect_data_files
+datas = collect_data_files('ascript', include_py_files=False)

ascript/windows/__init__.py

@@ -0,0 +1,29 @@
+"""ascript.windows 模块 - Windows 平台自动化核心包。
+
+负责初始化 Windows 平台相关的路径配置和 RapidOCR Hook 注入。
+"""
+import os
+import sys
+
+# 获取当前 windows 目录的路径
+_current_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 关键：将 windows 目录加入搜索路径
+# 这样其下的子模块 license 就能直接 import 旁边的 pyarmor_runtime_000000
+if _current_dir not in sys.path:
+    sys.path.insert(0, _current_dir)
+
+
+try:
+    from ascript.windows.screen.ocr import rapidocr_hook
+    import rapidocr
+
+    # 检查是否已经挂钩
+    if not hasattr(rapidocr, 'find'):
+        rapidocr_hook.install()
+        # print("RapidOCR Hook 注入成功")
+except Exception as e:
+    # 捕获所有异常，确保主程序继续运行
+    # 你可以选择静默失败，或者只在日志里记录一下
+    # print(f"RapidOCR Hook 注入失败（非致命）: {e}")
+    pass

ascript/windows/daos/screen.py

@@ -0,0 +1,143 @@
+"""屏幕数据模型模块。
+
+定义屏幕操作中使用的基础数据结构，包括坐标点、颜色、尺寸和 OCR 识别结果。
+"""
+
+import json
+
+
+class Point:
+    """屏幕坐标点。
+
+    表示屏幕上的一个二维坐标点。
+    """
+
+    def __init__(self, x: int = 0, y: int = 0):
+        """初始化坐标点。
+
+        Args:
+            x: 横坐标，默认为 0。
+            y: 纵坐标，默认为 0。
+        """
+        self.x = x
+        self.y = y
+
+    def __str__(self):
+        """返回坐标点的 JSON 字符串表示。
+
+        Returns:
+            str: 包含 x 和 y 的 JSON 字符串，例如 '{"x": 100, "y": 200}'。
+        """
+        return json.dumps({'x': self.x, 'y': self.y})
+
+    def __repr__(self):
+        return f"Point(x={self.x}, y={self.y})"
+
+    def __iter__(self):
+        yield self.x
+        yield self.y
+
+    def __len__(self):
+        return 2
+
+    def __getitem__(self, index):
+        return (self.x, self.y)[index]
+
+    def __eq__(self, other):
+        if isinstance(other, Point):
+            return self.x == other.x and self.y == other.y
+        if isinstance(other, (tuple, list)) and len(other) == 2:
+            return self.x == other[0] and self.y == other[1]
+        return NotImplemented
+
+    def to_dict(self):
+        """将坐标点转换为字典。
+
+        Returns:
+            dict: 包含 'x' 和 'y' 键的字典。
+        """
+        return {'x': self.x, 'y': self.y}
+
+
+class Color:
+    """颜色值。
+
+    将十六进制颜色字符串解析为 RGB 分量。
+    """
+
+    def __init__(self, color: str):
+        """初始化颜色对象。
+
+        从十六进制颜色字符串（如 '#FF00AA'）中解析出 R、G、B 分量。
+
+        Args:
+            color: 十六进制颜色字符串，格式为 '#RRGGBB'。
+        """
+        self.r = int(color[1:3], 16)
+        self.g = int(color[3:5], 16)
+        self.b = int(color[5:], 16)
+
+    def to_rgb(self):
+        """将颜色转换为 RGB 列表。
+
+        Returns:
+            list: 包含 [R, G, B] 三个整数值的列表，每个值范围为 0-255。
+        """
+        return [self.r, self.g, self.b]
+
+
+class Size:
+    """尺寸大小。
+
+    表示宽度和高度的二维尺寸。
+    """
+
+    def __init__(self, width, height):
+        """初始化尺寸对象。
+
+        Args:
+            width: 宽度值。
+            height: 高度值。
+        """
+        self.width = width
+        self.height = height
+
+
+class OcrRes:
+    """OCR 识别结果。
+
+    封装单条 OCR 文字识别的结果，包括识别文本、置信度和区域位置信息。
+    """
+
+    def __init__(self, text: str = None, confidence: float = None, region_position: list = None):
+        """初始化 OCR 识别结果。
+
+        Args:
+            text: 识别出的文本内容。
+            confidence: 识别置信度，取值范围为 0.0 到 1.0。
+            region_position: 文本区域的四个顶点坐标列表，
+                格式为 [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]。
+        """
+        self.text = text
+        self.confidence = float(confidence)
+        self.region_position = region_position
+        if self.region_position:
+            self.center_x = region_position[2][0] - region_position[0][0]
+            self.center_y = region_position[2][1] - region_position[0][1]
+
+    def to_dict(self):
+        """将 OCR 结果转换为字典。
+
+        Returns:
+            dict: 包含 'text'、'confidence' 和 'region_position' 键的字典。
+        """
+        return {'text': self.text, 'confidence': self.confidence, 'region_position': self.region_position}
+
+    def __str__(self):
+        """返回 OCR 结果的字符串表示。
+
+        Returns:
+            str: OCR 结果字典的字符串形式。
+        """
+        return self.to_dict().__str__()
+

ascript/windows/hardware/__init__.py

@@ -0,0 +1,5 @@
+
+from .keyboard import Keyboard
+from .mouse import Mouse, MouseFailSafeError
+
+__all__ = ["Keyboard", "Mouse", "MouseFailSafeError"]

ascript/windows/hardware/keyboard.py

@@ -0,0 +1,279 @@
+"""Native Windows keyboard input based on the standard-library ctypes module."""
+
+import ctypes
+import math
+import threading
+import time
+from ctypes import wintypes
+from typing import List, Sequence, Tuple, Union
+
+from .mouse import Mouse
+
+_INPUT_KEYBOARD = 1
+_KEYEVENTF_EXTENDEDKEY = 0x0001
+_KEYEVENTF_KEYUP = 0x0002
+_KEYEVENTF_UNICODE = 0x0004
+
+
+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 _KEYBDINPUT(ctypes.Structure):
+    _fields_ = [("wVk", wintypes.WORD), ("wScan", wintypes.WORD),
+                ("dwFlags", wintypes.DWORD), ("time", wintypes.DWORD),
+                ("dwExtraInfo", ctypes.c_size_t)]
+
+
+class _HARDWAREINPUT(ctypes.Structure):
+    _fields_ = [("uMsg", wintypes.DWORD), ("wParamL", wintypes.WORD),
+                ("wParamH", wintypes.WORD)]
+
+
+class _INPUTUNION(ctypes.Union):
+    _fields_ = [("mi", _MOUSEINPUT), ("ki", _KEYBDINPUT), ("hi", _HARDWAREINPUT)]
+
+
+class _INPUT(ctypes.Structure):
+    _anonymous_ = ("union",)
+    _fields_ = [("type", wintypes.DWORD), ("union", _INPUTUNION)]
+
+
+_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
+_vk_key_scan = _user32.VkKeyScanW
+_vk_key_scan.argtypes = (wintypes.WCHAR,)
+_vk_key_scan.restype = ctypes.c_short
+
+
+_KEYS = {
+    "backspace": 0x08, "tab": 0x09, "clear": 0x0C, "enter": 0x0D,
+    "shift": 0x10, "ctrl": 0x11, "control": 0x11, "alt": 0x12,
+    "pause": 0x13, "capslock": 0x14, "esc": 0x1B, "escape": 0x1B,
+    "space": 0x20, "pgup": 0x21, "pageup": 0x21, "pgdn": 0x22,
+    "pagedown": 0x22, "end": 0x23, "home": 0x24, "left": 0x25,
+    "up": 0x26, "right": 0x27, "down": 0x28, "select": 0x29,
+    "print": 0x2A, "execute": 0x2B, "prtsc": 0x2C, "prtscr": 0x2C,
+    "prntscrn": 0x2C, "printscreen": 0x2C, "insert": 0x2D,
+    "ins": 0x2D, "delete": 0x2E, "del": 0x2E, "help": 0x2F,
+    "win": 0x5B, "super": 0x5B, "winleft": 0x5B, "winright": 0x5C,
+    "apps": 0x5D, "sleep": 0x5F, "multiply": 0x6A, "add": 0x6B,
+    "separator": 0x6C, "subtract": 0x6D, "decimal": 0x6E, "divide": 0x6F,
+    "numlock": 0x90, "scrolllock": 0x91, "shiftleft": 0xA0,
+    "shiftright": 0xA1, "ctrlleft": 0xA2, "ctrlright": 0xA3,
+    "altleft": 0xA4, "altright": 0xA5, "browserback": 0xA6,
+    "browserforward": 0xA7, "browserrefresh": 0xA8, "browserstop": 0xA9,
+    "browsersearch": 0xAA, "browserfavorites": 0xAB, "browserhome": 0xAC,
+    "volumemute": 0xAD, "volumedown": 0xAE, "volumeup": 0xAF,
+    "nexttrack": 0xB0, "prevtrack": 0xB1, "stop": 0xB2,
+    "playpause": 0xB3, "launchmail": 0xB4, "launchmediaselect": 0xB5,
+    "launchapp1": 0xB6, "launchapp2": 0xB7,
+}
+_KEYS.update({f"f{number}": 0x6F + number for number in range(1, 25)})
+_KEYS.update({f"num{number}": 0x60 + number for number in range(10)})
+
+_EXTENDED_KEYS = {
+    "right", "left", "up", "down", "home", "end", "pageup", "pgup",
+    "pagedown", "pgdn", "insert", "ins", "delete", "del", "printscreen",
+    "prtsc", "prtscr", "prntscrn", "win", "super", "winleft", "winright",
+    "apps", "ctrlright", "altright", "divide", "numlock",
+}
+_MODIFIER_VKS = ((0x01, 0x10), (0x02, 0x11), (0x04, 0x12))
+
+
+class Keyboard:
+    """Chainable native keyboard controller for Windows."""
+
+    FAILSAFE = True
+    _lock = threading.RLock()
+    _held = {}
+
+    @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
+
+    @staticmethod
+    def _normalize_key(key: str) -> str:
+        if not isinstance(key, str):
+            raise TypeError("key must be a string")
+        if not key:
+            raise ValueError("key must not be empty")
+        aliases = {"\n": "enter", "\r": "enter", "\t": "tab", "\b": "backspace"}
+        return aliases.get(key, key.lower() if len(key) > 1 else key)
+
+    @classmethod
+    def _fail_safe_check(cls) -> None:
+        if cls.FAILSAFE:
+            Mouse._fail_safe_check()
+
+    @classmethod
+    def _emit(cls, vk: int = 0, scan: int = 0, flags: int = 0, check: bool = True) -> None:
+        if check:
+            cls._fail_safe_check()
+        event = _INPUT(type=_INPUT_KEYBOARD, ki=_KEYBDINPUT(
+            wVk=vk, wScan=scan, 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 _resolve(cls, key: str) -> Tuple[str, List[Tuple[int, int]]]:
+        token = cls._normalize_key(key)
+        if token in _KEYS:
+            flags = _KEYEVENTF_EXTENDEDKEY if token in _EXTENDED_KEYS else 0
+            return token, [(_KEYS[token], flags)]
+        if len(token) != 1:
+            raise ValueError(f"unsupported key: {key}")
+        code = int(_vk_key_scan(token))
+        if code == -1:
+            raise ValueError(f"the current keyboard layout cannot type: {key!r}")
+        vk, modifiers = code & 0xFF, (code >> 8) & 0xFF
+        events = [(modifier_vk, 0) for mask, modifier_vk in _MODIFIER_VKS if modifiers & mask]
+        events.append((vk, 0))
+        return token, events
+
+    @classmethod
+    def _press_events(cls, events: Sequence[Tuple[int, int]], check: bool = True) -> None:
+        pressed = []
+        try:
+            for vk, flags in events:
+                cls._emit(vk=vk, flags=flags, check=check)
+                pressed.append((vk, flags))
+        except Exception:
+            cls._release_events(pressed)
+            raise
+
+    @classmethod
+    def _release_events(cls, events: Sequence[Tuple[int, int]]) -> None:
+        for vk, flags in reversed(events):
+            cls._emit(vk=vk, flags=flags | _KEYEVENTF_KEYUP, check=False)
+
+    @classmethod
+    def _unicode_units(cls, text: str) -> List[int]:
+        encoded = text.encode("utf-16-le", errors="surrogatepass")
+        return [int.from_bytes(encoded[index:index + 2], "little")
+                for index in range(0, len(encoded), 2)]
+
+    @classmethod
+    def _type_character(cls, character: str) -> None:
+        if character in ("\r", "\n", "\t", "\b"):
+            cls._press_and_release(cls._normalize_key(character))
+            return
+        for unit in cls._unicode_units(character):
+            cls._emit(scan=unit, flags=_KEYEVENTF_UNICODE)
+            cls._emit(scan=unit, flags=_KEYEVENTF_UNICODE | _KEYEVENTF_KEYUP, check=False)
+
+    @classmethod
+    def _press_and_release(cls, key: str) -> None:
+        _, events = cls._resolve(key)
+        cls._press_events(events)
+        try:
+            pass
+        finally:
+            cls._release_events(events)
+
+    @classmethod
+    def input(cls, msg: str, interval: float = 0.0):
+        """Type Unicode text without using the clipboard or active input method."""
+        if not isinstance(msg, str):
+            raise TypeError("msg must be a string")
+        interval = cls._duration(interval, "interval")
+        with cls._lock:
+            for index, character in enumerate(msg):
+                cls._type_character(character)
+                if index + 1 < len(msg) and interval:
+                    time.sleep(interval)
+        return cls
+
+    @classmethod
+    def key(cls, keys: Union[str, List[str]], presses: int = 1, interval: float = 0.1):
+        """Press and release one key or a sequence of keys."""
+        if isinstance(keys, str):
+            sequence = [keys]
+        elif isinstance(keys, (list, tuple)) and all(isinstance(key, str) for key in keys):
+            sequence = list(keys)
+        else:
+            raise TypeError("keys must be a string or a list of strings")
+        if not sequence:
+            raise ValueError("keys must not be empty")
+        if not isinstance(presses, int) or isinstance(presses, bool):
+            raise TypeError("presses must be an integer")
+        if presses < 1:
+            raise ValueError("presses must be at least one")
+        interval = cls._duration(interval, "interval")
+        with cls._lock:
+            count = presses * len(sequence)
+            current = 0
+            for _ in range(presses):
+                for key in sequence:
+                    cls._press_and_release(key)
+                    current += 1
+                    if current < count and interval:
+                        time.sleep(interval)
+        return cls
+
+    @classmethod
+    def key_hot(cls, *args: str, interval: float = 0.1):
+        """Hold keys in order and release them in reverse order."""
+        if not args:
+            raise ValueError("at least one key is required")
+        interval = cls._duration(interval, "interval")
+        pressed = []
+        with cls._lock:
+            try:
+                for index, key in enumerate(args):
+                    _, events = cls._resolve(key)
+                    cls._press_events(events)
+                    pressed.append(events)
+                    if index + 1 < len(args) and interval:
+                        time.sleep(interval)
+            finally:
+                for index, events in enumerate(reversed(pressed)):
+                    cls._release_events(events)
+                    if index + 1 < len(pressed) and interval:
+                        time.sleep(interval)
+        return cls
+
+    @classmethod
+    def key_down(cls, key_str: str):
+        """Press a key and keep it held until key_up() or release_all()."""
+        with cls._lock:
+            token, events = cls._resolve(key_str)
+            if token not in cls._held:
+                cls._press_events(events)
+                cls._held[token] = events
+        return cls
+
+    @classmethod
+    def key_up(cls, key_str: str):
+        """Release a key previously held by key_down()."""
+        with cls._lock:
+            token = cls._normalize_key(key_str)
+            events = cls._held.pop(token, None)
+            if events is None:
+                _, events = cls._resolve(key_str)
+            cls._release_events(events)
+        return cls
+
+    @classmethod
+    def release_all(cls):
+        """Release every key held through key_down(), even during fail-safe recovery."""
+        with cls._lock:
+            held = list(cls._held.values())
+            cls._held.clear()
+            for events in reversed(held):
+                cls._release_events(events)
+        return cls
+
+    @classmethod
+    def wait(cls, seconds: float):
+        time.sleep(cls._duration(seconds, "seconds"))
+        return cls

ascript/windows/hardware/logitech_driver.py

@@ -0,0 +1,179 @@
+import ctypes
+import time
+import sys
+import os
+from ..system import R
+
+
+class LogitechDriver:
+    """罗技驱动级硬件操作类。
+
+    通过加载罗技 G HUB SDK 的 DLL，实现驱动级别的鼠标点击和移动操作。
+    需要系统已安装并运行罗技 G HUB 驱动程序。
+    支持 x86 和 x64 架构自动适配。
+
+    Attributes:
+        DLL_NAME: 罗技 SDK DLL 文件名。
+        _dll: 已加载的 DLL 对象实例。
+        _initialized: 驱动是否已完成初始化。
+    """
+
+    DLL_NAME = "LogitechGkeyEnginesWrapper.dll"
+
+    _dll = None
+    _initialized = False
+
+    @classmethod
+    def _get_dll_path(cls):
+        """根据当前 Python 解释器的位数定位对应架构的 DLL 文件路径。
+
+        Returns:
+            str: DLL 文件的完整路径。
+        """
+        arch = "x64" if sys.maxsize > 2 ** 32 else "x86"
+        return R.internal("windows", "resources", "libs", "logitech", arch, cls.DLL_NAME)
+
+    @classmethod
+    def _is_ghub_running(cls) -> bool:
+        """检测罗技 G HUB 进程是否正在运行。
+
+        通过 tasklist 命令检查 lghub.exe、lghub_agent.exe、lghub_updater.exe
+        等进程是否存在。
+
+        Returns:
+            bool: G HUB 正在运行返回 True，否则返回 False。
+        """
+        try:
+            # 罗技 G HUB 可能存在于这三个进程中
+            targets = {"lghub.exe", "lghub_agent.exe", "lghub_updater.exe"}
+            with os.popen('tasklist /NH /FI "STATUS eq running"') as f:
+                output = f.read().lower()
+            return any(t in output for t in targets)
+        except:
+            return False
+
+    @classmethod
+    def init(cls) -> bool:
+        """初始化罗技驱动。
+
+        执行环境检查（G HUB 进程、DLL 文件），加载 DLL 并尝试调用
+        SDK 初始化函数。初始化成功后会等待 0.5 秒确保驱动就绪。
+        重复调用时若已初始化会直接返回 True。
+
+        Returns:
+            bool: 初始化成功返回 True，失败返回 False。
+        """
+        if cls._initialized:
+            return True
+
+        # 1. 环境检查
+        if not cls._is_ghub_running():
+            print("[LogitechDriver] 错误: 未检测到 G HUB 进程，请确保罗技驱动已启动。")
+            return False
+
+        dll_path = cls._get_dll_path()
+        if not os.path.exists(dll_path):
+            print(f"[LogitechDriver] 错误: 找不到 DLL -> {dll_path}")
+            return False
+
+        try:
+            # 2. 加载 DLL 并强制使用 Windows 路径标准
+            cls._dll = ctypes.CDLL(dll_path)
+
+            # 3. 尝试所有可能的初始化导出函数
+            # 罗技 SDK 随版本变化，函数名可能为以下其一
+            init_functions = [
+                "LogiGkeyInitWithoutContext",
+                "LogiGkeyInit",
+                "LogiGkeyInitWithoutScene"
+            ]
+
+            success = False
+            for func_name in init_functions:
+                if hasattr(cls._dll, func_name):
+                    if getattr(cls._dll, func_name)():
+                        success = True
+                        break
+
+            if success:
+                # [关键] 驱动初始化后必须等待，否则紧随其后的指令会丢失
+                time.sleep(0.5)
+                cls._initialized = True
+                return True
+
+            return False
+        except Exception as e:
+            print(f"[LogitechDriver] 加载异常: {e}")
+            return False
+
+    @classmethod
+    def advanced_click_guide(cls):
+        """高级引导：检查运行权限与驱动环境。
+
+        检查当前是否以管理员权限运行，并尝试激活驱动模式。
+        在控制台输出检查结果供用户排查问题。
+
+        Returns:
+            bool: 驱动激活成功返回 True，失败返回 False。
+        """
+        print("--- [Logitech] 底层引擎自检 ---")
+
+        # 管理员权限检查
+        try:
+            is_admin = ctypes.windll.shell32.IsUserAnAdmin() != 0
+        except:
+            is_admin = False
+
+        if not is_admin:
+            print("⚠️ 注意: 当前非管理员权限，这可能是点击无效的主因！")
+
+        if cls.init():
+            print("✅ 驱动模式已激活。")
+            return True
+        else:
+            print("❌ 驱动激活失败，请检查 G HUB 是否正常运行。")
+            return False
+
+    @classmethod
+    def click(cls, button: int = 1, duration: float = 0.05):
+        """执行驱动级鼠标点击。
+
+        通过罗技 SDK 直接发送鼠标按键事件，可绕过部分反作弊检测。
+
+        Args:
+            button: 鼠标按键编号，1=左键，2=中键，4=右键（SDK 定义）。
+            duration: 按下与释放之间的间隔时间（秒），默认为 0.05。
+
+        Returns:
+            bool: 点击成功返回 True，失败（驱动未初始化或异常）返回 False。
+        """
+        if not cls.init():
+            return False
+        try:
+            cls._dll.LogiMouseButtonPressed(button)
+            time.sleep(duration)
+            cls._dll.LogiMouseButtonReleased(button)
+            return True
+        except:
+            return False
+
+    @classmethod
+    def move_rel(cls, x: int, y: int):
+        """驱动级鼠标相对位移。
+
+        通过罗技 SDK 发送鼠标相对移动事件。
+
+        Args:
+            x: 水平方向的相对位移量（像素）。
+            y: 垂直方向的相对位移量（像素）。
+
+        Returns:
+            bool: 移动成功返回对应的 SDK 返回值，失败返回 False。
+        """
+        if not cls.init():
+            return False
+        try:
+            # 罗技相对移动
+            return cls._dll.LogiMouseRelativeMove(int(x), int(y))
+        except:
+            return False