uiautodev 0.3.3__py3-none-any.whl

uiautodev/command_types.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 19 2024 10:19:27 by codeskyblue
+"""
+
+
+# Request and Response
+import enum
+from typing import List, Optional, Union
+
+from pydantic import BaseModel
+
+from uiautodev.model import Node
+
+
+# POST /api/v1/device/{serial}/command/{command}
+class Command(str, enum.Enum):
+    TAP = "tap"
+    TAP_ELEMENT = "tapElement"
+    APP_INSTALL = "installApp"
+    APP_CURRENT = "currentApp"
+    APP_LAUNCH = "appLaunch"
+    APP_TERMINATE = "appTerminate"
+
+    GET_WINDOW_SIZE = "getWindowSize"
+    HOME = "home"
+    DUMP = "dump"
+    WAKE_UP = "wakeUp"
+    FIND_ELEMENTS = "findElements"
+    CLICK_ELEMENT = "clickElement"
+
+    LIST = "list"
+
+
+class TapRequest(BaseModel):
+    x: Union[int, float]
+    y: Union[int, float]
+    isPercent: bool = False
+
+
+class InstallAppRequest(BaseModel):
+    url: str
+
+
+class InstallAppResponse(BaseModel):
+    success: bool
+    id: Optional[str] = None
+
+
+class CurrentAppResponse(BaseModel):
+    package: str
+    activity: Optional[str] = None
+    pid: Optional[int] = None
+
+
+class AppLaunchRequest(BaseModel):
+    package: str
+    stop: bool = False
+
+
+class AppTerminateRequest(BaseModel):
+    package: str
+
+
+class WindowSizeResponse(BaseModel):
+    width: int
+    height: int
+
+
+class DumpResponse(BaseModel):
+    value: str
+
+
+class By(str, enum.Enum):
+    ID = "id"
+    TEXT = "text"
+    XPATH = "xpath"
+    CLASS_NAME = "className"
+
+class FindElementRequest(BaseModel):
+    by: str
+    value: str
+    timeout: float = 10.0
+
+
+class FindElementResponse(BaseModel):
+    count: int
+    value: List[Node]

uiautodev/driver/android.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Fri Mar 01 2024 14:19:29 by codeskyblue
+"""
+
+import json
+import logging
+import re
+import socket
+import time
+from functools import cached_property, partial
+from typing import List, Tuple
+from xml.etree import ElementTree
+
+import adbutils
+import requests
+from PIL import Image
+
+from uiautodev.command_types import CurrentAppResponse
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.driver.udt.udt import UDT, UDTError
+from uiautodev.exceptions import AndroidDriverException, RequestError
+from uiautodev.model import Node, ShellResponse, WindowSize
+from uiautodev.utils.common import fetch_through_socket
+
+logger = logging.getLogger(__name__)
+
+class AndroidDriver(BaseDriver):
+    def __init__(self, serial: str):
+        super().__init__(serial)
+        self.device = adbutils.device(serial)
+        self._try_dump_list = [
+            self._get_u2_hierarchy,
+            self._get_appium_hierarchy,
+            self._get_udt_dump_hierarchy,
+            self.device.dump_hierarchy,
+            self._get_u2_lib_hierarchy,
+        ]
+    
+    @cached_property
+    def udt(self) -> UDT:    
+        return UDT(self.device)
+    
+    def screenshot(self, id: int) -> Image.Image:
+        # TODO: support multi-display
+        if id > 0:
+            raise ValueError("multi-display is not supported yet")
+        try:
+            img = self.device.screenshot()
+            return img.convert("RGB")
+        except adbutils.AdbError as e:
+            logger.warning("screenshot error: %s", str(e))
+            return self.udt.screenshot()
+
+    def shell(self, command: str) -> ShellResponse:
+        try:
+            ret = self.device.shell2(command, rstrip=True, timeout=20)
+            if ret.returncode == 0:
+                return ShellResponse(output=ret.output, error=None)
+            else:
+                return ShellResponse(
+                    output="", error=f"exit:{ret.returncode}, output:{ret.output}"
+                )
+        except Exception as e:
+            return ShellResponse(output="", error=f"adb error: {str(e)}")
+
+    def dump_hierarchy(self) -> Tuple[str, Node]:
+        """returns xml string and hierarchy object"""
+        wsize = self.device.window_size()
+        logger.debug("window size: %s", wsize)
+        start = time.time()
+        xml_data = self._dump_hierarchy_raw()
+        logger.debug("dump_hierarchy cost: %s", time.time() - start)
+
+        return xml_data, parse_xml(
+            xml_data, WindowSize(width=wsize[0], height=wsize[1])
+        )
+
+    def _dump_hierarchy_raw(self) -> str:
+        """
+        uiautomator2 server is conflict with "uiautomator dump" command.
+
+        uiautomator dump errors:
+        - ERROR: could not get idle state.
+
+        """
+        for dump_func in self._try_dump_list[:]:
+            try:
+                logger.debug(f"try to dump with %s", dump_func.__name__)
+                result = dump_func()
+                logger.debug("dump success")
+                self._try_dump_list.remove(dump_func)
+                self._try_dump_list.insert(0, dump_func)
+                return result
+            except (
+                requests.RequestException,
+                AndroidDriverException,
+                UDTError,
+                adbutils.AdbError,
+                socket.timeout,
+            ) as e:
+                logger.warning("dump error: %s", e)
+            except Exception as e:
+                logger.exception("unexpected dump error: %s", e)
+        raise AndroidDriverException("Failed to dump hierarchy")
+    
+    def _get_u2_hierarchy(self) -> str:
+        import uiautomator2 as u2
+        d = u2.connect_usb(self.serial)
+        return d.dump_hierarchy()
+        # c = self.device.create_connection(adbutils.Network.TCP, 9008)
+        # try:
+        #     compressed = False
+        #     payload = {
+        #         "jsonrpc": "2.0",
+        #         "method": "dumpWindowHierarchy",
+        #         "params": [compressed],
+        #         "id": 1,
+        #     }
+        #     content = fetch_through_socket(
+        #         c, "/jsonrpc/0", method="POST", json=payload, timeout=5
+        #     )
+        #     json_resp = json.loads(content)
+        #     if "error" in json_resp:
+        #         raise AndroidDriverException(json_resp["error"])
+        #     return json_resp["result"]
+        # except adbutils.AdbError as e:
+        #     raise AndroidDriverException(
+        #         f"Failed to get hierarchy from u2 server: {str(e)}"
+        #     )
+        # finally:
+        #     c.close()
+
+    def _get_appium_hierarchy(self) -> str:
+        c = self.device.create_connection(adbutils.Network.TCP, 6790)
+        try:
+            content = fetch_through_socket(c, "/wd/hub/session/0/source", timeout=10)
+            return json.loads(content)["value"]
+        except (adbutils.AdbError, RequestError) as e:
+            raise AndroidDriverException(
+                f"Failed to get hierarchy from appium server: {str(e)}"
+            )
+        finally:
+            c.close()
+
+    def _get_udt_dump_hierarchy(self) -> str:
+        return self.udt.dump_hierarchy()
+
+    def _get_u2_lib_hierarchy(self) -> str:
+        try:
+            import uiautomator2 as u2
+            d = u2.connect_usb(self.serial)
+            return d.dump_hierarchy()
+        except ModuleNotFoundError:
+            raise AndroidDriverException("uiautomator2 lib not installed")
+    
+    def tap(self, x: int, y: int):
+        self.device.click(x, y)
+
+    def window_size(self) -> Tuple[int, int]:
+        w, h = self.device.window_size()
+        return (w, h)
+
+    def app_install(self, app_path: str):
+        self.device.install(app_path)
+
+    def app_current(self) -> CurrentAppResponse:
+        info = self.device.app_current()
+        return CurrentAppResponse(
+            package=info.package, activity=info.activity, pid=info.pid
+        )
+
+    def app_launch(self, package: str):
+        if self.device.package_info(package) is None:
+            raise AndroidDriverException(f"App not installed: {package}")
+        self.device.app_start(package)
+    
+    def app_terminate(self, package: str):
+        self.device.app_stop(package)
+
+    def home(self):
+        self.device.keyevent("HOME")
+    
+    def wake_up(self):
+        self.device.keyevent("WAKEUP")
+
+
+def parse_xml(xml_data: str, wsize: WindowSize) -> Node:
+    root = ElementTree.fromstring(xml_data)
+    return parse_xml_element(root, wsize)
+
+
+def parse_xml_element(
+    element, wsize: WindowSize, indexes: List[int] = [0]
+) -> Node:
+    """
+    Recursively parse an XML element into a dictionary format.
+    """
+    name = element.tag
+    if name == "node":
+        name = element.attrib.get("class", "node")
+    bounds = None
+    # eg: bounds="[883,2222][1008,2265]"
+    if "bounds" in element.attrib:
+        bounds = element.attrib["bounds"]
+        bounds = list(map(int, re.findall(r"\d+", bounds)))
+        assert len(bounds) == 4
+        bounds = (
+            bounds[0] / wsize.width,
+            bounds[1] / wsize.height,
+            bounds[2] / wsize.width,
+            bounds[3] / wsize.height,
+        )
+        bounds = map(partial(round, ndigits=4), bounds)
+    elem = Node(
+        key="-".join(map(str, indexes)),
+        name=name,
+        bounds=bounds,
+        properties={key: element.attrib[key] for key in element.attrib},
+        children=[],
+    )
+
+    # Construct xpath for children
+    for index, child in enumerate(element):
+        elem.children.append(parse_xml_element(child, wsize, indexes + [index]))
+
+    return elem

