uiautodev 0.3.3__py3-none-any.whl

uiautodev/__init__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Mon Mar 04 2024 14:28:53 by codeskyblue
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("uiautodev")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

uiautodev/__main__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Sun Feb 18 2024 14:20:15 by codeskyblue
+"""
+
+from uiautodev.cli import main
+
+if __name__ == "__main__":
+    main()

uiautodev/app.py

@@ -0,0 +1,92 @@
+#!/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
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, RedirectResponse
+from pydantic import BaseModel
+
+from uiautodev import __version__
+from uiautodev.provider import AndroidProvider, IOSProvider, MockProvider
+from uiautodev.router.device import make_router
+from uiautodev.router.xml import router as xml_router
+
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+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())
+mock_router = make_router(MockProvider())
+
+app.include_router(mock_router, prefix="/api/mock", tags=["mock"])
+
+if os.environ.get("UIAUTODEV_MOCK"):
+    app.include_router(mock_router, prefix="/api/android", tags=["mock"])
+    app.include_router(mock_router, prefix="/api/ios", 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(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"],
+    )
+
+
+@app.get("/shutdown")
+def shutdown() -> str:
+    """Shutdown the server"""
+    os.kill(os.getpid(), signal.SIGINT)
+    return "Server shutting down..."
+
+
+@app.get("/demo")
+def demo() -> str:
+    """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 """
+    return RedirectResponse("https://uiauto.dev")

uiautodev/appium_proxy.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 19 2024 22:23:37 by codeskyblue
+"""
+
+import sys
+
+import httpx
+from fastapi import FastAPI, Request, Response
+
+app = FastAPI()
+
+
+# Retrieve the target URL from the command line arguments
+try:
+    TARGET_URL = sys.argv[1]
+except IndexError:
+    print("Usage: python proxy_server.py <target_url>")
+    sys.exit(1)
+
+@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
+async def proxy(request: Request, path: str):
+    # Construct the full URL to forward the request to
+    if path.endswith('/execute/sync'):
+        # 旧版appium处理不好这个请求，直接返回404, unknown command
+        # 目前browserstack也不支持这个请求
+        return Response(content=b'{"value": {"error": "unknown command", "message": "unknown command", "stacktrace": "UnknownCommandError"}}', status_code=404)
+    full_url = f"{TARGET_URL}/{path}"
+    body = await request.body()
+    print("Forwarding to", request.method, full_url)
+    print("==> BODY <==")
+    print(body)
+    # Include original headers in the request
+    headers = {k: v for k, v in request.headers.items() if k != 'host'}
+
+    # Forward the request to the target server
+    async with httpx.AsyncClient(timeout=120) as client:
+        resp = await client.request(
+            method=request.method,
+            url=full_url,
+            headers=headers,
+            data=body,
+            follow_redirects=True,        
+        )
+
+    # Return the response received from the target server
+    return Response(content=resp.content, status_code=resp.status_code, headers=dict(resp.headers))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

