pantoqa-bridge 0.4.4__py3-none-any.whl

pantoqa_bridge/__main__.py

@@ -0,0 +1,4 @@
+from .cli import cli
+
+if __name__ == "__main__":
+  cli()

pantoqa_bridge/cli.py

@@ -0,0 +1,58 @@
+import click
+
+from pantoqa_bridge.config import PKG_NAME, SERVER_HOST, SERVER_PORT
+from pantoqa_bridge.server import start_bridge_server
+from pantoqa_bridge.tasks.executor import AppiumExecutable, MaestroExecutable, QAExecutable
+from pantoqa_bridge.utils.misc import make_sync
+from pantoqa_bridge.utils.pkg import get_pkg_version
+
+
+@click.group(help="PantoAI QA Extension CLI", invoke_without_command=True)
+@click.option("--version", is_flag=True, help="Show version and exit")
+@click.pass_context
+def cli(ctx: click.Context, version: bool) -> None:
+  if version:
+    click.echo(f"PantoQA Bridge version: {get_pkg_version(PKG_NAME)}")
+    ctx.exit(0)
+
+  if ctx.invoked_subcommand is None:
+    ctx.invoke(serve)
+
+
+@cli.command()
+@click.option("--host", default=SERVER_HOST, show_default=True, help="Bind address")
+@click.option("--port", default=SERVER_PORT, show_default=True, type=int, help="Port to listen on")
+def serve(host: str, port: int) -> None:
+  start_bridge_server(host, port)
+
+
+@cli.command()
+@click.option("--framework",
+              type=click.Choice(["appium", "maestro"], case_sensitive=False),
+              required=True,
+              help="QA framework to use")
+@click.argument("files", nargs=-1, required=True, type=click.Path(exists=True))
+@click.option("--maestro-bin", help="Path to Maestro binary (for maestro framework)")
+@click.option("--appium-url", help="Appium server URL (for appium framework)")
+@make_sync
+async def execute(
+  framework: str,
+  files: list[str],
+  maestro_bin: str | None = None,
+  appium_url: str | None = None,
+) -> None:
+
+  executable: QAExecutable | None = None
+  if framework.lower() == "maestro":
+    executable = MaestroExecutable(files=files, maestro_bin=maestro_bin)
+  elif framework.lower() == "appium":
+    executable = AppiumExecutable(files=files, appium_url=appium_url)
+  else:
+    raise click.ClickException(f"Unsupported framework: {framework}")
+
+  await executable.execute()
+  click.echo("Execution completed.")
+
+
+if __name__ == "__main__":
+  cli()

pantoqa_bridge/config.py

@@ -0,0 +1,35 @@
+import os
+import platform
+from importlib.resources import files
+
+from dotenv import load_dotenv
+
+load_dotenv(
+  dotenv_path=".envrc",
+  verbose=True,
+)
+
+PKG_NAME = "pantoqa_bridge"
+
+
+def resource_path(path: str) -> str:
+  try:
+    return str(files(PKG_NAME).joinpath(path))
+  except Exception:
+    return path
+
+
+SCRCPY_SERVER_BIN = resource_path("scrcpy-server-v3.3.1")
+SCRCPY_SERVER_VERSION = "3.3.1"
+SCRCPY_SOCKET_PORT = 27888
+
+IS_WINDOWS = platform.system() == "Windows"
+
+SERVER_HOST = os.getenv("SERVER_HOST") or ("0.0.0.0" if not IS_WINDOWS else "127.0.0.1")
+SERVER_PORT = int(os.getenv("SERVER_PORT") or "6565")
+
+APPIUM_SERVER_HOST = os.getenv("APPIUM_SERVER_HOST") or SERVER_HOST
+APPIUM_SERVER_PORT = int(os.getenv("APPIUM_SERVER_PORT") or "6566")
+APPIUM_SERVER_URL = f"http://{APPIUM_SERVER_HOST}:{APPIUM_SERVER_PORT}"
+
+MAESTRO_BIN = "maestro"

pantoqa_bridge/lib/adb.py

