ascript 1.3.27__py3-none-win_amd64.whl

ascript/windows/tools/tool_window.py

@@ -0,0 +1,56 @@
+from ..system import R
+from ..ui.web_window import WebWindow
+from .tool_api import ToolApi
+
+
+TOOL_TITLES = {
+    "inspector": "AScript 控件检索",
+    "colors": "AScript 图色工具",
+}
+
+
+class SDKToolWindow(WebWindow):
+    def __init__(self, tool: str, hwnd=None):
+        if tool not in TOOL_TITLES:
+            raise ValueError(f"未知工具: {tool}")
+        html_path = R.internal("windows", "tools", "webview", "index.html")
+        super().__init__(html_path)
+        self.tool = tool
+        self.api = ToolApi(tool, hwnd)
+        for name in (
+            "get_context", "get_windows", "inspect_window", "capture", "load_image", "get_pixel_color", "test_selector",
+            "test_selector_spec",
+            "find_colors", "compare_colors", "count_colors", "find_blocks", "find_images",
+            "list_image_templates", "add_image_template", "import_image_template",
+            "rename_image_template", "delete_image_template", "clear_image_templates",
+            "save_image_templates", "list_project_images", "add_project_image_template",
+            "run_ocr", "run_ocrx", "run_canny", "scan_codes",
+            "save_capture", "open_capture_folder",
+            "list_capture_cache", "load_cached_capture", "delete_capture_cache", "clear_capture_cache",
+        ):
+            self.expose(getattr(self.api, name))
+
+    def show(self, **kwargs):
+        defaults = {
+            "title": TOOL_TITLES[self.tool],
+            "width": 1180,
+            "height": 760,
+            "min_size": (820, 560),
+            "background_color": "#171a1c",
+            "bring_to_front": True,
+            "exclude_from_capture": self.tool == "colors",
+        }
+        defaults.update(kwargs)
+        return super().show(**defaults)
+
+
+def start_tool(tool: str, hwnd=None, **kwargs):
+    return SDKToolWindow(tool, hwnd=hwnd).show(**kwargs)
+
+
+def start_inspector(hwnd=None, **kwargs):
+    return start_tool("inspector", hwnd=hwnd, **kwargs)
+
+
+def start_colors(hwnd=None, **kwargs):
+    return start_tool("colors", hwnd=hwnd, **kwargs)

ascript/windows/tools/uia_worker.py

