uiautodev 0.5.0__tar.gz → 0.7.0__tar.gz

{uiautodev-0.5.0 → uiautodev-0.7.0}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: uiautodev
-Version: 0.5.0
+Version: 0.7.0
 Summary: Mobile UI Automation, include UI hierarchy inspector, script recorder
-Home-page: https://uiauto.dev
 License: MIT
 Author: codeskyblue
 Author-email: codeskyblue@gmail.com
@@ -14,7 +13,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: adbutils (>=2.7.0,<3.0.0)
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: adbutils (>=2.8.10,<3)
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: construct
 Requires-Dist: fastapi (>=0.111.0,<0.112.0)
@@ -27,6 +27,7 @@ Requires-Dist: pygments (>=2)
 Requires-Dist: uiautomator2 (>=2)
 Requires-Dist: uvicorn[standard]
 Requires-Dist: wdapy (>=0.2.2,<0.3.0)
+Project-URL: Homepage, https://uiauto.dev
 Description-Content-Type: text/markdown
 
 # uiautodev
@@ -79,6 +80,18 @@ make format
 
 # run server
 make dev
+
+# If you encounter the error NameError: name 'int2byte' is not defined,
+# try installing a stable version of the construct package to resolve it:
+# and restart: make dev
+pip install construct==2.9.45
+
+```
+
+运行测试
+
+```sh
+make test
 ```
 
 # LICENSE

{uiautodev-0.5.0 → uiautodev-0.7.0}/README.md

@@ -48,6 +48,18 @@ make format
 
 # run server
 make dev
+
+# If you encounter the error NameError: name 'int2byte' is not defined,
+# try installing a stable version of the construct package to resolve it:
+# and restart: make dev
+pip install construct==2.9.45
+
+```
+
+运行测试
+
+```sh
+make test
 ```
 
 # LICENSE

{uiautodev-0.5.0 → uiautodev-0.7.0}/pyproject.toml

@@ -1,16 +1,20 @@
 [tool.poetry]
 name = "uiautodev"
-version = "0.5.0"
+version = "0.7.0"
 description = "Mobile UI Automation, include UI hierarchy inspector, script recorder"
 homepage = "https://uiauto.dev"
 authors = ["codeskyblue <codeskyblue@gmail.com>"]
 license = "MIT"
 readme = "README.md"
 
+include = [
+    {path = "uiautodev/binaries/scrcpy.jar"}
+]
+
 [tool.poetry.dependencies]
 python = "^3.8"
 pillow = "*"
-adbutils = "^2.7.0"
+adbutils = ">=2.8.10,<3"
 construct = "*"
 lxml = "*"
 click = "^8.1.7"

{uiautodev-0.5.0 → uiautodev-0.7.0}/uiautodev/__init__.py

