autoglm-gui 1.4.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

phone_agent/model/client.py

@@ -1,290 +0,0 @@
-"""Model client for AI inference using OpenAI-compatible API."""
-
-import json
-import time
-from dataclasses import dataclass, field
-from typing import Any
-
-from openai import OpenAI
-
-from phone_agent.config.i18n import get_message
-
-
-@dataclass
-class ModelConfig:
-    """Configuration for the AI model."""
-
-    base_url: str = "http://localhost:8000/v1"
-    api_key: str = "EMPTY"
-    model_name: str = "autoglm-phone-9b"
-    max_tokens: int = 3000
-    temperature: float = 0.0
-    top_p: float = 0.85
-    frequency_penalty: float = 0.2
-    extra_body: dict[str, Any] = field(default_factory=dict)
-    lang: str = "cn"  # Language for UI messages: 'cn' or 'en'
-
-
-@dataclass
-class ModelResponse:
-    """Response from the AI model."""
-
-    thinking: str
-    action: str
-    raw_content: str
-    # Performance metrics
-    time_to_first_token: float | None = None  # Time to first token (seconds)
-    time_to_thinking_end: float | None = None  # Time to thinking end (seconds)
-    total_time: float | None = None  # Total inference time (seconds)
-
-
-class ModelClient:
-    """
-    Client for interacting with OpenAI-compatible vision-language models.
-
-    Args:
-        config: Model configuration.
-    """
-
-    def __init__(self, config: ModelConfig | None = None):
-        self.config = config or ModelConfig()
-        self.client = OpenAI(base_url=self.config.base_url, api_key=self.config.api_key)
-
-    def request(self, messages: list[dict[str, Any]]) -> ModelResponse:
-        """
-        Send a request to the model.
-
-        Args:
-            messages: List of message dictionaries in OpenAI format.
-
-        Returns:
-            ModelResponse containing thinking and action.
-
-        Raises:
-            ValueError: If the response cannot be parsed.
-        """
-        # Start timing
-        start_time = time.time()
-        time_to_first_token = None
-        time_to_thinking_end = None
-
-        stream = self.client.chat.completions.create(
-            messages=messages,
-            model=self.config.model_name,
-            max_tokens=self.config.max_tokens,
-            temperature=self.config.temperature,
-            top_p=self.config.top_p,
-            frequency_penalty=self.config.frequency_penalty,
-            extra_body=self.config.extra_body,
-            stream=True,
-        )
-
-        raw_content = ""
-        buffer = ""  # Buffer to hold content that might be part of a marker
-        action_markers = ["finish(message=", "do(action="]
-        in_action_phase = False  # Track if we've entered the action phase
-        first_token_received = False
-
-        for chunk in stream:
-            if len(chunk.choices) == 0:
-                continue
-            if chunk.choices[0].delta.content is not None:
-                content = chunk.choices[0].delta.content
-                raw_content += content
-
-                # Record time to first token
-                if not first_token_received:
-                    time_to_first_token = time.time() - start_time
-                    first_token_received = True
-
-                if in_action_phase:
-                    # Already in action phase, just accumulate content without printing
-                    continue
-
-                buffer += content
-
-                # Check if any marker is fully present in buffer
-                marker_found = False
-                for marker in action_markers:
-                    if marker in buffer:
-                        # Marker found, print everything before it
-                        thinking_part = buffer.split(marker, 1)[0]
-                        print(thinking_part, end="", flush=True)
-                        print()  # Print newline after thinking is complete
-                        in_action_phase = True
-                        marker_found = True
-
-                        # Record time to thinking end
-                        if time_to_thinking_end is None:
-                            time_to_thinking_end = time.time() - start_time
-
-                        break
-
-                if marker_found:
-                    continue  # Continue to collect remaining content
-
-                # Check if buffer ends with a prefix of any marker
-                # If so, don't print yet (wait for more content)
-                is_potential_marker = False
-                for marker in action_markers:
-                    for i in range(1, len(marker)):
-                        if buffer.endswith(marker[:i]):
-                            is_potential_marker = True
-                            break
-                    if is_potential_marker:
-                        break
-
-                if not is_potential_marker:
-                    # Safe to print the buffer
-                    print(buffer, end="", flush=True)
-                    buffer = ""
-
-        # Calculate total time
-        total_time = time.time() - start_time
-
-        # Parse thinking and action from response
-        thinking, action = self._parse_response(raw_content)
-
-        # Print performance metrics
-        lang = self.config.lang
-        print()
-        print("=" * 50)
-        print(f"⏱️  {get_message('performance_metrics', lang)}:")
-        print("-" * 50)
-        if time_to_first_token is not None:
-            print(
-                f"{get_message('time_to_first_token', lang)}: {time_to_first_token:.3f}s"
-            )
-        if time_to_thinking_end is not None:
-            print(
-                f"{get_message('time_to_thinking_end', lang)}:        {time_to_thinking_end:.3f}s"
-            )
-        print(
-            f"{get_message('total_inference_time', lang)}:          {total_time:.3f}s"
-        )
-        print("=" * 50)
-
-        return ModelResponse(
-            thinking=thinking,
-            action=action,
-            raw_content=raw_content,
-            time_to_first_token=time_to_first_token,
-            time_to_thinking_end=time_to_thinking_end,
-            total_time=total_time,
-        )
-
-    def _parse_response(self, content: str) -> tuple[str, str]:
-        """
-        Parse the model response into thinking and action parts.
-
-        Parsing rules:
-        1. If content contains 'finish(message=', everything before is thinking,
-           everything from 'finish(message=' onwards is action.
-        2. If rule 1 doesn't apply but content contains 'do(action=',
-           everything before is thinking, everything from 'do(action=' onwards is action.
-        3. Fallback: If content contains '<answer>', use legacy parsing with XML tags.
-        4. Otherwise, return empty thinking and full content as action.
-
-        Args:
-            content: Raw response content.
-
-        Returns:
-            Tuple of (thinking, action).
-        """
-        # Rule 1: Check for finish(message=
-        if "finish(message=" in content:
-            parts = content.split("finish(message=", 1)
-            thinking = parts[0].strip()
-            action = "finish(message=" + parts[1]
-            return thinking, action
-
-        # Rule 2: Check for do(action=
-        if "do(action=" in content:
-            parts = content.split("do(action=", 1)
-            thinking = parts[0].strip()
-            action = "do(action=" + parts[1]
-            return thinking, action
-
-        # Rule 3: Fallback to legacy XML tag parsing
-        if "<answer>" in content:
-            parts = content.split("<answer>", 1)
-            thinking = parts[0].replace("<think>", "").replace("</think>", "").strip()
-            action = parts[1].replace("</answer>", "").strip()
-            return thinking, action
-
-        # Rule 4: No markers found, return content as action
-        return "", content
-
-
-class MessageBuilder:
-    """Helper class for building conversation messages."""
-
-    @staticmethod
-    def create_system_message(content: str) -> dict[str, Any]:
-        """Create a system message."""
-        return {"role": "system", "content": content}
-
-    @staticmethod
-    def create_user_message(
-        text: str, image_base64: str | None = None
-    ) -> dict[str, Any]:
-        """
-        Create a user message with optional image.
-
-        Args:
-            text: Text content.
-            image_base64: Optional base64-encoded image.
-
-        Returns:
-            Message dictionary.
-        """
-        content = []
-
-        if image_base64:
-            content.append(
-                {
-                    "type": "image_url",
-                    "image_url": {"url": f"data:image/png;base64,{image_base64}"},
-                }
-            )
-
-        content.append({"type": "text", "text": text})
-
-        return {"role": "user", "content": content}
-
-    @staticmethod
-    def create_assistant_message(content: str) -> dict[str, Any]:
-        """Create an assistant message."""
-        return {"role": "assistant", "content": content}
-
-    @staticmethod
-    def remove_images_from_message(message: dict[str, Any]) -> dict[str, Any]:
-        """
-        Remove image content from a message to save context space.
-
-        Args:
-            message: Message dictionary.
-
-        Returns:
-            Message with images removed.
-        """
-        if isinstance(message.get("content"), list):
-            message["content"] = [
-                item for item in message["content"] if item.get("type") == "text"
-            ]
-        return message
-
-    @staticmethod
-    def build_screen_info(current_app: str, **extra_info) -> str:
-        """
-        Build screen info string for the model.
-
-        Args:
-            current_app: Current app name.
-            **extra_info: Additional info to include.
-
-        Returns:
-            JSON string with screen info.
-        """
-        info = {"current_app": current_app, **extra_info}
-        return json.dumps(info, ensure_ascii=False)