@@ -0,0 +1,365 @@
+"""Crash- and hang-isolated UI Automation worker for the inspector."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import sys
+
+
+RESULT_PREFIX = "ASCRIPT_UIA_RESULT="
+
+
+def _count_nodes(node):
+    return 1 + sum(_count_nodes(child) for child in node.get("children", []))
+
+
+def _tag_source_and_offset(
+    node, source_hwnd: int, offset_x: int = 0, offset_y: int = 0,
+    source_class_name: str = "",
+):
+    """Keep enough origin information for overlays and generated selectors."""
+    node["source_hwnd"] = int(source_hwnd)
+    node["source_class_name"] = source_class_name
+    rect = node.get("rect")
+    if rect:
+        rect["left"] += offset_x
+        rect["right"] += offset_x
+        rect["top"] += offset_y
+        rect["bottom"] += offset_y
+    for child in node.get("children", []):
+        _tag_source_and_offset(child, source_hwnd, offset_x, offset_y, source_class_name)
+
+
+def _renderer_documents(target, data, depth: int):
+    """Read Chromium/Electron web content from its renderer child HWND.
+
+    Chromium does not expose the active document below the top-level browser
+    HWND in Raw View. ElementFromHandle on Chrome_RenderWidgetHostHWND does.
+    """
+    import win32gui
+    from ..window import Selector, Window
+
+    handles = []
+    win32gui.EnumChildWindows(target.hwnd, lambda child, output: output.append(child), handles)
+    renderer_handles = []
+    for child in handles:
+        try:
+            if win32gui.GetClassName(child) == "Chrome_RenderWidgetHostHWND" and win32gui.IsWindowVisible(child):
+                renderer_handles.append(child)
+        except Exception:
+            continue
+    if not renderer_handles:
+        return 0
+
+    main_client = target.client_rect
+    existing_documents = set()
+
+    def collect_documents(node):
+        if node.get("type") == "DocumentControl":
+            rect = node.get("rect") or {}
+            existing_documents.add((
+                node.get("name") or "",
+                rect.get("left"), rect.get("top"), rect.get("right"), rect.get("bottom"),
+            ))
+        for child in node.get("children", []):
+            collect_documents(child)
+
+    collect_documents(data)
+
+    def remove_document(node, key):
+        children = node.get("children", [])
+        for index, child in enumerate(children):
+            rect = child.get("rect") or {}
+            child_key = (
+                child.get("name") or "",
+                rect.get("left"), rect.get("top"), rect.get("right"), rect.get("bottom"),
+            )
+            if child.get("type") == "DocumentControl" and child_key == key:
+                children.pop(index)
+                node["child_count"] = len(children)
+                return True
+            if remove_document(child, key):
+                return True
+        return False
+    added = 0
+    for child_hwnd in renderer_handles:
+        try:
+            renderer_window = Window(child_hwnd)
+            renderer_root = Selector(renderer_window, depth=depth).get_uielement_tree()
+            if not renderer_root:
+                continue
+            renderer_data = renderer_root.to_dict()
+            documents = [child for child in renderer_data.get("children", [])
+                         if child.get("type") == "DocumentControl"]
+            if not documents:
+                continue
+            renderer_client = renderer_window.client_rect
+            offset_x = renderer_client.left - main_client.left
+            offset_y = renderer_client.top - main_client.top
+            for document in documents:
+                _tag_source_and_offset(
+                    document, child_hwnd, offset_x, offset_y,
+                    win32gui.GetClassName(child_hwnd),
+                )
+                rect = document.get("rect") or {}
+                key = (
+                    document.get("name") or "",
+                    rect.get("left"), rect.get("top"), rect.get("right"), rect.get("bottom"),
+                )
+                if key in existing_documents:
+                    remove_document(data, key)
+                existing_documents.add(key)
+                document["depth"] = 1
+                data.setdefault("children", []).append(document)
+                added += _count_nodes(document)
+        except Exception:
+            continue
+    data["child_count"] = len(data.get("children", []))
+    return added
+
+
+def inspect_window(hwnd: int, depth: int):
+    from ..window import Selector, Window
+    import uiautomation as auto
+
+    with auto.UIAutomationInitializerInThread():
+        target = Window(hwnd)
+        selector = Selector(target, depth=depth if depth > 0 else 30)
+        root = selector.get_uielement_tree()
+        if not root:
+            return {"status": "empty", "message": "目标窗口未暴露 UIA 控件"}
+        data = root.to_dict()
+        _tag_source_and_offset(data, target.hwnd, source_class_name=target.class_name)
+        renderer_count = _renderer_documents(target, data, depth)
+        count = _count_nodes(data)
+        if count <= 1:
+            return {"status": "empty", "message": "目标窗口只暴露了 UIA 根节点"}
+        return {
+            "status": "success",
+            "backend": "UI Automation Raw View" + (" + Chromium Renderer" if renderer_count else ""),
+            "node_count": count,
+            "message": f"已从浏览器渲染进程补充 {renderer_count} 个网页控件" if renderer_count else "",
+            "data": data,
+        }
+
+
+FILTER_METHODS = {
+    "name", "type", "class_name", "res_id", "value", "description", "handle",
+    "enabled", "visible", "clickable", "password", "child_count", "depth",
+    "checkable", "checked", "editable", "focusable", "focused", "selected", "node_depth",
+}
+RELATION_METHODS = {"child", "parent", "brother"}
+ACTION_METHODS = {"click", "input"}
+TERMINAL_METHODS = {"find", "find_first", "find_all"}
+WINDOW_FIND_ARGUMENTS = {"title_re", "process_name", "class_name", "visible_only", "timeout"}
+CHILD_FIND_ARGUMENTS = {"title_re", "class_name", "visible_only", "timeout"}
+SELECTOR_APP_ARGUMENTS = {"title_re", "class_name", "content", "timeout", "depth"}
+SELECTOR_INIT_ARGUMENTS = {
+    "app", "title_re", "class_name", "content", "timeout", "depth",
+}
+
+
+def _literal(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, (str, int, float, bool, type(None))):
+        return node.value
+    raise ValueError("Selector 参数只允许字符串、数字、布尔值或 None")
+
+
+def _evaluate_legacy_selector(expression: str):
+    """Evaluate the old generated syntax without executing arbitrary Python."""
+    from ..window import Selector, Window
+
+    def evaluate(node):
+        if not isinstance(node, ast.Call):
+            raise ValueError("只支持 Selector 链式调用")
+        if isinstance(node.func, ast.Name) and node.func.id == "Window":
+            if len(node.args) != 1 or node.keywords:
+                raise ValueError("Window 只接受一个 HWND")
+            return Window(int(_literal(node.args[0])))
+        if isinstance(node.func, ast.Name) and node.func.id == "Selector":
+            if node.args:
+                raise ValueError("Selector 请使用关键字参数")
+            if any(item.arg is None for item in node.keywords):
+                raise ValueError("Selector 不支持展开关键字参数")
+            names = {item.arg for item in node.keywords}
+            allowed = SELECTOR_INIT_ARGUMENTS | {"window"}
+            if names - allowed or len(names) != len(node.keywords):
+                raise ValueError("Selector 包含不支持或重复的参数")
+            if "window" in names and len(names) != 1:
+                raise ValueError("window 不能与应用定位参数同时使用")
+            values = {
+                item.arg: evaluate(item.value) if item.arg == "window" else _literal(item.value)
+                for item in node.keywords
+            }
+            return Selector(**values)
+        if not isinstance(node.func, ast.Attribute):
+            raise ValueError("非法 Selector 表达式")
+        if isinstance(node.func.value, ast.Name) and node.func.value.id == "Selector" and node.func.attr == "app":
+            if len(node.args) > 1:
+                raise ValueError("Selector.app 最多接受一个位置参数")
+            kwargs = {item.arg: _literal(item.value) for item in node.keywords if item.arg}
+            if len(kwargs) != len(node.keywords) or set(kwargs) - SELECTOR_APP_ARGUMENTS:
+                raise ValueError("Selector.app 包含不支持的参数")
+            process_name = _literal(node.args[0]) if node.args else None
+            return Selector.app(process_name, **kwargs)
+        if isinstance(node.func.value, ast.Name) and node.func.value.id == "Window" and node.func.attr == "find":
+            if node.args:
+                raise ValueError("Window.find 请使用关键字参数")
+            kwargs = {item.arg: _literal(item.value) for item in node.keywords if item.arg}
+            if len(kwargs) != len(node.keywords) or set(kwargs) - WINDOW_FIND_ARGUMENTS:
+                raise ValueError("Window.find 包含不支持的参数")
+            window = Window.find(**kwargs)
+            if window is None:
+                raise ValueError("未找到目标窗口")
+            return window
+        target = evaluate(node.func.value)
+        method = node.func.attr
+        if isinstance(target, Window) and method == "find_child":
+            if node.args:
+                raise ValueError("find_child 请使用关键字参数")
+            kwargs = {item.arg: _literal(item.value) for item in node.keywords if item.arg}
+            if len(kwargs) != len(node.keywords) or set(kwargs) - CHILD_FIND_ARGUMENTS:
+                raise ValueError("find_child 包含不支持的参数")
+            child = target.find_child(**kwargs)
+            if child is None:
+                raise ValueError("未找到目标内容窗口")
+            return child
+        if method not in FILTER_METHODS | RELATION_METHODS | ACTION_METHODS | TERMINAL_METHODS:
+            raise ValueError(f"不支持的方法: {method}")
+        if node.keywords:
+            raise ValueError("Selector 表达式暂不支持关键字参数")
+        args = [_literal(item) for item in node.args]
+        return getattr(target, method)(*args)
+
+    parsed = ast.parse(expression.strip(), mode="eval")
+    return evaluate(parsed.body)
+
+
+def _serialize_results(values, source_window, display_window):
+    data = [item.to_dict() for item in values]
+    offset_x = offset_y = 0
+    if source_window.hwnd != display_window.hwnd:
+        source_rect = source_window.client_rect
+        display_rect = display_window.client_rect
+        offset_x = source_rect.left - display_rect.left
+        offset_y = source_rect.top - display_rect.top
+    for item in data:
+        _tag_source_and_offset(
+            item, source_window.hwnd, offset_x, offset_y,
+            source_window.class_name,
+        )
+    return data
+
+
+def _resolve_window_locator(locator):
+    from ..window import Window
+
+    if isinstance(locator, int) and not isinstance(locator, bool):
+        window = Window(locator)
+        return window, window
+    if not isinstance(locator, dict):
+        raise ValueError("window 必须是窗口定位对象")
+    allowed = WINDOW_FIND_ARGUMENTS | {"child_class_name"}
+    unknown = set(locator) - allowed
+    if unknown:
+        raise ValueError(f"不支持的窗口定位属性: {', '.join(sorted(unknown))}")
+    find_args = {key: value for key, value in locator.items() if key in WINDOW_FIND_ARGUMENTS}
+    if not any(find_args.get(key) for key in ("title_re", "process_name", "class_name")):
+        raise ValueError("窗口定位至少需要 title_re、process_name 或 class_name")
+    find_args.setdefault("timeout", 10)
+    root_window = Window.find(**find_args)
+    if root_window is None:
+        raise ValueError("未找到目标窗口，请检查进程名、窗口类名或标题")
+    source_window = root_window
+    child_class_name = locator.get("child_class_name")
+    if child_class_name:
+        source_window = root_window.find_child(
+            class_name=str(child_class_name), visible_only=True,
+            timeout=float(find_args.get("timeout") or 0),
+        )
+        if source_window is None:
+            raise ValueError(f"未找到内容窗口: {child_class_name}")
+    return root_window, source_window
+
+
+def test_selector_spec(spec):
+    from ..window import Selector
+    import uiautomation as auto
+
+    if not isinstance(spec, dict):
+        raise ValueError("Selector spec 必须是对象")
+    display_window, source_window = _resolve_window_locator(spec.get("window"))
+    steps = spec.get("steps")
+    if not isinstance(steps, list) or not steps:
+        raise ValueError("Selector 至少需要一个步骤")
+    mode = spec.get("mode", "first")
+    if mode not in ("first", "all"):
+        raise ValueError("mode 只允许 first 或 all")
+
+    with auto.UIAutomationInitializerInThread():
+        selector = Selector(source_window, depth=max(1, min(int(spec.get("depth") or 30), 50)))
+        for index, step in enumerate(steps):
+            if not isinstance(step, dict):
+                raise ValueError(f"第 {index + 1} 个步骤格式错误")
+            method = step.get("method")
+            filters = step.get("filters", {})
+            if not isinstance(filters, dict):
+                raise ValueError(f"第 {index + 1} 个步骤 filters 必须是对象")
+            unknown = set(filters) - FILTER_METHODS
+            if unknown:
+                raise ValueError(f"不支持的属性: {', '.join(sorted(unknown))}")
+            if method in RELATION_METHODS:
+                getattr(selector, method)(step.get("param"))
+            elif method == "find":
+                if index and selector._current_filters:
+                    selector._flush_to_step()
+            elif method == "action":
+                action = step.get("action")
+                if action not in ACTION_METHODS:
+                    raise ValueError(f"不支持的动作: {action}")
+                getattr(selector, action)(step.get("param") if action == "input" else bool(step.get("param", False)))
+            else:
+                raise ValueError(f"不支持的步骤: {method}")
+            for name, value in filters.items():
+                getattr(selector, name)(value)
+
+        result = selector.find_all() if mode == "all" else selector.find()
+        values = [] if result is None else result if isinstance(result, list) else [result]
+        return {"status": "success", "data": _serialize_results(values, source_window, display_window)}
+
+
+def test_selector(expression: str):
+    import uiautomation as auto
+
+    with auto.UIAutomationInitializerInThread():
+        result = _evaluate_legacy_selector(expression)
+        if hasattr(result, "find"):
+            result = result.find()
+        values = [] if result is None else result if isinstance(result, list) else [result]
+        source_window = values[0].window if values else None
+        data = _serialize_results(values, source_window, source_window) if source_window else []
+        return {"status": "success", "data": data}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=("inspect", "test", "test-spec"))
+    parser.add_argument("--hwnd", type=int)
+    parser.add_argument("--depth", type=int, default=0)
+    args = parser.parse_args()
+    try:
+        if args.action == "inspect":
+            result = inspect_window(args.hwnd, args.depth)
+        elif args.action == "test":
+            result = test_selector(sys.stdin.read())
+        else:
+            result = test_selector_spec(json.loads(sys.stdin.read()))
+    except Exception as exc:
+        result = {"status": "error", "message": str(exc), "data": []}
+    print(RESULT_PREFIX + json.dumps(result, ensure_ascii=False, separators=(",", ":")), flush=True)
+
+
+if __name__ == "__main__":
+    main()