uiautodev/case.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Sat Apr 13 2024 22:35:03 by codeskyblue
+"""
+
+import enum
+import logging
+from typing import Dict, Union
+
+from pydantic import BaseModel
+
+from uiautodev import command_proxy
+from uiautodev.command_types import Command
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.provider import AndroidProvider
+
+logger = logging.getLogger(__name__)
+
+class CommandStep(BaseModel):
+    method: Union[str, Command]
+    params: Dict[str, str]
+    skip: bool = False
+    ignore_error: bool = False
+
+
+class CompareEnum(str, enum.Enum):
+    EQUAL = "equal"
+    CONTAINS = "contains"
+    NOT_EQUAL = "not_equal"
+    NOT_CONTAINS = "not_contains"
+
+
+class CompareCheckStep(BaseModel):
+    method: CompareEnum
+    value_a: str
+    value_b: str
+    skip: bool = False
+
+
+def run_driver_command(driver: BaseDriver, command: Command, params: dict):
+    model = command_proxy.get_command_params_type(command)
+    params_obj = model.model_validate(params) if params else None
+    # print("Params:", params, params_obj)
+    result = command_proxy.send_command(driver, command, params_obj)
+    return result
+
+def run():
+    # all params key and value should be string
+    # Step中
+    # 入参类型在为前端保存一份，后端需要同步兼容
+    # params所有的key和value都是string类型
+    # 出参类型支持重命名 result
+    # - key: string, old_key: string, desc: string
+    # eg. "WIDTH", "width", "屏幕宽度"
+    steps = [
+        CommandStep(
+            method=Command.APP_LAUNCH,
+            params= {
+                "package": "com.saucelabs.mydemoapp.android",
+                "stop": "true" # bool
+            }
+        ),
+        CommandStep(
+            method=Command.GET_WINDOW_SIZE,
+            result_trans=[
+                dict(key="WIDTH", result_key="width", desc="屏幕宽度"),
+            ]
+        ),
+        CommandStep(
+            method=Command.ECHO,
+            params={
+                "message": "WindowWidth is {{WIDTH}}", 
+            }
+        ),
+        CommandStep(
+            method=Command.CLICK_ELEMENT,
+            params={
+                "by": "id",
+                "value": "com.saucelabs.mydemoapp.android:id/productIV",
+            }
+        ),
+        CommandStep(
+            method=Command.CLICK_ELEMENT,
+            params={
+                "by": "id",
+                "value": "com.saucelabs.mydemoapp.android:id/plusIV",
+            }
+        ),
+        CommandStep(
+            method=Command.CLICK_ELEMENT,
+            params={
+                "by": "id",
+                "value": "com.saucelabs.mydemoapp.android:id/cartBt",
+            }
+        ),
+        CommandStep(
+            method=Command.CLICK_ELEMENT,
+            params={
+                "by": "id",
+                "value": "com.saucelabs.mydemoapp.android:id/cartIV",
+            }
+        ),
+        CommandStep(
+            method=Command.FIND_ELEMENT,
+            params={
+                "by": "text",
+                "value": "Proceed To Checkout",
+            },
+            skip=True,
+        ),
+        CompareCheckStep(
+            method=CompareEnum.EQUAL,
+            value_a="$.name",
+            value_b="com.saucelabs.mydemoapp.android:id/cartIV",
+        ),
+        CommandStep(
+            method=Command.CLICK_ELEMENT,
+            params={
+                "by": "text",
+                "value": "Proceed To Checkout",
+            }
+        ),
+    ]
+    provider = AndroidProvider()
+    driver = provider.get_single_device_driver()
+    local_vars: Dict[str, str] = {}
+    for step in steps:
+        if not isinstance(step, CommandStep):
+            continue
+        command = Command(step.method)
+        params = step.params
+        print(step.method, params)
+        if step.skip:
+            logger.debug("Skip step: %s", step.method)
+            continue
+        run_driver_command(driver, command, params)

uiautodev/cli.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 19 2024 10:53:03 by codeskyblue
+"""
+
+from __future__ import annotations
+
+import logging
+import platform
+import sys
+import threading
+import time
+from pprint import pprint
+
+import click
+import httpx
+import pydantic
+import uvicorn
+
+from uiautodev import __version__, command_proxy
+from uiautodev.command_types import Command
+from uiautodev.provider import AndroidProvider, BaseProvider, IOSProvider
+from uiautodev.utils.common import convert_params_to_model, print_json
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+@click.option("--verbose", "-v", is_flag=True, default=False, help="verbose mode")
+def cli(verbose: bool):
+    if verbose:
+        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)
+        logger.debug("Verbose mode enabled")
+
+
+def run_driver_command(provider: BaseProvider, command: Command, params: list[str] = None):
+    if command == Command.LIST:
+        devices = provider.list_devices()
+        print("==> Devices <==")
+        pprint(devices)
+        return
+    driver = provider.get_single_device_driver()
+    params_obj = None
+    model = command_proxy.get_command_params_type(command)
+    if model:
+        if not params:
+            print(f"params is required for {command}")
+            pprint(model.model_json_schema())
+            return
+        params_obj = convert_params_to_model(params, model)
+
+    try:
+        print("Command:", command.value)
+        print("Params ↓")
+        print_json(params_obj)
+        result = command_proxy.send_command(driver, command, params_obj)
+        print("Result ↓")
+        print_json(result)
+    except pydantic.ValidationError as e:
+        print(f"params error: {e}")
+        print(f"\n--- params should be match schema ---")
+        pprint(model.model_json_schema()["properties"])
+
+
+@cli.command(help="COMMAND: " + ", ".join(c.value for c in Command))
+@click.argument("command", type=Command, required=True)
+@click.argument("params", required=False, nargs=-1)
+def android(command: Command, params: list[str] = None):
+    provider = AndroidProvider()
+    run_driver_command(provider, command, params)
+
+
+@cli.command(help="COMMAND: " + ", ".join(c.value for c in Command))
+@click.argument("command", type=Command, required=True)
+@click.argument("params", required=False, nargs=-1)
+def ios(command: Command, params: list[str] = None):
+    provider = IOSProvider()
+    run_driver_command(provider, command, params)
+
+
+@cli.command(help="run case (beta)")
+def case():
+    from uiautodev.case import run
+    run()
+
+
+@cli.command(help="COMMAND: " + ", ".join(c.value for c in Command))
+@click.argument("command", type=Command, required=True)
+@click.argument("params", required=False, nargs=-1)
+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)
+    except AppiumDriverException as e:
+        print(f"Error: {e}")
+
+
+@cli.command('version')
+def print_version():
+    print(__version__)
+
+
+@cli.command(help="start uiauto.dev local server [default]")
+@click.option("--port", default=20242, help="port number", show_default=True)
+@click.option("--host", default="127.0.0.1", help="host", show_default=True)
+@click.option("--reload", is_flag=True, default=False, help="auto reload, dev only")
+@click.option("-f", "--force", is_flag=True, default=False, help="shutdown alrealy runningserver")
+@click.option("--no-browser", is_flag=True, default=False, help="do not open browser")
+def server(port: int, host: str, reload: bool, force: bool, no_browser: bool):
+    logger.info("version: %s", __version__)
+    if force:
+        try:
+            httpx.get(f"http://{host}:{port}/shutdown", timeout=3)
+        except httpx.HTTPError:
+            pass
+
+    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
+        th.start()
+    uvicorn.run("uiautodev.app:app", host=host, port=port, reload=reload, use_colors=use_color)
+
+
+def open_browser_when_server_start(server_url: str):
+    deadline = time.time() + 10
+    while time.time() < deadline:
+        try:
+            httpx.get(f"{server_url}/api/info", timeout=1)
+            break
+        except Exception as e:
+            time.sleep(0.5)
+    import webbrowser
+    web_url = "https://uiauto.dev"
+    logger.info("open browser: %s", web_url)
+    webbrowser.open(web_url)
+
+def main():
+    # set logger level to INFO
+    # logging.basicConfig(level=logging.INFO)
+    logger.setLevel(logging.INFO)
+
+    has_command = False
+    for name in sys.argv[1:]:
+        if not name.startswith("-"):
+            has_command = True
+
+    if not has_command:
+        cli.main(args=sys.argv[1:] + ["server"], prog_name="uiauto.dev")
+    else:
+        cli()
+
+
+if __name__ == "__main__":
+    main()

