⚡️ Speed up function _hvplot_interactive_transform by 28%

[codeflash-ai]

📄 28% (0.28x) speedup for _hvplot_interactive_transform in panel/pane/holoviews.py

⏱️ Runtime : 3.42 milliseconds → 2.67 milliseconds (best of 39 runs)

📝 Explanation and details

The optimized code achieves a 28% speedup by eliminating redundant module lookups and expensive imports. Here are the key optimizations:

1. Efficient Module Checking

• Original: Uses 'hvplot.interactive' not in sys.modules which performs a string-based dictionary lookup
• Optimized: Uses sys.modules.get('hvplot.interactive') which is more direct and stores the result for reuse

2. Eliminates Expensive Import Statement

• Original: Executes from hvplot.interactive import Interactive every time the function runs when the module exists (40.1% of total runtime in profiler)
• Optimized: Uses getattr(mod, 'Interactive', None) to access the class directly from the already-loaded module, avoiding the import machinery

3. Single Module Reference

• Original: Performs multiple sys.modules lookups
• Optimized: Caches the module reference in mod variable and reuses it

The profiler shows the import statement (from hvplot.interactive import Interactive) was the biggest bottleneck at 1.25ms out of 3.13ms total time. The optimized version eliminates this entirely.

Performance Characteristics:

• Best gains for cases where hvplot.interactive is loaded but objects aren't Interactive instances (100%+ faster in tests)
• Consistent improvements across all Interactive object scenarios (5-40% faster)
• Scales well with large parameter lists (28-40% faster for 1000+ params)

This optimization is particularly effective because it targets the common case where the module check and class verification happen frequently but actual Interactive object processing is less common.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import sys

# imports
import pytest  # used for our unit tests
from panel.pane.holoviews import _hvplot_interactive_transform
from param.reactive import bind

# --- Unit tests for _hvplot_interactive_transform ---

class DummyInteractive:
    """A dummy class to simulate hvplot.interactive.Interactive for testing."""
    def __init__(self, value, params=None):
        self.value = value
        self._params = params if params is not None else []

    def eval(self):
        # Simulate evaluation, return the value
        return self.value

# Helper to monkeypatch sys.modules and hvplot.interactive.Interactive
@pytest.fixture
def patch_hvplot_interactive(monkeypatch):
    # Patch sys.modules to simulate hvplot.interactive import
    sys.modules['hvplot.interactive'] = type('hvplot', (), {})()
    # Patch Interactive in hvplot.interactive
    sys.modules['hvplot.interactive'].Interactive = DummyInteractive
    yield
    # Cleanup
    del sys.modules['hvplot.interactive']

# ----------- BASIC TEST CASES ------------

def test_returns_obj_if_hvplot_interactive_not_imported():
    # hvplot.interactive not in sys.modules
    obj = "some object"
    if 'hvplot.interactive' in sys.modules:
        del sys.modules['hvplot.interactive']
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 750ns -> 786ns (4.58% slower)

def test_returns_obj_if_not_interactive(patch_hvplot_interactive):
    # Object is not instance of Interactive
    obj = [1, 2, 3]
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 2.11μs -> 1.05μs (100% faster)

def test_interactive_object_evaluated(patch_hvplot_interactive):
    # Object is instance of Interactive, should bind eval
    obj = DummyInteractive(42)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 34.0μs -> 31.9μs (6.84% faster)

def test_interactive_object_with_params(patch_hvplot_interactive):
    # Object with parameters, should bind with those params
    param1 = "foo"
    param2 = 123
    obj = DummyInteractive("bar", params=[param1, param2])
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 35.5μs -> 33.0μs (7.61% faster)

# ----------- EDGE TEST CASES ------------

def test_interactive_object_with_none_params(patch_hvplot_interactive):
    # _params is None
    obj = DummyInteractive("edge", params=None)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.4μs -> 28.8μs (5.54% faster)

def test_interactive_object_with_empty_params(patch_hvplot_interactive):
    # _params is empty list
    obj = DummyInteractive("empty", params=[])
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.3μs -> 28.8μs (5.36% faster)

def test_interactive_object_with_large_param_list(patch_hvplot_interactive):
    # _params is a large list
    params = list(range(100))
    obj = DummyInteractive("large", params=params)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 156μs -> 128μs (21.7% faster)

def test_interactive_object_with_unusual_types_in_params(patch_hvplot_interactive):
    # _params contains unusual types
    class Strange: pass
    params = [None, True, 3.14, Strange()]
    obj = DummyInteractive("strange", params=params)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 38.7μs -> 35.5μs (9.29% faster)

def test_interactive_object_with_eval_raises(patch_hvplot_interactive):
    # eval() raises an exception
    class BadInteractive(DummyInteractive):
        def eval(self):
            raise ValueError("Test error")
    obj = BadInteractive("fail")
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 29.9μs -> 28.4μs (5.35% faster)
    with pytest.raises(ValueError):
        result()

def test_interactive_object_with_eval_returning_none(patch_hvplot_interactive):
    # eval() returns None
    class NoneInteractive(DummyInteractive):
        def eval(self):
            return None
    obj = NoneInteractive("ignored")
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.2μs -> 28.4μs (6.19% faster)

def test_interactive_object_with_eval_returning_false(patch_hvplot_interactive):
    # eval() returns False
    class FalseInteractive(DummyInteractive):
        def eval(self):
            return False
    obj = FalseInteractive("ignored")
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.3μs -> 29.1μs (4.24% faster)

