wavexis 2.0.0__py3-none-any.whl

wavexis/__init__.py

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

wavexis/__main__.py

@@ -0,0 +1,6 @@
+"""Allow `python -m wavexis` execution."""
+
+from wavexis.cli import main
+
+if __name__ == "__main__":
+    main()

wavexis/actions/__init__.py

@@ -0,0 +1 @@
+"""Actions layer for wavexis."""

wavexis/actions/accessibility.py

@@ -0,0 +1,62 @@
+"""Accessibility action for retrieving a11y tree, node, and ancestors."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import WaitStrategy
+
+
+class AccessibilityAction(BaseAction[Any, Any]):
+    """Action for accessibility tree operations."""
+
+    def __init__(
+        self,
+        params: Any,
+        action: str = "tree",
+        node_id: str = "",
+        url: str = "",
+        wait: WaitStrategy | None = None,
+    ) -> None:
+        """Initialize the accessibility action.
+
+        Args:
+            params: Action parameters.
+            action: Accessibility action type ("tree" or "node").
+            node_id: Node ID for node-specific actions.
+            url: URL to navigate to before the action.
+            wait: Wait strategy after navigation.
+        """
+        self.params = params
+        self._action = action
+        self._node_id = node_id
+        self._url = url
+        self._wait = wait or WaitStrategy(strategy="load")
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the accessibility action on the backend.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            Accessibility tree dict, node dict, or list of ancestor dicts.
+        """
+        from wavexis.config import BrowserOptions
+
+        await backend.launch(BrowserOptions())
+        try:
+            if self._url:
+                await backend.navigate(self._url, self._wait)
+            if self._action == "tree":
+                return await backend.a11y_tree()
+            elif self._action == "node":
+                return await backend.a11y_node(self._node_id)
+            elif self._action == "ancestors":
+                return await backend.a11y_ancestors(self._node_id)
+            else:
+                raise ValueError(f"Unknown a11y action: {self._action}")
+        finally:
+            await backend.close()

wavexis/actions/animation.py

@@ -0,0 +1,59 @@
+"""Animation action for listing, pausing, playing, and seeking animations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import AnimationParams
+
+
+class AnimationAction(BaseAction[AnimationParams, Any]):
+    """Action for animation operations."""
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the animation action on the backend.
+
+        Args:
+            backend: An AbstractBackend instance.
+
+        Returns:
+            Result of the animation operation.
+        """
+        try:
+            await backend.launch(self.params.browser)
+            if self.params.url:
+                await backend.navigate(self.params.url, self.params.wait)
+
+            action = self.params.action
+
+            if action == "list":
+                return await backend.animation_list()
+
+            if action == "pause":
+                if not self.params.animation_id:
+                    raise ValueError("animation_id is required for pause action")
+                await backend.animation_pause(self.params.animation_id)
+                return None
+
+            if action == "play":
+                if not self.params.animation_id:
+                    raise ValueError("animation_id is required for play action")
+                await backend.animation_play(self.params.animation_id)
+                return None
+
+            if action == "seek":
+                if not self.params.animation_id or self.params.time_ms is None:
+                    raise ValueError(
+                        "animation_id and time_ms are required for seek action"
+                    )
+                await backend.animation_seek(
+                    self.params.animation_id, self.params.time_ms
+                )
+                return None
+
+            raise ValueError(f"Unknown animation action: {action}")
+
+        finally:
+            await backend.close()

wavexis/actions/base.py

