Merge branch 'main' into chore-send-email

Author: HeshamHM28

codeflash/cli_cmds/cmd_init.py

@@ -981,7 +981,7 @@ def install_github_app() -> None:
         )
         click.launch("https://github.com/apps/codeflash-ai/installations/select_target")
         click.prompt(
-            f"Press Enter once you've finished installing the github app from https://github.com/apps/codeflash-ai/installations/select_target…{LF}",
+            f"Press Enter once you've finished installing the github app from https://github.com/apps/codeflash-ai/installations/select_target{LF}",
             default="",
             type=click.STRING,
             prompt_suffix="",

codeflash/code_utils/edit_generated_tests.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime as dt
 import re
 
@@ -58,42 +60,27 @@ def format_time(nanoseconds: int) -> str:
         raise TypeError("Input must be an integer.")
     if nanoseconds < 0:
         raise ValueError("Input must be a positive integer.")
-    conversions = [(1_000_000_000, "s"), (1_000_000, "ms"), (1_000, "μs"), (1, "ns")]
 
-    # Handle nanoseconds case directly (no decimal formatting needed)
     if nanoseconds < 1_000:
         return f"{nanoseconds}ns"
-
-    # Find appropriate unit
-    for divisor, unit in conversions:
-        if nanoseconds >= divisor:
-            value = nanoseconds / divisor
-            int_value = nanoseconds // divisor
-
-            # Use integer formatting for values >= 100
-            if int_value >= 100:
-                formatted_value = f"{int_value:.0f}"
-            # Format with precision for 3 significant digits
-            elif value >= 100:
-                formatted_value = f"{value:.0f}"
-            elif value >= 10:
-                formatted_value = f"{value:.1f}"
-            else:
-                formatted_value = f"{value:.2f}"
-
-            return f"{formatted_value}{unit}"
-
-    # This should never be reached, but included for completeness
-    return f"{nanoseconds}ns"
+    if nanoseconds < 1_000_000:
+        value = nanoseconds / 1_000
+        return f"{value:.2f}μs" if value < 10 else (f"{value:.1f}μs" if value < 100 else f"{int(value)}μs")
+    if nanoseconds < 1_000_000_000:
+        value = nanoseconds / 1_000_000
+        return f"{value:.2f}ms" if value < 10 else (f"{value:.1f}ms" if value < 100 else f"{int(value)}ms")
+    value = nanoseconds / 1_000_000_000
+    return f"{value:.2f}s" if value < 10 else (f"{value:.1f}s" if value < 100 else f"{int(value)}s")
 
 
 def format_perf(percentage: float) -> str:
     """Format percentage into a human-readable string with 3 significant digits when needed."""
-    percentage_abs = abs(percentage)
-    if percentage_abs >= 100:
+    # Branch order optimized
+    abs_perc = abs(percentage)
+    if abs_perc >= 100:
         return f"{percentage:.0f}"
-    if percentage_abs >= 10:
+    if abs_perc >= 10:
         return f"{percentage:.1f}"
-    if percentage_abs >= 1:
+    if abs_perc >= 1:
         return f"{percentage:.2f}"
     return f"{percentage:.3f}"

codeflash/code_utils/time_utils.py

@@ -341,7 +341,7 @@ def discover_unit_tests(
     cfg: TestConfig,
     discover_only_these_tests: list[Path] | None = None,
     file_to_funcs_to_optimize: dict[Path, list[FunctionToOptimize]] | None = None,
-) -> tuple[dict[str, set[FunctionCalledInTest]], int]:
+) -> tuple[dict[str, set[FunctionCalledInTest]], int, int]:
     framework_strategies: dict[str, Callable] = {"pytest": discover_tests_pytest, "unittest": discover_tests_unittest}
     strategy = framework_strategies.get(cfg.test_framework, None)
     if not strategy:
