tessl/pypi-appium-python-client

Python client library for Appium mobile automation framework extending Selenium WebDriver with iOS and Android testing capabilities

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Configuration Options

Name: tessl/pypi-appium-python-client
Author: tessl

Platform-specific capability configuration classes for Android (UiAutomator2, Espresso), iOS (XCUITest, Safari), and other platforms. These options classes provide type-safe configuration of Appium capabilities and driver-specific settings.

Capabilities

Base Options Class

Foundation class for all platform-specific options providing common capability management functionality.

class AppiumOptions:
    def __init__(self):
        """Initialize options with empty capabilities."""
    
    def set_capability(self, name: str, value):
        """
        Set a capability value.
        
        Args:
            name (str): Capability name
            value: Capability value (any type)
        """
    
    def get_capability(self, name: str):
        """
        Get a capability value.
        
        Args:
            name (str): Capability name
            
        Returns:
            Any: Capability value or None if not set
        """
    
    def load_capabilities(self, caps: dict):
        """
        Load multiple capabilities from dictionary.
        
        Args:
            caps (dict): Dictionary of capability name-value pairs
        """
    
    def to_w3c(self) -> dict:
        """
        Convert capabilities to W3C format.
        
        Returns:
            dict: W3C-formatted capabilities
        """
    
    def to_capabilities(self) -> dict:
        """
        Convert to capabilities dictionary.
        
        Returns:
            dict: Capabilities dictionary ready for WebDriver
        """

Android Options

Android platform-specific options classes for UiAutomator2 and Espresso drivers.

class UiAutomator2Options(AppiumOptions):
    """Options for Android UiAutomator2 driver with 100+ capability mixins."""
    
    # Core Android capabilities
    platform_name: str = "Android"
    device_name: str = None
    platform_version: str = None
    udid: str = None
    
    # App capabilities
    app: str = None
    app_package: str = None
    app_activity: str = None
    app_wait_package: str = None
    app_wait_activity: str = None
    
    # Device capabilities
    system_port: int = None
    device_ready_timeout: int = None
    android_device_ready_timeout: int = None
    
    # ADB capabilities
    adb_port: int = None
    adb_exec_timeout: int = None
    
    # Chrome/WebView capabilities
    chromedriver_executable: str = None
    chromedriver_port: int = None
    chrome_options: dict = None
    
    def __init__(self):
        """Initialize UiAutomator2 options with Android defaults."""

class EspressoOptions(AppiumOptions):
    """Options for Android Espresso driver."""
    
    platform_name: str = "Android"
    automation_name: str = "Espresso"
    
    def __init__(self):
        """Initialize Espresso options with Android defaults."""

iOS Options

iOS platform-specific options classes for XCUITest and Safari drivers.

class XCUITestOptions(AppiumOptions):
    """Options for iOS XCUITest driver with 100+ capability mixins."""
    
    # Core iOS capabilities
    platform_name: str = "iOS"
    device_name: str = None
    platform_version: str = None
    udid: str = None
    
    # App capabilities
    app: str = None
    bundle_id: str = None
    
    # Simulator capabilities
    simulator_startup_timeout: int = None
    simulator_tracing_timeout: int = None
    
    # WebDriverAgent capabilities
    wda_launch_timeout: int = None
    wda_connection_timeout: int = None
    wda_startup_retries: int = None
    wda_base_url: str = None
    
    # WebView capabilities
    safari_options: dict = None
    webkit_response_timeout: int = None
    
    def __init__(self):
        """Initialize XCUITest options with iOS defaults."""

class SafariOptions(AppiumOptions):
    """Options for iOS Safari driver."""
    
    platform_name: str = "iOS"
    browser_name: str = "Safari"
    
    def __init__(self):
        """Initialize Safari options with iOS defaults."""

Other Platform Options

Options classes for additional platforms including Mac, Windows, and specialized drivers.

class Mac2Options(AppiumOptions):
    """Options for Mac automation."""
    
    platform_name: str = "Mac"
    automation_name: str = "Mac2"
    
    def __init__(self):
        """Initialize Mac2 options."""

