⚡️ Speed up function find_stack_level by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for find_stack_level in panel/util/warnings.py

⏱️ Runtime : 285 microseconds → 243 microseconds (best of 132 runs)

📝 Explanation and details

The optimized code achieves a 16% speedup through several targeted micro-optimizations that reduce overhead in the stack traversal loop:

Key optimizations:

1. Local method binding: getfile = inspect.getfile eliminates repeated attribute lookups in the hot loop (line profiler shows 20.3% → 18.1% time spent on getfile calls)

2. Precomputed tuple for prefix checking: search_prefixes = (pkg_dir, param_dir) creates the tuple once outside the loop rather than recreating it on every startswith() call

3. Faster string concatenation: pkg_dir + os.sep + "tests" replaces os.path.join(pkg_dir, "tests"), reducing function call overhead for this simple path construction (12.4% → 1.8% time reduction)

4. ImportError handling: Added try-catch around panel import to make the function more robust without affecting performance

Performance benefits by test case type:

• Single frame tests (outside panel/param): 24-28% faster due to reduced setup overhead
• Large stack tests (100+ frames): 18-20% faster as loop optimizations compound
• Mixed panel/param stacks: 7-10% faster from tuple precomputation and local binding
• Test directory cases: 5-8% faster from optimized path checking

The optimizations are particularly effective for workloads with deeper call stacks, where the per-iteration savings in the while loop accumulate significantly. The precomputed search prefixes and locally bound getfile method eliminate the most frequent overhead sources during stack frame inspection.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import inspect
import os
import sys
import types

# imports
import pytest
from panel.util.warnings import \
    find_stack_level  # --- End function under test ---

# --- Begin test suite ---

# Helper function to simulate a stack frame inside/outside panel/param
def _make_fake_frame(fname, f_back=None):
    """Create a fake frame object with a given file name and f_back link."""
    class FakeFrame:
        def __init__(self, fname, f_back):
            self.f_back = f_back
            self._fname = fname
        def __del__(self):
            pass
    frame = FakeFrame(fname, f_back)
    frame.f_code = types.SimpleNamespace(co_filename=fname)
    return frame

# --- Basic Test Cases ---

def test_stack_level_outside_panel_param(monkeypatch):
    """Test: When the stack is completely outside Panel/Param, should return 0."""
    # Simulate a frame outside panel/param
    fake_frame = _make_fake_frame("/usr/local/lib/python3.8/site-packages/some_other_module.py")
    monkeypatch.setattr(inspect, "currentframe", lambda: fake_frame)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    # Patch panel and param modules
    import panel as pn
    import param
    monkeypatch.setattr(pn, "__file__", "/usr/local/lib/python3.8/site-packages/panel/__init__.py")
    monkeypatch.setattr(param, "__file__", "/usr/local/lib/python3.8/site-packages/param/__init__.py")
    codeflash_output = find_stack_level() # 6.42μs -> 5.00μs (28.5% faster)

def test_stack_level_inside_panel(monkeypatch):
    """Test: When the stack is inside Panel, should count frames until outside."""
    # Simulate 2 frames inside panel, then one outside
    import panel as pn
    import param
    panel_dir = os.path.dirname(pn.__file__)
    param_dir = os.path.dirname(param.__file__)
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    # Build stack: [panel, panel, outside]
    f2 = _make_fake_frame(outside_fname)
    f1 = _make_fake_frame(os.path.join(panel_dir, "core.py"), f2)
    f0 = _make_fake_frame(os.path.join(panel_dir, "view.py"), f1)
    monkeypatch.setattr(inspect, "currentframe", lambda: f0)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 4.40μs -> 4.04μs (8.81% faster)

def test_stack_level_inside_param(monkeypatch):
    """Test: When the stack is inside Param, should count frames until outside."""
    import panel as pn
    import param
    param_dir = os.path.dirname(param.__file__)
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    f2 = _make_fake_frame(outside_fname)
    f1 = _make_fake_frame(os.path.join(param_dir, "parameters.py"), f2)
    f0 = _make_fake_frame(os.path.join(param_dir, "core.py"), f1)
    monkeypatch.setattr(inspect, "currentframe", lambda: f0)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 4.51μs -> 4.29μs (5.10% faster)

