testmu-playwright-python 0.1.0__tar.gz → 0.1.2__tar.gz

{testmu_playwright_python-0.1.0/testmu_playwright_python.egg-info → testmu_playwright_python-0.1.2}/PKG-INFO

@@ -1,25 +1,21 @@
 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
+Version: 0.1.2
+Summary: Testmu binding for Playwright Python — thin test runtime for LambdaTest exports
+Author-email: LambdaTest <engineering@lambdatest.com>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://github.com/shravan-lambdatest/testmu-bindings
+Project-URL: Repository, https://github.com/shravan-lambdatest/testmu-bindings
 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
+Classifier: Framework :: Pytest
+Classifier: Topic :: Software Development :: Testing
 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
@@ -28,16 +24,18 @@ 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.
+Testmu binding for Playwright Python — a thin test runtime for running LambdaTest exported tests locally or on the LambdaTest grid.
 
 ## Installation
 
 ```bash
-pip install testmu-playwright-python
+# From TestPyPI (pre-release)
+pip install --index-url https://test.pypi.org/simple/ \
+  --extra-index-url https://pypi.org/simple/ \
+  testmu-playwright-python
 ```
 
 ## Quick Start
@@ -75,11 +73,6 @@ testmu.run(my_test)
 - 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)
+Proprietary - LambdaTest

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/README.md

@@ -1,11 +1,14 @@
 # testmu-playwright-python
 
-TestMu binding for Playwright Python — a thin test runtime for running TestMu exported tests locally or on the LambdaTest grid.
+Testmu binding for Playwright Python — a thin test runtime for running LambdaTest exported tests locally or on the LambdaTest grid.
 
 ## Installation
 
 ```bash
-pip install testmu-playwright-python
+# From TestPyPI (pre-release)
+pip install --index-url https://test.pypi.org/simple/ \
+  --extra-index-url https://pypi.org/simple/ \
+  testmu-playwright-python
 ```
 
 ## Quick Start
@@ -43,11 +46,6 @@ testmu.run(my_test)
 - 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)
+Proprietary - LambdaTest

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/pyproject.toml

@@ -1,29 +1,24 @@
 [build-system]
-requires = ["setuptools>=68.0", "wheel"]
+requires = ["setuptools>=68.0"]
 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"
+version = "0.1.2"
+description = "Testmu binding for Playwright Python — thin test runtime for LambdaTest exports"
 requires-python = ">=3.11"
-license = "MIT"
-license-files = ["LICENSE"]
-authors = [
-    {name = "TestMu AI", email = "engineering@testmu.ai"},
-]
-keywords = ["testing", "ai", "agents", "playwright", "lambdatest", "testmu"]
+license = "LicenseRef-Proprietary"
+authors = [{name = "LambdaTest", email = "engineering@lambdatest.com"}]
+readme = "README.md"
 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",
