wavexis 2.3.3__tar.gz → 2.3.4__tar.gz

{wavexis-2.3.3 → wavexis-2.3.4}/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to wavexis are documented in this file.
 
+## v2.3.4 — 2026-07-07
+
+### Added
+
+- Generate locator: `suggest_locator` method in both CDP and BiDi backends
+- `wavexis dom <url> --action suggest_locator -s <selector>` CLI command
+- `--all` flag to return all suggestions ranked by specificity
+- Priority order: `#id` > `[data-testid]` > `[aria-label]` > `[role]` > `:has-text()` > `tag.classes` > `parent > tag` > `:nth-of-type()` > `tag`
+- Uses `CSS.escape()` for safe selector generation
+
 ## v2.3.3 — 2026-07-07
 
 ### Added

{wavexis-2.3.3 → wavexis-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavexis
-Version: 2.3.3
+Version: 2.3.4
 Summary: Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download
 Project-URL: Homepage, https://github.com/MathiasPaulenko/wavexis
 Project-URL: Repository, https://github.com/MathiasPaulenko/wavexis

{wavexis-2.3.3 → wavexis-2.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wavexis"
-version = "2.3.3"
+version = "2.3.4"
 description = "Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download"
 readme = "README.md"
 license = { text = "MIT" }

{wavexis-2.3.3 → wavexis-2.3.4}/tests/unit/test_backend_manager.py

@@ -132,6 +132,12 @@ class DummyBackend(AbstractBackend):
         """Dom scroll."""
         pass
 
+    async def suggest_locator(
+        self, selector: str, all: bool = False
+    ) -> list[str] | str:
+        """Suggest locator."""
+        return selector
+
     async def capture_har(self, params: object) -> dict:
         """Capture har."""
         return {}

{wavexis-2.3.3 → wavexis-2.3.4}/tests/unit/test_manager.py

@@ -66,6 +66,9 @@ class FakeBackend(AbstractBackend):
         """Dom focus."""
     async def dom_scroll(self, selector=None, x=0, y=0):
         """Dom scroll."""
+    async def suggest_locator(self, selector, all=False):
+        """Suggest locator."""
+        return selector
     async def capture_har(self, params):
         """Capture har."""
     async def get_cookies(self):

wavexis-2.3.4/tests/unit/test_suggest_locator.py

@@ -0,0 +1,110 @@
+"""Unit tests for suggest_locator in both backends."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from wavexis.exceptions import ElementNotFoundError
+
+
+def _make_cdp_backend() -> Any:
+    """Create a CDPBackend with mocked session."""
+    from wavexis.backend.cdp import CDPBackend
+
+    backend = CDPBackend()
+    backend._session = MagicMock()
+    backend._session.runtime = MagicMock()
+    backend._session.runtime.evaluate = AsyncMock(
+        return_value={"result": {"value": None}}
+    )
+    return backend
+
+
+def _make_bidi_backend() -> Any:
+    """Create a BiDiBackend with mocked client."""
+    from wavexis.backend.bidi import BiDiBackend
+
+    backend = BiDiBackend()
+    backend._client = MagicMock()
+    backend._context = MagicMock()
+    backend._client.script = MagicMock()
+    result = MagicMock()
+    result.value = None
+    backend._client.script.evaluate = AsyncMock(return_value=result)
+    return backend
+
+
+@pytest.mark.unit
+class TestSuggestLocatorCDP:
+    """Tests for suggest_locator in CDP backend."""
+
+    def test_returns_best_selector(self) -> None:
+        """Test that suggest_locator returns the first (best) suggestion."""
+        backend = _make_cdp_backend()
+        suggestions = ["#login-btn", "button.primary", "button"]
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": json.dumps(suggestions)}}
+        )
+        result = asyncio.run(backend.suggest_locator("#login-btn"))
+        assert result == "#login-btn"
+
+    def test_returns_all_suggestions(self) -> None:
+        """Test that suggest_locator with all=True returns all suggestions."""
+        backend = _make_cdp_backend()
+        suggestions = ["#my-id", "[data-testid='btn']", "button.clickable", "button"]
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": json.dumps(suggestions)}}
+        )
+        result = asyncio.run(backend.suggest_locator("button", all=True))
+        assert isinstance(result, list)
+        assert len(result) == 4
+        assert result[0] == "#my-id"
+
+    def test_raises_on_element_not_found(self) -> None:
+        """Test that suggest_locator raises ElementNotFoundError when element missing."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": None}}
+        )
+        with pytest.raises(ElementNotFoundError):
+            asyncio.run(backend.suggest_locator("#missing"))
+
+
+@pytest.mark.unit
+class TestSuggestLocatorBiDi:
+    """Tests for suggest_locator in BiDi backend."""
+
+    def test_returns_best_selector(self) -> None:
+        """Test that suggest_locator returns the first (best) suggestion."""
+        backend = _make_bidi_backend()
+        suggestions = ["#submit", "button[type='submit']", "button"]
+        result_mock = MagicMock()
+        result_mock.value = json.dumps(suggestions)
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        result = asyncio.run(backend.suggest_locator("#submit"))
+        assert result == "#submit"
+
+    def test_returns_all_suggestions(self) -> None:
+        """Test that suggest_locator with all=True returns all suggestions."""
+        backend = _make_bidi_backend()
+        suggestions = ["#email", "[data-testid='email']", "input.email", "input"]
+        result_mock = MagicMock()
+        result_mock.value = json.dumps(suggestions)
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        result = asyncio.run(backend.suggest_locator("input", all=True))
+        assert isinstance(result, list)
+        assert len(result) == 4
+
+    def test_raises_on_element_not_found(self) -> None:
+        """Test that suggest_locator raises ElementNotFoundError when element missing."""
+        backend = _make_bidi_backend()
+        result_mock = MagicMock()
+        result_mock.value = None
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        with pytest.raises(ElementNotFoundError):
+            asyncio.run(backend.suggest_locator("#missing"))

