⚡️ Speed up function in_denylist by 58%

[codeflash-ai]

📄 58% (0.58x) speedup for in_denylist in panel/io/reload.py

⏱️ Runtime : 152 milliseconds → 95.9 milliseconds (best of 30 runs)

📝 Explanation and details

The optimization achieves a 58% speedup by eliminating function call overhead and avoiding redundant computations in the in_denylist function.

Key optimizations:

1. Eliminated function calls: The original code called file_is_in_folder_glob() for each denylist pattern (up to 13 calls per filepath). The optimized version inlines this logic directly in the loop, removing function call overhead.

2. Moved directory computation outside the loop: os.path.dirname(filepath) + "/" is now computed once at the start rather than being recalculated for every denylist pattern. From the line profiler, this operation took 247ms in the original (41% of time) but only 27ms in the optimized version (6.4% of time).

3. Early termination: Changed from any() generator expression to explicit loop with early return True, allowing the function to exit immediately upon finding the first match instead of potentially evaluating all patterns.

Performance impact by test type:

• Single file checks: 40-65% faster across all test cases
• Large-scale tests: 35-70% faster, with the biggest gains on non-denylisted files that previously had to check all 13 patterns
• Hidden folder matches: 18-27% faster (smaller improvement since these match early in the denylist)

The optimization is most effective for files that either don't match any denylist pattern (forcing evaluation of all 13 patterns in the original) or match patterns later in the denylist, as the early termination provides maximum benefit.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
io/test_reload.py::test_file_in_denylist	45.1μs	32.4μs	39.2%✅

🌀 Generated Regression Tests and Runtime

import fnmatch
import os

# imports
import pytest  # used for our unit tests
from panel.io.reload import in_denylist

DEFAULT_FOLDER_DENYLIST = [
    "**/.*",
    "**/anaconda",
    "**/anaconda2",
    "**/anaconda3",
    "**/dist-packages",
    "**/miniconda",
    "**/miniconda2",
    "**/miniconda3",
    "**/node_modules",
    "**/pyenv",
    "**/site-packages",
    "**/venv",
    "**/virtualenv",
]
from panel.io.reload import in_denylist

# unit tests

# ----------- Basic Test Cases -----------
def test_basic_non_denylist_file():
    # File in a regular folder should not be denylisted
    codeflash_output = not in_denylist("src/main.py") # 22.6μs -> 15.3μs (47.8% faster)
    codeflash_output = not in_denylist("docs/readme.md") # 14.3μs -> 8.78μs (62.4% faster)

def test_basic_denylist_file():
    # File inside denylisted folders should be denylisted
    codeflash_output = in_denylist("project/venv/foo.py") # 22.1μs -> 14.9μs (48.6% faster)
    codeflash_output = in_denylist("node_modules/bar.js") # 15.8μs -> 10.1μs (56.7% faster)
    codeflash_output = in_denylist("anaconda3/bin/python") # 15.3μs -> 9.72μs (57.6% faster)
    codeflash_output = in_denylist("myenv/virtualenv/lib.py") # 16.3μs -> 10.4μs (57.1% faster)
    codeflash_output = in_denylist("site-packages/module.py") # 15.3μs -> 9.82μs (56.1% faster)
    codeflash_output = in_denylist("dist-packages/module.py") # 15.2μs -> 9.51μs (60.3% faster)
    codeflash_output = in_denylist("pyenv/bin/python") # 14.2μs -> 8.60μs (65.2% faster)

def test_basic_hidden_folder():
    # Files inside hidden folders (starting with .) should be denylisted
    codeflash_output = in_denylist(".git/config") # 19.7μs -> 13.0μs (51.9% faster)
    codeflash_output = in_denylist("foo/.hidden/file.txt") # 2.86μs -> 2.39μs (19.7% faster)
    codeflash_output = in_denylist("bar/baz/.anotherhidden/file.txt") # 1.94μs -> 1.60μs (21.0% faster)

