uiautodev 0.3.5__tar.gz → 0.3.7__tar.gz

{uiautodev-0.3.5 → uiautodev-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uiautodev
-Version: 0.3.5
+Version: 0.3.7
 Summary: Mobile UI Automation, include UI hierarchy inspector, script recorder
 Home-page: https://uiauto.dev
 License: MIT
@@ -25,6 +25,7 @@ Requires-Dist: httpx
 Requires-Dist: lxml
 Requires-Dist: pillow
 Requires-Dist: poetry (>=1.8.2,<2.0.0)
+Requires-Dist: pydantic (>=2.6,<3.0)
 Requires-Dist: pygments (>=2)
 Requires-Dist: uiautomator2 (>=2)
 Requires-Dist: uvicorn[standard]

{uiautodev-0.3.5 → uiautodev-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "uiautodev"
-version = "0.3.5"
+version = "0.3.7"
 description = "Mobile UI Automation, include UI hierarchy inspector, script recorder"
 homepage = "https://uiauto.dev"
 authors = ["codeskyblue <codeskyblue@gmail.com>"]
@@ -22,6 +22,7 @@ httpx = "*"
 fastapi = "^0.111.0"
 uvicorn = {version = "*", extras = ["standard"]}
 poetry = "^1.8.2"
+pydantic = "^2.6"
 
 [tool.poetry.extras]
 appium = ["appium-python-client", "httppretty"]

{uiautodev-0.3.5 → uiautodev-0.3.7}/uiautodev/app.py

@@ -68,7 +68,7 @@ def info() -> InfoResponse:
         platform=platform.system(),  # Linux | Darwin | Windows
         code_language="Python",
         cwd=os.getcwd(),
-        drivers=["android"],
+        drivers=["android", "ios"],
     )
 
 

{uiautodev-0.3.5 → uiautodev-0.3.7}/uiautodev/driver/android.py

@@ -9,11 +9,10 @@ import logging
 import re
 import time
 from functools import cached_property, partial
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 from xml.etree import ElementTree
 
 import adbutils
-import requests
 import uiautomator2 as u2
 from PIL import Image
 
@@ -21,7 +20,7 @@ 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.model import Node, Rect, ShellResponse, WindowSize
 from uiautodev.utils.common import fetch_through_socket
 
 logger = logging.getLogger(__name__)
@@ -29,16 +28,16 @@ logger = logging.getLogger(__name__)
 class AndroidDriver(BaseDriver):
     def __init__(self, serial: str):
         super().__init__(serial)
-        self.device = adbutils.device(serial)
+        self.adb_device = adbutils.device(serial)
         self._try_dump_list = [
             self._get_u2_hierarchy,
-            self._get_appium_hierarchy,
             self._get_udt_dump_hierarchy,
+            # self._get_appium_hierarchy,
         ]
     
     @cached_property
     def udt(self) -> UDT:    
-        return UDT(self.device)
+        return UDT(self.adb_device)
 
     @cached_property
     def ud(self) -> u2.Device:
@@ -46,8 +45,7 @@ class AndroidDriver(BaseDriver):
     
     def screenshot(self, id: int) -> Image.Image:
         try:
-            img = self.device.screenshot(display_id=id)
-            return img.convert("RGB")
+            return self.adb_device.screenshot() # display_id is not OK now
         except adbutils.AdbError as e:
             logger.warning("screenshot error: %s", str(e))
             if id > 0:
@@ -56,7 +54,7 @@ class AndroidDriver(BaseDriver):
 
     def shell(self, command: str) -> ShellResponse:
         try:
-            ret = self.device.shell2(command, rstrip=True, timeout=20)
+            ret = self.adb_device.shell2(command, rstrip=True, timeout=20)
             if ret.returncode == 0:
                 return ShellResponse(output=ret.output, error=None)
             else:
@@ -66,16 +64,16 @@ class AndroidDriver(BaseDriver):
         except Exception as e:
             return ShellResponse(output="", error=f"adb error: {str(e)}")
 
-    def dump_hierarchy(self) -> Tuple[str, Node]:
+    def dump_hierarchy(self, display_id: Optional[int] = 0) -> 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)
 
+        wsize = self.adb_device.window_size()
+        logger.debug("window size: %s", wsize)
         return xml_data, parse_xml(
-            xml_data, WindowSize(width=wsize[0], height=wsize[1])
+            xml_data, WindowSize(width=wsize[0], height=wsize[1]), display_id
         )
 
     def _dump_hierarchy_raw(self) -> str:
@@ -101,31 +99,9 @@ class AndroidDriver(BaseDriver):
     def _get_u2_hierarchy(self) -> str:
         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)
+        c = self.adb_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"]
@@ -140,56 +116,64 @@ class AndroidDriver(BaseDriver):
         return self.udt.dump_hierarchy()
     
     def tap(self, x: int, y: int):
-        self.device.click(x, y)
+        self.adb_device.click(x, y)
 
     def window_size(self) -> Tuple[int, int]:
