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

AutoGLM_GUI/devices/__init__.py

@@ -0,0 +1,49 @@
+"""Device implementations for the DeviceProtocol interface.
+
+This package provides concrete implementations of DeviceProtocol:
+- ADBDevice: Local ADB subprocess calls
+- MockDevice: State machine driven mock for testing
+- RemoteDevice: HTTP client for remote device agents
+
+Example:
+    >>> from AutoGLM_GUI.devices import ADBDevice, RemoteDevice, get_device_manager
+    >>>
+    >>> # Local ADB device
+    >>> device = ADBDevice("emulator-5554")
+    >>> device.tap(100, 200)
+    >>>
+    >>> # Remote device via HTTP
+    >>> remote = RemoteDevice("phone_001", "http://device-agent:8001")
+    >>> remote.tap(100, 200)
+"""
+
+from AutoGLM_GUI.devices.adb_device import ADBDevice, ADBDeviceManager
+from AutoGLM_GUI.devices.mock_device import MockDevice
+from AutoGLM_GUI.devices.remote_device import RemoteDevice, RemoteDeviceManager
+
+_device_manager: "ADBDeviceManager | None" = None
+
+
+def get_device_manager() -> ADBDeviceManager:
+    """Get the global device manager instance."""
+    global _device_manager
+    if _device_manager is None:
+        _device_manager = ADBDeviceManager()
+    return _device_manager
+
+
+def set_device_manager(manager: "ADBDeviceManager") -> None:
+    """Set the global device manager instance (useful for testing)."""
+    global _device_manager
+    _device_manager = manager
+
+
+__all__ = [
+    "ADBDevice",
+    "ADBDeviceManager",
+    "MockDevice",
+    "RemoteDevice",
+    "RemoteDeviceManager",
+    "get_device_manager",
+    "set_device_manager",
+]

AutoGLM_GUI/devices/adb_device.py

