Merge branch 'main' into lsp/failed-test-results

Author: KRRT7

codeflash-benchmark/codeflash_benchmark/plugin.py

@@ -52,10 +52,11 @@ def pytest_addoption(parser: pytest.Parser) -> None:
     parser.addoption(
         "--codeflash-trace", action="store_true", default=False, help="Enable CodeFlash tracing for benchmarks"
     )
-    # These options are ignored when --codeflash-trace is used
-    for option, action, default, help_text in benchmark_options:
-        help_suffix = " (ignored when --codeflash-trace is used)"
-        parser.addoption(option, action=action, default=default, help=help_text + help_suffix)
+    # Only add benchmark options if pytest-benchmark is not installed for backward compatibility with existing pytest-benchmark setup
+    if not PYTEST_BENCHMARK_INSTALLED:
+        for option, action, default, help_text in benchmark_options:
+            help_suffix = " (ignored when --codeflash-trace is used)"
+            parser.addoption(option, action=action, default=default, help=help_text + help_suffix)
 
 
 @pytest.fixture

codeflash/api/cfapi.py

@@ -91,7 +91,7 @@ def get_user_id(api_key: Optional[str] = None) -> Optional[str]:
 
     :return: The userid or None if the request fails.
     """
-    if not ensure_codeflash_api_key():
+    if not api_key and not ensure_codeflash_api_key():
         return None
 
     response = make_cfapi_request(

codeflash/code_utils/edit_generated_tests.py

@@ -4,7 +4,7 @@
 import os
 import re
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 import libcst as cst
 from libcst import MetadataWrapper
@@ -149,18 +149,19 @@ def leave_SimpleStatementSuite(
         return updated_node
 
 
-def unique_inv_id(inv_id_runtimes: dict[InvocationId, list[int]]) -> dict[str, int]:
+def unique_inv_id(inv_id_runtimes: dict[InvocationId, list[int]], tests_project_rootdir: Path) -> dict[str, int]:
     unique_inv_ids: dict[str, int] = {}
     for inv_id, runtimes in inv_id_runtimes.items():
         test_qualified_name = (
             inv_id.test_class_name + "." + inv_id.test_function_name  # type: ignore[operator]
             if inv_id.test_class_name
             else inv_id.test_function_name
         )
-        abs_path = str(Path(inv_id.test_module_path.replace(".", os.sep)).with_suffix(".py").resolve().with_suffix(""))
-        if "__unit_test_" not in abs_path:
+        abs_path = tests_project_rootdir / Path(inv_id.test_module_path.replace(".", os.sep)).with_suffix(".py")
+        abs_path_str = str(abs_path.resolve().with_suffix(""))
+        if "__unit_test_" not in abs_path_str or not test_qualified_name:
             continue
-        key = test_qualified_name + "#" + abs_path  # type: ignore[operator]
+        key = test_qualified_name + "#" + abs_path_str
         parts = inv_id.iteration_id.split("_").__len__()  # type: ignore[union-attr]
         cur_invid = inv_id.iteration_id.split("_")[0] if parts < 3 else "_".join(inv_id.iteration_id.split("_")[:-1])  # type: ignore[union-attr]
         match_key = key + "#" + cur_invid
@@ -174,10 +175,11 @@ def add_runtime_comments_to_generated_tests(
     generated_tests: GeneratedTestsList,
     original_runtimes: dict[InvocationId, list[int]],
     optimized_runtimes: dict[InvocationId, list[int]],
+    tests_project_rootdir: Optional[Path] = None,
 ) -> GeneratedTestsList:
     """Add runtime performance comments to function calls in generated tests."""
-    original_runtimes_dict = unique_inv_id(original_runtimes)
-    optimized_runtimes_dict = unique_inv_id(optimized_runtimes)
+    original_runtimes_dict = unique_inv_id(original_runtimes, tests_project_rootdir or Path())
+    optimized_runtimes_dict = unique_inv_id(optimized_runtimes, tests_project_rootdir or Path())
     # Process each generated test
     modified_tests = []
     for test in generated_tests.generated_tests:

codeflash/code_utils/env_utils.py

@@ -2,6 +2,8 @@
 
 import json
 import os
+import shlex
+import shutil
 import tempfile
 from functools import lru_cache
 from pathlib import Path
@@ -14,21 +16,41 @@
 
 
 def check_formatter_installed(formatter_cmds: list[str], exit_on_failure: bool = True) -> bool:  # noqa
-    return_code = True
-    if formatter_cmds[0] == "disabled":
-        return return_code
+    if not formatter_cmds or formatter_cmds[0] == "disabled":
+        return True
+
+    first_cmd = formatter_cmds[0]
+    cmd_tokens = shlex.split(first_cmd) if isinstance(first_cmd, str) else [first_cmd]
+
+    if not cmd_tokens:
+        return True
+
+    exe_name = cmd_tokens[0]
+    command_str = " ".join(formatter_cmds).replace(" $file", "")
+
+    if shutil.which(exe_name) is None:
+        logger.error(
+            f"Could not find formatter: {command_str}\n"
+            f"Please install it or update 'formatter-cmds' in your codeflash configuration"
+        )
+        return False
+
     tmp_code = """print("hello world")"""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        tmp_file = Path(tmpdir) / "test_codeflash_formatter.py"
-        tmp_file.write_text(tmp_code, encoding="utf-8")
-        try:
-            format_code(formatter_cmds, tmp_file, print_status=False, exit_on_failure=exit_on_failure)
-        except Exception:
-            exit_with_message(
-                "⚠️ Codeflash requires a code formatter to be installed in your environment, but none was found. Please install a supported formatter, verify the formatter-cmds in your codeflash pyproject.toml config and try again.",
-                error_on_exit=True,
-            )
-        return return_code
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp_file = Path(tmpdir) / "test_codeflash_formatter.py"
+            tmp_file.write_text(tmp_code, encoding="utf-8")
+            format_code(formatter_cmds, tmp_file, print_status=False, exit_on_failure=False)
+            return True
+    except FileNotFoundError:
+        logger.error(
+            f"Could not find formatter: {command_str}\n"
+            f"Please install it or update 'formatter-cmds' in your codeflash configuration"
+        )
+        return False
+    except Exception as e:
+        logger.error(f"Formatter failed to run: {command_str}\nError: {e}")
+        return False
 
 
 @lru_cache(maxsize=1)

codeflash/code_utils/formatter.py

@@ -76,12 +76,9 @@ def apply_formatter_cmds(
                 logger.error(f"Failed to format code with {' '.join(formatter_cmd_list)}")
         except FileNotFoundError as e:
             from rich.panel import Panel
-            from rich.text import Text
 
-            panel = Panel(
-                Text.from_markup(f"⚠️  Formatter command not found: {' '.join(formatter_cmd_list)}", style="bold red"),
-                expand=False,
-            )
+            command_str = " ".join(str(part) for part in formatter_cmd_list)
+            panel = Panel(f"⚠️  Formatter command not found: {command_str}", expand=False, border_style="yellow")
             console.print(panel)
             if exit_on_failure:
                 raise e from None

codeflash/code_utils/git_worktree_utils.py

@@ -3,34 +3,18 @@
 import subprocess
 import tempfile
 import time
-from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import Optional
 
 import git
 
 from codeflash.cli_cmds.console import logger
 from codeflash.code_utils.compat import codeflash_cache_dir
 from codeflash.code_utils.git_utils import check_running_in_git_repo, git_root_dir
 
-if TYPE_CHECKING:
-    from git import Repo
-
-
 worktree_dirs = codeflash_cache_dir / "worktrees"
 patches_dir = codeflash_cache_dir / "patches"
 
-if TYPE_CHECKING:
-    from git import Repo
-
-
-@lru_cache(maxsize=1)
-def get_git_project_id() -> str:
-    """Return the first commit sha of the repo."""
-    repo: Repo = git.Repo(search_parent_directories=True)
-    root_commits = list(repo.iter_commits(rev="HEAD", max_parents=0))
-    return root_commits[0].hexsha
-
 
 def create_worktree_snapshot_commit(worktree_dir: Path, commit_message: str) -> None:
     repository = git.Repo(worktree_dir, search_parent_directories=True)
@@ -96,12 +80,6 @@ def remove_worktree(worktree_dir: Path) -> None:
         logger.exception(f"Failed to remove worktree: {worktree_dir}")
 
 
-@lru_cache(maxsize=1)
-def get_patches_dir_for_project() -> Path:
-    project_id = get_git_project_id() or ""
-    return Path(patches_dir / project_id)
-
-
 def create_diff_patch_from_worktree(
     worktree_dir: Path, files: list[str], fto_name: Optional[str] = None
 ) -> Optional[Path]:
@@ -115,10 +93,8 @@ def create_diff_patch_from_worktree(
     if not uni_diff_text.endswith("\n"):
         uni_diff_text += "\n"
 
-    project_patches_dir = get_patches_dir_for_project()
-    project_patches_dir.mkdir(parents=True, exist_ok=True)
-
-    patch_path = project_patches_dir / f"{worktree_dir.name}.{fto_name}.patch"
+    patches_dir.mkdir(parents=True, exist_ok=True)
+    patch_path = Path(patches_dir / f"{worktree_dir.name}.{fto_name}.patch")
     with patch_path.open("w", encoding="utf8") as f:
         f.write(uni_diff_text)