def test_basic_subfolder_in_denylist():
    # Files in subfolders of denylisted folders should also be denylisted
    codeflash_output = in_denylist("venv/lib/python3.8/site.py") # 22.4μs -> 15.8μs (41.8% faster)
    codeflash_output = in_denylist("node_modules/foo/bar.js") # 16.6μs -> 10.5μs (57.2% faster)
    codeflash_output = in_denylist("anaconda2/lib/python2.7/site.py") # 16.6μs -> 10.7μs (55.7% faster)
    codeflash_output = in_denylist("miniconda3/envs/env1/bin/python") # 16.5μs -> 10.8μs (53.5% faster)

def test_basic_relative_paths():
    # Relative paths should work as expected
    codeflash_output = in_denylist("./venv/lib.py") # 20.3μs -> 13.4μs (51.3% faster)
    codeflash_output = in_denylist("../node_modules/foo.js") # 12.5μs -> 8.27μs (50.8% faster)
    codeflash_output = not in_denylist("../src/main.py") # 14.4μs -> 8.79μs (63.8% faster)

# ----------- Edge Test Cases -----------
def test_edge_empty_string():
    # Empty string should not match any denylist
    codeflash_output = not in_denylist("") # 17.5μs -> 12.0μs (45.5% faster)

def test_edge_root_folder():
    # Files at the root should not be denylisted unless root is denylisted
    codeflash_output = not in_denylist("/main.py") # 18.9μs -> 13.1μs (44.5% faster)
    codeflash_output = not in_denylist("main.py") # 12.5μs -> 8.37μs (49.2% faster)

def test_edge_folder_name_substring():
    # Folders with similar names should not be denylisted
    codeflash_output = not in_denylist("venv2/foo.py") # 19.9μs -> 13.2μs (51.0% faster)
    codeflash_output = not in_denylist("node_module/foo.js") # 16.1μs -> 10.3μs (57.3% faster)
    codeflash_output = not in_denylist("anacondas/bin/python") # 15.4μs -> 9.71μs (58.4% faster)
    codeflash_output = not in_denylist("minicondas/envs/env1/bin/python") # 16.9μs -> 10.8μs (56.6% faster)
    codeflash_output = not in_denylist("dist-package/module.py") # 15.4μs -> 9.45μs (62.8% faster)
    codeflash_output = not in_denylist("site-package/module.py") # 15.2μs -> 9.28μs (63.5% faster)

def test_edge_file_in_hidden_file():
    # File named with a dot but not in a hidden folder should not be denylisted
    codeflash_output = not in_denylist("foo/.bar.py") # 20.0μs -> 13.0μs (53.7% faster)
    codeflash_output = not in_denylist("foo.bar/baz.py") # 14.6μs -> 9.01μs (62.2% faster)

def test_edge_folder_with_dot_in_name():
    # Folders with a dot in their name but not starting with dot should not be denylisted
    codeflash_output = not in_denylist("foo.bar/baz.py") # 19.9μs -> 13.2μs (50.1% faster)
    codeflash_output = not in_denylist("foo/.barbaz/file.txt") # 3.14μs -> 2.46μs (27.7% faster)

def test_edge_trailing_slash_in_path():
    # File paths with trailing slashes should be handled
    codeflash_output = in_denylist("venv/lib/") # 20.0μs -> 13.3μs (50.9% faster)
    codeflash_output = not in_denylist("src/lib/") # 14.2μs -> 8.94μs (58.6% faster)

def test_edge_file_in_multiple_denylist_folders():
    # File nested in multiple denylisted folders should be denylisted
    codeflash_output = in_denylist("venv/node_modules/foo.js") # 18.4μs -> 12.7μs (44.8% faster)
    codeflash_output = in_denylist("anaconda3/.git/config") # 2.45μs -> 2.06μs (18.7% faster)
    codeflash_output = in_denylist("site-packages/venv/lib.py") # 15.6μs -> 9.93μs (56.8% faster)

def test_edge_case_sensitive():
    # Denylist is case sensitive
    codeflash_output = not in_denylist("VENV/foo.py") # 20.2μs -> 13.0μs (55.0% faster)
    codeflash_output = not in_denylist("Node_Modules/bar.js") # 16.0μs -> 10.1μs (57.8% faster)
    codeflash_output = not in_denylist("Anaconda3/bin/python") # 15.4μs -> 9.69μs (58.9% faster)