@@ -0,0 +1,205 @@
+"""ADB Device implementation of DeviceProtocol.
+
+This module wraps the existing phone_agent.adb module to provide
+a DeviceProtocol-compliant implementation.
+"""
+
+from phone_agent import adb
+from phone_agent.adb import ADBConnection
+
+from AutoGLM_GUI.device_protocol import (
+    DeviceInfo,
+    DeviceManagerProtocol,
+    DeviceProtocol,
+    Screenshot,
+)
+
+
+class ADBDevice:
+    """
+    ADB device implementation using local subprocess calls.
+
+    Wraps the existing phone_agent.adb module to provide a clean
+    DeviceProtocol interface.
+
+    Example:
+        >>> device = ADBDevice("emulator-5554")
+        >>> screenshot = device.get_screenshot()
+        >>> device.tap(100, 200)
+        >>> device.swipe(100, 200, 300, 400)
+    """
+
+    def __init__(self, device_id: str):
+        """
+        Initialize ADB device.
+
+        Args:
+            device_id: ADB device ID (e.g., "emulator-5554", "192.168.1.100:5555").
+        """
+        self._device_id = device_id
+
+    @property
+    def device_id(self) -> str:
+        """Unique device identifier."""
+        return self._device_id
+
+    # === Screenshot ===
+    def get_screenshot(self, timeout: int = 10) -> Screenshot:
+        """Capture current screen."""
+        result = adb.get_screenshot(self._device_id, timeout)
+        return Screenshot(
+            base64_data=result.base64_data,
+            width=result.width,
+            height=result.height,
+            is_sensitive=result.is_sensitive,
+        )
+
+    # === Input Operations ===
+    def tap(self, x: int, y: int, delay: float | None = None) -> None:
+        """Tap at specified coordinates."""
+        adb.tap(x, y, self._device_id, delay)
+
+    def double_tap(self, x: int, y: int, delay: float | None = None) -> None:
+        """Double tap at specified coordinates."""
+        adb.double_tap(x, y, self._device_id, delay)
+
+    def long_press(
+        self, x: int, y: int, duration_ms: int = 3000, delay: float | None = None
+    ) -> None:
+        """Long press at specified coordinates."""
+        adb.long_press(x, y, duration_ms, self._device_id, delay)
+
+    def swipe(
+        self,
+        start_x: int,
+        start_y: int,
+        end_x: int,
+        end_y: int,
+        duration_ms: int | None = None,
+        delay: float | None = None,
+    ) -> None:
+        """Swipe from start to end coordinates."""
+        adb.swipe(start_x, start_y, end_x, end_y, duration_ms, self._device_id, delay)
+
+    def type_text(self, text: str) -> None:
+        """Type text into the currently focused input field."""
+        adb.type_text(text, self._device_id)
+
+    def clear_text(self) -> None:
+        """Clear text in the currently focused input field."""
+        adb.clear_text(self._device_id)
+
+    # === Navigation ===
+    def back(self, delay: float | None = None) -> None:
+        """Press the back button."""
+        adb.back(self._device_id, delay)
+
+    def home(self, delay: float | None = None) -> None:
+        """Press the home button."""
+        adb.home(self._device_id, delay)
+
+    def launch_app(self, app_name: str, delay: float | None = None) -> bool:
+        """Launch an app by name."""
+        return adb.launch_app(app_name, self._device_id, delay)
+
+    # === State Query ===
+    def get_current_app(self) -> str:
+        """Get the currently focused app name."""
+        return adb.get_current_app(self._device_id)
+
+    # === Keyboard Management ===
+    def detect_and_set_adb_keyboard(self) -> str:
+        """Detect current keyboard and switch to ADB Keyboard if needed."""
+        return adb.detect_and_set_adb_keyboard(self._device_id)
+
+    def restore_keyboard(self, ime: str) -> None:
+        """Restore the original keyboard IME."""
+        adb.restore_keyboard(ime, self._device_id)
+
+
+# Verify ADBDevice implements DeviceProtocol
+assert isinstance(ADBDevice("test"), DeviceProtocol)
+
+
+class ADBDeviceManager:
+    """
+    ADB device manager implementation.
+
+    Manages multiple ADB devices and provides DeviceProtocol instances.
+
+    Example:
+        >>> manager = ADBDeviceManager()
+        >>> devices = manager.list_devices()
+        >>> device = manager.get_device("emulator-5554")
+        >>> device.tap(100, 200)
+    """
+
+    def __init__(self, adb_path: str = "adb"):
+        """
+        Initialize the device manager.
+
+        Args:
+            adb_path: Path to ADB executable.
+        """
+        self._connection = ADBConnection(adb_path)
+        self._devices: dict[str, ADBDevice] = {}
+
+    def list_devices(self) -> list[DeviceInfo]:
+        """List all available devices."""
+        adb_devices = self._connection.list_devices()
+        result = []
+
+        for dev in adb_devices:
+            result.append(
+                DeviceInfo(
+                    device_id=dev.device_id,
+                    status="online" if dev.status == "device" else dev.status,
+                    model=dev.model,
+                    platform="android",
+                    connection_type=dev.connection_type.value,
+                )
+            )
+
+        return result
+
+    def get_device(self, device_id: str) -> ADBDevice:
+        """
+        Get a device instance by ID.
+
+        Args:
+            device_id: The device ID.
+
+        Returns:
+            ADBDevice instance.
+
+        Raises:
+            KeyError: If device not found or offline.
+        """
+        # Check if device exists and is online
+        devices = self.list_devices()
+        device_info = next((d for d in devices if d.device_id == device_id), None)
+
+        if device_info is None:
+            raise KeyError(f"Device '{device_id}' not found")
+        if device_info.status != "online":
+            raise KeyError(f"Device '{device_id}' is {device_info.status}")
+
+        # Cache and return device instance
+        if device_id not in self._devices:
+            self._devices[device_id] = ADBDevice(device_id)
+
+        return self._devices[device_id]
+
+    def connect(self, address: str, timeout: int = 10) -> tuple[bool, str]:
+        """Connect to a remote device."""
+        return self._connection.connect(address, timeout)
+
+    def disconnect(self, device_id: str) -> tuple[bool, str]:
+        """Disconnect from a device."""
+        # Remove from cache
+        self._devices.pop(device_id, None)
+        return self._connection.disconnect(device_id)
+
+
+# Verify ADBDeviceManager implements DeviceManagerProtocol
+assert isinstance(ADBDeviceManager(), DeviceManagerProtocol)

AutoGLM_GUI/devices/mock_device.py