@@ -0,0 +1,112 @@
+import asyncio
+import subprocess
+from asyncio.subprocess import Process
+from typing import Literal, overload
+
+ADB_BIN = "adb"
+
+
+class ADB:
+
+  def __init__(
+    self,
+    adb: str = ADB_BIN,
+    device_serial: str | None = None,
+  ):
+    self.adb = adb
+    self.device_serial = device_serial
+
+  async def device_list(self) -> list[str]:
+    cmd = ["devices"]
+    res = await self._run_adb_cmd(cmd)
+    lines = res.stdout.decode().splitlines()
+    devices = []
+    for line in lines[1:]:
+      if line.strip():
+        device_id = line.split("\t")[0]
+        devices.append(device_id)
+    return devices
+
+  async def push(
+    self,
+    local_path: str,
+    remote_path: str,
+  ) -> subprocess.CompletedProcess:
+    cmd = ["push", local_path, remote_path]
+    res = await self._run_adb_cmd(cmd)
+    return res
+
+  async def shell(self, command: str) -> subprocess.CompletedProcess:
+    cmd = ["shell", command]
+    res = await self._run_adb_cmd(cmd)
+    return res
+
+  async def exec(
+    self,
+    command: list[str],
+    skip_check: bool = False,
+  ) -> subprocess.CompletedProcess:
+    return await self._run_adb_cmd(
+      command,
+      skip_check=skip_check,
+    )
+
+  async def exec_p(
+    self,
+    command: list[str],
+  ) -> Process:
+    return await self._run_adb_cmd(command, return_process=True)
+
+  @overload
+  async def _run_adb_cmd(
+    self,
+    cmd: list[str],
+    *,
+    return_process: Literal[True],
+    skip_check: bool = False,
+  ) -> Process:
+    ...
+
+  @overload
+  async def _run_adb_cmd(
+    self,
+    cmd: list[str],
+    *,
+    return_process: Literal[False] = False,
+    skip_check: bool = False,
+  ) -> subprocess.CompletedProcess:
+    ...
+
+  async def _run_adb_cmd(
+    self,
+    cmd: list[str],
+    *,
+    return_process: bool = False,
+    skip_check=False,
+  ) -> subprocess.CompletedProcess | Process:
+    if self.device_serial:
+      cmds = [self.adb, "-s", self.device_serial] + cmd
+    else:
+      cmds = [self.adb] + cmd
+
+    print(f"Executing ADB command: {' '.join(cmds)}")
+
+    process = await asyncio.create_subprocess_exec(
+      *cmds,
+      stdout=asyncio.subprocess.PIPE,
+      stderr=asyncio.subprocess.PIPE,
+    )
+    if return_process:
+      return process
+
+    stdout, stderr = await process.communicate()
+
+    if not skip_check and process.returncode != 0:
+      raise subprocess.CalledProcessError(
+        process.returncode or -1,
+        cmds,
+        output=stdout,
+        stderr=stderr,
+      )
+
+    return subprocess.CompletedProcess(cmds, process.returncode or 0, stdout, stderr)

pantoqa_bridge/lib/scrcpy.py