@@ -0,0 +1,31 @@
+"""Base action class for wavexis actions."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from wavexis.backend.base import AbstractBackend
+
+P = TypeVar("P")
+R = TypeVar("R")
+
+
+class BaseAction(ABC, Generic[P, R]):
+    """Abstract base class for all wavexis actions.
+
+    An action encapsulates a single operation (e.g. screenshot, eval, pdf)
+    that is executed against a backend.
+    """
+
+    def __init__(self, params: P) -> None:
+        """Initialize the action with parameters.
+
+        Args:
+            params: Action-specific parameters.
+        """
+        self.params = params
+
+    @abstractmethod
+    async def execute(self, backend: AbstractBackend) -> R:
+        """Execute the action against the given backend."""

wavexis/actions/bluetooth.py

@@ -0,0 +1,68 @@
+"""Bluetooth action for BLE emulation (experimental)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import BrowserOptions, WaitStrategy
+
+
+@dataclass
+class BluetoothParams:
+    """Parameters for Bluetooth emulation operations.
+
+    Attributes:
+        url: URL to navigate to before Bluetooth operations.
+        action: Bluetooth action — "emulate", "stop".
+        name: Device name for "emulate" action.
+        address: Device MAC address for "emulate" action.
+        wait: Wait strategy after navigation.
+        browser: Browser launch options.
+    """
+
+    url: str = ""
+    action: str = "emulate"
+    name: str | None = None
+    address: str = "00:00:00:00:00:01"
+    wait: WaitStrategy = field(default_factory=WaitStrategy)
+    browser: BrowserOptions = field(default_factory=BrowserOptions)
+
+
+class BluetoothAction(BaseAction[BluetoothParams, Any]):
+    """Action for Bluetooth emulation operations (experimental)."""
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the Bluetooth action on the backend.
+
+        Args:
+            backend: An AbstractBackend instance.
+
+        Returns:
+            Result of the Bluetooth operation.
+        """
+        try:
+            await backend.launch(self.params.browser)
+            if self.params.url:
+                await backend.navigate(self.params.url, self.params.wait)
+
+            action = self.params.action
+
+            if action == "emulate":
+                if not self.params.name:
+                    raise ValueError("name is required for emulate action")
+                await backend.bluetooth_emulate(
+                    self.params.name, self.params.address
+                )
+                return None
+
+            if action == "stop":
+                await backend.bluetooth_stop()
+                return None
+
+            raise ValueError(f"Unknown Bluetooth action: {action}")
+
+        finally:
+            await backend.close()

wavexis/actions/browser.py

@@ -0,0 +1,39 @@
+"""Browser action for context and window management."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+
+
+class BrowserAction(BaseAction[str, Any]):
+    """Action for browser management operations.
+
+    Supports contexts (new/list/close), window bounds (get/set), and version.
+    The params string specifies the action: "new_context", "list_contexts",
+    "close_context", "get_window", "set_window", or "version".
+    """
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the browser action.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            Action-dependent result (str, list, dict, or None).
+        """
+        action = self.params
+
+        if action == "version":
+            return await backend.browser_version()
+
+        if action == "new_context":
+            return await backend.new_context()
+
+        if action == "list_contexts":
+            return await backend.list_contexts()
+
+        return None

wavexis/actions/cast.py

@@ -0,0 +1,67 @@
+"""Cast action for listing sinks and controlling tab mirroring (experimental)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import BrowserOptions, WaitStrategy
+
+
+@dataclass
+class CastParams:
+    """Parameters for Cast operations.
+
+    Attributes:
+        url: URL to navigate to before Cast operations.
+        action: Cast action — "list", "start-tab", "stop".
+        sink_name: Cast sink name for "start-tab" action.
+        wait: Wait strategy after navigation.
+        browser: Browser launch options.
+    """
+
+    url: str = ""
+    action: str = "list"
+    sink_name: str | None = None
+    wait: WaitStrategy = field(default_factory=WaitStrategy)
+    browser: BrowserOptions = field(default_factory=BrowserOptions)
+
+
+class CastAction(BaseAction[CastParams, Any]):
+    """Action for Cast operations (experimental)."""
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the Cast action on the backend.
+
+        Args:
+            backend: An AbstractBackend instance.
+
+        Returns:
+            Result of the Cast operation.
+        """
+        try:
+            await backend.launch(self.params.browser)
+            if self.params.url:
+                await backend.navigate(self.params.url, self.params.wait)
+
+            action = self.params.action
+
+            if action == "list":
+                return await backend.cast_list()
+
+            if action == "start-tab":
+                if not self.params.sink_name:
+                    raise ValueError("sink_name is required for start-tab action")
+                await backend.cast_start_tab(self.params.sink_name)
+                return None
+
+            if action == "stop":
+                await backend.cast_stop()
+                return None
+
+            raise ValueError(f"Unknown Cast action: {action}")
+
+        finally:
+            await backend.close()

wavexis/actions/console.py

@@ -0,0 +1,57 @@
+"""Console action for capturing console messages and browser logs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import WaitStrategy
+
+
+@dataclass
+class ConsoleParams:
+    """Parameters for console capture.
+
+    Attributes:
+        url: URL to navigate to before capturing.
+        level: Minimum log level — "all", "error", "warning", "info".
+        wait: Wait strategy after navigation.
+        capture: What to capture — "console", "logs", or "both".
+    """
+
+    url: str = ""
+    level: str = "all"
+    wait: WaitStrategy | None = None
+    capture: str = "console"
+
+
+class ConsoleAction(BaseAction[ConsoleParams, dict[str, Any]]):
+    """Action for capturing console messages and browser logs.
+
+    Navigates to the URL, then captures console messages and/or log entries.
+    """
+
+    async def execute(self, backend: AbstractBackend) -> dict[str, Any]:
+        """Execute the console action.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            Dict with "console" and/or "logs" keys containing entry lists.
+        """
+        params = self.params
+        if params.url:
+            await backend.navigate(params.url, params.wait)
+
+        result: dict[str, Any] = {}
+
+        if params.capture in ("console", "both"):
+            result["console"] = await backend.capture_console(level=params.level)
+
+        if params.capture in ("logs", "both"):
+            result["logs"] = await backend.capture_logs()
+
+        return result