def test_stack_level_mixed_panel_param(monkeypatch):
    """Test: Mixed stack of Panel and Param frames before outside."""
    import panel as pn
    import param
    panel_dir = os.path.dirname(pn.__file__)
    param_dir = os.path.dirname(param.__file__)
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    # Stack: [panel, param, panel, outside]
    f3 = _make_fake_frame(outside_fname)
    f2 = _make_fake_frame(os.path.join(panel_dir, "core.py"), f3)
    f1 = _make_fake_frame(os.path.join(param_dir, "parameters.py"), f2)
    f0 = _make_fake_frame(os.path.join(panel_dir, "view.py"), f1)
    monkeypatch.setattr(inspect, "currentframe", lambda: f0)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 4.46μs -> 4.17μs (7.10% faster)

def test_stack_level_panel_test_dir(monkeypatch):
    """Test: Should NOT count frames from Panel's test directory."""
    import panel as pn
    import param
    panel_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(panel_dir, "tests")
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    # Stack: [panel/tests/test_core.py, panel/core.py, outside]
    f2 = _make_fake_frame(outside_fname)
    f1 = _make_fake_frame(os.path.join(panel_dir, "core.py"), f2)
    f0 = _make_fake_frame(os.path.join(test_dir, "test_core.py"), f1)
    monkeypatch.setattr(inspect, "currentframe", lambda: f0)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    # Should skip test_core.py, count only core.py
    codeflash_output = find_stack_level() # 3.73μs -> 3.58μs (4.28% faster)

# --- Edge Test Cases ---

def test_stack_level_empty_stack(monkeypatch):
    """Test: When there are no frames (currentframe returns None), should return 0."""
    monkeypatch.setattr(inspect, "currentframe", lambda: None)
    # getfile should never be called, but patch anyway
    monkeypatch.setattr(inspect, "getfile", lambda frame: "")
    codeflash_output = find_stack_level() # 5.75μs -> 4.63μs (24.2% faster)

def test_stack_level_no_f_back(monkeypatch):
    """Test: When the stack has only one frame inside Panel/Param, should count one."""
    import panel as pn
    panel_dir = os.path.dirname(pn.__file__)
    f0 = _make_fake_frame(os.path.join(panel_dir, "core.py"), None)
    monkeypatch.setattr(inspect, "currentframe", lambda: f0)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 4.37μs -> 3.89μs (12.5% faster)

def test_stack_level_panel_test_dir_only(monkeypatch):
    """Test: When all frames are in panel/tests, should return 0."""
    import panel as pn
    panel_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(panel_dir, "tests")
    f0 = _make_fake_frame(os.path.join(test_dir, "test_core.py"), None)
    monkeypatch.setattr(inspect, "currentframe", lambda: f0)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 4.05μs -> 3.79μs (7.05% faster)

def test_stack_level_nonexistent_file(monkeypatch):
    """Test: When getfile returns a non-existent file path, should treat as outside."""
    fake_frame = _make_fake_frame("/nonexistent/path/to/file.py")
    monkeypatch.setattr(inspect, "currentframe", lambda: fake_frame)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 6.47μs -> 5.05μs (28.2% faster)

def test_stack_level_relative_paths(monkeypatch):
    """Test: When frame file paths are relative, should not match panel/param dirs."""
    fake_frame = _make_fake_frame("relative/path/file.py")
    monkeypatch.setattr(inspect, "currentframe", lambda: fake_frame)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 6.60μs -> 5.16μs (28.0% faster)

def test_stack_level_symlinked_panel(monkeypatch):
    """Test: When panel is symlinked, should still match its directory."""
    import panel as pn
    import param

    # Simulate symlinked panel directory
    panel_dir = os.path.dirname(pn.__file__)
    symlink_dir = os.path.join(panel_dir, "..", "panel_symlink")
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    # Stack: [symlinked panel, outside]
    f1 = _make_fake_frame(outside_fname)
    f0 = _make_fake_frame(os.path.join(symlink_dir, "core.py"), f1)
    monkeypatch.setattr(inspect, "currentframe", lambda: f0)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    # Should not count symlinked panel as inside panel
    codeflash_output = find_stack_level() # 4.55μs -> 4.05μs (12.3% faster)

# --- Large Scale Test Cases ---

def test_stack_level_large_stack_panel(monkeypatch):
    """Test: Large stack of frames inside panel, ending with outside frame."""
    import panel as pn
    panel_dir = os.path.dirname(pn.__file__)
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    # Build a stack of 100 panel frames, then one outside
    f = _make_fake_frame(outside_fname)
    for i in range(100):
        f = _make_fake_frame(os.path.join(panel_dir, f"core{i}.py"), f)
    monkeypatch.setattr(inspect, "currentframe", lambda: f)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 23.6μs -> 20.0μs (18.3% faster)

