removed prints, added cfapi.py func

Author: dasarchan

codeflash/api/cfapi.py

@@ -6,7 +6,7 @@
 import sys
 from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Optional, Dict
 
 import requests
 import sentry_sdk
@@ -204,18 +204,17 @@ def get_blocklisted_functions() -> dict[str, set[str]] | dict[str, Any]:
     return {Path(k).name: {v.replace("()", "") for v in values} for k, values in content.items()}
 
 
-def is_function_being_optimized_again(code_context: CodeOptimizationContext) -> bool:
+def is_function_being_optimized_again(owner: str, repo: str, pr_number: int, code_contexts: dict[str, str]) -> Dict:
     """Check if the function being optimized is being optimized again."""
-    pr_number = get_pr_number()
-    if pr_number is None:
-        # Only want to do this check during GH Actions
-        return False
-    owner, repo = get_repo_owner_and_name()
-    # TODO: Add file paths
-    rw_context_hash = hashlib.sha256(str(code_context.read_writable_code).encode()).hexdigest()
-
-    payload = {"owner": owner, "repo": repo, "pullNumber": pr_number, "code_hash": rw_context_hash}
-    response = make_cfapi_request(endpoint="/is-function-being-optimized-again", method="POST", payload=payload)
-    if not response.ok or response.text != "true":
-        logger.error(f"Error: {response.text}")
-        return False
+    response = make_cfapi_request(
+        "/is-already-optimized",
+        "POST",
+        {
+            "owner": owner,
+            "repo": repo,
+            "pr_number": pr_number,
+            "code_contexts": code_contexts
+        }
+    )
+    response.raise_for_status()
+    return response.json()

codeflash/discovery/functions_to_optimize.py

@@ -15,7 +15,7 @@
 import libcst as cst
 from pydantic.dataclasses import dataclass
 
-from codeflash.api.cfapi import get_blocklisted_functions, make_cfapi_request
+from codeflash.api.cfapi import get_blocklisted_functions, make_cfapi_request, is_function_being_optimized_again
 from codeflash.cli_cmds.console import DEBUG_MODE, console, logger
 from codeflash.code_utils.code_utils import (
     is_class_defined_in_file,
@@ -474,7 +474,6 @@ def check_optimization_status(
     Returns:
         Tuple of (filtered_functions_dict, remaining_count)
     """
-    logger.info("entering function")
     # Build the code_contexts dictionary for the API call
     code_contexts = {}
     path_to_function_map = {}
@@ -491,23 +490,9 @@ def check_optimization_status(
         return {}, 0
 
     try:
-        # Call the optimization check API
-        logger.info("Checking status")
-        response = make_cfapi_request(
-            "/is-already-optimized",
-            "POST",
-            {
-                "owner": owner,
-                "repo": repo,
-                "pr_number": pr_number,
-                "code_contexts": code_contexts
-            }
-        )
-        response.raise_for_status()
-        result = response.json()
+        result = is_function_being_optimized_again(owner, repo, pr_number, code_contexts)
         already_optimized_paths = set(result.get("already_optimized_paths", []))
 
-        logger.info(f"Found {len(already_optimized_paths)} already optimized functions")
 
         # Filter out already optimized functions
         filtered_functions = defaultdict(list)
@@ -522,7 +507,6 @@ def check_optimization_status(
 
     except Exception as e:
         logger.warning(f"Failed to check optimization status: {e}")
-        logger.info("Proceeding with all functions (optimization check failed)")
         # Return all functions if API call fails
         total_count = sum(len(funcs) for funcs in functions_by_file.values())
         return functions_by_file, total_count
@@ -536,7 +520,6 @@ def filter_functions(
         module_root: Path,
         disable_logs: bool = False,
 ) -> tuple[dict[Path, list[FunctionToOptimize]], int]:
-    logger.info("filtering functions boogaloo")
     blocklist_funcs = get_blocklisted_functions()
     # Remove any function that we don't want to optimize
 
@@ -601,7 +584,6 @@ def filter_functions(
     repository = git.Repo(Path.cwd(), search_parent_directories=True)
     owner, repo = get_repo_owner_and_name(repository)
     pr_number = get_pr_number()
-    print(owner, repo, pr_number)
     if owner and repo and pr_number is not None:
         path_based_functions, functions_count = check_optimization_status(
             path_based_functions, owner, repo, pr_number

codeflash/optimization/function_optimizer.py

@@ -145,9 +145,6 @@ def optimize_function(self) -> Result[BestOptimization, str]:
         if has_any_async_functions(code_context.read_writable_code):
             return Failure("Codeflash does not support async functions in the code to optimize.")
 
-        if is_function_being_optimized_again(code_context=code_context):
-            return Failure("This code has already been optimized earlier")
-
         code_print(code_context.read_writable_code)
         generated_test_paths = [
             get_test_file_path(