⚡️ Speed up method NestedAppDiscovery.discover by 42%

[codeflash-ai]

📄 42% (0.42x) speedup for NestedAppDiscovery.discover in backend/python/app/agents/tools/discovery.py

⏱️ Runtime : 31.2 milliseconds → 22.0 milliseconds (best of 41 runs)

📝 Explanation and details

The optimized code replaces a traditional for-loop with list.append() pattern with a list comprehension, delivering a 41% speedup.

Key optimization applied:

• List comprehension: Combined the loop iteration, path existence checks, and list building into a single expression that leverages Python's optimized C-level iteration.

Why this is faster:

• Reduced Python bytecode overhead: The original code had separate operations for loop iteration, path construction, existence checks, and list appending. The list comprehension consolidates these into fewer Python bytecode instructions.
• Better memory efficiency: List comprehensions pre-allocate the result list size when possible and avoid the repeated list.append() calls that can trigger memory reallocations.
• Optimized path operations: Instead of creating intermediate subdir_path variables, the optimized version chains path operations directly: (app_dir / subdir / f"{subdir}.py").exists().

Performance characteristics from tests:

• Best for large-scale scenarios: The optimization shows excellent scaling with tests like test_discover_large_all_subdirs_have_files (1000 subdirs) and test_discover_many_subdirs (100+ subdirs), where the overhead reduction is most pronounced.
• Consistent gains across all cases: Even small cases with 1-3 subdirs benefit from the reduced bytecode overhead.
• Particularly effective when many paths don't exist: Tests like test_discover_large_no_subdirs_have_files benefit from the streamlined existence checking without intermediate variable assignments.

The line profiler shows the optimization eliminates multiple high-cost operations (subdir_path creation, separate existence checks) into a single comprehension that executes 99% of the time in one optimized operation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from pathlib import Path
from typing import List

# imports
import pytest  # used for our unit tests
from app.agents.tools.discovery import NestedAppDiscovery


# function to test
class DiscoveryStrategy:
    """Dummy base class for type compatibility in tests."""
    pass

class ModuleImporter:
    """Dummy importer for compatibility; not used in logic."""
    pass
from app.agents.tools.discovery import NestedAppDiscovery

# unit tests

# Basic Test Cases

