fleet-python 0.2.66b2__py3-none-any.whl → 0.2.105__py3-none-any.whl

fleet/utils/playwright.py

@@ -0,0 +1,440 @@
+"""Playwright browser control utilities.
+
+Provides PlaywrightComputer class for browser automation with:
+- Mouse actions (click, move, drag, scroll)
+- Keyboard actions (type, key combinations)
+- Screenshot capture
+- Normalized coordinate support (0-1000 range)
+
+Key mapping follows the action spec convention for cross-platform compatibility.
+"""
+
+import asyncio
+import logging
+from typing import List, Optional, Tuple
+
+from playwright.async_api import async_playwright, Page, Browser, BrowserContext
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Key Mapping - Action spec keys to Playwright keys
+# =============================================================================
+
+PLAYWRIGHT_KEY_MAP = {
+    # Common keys
+    "enter": "Enter", "return": "Enter", "tab": "Tab",
+    "escape": "Escape", "esc": "Escape", "space": " ",
+    "backspace": "Backspace", "delete": "Delete", "insert": "Insert",
+    
+    # Modifiers
+    "alt": "Alt", "alt_left": "Alt", "alt_right": "Alt",
+    "control": "Control", "control_left": "Control", "control_right": "Control",
+    "ctrl": "Control", "ctrl_left": "Control", "ctrl_right": "Control",
+    "shift": "Shift", "shift_left": "Shift", "shift_right": "Shift",
+    "caps_lock": "CapsLock", "capslock": "CapsLock",
+    "meta": "Meta", "meta_left": "Meta", "meta_right": "Meta",
+    "command": "Meta", "cmd": "Meta", "super": "Meta", "win": "Meta", "windows": "Meta",
+    "num_lock": "NumLock", "numlock": "NumLock",
+    "scroll_lock": "ScrollLock", "scrolllock": "ScrollLock",
+    
+    # Navigation
+    "arrow_down": "ArrowDown", "arrow_up": "ArrowUp",
+    "arrow_left": "ArrowLeft", "arrow_right": "ArrowRight",
+    "down": "ArrowDown", "up": "ArrowUp", "left": "ArrowLeft", "right": "ArrowRight",
+    "end": "End", "home": "Home",
+    "page_down": "PageDown", "pagedown": "PageDown",
+    "page_up": "PageUp", "pageup": "PageUp",
+    
+    # Function keys
+    **{f"f{i}": f"F{i}" for i in range(1, 21)},
+    
+    # Symbols
+    "backquote": "`", "grave": "`", "tilde": "`",
+    "backslash": "\\", "bracket_left": "[", "bracketleft": "[",
+    "bracket_right": "]", "bracketright": "]",
+    "comma": ",", "double_quote": '"', "doublequote": '"',
+    "equal": "=", "equals": "=", "minus": "-", "dash": "-",
+    "period": ".", "dot": ".", "quote": "'", "apostrophe": "'",
+    "semicolon": ";", "slash": "/", "forward_slash": "/", "forwardslash": "/",
+    
+    # Numpad
+    **{f"numpad_{i}": f"Numpad{i}" for i in range(10)},
+    **{f"numpad{i}": f"Numpad{i}" for i in range(10)},
+    "numpad_add": "NumpadAdd", "numpadadd": "NumpadAdd",
+    "numpad_subtract": "NumpadSubtract", "numpadsubtract": "NumpadSubtract",
+    "numpad_multiply": "NumpadMultiply", "numpadmultiply": "NumpadMultiply",
+    "numpad_divide": "NumpadDivide", "numpaddivide": "NumpadDivide",
+    "numpad_decimal": "NumpadDecimal", "numpaddecimal": "NumpadDecimal",
+    "numpad_enter": "NumpadEnter", "numpadenter": "NumpadEnter",
+    
+    # Media
+    "audio_volume_mute": "AudioVolumeMute",
+    "audio_volume_down": "AudioVolumeDown",
+    "audio_volume_up": "AudioVolumeUp",
+    "media_track_next": "MediaTrackNext",
+    "media_track_previous": "MediaTrackPrevious",
+    "media_stop": "MediaStop",
+    "media_play_pause": "MediaPlayPause",
+    
+    # Other
+    "print_screen": "PrintScreen", "printscreen": "PrintScreen",
+    "pause": "Pause", "context_menu": "ContextMenu", "contextmenu": "ContextMenu",
+    "help": "Help",
+}
+
+MODIFIER_KEYS = {
+    "Alt", "Control", "Shift", "Meta",
+    "alt", "alt_left", "alt_right",
+    "control", "control_left", "control_right", "ctrl", "ctrl_left", "ctrl_right",
+    "shift", "shift_left", "shift_right",
+    "meta", "meta_left", "meta_right", "command", "cmd", "super", "win", "windows",
+}
+
+# Key specification for tool docstrings
+KEY_SPEC = (
+    "Key specification: * Common: enter, tab, escape, space, backspace, delete "
+    "* Modifiers: alt_left, control_left, control_right, shift_left, caps_lock, meta "
+    "* Navigation: arrow_down, arrow_right, end, home, page_down "
+    "* Function: f1 to f12 "
+    "* Alphanumeric: key_a to key_z, digit_0 to digit_9 "
+    "* Symbols: backquote, backslash, bracket_left, bracket_right, comma, double_quote, "
+    "equal, minus, period, quote, semicolon, slash "
+    "* Numpad: numpad_0 to numpad_9, numpad_add, numpad_divide, numpad_enter, numpad_multiply"
+)
+
+
+def map_key(key: str) -> str:
+    """Map action spec key name to Playwright key name.
+    
+    Args:
+        key: Key name in action spec format (e.g., "key_a", "control_left")
+        
+    Returns:
+        Playwright key name (e.g., "a", "Control")
+    """
+    k = key.lower().strip()
+    if k in PLAYWRIGHT_KEY_MAP:
+        return PLAYWRIGHT_KEY_MAP[k]
+    if k.startswith("key_") and len(k) == 5:
+        return k[4].lower()
+    if k.startswith("digit_") and len(k) == 7:
+        return k[6]
+    if len(key) == 1:
+        return key
+    return key
+
+
+def is_modifier(key: str) -> bool:
+    """Check if a key is a modifier key.
+    
+    Args:
+        key: Key name to check
+        
+    Returns:
+        True if the key is a modifier (Alt, Control, Shift, Meta)
+    """
+    return key.lower().strip() in MODIFIER_KEYS or map_key(key) in {"Alt", "Control", "Shift", "Meta"}
+
+
+# =============================================================================
+# PlaywrightComputer - Browser control
+# =============================================================================
+
+class PlaywrightComputer:
+    """Browser control via Playwright.
+    
+    Provides a high-level interface for browser automation:
+    - Mouse actions with optional visual highlighting
+    - Keyboard input with proper modifier handling
+    - Screenshot capture
+    - Automatic page load waiting
+    
+    Args:
+        screen_size: Tuple of (width, height) for viewport
+        initial_url: URL to navigate to on start
+        headless: Run browser without visible window
+        highlight_mouse: Show visual indicator for mouse actions (useful for debugging)
+    
+    Example:
+        computer = PlaywrightComputer(
+            screen_size=(1366, 768),
+            initial_url="https://example.com",
+            headless=False,
+            highlight_mouse=True,
+        )
+        await computer.start()
+        await computer.mouse_click(683, 384)  # Click center
+        screenshot = await computer.screenshot()
+        await computer.stop()
+    """
+    
+    def __init__(
+        self,
+        screen_size: Tuple[int, int],
+        initial_url: str,
+        headless: bool = True,
+        highlight_mouse: bool = False,
+    ):
+        self._screen_size = screen_size
+        self._initial_url = initial_url
+        self._headless = headless
+        self._highlight_mouse = highlight_mouse
+        self._playwright = None
+        self._browser: Optional[Browser] = None
+        self._context: Optional[BrowserContext] = None
+        self._page: Optional[Page] = None
+    
+    @property
+    def width(self) -> int:
+        """Viewport width in pixels."""
+        return self._screen_size[0]
+    
+    @property
+    def height(self) -> int:
+        """Viewport height in pixels."""
+        return self._screen_size[1]
+    
+    @property
+    def current_url(self) -> str:
+        """Current page URL."""
+        return self._page.url if self._page else ""
+    
+    async def _handle_new_page(self, new_page: Page):
+        """Handle new tab by redirecting to current page."""
+        new_url = new_page.url
+        await new_page.close()
+        await self._page.goto(new_url)
+    
+    async def start(self):
+        """Start the browser and navigate to initial URL."""
+        logger.info(f"Starting browser (headless={self._headless})...")
+        self._playwright = await async_playwright().start()
+        self._browser = await self._playwright.chromium.launch(
+            headless=self._headless,
+            args=[
+                "--no-sandbox",
+                "--disable-extensions",
+                "--disable-file-system",
+                "--disable-plugins",
+                "--disable-dev-shm-usage",
+                "--disable-background-networking",
+                "--disable-default-apps",
+                "--disable-sync",
+            ],
+        )
+        self._context = await self._browser.new_context(
+            viewport={"width": self._screen_size[0], "height": self._screen_size[1]}
+        )
+        self._page = await self._context.new_page()
+        self._context.on("page", self._handle_new_page)
+        await self._page.goto(self._initial_url)
+        await self._page.wait_for_load_state()
+        logger.info(f"Browser ready: {self._initial_url}")
+    
+    async def stop(self):
+        """Stop the browser and clean up resources."""
+        if self._context:
+            await self._context.close()
+        if self._browser:
+            try:
+                await self._browser.close()
+            except Exception:
+                pass
+        if self._playwright:
+            await self._playwright.stop()
+        logger.info("Browser stopped")
+    
+    async def screenshot(self) -> bytes:
+        """Take a screenshot of the current viewport.
+        
+        Returns:
+            PNG image data as bytes
+        """
+        await self._page.wait_for_load_state()
+        await asyncio.sleep(0.5)
+        return await self._page.screenshot(type="png", full_page=False)
+    
+    async def _highlight(self, x: int, y: int):
+        """Show visual highlight at mouse position (for debugging)."""
+        if not self._highlight_mouse:
+            return
+        await self._page.evaluate(f"""
+            () => {{
+                const div = document.createElement('div');
+                div.style.cssText = 'position:fixed;width:20px;height:20px;border-radius:50%;border:4px solid red;pointer-events:none;z-index:9999;left:{x-10}px;top:{y-10}px;';
+                document.body.appendChild(div);
+                setTimeout(() => div.remove(), 2000);
+            }}
+        """)
+        await asyncio.sleep(1)
+    
+    # -------------------------------------------------------------------------
+    # Mouse actions
+    # -------------------------------------------------------------------------
+    
+    async def mouse_click(self, x: int, y: int, button: str = "left", repeats: int = 1) -> None:
+        """Click at position.
+        
+        Args:
+            x: X coordinate in pixels
+            y: Y coordinate in pixels
+            button: Mouse button ('left', 'middle', 'right')
+            repeats: Number of clicks (2 for double-click)
+        """
+        await self._highlight(x, y)
+        for _ in range(repeats):
+            await self._page.mouse.click(x, y, button=button)
+        await self._page.wait_for_load_state()
+    
+    async def mouse_move(self, x: int, y: int) -> None:
+        """Move mouse to position.
+        
+        Args:
+            x: X coordinate in pixels
+            y: Y coordinate in pixels
+        """
+        await self._highlight(x, y)
+        await self._page.mouse.move(x, y)
+        await self._page.wait_for_load_state()
+    
+    async def mouse_down(self, button: str = "left") -> None:
+        """Press mouse button down.
+        
+        Args:
+            button: Mouse button ('left', 'middle', 'right')
+        """
+        await self._page.mouse.down(button=button)
+    
+    async def mouse_up(self, button: str = "left") -> None:
+        """Release mouse button.
+        
+        Args:
+            button: Mouse button ('left', 'middle', 'right')
+        """
+        await self._page.mouse.up(button=button)
+        await self._page.wait_for_load_state()
+    
+    async def mouse_scroll(self, dx: int, dy: int) -> None:
+        """Scroll the mouse wheel.
+        
+        Args:
+            dx: Horizontal scroll amount in pixels
+            dy: Vertical scroll amount in pixels
+        """
+        await self._page.mouse.wheel(dx, dy)
+        await self._page.wait_for_load_state()
+    
+    async def mouse_drag(
+        self,
+        x_start: int,
+        y_start: int,
+        x_end: int,
+        y_end: int,
+        button: str = "left",
+    ) -> None:
+        """Drag from one position to another.
+        
+        Args:
+            x_start: Starting X coordinate
+            y_start: Starting Y coordinate
+            x_end: Ending X coordinate
+            y_end: Ending Y coordinate
+            button: Mouse button to hold during drag
+        """
+        await self._highlight(x_start, y_start)
+        await self._page.mouse.move(x_start, y_start)
+        await self._page.mouse.down(button=button)
+        await self._highlight(x_end, y_end)
+        await self._page.mouse.move(x_end, y_end)
+        await self._page.mouse.up(button=button)
+        await self._page.wait_for_load_state()
+    
+    # -------------------------------------------------------------------------
+    # Keyboard actions
+    # -------------------------------------------------------------------------
+    
+    async def type_text(self, text: str, press_enter: bool = False) -> None:
+        """Type text using the keyboard.
+        
+        Args:
+            text: Text to type
+            press_enter: Whether to press Enter after typing
+        """
+        await self._page.keyboard.type(text)
+        await self._page.wait_for_load_state()
+        if press_enter:
+            await self._page.keyboard.press("Enter")
+            await self._page.wait_for_load_state()
+    
+    async def key_combination(self, keys: List[str]) -> None:
+        """Press a key combination (e.g., Ctrl+C).
+        
+        Handles modifiers properly - holds them down while pressing other keys.
+        
+        Args:
+            keys: List of keys to press together
+        """
+        if not keys:
+            return
+        
+        modifiers = [map_key(k) for k in keys if is_modifier(k)]
+        regular = [map_key(k) for k in keys if not is_modifier(k)]
+        
+        # Press modifiers down
+        for mod in modifiers:
+            await self._page.keyboard.down(mod)
+        
+        # Press regular keys
+        for key in regular:
+            await self._page.keyboard.press(key)
+        
+        # If only modifiers, brief pause
+        if not regular and modifiers:
+            await asyncio.sleep(0.05)
+        
+        # Release modifiers
+        for mod in reversed(modifiers):
+            await self._page.keyboard.up(mod)
+        
+        await self._page.wait_for_load_state()
+    
+    async def key_down(self, key: str) -> None:
+        """Press a key down (without releasing).
+        
+        Args:
+            key: Key to press down
+        """
+        await self._page.keyboard.down(map_key(key))
+    
+    async def key_up(self, key: str) -> None:
+        """Release a key.
+        
+        Args:
+            key: Key to release
+        """
+        await self._page.keyboard.up(map_key(key))
+        await self._page.wait_for_load_state()
+    
+    # -------------------------------------------------------------------------
+    # Utilities
+    # -------------------------------------------------------------------------
+    
+    async def wait(self, seconds: int) -> None:
+        """Wait for a number of seconds.
+        
+        Args:
+            seconds: Number of seconds to wait
+        """
+        await asyncio.sleep(seconds)
+    
+    async def goto(self, url: str) -> None:
+        """Navigate to a URL.
+        
+        Args:
+            url: URL to navigate to
+        """
+        await self._page.goto(url)
+        await self._page.wait_for_load_state()
+

