⚡️ Speed up method HTML.applies by 82%

[codeflash-ai]

📄 82% (0.82x) speedup for HTML.applies in panel/pane/markup.py

⏱️ Runtime : 1.52 milliseconds → 836 microseconds (best of 26 runs)

📝 Explanation and details

The optimization achieves an 81% speedup through three key changes:

1. Early String Check Reordering
The optimized code checks isinstance(obj, str) first, which provides significant speedup for string inputs (120% faster). Since strings are common inputs and this is a fast type check, it eliminates unnecessary work for a frequent case.

2. Eliminated Generator Expression
Replaced any(m in module for m in ('pandas', 'dask')) with direct boolean logic 'pandas' in module or 'dask' in module. The original generator expression was the most expensive operation (57% of total time), and the direct string containment checks are much faster.

3. Simplified Control Flow
Removed the elif/else structure in favor of direct conditional returns, reducing branching overhead and making the code path more predictable.

Performance Impact by Test Type:

• String inputs: 88-128% faster (most dramatic improvement)
• Pandas/Dask objects: 58-81% faster due to eliminating the generator
• Objects with _repr_html_: 37-57% faster from reduced overhead
• Plain objects: 51-85% faster from streamlined flow

The optimizations are particularly effective for workloads with many string inputs or mixed object types, while maintaining identical behavior and return values.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

from collections.abc import Mapping
from typing import Any, ClassVar

import param
# imports
import pytest
from panel.pane.markup import HTML


def HTML_SANITIZER_clean(x):
    # Dummy sanitizer for testing
    return x

class HTMLBasePane:
    pass
from panel.pane.markup import HTML

# unit tests

# --- Basic Test Cases ---

def test_applies_pandas_dataframe():
    # Simulate a pandas DataFrame object
    class DummyDF:
        __module__ = 'pandas.core.frame'
        def __init__(self): pass
    df = DummyDF()
    codeflash_output = HTML.applies(df) # 2.62μs -> 1.55μs (69.2% faster)

def test_applies_pandas_series():
    # Simulate a pandas Series object
    class DummySeries:
        __module__ = 'pandas.core.series'
        def __init__(self): pass
    s = DummySeries()
    codeflash_output = HTML.applies(s) # 2.42μs -> 1.40μs (73.0% faster)

def test_applies_dask_dataframe():
    # Simulate a dask DataFrame object
    class DummyDF:
        __module__ = 'dask.dataframe.core'
        def __init__(self): pass
    ddf = DummyDF()
    codeflash_output = HTML.applies(ddf) # 2.48μs -> 1.47μs (68.8% faster)

def test_applies_object_with_repr_html():
    # Object with a _repr_html_ method
    class HasHTML:
        def _repr_html_(self): return "<b>hi</b>"
    obj = HasHTML()
    codeflash_output = HTML.applies(obj) # 2.73μs -> 1.79μs (53.0% faster)


def test_applies_plain_string():
    # Plain string should return None
    codeflash_output = HTML.applies("<h1>Hello</h1>") # 1.99μs -> 904ns (120% faster)

def test_applies_plain_int():
    # Non-string, non-html object should return False
    codeflash_output = HTML.applies(12345) # 2.06μs -> 1.30μs (58.1% faster)

def test_applies_plain_list():
    # Non-string, non-html object should return False
    codeflash_output = HTML.applies([1, 2, 3]) # 2.08μs -> 1.36μs (52.9% faster)

# --- Edge Test Cases ---



def test_applies_object_with_module_pandas_but_wrong_name():
    # Module matches but name does not
    class NotDF:
        __module__ = 'pandas.core.frame'
    obj = NotDF()
    codeflash_output = HTML.applies(obj) # 2.56μs -> 1.46μs (75.0% faster)

def test_applies_object_with_module_dask_but_wrong_name():
    # Module matches but name does not
    class NotDF:
        __module__ = 'dask.dataframe.core'
    obj = NotDF()
    codeflash_output = HTML.applies(obj) # 2.57μs -> 1.50μs (71.8% faster)



def test_applies_object_with_module_pandas_and_name_series_but_repr_html():
    # Simulate a pandas Series with _repr_html_
    class DummySeries:
        __module__ = 'pandas.core.series'
        def _repr_html_(self): return "<b>hi</b>"
    s = DummySeries()
    codeflash_output = HTML.applies(s) # 2.85μs -> 1.83μs (56.1% faster)


def test_applies_object_with_weird_module_and_repr_html():
    # Module is unrelated, but has _repr_html_
    class Odd:
        __module__ = 'weird.module'
        def _repr_html_(self): return "<b>hi</b>"
    obj = Odd()
    codeflash_output = HTML.applies(obj) # 2.54μs -> 1.72μs (47.5% faster)

