ascript 1.3.27__py3-none-win_amd64.whl

ascript/windows/screen/ocr/rapidocr_hook.py

@@ -0,0 +1,301 @@
+import sys
+import re
+import importlib.abc
+import importlib.util
+import importlib
+from dataclasses import dataclass, asdict
+from typing import List, Optional, Tuple, Union, TYPE_CHECKING
+
+# 假设你的硬件操作模块路径如下
+from ...hardware.mouse import Mouse
+
+# --- 1. 类型存根 (仅用于 PyCharm 等 IDE 的代码补全提示) ---
+if TYPE_CHECKING:
+    try:
+        from rapidocr.utils.output import RapidOCROutput as BaseOutput
+    except ImportError:
+        class BaseOutput:
+            pass
+
+
+    class RapidOCROutput(BaseOutput):
+        """RapidOCR 输出结果的类型存根（仅用于 IDE 代码补全提示）。
+
+        声明 find 和 find_all 方法签名，使 IDE 能正确提示动态注入的方法。
+        """
+
+        def find(self, text_re: str = None, score: float = 0.85) -> 'OCRItem': ...
+
+        def find_all(self, text_re: str = None, score: float = 0.85) -> List['OCRItem']: ...
+
+
+# --- 2. 核心结果对象定义 ---
+
+@dataclass
+class OCRItem:
+    """OCR 单条识别结果的数据封装类。
+
+    封装一条文字识别结果的完整信息，支持直接点击识别到的文字位置。
+
+    Attributes:
+        txt: 识别出的文本内容。
+        box: 文字区域的四个顶点坐标，格式为 [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]。
+        score: 识别置信度，范围 0.0 ~ 1.0。
+        center: 文字区域的中心点坐标 (x, y)。
+        rect: 文字区域的外接矩形 [left, top, right, bottom]。
+    """
+
+    txt: str
+    box: List[List[float]]
+    score: float
+    center: Tuple[int, int]
+    rect: List[int]
+
+    def click(self, window=None):
+        """点击该识别结果所在的位置。
+
+        Args:
+            window: 可选的 Window 对象。传入时调用 window.click() 进行窗口内相对坐标点击；
+                不传时调用全局 Mouse.click() 进行屏幕绝对坐标点击。
+
+        Returns:
+            OCRItem: 返回自身，支持链式调用。
+        """
+        x, y = self.center
+        if window:
+            # 让窗口对象处理相对坐标点击
+            window.click(x, y)
+        else:
+            # 全屏绝对点击
+            Mouse.click(x, y)
+        return self
+
+    def to_dict(self) -> dict:
+        """将识别结果转换为字典格式。
+
+        Returns:
+            dict: 包含 txt、box、score、center、rect 等字段的字典。
+        """
+        return {
+            **asdict(self),
+            "text": self.txt,
+            "confidence": self.score,
+            "center_x": int(self.center[0]),
+            "center_y": int(self.center[1]),
+        }
+
+    @property
+    def text(self):
+        return self.txt
+
+    @property
+    def confidence(self):
+        return self.score
+
+    def __bool__(self):
+        """支持布尔判断，OCRItem 实例始终为 True。
+
+        Returns:
+            bool: 始终返回 True，表示存在有效识别结果。
+        """
+        return True
+
+    def __repr__(self):
+        """返回 OCRItem 的可读字符串表示。
+
+        Returns:
+            str: 包含文本、置信度和中心坐标的描述字符串。
+        """
+        return f"<OCRItem txt='{self.txt}' score={self.score:.2f} center={self.center}>"
+
+
+class NullOCRItem:
+    """空 OCR 结果对象（空对象模式）。
+
+    当 find 方法未找到匹配结果时返回此对象，防止链式调用因 None 而报错。
+    所有属性均为默认空值，布尔值为 False。
+    """
+
+    def __init__(self):
+        """初始化空 OCR 结果，所有属性设为默认空值。"""
+        self.txt, self.box, self.score = "", [], 0.0
+        self.center, self.rect = (0, 0), [0, 0, 0, 0]
+
+    def click(self, window=None):
+        """静默处理点击操作，不执行任何动作。
+
+        Args:
+            window: 忽略此参数。
+
+        Returns:
+            NullOCRItem: 返回自身，支持链式调用。
+        """
+        return self
+
+    def to_dict(self) -> dict:
+        """转换为空字典。
+
+        Returns:
+            dict: 空字典。
+        """
+        return {}
+
+    @property
+    def text(self):
+        return ""
+
+    @property
+    def confidence(self):
+        return 0.0
+
+    def __bool__(self):
+        """支持布尔判断，NullOCRItem 始终为 False。
+
+        Returns:
+            bool: 始终返回 False，表示未找到结果。
+        """
+        return False
+
+    def __repr__(self):
+        """返回 NullOCRItem 的可读字符串表示。
+
+        Returns:
+            str: 空结果的描述字符串。
+        """
+        return "<NullOCRItem (Not Found)>"
+
+
+# --- 3. 运行时 Hook 逻辑 ---
+
+class RapidOCRHook(importlib.abc.MetaPathFinder):
+    """RapidOCR 运行时 Hook，动态注入 find/find_all 扩展方法。
+
+    通过 Python 的 MetaPathFinder 机制拦截 rapidocr.utils.output 模块的导入，
+    在其 RapidOCROutput 类上注入 find() 和 find_all() 方法，
+    使 OCR 结果对象直接支持文字搜索和定位功能。
+    """
+
+    def find_spec(self, fullname, path, target=None):
+        """拦截模块导入，在目标模块加载时注入扩展方法。
+
+        Args:
+            fullname: 正在导入的模块全名。
+            path: 模块搜索路径。
+            target: 目标模块对象（可选）。
+
+        Returns:
+            ModuleSpec: 当拦截到目标模块时返回其 spec，否则返回 None。
+        """
+        # 监听 RapidOCR 的核心输出模块
+        if fullname == "rapidocr.utils.output":
+            importlib.invalidate_caches()  # 动态感知新安装的包
+            try:
+                spec = importlib.util.find_spec(fullname)
+                if spec is None: return None
+
+                if self in sys.meta_path:
+                    sys.meta_path.remove(self)
+
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                self._patch(module)
+                sys.modules[fullname] = module
+                return spec
+            except Exception:
+                return None
+        return None
+
+    def _patch(self, module):
+        """向目标模块的 RapidOCROutput 类动态注入 find 和 find_all 方法。
+
+        Args:
+            module: 已加载的 rapidocr.utils.output 模块对象。
+        """
+
+        def _build_item(txt, box, score) -> OCRItem:
+            """根据原始 OCR 数据构建 OCRItem 结果对象。
+
+            Args:
+                txt: 识别出的文本内容。
+                box: 文字区域的四个顶点坐标数组。
+                score: 识别置信度。
+
+            Returns:
+                OCRItem: 封装好的识别结果对象。
+            """
+            l, t = float(box[0][0]), float(box[0][1])
+            r, b = float(box[2][0]), float(box[2][1])
+            center = (int((l + r) / 2), int((t + b) / 2))
+            rect = [int(l), int(t), int(r), int(b)]
+            return OCRItem(
+                txt=str(txt),
+                box=box.tolist() if hasattr(box, 'tolist') else box,
+                score=float(score),
+                center=center,
+                rect=rect
+            )
+
+        def find(self, text_re: str = None, score: float = 0.85) -> Union[OCRItem, NullOCRItem]:
+            """在 OCR 识别结果中查找第一个匹配的文本。
+
+            Args:
+                text_re: 正则表达式模式，用于匹配文本内容。为 None 时匹配所有文本。
+                score: 最低置信度阈值，默认为 0.85。
+
+            Returns:
+                Union[OCRItem, NullOCRItem]: 匹配到的结果对象，未找到时返回 NullOCRItem。
+            """
+            txts, boxes, scores = getattr(self, 'txts', None), getattr(self, 'boxes', None), getattr(self, 'scores',
+                                                                                                     None)
+            if txts is not None and boxes is not None:
+                for i in range(len(txts)):
+                    if scores[i] >= score:
+                        if text_re is None or re.search(text_re, str(txts[i])):
+                            return _build_item(txts[i], boxes[i], scores[i])
+            return NullOCRItem()
+
+        def find_all(self, text_re: str = None, score: float = 0.85) -> List[OCRItem]:
+            """在 OCR 识别结果中查找所有匹配的文本，按从上到下、从左到右排序。
+
+            Args:
+                text_re: 正则表达式模式，用于匹配文本内容。为 None 时匹配所有文本。
+                score: 最低置信度阈值，默认为 0.85。
+
+            Returns:
+                List[OCRItem]: 匹配结果列表，按坐标排序（从上到下、从左到右）。
+            """
+            results = []
+            txts, boxes, scores = getattr(self, 'txts', None), getattr(self, 'boxes', None), getattr(self, 'scores',
+                                                                                                     None)
+            if txts is not None and boxes is not None:
+                for i in range(len(txts)):
+                    if scores[i] >= score:
+                        if text_re is None or re.search(text_re, str(txts[i])):
+                            results.append(_build_item(txts[i], boxes[i], scores[i]))
+
+            # 按从上到下、从左到右排序
+            results.sort(key=lambda x: (x.center[1], x.center[0]))
+            return results
+
+        # 将方法绑定到目标类
+        target_class = "RapidOCROutput"
+        if hasattr(module, target_class):
+            cls = getattr(module, target_class)
+            if not hasattr(cls, "find"):
+                cls.find = find
+                cls.find_all = find_all
+                # print(f"✅ [RapidOCR-Hook] 成功注入 find/find_all 扩展")
+
+
+def install():
+    """注册 RapidOCR Hook 的入口函数。
+
+    如果 rapidocr.utils.output 已加载，直接对其进行补丁；
+    否则将 RapidOCRHook 注册到 sys.meta_path，等待模块导入时自动注入。
+    """
+    target_mod = "rapidocr.utils.output"
+    if target_mod in sys.modules:
+        RapidOCRHook()._patch(sys.modules[target_mod])
+        return
+    if not any(isinstance(h, RapidOCRHook) for h in sys.meta_path):
+        sys.meta_path.insert(0, RapidOCRHook())

