browsix 1.0.0__py3-none-any.whl

browsix/__init__.py

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

browsix/__main__.py

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

browsix/actions/__init__.py

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

browsix/actions/accessibility.py

@@ -0,0 +1,53 @@
+"""Accessibility action for retrieving a11y tree, node, and ancestors."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.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:
+        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 browsix.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()

browsix/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 browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.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()

browsix/actions/base.py

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

browsix/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 browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.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()

browsix/actions/browser.py

@@ -0,0 +1,39 @@
+"""Browser action for context and window management."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from browsix.actions.base import BaseAction
+from browsix.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

browsix/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 browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.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()

browsix/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 browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.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

browsix/actions/css.py

@@ -0,0 +1,96 @@
+"""CSS action for inspecting styles, stylesheets, rules, and computed styles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.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]]:
+        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 browsix.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)

browsix/actions/debug.py

@@ -0,0 +1,134 @@
+"""Debug action for breakpoints, stepping, pause/resume, and listeners."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.config import BrowserOptions, DebugParams, WaitStrategy
+
+
+@dataclass
+class DebugActionParams:
+    """Parameters for debugging operations.
+
+    Attributes:
+        url: URL to navigate to before debugging (optional for step/pause/resume).
+        line: Line number for breakpoint (0-based).
+        function_name: Function name for function breakpoint.
+        condition: Optional condition expression for breakpoint.
+        action: Debug action — "breakpoint", "function_breakpoint",
+            "remove_breakpoint", "step_over", "step_into", "step_out",
+            "pause", "resume", "listeners".
+        breakpoint_id: Breakpoint ID for remove_breakpoint.
+        selector: CSS selector for listeners action.
+        script_url: URL of the script for breakpoint (distinct from page url).
+        wait: Wait strategy after navigation.
+        browser: Browser launch options.
+    """
+
+    url: str | None = None
+    line: int | None = None
+    function_name: str | None = None
+    condition: str | None = None
+    action: str = "breakpoint"
+    breakpoint_id: str | None = None
+    selector: str | None = None
+    script_url: str | None = None
+    wait: WaitStrategy = field(default_factory=WaitStrategy)
+    browser: BrowserOptions = field(default_factory=BrowserOptions)
+
+
+class DebugAction(BaseAction[DebugActionParams, Any]):
+    """Action for debugging operations."""
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the debug action on the backend.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            Result of the debug action (breakpoint ID, listener list, or None).
+
+        Raises:
+            ValueError: If the action is not recognized or required params missing.
+        """
+        await backend.launch(self.params.browser)
+        try:
+            if self.params.url:
+                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) -> Any:
+        action = self.params.action
+        if action == "breakpoint":
+            if self.params.script_url is None or self.params.line is None:
+                raise ValueError(
+                    "script_url and line are required for breakpoint action"
+                )
+            return await backend.debug_set_breakpoint(
+                self.params.script_url, self.params.line, self.params.condition
+            )
+        if action == "function_breakpoint":
+            if not self.params.function_name:
+                raise ValueError(
+                    "function_name is required for function_breakpoint action"
+                )
+            return await backend.debug_set_breakpoint_function(
+                self.params.function_name
+            )
+        if action == "remove_breakpoint":
+            if not self.params.breakpoint_id:
+                raise ValueError(
+                    "breakpoint_id is required for remove_breakpoint action"
+                )
+            await backend.debug_remove_breakpoint(self.params.breakpoint_id)
+            return None
+        if action == "step_over":
+            await backend.debug_step_over()
+            return None
+        if action == "step_into":
+            await backend.debug_step_into()
+            return None
+        if action == "step_out":
+            await backend.debug_step_out()
+            return None
+        if action == "pause":
+            await backend.debug_pause()
+            return None
+        if action == "resume":
+            await backend.debug_resume()
+            return None
+        if action == "listeners":
+            if not self.params.selector:
+                raise ValueError("selector is required for listeners action")
+            return await backend.debug_get_listeners(self.params.selector)
+        raise ValueError(f"Unknown debug action: {action}")
+
+
+def debug_action_from_config(params: DebugParams) -> DebugAction:
+    """Create a DebugAction from DebugParams config dataclass.
+
+    Args:
+        params: DebugParams from browsix.config.
+
+    Returns:
+        DebugAction instance with mapped parameters.
+    """
+    action_params = DebugActionParams(
+        url=params.url,
+        line=params.line,
+        function_name=params.function_name,
+        condition=params.condition,
+        action=params.action,
+        breakpoint_id=params.breakpoint_id,
+        selector=params.selector,
+        wait=params.wait,
+        browser=params.browser,
+    )
+    return DebugAction(action_params)

browsix/actions/dialog.py

@@ -0,0 +1,50 @@
+"""Dialog action for accepting or dismissing JavaScript dialogs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from browsix.actions.base import BaseAction
+from browsix.backend.base import AbstractBackend
+from browsix.config import BrowserOptions, WaitStrategy
+
+
+class DialogAction(BaseAction[str, None]):
+    """Action for handling JavaScript dialogs (alert, confirm, prompt)."""
+
+    def __init__(
+        self,
+        params: str,
+        action: str = "accept",
+        prompt_text: str | None = None,
+        url: str = "",
+        wait: WaitStrategy | None = None,
+    ) -> None:
+        self.params = params
+        self._action = action
+        self._prompt_text = prompt_text
+        self._url = url
+        self._wait = wait or WaitStrategy(strategy="load")
+
+    async def execute(self, backend: AbstractBackend) -> Any:
+        """Execute the dialog action on the backend.
+
+        Args:
+            backend: The browser backend to use.
+
+        Returns:
+            None.
+        """
+        await backend.launch(BrowserOptions())
+        try:
+            if self._url:
+                await backend.navigate(self._url, self._wait)
+            if self._action == "accept":
+                await backend.dialog_accept(self._prompt_text)
+            elif self._action == "dismiss":
+                await backend.dialog_dismiss()
+            else:
+                raise ValueError(f"Unknown dialog action: {self._action}")
+        finally:
+            await backend.close()
+        return None