@@ -0,0 +1,183 @@
+"""Mock Device implementation for testing.
+
+This module provides a MockDevice that routes all operations through
+a state machine, enabling controlled testing without real devices.
+"""
+
+from typing import TYPE_CHECKING
+
+from AutoGLM_GUI.device_protocol import (
+    DeviceInfo,
+    Screenshot,
+)
+
+if TYPE_CHECKING:
+    from tests.integration.state_machine import StateMachine
+
+
+class MockDevice:
+    """
+    Mock device implementation driven by a state machine.
+
+    All operations are routed through the state machine, which controls
+    screenshots and validates actions (tap coordinates, etc.).
+
+    Example:
+        >>> from tests.integration.state_machine import load_test_case
+        >>> state_machine, instruction, max_steps = load_test_case("scenario.yaml")
+        >>>
+        >>> device = MockDevice("mock_001", state_machine)
+        >>> screenshot = device.get_screenshot()  # Returns current state's screenshot
+        >>> device.tap(100, 200)  # State machine validates and transitions
+    """
+
+    def __init__(self, device_id: str, state_machine: "StateMachine"):
+        """
+        Initialize mock device.
+
+        Args:
+            device_id: Mock device ID.
+            state_machine: State machine that controls test flow.
+        """
+        self._device_id = device_id
+        self._state_machine = state_machine
+
+    @property
+    def device_id(self) -> str:
+        """Unique device identifier."""
+        return self._device_id
+
+    @property
+    def state_machine(self) -> "StateMachine":
+        """Get the underlying state machine."""
+        return self._state_machine
+
+    # === Screenshot ===
+    def get_screenshot(self, timeout: int = 10) -> Screenshot:
+        """Get screenshot from current state."""
+        result = self._state_machine.get_current_screenshot()
+        return Screenshot(
+            base64_data=result.base64_data,
+            width=result.width,
+            height=result.height,
+        )
+
+    # === Input Operations ===
+    def tap(self, x: int, y: int, delay: float | None = None) -> None:
+        """Handle tap action through state machine."""
+        self._state_machine.handle_tap(x, y)
+
+    def double_tap(self, x: int, y: int, delay: float | None = None) -> None:
+        """Handle double tap (treated as single tap)."""
+        self._state_machine.handle_tap(x, y)
+
+    def long_press(
+        self, x: int, y: int, duration_ms: int = 3000, delay: float | None = None
+    ) -> None:
+        """Handle long press (treated as tap for testing)."""
+        self._state_machine.handle_tap(x, y)
+
+    def swipe(
+        self,
+        start_x: int,
+        start_y: int,
+        end_x: int,
+        end_y: int,
+        duration_ms: int | None = None,
+        delay: float | None = None,
+    ) -> None:
+        """Handle swipe action."""
+        self._state_machine.handle_swipe(start_x, start_y, end_x, end_y)
+
+    def type_text(self, text: str) -> None:
+        """Handle text input (no-op in testing)."""
+        pass
+
+    def clear_text(self) -> None:
+        """Handle text clear (no-op in testing)."""
+        pass
+
+    # === Navigation ===
+    def back(self, delay: float | None = None) -> None:
+        """Handle back button (no-op in testing)."""
+        pass
+
+    def home(self, delay: float | None = None) -> None:
+        """Handle home button (no-op in testing)."""
+        pass
+
+    def launch_app(self, app_name: str, delay: float | None = None) -> bool:
+        """Handle app launch (always succeeds in testing)."""
+        return True
+
+    # === State Query ===
+    def get_current_app(self) -> str:
+        """Get current app name from the current state."""
+        return self._state_machine.current_state.current_app
+
+    # === Keyboard Management ===
+    def detect_and_set_adb_keyboard(self) -> str:
+        """Mock keyboard detection."""
+        return "com.mock.keyboard"
+
+    def restore_keyboard(self, ime: str) -> None:
+        """Mock keyboard restore."""
+        pass
+
+
+class MockDeviceManager:
+    """
+    Mock device manager for testing.
+
+    Provides a single mock device backed by a state machine.
+
+    Example:
+        >>> state_machine, _, _ = load_test_case("scenario.yaml")
+        >>> manager = MockDeviceManager(state_machine)
+        >>> device = manager.get_device("mock_001")
+    """
+
+    def __init__(
+        self,
+        state_machine: "StateMachine",
+        device_id: str = "mock_device_001",
+    ):
+        """
+        Initialize mock device manager.
+
+        Args:
+            state_machine: State machine for the mock device.
+            device_id: ID for the mock device.
+        """
+        self._device_id = device_id
+        self._device = MockDevice(device_id, state_machine)
+
+    def list_devices(self) -> list[DeviceInfo]:
+        """List the mock device."""
+        return [
+            DeviceInfo(
+                device_id=self._device_id,
+                status="online",
+                model="MockPhone",
+                platform="android",
+                connection_type="mock",
+            )
+        ]
+
+    def get_device(self, device_id: str) -> MockDevice:
+        """Get the mock device."""
+        if device_id != self._device_id:
+            raise KeyError(f"Device '{device_id}' not found")
+        return self._device
+
+    def connect(self, address: str, timeout: int = 10) -> tuple[bool, str]:
+        """Mock connect (always succeeds)."""
+        return True, f"Connected to {address}"
+
+    def disconnect(self, device_id: str) -> tuple[bool, str]:
+        """Mock disconnect (always succeeds)."""
+        return True, f"Disconnected from {device_id}"
+
+
+# Verify MockDeviceManager implements DeviceManagerProtocol
+# Same issue as above - can't verify at import time