def test_interactive_object_with_eval_returning_complex_object(patch_hvplot_interactive):
    # eval() returns a complex object (dict)
    class DictInteractive(DummyInteractive):
        def eval(self):
            return {"a": 1, "b": [2, 3]}
    obj = DictInteractive("ignored")
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.9μs -> 29.4μs (5.17% faster)

# ----------- LARGE SCALE TEST CASES ------------

def test_large_scale_interactive_transform_with_many_params(patch_hvplot_interactive):
    # Large number of parameters (<=1000)
    params = list(range(1000))
    obj = DummyInteractive("large_scale", params=params)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 1.30ms -> 1.02ms (28.1% faster)

def test_large_scale_interactive_transform_with_large_eval_result(patch_hvplot_interactive):
    # eval() returns a large list
    class LargeEvalInteractive(DummyInteractive):
        def eval(self):
            return list(range(1000))
    obj = LargeEvalInteractive("ignored")
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.3μs -> 29.0μs (4.56% faster)
    res = result()

def test_large_scale_interactive_transform_multiple_calls(patch_hvplot_interactive):
    # Call the result multiple times to check determinism
    obj = DummyInteractive("repeat", params=[1, 2])
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 34.1μs -> 32.1μs (6.00% faster)
    for _ in range(100):
        pass

def test_large_scale_interactive_transform_with_large_object(patch_hvplot_interactive):
    # Interactive object with a large attribute
    large_data = "x" * 1000
    obj = DummyInteractive(large_data)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 29.8μs -> 27.8μs (7.15% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

import sys

# imports
import pytest  # used for our unit tests
from panel.pane.holoviews import _hvplot_interactive_transform
from param.reactive import bind


# Dummy Interactive class for testing
class DummyInteractive:
    def __init__(self, value, params=None):
        self.value = value
        self._params = params if params is not None else []
    def eval(self):
        return self.value

# Dummy bind function for testing
def dummy_bind(func, *params):
    # Just call func with params and return the result
    return func(*params)

# Patchers for sys.modules and imports
class DummyHvplotInteractiveModule:
    class Interactive(DummyInteractive):
        pass

# Basic Test Cases

def test_returns_obj_if_hvplot_interactive_not_imported(monkeypatch):
    # Ensure 'hvplot.interactive' is not in sys.modules
    sys.modules.pop('hvplot.interactive', None)
    obj = object()
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 741ns -> 757ns (2.11% slower)

def test_returns_obj_if_not_interactive(monkeypatch):
    # Add 'hvplot.interactive' to sys.modules
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    obj = object()
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 2.42μs -> 1.13μs (114% faster)

def test_interactive_object_transformed(monkeypatch):
    # Add 'hvplot.interactive' to sys.modules
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    # Patch bind to dummy_bind for test isolation
    monkeypatch.setattr('param.reactive.bind', dummy_bind)
    obj = DummyHvplotInteractiveModule.Interactive(42)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 34.3μs -> 32.8μs (4.60% faster)

def test_interactive_object_with_params(monkeypatch):
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    monkeypatch.setattr('param.reactive.bind', dummy_bind)
    # The params are passed to eval via bind, but our dummy ignores them
    obj = DummyHvplotInteractiveModule.Interactive("foo", params=[1,2,3])
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 37.3μs -> 33.7μs (10.8% faster)

# Edge Test Cases

def test_interactive_object_with_none_params(monkeypatch):
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    monkeypatch.setattr('param.reactive.bind', dummy_bind)
    obj = DummyHvplotInteractiveModule.Interactive("bar", params=None)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.1μs -> 28.4μs (6.19% faster)

def test_interactive_object_with_empty_params(monkeypatch):
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    monkeypatch.setattr('param.reactive.bind', dummy_bind)
    obj = DummyHvplotInteractiveModule.Interactive("baz", params=[])
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 29.7μs -> 28.0μs (5.98% faster)

def test_interactive_object_with_nonstandard_eval(monkeypatch):
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    monkeypatch.setattr('param.reactive.bind', dummy_bind)
    class WeirdInteractive(DummyHvplotInteractiveModule.Interactive):
        def eval(self):
            return "weird"
    obj = WeirdInteractive("should not see this")
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 30.0μs -> 28.7μs (4.65% faster)


def test_interactive_object_with_non_iterable_params(monkeypatch):
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    monkeypatch.setattr('param.reactive.bind', dummy_bind)
    # _params is not iterable
    obj = DummyHvplotInteractiveModule.Interactive("noiter", params=42)
    # Should raise TypeError in dummy_bind
    with pytest.raises(TypeError):
        _hvplot_interactive_transform(obj) # 3.75μs -> 2.58μs (45.2% faster)

# Large Scale Test Cases

def test_large_number_of_params(monkeypatch):
    sys.modules['hvplot.interactive'] = DummyHvplotInteractiveModule
    monkeypatch.setattr('param.reactive.bind', dummy_bind)
    params = list(range(1000))  # Large param list
    obj = DummyHvplotInteractiveModule.Interactive("large", params=params)
    codeflash_output = _hvplot_interactive_transform(obj); result = codeflash_output # 1.41ms -> 1.01ms (39.8% faster)

⏪ Replay Tests and Runtime

To edit these changes git checkout codeflash/optimize-_hvplot_interactive_transform-mha7g5lo and push.