def test_edge_dotfile_in_root():
    # Dotfiles in root are not considered to be in a denylisted folder
    codeflash_output = not in_denylist(".bashrc") # 17.7μs -> 12.0μs (47.4% faster)
    codeflash_output = not in_denylist(".vimrc") # 12.3μs -> 8.27μs (48.5% faster)

def test_edge_file_in_folder_named_dot():
    # Folder named '.' is not denylisted unless it's a hidden folder
    codeflash_output = not in_denylist("./main.py") # 19.4μs -> 13.1μs (48.6% faster)

def test_edge_file_in_folder_with_hidden_subfolder():
    # File inside a hidden subfolder is denylisted
    codeflash_output = in_denylist("foo/.hidden/bar.py") # 7.18μs -> 5.80μs (23.8% faster)
    codeflash_output = in_denylist("foo/bar/.baz/qux.py") # 2.51μs -> 2.00μs (25.1% faster)

def test_edge_file_in_folder_with_dot_and_hidden_folder():
    # File in folder with dot AND inside a hidden folder
    codeflash_output = in_denylist("foo.bar/.hidden/file.txt") # 6.71μs -> 5.37μs (25.1% faster)

# ----------- Large Scale Test Cases -----------
def test_large_scale_many_files_in_denylist():
    # Test many files in denylisted folders
    for i in range(500):
        codeflash_output = in_denylist(f"project/venv/lib{i}.py") # 6.90ms -> 4.30ms (60.7% faster)
        codeflash_output = in_denylist(f"node_modules/lib{i}.js")
        codeflash_output = in_denylist(f"site-packages/module{i}.py") # 7.40ms -> 4.57ms (61.9% faster)
        codeflash_output = in_denylist(f".hidden_folder/file{i}.txt")

def test_large_scale_many_files_not_in_denylist():
    # Test many files NOT in denylisted folders
    for i in range(500):
        codeflash_output = not in_denylist(f"src/lib{i}.py") # 6.80ms -> 3.98ms (70.7% faster)
        codeflash_output = not in_denylist(f"docs/file{i}.md")
        codeflash_output = not in_denylist(f"myenv2/module{i}.py") # 6.77ms -> 3.98ms (69.9% faster)
        codeflash_output = not in_denylist(f"public/file{i}.txt")

def test_large_scale_mixed_files():
    # Mix of denylisted and non-denylisted files
    for i in range(250):
        codeflash_output = in_denylist(f"venv/lib{i}.py") # 3.43ms -> 2.03ms (68.9% faster)
        codeflash_output = not in_denylist(f"venv2/lib{i}.py")
        codeflash_output = in_denylist(f"node_modules/lib{i}.js") # 3.41ms -> 2.03ms (68.1% faster)
        codeflash_output = not in_denylist(f"node_module/lib{i}.js")
        codeflash_output = in_denylist(f".hidden_folder/file{i}.txt") # 3.71ms -> 2.29ms (61.7% faster)
        codeflash_output = not in_denylist(f"visible_folder/file{i}.txt")

def test_large_scale_deeply_nested_denylist():
    # Deeply nested denylisted folders
    for i in range(100):
        path = f"project/venv/node_modules/site-packages/.hidden_folder/file{i}.py"
        codeflash_output = in_denylist(path) # 197μs -> 171μs (15.3% faster)
        path2 = f"project/src/lib{i}.py"
        codeflash_output = not in_denylist(path2)

def test_large_scale_varied_folder_names():
    # Varied folder names, some similar to denylist but not matching
    for i in range(100):
        codeflash_output = not in_denylist(f"venv_backup/lib{i}.py") # 1.48ms -> 922μs (60.3% faster)
        codeflash_output = not in_denylist(f"node_modules_backup/lib{i}.js")
        codeflash_output = not in_denylist(f"site-packages2/module{i}.py") # 1.58ms -> 1.01ms (56.1% faster)
        codeflash_output = not in_denylist(f".hiddenfolder/file{i}.txt")  # Not hidden (no slash after dot)

def test_large_scale_hidden_folder_variations():
    # Test files in folders starting with dot and other variations
    for i in range(100):
        codeflash_output = in_denylist(f"foo/.hidden/file{i}.txt") # 160μs -> 133μs (20.6% faster)
        codeflash_output = in_denylist(f"bar/baz/.anotherhidden/file{i}.txt")
        codeflash_output = not in_denylist(f"foo/.hiddenfolder/file{i}.txt") # 163μs -> 137μs (18.9% faster)