@@ -0,0 +1,119 @@
+import asyncio
+import signal
+import socket
+from asyncio.subprocess import Process
+from collections.abc import Awaitable, Callable
+
+from pantoqa_bridge.config import SCRCPY_SERVER_BIN, SCRCPY_SERVER_VERSION, SCRCPY_SOCKET_PORT
+from pantoqa_bridge.lib.adb import ADB
+
+# ADB = "adb"
+
+
+class InvalidDummyByte(Exception):
+  ...
+
+
+class ScrcpyPyClient:
+
+  def __init__(
+    self,
+    on_frame_update: Callable[[bytes], Awaitable[None]],
+    max_size: int | None = None,
+    server_version: str = SCRCPY_SERVER_VERSION,
+    sever_port: int = SCRCPY_SOCKET_PORT,
+    server_bin: str = SCRCPY_SERVER_BIN,
+    adb: ADB | None = None,
+    device_serial: str | None = None,
+  ):
+    self.on_frame = on_frame_update
+    self.device_serial = device_serial
+    self.adb = adb or ADB(device_serial=self.device_serial)
+    self.server_bin = server_bin
+    self.socket_port = sever_port
+    self.server_version = server_version
+    self.max_size = max_size or 720
+    self._is_stopping = asyncio.Event()
+    self._remote_tmp_path = f"/data/local/tmp/scrcpy-server{server_version}"
+    self._scrcpy_process: Process | None = None
+
+  async def push_server(self):
+    await self.adb.push(self.server_bin, self._remote_tmp_path)
+
+  async def start_server(self):
+    cmd = [
+      "shell",
+      f"CLASSPATH={self._remote_tmp_path}",
+      "app_process",
+      "/",
+      "com.genymobile.scrcpy.Server",
+      self.server_version,
+      "control=false",
+      "audio=false",
+      "tunnel_forward=true",
+      f"max_size={self.max_size}",
+    ]
+    process = await self.adb.exec_p(cmd)
+    self._scrcpy_process = process
+    assert process.stdout, "Scrcpy process stdout is None."
+    data = await process.stdout.readline()  # some delay until server starts
+    print(f"[Scrcpy]: {data!r}")
+    print("Scrcpy server started.")
+
+  async def forward_video_socket(self):
+    cmd = ["forward", f"tcp:{self.socket_port}", "localabstract:scrcpy"]
+    await self.adb.exec(cmd)
+
+  async def read_video_socket(self, connect_timeout: int = 30):
+
+    async def connect() -> socket.socket:
+      print("Trying to connect to video socket...")
+      sock = socket.create_connection(("127.0.0.1", self.socket_port), timeout=5)
+      sock.setblocking(False)
+      loop = asyncio.get_running_loop()
+      DUMMY_FIELD_LENGTH = 1
+      dummy_byte = await loop.sock_recv(sock, DUMMY_FIELD_LENGTH)
+      if not len(dummy_byte) or dummy_byte != b"\x00":
+        print(f"Received invalid dummy byte: {dummy_byte!r}")
+        sock.close()
+        raise InvalidDummyByte("invalid_dummy_byte")
+
+      return sock
+
+    async def connect_with_retries(connect_timeout: int = 30) -> socket.socket:
+      start_time = asyncio.get_running_loop().time()
+      while True:
+        print("Attempting to connect to scrcpy video socket...")
+        try:
+          sock = await connect()
+          return sock
+        except InvalidDummyByte as e:
+          if asyncio.get_running_loop().time() - start_time > connect_timeout:
+            raise TimeoutError("Timeout connecting to scrcpy video socket.")
+          print(f"Connection to video socket failed: {e}. Retrying...")
+          await asyncio.sleep(1)
+
+    sock = await connect_with_retries(connect_timeout)
+    print("Connected to video socket. Streaming video data...")
+
+    loop = asyncio.get_running_loop()
+    while not self._is_stopping.is_set():
+      try:
+        raw_data = await loop.sock_recv(sock, 0x10000)
+        if not raw_data:
+          print("No more data from video stream. Exiting...")
+          break
+        await self.on_frame(raw_data)
+      except Exception as e:
+        print(f"Error reading video stream: {e}")
+        raise e
+
+  async def stop(self):
+    self._is_stopping.set()
+    cmd = ["forward", "--remove", f"tcp:{self.socket_port}"]
+    await self.adb.exec(cmd, skip_check=True)
+    print("Stopped scrcpy client.")
+    if self._scrcpy_process:
+      print("Terminating scrcpy server process...")
+      self._scrcpy_process.send_signal(signal.SIGTERM)
+      await self._scrcpy_process.wait()

pantoqa_bridge/logger.py