AutoGLM_GUI/devices/remote_device.py

@@ -0,0 +1,172 @@
+"""Remote Device implementation using HTTP.
+
+This module provides a RemoteDevice that connects to a Device Agent
+via HTTP, allowing remote control of devices.
+"""
+
+import httpx
+
+from AutoGLM_GUI.device_protocol import DeviceInfo, Screenshot
+
+
+class RemoteDevice:
+    """
+    Remote device implementation using HTTP.
+
+    Connects to a Device Agent server that handles actual device operations.
+    The server decides the implementation (ADB, Accessibility, Mock, etc.).
+
+    Example:
+        >>> device = RemoteDevice("phone_001", "http://localhost:8001")
+        >>> screenshot = device.get_screenshot()
+        >>> device.tap(100, 200)
+    """
+
+    def __init__(self, device_id: str, base_url: str, timeout: float = 30.0):
+        self._device_id = device_id
+        self._base_url = base_url.rstrip("/")
+        self._client = httpx.Client(timeout=timeout)
+
+    @property
+    def device_id(self) -> str:
+        return self._device_id
+
+    def _post(self, endpoint: str, json: dict | None = None) -> dict:
+        """POST request helper."""
+        url = f"{self._base_url}/device/{self._device_id}{endpoint}"
+        resp = self._client.post(url, json=json or {})
+        resp.raise_for_status()
+        return resp.json()
+
+    def _get(self, endpoint: str) -> dict:
+        """GET request helper."""
+        url = f"{self._base_url}/device/{self._device_id}{endpoint}"
+        resp = self._client.get(url)
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_screenshot(self, timeout: int = 10) -> Screenshot:
+        data = self._post("/screenshot", {"timeout": timeout})
+        return Screenshot(
+            base64_data=data["base64_data"],
+            width=data["width"],
+            height=data["height"],
+            is_sensitive=data.get("is_sensitive", False),
+        )
+
+    def tap(self, x: int, y: int, delay: float | None = None) -> None:
+        self._post("/tap", {"x": x, "y": y, "delay": delay})
+
+    def double_tap(self, x: int, y: int, delay: float | None = None) -> None:
+        self._post("/double_tap", {"x": x, "y": y, "delay": delay})
+
+    def long_press(
+        self, x: int, y: int, duration_ms: int = 3000, delay: float | None = None
+    ) -> None:
+        self._post(
+            "/long_press", {"x": x, "y": y, "duration_ms": duration_ms, "delay": delay}
+        )
+
+    def swipe(
+        self,
+        start_x: int,
+        start_y: int,
+        end_x: int,
+        end_y: int,
+        duration_ms: int | None = None,
+        delay: float | None = None,
+    ) -> None:
+        self._post(
+            "/swipe",
+            {
+                "start_x": start_x,
+                "start_y": start_y,
+                "end_x": end_x,
+                "end_y": end_y,
+                "duration_ms": duration_ms,
+                "delay": delay,
+            },
+        )
+
+    def type_text(self, text: str) -> None:
+        self._post("/type_text", {"text": text})
+
+    def clear_text(self) -> None:
+        self._post("/clear_text")
+
+    def back(self, delay: float | None = None) -> None:
+        self._post("/back", {"delay": delay})
+
+    def home(self, delay: float | None = None) -> None:
+        self._post("/home", {"delay": delay})
+
+    def launch_app(self, app_name: str, delay: float | None = None) -> bool:
+        data = self._post("/launch_app", {"app_name": app_name, "delay": delay})
+        return data.get("success", True)
+
+    def get_current_app(self) -> str:
+        data = self._get("/current_app")
+        return data["app_name"]
+
+    def detect_and_set_adb_keyboard(self) -> str:
+        data = self._post("/detect_keyboard")
+        return data.get("original_ime", "")
+
+    def restore_keyboard(self, ime: str) -> None:
+        self._post("/restore_keyboard", {"ime": ime})
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class RemoteDeviceManager:
+    """
+    Remote device manager using HTTP.
+
+    Manages connections to a Device Agent server.
+    """
+
+    def __init__(self, base_url: str, timeout: float = 30.0):
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._client = httpx.Client(timeout=timeout)
+        self._devices: dict[str, RemoteDevice] = {}
+
+    def list_devices(self) -> list[DeviceInfo]:
+        resp = self._client.get(f"{self._base_url}/devices")
+        resp.raise_for_status()
+        return [DeviceInfo(**d) for d in resp.json()]
+
+    def get_device(self, device_id: str) -> RemoteDevice:
+        if device_id not in self._devices:
+            self._devices[device_id] = RemoteDevice(
+                device_id, self._base_url, self._timeout
+            )
+        return self._devices[device_id]
+
+    def connect(self, address: str, timeout: int = 10) -> tuple[bool, str]:
+        resp = self._client.post(
+            f"{self._base_url}/connect", json={"address": address, "timeout": timeout}
+        )
+        data = resp.json()
+        return data.get("success", False), data.get("message", "")
+
+    def disconnect(self, device_id: str) -> tuple[bool, str]:
+        self._devices.pop(device_id, None)
+        resp = self._client.post(
+            f"{self._base_url}/disconnect", json={"device_id": device_id}
+        )
+        data = resp.json()
+        return data.get("success", True), data.get("message", "Disconnected")
+
+    def close(self) -> None:
+        for device in self._devices.values():
+            device.close()
+        self._client.close()