def test_discover_single_subdir(tmp_path):
    # Setup: create app_name directory and one subdir with its .py file
    app_name = "google"
    subdirs = ["drive"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    subdir_dir = app_dir / "drive"
    subdir_dir.mkdir()
    (subdir_dir / "drive.py").touch()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    # Should discover the drive module
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_multiple_subdirs(tmp_path):
    # Setup: create app_name directory, two subdirs, only one has .py file
    app_name = "microsoft"
    subdirs = ["excel", "word"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    # excel subdir with main file
    excel_dir = app_dir / "excel"
    excel_dir.mkdir()
    (excel_dir / "excel.py").touch()
    # word subdir without main file
    word_dir = app_dir / "word"
    word_dir.mkdir()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    # Should discover only excel
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_no_subdirs(tmp_path):
    # Setup: app_name directory exists but no subdirs
    app_name = "apple"
    subdirs = []
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_subdir_missing_py(tmp_path):
    # Setup: subdir exists but .py file missing
    app_name = "google"
    subdirs = ["calendar"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    subdir_dir = app_dir / "calendar"
    subdir_dir.mkdir()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_app_dir_missing(tmp_path):
    # Setup: app_name directory does not exist
    app_name = "amazon"
    subdirs = ["shopping"]
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

# Edge Test Cases

def test_discover_subdir_is_file(tmp_path):
    # Setup: subdir path is a file, not a directory
    app_name = "google"
    subdirs = ["maps"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    # Create a file named 'maps' instead of a directory
    (app_dir / "maps").touch()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    # Should not discover anything
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_subdir_with_extra_files(tmp_path):
    # Setup: subdir contains other files, but main file exists
    app_name = "google"
    subdirs = ["photos"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    photos_dir = app_dir / "photos"
    photos_dir.mkdir()
    (photos_dir / "photos.py").touch()
    (photos_dir / "extra.txt").touch()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    # Should discover photos
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_subdir_py_is_directory(tmp_path):
    # Setup: subdir exists, but subdir.py is a directory
    app_name = "google"
    subdirs = ["mail"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    mail_dir = app_dir / "mail"
    mail_dir.mkdir()
    (mail_dir / "mail.py").mkdir()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    # Should not discover anything
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_subdir_with_dot_in_name(tmp_path):
    # Setup: subdir name contains a dot
    app_name = "google"
    subdirs = ["drive.v2"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    drivev2_dir = app_dir / "drive.v2"
    drivev2_dir.mkdir()
    (drivev2_dir / "drive.v2.py").touch()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_subdir_case_sensitivity(tmp_path):
    # Setup: subdir name case does not match file name
    app_name = "google"
    subdirs = ["Drive"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    drive_dir = app_dir / "Drive"
    drive_dir.mkdir()
    (drive_dir / "drive.py").touch()  # file name is lowercase
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    # Should not discover anything since file name is case sensitive
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

# Large Scale Test Cases

def test_discover_many_subdirs(tmp_path):
    # Setup: app_name with 100 subdirs, all have main file
    app_name = "bigapp"
    subdirs = [f"tool{i}" for i in range(100)]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    for subdir in subdirs:
        subdir_dir = app_dir / subdir
        subdir_dir.mkdir()
        (subdir_dir / f"{subdir}.py").touch()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output
    expected = [f"app.agents.actions.bigapp.{subdir}.{subdir}" for subdir in subdirs]

def test_discover_many_subdirs_some_missing(tmp_path):
    # Setup: app_name with 100 subdirs, only even indexed have main file
    app_name = "bigapp"
    subdirs = [f"tool{i}" for i in range(100)]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    for i, subdir in enumerate(subdirs):
        subdir_dir = app_dir / subdir
        subdir_dir.mkdir()
        if i % 2 == 0:
            (subdir_dir / f"{subdir}.py").touch()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output
    expected = [f"app.agents.actions.bigapp.tool{i}.tool{i}" for i in range(0, 100, 2)]

def test_discover_multiple_apps(tmp_path):
    # Setup: two apps, each with several subdirs
    app_names = ["google", "microsoft"]
    subdirs_google = ["drive", "mail"]
    subdirs_microsoft = ["excel", "word"]
    # google
    google_dir = tmp_path / "google"
    google_dir.mkdir()
    for subdir in subdirs_google:
        subdir_dir = google_dir / subdir
        subdir_dir.mkdir()
        (subdir_dir / f"{subdir}.py").touch()
    # microsoft
    microsoft_dir = tmp_path / "microsoft"
    microsoft_dir.mkdir()
    for subdir in subdirs_microsoft:
        subdir_dir = microsoft_dir / subdir
        subdir_dir.mkdir()
        (subdir_dir / f"{subdir}.py").touch()
    # Discover for google
    discovery_google = NestedAppDiscovery("google", subdirs_google)
    importer = ModuleImporter()
    codeflash_output = discovery_google.discover(tmp_path, importer); result_google = codeflash_output
    expected_google = [
        "app.agents.actions.google.drive.drive",
        "app.agents.actions.google.mail.mail"
    ]
    # Discover for microsoft
    discovery_microsoft = NestedAppDiscovery("microsoft", subdirs_microsoft)
    codeflash_output = discovery_microsoft.discover(tmp_path, importer); result_microsoft = codeflash_output
    expected_microsoft = [
        "app.agents.actions.microsoft.excel.excel",
        "app.agents.actions.microsoft.word.word"
    ]

def test_discover_large_app_dir_missing(tmp_path):
    # Setup: large number of subdirs, but app_name dir missing
    app_name = "missingapp"
    subdirs = [f"tool{i}" for i in range(1000)]
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_performance_many_subdirs(tmp_path):
    # Setup: test efficiency with 1000 subdirs, only last has main file
    app_name = "bigapp"
    subdirs = [f"tool{i}" for i in range(1000)]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    for subdir in subdirs:
        subdir_dir = app_dir / subdir
        subdir_dir.mkdir()
    # Only last subdir has main file
    (app_dir / subdirs[-1] / f"{subdirs[-1]}.py").touch()
    discovery = NestedAppDiscovery(app_name, subdirs)
    importer = ModuleImporter()
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output
    expected = [f"app.agents.actions.bigapp.{subdirs[-1]}.{subdirs[-1]}"]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import os
import shutil
import tempfile
from pathlib import Path

# imports
import pytest
from app.agents.tools.discovery import NestedAppDiscovery


# function to test
class DiscoveryStrategy:
    pass  # Dummy base class for the test

class ModuleImporter:
    pass  # Dummy class for the test
from app.agents.tools.discovery import NestedAppDiscovery

# unit tests

# Helper function to create nested directory structures for tests
def create_nested_structure(base_dir, app_name, subdirs, files_to_create):
    app_dir = base_dir / app_name
    app_dir.mkdir()
    for subdir in subdirs:
        subdir_path = app_dir / subdir
        subdir_path.mkdir()
        if subdir in files_to_create:
            file_path = subdir_path / f"{subdir}.py"
            file_path.touch()

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

def test_discover_basic_single_subdir_found(tmp_path):
    # Test with one subdir, file exists
    app_name = "google"
    subdirs = ["calendar"]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=["calendar"])
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_basic_multiple_subdirs_some_found(tmp_path):
    # Test with multiple subdirs, only some have the .py file
    app_name = "microsoft"
    subdirs = ["word", "excel", "powerpoint"]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=["word", "powerpoint"])
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_basic_no_subdirs_found(tmp_path):
    # Test with subdirs, none have the .py file
    app_name = "slack"
    subdirs = ["chat", "files"]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=[])
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_basic_app_dir_missing(tmp_path):
    # App directory does not exist
    app_name = "zoom"
    subdirs = ["meeting", "chat"]
    # Do not create app dir
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_basic_empty_subdirs(tmp_path):
    # Subdirs list is empty
    app_name = "google"
    subdirs = []
    tmp_path.mkdir(exist_ok=True)
    (tmp_path / app_name).mkdir()
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

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

def test_discover_edge_subdir_exists_but_file_missing(tmp_path):
    # Subdir exists, but .py file is missing
    app_name = "testapp"
    subdirs = ["alpha"]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=[])
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_edge_file_exists_but_subdir_missing(tmp_path):
    # .py file exists in app dir, but subdir is missing
    app_name = "testapp"
    subdirs = ["beta"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    # Create beta.py directly in app dir, not in subdir
    (app_dir / "beta.py").touch()
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_edge_subdir_is_file(tmp_path):
    # Subdir name exists as a file, not a directory
    app_name = "testapp"
    subdirs = ["gamma"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    # Create a file named "gamma" instead of a directory
    (app_dir / "gamma").touch()
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_edge_special_characters_in_names(tmp_path):
    # Subdir names with special characters
    app_name = "my-app"
    subdirs = ["sub-dir", "sub.dir", "sub dir"]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=["sub-dir", "sub.dir"])
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_edge_base_dir_is_file(tmp_path):
    # base_dir is a file, not a directory
    file_path = tmp_path / "not_a_dir"
    file_path.write_text("hello")
    app_name = "google"
    subdirs = ["calendar"]
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(file_path, importer); result = codeflash_output



def test_discover_edge_symlinked_subdir(tmp_path):
    # Subdir is a symlink to another directory containing the .py file
    app_name = "google"
    subdirs = ["calendar"]
    app_dir = tmp_path / app_name
    app_dir.mkdir()
    # Create a real directory elsewhere
    real_dir = tmp_path / "real_calendar"
    real_dir.mkdir()
    (real_dir / "calendar.py").touch()
    # Create symlink in app_dir
    symlink_path = app_dir / "calendar"
    symlink_path.symlink_to(real_dir, target_is_directory=True)
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_edge_case_sensitive(tmp_path):
    # Check case sensitivity: subdir exists with different case
    app_name = "google"
    subdirs = ["Calendar"]
    create_nested_structure(tmp_path, app_name, ["calendar"], files_to_create=["calendar"])
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

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

def test_discover_large_many_subdirs(tmp_path):
    # Large number of subdirs, only some have .py files
    app_name = "megaapp"
    subdirs = [f"tool{i}" for i in range(500)]
    # Create .py files for every 10th subdir
    files_to_create = [f"tool{i}" for i in range(0, 500, 10)]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=files_to_create)
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output
    expected = [f"app.agents.actions.megaapp.tool{i}.tool{i}" for i in range(0, 500, 10)]
    # Should not include any toolX where X % 10 != 0
    for i in range(1, 500, 10):
        pass

def test_discover_large_all_subdirs_have_files(tmp_path):
    # All subdirs have .py files
    app_name = "fullapp"
    subdirs = [f"mod{i}" for i in range(1000)]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=subdirs)
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output
    expected = [f"app.agents.actions.fullapp.mod{i}.mod{i}" for i in range(1000)]

def test_discover_large_no_subdirs_have_files(tmp_path):
    # None of the subdirs have .py files
    app_name = "emptyapp"
    subdirs = [f"mod{i}" for i in range(1000)]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=[])
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_large_missing_app_dir(tmp_path):
    # App dir does not exist, with large subdir list
    app_name = "missingapp"
    subdirs = [f"mod{i}" for i in range(1000)]
    # Do not create app dir
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output

def test_discover_large_subdir_names_are_long(tmp_path):
    # Subdir names are very long
    app_name = "longapp"
    subdirs = [f"{'a'*100}_{i}" for i in range(100)]
    create_nested_structure(tmp_path, app_name, subdirs, files_to_create=subdirs)
    importer = ModuleImporter()
    discovery = NestedAppDiscovery(app_name, subdirs)
    codeflash_output = discovery.discover(tmp_path, importer); result = codeflash_output
    expected = [f"app.agents.actions.longapp.{name}.{name}" for name in subdirs]
# 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-NestedAppDiscovery.discover-mhcud4t0 and push.