all roads lead to VSC

KRRT7 · KRRT7 · commit e80a05485f65 · 2025-02-24T14:19:56.000-08:00
diff --git a/codeflash.code-workspace b/codeflash.code-workspace
@@ -0,0 +1,87 @@
+{
+    "folders": [
+        {
+            "path": ".",
+            "name": "codeflash",
+            "extensions": [
+                "charliermarsh.ruff",
+                "ms-python.python",
+            ]
+        },
+        {
+            "path": "docs"
+        },
+        {
+            "path": "tests"
+        },
+        {
+            "path": "code_to_optimize"
+        }
+    ],
+    "settings": {
+        "python.defaultInterpreterPath": "~/miniforge3/envs/dev/bin/python",
+        "python.terminal.activateEnvironment": true
+    },
+    "launch": {
+        "version": "0.2.0",
+        "configurations": [
+            {
+                "name": "bubble_sort",
+                "type": "debugpy",
+                "request": "launch",
+                "program": "${workspaceFolder:codeflash}/codeflash/main.py",
+                "args": [
+                    "--file",
+                    "code_to_optimize/bubble_sort.py",
+                    "--module-root",
+                    "${workspaceFolder:codeflash}",
+                    "--function",
+                    "sorter",
+                    "--test-framework",
+                    "pytest",
+                    "--tests-root",
+                    "code_to_optimize/tests/pytest"
+                ],
+                "cwd": "${workspaceFolder:codeflash}",
+                "console": "integratedTerminal",
+                "env": {
+                    "PYTHONUNBUFFERED": "1"
+                },
+            },
+            {
+                "name": "bubble_sort -all",
+                "type": "debugpy",
+                "request": "launch",
+                "program": "${workspaceFolder:codeflash}/codeflash/main.py",
+                "args": [
+                    "--all",
+                    "--test-framework",
+                    "pytest",
+                    "--tests-root",
+                    "code_to_optimize/tests/pytest",
+                    "--module-root",
+                    "code_to_optimize"
+                ],
+                "cwd": "${workspaceFolder:codeflash}",
+                "console": "integratedTerminal",
+                "env": {
+                    "PYTHONUNBUFFERED": "1"
+                },
+            },
+            {
+                "name": "bubble_sort --file bubble_sort.py (MBR)",
+                "type": "debugpy",
+                "request": "launch",
+                "program": "${workspaceFolder:codeflash}/codeflash/main.py",
+                "args": [
+                    "--all",
+                ],
+                "cwd": "/Users/krrt7/Desktop/work/my-best-repo",
+                "console": "integratedTerminal",
+                "env": {
+                    "PYTHONUNBUFFERED": "1"
+                },
+            }
+        ]
+    }
+}
diff --git a/codeflash/api/aiservice.py b/codeflash/api/aiservice.py
@@ -29,6 +29,7 @@ def __init__(self) -> None:
     def get_aiservice_base_url(self) -> str:
         if os.environ.get("CODEFLASH_AIS_SERVER", default="prod").lower() == "local":
             logger.info("Using local AI Service at http://localhost:8000")
+            console.rule()
             return "http://localhost:8000"
         return "https://app.codeflash.ai"
 
diff --git a/codeflash/optimization/function_optimizer.py b/codeflash/optimization/function_optimizer.py
@@ -855,9 +855,7 @@ def establish_original_code_baseline(
                 )
                 console.rule()
                 return Failure("Failed to establish a baseline for the original code - bevhavioral tests failed.")