# ----------- Mutation Testing: Catching Implementation Bugs -----------
def test_mutation_denylist_folder_substring_bug():
    # Ensure substring matches do not trigger denylist
    codeflash_output = not in_denylist("venv2/foo.py") # 21.3μs -> 13.9μs (53.3% faster)
    codeflash_output = not in_denylist("node_module/foo.js") # 15.9μs -> 10.3μs (53.5% faster)
    codeflash_output = not in_denylist("site-packages2/module.py") # 15.8μs -> 10.2μs (55.1% faster)
    codeflash_output = not in_denylist("virtualenvs/foo.py") # 15.1μs -> 9.41μs (60.8% faster)
    codeflash_output = not in_denylist("miniconda_backup/foo.py") # 15.9μs -> 10.1μs (57.8% faster)

def test_mutation_hidden_folder_bug():
    # Only folders starting with '.' should be denylisted, not files
    codeflash_output = not in_denylist("foo/.bar.py") # 19.8μs -> 12.9μs (52.8% faster)
    codeflash_output = not in_denylist("foo.bar/baz.py") # 14.6μs -> 9.24μs (57.7% faster)
    codeflash_output = not in_denylist("foo/.barbaz/file.txt") # 2.80μs -> 2.07μs (34.9% faster)

def test_mutation_trailing_slash_bug():
    # File paths with trailing slashes should be handled correctly
    codeflash_output = in_denylist("venv/lib/") # 19.9μs -> 13.6μs (47.0% faster)
    codeflash_output = not in_denylist("src/lib/") # 14.3μs -> 8.85μs (61.5% faster)

def test_mutation_case_sensitivity_bug():
    # Denylist is case sensitive
    codeflash_output = not in_denylist("VENV/foo.py") # 19.8μs -> 12.9μs (53.1% faster)
    codeflash_output = not in_denylist("Node_Modules/bar.js") # 16.0μs -> 10.4μs (53.8% faster)
    codeflash_output = not in_denylist("Anaconda3/bin/python") # 15.6μs -> 9.83μs (58.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import fnmatch
import os

# imports
import pytest  # used for our unit tests
from panel.io.reload import in_denylist

DEFAULT_FOLDER_DENYLIST = [
    "**/.*",
    "**/anaconda",
    "**/anaconda2",
    "**/anaconda3",
    "**/dist-packages",
    "**/miniconda",
    "**/miniconda2",
    "**/miniconda3",
    "**/node_modules",
    "**/pyenv",
    "**/site-packages",
    "**/venv",
    "**/virtualenv",
]
from panel.io.reload import in_denylist

# unit tests

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

def test_basic_denylist_match_anaconda():
    # File inside anaconda directory should be denied
    codeflash_output = in_denylist("/home/user/anaconda/file.py") # 9.16μs -> 7.09μs (29.2% faster)

def test_basic_denylist_match_node_modules():
    # File inside node_modules directory should be denied
    codeflash_output = in_denylist("/project/node_modules/module.js") # 18.9μs -> 13.5μs (39.5% faster)

def test_basic_denylist_match_venv():
    # File inside venv directory should be denied
    codeflash_output = in_denylist("/home/user/project/venv/main.py") # 22.8μs -> 16.0μs (42.2% faster)

def test_basic_not_in_denylist():
    # File not in any denylisted folder should not be denied
    codeflash_output = in_denylist("/home/user/project/src/main.py") # 23.5μs -> 16.1μs (46.4% faster)

def test_basic_denylist_hidden_folder():
    # File inside a hidden folder should be denied
    codeflash_output = in_denylist("/home/user/.hidden/file.txt") # 7.05μs -> 5.73μs (23.1% faster)

def test_basic_denylist_site_packages():
    # File inside site-packages should be denied
    codeflash_output = in_denylist("/usr/lib/python3.8/site-packages/somepkg/__init__.py") # 23.7μs -> 16.9μs (40.4% faster)