fleet/verifiers/bundler.py

@@ -37,7 +37,7 @@ class FunctionBundler:
     ) -> bytes:
         """Create a function bundle with statically extracted code."""
 
-        logger.info(f"Creating function bundle for {func.__name__}")
+        # logger.info(f"Creating function bundle for {func.__name__}")
 
         # 1. Parse the main function and find dependencies
         mod_file = Path(func.__code__.co_filename)
@@ -115,7 +115,7 @@ class FunctionBundler:
 
         # Find function calls within the verifier function
         called_functions = self._extract_function_calls(main_func_ast)
-        logger.debug(f"Functions called in verifier: {called_functions}")
+        # logger.debug(f"Functions called in verifier: {called_functions}")
 
         # Find all functions defined in the module
         module_functions = {}
@@ -128,7 +128,7 @@ class FunctionBundler:
         for func_name in called_functions:
             if func_name in module_functions and func_name != func.__name__:
                 same_module_deps.append(func_name)
-                logger.debug(f"Found same-module dependency: {func_name}")
+                # logger.debug(f"Found same-module dependency: {func_name}")
 
         # Separate local and external imports
         local_imports = {}
@@ -292,7 +292,7 @@ class FunctionBundler:
                     code = ast.unparse(node)
                     extracted_code.append(code)
                 except Exception as e:
-                    logger.warning(f"Could not unparse AST node: {e}")
+                    # logger.warning(f"Could not unparse AST node: {e}")
                     # Fallback to original source extraction
                     lines = content.split("\n")
                     start_line = node.lineno - 1
@@ -305,11 +305,11 @@ class FunctionBundler:
                     extracted_code.append(code)
 
             result = "\n\n".join(extracted_code)
-            logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
+            # logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
             return result
 
         except Exception as e:
-            logger.warning(f"Failed to extract functions from {file_path}: {e}")
+            # logger.warning(f"Failed to extract functions from {file_path}: {e}")
             # Fallback to including the entire file
             with open(file_path, "r", encoding="utf-8") as f:
                 return f.read()
@@ -464,14 +464,14 @@ class FunctionBundler:
                 version = dist.version  # Get the installed version
                 package_with_version = f"{package_name}=={version}"
                 packages.add(package_with_version)
-                logger.debug(f"Mapped {mod} -> {package_with_version}")
+                # logger.debug(f"Mapped {mod} -> {package_with_version}")
             except imd.PackageNotFoundError:
                 # Skip stdlib or local modules
-                logger.debug(f"Skipping {mod} (stdlib or local)")
+                # logger.debug(f"Skipping {mod} (stdlib or local)")
                 continue
 
         package_list = list(packages)
