⚡️ Speed up method SkyvernLocator.locator by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for SkyvernLocator.locator in skyvern/library/skyvern_locator.py

⏱️ Runtime : 15.9 milliseconds → 14.5 milliseconds (best of 75 runs)

📝 Explanation and details

The optimized code achieves a 9% speedup by eliminating unnecessary dictionary allocations when no keyword arguments are passed to the locator() method.

Key Optimization:

• Added a conditional check if not kwargs: to avoid passing empty **kwargs to the underlying Playwright locator
• When no kwargs are provided (which happens in ~97% of calls based on line profiler data), the method now calls self._locator.locator(selector) directly instead of self._locator.locator(selector, **kwargs)

Why This Works:

• Python's **kwargs mechanism creates dictionary overhead even when empty, requiring argument unpacking and additional function call setup
• The line profiler shows 2,220 out of 2,286 calls (97%) take the no-kwargs path, making this optimization highly effective for the common case
• The optimization reduces per-hit time from ~52μs to ~47μs for the common path

Performance Benefits by Use Case:

• Simple selector chaining (most common): 6-9% faster as seen in chain tests
• Complex selectors with kwargs: Minimal impact (~0-2% slower due to branch overhead)
• Deep nesting scenarios: 6-9% improvement scales with call frequency

This optimization is particularly valuable since SkyvernLocator appears to be a wrapper around Playwright's locator API, commonly used for element selection in web automation where chaining operations like locator("div").locator("span") are frequent. The micro-optimization compounds across multiple chained calls, providing meaningful performance gains in selector-heavy workflows.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any

# imports
import pytest  # used for our unit tests
# function to test
# python:skyvern/library/skyvern_locator.py
from playwright.async_api import Locator
from skyvern.library.skyvern_locator import SkyvernLocator

# unit tests

class DummyLocator:
    """
    Dummy Locator to simulate Playwright's Locator for unit testing.
    Tracks calls and arguments for assertion purposes.
    """
    def __init__(self, name="root", parent=None):
        self.name = name
        self.parent = parent
        self.calls = []

    def locator(self, selector, **kwargs):
        # Record the call for test verification
        self.calls.append((selector, kwargs))
        # Return a new DummyLocator to simulate chaining
        # For uniqueness, append selector to name
        new_name = f"{self.name}->{selector}"
        return DummyLocator(new_name, parent=self)

    def __eq__(self, other):
        # For test purposes, equality is based on name and parent
        return isinstance(other, DummyLocator) and self.name == other.name and self.parent == other.parent

    def __repr__(self):
        return f"DummyLocator(name={self.name!r})"

@pytest.fixture
def dummy_root_locator():
    # Fixture to provide a fresh DummyLocator for each test
    return DummyLocator()

# --------------------------
# 1. Basic Test Cases
# --------------------------

def test_locator_chain_multiple_calls(dummy_root_locator):
    # Test chaining multiple locator() calls
    skyvern = SkyvernLocator(dummy_root_locator)
    codeflash_output = skyvern.locator("div").locator("span").locator("a.link"); result = codeflash_output # 1.04μs -> 971ns (7.00% faster)
    # The next locator is recorded in the child DummyLocator
    codeflash_output = dummy_root_locator.locator("div"); div_locator = codeflash_output # 564ns -> 615ns (8.29% slower)
    codeflash_output = div_locator.locator("span"); span_locator = codeflash_output # 415ns -> 398ns (4.27% faster)

# --------------------------
# 2. Edge Test Cases
# --------------------------

def test_locator_with_special_characters_in_selector(dummy_root_locator):
    # Test with selector containing special characters
    special_selector = "div#main.content[data-test='!@#$%^&*()']"
    skyvern = SkyvernLocator(dummy_root_locator)
    codeflash_output = skyvern.locator(special_selector); result = codeflash_output # 1.47μs -> 1.44μs (1.66% faster)

def test_locator_with_long_selector_string(dummy_root_locator):
    # Test with a very long selector string
    long_selector = "div" + " > span" * 100
    skyvern = SkyvernLocator(dummy_root_locator)
    codeflash_output = skyvern.locator(long_selector); result = codeflash_output # 1.59μs -> 1.55μs (2.32% faster)

def test_locator_with_non_string_selector(dummy_root_locator):
    # Test with non-string selector (should be accepted and passed through)
    skyvern = SkyvernLocator(dummy_root_locator)
    selector = 12345  # integer selector
    codeflash_output = skyvern.locator(selector); result = codeflash_output # 2.09μs -> 1.95μs (7.30% faster)

def test_locator_with_no_selector_raises_typeerror(dummy_root_locator):
    # Test that missing selector argument raises TypeError
    skyvern = SkyvernLocator(dummy_root_locator)
    with pytest.raises(TypeError):
        # locator() requires at least one positional argument
        skyvern.locator() # 3.48μs -> 3.24μs (7.44% faster)

def test_locator_chain_deep_nesting(dummy_root_locator):
    # Test chaining locator() calls up to 100 levels deep
    skyvern = SkyvernLocator(dummy_root_locator)
    current = skyvern
    for i in range(100):
        codeflash_output = current.locator(f"div.level{i}"); current = codeflash_output # 51.8μs -> 48.7μs (6.27% faster)
    # The last DummyLocator's name should reflect the full chain
    expected_suffix = "->".join([f"div.level{i}" for i in range(100)])

def test_locator_chain_with_varied_selectors_and_kwargs(dummy_root_locator):
    # Test chaining locator() with varied selectors and kwargs
    skyvern = SkyvernLocator(dummy_root_locator)
    selectors = [f"el{i}" for i in range(10)]
    kwargs_list = [{"attr": i, "flag": True} for i in range(10)]
    current = skyvern
    for selector, kwargs in zip(selectors, kwargs_list):
        codeflash_output = current.locator(selector, **kwargs); current = codeflash_output # 8.39μs -> 8.58μs (2.26% slower)
    # Check that the final DummyLocator's name is correct
    expected_suffix = "->".join(selectors)

def test_locator_large_selector_and_kwargs(dummy_root_locator):
    # Test with a large selector and large kwargs
    large_selector = "div" + " > span" * 500
    large_kwargs = {f"key{i}": i for i in range(500)}
    skyvern = SkyvernLocator(dummy_root_locator)
    codeflash_output = skyvern.locator(large_selector, **large_kwargs); result = codeflash_output # 42.7μs -> 42.9μs (0.403% slower)

def test_locator_chain_performance(dummy_root_locator):
    # Test performance with 1000 chained locator() calls (without exceeding 1000 elements)
    skyvern = SkyvernLocator(dummy_root_locator)
    current = skyvern
    for i in range(1000):
        codeflash_output = current.locator(f"el{i}"); current = codeflash_output # 596μs -> 546μs (9.08% faster)
    # The final DummyLocator's name should reflect the full chain
    expected_suffix = "->".join([f"el{i}" for i in range(1000)])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-SkyvernLocator.locator-mjaoif79 and push.