testmu-playwright-python 0.1.0__tar.gz

testmu_playwright_python-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 TestMu AI (LambdaTest)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

testmu_playwright_python-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+include LICENSE
+include README.md
+include pyproject.toml
+recursive-include testmu *.py
+
+# Exclude tests and dev artifacts from sdist
+prune tests
+prune .github

testmu_playwright_python-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: testmu-playwright-python
+Version: 0.1.0
+Summary: TestMu binding for Playwright Python — thin test runtime for TestMu/LambdaTest exports
+Author-email: TestMu AI <engineering@testmu.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://testmu.ai
+Project-URL: Documentation, https://docs.testmu.ai
+Project-URL: Repository, https://github.com/testmuai/testmu-bindings
+Keywords: testing,ai,agents,playwright,lambdatest,testmu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Topic :: Software Development :: Testing
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.57.0
+Requires-Dist: pyotp>=2.9.0
+Requires-Dist: aiohttp
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Dynamic: license-file
+
+# testmu-playwright-python
+
+TestMu binding for Playwright Python — a thin test runtime for running TestMu exported tests locally or on the LambdaTest grid.
+
+## Installation
+
+```bash
+pip install testmu-playwright-python
+```
+
+## Quick Start
+
+```python
+import testmu
+
+testmu.configure(
+    username="YOUR_LT_USERNAME",
+    access_key="YOUR_LT_ACCESS_KEY",
+)
+
+@testmu.test
+async def my_test(page):
+    async with testmu.step("Open site"):
+        await page.goto("https://example.com")
+
+    async with testmu.step("Verify title"):
+        testmu.expect(page).to_have_title("Example Domain")
+
+testmu.run(my_test)
+```
+
+## Features
+
+- **Test decorator** — `@testmu.test` wraps async Playwright tests with session lifecycle
+- **Step tracking** — `testmu.step(...)` context manager for structured test steps
+- **Variable system** — `var()` / `set_var()` for template-based test data
+- **Helpers** — vision queries, API/DB/JS execution, network assertions, SmartUI snapshots
+- **Reporters** — local console and LambdaTest cloud reporting
+- **Self-healing locators** — automatic locator recovery via heal patch
+
+## Requirements
+
+- Python >= 3.11
+- Playwright >= 1.57.0
+
+## Links
+
+- Homepage: [testmu.ai](https://testmu.ai)
+- Documentation: [docs.testmu.ai](https://docs.testmu.ai)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

testmu_playwright_python-0.1.0/README.md

@@ -0,0 +1,53 @@
+# testmu-playwright-python
+
+TestMu binding for Playwright Python — a thin test runtime for running TestMu exported tests locally or on the LambdaTest grid.
+
+## Installation
+
+```bash
+pip install testmu-playwright-python
+```
+
+## Quick Start
+
+```python
+import testmu
+
+testmu.configure(
+    username="YOUR_LT_USERNAME",
+    access_key="YOUR_LT_ACCESS_KEY",
+)
+
+@testmu.test
+async def my_test(page):
+    async with testmu.step("Open site"):
+        await page.goto("https://example.com")
+
+    async with testmu.step("Verify title"):
+        testmu.expect(page).to_have_title("Example Domain")
+
+testmu.run(my_test)
+```
+
+## Features
+
+- **Test decorator** — `@testmu.test` wraps async Playwright tests with session lifecycle
+- **Step tracking** — `testmu.step(...)` context manager for structured test steps
+- **Variable system** — `var()` / `set_var()` for template-based test data
+- **Helpers** — vision queries, API/DB/JS execution, network assertions, SmartUI snapshots
+- **Reporters** — local console and LambdaTest cloud reporting
+- **Self-healing locators** — automatic locator recovery via heal patch
+
+## Requirements
+
+- Python >= 3.11
+- Playwright >= 1.57.0
+
+## Links
+
+- Homepage: [testmu.ai](https://testmu.ai)
+- Documentation: [docs.testmu.ai](https://docs.testmu.ai)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

testmu_playwright_python-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "testmu-playwright-python"
+version = "0.1.0"
+description = "TestMu binding for Playwright Python — thin test runtime for TestMu/LambdaTest exports"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    {name = "TestMu AI", email = "engineering@testmu.ai"},
+]
+keywords = ["testing", "ai", "agents", "playwright", "lambdatest", "testmu"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Topic :: Software Development :: Testing",
+    "Framework :: Pytest",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "playwright>=1.57.0",
+    "pyotp>=2.9.0",
+    "aiohttp",
+    "httpx>=0.27.0",
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+]
+
+[project.urls]
+Homepage = "https://testmu.ai"
+Documentation = "https://docs.testmu.ai"
+Repository = "https://github.com/testmuai/testmu-bindings"
+
+[tool.setuptools.packages.find]
+include = ["testmu*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

testmu_playwright_python-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

testmu_playwright_python-0.1.0/testmu/__init__.py

@@ -0,0 +1,58 @@
+"""Testmu binding for Playwright Python.
+
+Public API:
+    testmu.test          — decorator for test functions
+    testmu.step(...)     — step context manager
+    testmu.run(fn)       — session lifecycle runner
+    var(template)        — variable/template resolver
+    set_var(name, value) — store variable
+    expect               — PW expect with custom matchers
+    testmu.<helper>(...)  — helper functions (execute_js, vision_query, etc.)
+"""
+
+from testmu._configure import configure
+from testmu._decorator import test
+from testmu._step import step
+from testmu._session import run
+from testmu._vars import var, set_var
+from testmu._matchers import expect
+from testmu._errors import TestmuConfigError
+
+# Helpers — vision functions ported; remaining stubs will be replaced in Layer B
+from testmu._helpers import (
+    execute_js,
+    execute_api,
+    execute_db,
+    vision_query,
+    textual_query,
+    vision_wait,
+    vision_action,
+    verify_assertion,
+    evaluate_branch,
+    network_query,
+    evaluate_network_assertion,
+    evaluate_math,
+    smartui_snapshot,
+    switch_tab,
+    click_drag,
+    execute_kane_cli,
+    check_until_condition,
+    get_vision_coordinates,
+)
+
+# Install PW-specific heal patch
+import testmu.playwright_async  # noqa: F401 — triggers _install_heal()
+
+__all__ = [
+    "configure",
+    "test", "step", "run", "var", "set_var", "expect",
+    "execute_js", "execute_api", "execute_db",
+    "vision_query", "textual_query", "vision_wait", "vision_action",
+    "verify_assertion", "evaluate_branch",
+    "network_query", "evaluate_network_assertion",
+    "evaluate_math", "smartui_snapshot",
+    "switch_tab", "click_drag",
+    "execute_kane_cli", "check_until_condition",
+    "get_vision_coordinates",
+    "TestmuConfigError",
+]

testmu_playwright_python-0.1.0/testmu/_capability.py

@@ -0,0 +1,249 @@
+"""LambdaTest capability builder for Playwright Python.
+
+Configuration is sourced from testmu.configure() data first, then falls back
+to environment variables (no sys.argv / test-run JSON).
+This module is the env-var-only equivalent of the capability.py template produced by
+create_capabilities_file_playwright() in auteur-code-export.
+"""
+import json
+import os
+import urllib.parse
+from pathlib import Path
+
+from testmu import _configure
+
+try:
+    from importlib.metadata import version as _pkg_version
+    _PW_VERSION = _pkg_version("playwright")
+except Exception:
+    _PW_VERSION = "unknown"
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers (match template helpers exactly)
+# ---------------------------------------------------------------------------
+
+def _get_download_folder() -> Path:
+    """Return the system Downloads folder, creating it if needed."""
+    if os.name == "nt":
+        downloads_path = Path(os.path.join(os.environ.get("USERPROFILE", ""), "Downloads"))
+    else:
+        downloads_path = Path(os.path.expanduser("~/Downloads"))
+    downloads_path.mkdir(parents=True, exist_ok=True)
+    return downloads_path
+
+
+def _get_cap_value(cap_name: str, default_value=None):
+    """Return env var value or default — mirrors get_cap_value(None, ...) path."""
+    return os.getenv(cap_name, default_value)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def get_capabilities(
+    browser: str = None,
+    browser_version: str = None,
+    resolution: str = None,
+    platform: str = None,
+    *,
+    # baked-in values (set at code-export time, overridable by env)
+    build: str = None,
+    name: str = None,
+    tc_id: str = None,
+    network_caps: bool = False,
+    multiple_profiles: bool = False,
+    chrome_options: list = None,
+    custom_headers: dict = None,
+) -> dict:
+    """Build and return the LambdaTest capabilities dict.
+
+    All parameters fall back to env vars when not supplied, mirroring the
+    template's get_cap_value(test_config, ...) with test_config=None path.
+
+    After building, sets smart_os / smart_os_version / smart_browser_name /
+    smart_browser_version env vars (same as the template).
+    """
+    if chrome_options is None:
+        chrome_options = _configure.get("chrome_options", [])
+    if custom_headers is None:
+        custom_headers = _configure.get("custom_headers", {})
+
+    # Resolve top-level fields from env or defaults
+    _browser = browser or os.getenv("LT_BROWSER", "Chrome")
+    _browser_version = browser_version or os.getenv("LT_BROWSER_VERSION", "latest")
+    _resolution = resolution or os.getenv("LT_RESOLUTION", "1920x1080")
+    _platform = platform or os.getenv("LT_PLATFORM", "linux")
+
+    username = os.getenv("LT_USERNAME")
+    access_key = os.getenv("LT_ACCESS_KEY")
+
+    # HE test-run config — checked after configure(), before env vars
+    from testmu._test_config import get_cap_value as _he_cap
+
+    # video/visual/console/network coerce env strings to bool-like; template
+    # passes True/False from get_cap_value so booleans are fine here.
+    def _bool_env(key: str, default: bool) -> bool:
+        val = os.getenv(key)
+        if val is None:
+            return default
+        return val.lower() in ("1", "true", "yes")
+
+    def _bool_he(key: str, default: bool) -> bool:
+        """Check test_config first, then env var, then default."""
+        val = _he_cap(key, None)
+        if val is None:
+            return default
+        if isinstance(val, bool):
+            return val
+        return str(val).lower() in ("1", "true", "yes")
+
+    # Build + name: configure() > test_config > env > default
+    _build = _configure.get("build") or _he_cap("BUILD", os.getenv("BUILD", build or ""))
+    _name = _configure.get("name") or _he_cap("TEST_NAME", os.getenv("TEST_NAME", name or ""))
+    _tc_id = _configure.get("tc_id") or tc_id or os.getenv("LT_TC_ID", "")
+
+    # For bool fields: configure() wins when explicitly set, then test_config > env > default.
+    _cfg_network = _configure.get("network")
+    if _configure.was_set("network"):
+        _network = bool(_cfg_network)
+    else:
+        _network = _bool_he("NETWORK", network_caps)
+
+    _cfg_multiple_profiles = _configure.get("multiple_profiles")
+    if _configure.was_set("multiple_profiles"):
+        multiple_profiles = _cfg_multiple_profiles
+
+    # Bool caps: configure() has no explicit setters for these, so test_config > env > default.
+    _video = _bool_he("VIDEO", True)
+    _visual = _bool_he("VISUAL", True)
+    _console = _bool_he("CONSOLE", True)
+    _tunnel = _bool_he("TUNNEL", False)
+    _performance = _bool_he("PERFORMANCE", False)
+    _dedicated_proxy = _bool_he("DEDICATED_PROXY", False)
+    _accessibility = _bool_he("ACCESSIBILITY", False)
+    _idle_timeout = int(_he_cap("IDLE_TIMEOUT", os.getenv("IDLE_TIMEOUT", "1800")))
+
+    capabilities = {
+        "browserName": _browser,
+        "browserVersion": _browser_version,
+        "LT:Options": {
+            "platform": _platform,
+            "user": username,
+            "accessKey": access_key,
+            "video": _video,
+            "resolution": _resolution,
+            "network": _network,
+            "network.full.har": _network,
+            "build": _build,
+            "project": "Auteur-Code-Export",
+            "name": _name,
+            "w3c": True,
+            "plugin": "python-python",
+            "visual": _visual,
+            "console": _console,
+            "tms.tc_id": _tc_id,
+            "loadExtensions": [os.getenv("EXTENSION")],
+            "playwrightClientVersion": _PW_VERSION,
+            "tunnel": _tunnel,
+            "performance": _performance,
+            "dedicatedProxy": _dedicated_proxy,
+            "idleTimeout": _idle_timeout,
+            "accessibility": _accessibility,
+            "hideInternalCommandLogs": True,
+            "dependentTestsInScenario": multiple_profiles,
+        },
+    }
+
+    # Geolocation — conditional (matches: if os.getenv("GEO_LOCATION", False))
+    if os.getenv("GEO_LOCATION", False):
+        capabilities["LT:Options"]["geoLocation"] = os.getenv("GEO_LOCATION")
+
+    # Timezone — configure() > test_config (dict with "region") > env var
+    _timezone = _configure.get("timezone") or ""
+    if not _timezone:
+        from testmu._test_config import load_test_config
+        _tc = load_test_config()
+        if _tc:
+            _tz_val = _tc.get("timezone", {})
+            if isinstance(_tz_val, dict) and _tz_val.get("region"):
+                _timezone = _tz_val["region"]
+    if not _timezone:
+        _timezone = os.getenv("TIMEZONE", "")
+    if _timezone:
+        capabilities["LT:Options"]["timezone"] = _timezone
+
+    # Custom headers — conditional
+    if custom_headers:
+        capabilities["LT:Options"]["customHeaders"] = custom_headers
+
+    # Browser-specific options
+    if _browser.lower() in ("chrome", "pw-chromium"):
+        default_args = [
+            "--enable-logging",
+            "--disable-notifications",
+            "--no-sandbox",
+            "--log-level=0",
+            "--ignore-certificate-errors",
+            "--disable-blink-features=AutomationControlled",
+            "--password-store=basic",
+            "--safebrowsing-disable-auto-update",
+            "--disable-sync",
+        ]
+        capabilities["LT:Options"]["goog:chromeOptions"] = default_args
+        for op in chrome_options:
+            op_key = op.get("key", "")
+            op_type = op.get("type", "")
+            if op_type == "file":
+                op_value = os.path.join(str(_get_download_folder()), op.get("value", ""))
+            else:
+                op_value = op.get("value", "")
+            if op_type == "no-args":
+                capabilities["LT:Options"]["goog:chromeOptions"].append(f"{op_key}")
+            else:
+                capabilities["LT:Options"]["goog:chromeOptions"].append(f"{op_key}={op_value}")
+    elif _browser.lower() == "microsoftedge":
+        default_args = [
+            "--enable-logging",
+            "--disable-notifications",
+            "--log-level=0",
+            "--disable-blink-features=AutomationControlled",
+            "--password-store=basic",
+            "--safebrowsing-disable-auto-update",
+            "--disable-sync",
+        ]
+        capabilities["LT:Options"]["ms:edgeOptions"] = default_args
+    elif _browser.lower() in ("firefox", "pw-firefox"):
+        capabilities["LT:Options"]["firefoxUserPrefs"] = {
+            "dom.webnotifications.enabled": False,
+            "signon.rememberSignons": False,
+            "signon.autofillForms": False,
+            "permissions.default.desktop-notification": 2,
+        }
+
+    # Set smart env vars (same as template)
+    os.environ["smart_os"] = capabilities["LT:Options"]["platform"]
+    os.environ["smart_os_version"] = "latest"
+    os.environ["smart_browser_name"] = capabilities["browserName"]
+    os.environ["smart_browser_version"] = capabilities["browserVersion"]
+
+    return capabilities
+
+
+def get_cdp_url(capabilities: dict) -> str:
+    """Build the LambdaTest CDP WebSocket URL from a capabilities dict."""
+    return (
+        "wss://cdp.lambdatest.com/playwright?capabilities="
+        + urllib.parse.quote(json.dumps(capabilities))
+    )
+
+
+def get_viewport(resolution: str = None) -> dict:
+    """Parse a resolution string like '1920x1080' into a viewport dict."""
+    _res = resolution or os.getenv("LT_RESOLUTION", "1920x1080")
+    try:
+        width_str, height_str = _res.lower().split("x")
+        return {"width": int(width_str), "height": int(height_str)}
+    except (ValueError, AttributeError):
+        return {"width": 1920, "height": 1080}

testmu_playwright_python-0.1.0/testmu/_config.py

@@ -0,0 +1,9 @@
+"""Platform and smart mode detection from environment variables.
+
+platform: True when LT_USERNAME + LT_ACCESS_KEY are set (LT infrastructure accessible)
+smart: True when platform is on AND TESTMU_SMART=1 (AI/heal features enabled)
+"""
+import os
+
+platform = bool(os.getenv("LT_USERNAME")) and bool(os.getenv("LT_ACCESS_KEY"))
+smart = platform and os.getenv("TESTMU_SMART", "0") == "1"

testmu_playwright_python-0.1.0/testmu/_configure.py

@@ -0,0 +1,81 @@
+"""Export-time configuration for testmu.
+
+testmu.configure() is called at the top of generated test files to
+pass values that were known at export time (test name, build ID,
+variables, chrome options, etc.) into the binding runtime.
+
+This replaces the old pattern of baking values into capability.py
+and test.py as string literals.
+"""
+import logging
+
+_log = logging.getLogger("testmu")
+
+# All config fields with defaults
+_config_data = {
+    "build": "",
+    "name": "",
+    "tc_id": "",
+    "network": False,
+    "timezone": "",
+    "chrome_options": [],
+    "custom_headers": {},
+    "multiple_profiles": False,
+    "variables": {},
+    "test_params": {},
+    "global_variables": [],
+    "uploaded_files": [],
+}
+
+# Keys explicitly set via configure() — used to distinguish "not configured"
+# from "configured to the default value" (important for bool fields).
+_configured_keys: set = set()
+
+
+def configure(**kwargs):
+    """Set export-time configuration values.
+
+    Called once at the top of generated test files before @testmu.test.
+    Values are consumed by _capability.py, _vars.py, and _session.py.
+    """
+    for key, value in kwargs.items():
+        if key not in _config_data:
+            _log.warning(f"testmu.configure: unknown key '{key}', ignoring")
+            continue
+        _config_data[key] = value
+        _configured_keys.add(key)
+
+    # Populate variable stores immediately
+    from testmu._vars import set_var, _test_params, _global_variables
+    for var_name, var_value in _config_data.get("variables", {}).items():
+        set_var(var_name, var_value)
+    _test_params.update(_config_data.get("test_params", {}))
+    _global_variables.clear()
+    _global_variables.extend(_config_data.get("global_variables", []))
+
+
+def get(key, default=None):
+    """Read a config value."""
+    return _config_data.get(key, default)
+
+
+def was_set(key) -> bool:
+    """Return True if key was explicitly passed to configure()."""
+    return key in _configured_keys
+
+
+def _reset():
+    """Reset all config and variable stores (for testing)."""
+    for key in _config_data:
+        if isinstance(_config_data[key], dict):
+            _config_data[key] = {}
+        elif isinstance(_config_data[key], list):
+            _config_data[key] = []
+        elif isinstance(_config_data[key], bool):
+            _config_data[key] = False
+        else:
+            _config_data[key] = ""
+    _configured_keys.clear()
+    # Also reset variable stores populated by configure()
+    from testmu._vars import _reset_store
+    _reset_store()

testmu_playwright_python-0.1.0/testmu/_decorator.py

@@ -0,0 +1,53 @@
+"""@testmu.test decorator.
+
+Wraps test functions for lifecycle reporting:
+- begin_test / pass_test / fail_test
+- screenshot on failure (best-effort)
+
+Does NOT own browser launch (that's testmu.run).
+Does NOT override PW methods (that's the heal patch).
+"""
+import asyncio
+import functools
+
+from testmu._reporter import reporter
+
+
+def _find_page(args, kwargs):
+    """Extract the page argument from args/kwargs."""
+    if "page" in kwargs:
+        return kwargs["page"]
+    for arg in args:
+        if hasattr(arg, "screenshot") and hasattr(arg, "locator"):
+            return arg
+    return None
+
+
+def test(fn):
+    if asyncio.iscoroutinefunction(fn):
+        @functools.wraps(fn)
+        async def async_wrapper(*args, **kwargs):
+            rep = reporter()
+            await rep.begin_test(fn.__name__)
+            try:
+                result = await fn(*args, **kwargs)
+                await rep.pass_test()
+                return result
+            except Exception as e:
+                page = _find_page(args, kwargs)
+                if page is not None:
+                    try:
+                        screenshot = await page.screenshot()
+                        await rep.attach_screenshot(screenshot)
+                    except Exception:
+                        pass
+                await rep.fail_test(e)
+                raise
+        return async_wrapper
+    else:
+        @functools.wraps(fn)
+        def sync_wrapper(*args, **kwargs):
+            raise NotImplementedError(
+                "Sync test functions are not yet supported. Use 'async def'."
+            )
+        return sync_wrapper