autoglm-gui 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

phone_agent/xctest/input.py

@@ -0,0 +1,311 @@
+"""Input utilities for iOS device text input via WebDriverAgent."""
+
+import time
+
+
+def _get_wda_session_url(wda_url: str, session_id: str | None, endpoint: str) -> str:
+    """
+    Get the correct WDA URL for a session endpoint.
+
+    Args:
+        wda_url: Base WDA URL.
+        session_id: Optional session ID.
+        endpoint: The endpoint path.
+
+    Returns:
+        Full URL for the endpoint.
+    """
+    base = wda_url.rstrip("/")
+    if session_id:
+        return f"{base}/session/{session_id}/{endpoint}"
+    else:
+        # Try to use WDA endpoints without session when possible
+        return f"{base}/{endpoint}"
+
+
+def type_text(
+    text: str,
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+    frequency: int = 60,
+) -> None:
+    """
+    Type text into the currently focused input field.
+
+    Args:
+        text: The text to type.
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+        frequency: Typing frequency (keys per minute). Default is 60.
+
+    Note:
+        The input field must be focused before calling this function.
+        Use tap() to focus on the input field first.
+    """
+    try:
+        import requests
+
+        url = _get_wda_session_url(wda_url, session_id, "wda/keys")
+
+        # Send text to WDA
+        response = requests.post(
+            url,
+            json={"value": list(text), "frequency": frequency},
+            timeout=30,
+            verify=False,
+        )
+
+        if response.status_code not in (200, 201):
+            print(
+                f"Warning: Text input may have failed. Status: {response.status_code}"
+            )
+
+    except ImportError:
+        print("Error: requests library required. Install: pip install requests")
+    except Exception as e:
+        print(f"Error typing text: {e}")
+
+
+def clear_text(
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+) -> None:
+    """
+    Clear text in the currently focused input field.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+
+    Note:
+        This sends a clear command to the active element.
+        The input field must be focused before calling this function.
+    """
+    try:
+        import requests
+
+        # First, try to get the active element
+        url = _get_wda_session_url(wda_url, session_id, "element/active")
+
+        response = requests.get(url, timeout=10, verify=False)
+
+        if response.status_code == 200:
+            data = response.json()
+            element_id = data.get("value", {}).get("ELEMENT") or data.get(
+                "value", {}
+            ).get("element-6066-11e4-a52e-4f735466cecf")
+
+            if element_id:
+                # Clear the element
+                clear_url = _get_wda_session_url(
+                    wda_url, session_id, f"element/{element_id}/clear"
+                )
+                requests.post(clear_url, timeout=10, verify=False)
+                return
+
+        # Fallback: send backspace commands
+        _clear_with_backspace(wda_url, session_id)
+
+    except ImportError:
+        print("Error: requests library required. Install: pip install requests")
+    except Exception as e:
+        print(f"Error clearing text: {e}")
+
+
+def _clear_with_backspace(
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+    max_backspaces: int = 100,
+) -> None:
+    """
+    Clear text by sending backspace keys.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+        max_backspaces: Maximum number of backspaces to send.
+    """
+    try:
+        import requests
+
+        url = _get_wda_session_url(wda_url, session_id, "wda/keys")
+
+        # Send backspace character multiple times
+        backspace_char = "\u0008"  # Backspace Unicode character
+        requests.post(
+            url,
+            json={"value": [backspace_char] * max_backspaces},
+            timeout=10,
+            verify=False,
+        )
+
+    except Exception as e:
+        print(f"Error clearing with backspace: {e}")
+
+
+def send_keys(
+    keys: list[str],
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+) -> None:
+    """
+    Send a sequence of keys.
+
+    Args:
+        keys: List of keys to send.
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+
+    Example:
+        >>> send_keys(["H", "e", "l", "l", "o"])
+        >>> send_keys(["\n"])  # Send enter key
+    """
+    try:
+        import requests
+
+        url = _get_wda_session_url(wda_url, session_id, "wda/keys")
+
+        requests.post(url, json={"value": keys}, timeout=10, verify=False)
+
+    except ImportError:
+        print("Error: requests library required. Install: pip install requests")
+    except Exception as e:
+        print(f"Error sending keys: {e}")
+
+
+def press_enter(
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+    delay: float = 0.5,
+) -> None:
+    """
+    Press the Enter/Return key.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+        delay: Delay in seconds after pressing enter.
+    """
+    send_keys(["\n"], wda_url, session_id)
+    time.sleep(delay)
+
+
+def hide_keyboard(
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+) -> None:
+    """
+    Hide the on-screen keyboard.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+    """
+    try:
+        import requests
+
+        url = f"{wda_url.rstrip('/')}/wda/keyboard/dismiss"
+
+        requests.post(url, timeout=10, verify=False)
+
+    except ImportError:
+        print("Error: requests library required. Install: pip install requests")
+    except Exception as e:
+        print(f"Error hiding keyboard: {e}")
+
+
+def is_keyboard_shown(
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+) -> bool:
+    """
+    Check if the on-screen keyboard is currently shown.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+
+    Returns:
+        True if keyboard is shown, False otherwise.
+    """
+    try:
+        import requests
+
+        url = _get_wda_session_url(wda_url, session_id, "wda/keyboard/shown")
+
+        response = requests.get(url, timeout=5, verify=False)
+
+        if response.status_code == 200:
+            data = response.json()
+            return data.get("value", False)
+
+    except ImportError:
+        print("Error: requests library required. Install: pip install requests")
+    except Exception:
+        pass
+
+    return False
+
+
+def set_pasteboard(
+    text: str,
+    wda_url: str = "http://localhost:8100",
+) -> None:
+    """
+    Set the device pasteboard (clipboard) content.
+
+    Args:
+        text: Text to set in pasteboard.
+        wda_url: WebDriverAgent URL.
+
+    Note:
+        This can be useful for inputting large amounts of text.
+        After setting pasteboard, you can simulate paste gesture.
+    """
+    try:
+        import requests
+
+        url = f"{wda_url.rstrip('/')}/wda/setPasteboard"
+
+        requests.post(
+            url,
+            json={"content": text, "contentType": "plaintext"},
+            timeout=10,
+            verify=False,
+        )
+
+    except ImportError:
+        print("Error: requests library required. Install: pip install requests")
+    except Exception as e:
+        print(f"Error setting pasteboard: {e}")
+
+
+def get_pasteboard(
+    wda_url: str = "http://localhost:8100",
+) -> str | None:
+    """
+    Get the device pasteboard (clipboard) content.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+
+    Returns:
+        Pasteboard content or None if failed.
+    """
+    try:
+        import requests
+
+        url = f"{wda_url.rstrip('/')}/wda/getPasteboard"
+
+        response = requests.post(url, timeout=10, verify=False)
+
+        if response.status_code == 200:
+            data = response.json()
+            return data.get("value")
+
+    except ImportError:
+        print("Error: requests library required. Install: pip install requests")
+    except Exception as e:
+        print(f"Error getting pasteboard: {e}")
+
+    return None