ascript/windows/screen/ocrx.py

@@ -0,0 +1,169 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+import cv2
+import numpy as np
+
+from .color_algorithms import color_mask
+
+
+_RADIX_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@}{[])(*?><~`$^"
+
+
+def _to_radix(value: int) -> str:
+    if value == 0:
+        return "0"
+    base = len(_RADIX_ALPHABET)
+    output = []
+    while value:
+        value, remainder = divmod(value, base)
+        output.append(_RADIX_ALPHABET[remainder])
+    return "".join(reversed(output))
+
+
+def _from_radix(value: str) -> int:
+    base = len(_RADIX_ALPHABET)
+    result = 0
+    for char in value:
+        index = _RADIX_ALPHABET.find(char)
+        if index < 0:
+            raise ValueError(f"字库包含无效字符: {char}")
+        result = result * base + index
+    return result
+
+
+@dataclass
+class OcrXResult:
+    text: str
+    fonts: List[dict]
+
+    def getText(self):
+        return self.text
+
+    def to_dict(self):
+        return {"text": self.text, "fonts": self.fonts}
+
+
+class OcrX:
+    """兼容 Android ``.t`` 点阵字库格式的轻量识字实现。"""
+
+    @staticmethod
+    def append_to_lib(lib_path, content):
+        path = Path(lib_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        prefix = "\n" if path.exists() and path.stat().st_size else ""
+        with path.open("a", encoding="utf-8") as stream:
+            stream.write(prefix + str(content).strip())
+
+    @staticmethod
+    def _trim_mask(mask):
+        ys, xs = np.where(mask)
+        if not len(xs):
+            return mask[:0, :0], 0, 0
+        left, right = int(xs.min()), int(xs.max()) + 1
+        top, bottom = int(ys.min()), int(ys.max()) + 1
+        return mask[top:bottom, left:right], left, top
+
+    @staticmethod
+    def make_font(image, colors: str, name: str = "字") -> str:
+        mask, _, _, _ = color_mask(image, colors, similarity=1.0)
+        mask, _, _ = OcrX._trim_mask(mask)
+        if mask.size == 0:
+            raise ValueError("选定颜色在图像中不存在")
+        rows = [_to_radix(int("".join("1" if value else "0" for value in row), 2)) for row in mask]
+        return f"{name}|{colors}|{int(mask.sum())}|{mask.shape[1]}|{'&'.join(rows)}"
+
+    @staticmethod
+    def _load(font_lib):
+        content = str(font_lib or "")
+        if isinstance(font_lib, (str, Path)):
+            try:
+                path = Path(font_lib)
+                if path.exists() and path.is_file():
+                    content = path.read_text(encoding="utf-8")
+            except OSError:
+                pass
+        fonts = []
+        for line_number, line in enumerate(content.splitlines(), 1):
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split("|", 4)
+            if len(parts) != 5:
+                raise ValueError(f"字库第 {line_number} 行格式错误")
+            name, colors, count, width, encoded = parts
+            width = int(width)
+            rows = []
+            for row in encoded.split("&"):
+                bits = bin(_from_radix(row))[2:].zfill(width)[-width:]
+                rows.append([1 if char == "1" else 0 for char in bits])
+            matrix = np.asarray(rows, dtype=np.float32)
+            fonts.append({"text": name, "colors": colors, "count": max(1, int(count)), "matrix": matrix})
+        if not fonts:
+            raise ValueError("字库为空")
+        return fonts
+
+    @staticmethod
+    def _iou(first, second):
+        left = max(first[0], second[0])
+        top = max(first[1], second[1])
+        right = min(first[2], second[2])
+        bottom = min(first[3], second[3])
+        if right <= left or bottom <= top:
+            return 0.0
+        intersection = (right - left) * (bottom - top)
+        first_area = (first[2] - first[0]) * (first[3] - first[1])
+        second_area = (second[2] - second[0]) * (second[3] - second[1])
+        return intersection / max(1, first_area + second_area - intersection)
+
+    @staticmethod
+    def recognize(font_lib, rect=None, region=0.9, image=None) -> OcrXResult:
+        fonts = OcrX._load(font_lib)
+        candidates = []
+        for font in fonts:
+            mask, _, offset_x, offset_y = color_mask(image, font["colors"], rect=rect, similarity=1.0)
+            mask, trim_x, trim_y = OcrX._trim_mask(mask)
+            template = font["matrix"]
+            if mask.size == 0 or mask.shape[0] < template.shape[0] or mask.shape[1] < template.shape[1]:
+                continue
+            scores = cv2.matchTemplate(mask.astype(np.float32), template, cv2.TM_CCORR) / float(font["count"])
+            local_max = scores >= cv2.dilate(scores, np.ones((3, 3), np.uint8))
+            ys, xs = np.where((scores >= float(region)) & local_max)
+            for x, y in zip(xs, ys):
+                width, height = template.shape[1], template.shape[0]
+                left, top = int(x + trim_x + offset_x), int(y + trim_y + offset_y)
+                candidates.append({
+                    "text": font["text"], "score": round(float(scores[y, x]), 4),
+                    "rect": [left, top, left + width, top + height],
+                    "x": left, "y": top, "width": width, "height": height,
+                })
+
+        selected = []
+        for candidate in sorted(candidates, key=lambda item: (-item["score"], item["y"], item["x"])):
+            if any(OcrX._iou(candidate["rect"], old["rect"]) > 0.3 for old in selected):
+                continue
+            selected.append(candidate)
+        selected.sort(key=lambda item: (item["y"] + item["height"] // 2, item["x"]))
+
+        lines = []
+        for item in selected:
+            center_y = item["y"] + item["height"] // 2
+            line = next((line for line in lines if abs(line[0] - center_y) <= max(3, item["height"] // 2)), None)
+            if line is None:
+                line = [center_y, []]
+                lines.append(line)
+            line[1].append(item)
+        lines.sort(key=lambda line: line[0])
+        text_lines = []
+        ordered = []
+        for _, items in lines:
+            items.sort(key=lambda item: item["x"])
+            ordered.extend(items)
+            text_lines.append("".join(item["text"] for item in items))
+        return OcrXResult("\n".join(text_lines), ordered)
+
+    @staticmethod
+    def find_all(font_lib: str, rect=None, region=0.9, image=None):
+        result = OcrX.recognize(font_lib, rect=rect, region=region, image=image)
+        return result.text or None

ascript/windows/screen/screen_core.py

@@ -0,0 +1,139 @@
+import os
+import base64
+import ctypes
+from io import BytesIO
+from typing import Literal, Union, Optional, List
+import numpy as np
+from PIL import Image
+from mss import mss
+
+# 解决 Windows 高分屏缩放导致的截图坐标偏差
+try:
+    ctypes.windll.shcore.SetProcessDpiAwareness(1)
+except Exception:
+    try:
+        ctypes.windll.user32.SetProcessDPIAware()
+    except Exception:
+        pass
+
+class Screen:
+    """屏幕截图与显示器信息工具类。
+
+    基于 mss 库实现高性能屏幕截图，支持 Windows 高分屏 DPI 自适应。
+    提供多种输出格式（PIL、NumPy、OpenCV、Base64）及区域截取功能。
+    """
+
+    JPEG_QUALITY = 80
+
+    @staticmethod
+    def encode_image(image: Image.Image, image_format: str = "JPEG") -> bytes:
+        """Encode a PIL image using the same settings as capture()."""
+        image_format = image_format.upper()
+        output = BytesIO()
+        save_args = {"format": image_format}
+        if image_format == "JPEG":
+            if image.mode != "RGB":
+                image = image.convert("RGB")
+            save_args["quality"] = Screen.JPEG_QUALITY
+        image.save(output, **save_args)
+        return output.getvalue()
+
+    @staticmethod
+    def size() -> List[int]:
+        """获取主显示器的分辨率尺寸。
+
+        Returns:
+            List[int]: [宽度, 高度]，单位为像素。
+        """
+        with mss() as sct:
+            monitor = sct.monitors[1]
+            return [monitor["width"], monitor["height"]]
+
+
+
+    @staticmethod
+    def capture(
+            rect: Optional[List[int]] = None,
+            format: str = "pillow",
+            save_path: Optional[str] = None
+    ) -> Union[Image.Image, np.ndarray, str, None]:
+        """截取屏幕图像。
+
+        支持全屏或指定区域截图，可输出多种格式并可选保存到文件。
+        已处理 Windows 高分屏 DPI 缩放问题。
+
+        Args:
+            rect: 截图区域 [left, top, right, bottom]，为 None 时截取整个主显示器。
+            format: 输出格式，可选值：
+                - 'pillow': 返回 PIL.Image 对象（默认）。
+                - 'numpy': 返回 RGB 格式的 NumPy 数组。
+                - 'opencv': 返回 BGR 格式的 NumPy 数组。
+                - 'base64': 返回 JPEG 格式的 Base64 数据 URI 字符串。
+                - 'base64:png': 返回 PNG 格式的 Base64 数据 URI 字符串。
+            save_path: 文件保存路径，自动根据后缀名选择存储格式（支持 jpg/png），
+                为 None 时不保存。
+
+        Returns:
+            Union[Image.Image, numpy.ndarray, str, None]: 根据 format 参数返回对应格式的截图，
+                截图失败时返回 None。
+        """
+        with mss() as sct:
+            try:
+                # 1. 区域计算与合法性校验
+                if rect and len(rect) == 4:
+                    left, top, right, bottom = rect
+                    # 确保 width 和 height 为正数
+                    width, height = max(0, right - left), max(0, bottom - top)
+                    if width == 0 or height == 0:
+                        return None
+                    monitor = {"left": left, "top": top, "width": width, "height": height}
+                else:
+                    monitor = sct.monitors[1]
+
+                # 2. 执行截图
+                sct_img = sct.grab(monitor)
+
+                # 3. 构造 PIL 对象 (核心中转)
+                img = Image.frombytes("RGB", sct_img.size, sct_img.bgra, "raw", "BGRX")
+
+                # 4. 磁盘保存逻辑
+                if save_path:
+                    directory = os.path.dirname(save_path)
+                    if directory and not os.path.exists(directory):
+                        os.makedirs(directory, exist_ok=True)
+
+                    _, ext = os.path.splitext(save_path)
+                    ext = ext.lower().strip('.')
+                    # 自动匹配存储格式
+                    save_fmt = "JPEG" if ext in ["jpg", "jpeg"] else ("PNG" if ext == "png" else "PNG")
+
+                    # 针对不同格式设置最优参数
+                    save_args = {"format": save_fmt}
+                    if save_fmt == "JPEG":
+                        save_args["quality"] = 95
+                        save_args["subsampling"] = 0  # 提升色彩保持度
+
+                    img.save(save_path, **save_args)
+
+                # 5. 返回格式化处理
+                if format.startswith("base64"):
+                    # 默认 jpeg，除非明确指定 base64:png
+                    sub_format = "PNG" if (":" in format and format.split(":")[1].lower() == "png") else "JPEG"
+                    image_bytes = Screen.encode_image(img, sub_format)
+                    img_str = base64.b64encode(image_bytes).decode("utf-8")
+                    return f"data:image/{sub_format.lower()};base64,{img_str}"
+
+                elif format == "pillow":
+                    return img
+
+                elif format == "numpy":
+                    return np.array(img)
+
+                elif format == "opencv":
+                    return np.array(img)[:, :, ::-1]
+
+                return img
+
+            except Exception as e:
+                print(f"Screenshot Error: {e}")
+                return None

ascript/windows/store/__init__.py

@@ -0,0 +1,21 @@
+
+def main():
+    from ascript.windows.ui.app_store_window import AppStoreWindow
+    import os
+
+    def on_start(app_info, license_data):
+        print(app_info)
+        print(license_data)
+        # package_name = "AScriptProject2"
+        user_id = str(app_info["id"])
+        file_md5 = app_info['fileMd5']
+
+        is_ready = app_store.env_manager.smart_deploy(user_id, app_store.target_path, file_md5)
+        if not is_ready:
+            return False
+        return app_store.env_manager.run_app(user_id) is not None
+
+    root_path = os.path.join(os.getcwd(), "apps")
+    default_id = os.environ.get("ASCRIPT_APP_ID") or None
+    app_store = AppStoreWindow(default_id=default_id, on_start=on_start, env_path=root_path)
+    app_store.show()

ascript/windows/system/__init__.py

@@ -0,0 +1,8 @@
+from .r import R
+from .key_value import KeyValue
+from .runtime import Runtime
+from .device import Device
+from .pip import Pip
+from .env import EnvManager
+
+__all__ = ['R', 'KeyValue','Runtime',"Device","Pip","EnvManager"]