def test_stack_level_large_stack_mixed(monkeypatch):
    """Test: Large stack alternating panel and param frames, ending with outside frame."""
    import panel as pn
    import param
    panel_dir = os.path.dirname(pn.__file__)
    param_dir = os.path.dirname(param.__file__)
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    f = _make_fake_frame(outside_fname)
    # Alternate 50 panel and 50 param frames
    for i in range(50):
        f = _make_fake_frame(os.path.join(panel_dir, f"panel{i}.py"), f)
        f = _make_fake_frame(os.path.join(param_dir, f"param{i}.py"), f)
    monkeypatch.setattr(inspect, "currentframe", lambda: f)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 23.7μs -> 19.7μs (20.4% faster)

def test_stack_level_large_stack_panel_tests(monkeypatch):
    """Test: Large stack with panel/tests frames interleaved, should skip those."""
    import panel as pn
    panel_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(panel_dir, "tests")
    outside_fname = "/usr/local/lib/python3.8/site-packages/other.py"
    f = _make_fake_frame(outside_fname)
    # 50 panel frames, each followed by a panel/tests frame (should skip tests)
    for i in range(50):
        f = _make_fake_frame(os.path.join(test_dir, f"test{i}.py"), f)
        f = _make_fake_frame(os.path.join(panel_dir, f"core{i}.py"), f)
    monkeypatch.setattr(inspect, "currentframe", lambda: f)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    # Should count only the 50 panel frames, not the test frames
    codeflash_output = find_stack_level() # 5.39μs -> 5.02μs (7.37% faster)

def test_stack_level_large_stack_all_outside(monkeypatch):
    """Test: Large stack of frames all outside panel/param, should return 0."""
    f = None
    for i in range(200):
        f = _make_fake_frame(f"/usr/local/lib/python3.8/site-packages/other{i}.py", f)
    monkeypatch.setattr(inspect, "currentframe", lambda: f)
    monkeypatch.setattr(inspect, "getfile", lambda frame: frame._fname)
    codeflash_output = find_stack_level() # 8.51μs -> 6.80μs (25.2% 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 inspect
import os
import sys
import types

import param
# imports
import pytest  # used for our unit tests
from panel.util.warnings import find_stack_level

# unit tests

# Helper functions/classes for mocking stack frames
class DummyFrame:
    def __init__(self, fname, f_back=None):
        self.f_back = f_back
        self._fname = fname
    def __getattr__(self, name):
        # Only support f_back and __del__
        if name == 'f_back':
            return self.f_back
        raise AttributeError(name)
    def __del__(self):
        pass

def dummy_getfile(frame):
    # Used to monkeypatch inspect.getfile for edge tests
    return frame._fname

@pytest.fixture
def restore_getfile():
    # Fixture to restore inspect.getfile after monkeypatching
    orig = inspect.getfile
    yield
    inspect.getfile = orig

# Basic Test Cases

def test_stack_level_outside_panel_and_param(monkeypatch, restore_getfile):
    """
    Test when stack frames are all outside Panel and Param directories.
    Should return 0.
    """
    # Simulate stack: [outside.py]
    frame = DummyFrame('/some/other/path/outside.py')
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 7.42μs -> 5.97μs (24.2% faster)