wavexis/actions/cookies.py

@@ -0,0 +1,57 @@
+"""Cookie action for browser cookie operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import CookieActionParams
+
+
+class CookieAction(BaseAction[CookieActionParams, Any]):
+    """Action for cookie operations: get, set, delete, clear.
+
+    Navigates to the URL in params, then performs the requested
+    cookie operation against the backend.
+    """
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the cookie action on the backend.
+
+        Args:
+            backend: An AbstractBackend instance.
+
+        Returns:
+            Result of the cookie operation.
+
+        Raises:
+            ValueError: If required parameters are missing.
+        """
+        try:
+            await backend.launch(self.params.browser)
+            if self.params.url:
+                await backend.navigate(self.params.url, self.params.wait)
+
+            action = self.params.action
+
+            if action == "get":
+                return await backend.get_cookies()
+
+            if action == "set":
+                await backend.set_cookie(self.params.cookie)
+                return None
+
+            if action == "delete":
+                if not self.params.name:
+                    raise ValueError("name is required for delete action")
+                await backend.delete_cookie(self.params.name, self.params.domain)
+                return None
+
+            if action == "clear":
+                await backend.clear_cookies()
+                return None
+
+            raise ValueError(f"Unknown cookie action: {action}")
+        finally:
+            await backend.close()

wavexis/actions/crawl.py

@@ -0,0 +1,105 @@
+"""Crawl action for spidering a website with depth limit."""
+
+from __future__ import annotations
+
+import contextlib
+import re
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import urljoin, urlparse
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import WaitStrategy
+
+
+@dataclass
+class CrawlParams:
+    """Parameters for crawling a website.
+
+    Attributes:
+        start_url: Starting URL for the crawl.
+        max_depth: Maximum crawl depth (1 = start page only, 2 = start + links).
+        max_pages: Maximum number of pages to visit.
+        same_origin: If True, only crawl links on the same origin.
+        url_pattern: Regex pattern to filter URLs (empty = all).
+        wait: Wait strategy after each navigation.
+    """
+
+    start_url: str = ""
+    max_depth: int = 2
+    max_pages: int = 50
+    same_origin: bool = True
+    url_pattern: str = ""
+    wait: WaitStrategy = field(default_factory=WaitStrategy)
+
+
+class CrawlAction(BaseAction[CrawlParams, list[dict[str, Any]]]):
+    """Action for crawling a website and collecting page data."""
+
+    async def execute(
+        self, backend: AbstractBackend
+    ) -> list[dict[str, Any]]:
+        """Execute the crawl on the backend.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            List of page dicts with url, title, links, and depth.
+        """
+        results: list[dict[str, Any]] = []
+        visited: set[str] = set()
+        queue: list[tuple[str, int]] = [(self.params.start_url, 0)]
+        origin = urlparse(self.params.start_url).netloc
+        pattern = re.compile(self.params.url_pattern) if self.params.url_pattern else None
+
+        while queue and len(results) < self.params.max_pages:
+            url, depth = queue.pop(0)
+            normalized = url.rstrip("/")
+            if normalized in visited or depth > self.params.max_depth:
+                continue
+            visited.add(normalized)
+
+            try:
+                await backend.navigate(url, self.params.wait)
+            except Exception:
+                continue
+
+            title = ""
+            links: list[str] = []
+            with contextlib.suppress(Exception):
+                title = await backend.eval(
+                    "document.title", await_promise=False
+                )
+            with contextlib.suppress(Exception):
+                raw_links = await backend.eval(
+                    "Array.from(document.querySelectorAll('a[href]')).map(a => a.href)",
+                    await_promise=False,
+                )
+                if isinstance(raw_links, list):
+                    links = [str(link) for link in raw_links if isinstance(link, str)]
+
+            page_data: dict[str, Any] = {
+                "url": url,
+                "title": title,
+                "depth": depth,
+                "links_found": len(links),
+            }
+            results.append(page_data)
+
+            if depth < self.params.max_depth:
+                for link in links:
+                    absolute = urljoin(url, link)
+                    parsed = urlparse(absolute)
+                    if parsed.scheme not in ("http", "https"):
+                        continue
+                    if self.params.same_origin and parsed.netloc != origin:
+                        continue
+                    if pattern and not pattern.search(absolute):
+                        continue
+                    norm = absolute.rstrip("/")
+                    if norm not in visited:
+                        queue.append((absolute, depth + 1))
+
+        return results