def test_basic_denylist_dist_packages():
    # File inside dist-packages should be denied
    codeflash_output = in_denylist("/usr/lib/python3.8/dist-packages/somepkg/__init__.py") # 14.6μs -> 10.8μs (35.5% faster)

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

def test_edge_file_in_root():
    # File in root directory should not be denied unless root is denylisted
    codeflash_output = in_denylist("/file_in_root.txt") # 19.6μs -> 13.5μs (45.0% faster)

def test_edge_file_in_hidden_subfolder():
    # File inside a subfolder of a hidden folder should be denied
    codeflash_output = in_denylist("/home/user/.hidden/subfolder/file.txt") # 7.45μs -> 6.03μs (23.6% faster)

def test_edge_file_with_similar_name_not_denylisted():
    # File in a folder named "anacondas" (not exactly "anaconda") should not be denied
    codeflash_output = in_denylist("/home/user/anacondas/file.py") # 24.1μs -> 16.6μs (44.8% faster)

def test_edge_file_in_partial_match_folder():
    # File in a folder named "anaconda_backup" should not be denied
    codeflash_output = in_denylist("/home/user/anaconda_backup/file.py") # 23.8μs -> 16.7μs (43.1% faster)

def test_edge_file_in_folder_with_dot_in_name():
    # File in a folder named "project.folder" should not be denied unless it starts with a dot
    codeflash_output = in_denylist("/home/user/project.folder/file.py") # 23.3μs -> 16.8μs (38.7% faster)

def test_edge_file_in_dot_folder():
    # File in a folder named ".venv" (hidden venv) should be denied because of "**/.*"
    codeflash_output = in_denylist("/home/user/.venv/file.py") # 7.30μs -> 5.75μs (26.8% faster)

def test_edge_file_in_deeply_nested_denylisted_folder():
    # File deeply nested inside a denylisted folder should be denied
    codeflash_output = in_denylist("/a/b/c/d/e/f/g/anaconda/file.txt") # 9.57μs -> 7.52μs (27.3% faster)

def test_edge_file_in_folder_with_similar_prefix():
    # File in a folder named "minicondabeta" should not be denied
    codeflash_output = in_denylist("/home/user/minicondabeta/file.py") # 24.0μs -> 17.1μs (40.0% faster)

def test_edge_file_in_folder_with_trailing_slash():
    # File in folder with trailing slash in path
    codeflash_output = in_denylist("/home/user/anaconda//file.py") # 9.48μs -> 7.42μs (27.6% faster)

def test_edge_file_in_folder_with_multiple_dots():
    # File in folder named ".hidden.folder" should be denied because of "**/.*"
    codeflash_output = in_denylist("/home/user/.hidden.folder/file.txt") # 7.08μs -> 5.71μs (23.9% faster)

def test_edge_file_in_folder_named_dot():
    # File in folder named "." should be denied because of "**/.*"
    codeflash_output = in_denylist("/home/user/./file.txt") # 7.08μs -> 5.68μs (24.5% faster)

def test_edge_file_in_folder_named_dotdot():
    # File in folder named ".." should be denied because of "**/.*"
    codeflash_output = in_denylist("/home/user/../file.txt") # 7.13μs -> 5.76μs (23.7% faster)

def test_edge_file_in_pyenv():
    # File in pyenv folder should be denied
    codeflash_output = in_denylist("/home/user/.pyenv/bin/python") # 7.20μs -> 5.75μs (25.2% faster)

def test_edge_file_in_virtualenv():
    # File in virtualenv folder should be denied
    codeflash_output = in_denylist("/home/user/virtualenv/bin/activate") # 25.1μs -> 17.5μs (43.6% faster)

def test_edge_file_in_miniconda3():
    # File in miniconda3 folder should be denied
    codeflash_output = in_denylist("/opt/miniconda3/bin/python") # 17.6μs -> 12.9μs (37.0% faster)

def test_edge_file_with_no_directory():
    # File with no directory (just filename) should not be denied
    codeflash_output = in_denylist("main.py") # 17.5μs -> 12.3μs (42.4% faster)

def test_edge_file_in_folder_with_space():
    # File in folder with space in name, not denylisted
    codeflash_output = in_denylist("/home/user/my folder/file.py") # 23.9μs -> 16.4μs (45.4% faster)