phone_agent/xctest/__init__.py

@@ -1,47 +0,0 @@
-"""XCTest utilities for iOS device interaction via WebDriverAgent/XCUITest."""
-
-from phone_agent.xctest.connection import (
-    ConnectionType,
-    DeviceInfo,
-    XCTestConnection,
-    list_devices,
-    quick_connect,
-)
-from phone_agent.xctest.device import (
-    back,
-    double_tap,
-    get_current_app,
-    home,
-    launch_app,
-    long_press,
-    swipe,
-    tap,
-)
-from phone_agent.xctest.input import (
-    clear_text,
-    type_text,
-)
-from phone_agent.xctest.screenshot import get_screenshot
-
-__all__ = [
-    # Screenshot
-    "get_screenshot",
-    # Input
-    "type_text",
-    "clear_text",
-    # Device control
-    "get_current_app",
-    "tap",
-    "swipe",
-    "back",
-    "home",
-    "double_tap",
-    "long_press",
-    "launch_app",
-    # Connection management
-    "XCTestConnection",
-    "DeviceInfo",
-    "ConnectionType",
-    "quick_connect",
-    "list_devices",
-]

phone_agent/xctest/connection.py

@@ -1,379 +0,0 @@
-"""iOS device connection management via idevice tools and WebDriverAgent."""
-
-import subprocess
-from dataclasses import dataclass
-from enum import Enum
-
-
-class ConnectionType(Enum):
-    """Type of iOS connection."""
-
-    USB = "usb"
-    NETWORK = "network"
-
-
-@dataclass
-class DeviceInfo:
-    """Information about a connected iOS device."""
-
-    device_id: str  # UDID
-    status: str
-    connection_type: ConnectionType
-    model: str | None = None
-    ios_version: str | None = None
-    device_name: str | None = None
-
-
-class XCTestConnection:
-    """
-    Manages connections to iOS devices via libimobiledevice and WebDriverAgent.
-
-    Requires:
-        - libimobiledevice (idevice_id, ideviceinfo)
-        - WebDriverAgent running on the iOS device
-        - ios-deploy (optional, for app installation)
-
-    Example:
-        >>> conn = XCTestConnection()
-        >>> # List connected devices
-        >>> devices = conn.list_devices()
-        >>> # Get device info
-        >>> info = conn.get_device_info()
-        >>> # Check if WDA is running
-        >>> is_ready = conn.is_wda_ready()
-    """
-
-    def __init__(self, wda_url: str = "http://localhost:8100"):
-        """
-        Initialize iOS connection manager.
-
-        Args:
-            wda_url: WebDriverAgent URL (default: http://localhost:8100).
-                     For network devices, use http://<device-ip>:8100
-        """
-        self.wda_url = wda_url.rstrip("/")
-
-    def list_devices(self) -> list[DeviceInfo]:
-        """
-        List all connected iOS devices.
-
-        Returns:
-            List of DeviceInfo objects.
-
-        Note:
-            Requires libimobiledevice to be installed.
-            Install on macOS: brew install libimobiledevice
-        """
-        try:
-            # Get list of device UDIDs
-            result = subprocess.run(
-                ["idevice_id", "-ln"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
-
-            devices = []
-            for line in result.stdout.strip().split("\n"):
-                udid = line.strip()
-                if not udid:
-                    continue
-
-                # Determine connection type (network devices have specific format)
-                conn_type = (
-                    ConnectionType.NETWORK
-                    if "-" in udid and len(udid) > 40
-                    else ConnectionType.USB
-                )
-
-                # Get detailed device info
-                device_info = self._get_device_details(udid)
-
-                devices.append(
-                    DeviceInfo(
-                        device_id=udid,
-                        status="connected",
-                        connection_type=conn_type,
-                        model=device_info.get("model"),
-                        ios_version=device_info.get("ios_version"),
-                        device_name=device_info.get("name"),
-                    )
-                )
-
-            return devices
-
-        except FileNotFoundError:
-            print(
-                "Error: idevice_id not found. Install libimobiledevice: brew install libimobiledevice"
-            )
-            return []
-        except Exception as e:
-            print(f"Error listing devices: {e}")
-            return []
-
-    def _get_device_details(self, udid: str) -> dict[str, str]:
-        """
-        Get detailed information about a specific device.
-
-        Args:
-            udid: Device UDID.
-
-        Returns:
-            Dictionary with device details.
-        """
-        try:
-            result = subprocess.run(
-                ["ideviceinfo", "-u", udid],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
-
-            info = {}
-            for line in result.stdout.split("\n"):
-                if ": " in line:
-                    key, value = line.split(": ", 1)
-                    key = key.strip()
-                    value = value.strip()
-
-                    if key == "ProductType":
-                        info["model"] = value
-                    elif key == "ProductVersion":
-                        info["ios_version"] = value
-                    elif key == "DeviceName":
-                        info["name"] = value
-
-            return info
-
-        except Exception:
-            return {}
-
-    def get_device_info(self, device_id: str | None = None) -> DeviceInfo | None:
-        """
-        Get detailed information about a device.
-
-        Args:
-            device_id: Device UDID. If None, uses first available device.
-
-        Returns:
-            DeviceInfo or None if not found.
-        """
-        devices = self.list_devices()
-
-        if not devices:
-            return None
-
-        if device_id is None:
-            return devices[0]
-
-        for device in devices:
-            if device.device_id == device_id:
-                return device
-
-        return None
-
-    def is_connected(self, device_id: str | None = None) -> bool:
-        """
-        Check if a device is connected.
-
-        Args:
-            device_id: Device UDID to check. If None, checks if any device is connected.
-
-        Returns:
-            True if connected, False otherwise.
-        """
-        devices = self.list_devices()
-
-        if not devices:
-            return False
-
-        if device_id is None:
-            return len(devices) > 0
-
-        return any(d.device_id == device_id for d in devices)
-
-    def is_wda_ready(self, timeout: int = 2) -> bool:
-        """
-        Check if WebDriverAgent is running and accessible.
-
-        Args:
-            timeout: Request timeout in seconds.
-
-        Returns:
-            True if WDA is ready, False otherwise.
-        """
-        try:
-            import requests
-
-            response = requests.get(
-                f"{self.wda_url}/status", timeout=timeout, verify=False
-            )
-            return response.status_code == 200
-        except ImportError:
-            print("Error: requests library not found. Install it: pip install requests")
-            return False
-        except Exception:
-            return False
-
-    def start_wda_session(self) -> tuple[bool, str]:
-        """
-        Start a new WebDriverAgent session.
-
-        Returns:
-            Tuple of (success, session_id or error_message).
-        """
-        try:
-            import requests
-
-            response = requests.post(
-                f"{self.wda_url}/session",
-                json={"capabilities": {}},
-                timeout=30,
-                verify=False,
-            )
-
-            if response.status_code in (200, 201):
-                data = response.json()
-                session_id = data.get("sessionId") or data.get("value", {}).get(
-                    "sessionId"
-                )
-                return True, session_id or "session_started"
-            else:
-                return False, f"Failed to start session: {response.text}"
-
-        except ImportError:
-            return (
-                False,
-                "requests library not found. Install it: pip install requests",
-            )
-        except Exception as e:
-            return False, f"Error starting WDA session: {e}"
-
-    def get_wda_status(self) -> dict | None:
-        """
-        Get WebDriverAgent status information.
-
-        Returns:
-            Status dictionary or None if not available.
-        """
-        try:
-            import requests
-
-            response = requests.get(f"{self.wda_url}/status", timeout=5, verify=False)
-
-            if response.status_code == 200:
-                return response.json()
-            return None
-
-        except Exception:
-            return None
-
-    def pair_device(self, device_id: str | None = None) -> tuple[bool, str]:
-        """
-        Pair with an iOS device (required for some operations).
-
-        Args:
-            device_id: Device UDID. If None, uses first available device.
-
-        Returns:
-            Tuple of (success, message).
-        """
-        try:
-            cmd = ["idevicepair"]
-            if device_id:
-                cmd.extend(["-u", device_id])
-            cmd.append("pair")
-
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
-
-            output = result.stdout + result.stderr
-
-            if "SUCCESS" in output or "already paired" in output.lower():
-                return True, "Device paired successfully"
-            else:
-                return False, output.strip()
-
-        except FileNotFoundError:
-            return (
-                False,
-                "idevicepair not found. Install libimobiledevice: brew install libimobiledevice",
-            )
-        except Exception as e:
-            return False, f"Error pairing device: {e}"
-
-    def get_device_name(self, device_id: str | None = None) -> str | None:
-        """
-        Get the device name.
-
-        Args:
-            device_id: Device UDID. If None, uses first available device.
-
-        Returns:
-            Device name string or None if not found.
-        """
-        try:
-            cmd = ["ideviceinfo"]
-            if device_id:
-                cmd.extend(["-u", device_id])
-            cmd.extend(["-k", "DeviceName"])
-
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
-
-            return result.stdout.strip() or None
-
-        except Exception as e:
-            print(f"Error getting device name: {e}")
-            return None
-
-    def restart_wda(self) -> tuple[bool, str]:
-        """
-        Restart WebDriverAgent (requires manual restart on device).
-
-        Returns:
-            Tuple of (success, message).
-
-        Note:
-            This method only checks if WDA needs restart.
-            Actual restart requires re-running WDA on the device via Xcode or other means.
-        """
-        if self.is_wda_ready():
-            return True, "WDA is already running"
-        else:
-            return (
-                False,
-                "WDA is not running. Please start it manually on the device.",
-            )
-
-
-def quick_connect(wda_url: str = "http://localhost:8100") -> tuple[bool, str]:
-    """
-    Quick helper to check iOS device connection and WDA status.
-
-    Args:
-        wda_url: WebDriverAgent URL.
-
-    Returns:
-        Tuple of (success, message).
-    """
-    conn = XCTestConnection(wda_url=wda_url)
-
-    # Check if device is connected
-    if not conn.is_connected():
-        return False, "No iOS device connected"
-
-    # Check if WDA is ready
-    if not conn.is_wda_ready():
-        return False, "WebDriverAgent is not running"
-
-    return True, "iOS device connected and WDA ready"
-
-
-def list_devices() -> list[DeviceInfo]:
-    """
-    Quick helper to list connected iOS devices.
-
-    Returns:
-        List of DeviceInfo objects.
-    """
-    conn = XCTestConnection()
-    return conn.list_devices()