pantoqa-bridge 0.4.4__py3-none-any.whl → 0.4.20__py3-none-any.whl

pantoqa_bridge/cli.py

@@ -1,7 +1,7 @@
 import click
 
 from pantoqa_bridge.config import PKG_NAME, SERVER_HOST, SERVER_PORT
-from pantoqa_bridge.server import start_bridge_server
+from pantoqa_bridge.server import precheck_required_tools, 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
@@ -9,12 +9,21 @@ 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.option(
+  "--skip-pre-check",
+  is_flag=True,
+  default=False,
+  help="Skip pre-check of required tools",
+)
 @click.pass_context
-def cli(ctx: click.Context, version: bool) -> None:
+def cli(ctx: click.Context, version: bool, skip_pre_check: bool) -> None:
   if version:
     click.echo(f"PantoQA Bridge version: {get_pkg_version(PKG_NAME)}")
     ctx.exit(0)
 
+  if not skip_pre_check:
+    precheck_required_tools()
+
   if ctx.invoked_subcommand is None:
     ctx.invoke(serve)
 
@@ -34,19 +43,21 @@ def serve(host: str, port: int) -> None:
 @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)")
+@click.option("--device", help="Device serial number to run tests on")
 @make_sync
 async def execute(
   framework: str,
   files: list[str],
   maestro_bin: str | None = None,
   appium_url: str | None = None,
+  device: str | None = None,
 ) -> None:
 
   executable: QAExecutable | None = None
   if framework.lower() == "maestro":
-    executable = MaestroExecutable(files=files, maestro_bin=maestro_bin)
+    executable = MaestroExecutable(files=files, maestro_bin=maestro_bin, device_serial=device)
   elif framework.lower() == "appium":
-    executable = AppiumExecutable(files=files, appium_url=appium_url)
+    executable = AppiumExecutable(files=files, appium_url=appium_url, device_serial=device)
   else:
     raise click.ClickException(f"Unsupported framework: {framework}")
 

pantoqa_bridge/config.py

@@ -33,3 +33,9 @@ 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"
+INACTIVITY_TIMEOUT = 5 * 60
+
+APPIUM_BIN = os.getenv("APPIUM_BIN") or "appium"
+NODE_PATH = os.getenv("NODE_PATH") or "node"
+# ADBUTILS_ADB_PATH is also used by https://github.com/openatx/adbutils package
+ADB_BIN = os.getenv("ADBUTILS_ADB_PATH") or "adb"

pantoqa_bridge/lib/adb.py

@@ -3,7 +3,8 @@ import subprocess
 from asyncio.subprocess import Process
 from typing import Literal, overload
 
-ADB_BIN = "adb"
+from pantoqa_bridge.config import ADB_BIN
+from pantoqa_bridge.logger import logger
 
 
 class ADB:
@@ -89,7 +90,7 @@ class ADB:
     else:
       cmds = [self.adb] + cmd
 