@@ -0,0 +1,39 @@
+import logging
+
+from rich.logging import RichHandler
+
+logging.getLogger("httpx").setLevel(logging.ERROR)
+
+_logger_name = 'pantoqa.automations'
+
+
+def setup_logger():
+  formatter = logging.Formatter('%(levelname)s: %(asctime)s %(filename)s:%(lineno)d %(message)s')
+  loghandler = logging.StreamHandler()
+
+  logger = logging.getLogger(_logger_name)
+  logger.setLevel(logging.INFO)
+  loghandler.setFormatter(formatter)
+  logger.addHandler(loghandler)
+  logger.propagate = False
+  return logger
+
+
+def setup_logger_cli():
+  formatter = logging.Formatter("%(message)s")
+  loghandler = RichHandler(
+    markup=True,
+    rich_tracebacks=False,
+    show_time=False,
+    show_path=False,
+  )
+
+  logger = logging.getLogger(_logger_name)
+  logger.setLevel(logging.INFO)
+  loghandler.setFormatter(formatter)
+  logger.addHandler(loghandler)
+  logger.propagate = False
+  return logger
+
+
+logger = setup_logger_cli()

pantoqa_bridge/models/code_execute.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class CodeFile(BaseModel):
+  path: str
+  content: str

pantoqa_bridge/routes/action.py

@@ -0,0 +1,114 @@
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from pantoqa_bridge.service.uiautomator_action import LocalBridgeService
+
+router = APIRouter()
+
+
+class Action(BaseModel):
+  action_type: str
+  params: dict | None = None
+
+
+class ActionRequestModel(BaseModel):
+  id: str
+  action: Action
+  device_serial_no: str | None = None
+
+
+class ActionResponseModel(BaseModel):
+  id: str
+  type: str
+  data: Any | None = None
+
+
+@router.post('/perform-action', response_model=ActionResponseModel)
+async def perform_action(request: ActionRequestModel):
+  action = request.action
+  srv = LocalBridgeService(request.device_serial_no)
+  result = _process_action(srv, action)
+  response = ActionResponseModel(id=request.id, type="driver_action_response", data=result)
+  return response
+
+
+def _process_action(srv: LocalBridgeService, action: Action):
+  action_type = action.action_type
+  if action_type == "screenshot":
+    return srv.take_screenshot()
+  if action_type == "click":
+    params = action.params
+    assert params, "params is not present."
+    srv.click(params['x'], params['y'])
+    return
+  if action_type == "long_click":
+    params = action.params
+    assert params, "params is not present."
+    srv.long_click(params['x'], params['y'])
+    return
+  if action_type == "get_os_version":
+    return srv.get_os_version()
+  if action_type == "get_device_model":
+    return srv.get_device_model()
+  if action_type == "get_device_resolution":
+    return srv.device_resolution()
+  if action_type == "get_ui_dump":
+    return srv.get_ui_dump()
+  if action_type == "get_current_app_activity":
+    return srv.get_current_app_activity()
+  if action_type == "get_main_activity":
+    params = action.params
+    assert params, "params is not present."
+    return srv.get_main_activity(params['package_name'])
+  if action_type == "get_all_packages":
+    return srv.get_all_packages()
+  if action_type == "open_app":
+    params = action.params
+    assert params, "params is not present."
+    srv.open_app(params['package_name'], params['activity_name'])
+    return
+  if action_type == "close_keyboard":
+    srv.close_keyboard()
+    return
+  if action_type == "press_enter":
+    srv.press_enter()
+    return
+  if action_type == "go_back":
+    srv.go_back()
+    return
+  if action_type == "is_keyboard_open":
+    return srv.is_keyboard_open()
+  if action_type == "goto_home":
+    srv.goto_home()
+    return
+  if action_type == "clear_all_inputs":
+    srv.clear_all_inputs()
+    return
+  if action_type == "backspace":
+    srv.backspace()
+    return
+  if action_type == "input_text":
+    params = action.params
+    assert params, "params is not present."
+    srv.input_text(params['text'])
+    return
+  if action_type == "swipe":
+    params = action.params
+    assert params, "params is not present."
+    srv.swipe(params['x1'], params['y1'], params['x2'], params['y2'])
+    return
+  if action_type == "long_press":
+    params = action.params
+    assert params, "params is not present."
+    srv.long_press(params['x'], params['y'])
+    return
+  if action_type == "get_oem_name":
+    return srv.get_oem_name()
+  if action_type == "get_device_name":
+    return srv.get_device_name()
+  if action_type == "get_os_build_version":
+    return srv.get_os_build_version()
+
+  raise ValueError(f"Unsupported action type: {action_type}")