AutoGLM_GUI/dual_model/decision_model.py

@@ -49,8 +49,8 @@ class ActionStep:
     need_generate: bool = False
     direction: Optional[str] = None
 
-    def to_dict(self) -> dict:
-        result = {"action": self.action, "target": self.target}
+    def to_dict(self) -> dict[str, str | bool]:
+        result: dict[str, str | bool] = {"action": self.action, "target": self.target}
         if self.content:
             result["content"] = self.content
         if self.need_generate:
@@ -127,7 +127,7 @@ class DecisionModel:
         self.client = OpenAI(
             base_url=config.base_url,
             api_key=config.api_key,
-        )
+        )  # type: ignore[call-arg]
         self.model_name = config.model_name
         self.conversation_history: list[dict] = []
         self.current_task: str = ""
@@ -159,7 +159,7 @@ class DecisionModel:
         try:
             response = self.client.chat.completions.create(
                 model=self.model_name,
-                messages=messages,
+                messages=messages,  # type: ignore[arg-type]
                 max_tokens=self.config.max_tokens,
                 temperature=self.config.temperature,
                 stream=True,

AutoGLM_GUI/exceptions.py

@@ -79,9 +79,9 @@ class AgentInitializationError(Exception):
     How to fix:
         1. Check configuration:
             >>> from AutoGLM_GUI.config_manager import config_manager
-            >>> config = config_manager.get_effective_config()
-            >>> print(f"base_url: {config.base_url}")
-            >>> print(f"model_name: {config.model_name}")
+            >>> effective_config = config_manager.get_effective_config()
+            >>> print(f"base_url: {effective_config.base_url}")
+            >>> print(f"model_name: {effective_config.model_name}")
 
         2. Set configuration:
             >>> via API: POST /api/config {"base_url": "...", "model_name": "...", "api_key": "..."}

AutoGLM_GUI/mai_ui_adapter/agent_wrapper.py

@@ -8,8 +8,8 @@ from phone_agent.actions.handler import ActionHandler
 from phone_agent.model import ModelConfig
 
 from AutoGLM_GUI.logger import logger
-from AutoGLM_GUI.mai_ui.mai_navigation_agent import MAIUINaivigationAgent
-from AutoGLM_GUI.mai_ui_adapter.action_adapter import MAIUIActionAdapter
+from AutoGLM_GUI.mai_ui.mai_navigation_agent import MAIUINaivigationAgent  # type: ignore[import-not-found]
+from AutoGLM_GUI.mai_ui_adapter.action_adapter import MAIUIActionAdapter  # type: ignore[import-not-found]
 
 
 @dataclass