-        w, h = self.device.window_size()
+        w, h = self.adb_device.window_size()
         return (w, h)
 
     def app_install(self, app_path: str):
-        self.device.install(app_path)
+        self.adb_device.install(app_path)
 
     def app_current(self) -> CurrentAppResponse:
-        info = self.device.app_current()
+        info = self.adb_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:
+        if self.adb_device.package_info(package) is None:
             raise AndroidDriverException(f"App not installed: {package}")
-        self.device.app_start(package)
+        self.adb_device.app_start(package)
     
     def app_terminate(self, package: str):
-        self.device.app_stop(package)
+        self.adb_device.app_stop(package)
 
     def home(self):
-        self.device.keyevent("HOME")
+        self.adb_device.keyevent("HOME")
     
     def wake_up(self):
-        self.device.keyevent("WAKEUP")
+        self.adb_device.keyevent("WAKEUP")
 
 
-def parse_xml(xml_data: str, wsize: WindowSize) -> Node:
+def parse_xml(xml_data: str, wsize: WindowSize, display_id: Optional[int] = None) -> Node:
     root = ElementTree.fromstring(xml_data)
-    return parse_xml_element(root, wsize)
+    node = parse_xml_element(root, wsize, display_id)
+    if node is None:
+        raise AndroidDriverException("Failed to parse xml")
+    return node
 
 
-def parse_xml_element(
-    element, wsize: WindowSize, indexes: List[int] = [0]
-) -> Node:
+def parse_xml_element(element, wsize: WindowSize, display_id: Optional[int], indexes: List[int] = [0]) -> Optional[Node]:
     """
     Recursively parse an XML element into a dictionary format.
     """
     name = element.tag
     if name == "node":
         name = element.attrib.get("class", "node")
+    if display_id is not None:
+        elem_display_id = int(element.attrib.get("display-id", display_id))
+        if elem_display_id != display_id:
+            return
+
     bounds = None
+    rect = 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
+        rect = Rect(x=bounds[0], y=bounds[1], width=bounds[2] - bounds[0], height=bounds[3] - bounds[1])
         bounds = (
             bounds[0] / wsize.width,
             bounds[1] / wsize.height,
@@ -197,16 +181,20 @@ def parse_xml_element(
             bounds[3] / wsize.height,
         )
         bounds = map(partial(round, ndigits=4), bounds)
+        
     elem = Node(
         key="-".join(map(str, indexes)),
         name=name,
         bounds=bounds,
+        rect=rect,
         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]))
+        child_node = parse_xml_element(child, wsize, display_id, indexes + [index])
+        if child_node:
+            elem.children.append(child_node)
 
     return elem

{uiautodev-0.3.5 → uiautodev-0.3.7}/uiautodev/model.py

@@ -24,10 +24,18 @@ class ShellResponse(BaseModel):
     error: Optional[str] = ""
 
 
+class Rect(BaseModel):
+    x: int
+    y: int
+    width: int
+    height: int
+
+
 class Node(BaseModel):
     key: str
     name: str
     bounds: Optional[Tuple[float, float, float, float]] = None
+    rect: Optional[Rect] = None
     properties: Dict[str, Union[str, bool]] = []
     children: List[Node] = []
 

{uiautodev-0.3.5 → uiautodev-0.3.7}/uiautodev/router/device.py

@@ -16,7 +16,6 @@ from uiautodev.command_types import Command, CurrentAppResponse, InstallAppReque
 from uiautodev.model import DeviceInfo, Node, ShellResponse
 from uiautodev.provider import BaseProvider
 
-
 logger = logging.getLogger(__name__)
 
 class AndroidShellPayload(BaseModel):
@@ -58,7 +57,7 @@ def make_router(provider: BaseProvider) -> APIRouter:
         """Take a screenshot of device"""
         try:
             driver = provider.get_device_driver(serial)
-            pil_img = driver.screenshot(id)
+            pil_img = driver.screenshot(id).convert("RGB")
             buf = io.BytesIO()
             pil_img.save(buf, format="JPEG")
             image_bytes = buf.getvalue()
@@ -68,12 +67,17 @@ def make_router(provider: BaseProvider) -> APIRouter:
             return Response(content=str(e), media_type="text/plain", status_code=500)
 
     @router.get("/{serial}/hierarchy")
-    def dump_hierarchy(serial: str) -> Node:
+    def dump_hierarchy(serial: str, format: str = "json") -> Node:
         """Dump the view hierarchy of an Android device"""
         try:
             driver = provider.get_device_driver(serial)
             xml_data, hierarchy = driver.dump_hierarchy()
-            return hierarchy
+            if format == "xml":
+                return Response(content=xml_data, media_type="text/xml")
+            elif format == "json":
+                return hierarchy
+            else:
+                return Response(content=f"Invalid format: {format}", media_type="text/plain", status_code=400)
         except Exception as e:
             logger.exception("dump_hierarchy failed")
             return Response(content=str(e), media_type="text/plain", status_code=500)