{wavexis-2.3.3 → wavexis-2.3.4}/wavexis/__init__.py

@@ -1,3 +1,3 @@
 """wavexis — CLI de automatización de navegador."""
 
-__version__ = "2.3.3"
+__version__ = "2.3.4"

{wavexis-2.3.3 → wavexis-2.3.4}/wavexis/backend/base.py

@@ -149,6 +149,23 @@ class AbstractBackend(ABC):
     ) -> None:
         """Scroll to an element or by offset."""
 
+    @abstractmethod
+    async def suggest_locator(
+        self, selector: str, all: bool = False
+    ) -> list[str] | str:
+        """Suggest the best CSS selector for an element.
+
+        Analyzes the element and generates optimal selectors in priority order:
+        id > data-testid > aria-label > text > tag.classes > nth-of-type chain.
+
+        Args:
+            selector: CSS selector for the target element.
+            all: If True, return multiple suggestions; otherwise just the best one.
+
+        Returns:
+            List of selector strings when all=True, single best selector when all=False.
+        """
+
     # ── Network ────────────────────────────────────────────
 
     @abstractmethod

{wavexis-2.3.3 → wavexis-2.3.4}/wavexis/backend/bidi.py

@@ -537,6 +537,64 @@ class BiDiBackend(AbstractBackend):
             js = f"window.scrollTo({x},{y})"
         await self._client.script.evaluate(self._context, js)
 
