fix inline condition

Author: saga4

codeflash/api/aiservice.py

@@ -10,7 +10,7 @@
 from pydantic.json import pydantic_encoder
 
 from codeflash.cli_cmds.console import console, logger
-from codeflash.code_utils.config_consts import get_n_candidates, get_n_candidates_lp
+from codeflash.code_utils.config_consts import N_CANDIDATES_EFFECTIVE, N_CANDIDATES_LP_EFFECTIVE
 from codeflash.code_utils.env_utils import get_codeflash_api_key
 from codeflash.code_utils.git_utils import get_last_commit_author_if_pr_exists, get_repo_owner_and_name
 from codeflash.lsp.helpers import is_LSP_enabled
@@ -132,7 +132,7 @@ def optimize_python_code(  # noqa: D417
             "current_username": get_last_commit_author_if_pr_exists(None),
             "repo_owner": git_repo_owner,
             "repo_name": git_repo_name,
-            "n_candidates": get_n_candidates(),
+            "n_candidates": N_CANDIDATES_EFFECTIVE,
         }
 
         logger.info("Generating optimized candidates…")
@@ -194,7 +194,7 @@ def optimize_python_code_line_profiler(  # noqa: D417
             "experiment_metadata": experiment_metadata,
             "codeflash_version": codeflash_version,
             "lsp_mode": is_LSP_enabled(),
-            "n_candidates_lp": get_n_candidates_lp(),
+            "n_candidates_lp": N_CANDIDATES_LP_EFFECTIVE,
         }
 
         logger.info("Generating optimized candidates…")

codeflash/code_utils/config_consts.py

@@ -19,26 +19,20 @@
 TOTAL_LOOPING_TIME_LSP = 10.0  # Kept same timing for LSP mode to avoid in increase in performance reporting
 N_CANDIDATES_LP_LSP = 3
 
+# Max limits to prevent excessive API calls
+MAX_N_CANDIDATES = 5
+MAX_N_CANDIDATES_LP = 6
 
-def get_n_candidates() -> int:
+# Inlined variables - determine LSP mode once at import time
+try:
     from codeflash.lsp.helpers import is_LSP_enabled
 
-    return N_CANDIDATES_LSP if is_LSP_enabled() else N_CANDIDATES
+    _IS_LSP_ENABLED = is_LSP_enabled()
+except ImportError:
+    _IS_LSP_ENABLED = False
 
-
-def get_n_candidates_lp() -> int:
-    from codeflash.lsp.helpers import is_LSP_enabled
-
-    return N_CANDIDATES_LP_LSP if is_LSP_enabled() else N_CANDIDATES_LP
-
-
-def get_n_tests_to_generate() -> int:
-    from codeflash.lsp.helpers import is_LSP_enabled
-
-    return N_TESTS_TO_GENERATE_LSP if is_LSP_enabled() else N_TESTS_TO_GENERATE
-
-
-def get_total_looping_time() -> float:
-    from codeflash.lsp.helpers import is_LSP_enabled
-
-    return TOTAL_LOOPING_TIME_LSP if is_LSP_enabled() else TOTAL_LOOPING_TIME
+# Direct variables with max limits applied
+N_CANDIDATES_EFFECTIVE = min(N_CANDIDATES_LSP if _IS_LSP_ENABLED else N_CANDIDATES, MAX_N_CANDIDATES)
+N_CANDIDATES_LP_EFFECTIVE = min(N_CANDIDATES_LP_LSP if _IS_LSP_ENABLED else N_CANDIDATES_LP, MAX_N_CANDIDATES_LP)
+N_TESTS_TO_GENERATE_EFFECTIVE = N_TESTS_TO_GENERATE_LSP if _IS_LSP_ENABLED else N_TESTS_TO_GENERATE
+TOTAL_LOOPING_TIME_EFFECTIVE = TOTAL_LOOPING_TIME_LSP if _IS_LSP_ENABLED else TOTAL_LOOPING_TIME

codeflash/code_utils/git_utils.py

@@ -16,7 +16,7 @@
 from unidiff import PatchSet
 
 from codeflash.cli_cmds.console import logger
-from codeflash.code_utils.config_consts import get_n_candidates
+from codeflash.code_utils.config_consts import N_CANDIDATES_EFFECTIVE
 
 if TYPE_CHECKING:
     from git import Repo
@@ -164,7 +164,7 @@ def create_git_worktrees(
 ) -> tuple[Path | None, list[Path]]:
     if git_root and worktree_root_dir:
         worktree_root = Path(tempfile.mkdtemp(dir=worktree_root_dir))
-        worktrees = [Path(tempfile.mkdtemp(dir=worktree_root)) for _ in range(get_n_candidates() + 1)]
+        worktrees = [Path(tempfile.mkdtemp(dir=worktree_root)) for _ in range(N_CANDIDATES_EFFECTIVE + 1)]
         for worktree in worktrees:
             subprocess.run(["git", "worktree", "add", "-d", worktree], cwd=module_root, check=True)
     else:

codeflash/optimization/function_optimizer.py