@@ -5,4 +5,4 @@
 """
 
 # version is auto managed by poetry
-__version__ = "0.5.0"
+__version__ = "0.7.0"

uiautodev-0.7.0/uiautodev/app.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Sun Feb 18 2024 13:48:55 by codeskyblue
+"""
+
+import logging
+import os
+import platform
+import signal
+from pathlib import Path
+from typing import List
+
+import adbutils
+import uvicorn
+from fastapi import FastAPI, File, UploadFile, WebSocket
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
+from pydantic import BaseModel
+from rich.logging import RichHandler
+from starlette.websockets import WebSocketDisconnect
+
+from uiautodev import __version__
+from uiautodev.common import convert_bytes_to_image, get_webpage_url, ocr_image
+from uiautodev.model import Node
+from uiautodev.provider import AndroidProvider, HarmonyProvider, IOSProvider, MockProvider
+from uiautodev.remote.scrcpy import ScrcpyServer
+from uiautodev.router.device import make_router
+from uiautodev.router.xml import router as xml_router
+from uiautodev.utils.envutils import Environment
+
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+
+def enable_logger_to_console():
+    _logger = logging.getLogger("uiautodev")
+    _logger.setLevel(logging.DEBUG)
+    _logger.addHandler(RichHandler(enable_link_path=False))
+
+
+if os.getenv("UIAUTODEV_DEBUG"):
+    enable_logger_to_console()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST"],
+    allow_headers=["*"],
+)
+
+android_router = make_router(AndroidProvider())
+ios_router = make_router(IOSProvider())
+harmony_router = make_router(HarmonyProvider())
+mock_router = make_router(MockProvider())
+
+app.include_router(mock_router, prefix="/api/mock", tags=["mock"])
+
+if Environment.UIAUTODEV_MOCK:
+    app.include_router(mock_router, prefix="/api/android", tags=["mock"])
+    app.include_router(mock_router, prefix="/api/ios", tags=["mock"])
+    app.include_router(mock_router, prefix="/api/harmony", tags=["mock"])
+else:
+    app.include_router(android_router, prefix="/api/android", tags=["android"])
+    app.include_router(ios_router, prefix="/api/ios", tags=["ios"])
+    app.include_router(harmony_router, prefix="/api/harmony", tags=["harmony"])
+
+app.include_router(xml_router, prefix="/api/xml", tags=["xml"])
+
+
+class InfoResponse(BaseModel):
+    version: str
+    description: str
+    platform: str
+    code_language: str
+    cwd: str
+    drivers: List[str]
+
+
+@app.get("/api/info")
+def info() -> InfoResponse:
+    """Information about the application"""
+    return InfoResponse(
+        version=__version__,
+        description="client for https://uiauto.dev",
+        platform=platform.system(),  # Linux | Darwin | Windows
+        code_language="Python",
+        cwd=os.getcwd(),
+        drivers=["android", "ios", "harmony"],
+    )
+
+
+@app.post('/api/ocr_image')
+async def _ocr_image(file: UploadFile = File(...)) -> List[Node]:
+    """OCR an image"""
+    image_data = await file.read()
+    image = convert_bytes_to_image(image_data)
+    return ocr_image(image)
+
+
+@app.get("/shutdown")
+def shutdown() -> str:
+    """Shutdown the server"""
+    os.kill(os.getpid(), signal.SIGINT)
+    return "Server shutting down..."
+
+
+@app.get("/demo")
+def demo():
+    """Demo endpoint"""
+    static_dir = Path(__file__).parent / "static"
+    print(static_dir / "demo.html")
+    return FileResponse(static_dir / "demo.html")
+
+
+@app.get("/")
+def index_redirect():
+    """ redirect to official homepage """
+    url = get_webpage_url()
+    logger.debug("redirect to %s", url)
+    return RedirectResponse(url)
+
+
+def get_scrcpy_server(serial: str):
+    # 这里主要是为了避免两次websocket建立建立，启动两个scrcpy进程
+    logger.info("create scrcpy server for %s", serial)
+    device = adbutils.device(serial)
+    return ScrcpyServer(device)
+
+
+@app.websocket("/ws/android/scrcpy/{serial}")
+async def unified_ws(websocket: WebSocket, serial: str):
+    """
+    Args:
+        serial: device serial
+        websocket: WebSocket
+    """
+    await websocket.accept()
+
+    try:
+        logger.info(f"WebSocket serial: {serial}")
+
+        # 获取 ScrcpyServer 实例
+        server = get_scrcpy_server(serial)
+        await server.handle_unified_websocket(websocket, serial)
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected by client.")
+    except Exception as e:
+        logger.exception(f"WebSocket error for serial={serial}: {e}")
+        await websocket.close(code=1000, reason=str(e))
+    finally:
+        logger.info(f"WebSocket closed for serial={serial}")
+
+
+if __name__ == '__main__':
+    uvicorn.run("uiautodev.app:app", port=4000, reload=True, use_colors=True)

{uiautodev-0.5.0 → uiautodev-0.7.0}/uiautodev/cli.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import platform
 import subprocess
 import sys
@@ -29,30 +30,12 @@ logger = logging.getLogger(__name__)
 
 CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
 
+
 @click.group(context_settings=CONTEXT_SETTINGS)
 @click.option("--verbose", "-v", is_flag=True, default=False, help="verbose mode")
 def cli(verbose: bool):
     if verbose:
-        # try to enable logger is not very easy
-        # you have to setup logHandler(logFormatter) for the root logger
-        # and set all children logger to DEBUG
-        # that's why it is not easy to use it with logging
-        root_logger = logging.getLogger(__name__.split(".")[0])
-        root_logger.setLevel(logging.DEBUG)
-
-        console_handler = logging.StreamHandler()
-        console_handler.setLevel(logging.DEBUG)
-        
-        formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
-        console_handler.setFormatter(formatter)
-
-        root_logger.addHandler(console_handler)
-
-        # set all children logger to DEBUG
-        for k in root_logger.manager.loggerDict.keys():
-            if k.startswith(root_logger.name+"."):
-                logging.getLogger(k).setLevel(logging.DEBUG)
-        
+        os.environ['UIAUTODEV_DEBUG'] = '1'
         logger.debug("Verbose mode enabled")
 
 