+    async def suggest_locator(
+        self, selector: str, all: bool = False
+    ) -> list[str] | str:
+        """Suggest the best CSS selector for an element.
+
+        Args:
+            selector: CSS selector for the target element.
+            all: If True, return multiple suggestions; otherwise just the best one.
+
+        Returns:
+            List of selector strings when all=True, single best selector when all=False.
+        """
+        client = self._require_client()
+        escaped = selector.replace("'", "\\'")
+        js = self._suggest_locator_js(escaped)
+        result = await client.script.evaluate(self._context, js)
+        raw = getattr(result, "value", None)
+        if not raw:
+            raise ElementNotFoundError(selector)
+        suggestions: list[str] = json.loads(raw)
+        if all:
+            return suggestions
+        return suggestions[0] if suggestions else selector
+
+    @staticmethod
+    def _suggest_locator_js(escaped: str) -> str:
+        """Build JS that generates CSS selector suggestions for an element."""
+        return (
+            f"(function(){{"
+            f"var el=document.querySelector('{escaped}');"
+            f"if(!el)return null;"
+            f"var s=[];var t=el.tagName.toLowerCase();"
+            f"var id=el.id;"
+            f"var tid=el.getAttribute('data-testid')"
+            f"||el.getAttribute('data-test-id')"
+            f"||el.getAttribute('data-cy');"
+            f"var aria=el.getAttribute('aria-label');"
+            f"var role=el.getAttribute('role');"
+            f"var txt=(el.textContent||'').trim().substring(0,50);"
+            f"var cls=Array.from(el.classList);"
+            f"if(id)s.push('#'+CSS.escape(id));"
+            f"if(tid)s.push('[data-testid=\"'+tid+'\"]');"
+            f"if(aria)s.push(t+'[aria-label=\"'+aria+'\"]');"
+            f"if(role)s.push(t+'[role=\"'+role+'\"]');"
+            f"if(txt&&txt.length<30)s.push(t+':has-text(\"'+txt+'\"]');"
+            f"if(cls.length>0)s.push(t+'.'+cls.join('.'));"
+            f"var p=el.parentElement;"
+            f"if(p&&p.id)s.push('#'+CSS.escape(p.id)+' > '+t);"
+            f"var sib=p?Array.from(p.children)"
+            f".filter(function(c){{return c.tagName===el.tagName}}):[];"
+            f"if(sib.length>1){{"
+            f"var i=sib.indexOf(el)+1;"
+            f"s.push(t+':nth-of-type('+i+')');}}"
+            f"s.push(t);"
+            f"return JSON.stringify(s);"
+            f"}})()"
+        )
+
     async def capture_har(self, params: HarParams) -> dict[str, Any]:
         """Capture HAR data via CDP Network domain.
 

{wavexis-2.3.3 → wavexis-2.3.4}/wavexis/backend/cdp.py

@@ -644,6 +644,64 @@ class CDPBackend(AbstractBackend):
             js = f"window.scrollBy({x}, {y})"
         await session.runtime.evaluate(js)
 
+    async def suggest_locator(
+        self, selector: str, all: bool = False
+    ) -> list[str] | str:
+        """Suggest the best CSS selector for an element.
+
+        Args:
+            selector: CSS selector for the target element.
+            all: If True, return multiple suggestions; otherwise just the best one.
+
+        Returns:
+            List of selector strings when all=True, single best selector when all=False.
+        """
+        session = self._require_session()
+        escaped = selector.replace("'", "\\'")
+        js = self._suggest_locator_js(escaped)
+        result = await session.runtime.evaluate(js)
+        raw = result.get("result", {}).get("value")
+        if not raw:
+            raise ElementNotFoundError(selector)
+        suggestions: list[str] = json.loads(raw)
+        if all:
+            return suggestions
+        return suggestions[0] if suggestions else selector
+
+    @staticmethod
+    def _suggest_locator_js(escaped: str) -> str:
+        """Build JS that generates CSS selector suggestions for an element."""
+        return (
+            f"(function(){{"
+            f"var el=document.querySelector('{escaped}');"
+            f"if(!el)return null;"
+            f"var s=[];var t=el.tagName.toLowerCase();"
+            f"var id=el.id;"
+            f"var tid=el.getAttribute('data-testid')"
+            f"||el.getAttribute('data-test-id')"
+            f"||el.getAttribute('data-cy');"
+            f"var aria=el.getAttribute('aria-label');"
+            f"var role=el.getAttribute('role');"
+            f"var txt=(el.textContent||'').trim().substring(0,50);"
+            f"var cls=Array.from(el.classList);"
+            f"if(id)s.push('#'+CSS.escape(id));"
+            f"if(tid)s.push('[data-testid=\"'+tid+'\"]');"
+            f"if(aria)s.push(t+'[aria-label=\"'+aria+'\"]');"
+            f"if(role)s.push(t+'[role=\"'+role+'\"]');"
+            f"if(txt&&txt.length<30)s.push(t+':has-text(\"'+txt+'\"]');"
+            f"if(cls.length>0)s.push(t+'.'+cls.join('.'));"
+            f"var p=el.parentElement;"
+            f"if(p&&p.id)s.push('#'+CSS.escape(p.id)+' > '+t);"
+            f"var sib=p?Array.from(p.children)"
+            f".filter(function(c){{return c.tagName===el.tagName}}):[];"
+            f"if(sib.length>1){{"
+            f"var i=sib.indexOf(el)+1;"
+            f"s.push(t+':nth-of-type('+i+')');}}"
+            f"s.push(t);"
+            f"return JSON.stringify(s);"
+            f"}})()"
+        )
+
     # ── Network ────────────────────────────────────────────
 
     async def capture_har(self, params: HarParams) -> dict[str, Any]:

{wavexis-2.3.3 → wavexis-2.3.4}/wavexis/cli/_capture.py

@@ -274,14 +274,20 @@ def dom(
         "get",
         "--action",
         "-a",
-        help="DOM action: get, query, attr, remove_attr, remove, focus, scroll",
+        help=(
+            "DOM action: get, query, attr, remove_attr, remove, focus, scroll, "
+            "suggest_locator"
+        ),
     ),
     selector: str = typer.Option("", "--selector", "-s", help="CSS selector"),
     output: str | None = typer.Option(
         None, "--output", "-o", help="Output file path"
     ),
     outer: bool = typer.Option(True, "--outer/--inner", help="Outer or inner HTML"),
-    all: bool = typer.Option(False, "--all", help="Query all matching elements"),
+    all: bool = typer.Option(
+        False, "--all",
+        help="Query all matching elements or all locator suggestions",
+    ),
     attribute: str | None = typer.Option(
         None, "--attribute", help="Attribute name for get/set/remove"
     ),
@@ -302,6 +308,13 @@ def dom(
             typer.echo(f"Output saved to {output}")
         else:
             typer.echo(result)
+    elif isinstance(result, list):
+        if output:
+            Output.write_json(result, output)
+            typer.echo(f"Output saved to {output}")
+        else:
+            for item in result:
+                typer.echo(item)
     elif result is not None:
         if output:
             Output.write_json(result, output)
@@ -324,6 +337,9 @@ async def _dom(
     backend = _get_backend()
     try:
         await backend.launch(_browser_options())
+        if action == "suggest_locator":
+            await backend.navigate(url, WaitStrategy(strategy="load"))
+            return await backend.suggest_locator(selector, all=all)
         params = DOMParams(
             url=url,
             action=action,