uiautodev/command_proxy.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 19 2024 10:43:51 by codeskyblue
+"""
+
+from __future__ import annotations
+
+import time
+import typing
+from typing import Callable, Dict, Optional
+
+from pydantic import BaseModel
+
+from uiautodev.command_types import AppLaunchRequest, AppTerminateRequest, By, Command, CurrentAppResponse, \
+    DumpResponse, FindElementRequest, FindElementResponse, InstallAppRequest, InstallAppResponse, TapRequest, \
+    WindowSizeResponse
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.exceptions import ElementNotFoundError
+from uiautodev.model import Node
+from uiautodev.utils.common import node_travel
+
+COMMANDS: Dict[Command, Callable] = {}
+
+
+def register(command: Command):
+    def wrapper(func):
+        COMMANDS[command] = func
+        return func
+
+    return wrapper
+
+
+def get_command_params_type(command: Command) -> Optional[BaseModel]:
+    func = COMMANDS.get(command)
+    if func is None:
+        return None
+    type_hints = typing.get_type_hints(func)
+    return type_hints.get("params")
+
+
+def send_command(driver: BaseDriver, command: Command, params=None):
+    if command not in COMMANDS:
+        raise NotImplementedError(f"command {command} not implemented")
+    func = COMMANDS[command]
+    type_hints = typing.get_type_hints(func)
+    if type_hints.get("params"):
+        if params is None:
+            raise ValueError(f"params is required for {command}")
+        if not isinstance(params, type_hints["params"]):
+            raise TypeError(f"params should be {type_hints['params']}")
+    if params is None:
+        return func(driver)
+    return func(driver, params)
+
+
+@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
+    if params.isPercent:
+        wsize = driver.window_size()
+        x = int(wsize[0] * params.x)
+        y = int(wsize[1] * params.y)
+    driver.tap(x, y)
+
+
+@register(Command.APP_INSTALL)
+def app_install(driver: BaseDriver, params: InstallAppRequest):
+    """install app"""
+    driver.app_install(params.url)
+    return InstallAppResponse(success=True, id=None)
+
+
+@register(Command.APP_CURRENT)
+def app_current(driver: BaseDriver) -> CurrentAppResponse:
+    """get current app"""
+    return driver.app_current()
+
+
+@register(Command.APP_LAUNCH)
+def app_launch(driver: BaseDriver, params: AppLaunchRequest):
+    if params.stop:
+        driver.app_terminate(params.package)
+    driver.app_launch(params.package)
+
+
+@register(Command.APP_TERMINATE)
+def app_terminate(driver: BaseDriver, params: AppTerminateRequest):
+    driver.app_terminate(params.package)
+
+
+@register(Command.GET_WINDOW_SIZE)
+def window_size(driver: BaseDriver) -> WindowSizeResponse:
+    wsize = driver.window_size()
+    return WindowSizeResponse(width=wsize[0], height=wsize[1])
+
+
+@register(Command.HOME)
+def home(driver: BaseDriver):
+    driver.home()
+
+
+@register(Command.DUMP)
+def dump(driver: BaseDriver) -> DumpResponse:
+    source, _ = driver.dump_hierarchy()
+    return DumpResponse(value=source)
+
+
+@register(Command.WAKE_UP)
+def wake_up(driver: BaseDriver):
+    driver.wake_up()
+
+
+def node_match(node: Node, by: By, value: str) -> bool:
+    if by == By.ID:
+        return node.properties.get("resource-id") == value
+    if by == By.TEXT:
+        return node.properties.get("text") == value
+    if by == By.CLASS_NAME:
+        return node.name == value
+    raise ValueError(f"not support by {by!r}")
+
+
+@register(Command.FIND_ELEMENTS)
+def find_elements(driver: BaseDriver, params: FindElementRequest) -> FindElementResponse:
+    _, root_node = driver.dump_hierarchy()
+    # TODO: support By.XPATH
+    nodes = []
+    for node in node_travel(root_node):
+        if node_match(node, params.by, params.value):
+            nodes.append(node)
+    return FindElementResponse(count=len(nodes), value=nodes)
+
+
+@register(Command.CLICK_ELEMENT)
+def click_element(driver: BaseDriver, params: FindElementRequest):
+    node = None
+    deadline = time.time() + params.timeout
+    while time.time() < deadline:
+        result = find_elements(driver, params)
+        if result.value:
+            node = result.value[0]
+            break
+        time.sleep(.5) # interval
+    if not node:
+        raise ElementNotFoundError(f"element not found by {params.by}={params.value}")
+    center_x = (node.bounds[0] + node.bounds[2]) / 2
+    center_y = (node.bounds[1] + node.bounds[3]) / 2
+    tap(driver, TapRequest(x=center_x, y=center_y, isPercent=True))