@@ -43,11 +43,11 @@
 )
 from codeflash.code_utils.config_consts import (
     INDIVIDUAL_TESTCASE_TIMEOUT,
+    N_CANDIDATES_EFFECTIVE,
+    N_CANDIDATES_LP_EFFECTIVE,
+    N_TESTS_TO_GENERATE_EFFECTIVE,
     REPEAT_OPTIMIZATION_PROBABILITY,
-    get_n_candidates,
-    get_n_candidates_lp,
-    get_n_tests_to_generate,
-    get_total_looping_time,
+    TOTAL_LOOPING_TIME_EFFECTIVE,
 )
 from codeflash.code_utils.deduplicate_code import normalize_code
 from codeflash.code_utils.edit_generated_tests import (
@@ -232,7 +232,7 @@ def __init__(
         self.generate_and_instrument_tests_results: (
             tuple[GeneratedTestsList, dict[str, set[FunctionCalledInTest]], OptimizationSet] | None
         ) = None
-        n_tests = get_n_tests_to_generate()
+        n_tests = N_TESTS_TO_GENERATE_EFFECTIVE
         self.executor = concurrent.futures.ThreadPoolExecutor(
             max_workers=n_tests + 2 if self.experiment_id is None else n_tests + 3
         )
@@ -284,7 +284,7 @@ def generate_and_instrument_tests(
         ]
     ]:
         """Generate and instrument tests, returning all necessary data for optimization."""
-        n_tests = get_n_tests_to_generate()
+        n_tests = N_TESTS_TO_GENERATE_EFFECTIVE
         generated_test_paths = [
             get_test_file_path(
                 self.test_cfg.tests_root, self.function_to_optimize.function_name, test_index, test_type="unit"
@@ -477,7 +477,7 @@ def determine_best_candidate(
             dependency_code=code_context.read_only_context_code,
             trace_id=self.function_trace_id[:-4] + exp_type if self.experiment_id else self.function_trace_id,
             line_profiler_results=original_code_baseline.line_profile_results["str_out"],
-            num_candidates=get_n_candidates_lp(),
+            num_candidates=N_CANDIDATES_LP_EFFECTIVE,
             experiment_metadata=ExperimentMetadata(
                 id=self.experiment_id, group="control" if exp_type == "EXP0" else "experiment"
             )
@@ -1013,7 +1013,7 @@ def generate_tests_and_optimizations(
         generated_perf_test_paths: list[Path],
         run_experiment: bool = False,  # noqa: FBT001, FBT002
     ) -> Result[tuple[GeneratedTestsList, dict[str, set[FunctionCalledInTest]], OptimizationSet], str]:
-        n_tests = get_n_tests_to_generate()
+        n_tests = N_TESTS_TO_GENERATE_EFFECTIVE
         assert len(generated_test_paths) == n_tests
         console.rule()
         # Submit the test generation task as future
@@ -1024,7 +1024,7 @@ def generate_tests_and_optimizations(
             generated_test_paths,
             generated_perf_test_paths,
         )
-        n_candidates = get_n_candidates()
+        n_candidates = N_CANDIDATES_EFFECTIVE
         future_optimization_candidates = self.executor.submit(
             self.aiservice_client.optimize_python_code,
             read_writable_code.markdown,
@@ -1421,7 +1421,7 @@ def establish_original_code_baseline(
                 instrument_codeflash_capture(
                     self.function_to_optimize, file_path_to_helper_classes, self.test_cfg.tests_root
                 )
-                total_looping_time = get_total_looping_time()
+                total_looping_time = TOTAL_LOOPING_TIME_EFFECTIVE
                 behavioral_results, coverage_results = self.run_and_parse_tests(
                     testing_type=TestingMode.BEHAVIOR,
                     test_env=test_env,
@@ -1561,7 +1561,7 @@ def run_optimized_candidate(
                     self.function_to_optimize, file_path_to_helper_classes, self.test_cfg.tests_root
                 )
 
-                total_looping_time = get_total_looping_time()
+                total_looping_time = TOTAL_LOOPING_TIME_EFFECTIVE
                 candidate_behavior_results, _ = self.run_and_parse_tests(
                     testing_type=TestingMode.BEHAVIOR,
                     test_env=test_env,
@@ -1614,7 +1614,7 @@ def run_optimized_candidate(
                 start_time: float = time.time()
                 loop_count = 0
                 for i in range(100):
-                    if i >= 5 and time.time() - start_time >= get_total_looping_time() * 1.5:
+                    if i >= 5 and time.time() - start_time >= TOTAL_LOOPING_TIME_EFFECTIVE * 1.5:
                         # * 1.5 to give unittest a bit more time to run
                         break
                     test_env["CODEFLASH_LOOP_INDEX"] = str(i + 1)
@@ -1623,7 +1623,7 @@ def run_optimized_candidate(
                         test_env=test_env,
                         test_files=self.test_files,
                         optimization_iteration=optimization_candidate_index,
-                        testing_time=get_total_looping_time(),
+                        testing_time=TOTAL_LOOPING_TIME_EFFECTIVE,
                         unittest_loop_index=i + 1,
                     )
                     loop_count = i + 1
@@ -1662,7 +1662,7 @@ def run_and_parse_tests(
         test_env: dict[str, str],
         test_files: TestFiles,
         optimization_iteration: int,
-        testing_time: float = get_total_looping_time(),
+        testing_time: float = TOTAL_LOOPING_TIME_EFFECTIVE,
         *,
         enable_coverage: bool = False,
         pytest_min_loops: int = 5,
@@ -1813,7 +1813,7 @@ def line_profiler_step(
                 test_env=test_env,
                 test_files=self.test_files,
                 optimization_iteration=0,
-                testing_time=get_total_looping_time(),
+                testing_time=TOTAL_LOOPING_TIME_EFFECTIVE,
                 enable_coverage=False,
                 code_context=code_context,
                 line_profiler_output_file=line_profiler_output_file,