def test_applies_object_with_weird_module_and_no_repr_html():
    # Module is unrelated, no _repr_html_
    class Odd:
        __module__ = 'weird.module'
    obj = Odd()
    codeflash_output = HTML.applies(obj) # 2.17μs -> 1.32μs (64.8% faster)

def test_applies_object_with_module_none_and_no_repr_html():
    # No __module__, no _repr_html_
    class Odd:
        pass
    obj = Odd()
    codeflash_output = HTML.applies(obj) # 2.14μs -> 1.33μs (60.4% faster)



def test_applies_object_with_module_as_list():
    # __module__ is a list
    class Odd:
        __module__ = ['pandas']
    obj = Odd()
    codeflash_output = HTML.applies(obj) # 2.76μs -> 1.59μs (73.7% faster)


def test_applies_object_with_module_as_pandas_and_name_as_dataframe_lowercase():
    # __module__ matches, but name is lowercase (should not match)
    class DummyDF:
        __module__ = 'pandas.core.frame'
        def __init__(self): pass
    DummyDF.__name__ = 'dataframe'
    df = DummyDF()
    codeflash_output = HTML.applies(df) # 2.47μs -> 1.44μs (72.0% faster)

def test_applies_object_with_module_as_pandas_and_name_as_dataframe_uppercase():
    # __module__ matches, name is 'DataFrame'
    class DummyDF:
        __module__ = 'pandas.core.frame'
        def __init__(self): pass
    DummyDF.__name__ = 'DataFrame'
    df = DummyDF()
    codeflash_output = HTML.applies(df) # 2.62μs -> 1.63μs (60.5% faster)

# --- Large Scale Test Cases ---

def test_applies_many_objects_with_repr_html():
    # Test many objects with _repr_html_
    class HasHTML:
        def _repr_html_(self): return "<b>hi</b>"
    objs = [HasHTML() for _ in range(1000)]
    for obj in objs:
        codeflash_output = HTML.applies(obj) # 528μs -> 335μs (57.2% faster)

def test_applies_many_strings():
    # Test many strings
    objs = [str(i) for i in range(1000)]
    for obj in objs:
        codeflash_output = HTML.applies(obj) # 430μs -> 188μs (128% faster)

def test_applies_many_plain_objects():
    # Test many plain objects (should all return False)
    class Plain:
        pass
    objs = [Plain() for _ in range(1000)]
    for obj in objs:
        codeflash_output = HTML.applies(obj) # 450μs -> 243μs (84.8% faster)



#------------------------------------------------
from __future__ import annotations

import param
# imports
import pytest  # used for our unit tests
from panel.pane.markup import HTML


class DummyWithReprHtml:
    def _repr_html_(self):
        return "<b>Dummy HTML</b>"

class DummyNoReprHtml:
    pass

class DummyPandasDataFrame:
    __module__ = 'pandas.core.frame'
    def __init__(self):
        pass

class DummyPandasSeries:
    __module__ = 'pandas.core.series'
    def __init__(self):
        pass

class DummyDaskDataFrame:
    __module__ = 'dask.dataframe.core'
    def __init__(self):
        pass

class DummyDaskSeries:
    __module__ = 'dask.dataframe.core'
    def __init__(self):
        pass

class DummyOtherModuleDataFrame:
    __module__ = 'othermodule'
    def __init__(self):
        pass

class DummyOtherModuleSeries:
    __module__ = 'othermodule'
    def __init__(self):
        pass
from panel.pane.markup import HTML

# unit tests

# -------------------------
# Basic Test Cases
# -------------------------

def test_applies_on_pandas_dataframe():
    # Should return 0.2 for non-Parameterized pandas DataFrame
    obj = DummyPandasDataFrame()
    obj.__class__.__name__ = 'DataFrame'
    codeflash_output = HTML.applies(obj) # 3.01μs -> 1.90μs (58.6% faster)

def test_applies_on_pandas_series():
    # Should return 0.2 for non-Parameterized pandas Series
    obj = DummyPandasSeries()
    obj.__class__.__name__ = 'Series'
    codeflash_output = HTML.applies(obj) # 2.71μs -> 1.68μs (61.3% faster)

def test_applies_on_dask_dataframe():
    # Should return 0.2 for non-Parameterized dask DataFrame
    obj = DummyDaskDataFrame()
    obj.__class__.__name__ = 'DataFrame'
    codeflash_output = HTML.applies(obj) # 2.60μs -> 1.63μs (60.0% faster)

def test_applies_on_dask_series():
    # Should return 0.2 for non-Parameterized dask Series
    obj = DummyDaskSeries()
    obj.__class__.__name__ = 'Series'
    codeflash_output = HTML.applies(obj) # 2.69μs -> 1.68μs (59.9% faster)