+    "Framework :: Pytest",
+    "Topic :: Software Development :: Testing",
 ]
 dependencies = [
     "playwright>=1.57.0",
@@ -40,12 +35,8 @@ dev = [
 ]
 
 [project.urls]
-Homepage = "https://testmu.ai"
-Documentation = "https://docs.testmu.ai"
-Repository = "https://github.com/testmuai/testmu-bindings"
-
-[tool.setuptools.packages.find]
-include = ["testmu*"]
+Homepage = "https://github.com/shravan-lambdatest/testmu-bindings"
+Repository = "https://github.com/shravan-lambdatest/testmu-bindings"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

testmu_playwright_python-0.1.2/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"

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_heal_patch.py

@@ -5,6 +5,16 @@ Installs wrappers on Locator action methods that catch TimeoutError
 
 The patch only fires inside a testmu.step() block (ContextVar check).
 Outside a step, the wrapper is a pure passthrough.
+
+heal_fn contract:
+    async def heal_fn(page, description, method_name, *args, **kwargs) -> bool
+
+    Returns True if heal handled the action (wrapper returns normally).
+    Returns False if heal couldn't help (wrapper re-raises original error).
+
+    Today's default heal does a coordinate lookup via vision API and clicks
+    at the returned coordinates for click/hover methods. Other methods are
+    not supported until locator re-resolution lands.
 """
 import functools
 from testmu._step import _current_step
@@ -41,9 +51,9 @@ def _make_wrapper(name, original, heal_fn):
         except TimeoutError:
             if await self.count() > 0:
                 raise  # element exists but not actionable — heal won't help
-            healed = await heal_fn(self.page, step.description)
-            if healed is None:
+            handled = await heal_fn(self.page, step.description, name, *args, **kwargs)
+            if not handled:
                 raise
-            return await original(healed, *args, **kwargs)
+            # heal performed the action (e.g. via page.mouse) — nothing to return
 
     return wrapper

testmu_playwright_python-0.1.2/testmu/_helpers/_http.py

@@ -0,0 +1,20 @@
+"""Shared HTTP session factory for AI API calls.
+
+All smart helpers (vision, assertion, wait, network) call LT-hosted
+endpoints that require Basic auth via LT_USERNAME + LT_ACCESS_KEY.
+"""
+import base64
+import os
+
+import aiohttp
+
+
+def create_session(**kwargs) -> aiohttp.ClientSession:
+    """Create an aiohttp session with LT Basic auth headers."""
+    headers = kwargs.pop("headers", {})
+    username = os.getenv("LT_USERNAME", "")
+    access_key = os.getenv("LT_ACCESS_KEY", "")
+    if username and access_key:
+        auth = base64.b64encode(f"{username}:{access_key}".encode()).decode()
+        headers["Authorization"] = f"Basic {auth}"
+    return aiohttp.ClientSession(headers=headers, **kwargs)

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/assertion.py

@@ -15,9 +15,14 @@ there are no store_keys (skips the visual fallback).
 """
 import base64
 import logging
+import os
 
 import aiohttp
 
+from testmu._helpers._http import create_session
+
+_AI_API_HOST = os.getenv("TESTMU_AI_API_HOST", "http://localhost:8000")
+
 from testmu import _config
 from testmu._vars import _variable_store, var
 
@@ -68,9 +73,9 @@ async def _call_evaluate_api(claim, composite_op, eval_sub_checks):
         "composite_operator": composite_op,
         "sub_checks": eval_sub_checks,
     }
-    async with aiohttp.ClientSession() as session:
+    async with create_session() as session:
         async with session.post(
-            "http://localhost:8000/api/v1/evaluate",
+            f"{_AI_API_HOST}/api/v1/evaluate",
             json=request_body,
             timeout=aiohttp.ClientTimeout(total=60),
         ) as response:
@@ -111,9 +116,9 @@ async def _verify_visual(page, claim, composite_op, sub_checks, assertion_tree):
         request_body["verification"] = verification
 
     _log.debug("[AssertionAPI] Sending to assertions/verify API...")
-    async with aiohttp.ClientSession() as session:
+    async with create_session() as session:
         async with session.post(
-            "http://localhost:8000/api/v1/assertions/verify",
+            f"{_AI_API_HOST}/api/v1/assertions/verify",
             json=request_body,
             timeout=aiohttp.ClientTimeout(total=60),
         ) as response:

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/execute_api.py

@@ -3,9 +3,9 @@
 Variable resolution: {{var}} templates in URL, headers, body, and params are
 resolved via testmu._vars.var() before the request is made.
 
-Proxy routing: when running on HyperExecute (platform is ON), routes all
-requests through the local proxy at 127.0.0.1:22000. When local, makes
-direct requests.
+Proxy routing: when running on HyperExecute (run_target == "cloud"),
+routes all requests through the local proxy at 127.0.0.1:22000. On local
+run target, makes direct requests.
 
 Raises RuntimeError on request failure (network error or bad/unsupported input).
 Returns the response dict directly on success.