class WindowsOptions(AppiumOptions):
    """Options for Windows automation."""
    
    platform_name: str = "Windows"
    automation_name: str = "Windows"
    
    def __init__(self):
        """Initialize Windows options."""

class GeckoOptions(AppiumOptions):
    """Options for Gecko (Firefox) automation."""
    
    browser_name: str = "firefox"
    automation_name: str = "Gecko"
    
    def __init__(self):
        """Initialize Gecko options."""

class FlutterIntegrationOptions(AppiumOptions):
    """Options for Flutter integration."""
    
    automation_name: str = "Flutter"
    
    def __init__(self):
        """Initialize Flutter integration options."""

Usage Examples

Basic Android Configuration

from appium import webdriver
from appium.options.android import UiAutomator2Options

# Create and configure Android options
options = UiAutomator2Options()
options.platform_name = "Android"
options.device_name = "Android Emulator"
options.platform_version = "11"
options.app = "/path/to/your/app.apk"
options.app_package = "com.example.myapp"
options.app_activity = ".MainActivity"

# Additional Android-specific settings
options.system_port = 8200
options.chromedriver_port = 9515
options.device_ready_timeout = 60
options.adb_exec_timeout = 20000

# Start driver with options
driver = webdriver.Remote("http://localhost:4723", options=options)

iOS Configuration

from appium import webdriver
from appium.options.ios import XCUITestOptions

# Create and configure iOS options
options = XCUITestOptions()
options.platform_name = "iOS"
options.device_name = "iPhone 14"
options.platform_version = "16.0"
options.app = "/path/to/your/app.ipa"
options.bundle_id = "com.example.myapp"

# iOS-specific settings
options.wda_launch_timeout = 60000
options.wda_connection_timeout = 60000
options.simulator_startup_timeout = 180000

# WebView testing configuration
options.safari_options = {
    "webInspectorDebugProxyPort": 9999
}

# Start driver with options
driver = webdriver.Remote("http://localhost:4723", options=options)

Advanced Capability Configuration

# Using generic capability setting
options = UiAutomator2Options()

# Set individual capabilities
options.set_capability("appium:deviceName", "Pixel 4")
options.set_capability("appium:platformVersion", "12")
options.set_capability("appium:noReset", True)
options.set_capability("appium:fullReset", False)

# Load capabilities from dictionary
caps_dict = {
    "appium:automationName": "UiAutomator2",
    "appium:newCommandTimeout": 300,
    "appium:unicodeKeyboard": True,
    "appium:resetKeyboard": True
}
options.load_capabilities(caps_dict)

# Get capability values
device_name = options.get_capability("appium:deviceName")
print(f"Device name: {device_name}")

# Convert to different formats
w3c_caps = options.to_w3c()
legacy_caps = options.to_capabilities()

Chrome/WebView Configuration

# Configure for hybrid app testing
options = UiAutomator2Options()
options.platform_name = "Android"
options.device_name = "Android Emulator"
options.app = "/path/to/hybrid/app.apk"

# Chrome/WebView specific settings
options.chromedriver_executable = "/path/to/chromedriver"
options.chromedriver_port = 9515

# Chrome options for WebView
chrome_options = {
    "w3c": False,
    "args": ["--disable-web-security", "--allow-running-insecure-content"]
}
options.chrome_options = chrome_options

# Additional WebView settings
options.set_capability("appium:chromedriverExecutableDir", "/usr/local/bin")
options.set_capability("appium:autoWebview", True)
options.set_capability("appium:autoWebviewTimeout", 20000)

Multi-Platform Testing Setup

def create_android_options():
    """Create Android testing options."""
    options = UiAutomator2Options()
    options.platform_name = "Android"
    options.device_name = "Android Emulator"
    options.app = "/path/to/android/app.apk"
    options.app_package = "com.example.app"
    options.app_activity = ".MainActivity"
    return options

def create_ios_options():
    """Create iOS testing options."""
    options = XCUITestOptions()
    options.platform_name = "iOS"
    options.device_name = "iPhone 14"
    options.app = "/path/to/ios/app.ipa"
    options.bundle_id = "com.example.app"
    return options

