testmuai-playwright-bindings 0.1.0__tar.gz

testmuai_playwright_bindings-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 TestMu AI
+
+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.

testmuai_playwright_bindings-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

testmuai_playwright_bindings-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: testmuai-playwright-bindings
+Version: 0.1.0
+Summary: TestMu binding for Playwright Python — thin test runtime for TestMu-exported tests on the LambdaTest grid
+Author-email: TestMu AI <engineering@testmu.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/samyakLambda/testmu-bindings
+Project-URL: Repository, https://github.com/samyakLambda/testmu-bindings
+Project-URL: Issues, https://github.com/samyakLambda/testmu-bindings/issues
+Keywords: testing,playwright,lambdatest,testmu,automation,e2e
+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
+
+# testmuai-playwright-bindings
+
+[![PyPI version](https://img.shields.io/pypi/v/testmuai-playwright-bindings.svg)](https://pypi.org/project/testmuai-playwright-bindings/)
+[![Python versions](https://img.shields.io/pypi/pyversions/testmuai-playwright-bindings.svg)](https://pypi.org/project/testmuai-playwright-bindings/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+TestMu binding for Playwright Python — a thin test runtime for running TestMu-exported tests locally or on the LambdaTest grid.
+
+## Installation
+
+```bash
+pip install testmuai-playwright-bindings
+```
+
+Then install the Playwright browsers (one-time):
+
+```bash
+playwright install
+```
+
+## Quick Start
+
+Set credentials (LambdaTest grid) once in your environment:
+
+```bash
+export LT_USERNAME="your_username"
+export LT_ACCESS_KEY="your_access_key"
+```
+
+Then write a test:
+
+```python
+import testmu
+
+@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"):
+        await testmu.expect(page).to_have_title("Example Domain")
+
+testmu.run(my_test)
+```
+
+`testmu.run()` is a synchronous entry point — it sets up the session,
+launches the browser, runs your test, and tears everything down.
+
+## Configuration
+
+Configuration is sourced from environment variables. See [`.env.example`](.env.example) for the full list. The most common ones:
+
+| Variable          | Purpose                               | Required           |
+| ----------------- | ------------------------------------- | ------------------ |
+| `LT_USERNAME`     | LambdaTest grid username              | For cloud features |
+| `LT_ACCESS_KEY`   | LambdaTest grid access key            | For cloud features |
+| `TESTMU_HEADLESS` | `true` (default) or `false`           | No                 |
+| `TESTMU_SMART`    | `1` to enable vision/heal AI features | No                 |
+
+Test-level metadata (build, name, variables, etc.) can be passed via
+`testmu.configure(...)` at the top of generated test files.
+
+## Features
+
+- **`@testmu.test`** — decorator that wraps async Playwright tests with session lifecycle management
+- **`testmu.step(...)`** — context manager for structured test steps
+- **`testmu.var()` / `testmu.set_var()`** — template-based variable resolution (with ATMS lookup when authed)
+- **Helpers** — `execute_js`, `execute_api`, `execute_db`, `vision_query`, `network_query`, `smartui_snapshot`, and more
+- **Reporters** — local console reporter and TestMu cloud reporter (LambdaTest dashboard)
+- **Self-healing locators** — automatic locator recovery via heal patch (when smart mode enabled)
+
+## Requirements
+
+- Python ≥ 3.11
+- Playwright ≥ 1.57.0
+
+## Links
+
+- **PyPI**: https://pypi.org/project/testmuai-playwright-bindings/
+- **TestMu**: https://testmu.ai
+- **LambdaTest grid**: https://www.lambdatest.com
+- **Issues**: https://github.com/samyakLambda/testmu-bindings/issues
+
+## License
+
+Released under the [MIT License](LICENSE).

testmuai_playwright_bindings-0.1.0/README.md

@@ -0,0 +1,86 @@
+# testmuai-playwright-bindings
+
+[![PyPI version](https://img.shields.io/pypi/v/testmuai-playwright-bindings.svg)](https://pypi.org/project/testmuai-playwright-bindings/)
+[![Python versions](https://img.shields.io/pypi/pyversions/testmuai-playwright-bindings.svg)](https://pypi.org/project/testmuai-playwright-bindings/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+TestMu binding for Playwright Python — a thin test runtime for running TestMu-exported tests locally or on the LambdaTest grid.
+
+## Installation
+
+```bash
+pip install testmuai-playwright-bindings
+```
+
+Then install the Playwright browsers (one-time):
+
+```bash
+playwright install
+```
+
+## Quick Start
+
+Set credentials (LambdaTest grid) once in your environment:
+
+```bash
+export LT_USERNAME="your_username"
+export LT_ACCESS_KEY="your_access_key"
+```
+
+Then write a test:
+
+```python
+import testmu
+
+@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"):
+        await testmu.expect(page).to_have_title("Example Domain")
+
+testmu.run(my_test)
+```
+
+`testmu.run()` is a synchronous entry point — it sets up the session,
+launches the browser, runs your test, and tears everything down.
+
+## Configuration
+
+Configuration is sourced from environment variables. See [`.env.example`](.env.example) for the full list. The most common ones:
+
+| Variable          | Purpose                               | Required           |
+| ----------------- | ------------------------------------- | ------------------ |
+| `LT_USERNAME`     | LambdaTest grid username              | For cloud features |
+| `LT_ACCESS_KEY`   | LambdaTest grid access key            | For cloud features |
+| `TESTMU_HEADLESS` | `true` (default) or `false`           | No                 |
+| `TESTMU_SMART`    | `1` to enable vision/heal AI features | No                 |
+
+Test-level metadata (build, name, variables, etc.) can be passed via
+`testmu.configure(...)` at the top of generated test files.
+
+## Features
+
+- **`@testmu.test`** — decorator that wraps async Playwright tests with session lifecycle management
+- **`testmu.step(...)`** — context manager for structured test steps
+- **`testmu.var()` / `testmu.set_var()`** — template-based variable resolution (with ATMS lookup when authed)
+- **Helpers** — `execute_js`, `execute_api`, `execute_db`, `vision_query`, `network_query`, `smartui_snapshot`, and more
+- **Reporters** — local console reporter and TestMu cloud reporter (LambdaTest dashboard)
+- **Self-healing locators** — automatic locator recovery via heal patch (when smart mode enabled)
+
+## Requirements
+
+- Python ≥ 3.11
+- Playwright ≥ 1.57.0
+
+## Links
+
+- **PyPI**: https://pypi.org/project/testmuai-playwright-bindings/
+- **TestMu**: https://testmu.ai
+- **LambdaTest grid**: https://www.lambdatest.com
+- **Issues**: https://github.com/samyakLambda/testmu-bindings/issues
+
+## License
+
+Released under the [MIT License](LICENSE).

testmuai_playwright_bindings-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "testmuai-playwright-bindings"
+version = "0.1.0"
+description = "TestMu binding for Playwright Python — thin test runtime for TestMu-exported tests on the LambdaTest grid"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    {name = "TestMu AI", email = "engineering@testmu.ai"},
+]
+keywords = ["testing", "playwright", "lambdatest", "testmu", "automation", "e2e"]
+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://github.com/samyakLambda/testmu-bindings"
+Repository = "https://github.com/samyakLambda/testmu-bindings"
+Issues = "https://github.com/samyakLambda/testmu-bindings/issues"
+
+[tool.setuptools.packages.find]
+include = ["testmu*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

testmuai_playwright_bindings-0.1.0/setup.cfg

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

testmuai_playwright_bindings-0.1.0/testmu/__init__.py

@@ -0,0 +1,81 @@
+"""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 importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("testmu-playwright-python")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+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__ = [
+    "__version__",
+    "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",
+]

testmuai_playwright_bindings-0.1.0/testmu/_capability.py

@@ -0,0 +1,263 @@
+"""TestMu capability builder for Playwright Python (LambdaTest grid).
+
+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}

testmuai_playwright_bindings-0.1.0/testmu/_config.py

@@ -0,0 +1,13 @@
+"""Run target, auth, and smart detection.
+
+Three orthogonal flags:
+- run_target: "local" (default) or "cloud". Only "cloud" connects to LT CDP.
+- lt_auth:    LT creds available. Enables ATMS/automind/downloads/API proxy
+              regardless of run target.
+- smart:      AI/heal features. Requires lt_auth; validated at testmu.run().
+"""
+import os
+
+run_target = os.getenv("TESTMU_RUN_TARGET", "local").lower()
+lt_auth = bool(os.getenv("LT_USERNAME")) and bool(os.getenv("LT_ACCESS_KEY"))
+smart = os.getenv("TESTMU_SMART", "0") == "1"