@@ -113,7 +96,7 @@ def case():
 def appium(command: Command, params: list[str] = None):
     from uiautodev.driver.appium import AppiumProvider
     from uiautodev.exceptions import AppiumDriverException
-    
+
     provider = AppiumProvider()
     try:
         run_driver_command(provider, command, params)
@@ -150,7 +133,7 @@ def server(port: int, host: str, reload: bool, force: bool, no_browser: bool):
     use_color = True
     if platform.system() == 'Windows':
         use_color = False
-    
+
     if not no_browser:
         th = threading.Thread(target=open_browser_when_server_start, args=(f"http://{host}:{port}",))
         th.daemon = True
@@ -171,6 +154,7 @@ def open_browser_when_server_start(server_url: str):
     logger.info("open browser: %s", web_url)
     webbrowser.open(web_url)
 
+
 def main():
     # set logger level to INFO
     # logging.basicConfig(level=logging.INFO)

{uiautodev-0.5.0 → uiautodev-0.7.0}/uiautodev/command_proxy.py

@@ -17,7 +17,7 @@ from uiautodev.command_types import AppLaunchRequest, AppTerminateRequest, By, C
     WindowSizeResponse
 from uiautodev.driver.base_driver import BaseDriver
 from uiautodev.exceptions import ElementNotFoundError
-from uiautodev.model import Node, AppInfo
+from uiautodev.model import AppInfo, Node
 from uiautodev.utils.common import node_travel
 
 COMMANDS: Dict[Command, Callable] = {}
@@ -61,8 +61,6 @@ def send_command(driver: BaseDriver, command: Union[str, Command], params=None):
 @register(Command.TAP)
 def tap(driver: BaseDriver, params: TapRequest):
     """Tap on the screen
-    :param x: x coordinate
-    :param y: y coordinate
     """
     x = params.x
     y = params.y