-            if not coverage_critic(
-            coverage_results, self.args.test_framework
-                ):
+            if not coverage_critic(coverage_results, self.args.test_framework):
                 return Failure("The threshold for test coverage was not met.")
             if test_framework == "pytest":
                 benchmarking_results, _ = self.run_and_parse_tests(
@@ -898,7 +896,6 @@ def establish_original_code_baseline(
             )
             console.rule()
 
-
             total_timing = benchmarking_results.total_passed_runtime()  # caution: doesn't handle the loop index
             functions_to_remove = [
                 result.id.test_function_name
@@ -1077,7 +1074,6 @@ def run_and_parse_tests(
                     cwd=self.project_root,
                     test_env=test_env,
                     pytest_timeout=INDIVIDUAL_TESTCASE_TIMEOUT,
-                    pytest_cmd=self.test_cfg.pytest_cmd,
                     verbose=True,
                     enable_coverage=enable_coverage,
                 )
@@ -1086,8 +1082,8 @@ def run_and_parse_tests(
                     test_files,
                     cwd=self.project_root,
                     test_env=test_env,
-                    pytest_timeout=INDIVIDUAL_TESTCASE_TIMEOUT,
                     pytest_cmd=self.test_cfg.pytest_cmd,
+                    pytest_timeout=INDIVIDUAL_TESTCASE_TIMEOUT,
                     pytest_target_runtime_seconds=testing_time,
                     pytest_min_loops=pytest_min_loops,
                     pytest_max_loops=pytest_max_loops,
@@ -1097,13 +1093,13 @@ def run_and_parse_tests(
                 raise ValueError(f"Unexpected testing type: {testing_type}")
         except subprocess.TimeoutExpired:
             logger.exception(
-                f'Error running tests in {", ".join(str(f) for f in test_files.test_files)}.\nTimeout Error'
+                f"Error running tests in {', '.join(str(f) for f in test_files.test_files)}.\nTimeout Error"
             )
             return TestResults(), None
         if run_result.returncode != 0 and testing_type == TestingMode.BEHAVIOR:
             logger.debug(
-                f'Nonzero return code {run_result.returncode} when running tests in '
-                f'{", ".join([str(f.instrumented_behavior_file_path) for f in test_files.test_files])}.\n'
+                f"Nonzero return code {run_result.returncode} when running tests in "
+                f"{', '.join([str(f.instrumented_behavior_file_path) for f in test_files.test_files])}.\n"
                 f"stdout: {run_result.stdout}\n"
                 f"stderr: {run_result.stderr}\n"
             )
@@ -1149,4 +1145,3 @@ def generate_and_instrument_tests(
                 zip(generated_test_paths, generated_perf_test_paths)
             )
         ]
-
diff --git a/codeflash/optimization/optimizer.py b/codeflash/optimization/optimizer.py
@@ -149,6 +149,7 @@ def run(self) -> None:
                         f"Optimizing function {function_iterator_count} of {num_optimizable_functions}: "
                         f"{function_to_optimize.qualified_name}"
                     )
+                    console.rule()
 
                     if not (
                         function_to_optimize_ast := get_first_top_level_function_or_method_ast(
diff --git a/codeflash/verification/test_runner.py b/codeflash/verification/test_runner.py
@@ -49,9 +49,10 @@ def run_behavioral_tests(
                 )
             else:
                 test_files.append(str(file.instrumented_behavior_file_path))
+        pytest_cmd_list = shlex.split(
+            f"{SAFE_SYS_EXECUTABLE} -m pytest" if pytest_cmd == "pytest" else pytest_cmd, posix=IS_POSIX
+        )
         test_files = list(set(test_files))  # remove multiple calls in the same test function
-        pytest_cmd_list = shlex.split(pytest_cmd, posix=IS_POSIX)
-
         common_pytest_args = [
             "--capture=tee-sys",
             f"--timeout={pytest_timeout}",
@@ -78,8 +79,7 @@ def run_behavioral_tests(
             logger.debug(cov_erase)
 
             results = execute_test_subprocess(
-                shlex.split(f"{SAFE_SYS_EXECUTABLE} -m coverage run --rcfile={coveragercfile.as_posix()} -m")
-                + pytest_cmd_list
+                shlex.split(f"{SAFE_SYS_EXECUTABLE} -m coverage run --rcfile={coveragercfile.as_posix()} -m pytest")
                 + common_pytest_args
                 + result_args
                 + test_files,
@@ -88,7 +88,8 @@ def run_behavioral_tests(
                 timeout=600,
             )
             logger.debug(
-                f"""Result return code: {results.returncode}, {"Result stderr:" + str(results.stderr) if results.stderr else ''}""")
+                f"""Result return code: {results.returncode}, {"Result stderr:" + str(results.stderr) if results.stderr else ""}"""
+            )
         else:
             results = execute_test_subprocess(
                 pytest_cmd_list + common_pytest_args + result_args + test_files,
@@ -97,15 +98,17 @@ def run_behavioral_tests(
                 timeout=600,  # TODO: Make this dynamic
             )
             logger.debug(
-                f"""Result return code: {results.returncode}, {"Result stderr:" + str(results.stderr) if results.stderr else ''}""")
+                f"""Result return code: {results.returncode}, {"Result stderr:" + str(results.stderr) if results.stderr else ""}"""
+            )
     elif test_framework == "unittest":
         if enable_coverage:
             raise ValueError("Coverage is not supported yet for unittest framework")
         test_env["CODEFLASH_LOOP_INDEX"] = "1"
         test_files = [file.instrumented_behavior_file_path for file in test_paths.test_files]
         result_file_path, results = run_unittest_tests(verbose, test_files, test_env, cwd)
         logger.debug(
-            f"""Result return code: {results.returncode}, {"Result stderr:" + str(results.stderr) if results.stderr else ''}""")
+            f"""Result return code: {results.returncode}, {"Result stderr:" + str(results.stderr) if results.stderr else ""}"""
+        )
     else:
         raise ValueError(f"Unsupported test framework: {test_framework}")
 
@@ -125,7 +128,11 @@ def run_benchmarking_tests(
     pytest_max_loops: int = 100_000,
 ):
     if test_framework == "pytest":
-        pytest_cmd_list = shlex.split(pytest_cmd, posix=IS_POSIX)
+        pytest_cmd_list = (
+            shlex.split(f"{SAFE_SYS_EXECUTABLE} -m pytest", posix=IS_POSIX)
+            if pytest_cmd == "pytest"
+            else shlex.split(pytest_cmd)
+        )
         test_files: list[str] = []
         for file in test_paths.test_files:
             if file.test_type in [TestType.REPLAY_TEST, TestType.EXISTING_UNIT_TEST] and file.tests_in_file:
diff --git a/codeflash/verification/verification_utils.py b/codeflash/verification/verification_utils.py
@@ -6,6 +6,8 @@
 
 from pydantic.dataclasses import dataclass
 
+from codeflash.code_utils.compat import SAFE_SYS_EXECUTABLE
+
 
 def get_test_file_path(test_dir: Path, function_name: str, iteration: int = 0, test_type: str = "unit") -> Path:
     assert test_type in ["unit", "inspired", "replay", "perf"]
@@ -73,4 +75,4 @@ class TestConfig:
     # tests_project_rootdir corresponds to pytest rootdir,
     # or for unittest - project_root_from_module_root(args.tests_root, pyproject_file_path)
     concolic_test_root_dir: Optional[Path] = None
-    pytest_cmd: str = "pytest"
+    pytest_cmd: str = "pytest"
diff --git a/pyproject.toml b/pyproject.toml
@@ -120,6 +120,7 @@ types-greenlet = "^3.1.0.20241221"
 types-pexpect = "^4.9.0.20241208"
 types-unidiff = "^0.7.0.20240505"
 sqlalchemy = "^2.0.38"
+uv = ">=0.6.2"
 
 [tool.poetry.build]
 script = "codeflash/update_license_version.py"
@@ -215,8 +216,8 @@ module-root = "codeflash"
 tests-root = "tests"
 test-framework = "pytest"
 formatter-cmds = [
-    "poetry run ruff check --exit-zero --fix $file",
-    "poetry run ruff format $file",
+    "uvx ruff check --exit-zero --fix $file",
+    "uvx ruff format $file",
 ]
 
 

Original file line number	Diff line number	Diff line change
`@@ -149,6 +149,7 @@ def run(self) -> None:`
`149`	`149`	`f"Optimizing function {function_iterator_count} of {num_optimizable_functions}: "`
`150`	`150`	`f"{function_to_optimize.qualified_name}"`
`151`	`151`	`)`
	`152`	`+ console.rule()`
`152`	`153`
`153`	`154`	`if not (`
`154`	`155`	`function_to_optimize_ast := get_first_top_level_function_or_method_ast(`