-    print(f"Executing ADB command: {' '.join(cmds)}")
+    logger.info(f"Executing ADB command: {' '.join(cmds)}")
 
     process = await asyncio.create_subprocess_exec(
       *cmds,

pantoqa_bridge/lib/scrcpy.py

@@ -6,8 +6,7 @@ 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"
+from pantoqa_bridge.logger import logger
 
 
 class InvalidDummyByte(Exception):
@@ -34,7 +33,7 @@ class ScrcpyPyClient:
     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._remote_tmp_path = f"/data/local/tmp/scrcpy-server{self.server_version}"
     self._scrcpy_process: Process | None = None
 
   async def push_server(self):
@@ -57,8 +56,8 @@ class ScrcpyPyClient:
     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.")
+    logger.info(f"[Scrcpy]: {data!r}")
+    logger.info("Scrcpy server started.")
 
   async def forward_video_socket(self):
     cmd = ["forward", f"tcp:{self.socket_port}", "localabstract:scrcpy"]
@@ -67,14 +66,14 @@ class ScrcpyPyClient:
   async def read_video_socket(self, connect_timeout: int = 30):
 
     async def connect() -> socket.socket:
-      print("Trying to connect to video socket...")
+      logger.info("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}")
+        logger.info(f"Received invalid dummy byte: {dummy_byte!r}")
         sock.close()
         raise InvalidDummyByte("invalid_dummy_byte")
 
@@ -83,37 +82,50 @@ class ScrcpyPyClient:
     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...")
+        logger.info("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...")
+          logger.info(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...")
+    logger.info("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...")
+    try:
+      while not self._is_stopping.is_set():
+        try:
+          raw_data = await loop.sock_recv(sock, 0x10000)
+          if not raw_data:
+            logger.info("No more data from video stream. Exiting...")
+            break
+          await self.on_frame(raw_data)
+        except asyncio.CancelledError:
+          logger.info("Video socket read task cancelled.")
           break
-        await self.on_frame(raw_data)
-      except Exception as e:
-        print(f"Error reading video stream: {e}")
-        raise e
+        except Exception as e:
+          logger.info(f"Error reading video stream: {e}")
+          break
+    finally:
+      logger.info("Closing video socket...")
+      try:
+        sock.close()
+      except Exception:
+        pass
 
   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()
+    logger.info("Stopped scrcpy client.")
+    try:
+      if self._scrcpy_process:
+        logger.info("Terminating scrcpy server process...")
+        self._scrcpy_process.send_signal(signal.SIGTERM)
+        await self._scrcpy_process.wait()
+    except ProcessLookupError:
+      pass

pantoqa_bridge/models/misc.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class Action(BaseModel):
+  action_type: str
+  params: dict | None = None

pantoqa_bridge/routes/action.py

@@ -3,16 +3,12 @@ from typing import Any
 from fastapi import APIRouter
 from pydantic import BaseModel
 
-from pantoqa_bridge.service.uiautomator_action import LocalBridgeService
+from pantoqa_bridge.models.misc import Action
+from pantoqa_bridge.utils.service_manager import get_service
 
 router = APIRouter()
 
 
-class Action(BaseModel):
-  action_type: str
-  params: dict | None = None
-
-
 class ActionRequestModel(BaseModel):
   id: str
   action: Action
@@ -27,88 +23,11 @@ class ActionResponseModel(BaseModel):
 
 @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}")
+  srv = get_service(request.device_serial_no)
+  result = srv.process(request.action)
+
+  return ActionResponseModel(
+    id=request.id,
+    type="driver_action_response",
+    data=result,
+  )

pantoqa_bridge/routes/executor.py

@@ -13,7 +13,9 @@ 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
+from pantoqa_bridge.utils.process import (create_stream_pipe, kill_process_gracefully,
+                                          stream_process)
+from pantoqa_bridge.utils.service_manager import remove_all_services
 
 route = APIRouter()
 
@@ -21,6 +23,7 @@ route = APIRouter()
 class ExecutionRequest(BaseModel):
   files: list[CodeFile]
   framework: Literal['APPIUM', 'MAESTRO']
+  device_serial: str | None = None
 
 
 class ExecutionResult(BaseModel):
@@ -52,6 +55,11 @@ async def execute(rawrequest: Request) -> StreamingResponse:
   return StreamingResponse(stream, media_type="text/event-stream")
 
 
+@route.delete("/stop-test/{process_id}")
+async def stop_test(process_id: str):
+  kill_process_gracefully(int(process_id))
+
+
 def _format_sse(event: str, data: str) -> str:
   json_dict = {
     "event": event,
@@ -72,23 +80,27 @@ async def _execute_qacode(
     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)
+      target.write_text(code_file.content, encoding="utf-8")
       copiedfiles.append(str(target))
 
     await on_data("status", "Starting testing...")
 
     process: asyncio.subprocess.Process | None = None
     try:
+      remove_all_services()  # kill all the LocalBridge instance and automator connection.
       cmd = [
         sys.executable,
         "-u",  # unbuffered output
         "-m",
         PKG_NAME,
+        "--skip-pre-check",
         "execute",
         "--framework",
         request.framework.lower(),
-        *copiedfiles,
       ]
+      if request.device_serial:
+        cmd.extend(["--device", request.device_serial])
+      cmd.extend(copiedfiles)
       process = await asyncio.create_subprocess_exec(
         *cmd,
         stdout=asyncio.subprocess.PIPE,
@@ -98,6 +110,7 @@ async def _execute_qacode(
         # env={**os.environ.copy(), "PYTHONUNBUFFERED": "1"},
       )
       logger.info(f"Started execution process with PID: {process.pid}")
+      await on_data("pid", str(process.pid))
       await stream_process(process, on_data)
       exit_code = process.returncode
     except asyncio.CancelledError:

pantoqa_bridge/routes/screen_mirror.py

@@ -3,6 +3,7 @@ import asyncio
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 
 from pantoqa_bridge.lib.scrcpy import ScrcpyPyClient
+from pantoqa_bridge.logger import logger
 
 route = APIRouter()
 
@@ -14,16 +15,14 @@ async def ws_endpoint(ws: WebSocket):
   try:
     params = ws.query_params
     max_size = int(params["max_size"]) if params.get("max_size") else None
-    params["device_serial"] if params.get('device_serial') else None
-    streaming = ScreenMirrorOverWS(ws, max_size)
+    device_serial = params.get("device_serial") if params.get("device_serial") else None
+    streaming = ScreenMirrorOverWS(ws, max_size, device_serial)
     await streaming.stream()  # blocking call
-    await streaming.teardown()
   except WebSocketDisconnect:
-    print("WebSocket disconnected.")
-    if streaming:
-      await streaming.teardown()
+    logger.warning("WebSocket disconnected.")
   except Exception as e:
-    print(f"Error in WebSocket endpoint: {e}")
+    logger.exception(f"Error in WebSocket endpoint: {e}")
+  finally:
     if streaming:
       await streaming.teardown()
 
@@ -49,7 +48,7 @@ class ScreenMirrorOverWS:
     await self.scrcpy.forward_video_socket()
     await self.scrcpy.start_server()
     self._socket_read_task = asyncio.create_task(self.scrcpy.read_video_socket())
-    print("Started streaming screen over WebSocket.")
+    logger.info("Started streaming screen over WebSocket.")
     await self._socket_read_task  # Blocking call to keep streaming
 
   async def on_frame_update(self, frame: bytes):
@@ -59,17 +58,17 @@ class ScreenMirrorOverWS:
     self._is_streaming = False
 
     if self.scrcpy:
-      print("[teardown]Stopping scrcpy client...")
+      logger.info("[teardown]Stopping scrcpy client...")
       try:
         await self.scrcpy.stop()
       finally:
         self.scrcpy = None
 
     if self._socket_read_task and not self._socket_read_task.done():
-      print("[teardown]Cancelling socket read task...")
+      logger.info("[teardown]Cancelling socket read task...")
       try:
         self._socket_read_task.cancel()
       finally:
         self._socket_read_task = None
 
-    print("[teardown]Teardown complete.")
+    logger.info("[teardown]Teardown complete.")

pantoqa_bridge/server.py

@@ -7,7 +7,7 @@ import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from pantoqa_bridge.config import (APPIUM_SERVER_HOST, APPIUM_SERVER_PORT, PKG_NAME,
+from pantoqa_bridge.config import (APPIUM_BIN, APPIUM_SERVER_HOST, APPIUM_SERVER_PORT, PKG_NAME,
                                    SCRCPY_SERVER_BIN, SERVER_HOST, SERVER_PORT)
 from pantoqa_bridge.logger import logger
 from pantoqa_bridge.routes.action import router as action_router
@@ -15,28 +15,30 @@ from pantoqa_bridge.routes.adb import router as adb_router
 from pantoqa_bridge.routes.executor import route as executor_route
 from pantoqa_bridge.routes.misc import route as misc_route
 from pantoqa_bridge.routes.screen_mirror import route as screen_mirror_route
-from pantoqa_bridge.utils.misc import ensure_android_home, start_appium_process_sync
+from pantoqa_bridge.utils.misc import ensure_android_home, start_appium_process_in_bg
 from pantoqa_bridge.utils.pkg import get_latest_package_version, get_pkg_version, upgrade_package
-from pantoqa_bridge.utils.process import (kill_process_sync, kill_self_process,
-                                          wait_for_port_to_alive, watch_process_bg)
+from pantoqa_bridge.utils.process import (kill_process_by_port, kill_self_process,
+                                          wait_for_port_to_alive)
 
 
 def create_app() -> FastAPI:
-  logger.info("Checking required tools...")
-  _pre_check_required_tools()
-  appium_pid = start_appium_process_sync()
+
+  def on_exit(pid: int, returncode: int) -> None:
+    if returncode == 0:
+      logger.info(f"Appium process exited normally PID={pid}.")
+      return
+
+    logger.info(f"Appium process exited PID={pid}. Return code: {returncode}. ")
+    logger.info("Killing bridge server...")
+    kill_self_process()
+
+  start_appium_process_in_bg(on_exit=on_exit)
 
   @asynccontextmanager
   async def lifespan(app: FastAPI):
     await wait_for_port_to_alive(APPIUM_SERVER_PORT, APPIUM_SERVER_HOST, timeout=15)
-
-    def on_exit(pid: int) -> None:
-      logger.info("Appium process exite. Shutting down PantoQA Bridge server...")
-      kill_self_process()
-
-    watch_process_bg(appium_pid, on_exit=on_exit)
     yield
-    kill_process_sync(appium_pid, timeout=10)
+    kill_process_by_port(APPIUM_SERVER_PORT, timeout=5)
 
   app = FastAPI(
     title="PantoAI QA Ext",
@@ -79,7 +81,7 @@ class DependencyNotInstalledError(Exception):
   pass
 
 
-def _pre_check_required_tools():
+def precheck_required_tools():
 
   def _current_package_check():
     curent_pkg_version = get_pkg_version(PKG_NAME)
@@ -95,7 +97,7 @@ def _pre_check_required_tools():
 
   def _install_uiautomator2() -> None:
     subprocess.check_output(
-      ["appium", "driver", "install", "uiautomator2"],
+      [APPIUM_BIN, "driver", "install", "uiautomator2"],
       stderr=subprocess.STDOUT,
       text=True,
     )
@@ -112,7 +114,7 @@ def _pre_check_required_tools():
   required_tools = [
     ("node", "node --version", "Node.js", None),
     ("npm", "npm --version", "npm", None),
-    ("appium", "appium --version", "Appium", _install_appium),
+    (APPIUM_BIN, f"{APPIUM_BIN} --version", "Appium", _install_appium),
   ]
   for cmd, version_cmd, name, install_func in required_tools:
     if shutil.which(cmd) is None:
@@ -130,7 +132,7 @@ def _pre_check_required_tools():
 
   # Check if uiautomator2 server is installed
   uiautomator2_check = subprocess.check_output(
-    "appium driver list --installed --json",
+    f"{APPIUM_BIN} driver list --installed --json",
     shell=True,
     text=True,
   )

pantoqa_bridge/service/uiautomator_action.py

@@ -1,45 +1,89 @@
 import base64
+import re
 from io import BytesIO
 
 import uiautomator2 as u2  # type: ignore
 from adbutils import adb  # type: ignore
 
+from pantoqa_bridge.logger import logger
+
 
 class LocalBridgeService():
 
-  def __init__(self, device_serial: str | None = None):
-    self.uiautomator = u2.connect(device_serial)
+  def __init__(self, device_serial: str):
+    self.uiautomator: u2.Device | None = None
     self.adb = adb.device(device_serial)
+    self._device_resolution: dict | None = None
+
+  def __enter__(self):
+    # self.uiautomator.start_uiautomator()
+    return self
+
+  def __exit__(self, exc_type, exc, tb):
+    self.stop()
+    return False
+
+  def stop(self):
+    if self.uiautomator:
+      self.uiautomator.stop_uiautomator()
+      self.uiautomator = None
+    ...
 
   def take_screenshot(self) -> str:
-    image = self.uiautomator.screenshot()
+    image = self.adb.screenshot()
     buf = BytesIO()
     image.save(buf, format="PNG")
     return base64.b64encode(buf.getvalue()).decode("utf-8")
 
   def click(self, x: int, y: int):
-    self.uiautomator.click(x, y)
+    self.adb.click(x, y)
 
   def long_click(self, x: int, y: int):
-    self.uiautomator.long_click(x, y)
+    duration = 100
+    self.adb.swipe(x, y, x, y, duration=duration)
 
   def get_os_version(self) -> str:
-    return str(self.uiautomator.device_info["version"])
+    version = self.adb.shell("getprop ro.build.version.release")
+    return f"Android {version.strip()}" if version else "unknown"
 
   def get_device_model(self) -> str:
-    return self.uiautomator.device_info["model"]
+    result = self.adb.shell("getprop ro.product.model")
+    return result.strip()
 
   def device_resolution(self) -> dict:
-    w, h = self.uiautomator.window_size()
-    return {"width": w, "height": h}
+    if self._device_resolution:
+      return self._device_resolution
+    txt_result = self.adb.shell("wm size")
+
+    txt_result = txt_result.replace("Physical size:", "").strip()
+
+    match = re.search(r'(\d+)\s*x\s*(\d+)', txt_result)
+    if not match:
+      raise ValueError(f"Could not parse resolution from: {txt_result!r}")
+
+    width, height = map(int, match.groups())
+    logger.debug(f"Device resolution: {width}x{height}")
+    self._device_resolution = {"width": width, "height": height}
+    return self._device_resolution
 
   def get_ui_dump(self) -> str:
+    try:
+      xml = self.adb.dump_hierarchy()
+      return xml
+    except Exception:
+      pass
+
+    if not self.uiautomator:
+      self.uiautomator = u2.connect_adb(self.adb.serial)
+
     xml = self.uiautomator.dump_hierarchy()
     return xml
 
   def get_current_app_activity(self) -> str:
-    activity = self.uiautomator.app_current()
-    return activity['activity']
+    data = self.adb.app_current()
+    package = data.package
+    activity = data.activity
+    return f"{package}/{activity}"
 
   def get_main_activity(self, package_name: str) -> str | None:
     result = self.adb.shell(f"cmd package resolve-activity --brief {package_name}")
@@ -51,52 +95,74 @@ class LocalBridgeService():
     return None
 
   def get_all_packages(self) -> list[str]:
-    packages = self.uiautomator.app_list()
+    packages = self.adb.list_packages()
     return packages
 
   def open_app(self, package_name: str, activity_name: str = ".MainActivity"):
-    self.uiautomator.app_start(package_name=package_name)
+    self.adb.app_start(package_name, activity_name)
 
   def close_keyboard(self):
-    self.uiautomator.hide_keyboard()
+    self.go_back()
 
   def press_enter(self):
-    self.uiautomator.keyevent("66")
+    self.adb.shell("input keyevent 66")
 
   def go_back(self):
-    self.uiautomator.press("back")
+    self.adb.shell("input keyevent 4")
 
   def is_keyboard_open(self) -> bool:
     result = self.adb.shell("dumpsys input_method")
     return "mInputShown=true" in result
 
   def goto_home(self):
-    self.uiautomator.press("home")
+    self.adb.shell("input keyevent 3")
 
   def clear_all_inputs(self):
-    self.uiautomator.clear_text()
+    self.adb.shell("input keycombination 113 29")  # select all (ctrl + a)
+    self.backspace()
 
   def backspace(self):
-    self.uiautomator.keyevent("67")
+    self.adb.shell("input keyevent 67")
 
   def input_text(self, text: str):
-    self.uiautomator.send_keys(text)
+    text = _adb_encode(text)
+    self.adb.shell(f'input text "{text}"')
 
   def swipe(self, x1: int, y1: int, x2: int, y2: int):
-    self.uiautomator.swipe(x1, y1, x2, y2)
+    self.adb.swipe(x1, y1, x2, y2)
 
   def long_press(self, x: int, y: int):
-    self.uiautomator.long_click(x, y)
+    duration = 100
+    self.adb.swipe(x, y, x, y, duration=duration)
 
   def get_oem_name(self) -> str:
-    info = self.uiautomator.device_info
-    return info["brand"]
+    result = self.adb.shell("getprop ro.product.manufacturer")
+    return result.strip()
 
   def get_device_name(self) -> str:
-
-    info = self.uiautomator.device_info
-    return info["model"]
+    result = self.adb.shell("getprop ro.product.model")
+    return result.strip()
 
   def get_os_build_version(self) -> str:
-    info = self.uiautomator.device_info
-    return str(info["sdk"])
+    result = self.adb.shell("getprop ro.build.display.id")
+    return result.strip()
+
+
+def _adb_encode(text: str) -> str:
+  escape_map = {
+    '%': r'\%',
+    ' ': '%s',
+    "'": r"\'",
+    '"': r'\"',
+    '&': r'\&',
+    '(': r'\(',
+    ')': r'\)',
+    ';': r'\;',
+    '<': r'\<',
+    '>': r'\>',
+    '\\': r'\\',
+  }
+  encoded = ""
+  for ch in text:
+    encoded += escape_map.get(ch, ch)
+  return encoded

pantoqa_bridge/tasks/executor.py

@@ -25,16 +25,23 @@ class QAExecutable(abc.ABC):
 
 class MaestroExecutable(QAExecutable):
 
-  def __init__(self, files: list[str], maestro_bin: str | None = None):
+  def __init__(self,
+               files: list[str],
+               maestro_bin: str | None = None,
+               device_serial: str | None = None):
     super().__init__(files)
     self.maestro_bin = maestro_bin or MAESTRO_BIN
+    self.device_serial = device_serial
 
   async def execute(self):
     yml_files = [f for f in self.files if (f.endswith('.yml') or f.endswith('.yaml'))]
     if not yml_files:
       logger.error("No Maestro test files found.")
       return
-    cmd = [self.maestro_bin, "test"] + yml_files
+    cmd = [self.maestro_bin, "test"]
+    if self.device_serial:
+      cmd.extend(["--device", self.device_serial])
+    cmd.extend(yml_files)
     logger.debug(f"Maestro command: {' '.join(cmd)}")
 
     logger.info(f"Running Maestro: {' '.join(cmd)}")
@@ -56,14 +63,20 @@ class MaestroExecutable(QAExecutable):
 
 class AppiumExecutable(QAExecutable):
 
-  def __init__(self, files: list[str], appium_url: str | None = None):
+  def __init__(self,
+               files: list[str],
+               appium_url: str | None = None,
+               device_serial: str | None = None):
     super().__init__(files)
     options = UiAutomator2Options()
     options.set_capability("platformName", "Android")
     options.set_capability("automationName", "UiAutomator2")
     options.set_capability("deviceName", "Android Device")
+    if device_serial:
+      options.set_capability("udid", device_serial)
     options.set_capability("noReset", True)
     options.set_capability("fullReset", False)
+    options.set_capability("ignoreHiddenApiPolicyError", True)
     self.default_wait_in_sec = 20
     self.options = options
     self.appium_url = appium_url or APPIUM_SERVER_URL

pantoqa_bridge/utils/misc.py

@@ -3,10 +3,15 @@ import functools
 import os
 import shutil
 import subprocess
+import threading
+import time
+from collections.abc import Callable
 from pathlib import Path
 
-from pantoqa_bridge.config import APPIUM_SERVER_HOST, APPIUM_SERVER_PORT, IS_WINDOWS
+from pantoqa_bridge.config import (APPIUM_BIN, APPIUM_SERVER_HOST, APPIUM_SERVER_PORT, IS_WINDOWS,
+                                   NODE_PATH)
 from pantoqa_bridge.logger import logger
+from pantoqa_bridge.utils.process import kill_process_by_port
 
 
 def find_android_home() -> str | None:
@@ -75,51 +80,65 @@ def ensure_android_home() -> tuple[str | None, bool]:
   return android_home, True
 
 
-def _get_appium_cmd() -> str:
-  """Get the appium command path based on the platform."""
-  appium_path = shutil.which("appium")
-  if not appium_path:
-    raise RuntimeError("Appium not found in PATH")
-  return appium_path
-
-
-async def start_appium_process() -> int:
-  cmd = [
-    _get_appium_cmd(),
-    "--port",
-    str(APPIUM_SERVER_PORT),
-    "--address",
-    APPIUM_SERVER_HOST,
-  ]
-  logger.info(f"Starting Appium at http://{APPIUM_SERVER_HOST}:{APPIUM_SERVER_PORT}")
-  result = await asyncio.create_subprocess_exec(
-    *cmd,
-    stdout=asyncio.subprocess.DEVNULL,
-    stderr=asyncio.subprocess.DEVNULL,
-    env=os.environ.copy(),
-  )
-  logger.info(f"Running appium at pid {result.pid}...")
-  return result.pid
-
-
-def start_appium_process_sync() -> int:
-  """Start Appium process synchronously. Works on both Windows and Mac."""
-  cmd = [_get_appium_cmd(), "--port", str(APPIUM_SERVER_PORT), "--address", APPIUM_SERVER_HOST]
-  logger.info(f"Starting Appium at http://{APPIUM_SERVER_HOST}:{APPIUM_SERVER_PORT}")
-
-  # On Windows, we need to avoid PIPE for long-running processes since
-  # unconsumed pipe buffers can cause the process to hang.
-  # Explicitly pass the environment to ensure ANDROID_HOME is inherited.
-  process = subprocess.Popen(
-    cmd,
-    stdout=subprocess.DEVNULL,
-    stderr=subprocess.DEVNULL,
-    start_new_session=True,
-    shell=False,
-    env=os.environ.copy(),
-  )
-  logger.info(f"Running Appium at pid {process.pid}...")
-  return process.pid
+def start_appium_process_in_bg(on_exit: Callable[[int, int], None]):
+
+  def start():
+    if not APPIUM_BIN.endswith(".js"):
+      cmd = [
+        APPIUM_BIN,
+        "--session-override",
+        "--port",
+        str(APPIUM_SERVER_PORT),
+        "--address",
+        APPIUM_SERVER_HOST,
+      ]
+    else:
+      cmd = [
+        NODE_PATH,
+        APPIUM_BIN,
+        "--session-override",
+        "--port",
+        str(APPIUM_SERVER_PORT),
+        "--address",
+        APPIUM_SERVER_HOST,
+      ]
+    logger.info(f"Starting Appium at http://{APPIUM_SERVER_HOST}:{APPIUM_SERVER_PORT}")
+
+    proc = subprocess.Popen(
+      cmd,
+      stdout=subprocess.DEVNULL,
+      stderr=subprocess.DEVNULL,
+      start_new_session=True,
+      shell=False,
+      env=os.environ.copy(),
+    )
+    logger.info("Appium process started with PID: %d", proc.pid)
+    return proc
+
+  def start_in_loop():
+    max_retries = 2
+    proc: subprocess.Popen[bytes] | None = None
+    while max_retries > 0:
+      max_retries -= 1
+      proc = start()
+      proc.wait()
+      if proc.returncode != 1:
+        break
+      logger.error("Appium process exited with errors. Return code: %d", proc.returncode)
+      kill_process_by_port(APPIUM_SERVER_PORT, timeout=5)
+      time.sleep(1)
+    if proc:
+      on_exit(proc.pid, proc.returncode)
+    else:
+      on_exit(-1, -1)
+
+  try:
+    kill_process_by_port(APPIUM_SERVER_PORT, timeout=5)
+  except Exception:
+    pass
+  thread = threading.Thread(target=start_in_loop, daemon=True)
+  thread.start()
+  logger.info("Starting Appium process in background.")
 
 
 def make_sync(func):

pantoqa_bridge/utils/pkg.py

@@ -5,6 +5,7 @@ from importlib.metadata import version as importlib_version
 
 from packaging import version as pkg_version
 
+from pantoqa_bridge.config import IS_WINDOWS
 from pantoqa_bridge.logger import logger
 
 
@@ -29,17 +30,24 @@ def get_latest_package_version(package_name: str) -> pkg_version.Version:
 
 def upgrade_package(package_name: str) -> None:
   logger.info(f"Upgrading package {package_name}...")
-  if shutil.which("pipx"):
-    subprocess.check_output(
-      ["pipx", "upgrade", package_name],
-      stderr=subprocess.STDOUT,
-      text=True,
-    )
-  else:
-    subprocess.check_output(
-      [sys.executable, "-m", "pipx", "upgrade", package_name],
-      stderr=subprocess.STDOUT,
-      text=True,
-    )
+  try:
+    if shutil.which("pipx"):
+      subprocess.check_output(
+        ["pipx", "upgrade", package_name],
+        stderr=subprocess.STDOUT,
+        text=True,
+      )
+    else:
+      subprocess.check_output(
+        [sys.executable, "-m", "pipx", "upgrade", package_name],
+        stderr=subprocess.STDOUT,
+        text=True,
+      )
+  except subprocess.CalledProcessError as e:
+    if IS_WINDOWS and "PermissionError" in e.output and "WinError 32" in e.output:
+      return
+    logger.error(
+      f"Failed to upgrade package {package_name}: {e.output}. Return Code: {e.returncode}")
+    raise
 
   logger.info(f"Package {package_name} upgraded successfully.")

pantoqa_bridge/utils/process.py

@@ -77,7 +77,7 @@ async def wait_for_port_to_alive(port: int, host: str = "127.0.0.1", timeout=15)
       with socket.create_connection((host, port), timeout=1):
         return True
     except OSError:
-      await asyncio.sleep(0.5)
+      await asyncio.sleep(0.25)
   raise TimeoutError("Appium did not start in time")
 
 
@@ -154,7 +154,7 @@ def kill_self_process():
   kill_by_pid(self_pid)
 
 
-def kill_process_sync(pid: int, timeout: int = 10) -> None:
+def kill_process_gracefully(pid: int, timeout: int = 10) -> None:
   if pid <= 0:
     return
 
@@ -181,3 +181,47 @@ def kill_process_sync(pid: int, timeout: int = 10) -> None:
   # Step 3: force kill
   logger.info(f"Killing process {pid}...")
   force_kill_by_pid(pid)
+
+
+def find_pids_by_port(port: int) -> list[int]:
+  pids: list[int] = []
+
+  try:
+    if IS_WINDOWS:
+      out = subprocess.check_output(
+        f'netstat -ano | findstr :{port}',
+        shell=True,
+        text=True,
+      )
+      for line in out.splitlines():
+        if "LISTENING" in line:
+          pid_str = line.split()[-1]
+          pids.append(int(pid_str))
+
+      return pids
+
+    out = subprocess.check_output(
+      ["lsof", "-t", f"-i:{port}"],
+      text=True,
+    )
+    for pid_str in out.split():
+      pids.append(int(pid_str))
+  except subprocess.CalledProcessError:
+    # No process found
+    pass
+
+  return pids
+
+
+def kill_process_by_port(port: int, timeout: int | None = None):
+  pids = find_pids_by_port(port)
+  for pid in pids:
+    logger.info(f"Killing process {pid} on port {port}...")
+    try:
+      if timeout and timeout > 0:
+        kill_process_gracefully(pid, timeout=timeout)
+      else:
+        kill_by_pid(pid)
+    except ProcessLookupError:
+      # Process already terminated
+      pass

pantoqa_bridge/utils/service_manager.py

@@ -0,0 +1,166 @@
+import threading
+import time
+
+import adbutils  # type: ignore
+
+from pantoqa_bridge.config import INACTIVITY_TIMEOUT
+from pantoqa_bridge.logger import logger
+from pantoqa_bridge.models.misc import Action
+from pantoqa_bridge.service.uiautomator_action import LocalBridgeService
+
+
+class ServiceManager:
+
+  def __init__(self, device_serial: str):
+    self.device_serial = device_serial
+    self.srv = LocalBridgeService(device_serial)
+    self.last_used = time.time()
+    self._lock = threading.Lock()
+    self._closed = False
+
+    self._cleanup_thread = threading.Thread(target=self._auto_cleanup, daemon=True)
+    self._cleanup_thread.start()
+
+  def touch(self):
+    with self._lock:
+      self.last_used = time.time()
+
+  def process(self, action: Action):
+    self.touch()
+    return _process_action(self.srv, action)
+
+  def _auto_cleanup(self):
+    while True:
+      time.sleep(30)
+      with self._lock:
+        if self._closed:
+          return
+
+        if time.time() - self.last_used > INACTIVITY_TIMEOUT:
+          self.close()
+          return
+
+  def close(self):
+    if self._closed:
+      return
+    self._closed = True
+    try:
+      self.srv.stop()
+    finally:
+      remove_service(self.device_serial)
+
+
+_services: dict[str, ServiceManager] = {}
+_services_lock = threading.Lock()
+
+
+def get_service(device_serial: str | None = None) -> ServiceManager:
+  adb = adbutils.AdbClient()
+  devices = adb.device_list()
+
+  if not device_serial:
+    device_serial = devices[0].serial
+
+  with _services_lock:
+    if device_serial not in _services:
+      _services[device_serial] = ServiceManager(device_serial)
+    return _services[device_serial]
+
+
+def remove_service(device_serial: str):
+  with _services_lock:
+    _services.pop(device_serial, None)
+
+
+def remove_all_services():
+  with _services_lock:
+    services = list(_services.values())
+    _services.clear()
+
+  for srv_mgr in services:
+    try:
+      srv_mgr.close()
+    except Exception as e:
+      logger.error(f"Error while closing service managers:{e}")
+
+
+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()
+  if action_type == "stop":
+    return srv.stop()
+
+  raise ValueError(f"Unsupported action type: {action_type}")

{pantoqa_bridge-0.4.4.dist-info → pantoqa_bridge-0.4.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pantoqa_bridge
-Version: 0.4.4
+Version: 0.4.20
 Summary: Panto QA Bridge
 Author-email: Ritwick Dey <ritwick@getpanto.ai>
 Requires-Python: >=3.10
@@ -14,7 +14,7 @@ Requires-Dist: aiohttp>=3.13.2
 Requires-Dist: rich>=14.2.0
 Requires-Dist: uiautomator2>=3.5.0
 Requires-Dist: adbutils>=2.12.0
-Requires-Dist: appium-utility>=0.3.0
+Requires-Dist: appium-utility>=0.3.7
 Requires-Dist: packaging>=25.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4.0; extra == "dev"

pantoqa_bridge-0.4.20.dist-info/RECORD

@@ -0,0 +1,27 @@
+pantoqa_bridge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pantoqa_bridge/__main__.py,sha256=5m0xHXIz0lDmzAOmkxmaRSUUVKA6_CDisaFxfd9Xe08,57
+pantoqa_bridge/cli.py,sha256=FiY0pBJoWO7rD8sEUNsu3cRISu7ZSvDasl7iTESuqGk,2378
+pantoqa_bridge/config.py,sha256=i9zBJ4gFYwx08kHUOTlwoJPi1HFyTRzMqAVwJZ-iSYw,1105
+pantoqa_bridge/logger.py,sha256=emPHG2YMPvHifHVbmzh3G2ZHDiX7tiS-iB4mUtSMfMY,899
+pantoqa_bridge/scrcpy-server-v3.3.1,sha256=oPcLIKpJmPv2WMlBGM1sjatqu7Bkejvas0TXC8Hry7g,90788
+pantoqa_bridge/server.py,sha256=Vj2bAmxVWoxq_C7K49997JubzJvyGwjA01HIx8x2g-Y,6570
+pantoqa_bridge/lib/adb.py,sha256=TBekDIDTh5iUNphXxDwZDSsj8JghJ6sc9JGAIJvFTHM,2605
+pantoqa_bridge/lib/scrcpy.py,sha256=On-VHpKBOv7M6y9_2xtlcEDpXqYpYL-C9AnwgZuSnuw,4447
+pantoqa_bridge/models/code_execute.py,sha256=SsvzgBmP1FweXhRXIirmQ_R2EtFmf6Kox567mrGht9U,87
+pantoqa_bridge/models/misc.py,sha256=5EQDdxOzItoD_n8nWbvh5V5pPGplnuqlWZYOks1h8I4,106
+pantoqa_bridge/routes/action.py,sha256=PM5Rm8epADNXIAZvOx_z4B0MCYUnlYLODRdmPqe4q8s,723
+pantoqa_bridge/routes/adb.py,sha256=sDy3UjeB9bNZPn7w07avoLKJ1K3KCk0V5gSX3pxoDdE,369
+pantoqa_bridge/routes/executor.py,sha256=HdQXCJNr6deiPCteu0ZrysE9cXlETmME4oQlghegtdA,4078
+pantoqa_bridge/routes/misc.py,sha256=TWz9aErGGdg96K-wnxvCfh2vjmdZmJEy9Wmih0YsbWg,2122
+pantoqa_bridge/routes/screen_mirror.py,sha256=EidHlobyMNLJwQrO5T7Gb-JTY3CjGe0a9IiLiw1AcQ4,2429
+pantoqa_bridge/service/uiautomator_action.py,sha256=B-5iPzYBiG3zfjsUieDAKvKQgmo9d6fDKNouG87duDI,4427
+pantoqa_bridge/tasks/executor.py,sha256=cW-u_BK6QSTZ1Kex4kuZBhibP6qWR-XI10UALYwbQw0,3109
+pantoqa_bridge/utils/misc.py,sha256=o-Zrpq2ON6MTU0ZKBi5ZRKPhIPBm1swhyEOVS7xdG-k,3948
+pantoqa_bridge/utils/pkg.py,sha256=N9z_C7aQYU2VAdp3ptigp50331pxTwErVrT5I9Htz-c,1634
+pantoqa_bridge/utils/process.py,sha256=M9xMNn8xLo_PLWlCkN7bQCvYGuOg1nWvqzbpx6ifJTA,5703
+pantoqa_bridge/utils/service_manager.py,sha256=gycC6Nn9Cd9tNwZ3R9M2DfeFq1GTO3f74XUoCN3nGeM,4601
+pantoqa_bridge-0.4.20.dist-info/METADATA,sha256=gnDd7XG-pc-BEiLDWlCIGccUsIDuvrekHadwAxVOcX8,1351
+pantoqa_bridge-0.4.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pantoqa_bridge-0.4.20.dist-info/entry_points.txt,sha256=GBytwhIuiZGX_cj_1JQpUteBsP51TSxTk4NxTp4bN_I,58
+pantoqa_bridge-0.4.20.dist-info/top_level.txt,sha256=r03tgM1pQrHwfxF9gkvU94HgR_s8tqDvZVSAzq8qwrA,15
+pantoqa_bridge-0.4.20.dist-info/RECORD,,

pantoqa_bridge-0.4.4.dist-info/RECORD

@@ -1,25 +0,0 @@
-pantoqa_bridge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pantoqa_bridge/__main__.py,sha256=5m0xHXIz0lDmzAOmkxmaRSUUVKA6_CDisaFxfd9Xe08,57
-pantoqa_bridge/cli.py,sha256=1EK3P3XcmFl4Il3-KNBNWddbL11ENR7Fi8zstXj1QIM,2016
-pantoqa_bridge/config.py,sha256=yJ_860ih9BG5e6n70tN_3EkpxCLzjgrpvDx-QFo86Fc,852
-pantoqa_bridge/logger.py,sha256=emPHG2YMPvHifHVbmzh3G2ZHDiX7tiS-iB4mUtSMfMY,899
-pantoqa_bridge/scrcpy-server-v3.3.1,sha256=oPcLIKpJmPv2WMlBGM1sjatqu7Bkejvas0TXC8Hry7g,90788
-pantoqa_bridge/server.py,sha256=tFvnQ9xbJQ14vuDEuJLuisxwdaXAIDhiBou8Yy59PGA,6509
-pantoqa_bridge/lib/adb.py,sha256=_4Vd3VUfklRqHFLhoMQdbzH2ZnS-lhQcCwu-p3a-SLY,2532
-pantoqa_bridge/lib/scrcpy.py,sha256=UNesa2XrV54r56MIm15X67HLka94I6mheNqKh4Bw54A,4023
-pantoqa_bridge/models/code_execute.py,sha256=SsvzgBmP1FweXhRXIirmQ_R2EtFmf6Kox567mrGht9U,87
-pantoqa_bridge/routes/action.py,sha256=pplP4eQI1qK7LIKxXb4I5j6tkcT6MowoIAtz-RMPwQI,3339
-pantoqa_bridge/routes/adb.py,sha256=sDy3UjeB9bNZPn7w07avoLKJ1K3KCk0V5gSX3pxoDdE,369
-pantoqa_bridge/routes/executor.py,sha256=gHRlNcncohPsD-VtaFTTBcu6JHrD4F-LvvETdoisuZI,3503
-pantoqa_bridge/routes/misc.py,sha256=TWz9aErGGdg96K-wnxvCfh2vjmdZmJEy9Wmih0YsbWg,2122
-pantoqa_bridge/routes/screen_mirror.py,sha256=KXpqKC0GzTW5JAoLZ0cKUY1RqZE3bNpk3zVVc5MReRE,2380
-pantoqa_bridge/service/uiautomator_action.py,sha256=UE_5-oyE_z5SjGa6Mtioap5jEM5MR9leXTdRuDl-vDI,2766
-pantoqa_bridge/tasks/executor.py,sha256=PWAS5hP79nYMLz4sNHLEYhF33YmslbcrjnqVr78rs2k,2683
-pantoqa_bridge/utils/misc.py,sha256=8tFn8p2OhLNIdT31w0LczQ8hjkhkpx3fkaeeMgs71sM,3668
-pantoqa_bridge/utils/pkg.py,sha256=difSA1MW6auFUNzOH7Emmukh5mqdsKb-Ow3jdiKKatg,1297
-pantoqa_bridge/utils/process.py,sha256=O71jC8twabT2MfcowAlMTOFeCQRb17MGTc3BFG4E9Bs,4674
-pantoqa_bridge-0.4.4.dist-info/METADATA,sha256=XuyB6iCj-9sH0RyU4h7Xzr2pZylaAkNJJi02z-PLXBE,1350
-pantoqa_bridge-0.4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pantoqa_bridge-0.4.4.dist-info/entry_points.txt,sha256=GBytwhIuiZGX_cj_1JQpUteBsP51TSxTk4NxTp4bN_I,58
-pantoqa_bridge-0.4.4.dist-info/top_level.txt,sha256=r03tgM1pQrHwfxF9gkvU94HgR_s8tqDvZVSAzq8qwrA,15
-pantoqa_bridge-0.4.4.dist-info/RECORD,,