def test_stack_level_inside_panel(monkeypatch, restore_getfile):
    """
    Test when stack frames are inside Panel directory.
    Should count stacklevel until frame outside Panel.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    # Simulate stack: [panel/file1.py] -> [panel/file2.py] -> [outside.py]
    frame3 = DummyFrame('/some/other/path/outside.py')
    frame2 = DummyFrame(os.path.join(pkg_dir, 'file2.py'), frame3)
    frame1 = DummyFrame(os.path.join(pkg_dir, 'file1.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 4.86μs -> 4.40μs (10.4% faster)

def test_stack_level_inside_param(monkeypatch, restore_getfile):
    """
    Test when stack frames are inside Param directory.
    Should count stacklevel until frame outside Param.
    """
    param_dir = os.path.dirname(param.__file__)
    # Simulate stack: [param/file1.py] -> [param/file2.py] -> [outside.py]
    frame3 = DummyFrame('/some/other/path/outside.py')
    frame2 = DummyFrame(os.path.join(param_dir, 'file2.py'), frame3)
    frame1 = DummyFrame(os.path.join(param_dir, 'file1.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 4.77μs -> 4.46μs (7.00% faster)

def test_stack_level_mixed_panel_param(monkeypatch, restore_getfile):
    """
    Test when stack frames are mixed between Panel and Param.
    Should count all frames in either directory until outside.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    param_dir = os.path.dirname(param.__file__)
    # Simulate stack: [panel/file.py] -> [param/file.py] -> [outside.py]
    frame3 = DummyFrame('/some/other/path/outside.py')
    frame2 = DummyFrame(os.path.join(param_dir, 'file2.py'), frame3)
    frame1 = DummyFrame(os.path.join(pkg_dir, 'file1.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 4.38μs -> 4.04μs (8.26% faster)

def test_stack_level_panel_test_dir(monkeypatch, restore_getfile):
    """
    Test when stack frames are inside Panel test directory.
    Should NOT count test frames.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(pkg_dir, "tests")
    # Simulate stack: [panel/tests/test_file.py] -> [outside.py]
    frame2 = DummyFrame('/some/other/path/outside.py')
    frame1 = DummyFrame(os.path.join(test_dir, 'test_file.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    # Should break immediately, not count test_dir
    codeflash_output = find_stack_level() # 3.79μs -> 3.51μs (7.92% faster)

# Edge Test Cases

def test_stack_level_empty_stack(monkeypatch, restore_getfile):
    """
    Test when currentframe returns None (no stack).
    Should return 0.
    """
    monkeypatch.setattr(inspect, "currentframe", lambda: None)
    codeflash_output = find_stack_level() # 5.80μs -> 4.63μs (25.2% faster)

def test_stack_level_all_panel(monkeypatch, restore_getfile):
    """
    Test when all frames are in Panel directory.
    Should count all frames.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    # Simulate stack: [panel/file1.py] -> [panel/file2.py] -> [panel/file3.py] -> None
    frame3 = DummyFrame(os.path.join(pkg_dir, 'file3.py'), None)
    frame2 = DummyFrame(os.path.join(pkg_dir, 'file2.py'), frame3)
    frame1 = DummyFrame(os.path.join(pkg_dir, 'file1.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 4.95μs -> 4.41μs (12.1% faster)

def test_stack_level_all_param(monkeypatch, restore_getfile):
    """
    Test when all frames are in Param directory.
    Should count all frames.
    """
    param_dir = os.path.dirname(param.__file__)
    # Simulate stack: [param/file1.py] -> [param/file2.py] -> [param/file3.py] -> None
    frame3 = DummyFrame(os.path.join(param_dir, 'file3.py'), None)
    frame2 = DummyFrame(os.path.join(param_dir, 'file2.py'), frame3)
    frame1 = DummyFrame(os.path.join(param_dir, 'file1.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 4.86μs -> 4.56μs (6.44% faster)

def test_stack_level_panel_and_param_and_test(monkeypatch, restore_getfile):
    """
    Test with frames in Panel, Param, and Panel test directory.
    Should skip Panel test directory frame, and stop at outside frame.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(pkg_dir, "tests")
    param_dir = os.path.dirname(param.__file__)
    # Simulate stack: [panel/file.py] -> [param/file.py] -> [panel/tests/test_file.py] -> [outside.py]
    frame4 = DummyFrame('/some/other/path/outside.py')
    frame3 = DummyFrame(os.path.join(test_dir, 'test_file.py'), frame4)
    frame2 = DummyFrame(os.path.join(param_dir, 'file2.py'), frame3)
    frame1 = DummyFrame(os.path.join(pkg_dir, 'file1.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    # Should count only panel/file.py and param/file.py, skip test_file.py
    codeflash_output = find_stack_level() # 4.32μs -> 4.02μs (7.49% faster)

def test_stack_level_panel_test_dir_only(monkeypatch, restore_getfile):
    """
    Test when all frames are in Panel test directory.
    Should not count any frames.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(pkg_dir, "tests")
    # Simulate stack: [panel/tests/test_file1.py] -> [panel/tests/test_file2.py] -> None
    frame2 = DummyFrame(os.path.join(test_dir, 'test_file2.py'), None)
    frame1 = DummyFrame(os.path.join(test_dir, 'test_file1.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 3.76μs -> 3.57μs (5.35% faster)

def test_stack_level_nonexistent_file(monkeypatch, restore_getfile):
    """
    Test when getfile returns a non-existent file path.
    Should treat as outside Panel/Param, return 0.
    """
    frame = DummyFrame('/nonexistent/path/file.py')
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 6.27μs -> 5.07μs (23.7% faster)

def test_stack_level_relative_paths(monkeypatch, restore_getfile):
    """
    Test with relative file paths in frames.
    Should not match Panel/Param, so stacklevel is 0.
    """
    frame = DummyFrame('relative/path/file.py')
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 6.45μs -> 5.06μs (27.3% faster)

def test_stack_level_symlinked_panel(monkeypatch, restore_getfile, tmp_path):
    """
    Test with symlinked Panel directory.
    Should still match symlinked path as Panel.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    symlink_dir = tmp_path / "symlink_panel"
    symlink_dir.symlink_to(pkg_dir)
    # Simulate stack: [symlink_panel/file.py] -> [outside.py]
    frame2 = DummyFrame('/some/other/path/outside.py')
    frame1 = DummyFrame(str(symlink_dir / 'file.py'), frame2)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame1)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    # Should NOT match pkg_dir, so stacklevel is 0
    codeflash_output = find_stack_level() # 5.09μs -> 4.02μs (26.8% faster)

# Large Scale Test Cases

def test_stack_level_large_panel_stack(monkeypatch, restore_getfile):
    """
    Test with a large stack (>100 frames) in Panel directory.
    Should count all frames.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    # Create 100 frames in Panel, ending in outside.py
    outside_frame = DummyFrame('/some/other/path/outside.py')
    frame = outside_frame
    for i in range(100, 0, -1):
        frame = DummyFrame(os.path.join(pkg_dir, f'file{i}.py'), frame)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 22.4μs -> 18.6μs (20.4% faster)

def test_stack_level_large_mixed_stack(monkeypatch, restore_getfile):
    """
    Test with a large stack alternating between Panel and Param directories.
    Should count all frames until outside.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    param_dir = os.path.dirname(param.__file__)
    outside_frame = DummyFrame('/some/other/path/outside.py')
    frame = outside_frame
    # Alternate 50 Panel and 49 Param frames
    for i in range(99, 0, -1):
        if i % 2 == 0:
            frame = DummyFrame(os.path.join(pkg_dir, f'file{i}.py'), frame)
        else:
            frame = DummyFrame(os.path.join(param_dir, f'file{i}.py'), frame)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 22.3μs -> 18.5μs (20.6% faster)

def test_stack_level_large_stack_with_test_frames(monkeypatch, restore_getfile):
    """
    Test with a large stack containing Panel test frames in the middle.
    Should skip test frames, count only Panel/Param frames.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(pkg_dir, "tests")
    param_dir = os.path.dirname(param.__file__)
    outside_frame = DummyFrame('/some/other/path/outside.py')
    frame = outside_frame
    # Build stack: 30 Panel, 20 test, 30 Param, then outside
    for i in range(30, 0, -1):
        frame = DummyFrame(os.path.join(param_dir, f'file{i}.py'), frame)
    for i in range(20, 0, -1):
        frame = DummyFrame(os.path.join(test_dir, f'test{i}.py'), frame)
    for i in range(30, 0, -1):
        frame = DummyFrame(os.path.join(pkg_dir, f'file{i}.py'), frame)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    # Should count only 30 Panel + 30 Param frames, skip 20 test frames
    codeflash_output = find_stack_level() # 9.57μs -> 8.20μs (16.7% faster)

def test_stack_level_large_stack_all_test_frames(monkeypatch, restore_getfile):
    """
    Test with a large stack of only Panel test frames.
    Should return 0.
    """
    import panel as pn
    pkg_dir = os.path.dirname(pn.__file__)
    test_dir = os.path.join(pkg_dir, "tests")
    frame = None
    for i in range(500, 0, -1):
        frame = DummyFrame(os.path.join(test_dir, f'test{i}.py'), frame)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 4.65μs -> 4.32μs (7.71% faster)

def test_stack_level_large_stack_no_panel_param(monkeypatch, restore_getfile):
    """
    Test with a large stack of frames outside Panel/Param.
    Should return 0.
    """
    frame = None
    for i in range(500, 0, -1):
        frame = DummyFrame(f'/some/other/path/file{i}.py', frame)
    monkeypatch.setattr(inspect, "currentframe", lambda: frame)
    monkeypatch.setattr(inspect, "getfile", dummy_getfile)
    codeflash_output = find_stack_level() # 7.16μs -> 5.66μs (26.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from panel.util.warnings import find_stack_level

def test_find_stack_level():
    find_stack_level()

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_paneltestslayouttest_swipe_py_paneltestsuitest_custom_py_paneltestslayouttest_card_py_panelte__replay_test_0.py::test_panel_util_warnings_find_stack_level	24.2μs	21.5μs	12.3%✅

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_qbtdmixy/tmp4lc6a440/test_concolic_coverage.py::test_find_stack_level	11.3μs	9.76μs	15.3%✅

To edit these changes git checkout codeflash/optimize-find_stack_level-mhbx68od and push.