uiautodev/driver/appium.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 19 2024 15:51:59 by codeskyblue
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import logging
+from pprint import pprint
+from typing import Tuple
+
+import httpretty
+import httpx
+from appium import webdriver
+from appium.options.android import UiAutomator2Options
+from appium.options.ios import XCUITestOptions
+from appium.webdriver.common.appiumby import AppiumBy as By
+from PIL import Image
+from selenium.webdriver.common.proxy import Proxy, ProxyType
+
+from uiautodev.command_types import CurrentAppResponse
+from uiautodev.driver.android import parse_xml
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.exceptions import AppiumDriverException
+from uiautodev.model import DeviceInfo, Node, ShellResponse, WindowSize
+from uiautodev.provider import BaseProvider
+
+logger = logging.getLogger(__name__)
+
+class AppiumProvider(BaseProvider):
+    sessions = []
+
+    def __init__(self, command_executor: str = "http://localhost:4723/wd/hub"):
+        # command_executor = "http://localhost:4700"
+        # command_executor = "http://localhost:4720/wd/hub"
+        self.command_executor = command_executor.rstrip('/')
+        self.sessions.clear()
+
+    def list_devices(self) -> list[DeviceInfo]:
+        """ appium just return all session_ids """
+        response = httpx.get(f"{self.command_executor}/sessions", verify=False)
+        if response.status_code >= 400:
+            raise AppiumDriverException(f"Failed request to appium server: {self.command_executor} status: {response.status_code}")
+        ret = []
+        self.sessions = response.json()['value']
+        for item in self.sessions:
+            item['sessionId'] = item.pop('id')
+            print("Active sessionId", item['sessionId'])
+            serial = item['capabilities']['platformName'] + ':' + item['sessionId']
+            ret.append(DeviceInfo(
+                serial=serial,
+                model=item['capabilities']['deviceModel'],
+                name=item['capabilities']['deviceName'],
+            ))
+        return ret
+    
+    def get_device_driver(self, serial: str, session_id: str = None) -> BaseDriver:
+        """ TODO: attach to the existing session """
+        platform_name, session_id = serial.split(':', 1)
+        filtered_sessions = [session for session in self.sessions if session['sessionId'] == session_id]
+        if len(filtered_sessions) == 1:
+            session = filtered_sessions[0]
+            driver = self.attach_session(session)
+            return AppiumDriver(driver, is_attached=True)
+        else:
+            options = UiAutomator2Options() if platform_name == "Android" else XCUITestOptions()
+            driver = webdriver.Remote(self.command_executor, options=options)
+            return AppiumDriver(driver)
+        
+    @httpretty.activate(allow_net_connect=False)
+    def attach_session(self, session: dict) -> webdriver.Remote:
+        """
+        https://github.com/appium/python-client/issues/212
+        the author say it can't
+        """
+        body = json.dumps({'value': session}, indent=4)
+        logger.debug("Mock response: POST /wd/hub/session", body)
+        httpretty.register_uri(httpretty.POST,
+                               self.command_executor + '/session',
+                               body=body,
+                               headers={'Content-Type': 'application/json'})
+        options = UiAutomator2Options()# if platform_name == "Android" else XCUITestOptions()
+        driver = webdriver.Remote(command_executor=self.command_executor, strict_ssl=False, options=options)
+        return driver
+
+    def get_single_device_driver(self) -> BaseDriver:
+        devices = self.list_devices()
+        if len(devices) == 0:
+            return self.get_device_driver("Android:12345")
+        #     raise AppiumDriverException("No device found")
+        return self.get_device_driver(devices[0].serial)
+
+
+class AppiumDriver(BaseDriver):
+    def __init__(self, driver: webdriver.Remote, is_attached: bool = False):
+        self.driver = driver
+        self.is_attached = is_attached
+    
+    # def __del__(self):
+    #     if not self.is_attached:
+    #         self.driver.quit()
+
+    def screenshot(self, id: int) -> Image:
+        png_data = self.driver.get_screenshot_as_png()
+        return Image.open(io.BytesIO(png_data))
+
+    def window_size(self) -> WindowSize:
+        size = self.driver.get_window_size()
+        return WindowSize(width=size["width"], height=size["height"])
+        
+    def dump_hierarchy(self) -> Tuple[str, Node]:
+        source = self.driver.page_source
+        wsize = self.window_size()
+        return source, parse_xml(source, wsize)
+    
+    def shell(self, command: str) -> ShellResponse:
+        # self.driver.execute_script(command)
+        raise NotImplementedError()
+
+    def tap(self, x: int, y: int):
+        self.driver.tap([(x, y)], 100)
+        print("Finished")
+    
+    def app_install(self, app_path: str):
+        self.driver.install_app(app_path)
+    
+    def app_current(self) -> CurrentAppResponse:
+        package = self.driver.current_package
+        activity = self.driver.current_activity
+        return CurrentAppResponse(package=package, activity=activity)
+
+    def home(self):
+        self.driver.press_keycode(3)