phone_agent/xctest/screenshot.py

@@ -0,0 +1,226 @@
+"""Screenshot utilities for capturing iOS device screen."""
+
+import base64
+import os
+import subprocess
+import tempfile
+import uuid
+from dataclasses import dataclass
+from io import BytesIO
+
+from PIL import Image
+
+
+@dataclass
+class Screenshot:
+    """Represents a captured screenshot."""
+
+    base64_data: str
+    width: int
+    height: int
+    is_sensitive: bool = False
+
+
+def get_screenshot(
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+    device_id: str | None = None,
+    timeout: int = 10,
+) -> Screenshot:
+    """
+    Capture a screenshot from the connected iOS device.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+        device_id: Optional device UDID (for idevicescreenshot fallback).
+        timeout: Timeout in seconds for screenshot operations.
+
+    Returns:
+        Screenshot object containing base64 data and dimensions.
+
+    Note:
+        Tries WebDriverAgent first, falls back to idevicescreenshot if available.
+        If both fail, returns a black fallback image.
+    """
+    # Try WebDriverAgent first (preferred method)
+    screenshot = _get_screenshot_wda(wda_url, session_id, timeout)
+    if screenshot:
+        return screenshot
+
+    # Fallback to idevicescreenshot
+    screenshot = _get_screenshot_idevice(device_id, timeout)
+    if screenshot:
+        return screenshot
+
+    # Return fallback black image
+    return _create_fallback_screenshot(is_sensitive=False)
+
+
+def _get_screenshot_wda(
+    wda_url: str, session_id: str | None, timeout: int
+) -> Screenshot | None:
+    """
+    Capture screenshot using WebDriverAgent.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+        timeout: Timeout in seconds.
+
+    Returns:
+        Screenshot object or None if failed.
+    """
+    try:
+        import requests
+
+        url = f"{wda_url.rstrip('/')}/screenshot"
+
+        response = requests.get(url, timeout=timeout, verify=False)
+
+        if response.status_code == 200:
+            data = response.json()
+            base64_data = data.get("value", "")
+
+            if base64_data:
+                # Decode to get dimensions
+                img_data = base64.b64decode(base64_data)
+                img = Image.open(BytesIO(img_data))
+                width, height = img.size
+
+                return Screenshot(
+                    base64_data=base64_data,
+                    width=width,
+                    height=height,
+                    is_sensitive=False,
+                )
+
+    except ImportError:
+        print("Note: requests library not installed. Install: pip install requests")
+    except Exception as e:
+        print(f"WDA screenshot failed: {e}")
+
+    return None
+
+
+def _get_screenshot_idevice(device_id: str | None, timeout: int) -> Screenshot | None:
+    """
+    Capture screenshot using idevicescreenshot (libimobiledevice).
+
+    Args:
+        device_id: Optional device UDID.
+        timeout: Timeout in seconds.
+
+    Returns:
+        Screenshot object or None if failed.
+    """
+    try:
+        temp_path = os.path.join(
+            tempfile.gettempdir(), f"ios_screenshot_{uuid.uuid4()}.png"
+        )
+
+        cmd = ["idevicescreenshot"]
+        if device_id:
+            cmd.extend(["-u", device_id])
+        cmd.append(temp_path)
+
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+
+        if result.returncode == 0 and os.path.exists(temp_path):
+            # Read and encode image
+            img = Image.open(temp_path)
+            width, height = img.size
+
+            buffered = BytesIO()
+            img.save(buffered, format="PNG")
+            base64_data = base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+            # Cleanup
+            os.remove(temp_path)
+
+            return Screenshot(
+                base64_data=base64_data, width=width, height=height, is_sensitive=False
+            )
+
+    except FileNotFoundError:
+        print(
+            "Note: idevicescreenshot not found. Install: brew install libimobiledevice"
+        )
+    except Exception as e:
+        print(f"idevicescreenshot failed: {e}")
+
+    return None
+
+
+def _create_fallback_screenshot(is_sensitive: bool) -> Screenshot:
+    """
+    Create a black fallback image when screenshot fails.
+
+    Args:
+        is_sensitive: Whether the failure was due to sensitive content.
+
+    Returns:
+        Screenshot object with black image.
+    """
+    # Default iPhone screen size (iPhone 14 Pro)
+    default_width, default_height = 1179, 2556
+
+    black_img = Image.new("RGB", (default_width, default_height), color="black")
+    buffered = BytesIO()
+    black_img.save(buffered, format="PNG")
+    base64_data = base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+    return Screenshot(
+        base64_data=base64_data,
+        width=default_width,
+        height=default_height,
+        is_sensitive=is_sensitive,
+    )
+
+
+def save_screenshot(
+    screenshot: Screenshot,
+    file_path: str,
+) -> bool:
+    """
+    Save a screenshot to a file.
+
+    Args:
+        screenshot: Screenshot object.
+        file_path: Path to save the screenshot.
+
+    Returns:
+        True if successful, False otherwise.
+    """
+    try:
+        img_data = base64.b64decode(screenshot.base64_data)
+        img = Image.open(BytesIO(img_data))
+        img.save(file_path)
+        return True
+    except Exception as e:
+        print(f"Error saving screenshot: {e}")
+        return False
+
+
+def get_screenshot_png(
+    wda_url: str = "http://localhost:8100",
+    session_id: str | None = None,
+    device_id: str | None = None,
+) -> bytes | None:
+    """
+    Get screenshot as PNG bytes.
+
+    Args:
+        wda_url: WebDriverAgent URL.
+        session_id: Optional WDA session ID.
+        device_id: Optional device UDID.
+
+    Returns:
+        PNG bytes or None if failed.
+    """
+    screenshot = get_screenshot(wda_url, session_id, device_id)
+
+    try:
+        return base64.b64decode(screenshot.base64_data)
+    except Exception:
+        return None