-        logger.debug(f"Final package list: {package_list}")
+        # logger.debug(f"Final package list: {package_list}")
         return package_list
 
     def _merge_requirements(
@@ -511,10 +511,10 @@ class FunctionBundler:
             if pkg_name not in seen_packages:
                 final_requirements.append(req)
                 seen_packages.add(pkg_name)
-            else:
-                logger.debug(
-                    f"Skipping auto-detected {req}, using explicit version instead"
-                )
+            # else:
+            #     logger.debug(
+            #         f"Skipping auto-detected {req}, using explicit version instead"
+            #     )
 
         # Always ensure fleet-python is included
         if "fleet-python" not in seen_packages:
@@ -565,9 +565,9 @@ class FunctionBundler:
                         )
                         if dep_src:
                             same_module_code += f"\n{dep_src}\n"
-                            logger.debug(
-                                f"Extracted same-module dependency: {dep_name}"
-                            )
+                            # logger.debug(
+                            #     f"Extracted same-module dependency: {dep_name}"
+                            # )
 
                 # Create verifier.py with the main function
                 verifier_file = build_dir / "verifier.py"
@@ -586,7 +586,7 @@ class FunctionBundler:
 {code}
 """
                     dest_path.write_text(extracted_content)
-                    logger.debug(f"Created extracted file: {relative_path}")
+                    # logger.debug(f"Created extracted file: {relative_path}")
 
                     # Ensure __init__.py files exist
                     self._ensure_init_files(Path(relative_path), build_dir)
@@ -595,7 +595,7 @@ class FunctionBundler:
                 return self._create_zip_bundle(build_dir)
 
             except Exception as e:
-                logger.error(f"Failed to build function bundle: {e}")
+                # logger.error(f"Failed to build function bundle: {e}")
                 raise RuntimeError(f"Function bundle creation failed: {e}")
 
     def _ensure_init_files(self, rel_path: Path, build_dir: Path):
@@ -607,7 +607,7 @@ class FunctionBundler:
             if not init_file.exists():
                 init_file.parent.mkdir(parents=True, exist_ok=True)
                 init_file.write_text("# Auto-generated __init__.py")
-                logger.debug(f"Created __init__.py: {current}")
+                # logger.debug(f"Created __init__.py: {current}")
             current = current.parent
 
     def _create_zip_bundle(self, build_dir: Path) -> bytes:
@@ -621,7 +621,7 @@ class FunctionBundler:
                     zf.write(file_path, arcname)
 
         bundle_size = len(zip_buffer.getvalue())
-        logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
+        # logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
         return zip_buffer.getvalue()
 
     def _extract_function_source(
@@ -662,7 +662,8 @@ class FunctionBundler:
                     return "\n".join(func_lines)
 
         except Exception as e:
-            logger.warning(f"Failed to extract function {function_name}: {e}")
+            # logger.warning(f"Failed to extract function {function_name}: {e}")
+            pass
 
         return None