uiautodev/driver/base_driver.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Fri Mar 01 2024 14:18:30 by codeskyblue
+"""
+import abc
+import enum
+from typing import Tuple
+
+from PIL import Image
+from pydantic import BaseModel
+
+from uiautodev.command_types import CurrentAppResponse
+from uiautodev.model import Node, ShellResponse, WindowSize
+
+
+class BaseDriver(abc.ABC):
+    def __init__(self, serial: str):
+        self.serial = serial
+
+    @abc.abstractmethod
+    def screenshot(self, id: int) -> Image.Image:
+        """Take a screenshot of the device
+        :param id: physical display ID to capture (normally: 0)
+        :return: PIL.Image.Image
+        """
+        raise NotImplementedError()
+    
+    @abc.abstractmethod
+    def dump_hierarchy(self) -> Tuple[str, Node]:
+        """Dump the view hierarchy of the device
+        :return: xml_source, Hierarchy
+        """
+        raise NotImplementedError()
+    
+    def shell(self, command: str) -> ShellResponse:
+        """Run a shell command on the device
+        :param command: shell command
+        :return: ShellResponse
+        """
+        raise NotImplementedError()
+    
+    def tap(self, x: int, y: int):
+        """Tap on the screen
+        :param x: x coordinate
+        :param y: y coordinate
+        """
+        raise NotImplementedError()
+
+    def window_size(self) -> WindowSize:
+        """ get window UI size """
+        raise NotImplementedError()
+
+    def app_install(self, app_path: str):
+        """ install app """
+        raise NotImplementedError()
+    
+    def app_current(self) -> CurrentAppResponse:
+        """ get current app """
+        raise NotImplementedError()
+    
+    def app_launch(self, package: str):
+        """ launch app """
+        raise NotImplementedError()
+    
+    def app_terminate(self, package: str):
+        """ terminate app """
+        raise NotImplementedError()
+    
+    def home(self):
+        """ press home button """
+        raise NotImplementedError()
+
+    def wake_up(self):
+        """ wake up the device """
+        raise NotImplementedError()

uiautodev/driver/ios.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Fri Mar 01 2024 14:35:46 by codeskyblue
+"""
+
+
+import base64
+import io
+import json
+import re
+from functools import partial
+from typing import List, Optional, Tuple
+from xml.etree import ElementTree
+
+from PIL import Image
+
+from uiautodev.command_types import CurrentAppResponse
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.exceptions import IOSDriverException
+from uiautodev.model import Node, WindowSize
+from uiautodev.utils.usbmux import MuxDevice, select_device
+
+
+class IOSDriver(BaseDriver):
+    def __init__(self, serial: str):
+        """ serial is the udid of the ios device """
+        super().__init__(serial)
+        self.device = select_device(serial)
+    
+    def _request(self, method: str, path: str, payload: Optional[dict] = None) -> bytes:
+        conn = self.device.make_http_connection(port=8100)
+        try:
+            if payload is None:
+                conn.request(method, path)
+            else:
+                conn.request(method, path, body=json.dumps(payload), headers={"Content-Type": "application/json"})
+            response = conn.getresponse()
+            if response.getcode() != 200:
+                raise IOSDriverException(f"Failed request to device, status: {response.getcode()}")
+            content = bytearray()
+            while chunk := response.read(4096):
+                content.extend(chunk)
+            return content
+        finally:
+            conn.close()
+    
+    def _request_json(self, method: str, path: str) -> dict:
+        content = self._request(method, path)
+        return json.loads(content)
+
+    def _request_json_value(self, method: str, path: str) -> dict:
+        return self._request_json(method, path)["value"]
+    
+    def status(self):
+        return self._request_json("GET", "/status")
+    
+    def screenshot(self, id: int = 0) -> Image.Image:
+        png_base64 = self._request_json_value("GET", "/screenshot")
+        png_data = base64.b64decode(png_base64)
+        return Image.open(io.BytesIO(png_data))
+    
+    def window_size(self):
+        return self._request_json_value("GET", "/window/size")
+    
+    def dump_hierarchy(self) -> Tuple[str, Node]:
+        """returns xml string and hierarchy object"""
+        xml_data = self._request_json_value("GET", "/source")
+        root = ElementTree.fromstring(xml_data)
+        return xml_data, parse_xml_element(root, WindowSize(width=1, height=1))
+    
+    def tap(self, x: int, y: int):
+        self._request("POST", f"/wda/tap/0", {"x": x, "y": y})
+    
+    def app_current(self) -> CurrentAppResponse:
+        # {'processArguments': {'env': {}, 'args': []}, 'name': '', 'pid': 32, 'bundleId': 'com.apple.springboard'}
+        value = self._request_json_value("GET", "/wda/activeAppInfo")
+        return CurrentAppResponse(package=value["bundleId"], pid=value["pid"])
+
+    def home(self):
+        self._request("POST", "/wda/homescreen")
+        
+
+def parse_xml_element(element, wsize: WindowSize, indexes: List[int]=[0]) -> Node:
+    """
+    Recursively parse an XML element into a dictionary format.
+    # <XCUIElementTypeApplication type="XCUIElementTypeApplication" name="设置" label="设置" enabled="true" visible="true" accessible="false" x="0" y="0" width="414" height="896" index="0">
+    """
+    if element.attrib.get("visible") == "false":
+        return None
+    if element.tag == "XCUIElementTypeApplication":
+        wsize = WindowSize(width=int(element.attrib["width"]), height=int(element.attrib["height"]))
+    x = int(element.attrib.get("x", 0))
+    y = int(element.attrib.get("y", 0))
+    width = int(element.attrib.get("width", 0))
+    height = int(element.attrib.get("height", 0))
+    bounds = (x / wsize.width, y / wsize.height, (x + width) / wsize.width, (y + height) / wsize.height)
+    bounds = list(map(partial(round, ndigits=4), bounds))
+    name = element.attrib.get("type", "XCUIElementTypeUnknown")
+    
+    elem = Node(
+        key='-'.join(map(str, indexes)),
+        name=name,
+        bounds=bounds,
+        properties={key: element.attrib[key] for key in element.attrib},
+        children=[],
+    )
+    for index, child in enumerate(element):
+        child_elem = parse_xml_element(child, wsize, indexes+[index])
+        if child_elem:
+            elem.children.append(child_elem)
+    return elem
+
+