@@ -352,8 +352,10 @@ def discover_unit_tests(
     functions_to_optimize = None
     if file_to_funcs_to_optimize:
         functions_to_optimize = [func for funcs_list in file_to_funcs_to_optimize.values() for func in funcs_list]
-    function_to_tests, num_discovered_tests = strategy(cfg, discover_only_these_tests, functions_to_optimize)
-    return function_to_tests, num_discovered_tests
+    function_to_tests, num_discovered_tests, num_discovered_replay_tests = strategy(
+        cfg, discover_only_these_tests, functions_to_optimize
+    )
+    return function_to_tests, num_discovered_tests, num_discovered_replay_tests
 
 
 def discover_tests_pytest(
@@ -515,6 +517,7 @@ def process_test_files(
 
     function_to_test_map = defaultdict(set)
     num_discovered_tests = 0
+    num_discovered_replay_tests = 0
     jedi_project = jedi.Project(path=project_root_path)
 
     with test_files_progress_bar(total=len(file_to_test_map), description="Processing test files") as (
@@ -661,11 +664,14 @@ def process_test_files(
                                     position=CodePosition(line_no=name.line, col_no=name.column),
                                 )
                             )
+                            if test_func.test_type == TestType.REPLAY_TEST:
+                                num_discovered_replay_tests += 1
+
                             num_discovered_tests += 1
                 except Exception as e:
                     logger.debug(str(e))
                     continue
 
             progress.advance(task_id)
 
-    return dict(function_to_test_map), num_discovered_tests
+    return dict(function_to_test_map), num_discovered_tests, num_discovered_replay_tests

codeflash/discovery/discover_unit_tests.py

@@ -304,7 +304,7 @@ def get_all_replay_test_functions(
         logger.error("Could not find trace_file_path in replay test files.")
         exit_with_message("Could not find trace_file_path in replay test files.")
 
-    function_tests, _ = discover_unit_tests(test_cfg, discover_only_these_tests=replay_test)
+    function_tests, _, _ = discover_unit_tests(test_cfg, discover_only_these_tests=replay_test)
     # Get the absolute file paths for each function, excluding class name if present
     filtered_valid_functions = defaultdict(list)
     file_to_functions_map = defaultdict(list)

codeflash/discovery/functions_to_optimize.py

@@ -905,7 +905,7 @@ def setup_and_establish_baseline(
             if self.args.override_fixtures:
                 restore_conftest(original_conftest_content)
             cleanup_paths(paths_to_cleanup)
-            return Failure("The threshold for test coverage was not met.")
+            return Failure("The threshold for test confidence was not met.")
 
         return Success(
             (
@@ -1016,11 +1016,7 @@ def find_and_process_best_optimization(
                     qualified_name = self.function_to_optimize.qualified_name_with_modules_from_root(self.project_root)
                     # Add runtime comments to generated tests before creating the PR
                     generated_tests = add_runtime_comments_to_generated_tests(
-                        qualified_name,
-                        self.test_cfg,
-                        generated_tests,
-                        original_runtime_by_test,
-                        optimized_runtime_by_test,
+                        generated_tests, original_runtime_by_test, optimized_runtime_by_test
                     )
                     generated_tests_str = "\n\n".join(
                         [test.generated_original_test_source for test in generated_tests.generated_tests]

codeflash/optimization/function_optimizer.py

@@ -227,12 +227,12 @@ def discover_tests(
 
         console.rule()
         start_time = time.time()
-        function_to_tests, num_discovered_tests = discover_unit_tests(
+        function_to_tests, num_discovered_tests, num_discovered_replay_tests = discover_unit_tests(
             self.test_cfg, file_to_funcs_to_optimize=file_to_funcs_to_optimize
         )
         console.rule()
         logger.info(
-            f"Discovered {num_discovered_tests} existing unit tests in {(time.time() - start_time):.1f}s at {self.test_cfg.tests_root}"
+            f"Discovered {num_discovered_tests} existing unit tests and {num_discovered_replay_tests} replay tests in {(time.time() - start_time):.1f}s at {self.test_cfg.tests_root}"
         )
         console.rule()
         ph("cli-optimize-discovered-tests", {"num_tests": num_discovered_tests})