def test_applies_on_object_with_repr_html():
    # Should return 0.2 for object with _repr_html_ method
    obj = DummyWithReprHtml()
    codeflash_output = HTML.applies(obj) # 2.58μs -> 1.87μs (37.6% faster)


def test_applies_on_string():
    # Should return None for string input
    obj = "<h1>Hello</h1>"
    codeflash_output = HTML.applies(obj) # 1.98μs -> 983ns (101% faster)

def test_applies_on_non_html_object():
    # Should return False for object without _repr_html_ and not a pandas/dask DataFrame/Series
    obj = DummyNoReprHtml()
    codeflash_output = HTML.applies(obj) # 2.27μs -> 1.38μs (64.3% faster)

def test_applies_on_integer():
    # Should return False for integer input
    obj = 42
    codeflash_output = HTML.applies(obj) # 2.04μs -> 1.34μs (51.9% faster)

def test_applies_on_float():
    # Should return False for float input
    obj = 3.14
    codeflash_output = HTML.applies(obj) # 2.16μs -> 1.31μs (64.7% faster)

def test_applies_on_boolean():
    # Should return False for boolean input
    obj = True
    codeflash_output = HTML.applies(obj) # 2.33μs -> 1.71μs (36.7% faster)

# -------------------------
# Edge Test Cases
# -------------------------

def test_applies_on_object_with_module_pandas_but_wrong_name():
    # Should return False for object with pandas module but wrong class name
    obj = DummyPandasDataFrame()
    obj.__class__.__name__ = 'NotADataFrame'
    codeflash_output = HTML.applies(obj) # 2.51μs -> 1.39μs (81.2% faster)

def test_applies_on_object_with_module_dask_but_wrong_name():
    # Should return False for object with dask module but wrong class name
    obj = DummyDaskSeries()
    obj.__class__.__name__ = 'NotASeries'
    codeflash_output = HTML.applies(obj) # 2.45μs -> 1.55μs (58.6% faster)

def test_applies_on_object_with_wrong_module_but_right_name():
    # Should return False for object with wrong module but correct class name
    obj = DummyOtherModuleDataFrame()
    obj.__class__.__name__ = 'DataFrame'
    codeflash_output = HTML.applies(obj) # 2.00μs -> 1.28μs (56.9% faster)

def test_applies_on_object_with_wrong_module_and_wrong_name():
    # Should return False for object with wrong module and wrong class name
    obj = DummyOtherModuleSeries()
    obj.__class__.__name__ = 'NotASeries'
    codeflash_output = HTML.applies(obj) # 1.92μs -> 1.23μs (56.5% faster)

def test_applies_on_object_with_module_attribute_missing():
    # Should not error, should return False if __module__ is missing
    class NoModule:
        pass
    obj = NoModule()
    codeflash_output = HTML.applies(obj) # 2.12μs -> 1.41μs (51.2% faster)


def test_applies_on_object_with_repr_html_and_module_pandas_dataframe():
    # Should return 0.2 for object with _repr_html_ and pandas DataFrame module/name
    class Hybrid(DummyPandasDataFrame):
        def _repr_html_(self):
            return "<table></table>"
    obj = Hybrid()
    obj.__class__.__name__ = 'DataFrame'
    codeflash_output = HTML.applies(obj) # 3.08μs -> 2.17μs (42.0% faster)


def test_applies_on_empty_string():
    # Should return None for empty string
    obj = ""
    codeflash_output = HTML.applies(obj) # 1.98μs -> 1.05μs (88.1% faster)

def test_applies_on_object_with_repr_html_is_not_callable():
    # Should return 0.2 even if _repr_html_ is not callable, as hasattr is True
    class NotCallableReprHtml:
        _repr_html_ = "<b>HTML</b>"
    obj = NotCallableReprHtml()
    codeflash_output = HTML.applies(obj) # 2.50μs -> 1.84μs (36.3% faster)

def test_applies_on_object_with_repr_html_is_none():
    # Should return 0.2 even if _repr_html_ is None, as hasattr is True
    class NoneReprHtml:
        _repr_html_ = None
    obj = NoneReprHtml()
    codeflash_output = HTML.applies(obj) # 2.51μs -> 1.69μs (48.4% faster)

# -------------------------
# Large Scale Test Cases
# -------------------------






#------------------------------------------------
from panel.pane.markup import HTML
from panel.pane.plot import YT

def test_HTML_applies():
    HTML.applies(YT, 0)

def test_HTML_applies_2():
    HTML.applies(YT, '')

To edit these changes git checkout codeflash/optimize-HTML.applies-mhbtznsw and push.