autoglm-gui 1.5.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

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()