⚡️ Speed up method SkyvernBrowserPage.screenshot by 24%

[codeflash-ai]

📄 24% (0.24x) speedup for SkyvernBrowserPage.screenshot in skyvern/library/skyvern_browser_page.py

⏱️ Runtime : 86.0 microseconds → 69.3 microseconds (best of 5 runs)

📝 Explanation and details

The optimization adds a fast path for empty kwargs by checking if not kwargs: before calling the underlying Playwright screenshot method. This avoids the overhead of Python's **kwargs unpacking mechanism when no additional arguments are provided.

Key optimization: When kwargs is empty (which appears to be the common case based on test results), the code now calls self._page.screenshot() directly instead of self._page.screenshot(**kwargs). This eliminates the dictionary unpacking overhead in CPython's function call mechanism.

Why this works: In Python, **kwargs unpacking involves additional dictionary operations and argument processing overhead, even when the dictionary is empty. The direct call bypasses this entirely, resulting in faster function invocation.

Performance impact: The line profiler shows that 210 out of 214 calls (98%) took the fast path with no kwargs, achieving a 24% runtime improvement (from 86.0 to 69.3 microseconds). The per-hit time for the fast path (1238.5ns) is significantly better than the original uniform time (1418.6ns).

Workload suitability: This optimization is particularly effective for:

• High-frequency screenshot operations with default settings
• Automated testing scenarios where screenshots are taken repeatedly without customization
• Browser automation workflows that capture screenshots for monitoring/debugging

The throughput remained constant at 1070 operations/second, suggesting the improvement is primarily in individual call latency rather than concurrent processing capacity. This micro-optimization provides consistent performance gains for the most common usage pattern while maintaining full backward compatibility.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 645 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import asyncio  # used to run async functions
# function to test
# (copied exactly as provided)
from typing import Any
from unittest.mock import AsyncMock, MagicMock

import pytest  # used for our unit tests
from skyvern.library.skyvern_browser_page import SkyvernBrowserPage

# --- UNIT TESTS FOR SkyvernBrowserPage.screenshot ---

# Helper: Create a mock Playwright Page with async screenshot method
class MockPage:
    def __init__(self, screenshot_return=None, should_raise=False):
        self._screenshot_return = screenshot_return if screenshot_return is not None else b"mocked_image_bytes"
        self._should_raise = should_raise
        self.screenshot_call_args = None

    async def screenshot(self, **kwargs):
        self.screenshot_call_args = kwargs
        if self._should_raise:
            raise RuntimeError("Screenshot failed")
        return self._screenshot_return

# --- BASIC TEST CASES ---

@pytest.mark.asyncio
async def test_screenshot_returns_bytes_basic():
    """Test that screenshot returns bytes under normal conditions."""
    mock_page = MockPage(screenshot_return=b"image_data")
    browser_page = SkyvernBrowserPage(browser=None, page=mock_page)
    result = await browser_page.screenshot()

@pytest.mark.asyncio
async def test_screenshot_accepts_kwargs_and_forwards_them():
    """Test that screenshot forwards kwargs to the underlying page.screenshot."""
    mock_page = MockPage()
    browser_page = SkyvernBrowserPage(browser=None, page=mock_page)
    result = await browser_page.screenshot(full_page=True, type="jpeg", quality=80)

# --- EDGE TEST CASES ---

@pytest.mark.asyncio
async def test_screenshot_raises_exception_from_page():
    """Test that screenshot propagates exceptions from underlying page.screenshot."""
    mock_page = MockPage(should_raise=True)
    browser_page = SkyvernBrowserPage(browser=None, page=mock_page)
    with pytest.raises(RuntimeError, match="Screenshot failed"):
        await browser_page.screenshot()

@pytest.mark.asyncio
async def test_screenshot_concurrent_calls_are_independent():
    """Test concurrent screenshot calls on separate SkyvernBrowserPage instances."""
    # Each mock returns a different byte string
    mock_page1 = MockPage(screenshot_return=b"img1")
    mock_page2 = MockPage(screenshot_return=b"img2")
    browser_page1 = SkyvernBrowserPage(browser=None, page=mock_page1)
    browser_page2 = SkyvernBrowserPage(browser=None, page=mock_page2)
    results = await asyncio.gather(
        browser_page1.screenshot(),
        browser_page2.screenshot()
    )

@pytest.mark.asyncio
async def test_screenshot_empty_kwargs():
    """Test screenshot with no kwargs provided."""
    mock_page = MockPage()
    browser_page = SkyvernBrowserPage(browser=None, page=mock_page)
    result = await browser_page.screenshot()

# --- LARGE SCALE TEST CASES ---

@pytest.mark.asyncio

async def test_screenshot_concurrent_with_kwargs():
    """Test concurrent screenshot calls with different kwargs."""
    mock_page = MockPage()
    browser_page = SkyvernBrowserPage(browser=None, page=mock_page)
    tasks = [
        browser_page.screenshot(full_page=True),
        browser_page.screenshot(type="jpeg", quality=90),
        browser_page.screenshot(clip={"x": 0, "y": 0, "width": 100, "height": 100})
    ]
    results = await asyncio.gather(*tasks)

# --- THROUGHPUT TEST CASES ---

@pytest.mark.asyncio

async def test_screenshot_throughput_high_volume():
    """Throughput test: high concurrent load (but bounded)."""
    num_calls = 100
    pages = [SkyvernBrowserPage(browser=None, page=MockPage(screenshot_return=b"high")) for _ in range(num_calls)]
    tasks = [page.screenshot() for page in pages]
    results = await asyncio.gather(*tasks)

@pytest.mark.asyncio

To edit these changes git checkout codeflash/optimize-SkyvernBrowserPage.screenshot-mi6sdyvs and push.