codeflash-omni-java

[misrasaurabh1]

No description provided.

[codeflash-ai]

⚡️Codeflash found 70% (0.70x) speedup for should_modify_java_config in codeflash/cli_cmds/init_java.py

⏱️ Runtime : 714 microseconds → 421 microseconds (best of 60 runs)

📝 Explanation and details

The optimized code achieves a 69% speedup (714μs → 421μs) by replacing pathlib.Path operations with equivalent os module functions, which have significantly lower overhead.

Key optimizations:

1. os.getcwd() instead of Path.cwd(): The line profiler shows Path.cwd() took 689,637ns (34.1% of total time) vs os.getcwd() taking only 68,036ns (7.4%). This is a ~10x improvement because Path.cwd() instantiates a Path object and performs additional normalization, while os.getcwd() returns a raw string from a system call.

2. os.path.join() instead of Path division operator: Constructing the config path via project_root / "codeflash.toml" took 386,582ns (19.1%) vs os.path.join() taking 190,345ns (20.6%). Though the percentage appears similar, the absolute time is ~50% faster because the / operator creates a new Path object with its associated overhead.

3. os.path.exists() instead of Path.exists(): The existence check dropped from 476,490ns (23.6%) to 223,477ns (24.2%) - roughly 2x faster. The os.path.exists() function directly calls the stat syscall, while Path.exists() goes through Path's object model.

Why this works:
Path objects provide a cleaner API but add object instantiation, method dispatch, and normalization overhead. For simple filesystem checks in initialization code that runs frequently, using lower-level os functions eliminates this overhead while maintaining identical functionality.

Test results:
All test cases show 68-111% speedup across scenarios including:

• Empty directories (fastest: 82-87% improvement)
• Large directories with 500 files (68-111% improvement)
• Edge cases like symlinks and directory-as-file (75-82% improvement)

The optimization is particularly beneficial for CLI initialization code that may run on every command invocation, where sub-millisecond improvements in frequently-called functions compound into noticeable user experience gains.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from __future__ import annotations

# imports
import os
from pathlib import Path
from typing import Any

import pytest  # used for our unit tests
from codeflash.cli_cmds.init_java import should_modify_java_config

def test_no_config_file_does_not_prompt_and_returns_true(monkeypatch, tmp_path):
    # Arrange: ensure working directory has no codeflash.toml
    monkeypatch.chdir(tmp_path)  # set cwd to a clean temporary directory

    # Replace Confirm.ask with a function that fails the test if called.
    def fail_if_called(*args, **kwargs):
        raise AssertionError("Confirm.ask should not be called when no config file exists")

    # Patch the exact attribute that the function imports at runtime.
    monkeypatch.setattr("rich.prompt.Confirm.ask", fail_if_called, raising=True)

    # Act: call function under test
    codeflash_output = should_modify_java_config(); result = codeflash_output # 28.9μs -> 15.9μs (82.0% faster)

