remove --async

Author: KRRT7

codeflash/cli_cmds/cli.py

@@ -1,4 +1,3 @@
-import importlib.util
 import logging
 import sys
 from argparse import SUPPRESS, ArgumentParser, Namespace
@@ -100,12 +99,6 @@ def parse_args() -> Namespace:
     )
     parser.add_argument("--no-draft", default=False, action="store_true", help="Skip optimization for draft PRs")
     parser.add_argument("--worktree", default=False, action="store_true", help="Use worktree for optimization")
-    parser.add_argument(
-        "--async",
-        default=False,
-        action="store_true",
-        help="Enable optimization of async functions. By default, async functions are excluded from optimization.",
-    )
 
     args, unknown_args = parser.parse_known_args()
     sys.argv[:] = [sys.argv[0], *unknown_args]
@@ -155,14 +148,6 @@ def process_and_validate_cmd_args(args: Namespace) -> Namespace:
         if env_utils.is_ci():
             args.no_pr = True
 
-    if getattr(args, "async", False) and importlib.util.find_spec("pytest_asyncio") is None:
-        logger.warning(
-            "Warning: The --async flag requires pytest-asyncio to be installed.\n"
-            "Please install it using:\n"
-            '  pip install "codeflash[asyncio]"'
-        )
-        raise SystemExit(1)
-
     return args
 
 

codeflash/discovery/functions_to_optimize.py

@@ -179,8 +179,6 @@ def get_functions_to_optimize(
     project_root: Path,
     module_root: Path,
     previous_checkpoint_functions: dict[str, dict[str, str]] | None = None,
-    *,
-    enable_async: bool = False,
 ) -> tuple[dict[Path, list[FunctionToOptimize]], int, Path | None]:
     assert sum([bool(optimize_all), bool(replay_test), bool(file)]) <= 1, (
         "Only one of optimize_all, replay_test, or file should be provided"
@@ -248,7 +246,6 @@ def get_functions_to_optimize(
             project_root,
             module_root,
             previous_checkpoint_functions,
-            enable_async=enable_async,
         )
 
         logger.info(f"!lsp|Found {functions_count} function{'s' if functions_count > 1 else ''} to optimize")
@@ -658,7 +655,6 @@ def filter_functions(
     previous_checkpoint_functions: dict[Path, dict[str, Any]] | None = None,
     *,
     disable_logs: bool = False,
-    enable_async: bool = False,
 ) -> tuple[dict[Path, list[FunctionToOptimize]], int]:
     filtered_modified_functions: dict[str, list[FunctionToOptimize]] = {}
     blocklist_funcs = get_blocklisted_functions()
@@ -678,7 +674,6 @@ def filter_functions(
     submodule_ignored_paths_count: int = 0
     blocklist_funcs_removed_count: int = 0
     previous_checkpoint_functions_removed_count: int = 0
-    async_functions_removed_count: int = 0
     tests_root_str = str(tests_root)
     module_root_str = str(module_root)
 
@@ -734,15 +729,6 @@ def filter_functions(
                 functions_tmp.append(function)
             _functions = functions_tmp
 
-        if not enable_async:
-            functions_tmp = []
-            for function in _functions:
-                if function.is_async:
-                    async_functions_removed_count += 1
-                    continue
-                functions_tmp.append(function)
-            _functions = functions_tmp
-
         filtered_modified_functions[file_path] = _functions
         functions_count += len(_functions)
 
@@ -756,7 +742,6 @@ def filter_functions(
             "Files from ignored submodules": (submodule_ignored_paths_count, "bright_black"),
             "Blocklisted functions removed": (blocklist_funcs_removed_count, "bright_red"),
             "Functions skipped from checkpoint": (previous_checkpoint_functions_removed_count, "green"),
-            "Async functions removed": (async_functions_removed_count, "bright_magenta"),
         }
         tree = Tree(Text("Ignored functions and files", style="bold"))
         for label, (count, color) in log_info.items():

codeflash/optimization/optimizer.py

@@ -134,7 +134,6 @@ def get_optimizable_functions(self) -> tuple[dict[Path, list[FunctionToOptimize]
             project_root=self.args.project_root,
             module_root=self.args.module_root,
             previous_checkpoint_functions=self.args.previous_checkpoint_functions,
-            enable_async=getattr(self.args, "async", False),
         )
 
     def create_function_optimizer(

tests/scripts/end_to_end_test_async.py

@@ -8,7 +8,6 @@ def run_test(expected_improvement_pct: int) -> bool:
     config = TestConfig(
         file_path="main.py",
         min_improvement_x=0.1,
-        enable_async=True,
         coverage_expectations=[
             CoverageExpectation(
                 function_name="retry_with_backoff",

tests/scripts/end_to_end_test_utilities.py

@@ -27,7 +27,6 @@ class TestConfig:
     trace_mode: bool = False
     coverage_expectations: list[CoverageExpectation] = field(default_factory=list)
     benchmarks_root: Optional[pathlib.Path] = None
-    enable_async: bool = False
     use_worktree: bool = False
 
 
@@ -136,8 +135,6 @@ def build_command(
         )
     if benchmarks_root:
         base_command.extend(["--benchmark", "--benchmarks-root", str(benchmarks_root)])
-    if config.enable_async:
-        base_command.append("--async")
     if config.use_worktree:
         base_command.append("--worktree")
     return base_command

tests/test_async_function_discovery.py

@@ -244,7 +244,6 @@ def sync_method(self):
         ignore_paths=[],
         project_root=file_path.parent,
         module_root=file_path.parent,
-        enable_async=True,
     )
 
     assert functions_count == 4
@@ -259,7 +258,8 @@ def sync_method(self):
 
 
 @pytest.mark.skipif(sys.platform == "win32", reason="pending support for asyncio on windows")
-def test_no_async_functions_finding(temp_dir):
+def test_async_functions_always_included(temp_dir):
+    """Test that async functions are always included now (no longer filtered out)."""
     mixed_code = """
 async def async_func_one():
     return await operation_one()
@@ -297,16 +297,17 @@ def sync_method(self):
         ignore_paths=[],
         project_root=file_path.parent,
         module_root=file_path.parent,
-        enable_async=False,
     )
 
-    assert functions_count == 2
+    # Now async functions are always included, so we expect 4 functions (not 2)
+    assert functions_count == 4
 
     function_names = [fn.function_name for fn in functions[file_path]]
     assert "sync_func_one" in function_names
     assert "sync_method" in function_names
-    assert "async_func_one" not in function_names
-    assert "async_method" not in function_names
+    # Async functions are now included by default
+    assert "async_func_one" in function_names
+    assert "async_method" in function_names
 
 
 @pytest.mark.skipif(sys.platform == "win32", reason="pending support for asyncio on windows")