@@ -166,8 +166,8 @@ def _do_request(method, url, headers, body, params, authorization, timeout, veri
                 _log.debug(f"AWS Signature auth failed: {e}")
 
     # -- Proxy ---------------------------------------------------------------
-    # Route through HyperExecute local proxy when on the platform.
-    proxy = "http://127.0.0.1:22000" if _config.platform else None
+    # Route through HyperExecute local proxy only when running on cloud target.
+    proxy = "http://127.0.0.1:22000" if _config.run_target == "cloud" else None
 
     # -- Build request kwargs ------------------------------------------------
     _method = method.upper()
@@ -281,8 +281,8 @@ async def execute_api(
 ):
     """Execute an HTTP API request.
 
-    Routes through the HyperExecute proxy (127.0.0.1:22000) when running on
-    the LT platform; makes direct requests otherwise.
+    Routes through the HyperExecute proxy (127.0.0.1:22000) when
+    run_target == "cloud"; makes direct requests on local runs.
 
     Variable templates ({{var}}) in url, headers, body, and params are resolved
     via testmu._vars.var() before the request is made.

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/execute_db.py

@@ -1,7 +1,8 @@
 """execute_db helper — runs a SQL query via the automind /db-query endpoint.
 
-Platform-gated: requires LT_USERNAME + LT_ACCESS_KEY to be set. When the
-platform is OFF, raises RuntimeError immediately.
+Auth-gated: requires LT_USERNAME + LT_ACCESS_KEY to be set (automind is an
+LT-hosted service). Works in both local and cloud run targets as long as
+creds are present. Raises RuntimeError when creds are missing.
 
 Env vars consumed (when not passed explicitly):
     LT_USERNAME         — LambdaTest username (used to build auth header)
@@ -10,7 +11,7 @@ Env vars consumed (when not passed explicitly):
     LT_PROXY_TUNNEL_ID  — Tunnel ID for network connectivity
 
 Raises:
-    RuntimeError: When platform is off, on non-200 response, or on network failure.
+    RuntimeError: When LT creds are missing, on non-200 response, or on network failure.
 
 Returns:
     Query result dict on success.
@@ -71,7 +72,7 @@ async def execute_db(
 ):
     """Execute a database query via the automind /db-query endpoint.
 
-    Platform-gated: raises RuntimeError when LT credentials are not configured.
+    Auth-gated: raises RuntimeError when LT_USERNAME/LT_ACCESS_KEY are not set.
 
     Args:
         query: Base64-encoded SQL query string.
@@ -86,13 +87,13 @@ async def execute_db(
         Query result dict on success.
 
     Raises:
-        RuntimeError: When platform credentials are missing, on non-200 response,
+        RuntimeError: When LT creds are missing, on non-200 response,
             or on network/query failure.
     """
     from testmu import _config
 
-    if not _config.platform:
-        raise RuntimeError("DB query requires LT platform credentials")
+    if not _config.lt_auth:
+        raise RuntimeError("DB query requires LT_USERNAME and LT_ACCESS_KEY")
 
     # Fall back to environment variables
     if not automind_url:

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/kane_cli.py

@@ -1,14 +1,12 @@
 """Kane CLI helper — execute_kane_cli.
 
-Smart AND platform gated: requires LT credentials for kane-cli auth and
-TESTMU_SMART=1 for the feature to be active.
-
-When smart is OFF: logs "branch unresolved", returns None.
+Gated: smart AND run_target == "cloud". kane-cli needs the HyperExecute
+relay proxy to connect back to the running test, which is only available
+in cloud runs. On local or smart-off runs, logs a warning and returns None.
 
 Note: relay proxy disconnect/reconnect is NOT ported here — that's a
 deferred gap. The subprocess runs kane-cli directly; if relay proxy is
-absent the test may fail when kane-cli tries to connect, which is expected
-until relay proxy support is ported.
+absent the test may fail when kane-cli tries to connect.
 """
 import asyncio
 import logging
@@ -22,8 +20,8 @@ _log = logging.getLogger("testmu")
 async def execute_kane_cli(objective: str):
     """Execute a test objective via kane-cli subprocess.
 
-    Smart AND platform gated: when _config.smart is OFF, logs a warning
-    and returns None without running kane-cli.
+    Gated: smart ON AND run_target == "cloud". Logs a warning and returns
+    None without running kane-cli otherwise (branch unresolved).
 
     Uses env vars:
         LT_USERNAME    — LambdaTest username (required by kane-cli auth)
@@ -42,6 +40,12 @@ async def execute_kane_cli(objective: str):
             "[execute_kane_cli] smart is OFF — branch unresolved, skipping kane-cli"
         )
         return None
+    if _config.run_target != "cloud":
+        _log.warning(
+            "[execute_kane_cli] run_target is not 'cloud' — kane-cli needs the "
+            "HyperExecute relay proxy, skipping (branch unresolved)"
+        )
+        return None
 
     username = os.getenv("LT_USERNAME", "")
     access_key = os.getenv("LT_ACCESS_KEY", "")

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/network.py

@@ -104,13 +104,14 @@ def evaluate_network_assertion(assertion_tree: dict) -> bool:
 
 
 # ---------------------------------------------------------------------------
-# network_query — smart-gated, polls HAR server at localhost:8181
+# network_query — cloud-only, polls HAR server at localhost:8181
 # ---------------------------------------------------------------------------
 
 async def network_query(method, url, index, network_log_id="", polling_interval=2, max_polling_time=10):
     """Poll the HAR server for a matching network entry.
 
-    Smart-gated: returns None immediately when _config.smart is OFF.
+    Cloud-only: the HAR server at localhost:8181 is a HyperExecute sidecar.
+    Returns None when run_target is not "cloud".
 
     Args:
         method: HTTP method to match (e.g. "GET", "POST").
@@ -121,16 +122,17 @@ async def network_query(method, url, index, network_log_id="", polling_interval=
         max_polling_time: Total seconds before giving up.
 
     Returns:
-        Decoded HAR entry dict, or None when smart is OFF / no match found.
+        Decoded HAR entry dict, or None when not on cloud / no match found.
     """
     from testmu import _config
 
-    if not _config.smart:
-        _log.info("[network_query] smart is OFF — skipping HAR lookup")
+    if _config.run_target != "cloud":
+        _log.info("[network_query] run_target is not 'cloud' — HAR server unavailable, skipping")
         return None
 
     import asyncio
     import aiohttp
+    from testmu._helpers._http import create_session
 
     _har_base = "http://127.0.0.1:8181"
 
@@ -141,7 +143,7 @@ async def network_query(method, url, index, network_log_id="", polling_interval=
 
     if network_log_id:
         try:
-            async with aiohttp.ClientSession() as session:
+            async with create_session() as session:
                 async with session.get(
                     f"{_har_base}/logs/entry?id={network_log_id}",
                     timeout=aiohttp.ClientTimeout(total=30),
@@ -162,7 +164,7 @@ async def network_query(method, url, index, network_log_id="", polling_interval=
         num_tries += 1
         _log.info(f"[network_query] polling attempt {num_tries}/{max_tries}")
         try:
-            async with aiohttp.ClientSession() as session:
+            async with create_session() as session:
                 async with session.get(
                     f"{_har_base}/logs",
                     timeout=aiohttp.ClientTimeout(total=30),
@@ -187,7 +189,7 @@ async def network_query(method, url, index, network_log_id="", polling_interval=
                             f" entry_id={entry_id!r}"
                         )
                         if entry_id:
-                            async with aiohttp.ClientSession() as s2:
+                            async with create_session() as s2:
                                 async with s2.get(
                                     f"{_har_base}/logs/entry?id={entry_id}",
                                     timeout=aiohttp.ClientTimeout(total=30),

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/smartui.py

@@ -1,9 +1,10 @@
 """SmartUI visual comparison screenshot.
 
 Captures a screenshot and sends it to LambdaTest's SmartUI via the
-lambdatest_action CDP protocol.
+lambdatest_action CDP protocol — cloud only (CDP channel is intercepted
+server-side by LT infrastructure).
 
-Smart-gated: no-op when TESTMU_SMART is OFF.
+Gated: smart ON AND run_target == "cloud". Warns and no-ops otherwise.
 """
 import json
 import logging
@@ -22,6 +23,12 @@ async def smartui_snapshot(page, name):
     """
     if not _config.smart:
         return None
+    if _config.run_target != "cloud":
+        _log.warning(
+            f"SmartUI snapshot '{name}' skipped — requires cloud run target "
+            f"(TESTMU_RUN_TARGET=cloud)"
+        )
+        return None
 
     try:
         payload = json.dumps({

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/vision.py

@@ -5,7 +5,7 @@ safe fallbacks immediately without touching any network endpoint.
 
 When smart is ON, they call the analyzer sidecar via aiohttp.
 
-Analyzer base URL is read from VISION_API_HOST env var
+Analyzer base URL is read from TESTMU_AI_API_HOST env var
 (default: http://localhost:8000).
 """
 import asyncio
@@ -17,10 +17,12 @@ import os
 import aiohttp
 
 from testmu import _config
+from testmu._helpers._http import create_session
 
 _log = logging.getLogger("testmu")
 
-_VISION_API_HOST = os.getenv("VISION_API_HOST", "http://localhost:8000")
+# TODO: replace default with public LT vision/analyzer endpoint once available.
+_VISION_API_HOST = os.getenv("TESTMU_AI_API_HOST", "http://localhost:8000")
 _ANALYZER_URL = f"{_VISION_API_HOST}/api/v1/analyzer"
 _ANALYZER_TIMEOUT = aiohttp.ClientTimeout(total=120)
 _QUERY_TIMEOUT = aiohttp.ClientTimeout(total=60)
@@ -204,7 +206,7 @@ async def _check_visibility(session: aiohttp.ClientSession, screenshot_b64: str,
 async def _wait_for_visibility(page, query: str) -> str:
     """Poll visibility API until element is visible; return the last screenshot_b64."""
     last_reasoning = None
-    async with aiohttp.ClientSession() as session:
+    async with create_session() as session:
         for attempt in range(1, _COORD_MAX_RETRIES + 1):
             screenshot_bytes = await page.screenshot()
             screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
@@ -254,7 +256,7 @@ async def vision_query(page, description: str, return_type: str):
     screenshot_bytes = await page.screenshot()
     screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
 
-    async with aiohttp.ClientSession() as session:
+    async with create_session() as session:
         result = await _post_analyzer(session, {
             "type": "visual",
             "query": description,
@@ -297,7 +299,7 @@ async def textual_query(page, description: str, return_type: str):
         screenshot_bytes = await page.screenshot()
         screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
 
-        async with aiohttp.ClientSession() as session:
+        async with create_session() as session:
             identify_resp = await _post_analyzer(session, {
                 "type": "dom",
                 "query": description,
@@ -348,7 +350,7 @@ async def vision_wait(page, description: str, timeout_ms: int = 30000):
 
     _log.debug(f"[vision_wait] Waiting for: '{description}' (timeout_ms={timeout_ms})")
 
-    async with aiohttp.ClientSession() as session:
+    async with create_session() as session:
         for attempt in range(1, _WAIT_MAX_RETRIES + 1):
             screenshot_bytes = await page.screenshot()
             screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
@@ -397,7 +399,7 @@ async def vision_action(page, description: str, action_type: str, direction: str
     width = viewport["width"] if viewport else 1280
     height = viewport["height"] if viewport else 713
 
-    async with aiohttp.ClientSession() as session:
+    async with create_session() as session:
         async with session.post(
             f"{_VISION_API_HOST}/api/v1/vision/coordinates",
             json={
@@ -464,7 +466,7 @@ async def get_vision_coordinates(page, description: str, action_type: str = "cli
         width = viewport["width"] if viewport else 1920
         height = viewport["height"] if viewport else 1080
 
-        async with aiohttp.ClientSession() as session:
+        async with create_session() as session:
             async with session.post(
                 f"{_VISION_API_HOST}/api/v1/vision/coordinates",
                 json={

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_helpers/wait.py

@@ -8,11 +8,13 @@ import logging
 
 import aiohttp
 
+from testmu._helpers._http import create_session
+
 from testmu import _config
 
 _log = logging.getLogger("testmu")
 
-_VISION_API_HOST_DEFAULT = "http://localhost:8000"
+_AI_API_HOST_DEFAULT = "http://localhost:8000"
 
 
 async def check_until_condition(page, condition: str) -> bool:
@@ -37,14 +39,14 @@ async def check_until_condition(page, condition: str) -> bool:
         _log.info("[check_until_condition] smart is OFF — returning False (condition skipped)")
         return False
 
-    vision_api_host = os.getenv("VISION_API_HOST", _VISION_API_HOST_DEFAULT)
+    vision_api_host = os.getenv("TESTMU_AI_API_HOST", _AI_API_HOST_DEFAULT)
 
     _log.info(f"[check_until_condition] checking condition: {condition!r}")
 
     screenshot_bytes = await page.screenshot()
     screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
 
-    async with aiohttp.ClientSession() as session:
+    async with create_session() as session:
         async with session.post(
             f"{vision_api_host}/api/v1/wait/check",
             json={"screenshot_b64": screenshot_b64, "query": condition},

{testmu_playwright_python-0.1.0 → testmu_playwright_python-0.1.2}/testmu/_reporter/__init__.py

@@ -1,9 +1,12 @@
 """Reporter protocol and factory.
 
-Three implementations:
-- NullReporter: no-op (default when platform is off)
-- LocalReporter: print to stdout
-- LTReporter: lambdatest_action evaluate for dashboard
+Two implementations:
+- LocalReporter: logs to stdout (used for local runs)
+- LTReporter:    lambdatest_action CDP evaluate for dashboard (cloud only)
+
+Picking rule: LTReporter only when run_target == "cloud". The LT reporter
+talks via the lambdatest_action CDP channel which is cloud-only, so a local
+browser always uses LocalReporter even when LT creds are present.
 """
 from typing import Optional, Protocol
 
@@ -20,8 +23,8 @@ class Reporter(Protocol):
 
 
 def get_reporter() -> Reporter:
-    """Factory: pick reporter based on config."""
-    if _config.platform:
+    """Factory: pick reporter based on run target."""
+    if _config.run_target == "cloud":
         from testmu._reporter.lt import LTReporter
         return LTReporter()
     from testmu._reporter.local import LocalReporter

testmu_playwright_python-0.1.2/testmu/_reporter/local.py

@@ -0,0 +1,33 @@
+"""Local stdout reporter."""
+import logging
+
+_log = logging.getLogger("testmu")
+
+
+class LocalReporter:
+    def __init__(self):
+        self._step_num = 0
+
+    async def begin_test(self, name):
+        self._step_num = 0
+        _log.info("[TEST START] %s", name)
+
+    async def pass_test(self):
+        _log.info("[TEST PASS] (%d steps)", self._step_num)
+
+    async def fail_test(self, error):
+        _log.error("[TEST FAIL] at step %d — %s", self._step_num, error)
+
+    async def begin_step(self, description):
+        self._step_num += 1
+        _log.info("  [STEP %d] %s", self._step_num, description)
+
+    async def end_step(self, description, ok, error=None):
+        if ok:
+            _log.info("  [STEP %d OK] %s", self._step_num, description)
+        else:
+            status = f"FAIL: {error}"
+            _log.info("  [STEP %d %s] %s", self._step_num, status, description)
+
+    async def attach_screenshot(self, data):
+        _log.info("  [SCREENSHOT] %d bytes", len(data))