def test_edge_file_in_folder_with_unicode():
    # File in folder with unicode character, not denylisted
    codeflash_output = in_denylist("/home/user/项目/file.py") # 23.7μs -> 16.5μs (43.3% faster)

def test_edge_file_in_folder_with_uppercase_denylist():
    # File in uppercase denylisted folder should not be denied (case sensitive)
    codeflash_output = in_denylist("/home/user/ANACONDA/file.py") # 22.5μs -> 16.0μs (40.5% faster)

def test_edge_file_in_folder_with_mixed_case_denylist():
    # File in mixed case denylisted folder should not be denied (case sensitive)
    codeflash_output = in_denylist("/home/user/Anaconda/file.py") # 23.0μs -> 16.1μs (42.3% faster)

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

def test_large_scale_many_files_none_denylisted():
    # Create 1000 filepaths not in denylist, all should return False
    for i in range(1000):
        path = f"/home/user/project/src/file_{i}.py"
        codeflash_output = in_denylist(path) # 16.0ms -> 10.3ms (56.1% faster)

def test_large_scale_many_files_all_denylisted():
    # Create 1000 filepaths in denylisted folder, all should return True
    for i in range(1000):
        path = f"/home/user/anaconda/file_{i}.py"
        codeflash_output = in_denylist(path) # 2.88ms -> 2.13ms (35.2% faster)

def test_large_scale_mixed_files():
    # 500 denylisted, 500 not denylisted
    for i in range(500):
        path = f"/home/user/venv/file_{i}.py"
        codeflash_output = in_denylist(path) # 7.19ms -> 4.54ms (58.3% faster)
    for i in range(500):
        path = f"/home/user/project/src/file_{i}.py"
        codeflash_output = in_denylist(path) # 7.97ms -> 5.11ms (56.1% faster)

def test_large_scale_deeply_nested_denylisted():
    # 1000 files inside deeply nested denylisted folder
    for i in range(1000):
        path = f"/a/b/c/d/e/f/g/node_modules/file_{i}.js"
        codeflash_output = in_denylist(path) # 11.7ms -> 7.77ms (50.4% faster)

def test_large_scale_hidden_folders():
    # 1000 files inside hidden folders
    for i in range(1000):
        path = f"/home/user/.hidden{i}/file.txt"
        codeflash_output = in_denylist(path) # 1.61ms -> 1.32ms (21.9% faster)

def test_large_scale_edge_case_folders():
    # 1000 files in folders that look similar but aren't denylisted
    for i in range(1000):
        path = f"/home/user/anacondaz/file_{i}.py"
        codeflash_output = in_denylist(path) # 16.0ms -> 10.4ms (54.8% faster)

# ------------------------------
# Additional Edge Cases
# ------------------------------

def test_edge_file_with_relative_path():
    # Relative path in denylisted folder
    codeflash_output = in_denylist("anaconda/file.py") # 22.0μs -> 14.9μs (47.6% faster)

def test_edge_file_with_dot_relative_path():
    # Relative path with dot folder
    codeflash_output = in_denylist("./.hidden/file.txt") # 7.26μs -> 5.81μs (24.9% faster)

def test_edge_file_with_dotdot_relative_path():
    # Relative path with double dot folder
    codeflash_output = in_denylist("../.hidden/file.txt") # 6.94μs -> 5.62μs (23.4% faster)

def test_edge_file_with_trailing_slash_in_filepath():
    # Filepath with trailing slash (should be treated as folder, not file)
    codeflash_output = in_denylist("/home/user/anaconda/") # 9.92μs -> 7.44μs (33.4% faster)

def test_edge_file_with_empty_string():
    # Empty string as filepath should not be denied
    codeflash_output = in_denylist("") # 18.2μs -> 12.8μs (42.0% faster)

def test_edge_file_with_only_dot():
    # Filepath is just ".", not a denylisted folder
    codeflash_output = in_denylist(".") # 17.7μs -> 12.2μs (45.2% faster)

def test_edge_file_with_only_dotdot():
    # Filepath is just "..", not a denylisted folder
    codeflash_output = in_denylist("..") # 17.6μs -> 12.3μs (42.5% faster)
# 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-in_denylist-mhbpze17 and push.