uiautodev-0.7.0/uiautodev/common.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Thu May 09 2024 11:33:17 by codeskyblue
+"""
+
+
+import io
+import locale
+import logging
+from typing import List
+
+from PIL import Image
+
+from uiautodev.model import Node, OCRNode
+
+logger = logging.getLogger(__name__)
+
+def is_chinese_language() -> bool:
+    language_code, _ = locale.getdefaultlocale()
+    
+    # Check if the language code starts with 'zh' (Chinese)
+    if language_code and language_code.startswith('zh'):
+        return True
+    else:
+        return False
+    
+    
+def get_webpage_url() -> str:
+    web_url = "https://uiauto.dev"
+    if is_chinese_language():
+        web_url = "https://uiauto.devsleep.com"
+    return web_url
+
+
+def convert_bytes_to_image(byte_data: bytes) -> Image.Image:
+    return Image.open(io.BytesIO(byte_data))
+
+
+def ocr_image(image: Image.Image) -> List[OCRNode]:
+    # Placeholder for OCR implementation
+    w, h = image.size
+    try:
+        from ocrmac import ocrmac
+    except ImportError:
+        logger.error("OCR is not supported on this platform")
+        return []
+    result = ocrmac.OCR(image).recognize()
+    nodes = []
+    for index, (text, confidence, pbounds) in enumerate(result):
+        print(f"OCR result: {text}, confidence: {confidence}, bounds: {pbounds}")
+        # bounds = int(pbounds[0]*w), int(pbounds[1]*h), int(pbounds[2]*w), int(pbounds[3]*h)
+        nodes.append(OCRNode(key=str(index), name=text, bounds=pbounds, confidence=confidence))
+    return nodes

{uiautodev-0.5.0 → uiautodev-0.7.0}/uiautodev/driver/android.py

@@ -18,7 +18,7 @@ from PIL import Image
 from uiautodev.command_types import CurrentAppResponse
 from uiautodev.driver.base_driver import BaseDriver
 from uiautodev.exceptions import AndroidDriverException, RequestError
-from uiautodev.model import Node, AppInfo, Rect, ShellResponse, WindowSize
+from uiautodev.model import AppInfo, Node, Rect, ShellResponse, WindowSize
 from uiautodev.utils.common import fetch_through_socket
 
 logger = logging.getLogger(__name__)
@@ -71,8 +71,7 @@ class AndroidDriver(BaseDriver):
         try:
             return self.ud.dump_hierarchy()
         except Exception as e:
-            logger.exception("unexpected dump error: %s", e)
-            raise AndroidDriverException("Failed to dump hierarchy")
+            raise AndroidDriverException(f"Failed to dump hierarchy: {str(e)}")
     
     def tap(self, x: int, y: int):
         self.adb_device.click(x, y)

{uiautodev-0.5.0 → uiautodev-0.7.0}/uiautodev/driver/base_driver.py

@@ -11,7 +11,7 @@ from PIL import Image
 from pydantic import BaseModel
 
 from uiautodev.command_types import CurrentAppResponse
-from uiautodev.model import Node, AppInfo, ShellResponse, WindowSize
+from uiautodev.model import AppInfo, Node, ShellResponse, WindowSize
 
 
 class BaseDriver(abc.ABC):

uiautodev-0.7.0/uiautodev/driver/harmony.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+import logging
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+import uuid
+from pathlib import Path
+from typing import List, Optional, Tuple, Union, final
+
+from PIL import Image
+
+from uiautodev.command_types import CurrentAppResponse
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.model import AppInfo, Node, Rect, ShellResponse, WindowSize
+
+logger = logging.getLogger(__name__)
+
+StrOrPath = Union[str, Path]
+
+
+def run_command(command: str, timeout: int = 60) -> str:
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            timeout=timeout,
+            text=True,
+            input='' # this avoid stdout: "FreeChannelContinue handle->data is nullptr"
+        )
+        # the hdc shell stderr is (不仅没啥用，还没办法去掉)
+        # Remote PTY will not be allocated because stdin is not a terminal.
+        # Use multiple -t options to force remote PTY allocation.
+        output = result.stdout.strip()
+        return output
+    except subprocess.TimeoutExpired as e:
+        raise TimeoutError(f"{command:r} timeout {e}")
+
+
+class HDCError(Exception):
+    pass
+
+
+class HDC:
+    def __init__(self):
+        self.hdc = 'hdc'
+        self.tmpdir = tempfile.TemporaryDirectory()
+    
+    def __del__(self):
+        self.tmpdir.cleanup()
+    
+    def list_device(self) -> List[str]:
+        command = f"{self.hdc} list targets"
+        result = run_command(command)
+        if result and not "Empty" in result:
+            devices = []
+            for line in result.strip().split("\n"):
+                serial = line.strip().split('\t', 1)[0]
+                devices.append(serial)
+            return devices
+        else:
+            return []
+    
+    def shell(self, serial: str, command: str) -> str:
+        command = f"{self.hdc} -t {serial} shell \"{command}\""
+        result = run_command(command)
+        return result.strip()
+    
+    def get_model(self, serial: str) -> str:
+        return self.shell(serial, "param get const.product.model")
+    
+    def pull(self, serial: str, remote: StrOrPath, local: StrOrPath):
+        if isinstance(remote, Path):
+            remote = remote.as_posix()
+        command = f"{self.hdc} -t {serial} file recv {remote} {local}"
+        output = run_command(command)
+        if not os.path.exists(local):
+            raise HDCError(f"device file: {remote} not found", output)
+    
+    def push(self, serial: str, local: StrOrPath, remote: StrOrPath) -> str:
+        if isinstance(remote, Path):
+            remote = remote.as_posix()
+        command = f"{self.hdc} -t {serial} file send {local} {remote}"
+        return run_command(command)
+    
+    def screenshot(self, serial: str) -> Image.Image:
+        device_path = f'/data/local/tmp/screenshot-{int(time.time()*1000)}.png'
+        self.shell(serial, f"uitest screenCap -p {device_path}")
+        try:
+            local_path = os.path.join(self.tmpdir.name, f"{uuid.uuid4()}.png")
+            self.pull(serial, device_path, local_path)
+            with Image.open(local_path) as image:
+                image.load()
+                return image
+        finally:
+            self.shell(serial, f"rm {device_path}")
+
+    def dump_layout(self, serial: str) -> dict:
+        name = "{}.json".format(int(time.time() * 1000))
+        remote_path = f"/data/local/tmp/layout-{name}.json"
+        temp_path = os.path.join(self.tmpdir.name, f"layout-{name}.json")
+        output = self.shell(serial, f"uitest dumpLayout -p {remote_path}")
+        self.pull(serial, remote_path, temp_path)
+        # mock
+        # temp_path = Path(__file__).parent / 'testdata/layout.json'
+        try:
+            with open(temp_path, "rb") as f:
+                json_content = json.load(f)
+            return json_content
+        except json.JSONDecodeError:
+            raise HDCError(f"failed to dump layout: {output}")
+        finally:
+            self.shell(serial, f"rm {remote_path}")
+    
+
+class HarmonyDriver(BaseDriver):
+    def __init__(self, hdc: HDC, serial: str):
+        super().__init__(serial)
+        self.hdc = hdc
+
+    def screenshot(self, id: int = 0) -> Image.Image:
+        return self.hdc.screenshot(self.serial)
+
+    def window_size(self) -> WindowSize:
+        result = self.hdc.shell(self.serial, "hidumper -s 10 -a screen")
+        pattern = r"activeMode:\s*(\d+x\d+)"
+        match = re.search(pattern, result)
+        if match:
+            resolution = match.group(1).split("x")
+            return WindowSize(width=int(resolution[0]), height=int(resolution[1]))
+        else:
+            image = self.screenshot()
+            return WindowSize(width=image.width, height=image.height)
+
+    def dump_hierarchy(self) -> Tuple[str, Node]:
+        """returns xml string and hierarchy object"""
+        layout = self.hdc.dump_layout(self.serial)
+        return json.dumps(layout), parse_json_element(layout)
+
+    def tap(self, x: int, y: int):
+        self.hdc.shell(self.serial, f"uinput -T -c {x} {y}")
+
+    def app_current(self) -> Optional[CurrentAppResponse]:
+        echo = self.hdc.shell(self.serial, "hidumper -s WindowManagerService -a '-a'")
+        focus_window = re.search(r"Focus window: (\d+)", echo)
+        if focus_window:
+            focus_window = focus_window.group(1)
+        mission_echo = self.hdc.shell(self.serial, "aa dump -a")
+        pkg_names = re.findall(r"Mission ID #(\d+)\s+mission name #\[(.*?)\]", mission_echo)
+        if focus_window and pkg_names:
+            for mission in pkg_names:
+                mission_id = mission[0]
+                if focus_window == mission_id:
+                    mission_name = mission[1]
+                    pkg_name = mission_name.split(":")[0].replace("#", "")
+                    ability_name = mission_name.split(":")[-1]
+                    pid = self.hdc.shell(self.serial, f"pidof {pkg_name}").strip()
+                    return CurrentAppResponse(package=pkg_name, activity=ability_name, pid=int(pid))
+        else:
+            return None
+
+    def shell(self, command: str) -> ShellResponse:
+        result = self.hdc.shell(self.serial, command)
+        return ShellResponse(output=result)
+
+    def home(self):
+        self.hdc.shell(self.serial, "uinput -K -d 1 -u 1")
+
+    def back(self):
+        self.hdc.shell(self.serial, "uinput -K -d 2 -u 2")
+
+    def volume_up(self):
+        self.hdc.shell(self.serial, "uinput -K -d 16 -u 16")
+
+    def volume_down(self):
+        self.hdc.shell(self.serial, "uinput -K -d 17 -u 17")
+
+    def volume_mute(self):
+        self.hdc.shell(self.serial, "uinput -K -d 22 -u 22")
+
+    def app_switch(self):
+        self.hdc.shell(self.serial, "uinput -K -d 2076 -d 2049 -u 2076 -u 2049")
+
+    def app_list(self) -> List[AppInfo]:
+        results = []
+        output = self.hdc.shell(self.serial, "bm dump -a")
+        for i in output.split("\n"):
+            if "ID" in i:
+                continue
+            else:
+                results.append(AppInfo(packageName=i.strip()))
+        return results
+
+
+def parse_json_element(element, indexes: List[int] = [0]) -> Node:
+    """
+    Recursively parse an json element into a dictionary format.
+    """
+    attributes = element.get("attributes", {})
+    name = attributes.get("type", "")
+    bounds = attributes.get("bounds", "")
+    bounds = list(map(int, re.findall(r"\d+", bounds)))
+    assert len(bounds) == 4
+    rect = Rect(x=bounds[0], y=bounds[1], width=bounds[2] - bounds[0], height=bounds[3] - bounds[1])
+    elem = Node(
+        key="-".join(map(str, indexes)),
+        name=name,
+        bounds=None,
+        rect=rect,
+        properties={key: attributes[key] for key in attributes},
+        children=[],
+    )
+    # Construct xpath for children
+    for index, child in enumerate(element.get("children", [])):
+        child_node = parse_json_element(child, indexes + [index])
+        if child_node:
+            elem.children.append(child_node)
+
+    return elem