def create_safari_options():
    """Create Safari web testing options."""
    options = SafariOptions()
    options.platform_name = "iOS"
    options.browser_name = "Safari"
    options.device_name = "iPhone 14"
    return options

# Platform detection and configuration
import sys

def get_platform_options(platform):
    """Get options based on platform."""
    if platform.lower() == "android":
        return create_android_options()
    elif platform.lower() == "ios":
        return create_ios_options()
    elif platform.lower() == "safari":
        return create_safari_options()
    else:
        raise ValueError(f"Unsupported platform: {platform}")

# Usage
platform = "android"  # Could be from command line or config
options = get_platform_options(platform)
driver = webdriver.Remote("http://localhost:4723", options=options)

Real Device Configuration

# Android real device
def configure_android_real_device():
    options = UiAutomator2Options()
    options.platform_name = "Android"
    options.device_name = "Samsung Galaxy S21"
    options.udid = "R58M40B1234"  # Device UDID
    options.platform_version = "12"
    options.app = "/path/to/app.apk"
    
    # Real device specific settings
    options.set_capability("appium:systemPort", 8200)
    options.set_capability("appium:skipServerInstallation", True)
    options.set_capability("appium:skipDeviceInitialization", True)
    
    return options

# iOS real device
def configure_ios_real_device():
    options = XCUITestOptions()
    options.platform_name = "iOS"
    options.device_name = "iPhone 13"
    options.udid = "00008110-001234567890123A"  # Device UDID
    options.platform_version = "15.4"
    options.bundle_id = "com.example.app"
    
    # Real device specific settings
    options.set_capability("appium:xcodeOrgId", "TEAM12345")
    options.set_capability("appium:xcodeSigningId", "iPhone Developer")
    options.set_capability("appium:useNewWDA", False)
    options.set_capability("appium:usePrebuiltWDA", True)
    
    return options

Cloud Testing Configuration

# Sauce Labs configuration
def configure_sauce_labs():
    options = UiAutomator2Options()
    options.platform_name = "Android"
    options.device_name = "Samsung Galaxy S.*"
    options.platform_version = "12"
    options.app = "sauce-storage:app.apk"
    
    # Sauce Labs specific capabilities
    options.set_capability("appium:appiumVersion", "2.0.0")
    options.set_capability("sauce:options", {
        "name": "My Test",
        "build": "Build 123",
        "tags": ["mobile", "android"]
    })
    
    return options

# BrowserStack configuration  
def configure_browserstack():
    options = XCUITestOptions()
    options.platform_name = "iOS"
    options.device_name = "iPhone 14"
    options.platform_version = "16"
    options.app = "bs://app-id-from-upload"
    
    # BrowserStack specific capabilities
    options.set_capability("bstack:options", {
        "projectName": "My Project",
        "buildName": "Build 123",
        "sessionName": "iOS Test"
    })
    
    return options

Types

# Base types
CapabilityName = str
CapabilityValue = Union[str, int, bool, dict, list]
CapabilitiesDict = Dict[str, CapabilityValue]

# Platform identifiers
PlatformName = str  # "Android", "iOS", "Windows", "Mac"
DeviceName = str    # Device name or pattern
PlatformVersion = str  # OS version
UDID = str         # Device unique identifier

# App identifiers
AppPath = str      # File path to app binary
PackageName = str  # Android package name
BundleId = str     # iOS bundle identifier
ActivityName = str # Android activity name

# Connection settings
ServerURL = str    # Appium server URL
Port = int        # Port number
Timeout = int     # Timeout in milliseconds

# Chrome/WebView settings
ChromeOptions = Dict[str, Union[bool, List[str]]]
ChromeDriverPath = str

# Cloud service settings
SauceOptions = Dict[str, Union[str, List[str]]]
BrowserStackOptions = Dict[str, str]

Install with Tessl CLI

npx tessl i tessl/pypi-appium-python-client

docs

advanced-features.md

android-platform.md

application-management.md

configuration-options.md

device-interaction.md

element-location.md

index.md

service-management.md

webdriver-core.md

tile.json

tessl/pypi-appium-python-client