pantoqa_bridge/routes/adb.py

@@ -0,0 +1,16 @@
+from adbutils import adb  # type:ignore
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+class ADBDeviceList(BaseModel):
+  serial_no: str
+
+
+router = APIRouter()
+
+
+@router.post("/get-devices", response_model=list[ADBDeviceList])
+async def get_available_devices():
+  devices = adb.device_list()
+  return [ADBDeviceList(serial_no=d.serial) for d in devices]

pantoqa_bridge/routes/executor.py

@@ -0,0 +1,117 @@
+import asyncio
+import json
+import sys
+import tempfile
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Literal
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from pantoqa_bridge.config import PKG_NAME
+from pantoqa_bridge.logger import logger
+from pantoqa_bridge.models.code_execute import CodeFile
+from pantoqa_bridge.utils.process import create_stream_pipe, stream_process
+
+route = APIRouter()
+
+
+class ExecutionRequest(BaseModel):
+  files: list[CodeFile]
+  framework: Literal['APPIUM', 'MAESTRO']
+
+
+class ExecutionResult(BaseModel):
+  status: str
+  exit_code: int | None = None
+  message: str | None = None
+
+
+@route.post("/execute")
+async def execute(rawrequest: Request) -> StreamingResponse:
+  request_json = await rawrequest.json()
+  request = ExecutionRequest.model_validate(request_json)
+  if not request.files:
+    raise HTTPException(status_code=400, detail="At least one file is required")
+
+  stream, push_to_stream, done = create_stream_pipe()
+
+  async def emit(event: str, data: str) -> None:
+    logger.info(f"[SSE]:{event}, data: {data}")
+    await push_to_stream(_format_sse(event, data))
+
+  async def task():
+    try:
+      await _execute_qacode(request, emit)
+    finally:
+      done.set()
+
+  asyncio.create_task(task())
+  return StreamingResponse(stream, media_type="text/event-stream")
+
+
+def _format_sse(event: str, data: str) -> str:
+  json_dict = {
+    "event": event,
+    "data": data,
+  }
+  json_str = json.dumps(json_dict)
+  return f"data: {json_str}\n\n"
+
+
+async def _execute_qacode(
+  request: ExecutionRequest,
+  on_data: Callable[[str, str], Awaitable[None]],
+):
+  logger.info(f"Executing QA code with framework: {request.framework}")
+  copiedfiles: list[str] = []
+  with tempfile.TemporaryDirectory(prefix="pantoqa-qa-run-") as tmpdir:
+    workdir = Path(tmpdir)
+    for code_file in request.files:
+      target = workdir / code_file.path
+      target.parent.mkdir(parents=True, exist_ok=True)
+      target.write_text(code_file.content)
+      copiedfiles.append(str(target))
+
+    await on_data("status", "Starting testing...")
+
+    process: asyncio.subprocess.Process | None = None
+    try:
+      cmd = [
+        sys.executable,
+        "-u",  # unbuffered output
+        "-m",
+        PKG_NAME,
+        "execute",
+        "--framework",
+        request.framework.lower(),
+        *copiedfiles,
+      ]
+      process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        cwd=workdir,
+        start_new_session=True,
+        # env={**os.environ.copy(), "PYTHONUNBUFFERED": "1"},
+      )
+      logger.info(f"Started execution process with PID: {process.pid}")
+      await stream_process(process, on_data)
+      exit_code = process.returncode
+    except asyncio.CancelledError:
+      if process and process.returncode is None:
+        process.kill()
+      await on_data("status", "Execution cancelled.")
+      raise
+    except Exception as e:
+      if process and process.returncode is None:
+        process.kill()
+      exit_code = process.returncode if process else -1
+      await on_data("exception", f"Execution failed: {str(e)}")
+      logger.exception(f"Execution failed: {str(e)}")
+
+    await on_data("status", f"Execution completed with exit code: {exit_code}")
+    logger.info(f"Execution completed with exit code: {exit_code}")
+    return exit_code