def test_config_file_exists_prompts_and_respects_true_choice(monkeypatch, tmp_path):
    # Arrange: create a codeflash.toml file so the function will detect it
    monkeypatch.chdir(tmp_path)
    config_file = tmp_path / "codeflash.toml"
    config_file.write_text("existing = true")  # create the file

    # Capture the arguments passed to Confirm.ask and return True to simulate user acceptance
    called = {}

    def fake_ask(prompt, default, show_default):
        # Record inputs for later assertions
        called["prompt"] = prompt
        called["default"] = default
        called["show_default"] = show_default
        return True

    # Patch Confirm.ask used inside the function
    monkeypatch.setattr("rich.prompt.Confirm.ask", fake_ask, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 25.6μs -> 13.7μs (86.9% faster)

def test_config_file_exists_prompts_and_respects_false_choice(monkeypatch, tmp_path):
    # Arrange: create the config file
    monkeypatch.chdir(tmp_path)
    (tmp_path / "codeflash.toml").write_text("existing = true")

    # Simulate user declining re-configuration
    def fake_ask_decline(prompt, default, show_default):
        return False

    monkeypatch.setattr("rich.prompt.Confirm.ask", fake_ask_decline, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 24.7μs -> 13.3μs (86.3% faster)

def test_presence_of_pom_xml_does_not_trigger_prompt(monkeypatch, tmp_path):
    # Arrange: create a pom.xml but NOT codeflash.toml
    monkeypatch.chdir(tmp_path)
    (tmp_path / "pom.xml").write_text("<project></project>")

    # If Confirm.ask is called, fail the test because only codeflash.toml should trigger it in current implementation
    def fail_if_called(*args, **kwargs):
        raise AssertionError("Confirm.ask should not be called when only pom.xml exists (implementation checks codeflash.toml)")

    monkeypatch.setattr("rich.prompt.Confirm.ask", fail_if_called, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 28.3μs -> 16.6μs (69.9% faster)

def test_codeflash_config_is_directory_triggers_prompt(monkeypatch, tmp_path):
    # Arrange: create a directory named codeflash.toml (Path.exists will be True)
    monkeypatch.chdir(tmp_path)
    (tmp_path / "codeflash.toml").mkdir()

    # Simulate user selecting True
    monkeypatch.setattr("rich.prompt.Confirm.ask", lambda *a, **k: True, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 23.6μs -> 12.9μs (82.2% faster)

def test_codeflash_config_symlink_triggers_prompt_if_supported(monkeypatch, tmp_path):
    # Arrange: attempt to create a symlink to a real file; skip if symlink not supported
    if not hasattr(os, "symlink"):
        pytest.skip("Platform does not support os.symlink; skipping symlink test")

    real = tmp_path / "real_config"
    real.write_text("x = 1")
    link = tmp_path / "codeflash.toml"

    try:
        os.symlink(real, link)  # may fail on Windows without privileges
    except (OSError, NotImplementedError) as e:
        pytest.skip(f"Could not create symlink on this platform/environment: {e}")

    monkeypatch.chdir(tmp_path)

    # Simulate user declining re-configuration
    monkeypatch.setattr("rich.prompt.Confirm.ask", lambda *a, **k: False, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 24.9μs -> 14.2μs (75.7% faster)

def test_large_directory_without_config_is_fast_and_does_not_prompt(monkeypatch, tmp_path):
    # Large scale scenario: create many files (but under 1000) to simulate busy project directory.
    monkeypatch.chdir(tmp_path)
    num_files = 500  # under the 1000 element guideline
    for i in range(num_files):
        # Create many innocuous files; should not affect the function's behavior
        (tmp_path / f"file_{i}.txt").write_text(str(i))

    # Ensure Confirm.ask is not called
    def fail_if_called(*args, **kwargs):
        raise AssertionError("Confirm.ask should not be called when codeflash.toml is absent even in large directories")

    monkeypatch.setattr("rich.prompt.Confirm.ask", fail_if_called, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 36.3μs -> 21.6μs (68.0% faster)

def test_large_directory_with_config_prompts_once(monkeypatch, tmp_path):
    # Large scale scenario with config present: many files plus codeflash.toml
    monkeypatch.chdir(tmp_path)
    num_files = 500
    for i in range(num_files):
        (tmp_path / f"file_{i}.txt").write_text(str(i))

    # Create the config file that should trigger prompting
    (tmp_path / "codeflash.toml").write_text("reconfigure = maybe")

    # Track how many times Confirm.ask is invoked to ensure single prompt
    counter = {"calls": 0}

    def fake_ask(prompt, default, show_default):
        counter["calls"] += 1
        return True

    monkeypatch.setattr("rich.prompt.Confirm.ask", fake_ask, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 30.8μs -> 14.6μs (111% faster)
# 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 tempfile
from pathlib import Path
from unittest.mock import MagicMock, patch

# imports
import pytest
from codeflash.cli_cmds.init_java import should_modify_java_config

class TestShouldModifyJavaConfigBasic:
    """Basic test cases for should_modify_java_config function."""

    def test_no_config_file_exists_returns_true(self):
        """
        Scenario: Project has no existing codeflash.toml file
        Expected: Function returns (True, None) without prompting user
        """
        # Create a temporary directory without codeflash.toml
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_exists_user_confirms(self):
        """
        Scenario: Project has existing codeflash.toml and user confirms re-configuration
        Expected: Function prompts user and returns (True, None) if user confirms
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a codeflash.toml file
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.touch()

                # Mock the Confirm.ask to return True (user confirms)
                with patch('rich.prompt.Confirm.ask', return_value=True):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_exists_user_declines(self):
        """
        Scenario: Project has existing codeflash.toml and user declines re-configuration
        Expected: Function prompts user and returns (False, None) if user declines
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a codeflash.toml file
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.touch()

                # Mock the Confirm.ask to return False (user declines)
                with patch('rich.prompt.Confirm.ask', return_value=False):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_return_tuple_structure(self):
        """
        Scenario: Verify the function always returns a tuple with specific structure
        Expected: Return value is a tuple of (bool, None)
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

class TestShouldModifyJavaConfigEdgeCases:
    """Edge case test cases for should_modify_java_config function."""

    def test_config_file_exists_but_empty(self):
        """
        Scenario: codeflash.toml file exists but is empty
        Expected: File is still considered as existing, prompts user
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create an empty codeflash.toml file
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.write_text("")

                with patch('rich.prompt.Confirm.ask', return_value=True):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_with_content(self):
        """
        Scenario: codeflash.toml file exists with actual TOML content
        Expected: Prompts user regardless of file content
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a codeflash.toml file with content
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.write_text("[codeflash]\nversion = 1\n")

                with patch('rich.prompt.Confirm.ask', return_value=False):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_case_sensitive(self):
        """
        Scenario: Directory has 'Codeflash.toml' or 'CODEFLASH.TOML' instead of lowercase
        Expected: Function only recognizes 'codeflash.toml' (case-sensitive on Unix)
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a file with different casing
                config_file = Path(tmpdir) / "Codeflash.toml"
                config_file.touch()

                codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_is_directory_not_file(self):
        """
        Scenario: codeflash.toml exists as a directory instead of a file
        Expected: Path.exists() still returns True, prompts user
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create codeflash.toml as a directory
                config_dir = Path(tmpdir) / "codeflash.toml"
                config_dir.mkdir()

                with patch('rich.prompt.Confirm.ask', return_value=True):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    

To test or edit this optimization locally git merge codeflash/optimize-pr1199-2026-02-01T21.20.00

Suggested change

	project_root = Path.cwd()
	# Check for existing codeflash config in pom.xml or a separate config file
	codeflash_config_path = project_root / "codeflash.toml"
	if codeflash_config_path.exists():
	project_root = os.getcwd()
	# Check for existing codeflash config in pom.xml or a separate config file
	codeflash_config_path = os.path.join(project_root, "codeflash.toml")
	if os.path.exists(codeflash_config_path):