wavexis/actions/css.py

@@ -0,0 +1,107 @@
+"""CSS action for inspecting styles, stylesheets, rules, and computed styles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from wavexis.actions.base import BaseAction
+from wavexis.backend.base import AbstractBackend
+from wavexis.config import BrowserOptions, CSSParams, WaitStrategy
+
+
+@dataclass
+class CSSActionParams:
+    """Parameters for CSS inspection operations.
+
+    Attributes:
+        url: URL to navigate to before CSS inspection.
+        selector: CSS selector for the target element.
+        stylesheet_id: Stylesheet ID for rules action.
+        action: CSS action — "styles", "stylesheets", "rules", "computed".
+        wait: Wait strategy after navigation.
+        browser: Browser launch options.
+    """
+
+    url: str = ""
+    selector: str | None = None
+    stylesheet_id: str | None = None
+    action: str = "styles"
+    wait: WaitStrategy = field(default_factory=WaitStrategy)
+    browser: BrowserOptions = field(default_factory=BrowserOptions)
+
+
+class CSSAction(BaseAction[CSSActionParams, dict[str, Any] | list[dict[str, Any]]]):
+    """Action for CSS inspection operations."""
+
+    async def execute(
+        self, backend: AbstractBackend
+    ) -> dict[str, Any] | list[dict[str, Any]]:
+        """Execute the CSS action on the backend.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            Dict or list of dicts containing CSS data.
+
+        Raises:
+            ValueError: If the action is not recognized or required params missing.
+        """
+        await backend.launch(self.params.browser)
+        try:
+            await backend.navigate(self.params.url, self.params.wait)
+            return await self._run_action(backend)
+        finally:
+            await backend.close()
+
+    async def _run_action(
+        self, backend: AbstractBackend
+    ) -> dict[str, Any] | list[dict[str, Any]]:
+        """Execute the CSS action against the backend.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            CSS data as a dict or list of dicts depending on the action.
+
+        Raises:
+            ValueError: If required parameters are missing for the action.
+        """
+        action = self.params.action
+        if action == "styles":
+            if not self.params.selector:
+                raise ValueError("selector is required for styles action")
+            return await backend.css_get_styles(self.params.selector)
+        if action == "stylesheets":
+            return await backend.css_get_stylesheets()
+        if action == "rules":
+            if not self.params.stylesheet_id:
+                raise ValueError("stylesheet_id is required for rules action")
+            return await backend.css_get_rules(self.params.stylesheet_id)
+        if action == "computed":
+            if not self.params.selector:
+                raise ValueError("selector is required for computed action")
+            return await backend.css_get_computed(self.params.selector)
+        raise ValueError(f"Unknown CSS action: {action}")
+
+
+def css_action_from_config(params: CSSParams) -> CSSAction:
+    """Create a CSSAction from CSSParams config dataclass.
+
+    Args:
+        params: CSSParams from wavexis.config.
+
+    Returns:
+        CSSAction instance with mapped parameters.
+    """
+    action_params = CSSActionParams(
+        url=params.url,
+        selector=params.selector,
+        stylesheet_id=params.stylesheet_id,
+        action=params.action,
+        wait=params.wait,
+        browser=params.browser,
+    )
+    return CSSAction(action_params)