Might work?

Author: misrasaurabh1

codeflash/code_utils/git_utils.py

@@ -5,6 +5,7 @@
 import sys
 import tempfile
 import time
+from functools import cache
 from io import StringIO
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -79,6 +80,7 @@ def get_git_remotes(repo: Repo) -> list[str]:
     return [remote.name for remote in repository.remotes]
 
 
+@cache
 def get_repo_owner_and_name(repo: Repo | None = None, git_remote: str | None = "origin") -> tuple[str, str]:
     remote_url = get_remote_url(repo, git_remote)  # call only once
     remote_url = remote_url.removesuffix(".git") if remote_url.endswith(".git") else remote_url

codeflash/discovery/functions_to_optimize.py

@@ -22,7 +22,6 @@
     module_name_from_file_path,
     path_belongs_to_site_packages,
 )
-from codeflash.code_utils.config_consts import REPEAT_OPTIMIZATION_PROBABILITY
 from codeflash.code_utils.env_utils import get_pr_number
 from codeflash.code_utils.git_utils import get_git_diff, get_repo_owner_and_name
 from codeflash.code_utils.time_utils import humanize_runtime
@@ -34,6 +33,7 @@
     from libcst import CSTNode
     from libcst.metadata import CodeRange
 
+    from codeflash.models.models import CodeOptimizationContext
     from codeflash.verification.verification_utils import TestConfig
 
 
@@ -127,8 +127,8 @@ class FunctionToOptimize:
     function_name: str
     file_path: Path
     parents: list[FunctionParent]  # list[ClassDef | FunctionDef | AsyncFunctionDef]
-    starting_line: Optional[int] = None
-    ending_line: Optional[int] = None
+    starting_line: int | None = None
+    ending_line: int | None = None
 
     @property
     def top_level_parent_name(self) -> str:
@@ -147,47 +147,6 @@ def qualified_name(self) -> str:
     def qualified_name_with_modules_from_root(self, project_root_path: Path) -> str:
         return f"{module_name_from_file_path(self.file_path, project_root_path)}.{self.qualified_name}"
 
-    def get_code_context_hash(self) -> str:
-        """Generate a SHA-256 hash representing the code context of this function.
-
-        This hash includes the function's code content, file path, and qualified name
-        to uniquely identify the function for optimization tracking.
-        """
-        try:
-            with open(self.file_path, encoding="utf-8") as f:
-                file_content = f.read()
-
-            # Extract the function's code content
-            lines = file_content.splitlines()
-            print("starting and ending line ", self.starting_line, self.ending_line)
-            if self.starting_line is not None and self.ending_line is not None:
-                # Use line numbers if available (1-indexed to 0-indexed)
-                function_content = "\n".join(lines[self.starting_line - 1 : self.ending_line])
-            else:
-                # Fallback: use the entire file content if line numbers aren't available
-                function_content = file_content
-
-            # Create a context string that includes:
-            # - File path (relative to make it portable)
-            # - Qualified function name
-            # - Function code content
-            context_parts = [
-                str(self.file_path.name),  # Just filename for portability
-                self.qualified_name,
-                function_content.strip(),
-            ]
-
-            context_string = "\n---\n".join(context_parts)
-
-            # Generate SHA-256 hash
-            return hashlib.sha256(context_string.encode("utf-8")).hexdigest()
-
-        except OSError as e:
-            logger.warning(f"Could not read file {self.file_path} for hashing: {e}")
-            # Fallback hash using available metadata
-            fallback_string = f"{self.file_path.name}:{self.qualified_name}"
-            return hashlib.sha256(fallback_string.encode("utf-8")).hexdigest()
-
 
 def get_functions_to_optimize(
     optimize_all: str | None,
@@ -461,58 +420,55 @@ def inspect_top_level_functions_or_methods(
     )
 
 
-def check_optimization_status(functions_by_file: dict[Path, list[FunctionToOptimize]], project_root_path: Path) -> set[tuple[str, str]]:
+def check_optimization_status(function_to_optimize: FunctionToOptimize, code_context: CodeOptimizationContext) -> bool:
     """Check which functions have already been optimized and filter them out.
 
     This function calls the optimization API to:
     1. Check which functions are already optimized
     2. Log new function hashes to the database
     3. Return only functions that need optimization
 
-    Args:
-        functions_by_file: Dictionary mapping file paths to lists of functions
-        owner: Repository owner
-        repo: Repository name
-        pr_number: Pull request number
-
     Returns:
         Tuple of (filtered_functions_dict, remaining_count)
 
     """
     # Check optimization status if repository info is provided
     # already_optimized_count = 0
     try:
-        repository = git.Repo(search_parent_directories=True)
-        owner, repo = get_repo_owner_and_name(repository)
+        owner, repo = get_repo_owner_and_name()
     except git.exc.InvalidGitRepositoryError:
         logger.warning("No git repository found")
         owner, repo = None, None
     pr_number = get_pr_number()
 
     if not owner or not repo or pr_number is None:
-        return []
+        return False
 
     code_contexts = []
 
-    for file_path, functions in functions_by_file.items():
-        for func in functions:
-            func_hash = func.get_code_context_hash()
-            # Use a unique path identifier that includes function info
-            code_contexts.append({"file_path": Path(file_path).relative_to(project_root_path),
-                                  "function_name": func.qualified_name, "code_hash": func_hash})
+    func_hash = hashlib.sha256(code_context.hashing_code_context.encode("utf-8")).hexdigest()
+    # Use a unique path identifier that includes function info
+
+    code_contexts.append(
+        {
+            "file_path": function_to_optimize.file_path,
+            "function_name": function_to_optimize.qualified_name,
+            "code_hash": func_hash,
+        }
+    )
 
     if not code_contexts:
-        return set(tuple())
+        return False
 
     try:
         result = is_function_being_optimized_again(owner, repo, pr_number, code_contexts)
         already_optimized_paths: list[tuple[str, str]] = result.get("already_optimized_tuples", [])
-        return set(( project_root_path / Path(path[0]), path[1]) for path in already_optimized_paths)
+        return len(already_optimized_paths) > 0
 
     except Exception as e:
         logger.warning(f"Failed to check optimization status: {e}")
         # Return all functions if API call fails
-        return set(tuple())
+        return False
 
 
 def filter_functions(
@@ -528,8 +484,7 @@ def filter_functions(
     blocklist_funcs = get_blocklisted_functions()
     logger.debug(f"Blocklisted functions: {blocklist_funcs}")
     # Remove any function that we don't want to optimize
-    already_optimized_paths = check_optimization_status(modified_functions, project_root)
-
+    # already_optimized_paths = check_optimization_status(modified_functions, project_root)
 
     # Ignore files with submodule path, cache the submodule paths
     submodule_paths = ignored_submodule_paths(module_root)
@@ -543,7 +498,6 @@ def filter_functions(
     already_optimized_count: int = 0
     submodule_ignored_paths_count: int = 0
     blocklist_funcs_removed_count: int = 0
-    already_optimized_paths_removed_count: int = 0
     previous_checkpoint_functions_removed_count: int = 0
     tests_root_str = str(tests_root)
     module_root_str = str(module_root)
@@ -590,17 +544,6 @@ def filter_functions(
                 # This function is NOT in blocklist. we can keep it
                 functions_tmp.append(function)
             _functions = functions_tmp
-        functions_tmp = []
-        for function in _functions:
-            if (
-                function.file_path,
-                function.qualified_name,
-            ) in already_optimized_paths and random.random() > REPEAT_OPTIMIZATION_PROBABILITY:
-                # This function is in blocklist, we can skip it with a probability
-                already_optimized_paths_removed_count += 1
-                continue
-            functions_tmp.append(function)
-        _functions = functions_tmp
 
         if previous_checkpoint_functions:
             functions_tmp = []
@@ -625,7 +568,6 @@ def filter_functions(
             f"{already_optimized_count} already optimized function{'s' if already_optimized_count != 1 else ''}": already_optimized_count,
             f"{blocklist_funcs_removed_count} function{'s' if blocklist_funcs_removed_count != 1 else ''} as previously optimized": blocklist_funcs_removed_count,
             f"{previous_checkpoint_functions_removed_count} function{'s' if previous_checkpoint_functions_removed_count != 1 else ''} skipped from checkpoint": previous_checkpoint_functions_removed_count,
-            f"{already_optimized_paths_removed_count} function{'s' if already_optimized_paths_removed_count != 1 else ''} as previously attempted optimization": already_optimized_paths_removed_count,
         }
         log_string = "\n".join([k for k, v in log_info.items() if v > 0])
         if log_string:

codeflash/optimization/function_optimizer.py

@@ -53,6 +53,7 @@
 from codeflash.code_utils.time_utils import humanize_runtime
 from codeflash.context import code_context_extractor
 from codeflash.context.unused_definition_remover import detect_unused_helper_functions, revert_unused_helper_functions
+from codeflash.discovery.functions_to_optimize import check_optimization_status
 from codeflash.either import Failure, Success, is_successful
 from codeflash.models.ExperimentMetadata import ExperimentMetadata
 from codeflash.models.models import (
@@ -151,8 +152,11 @@ def optimize_function(self) -> Result[BestOptimization, str]:  # noqa: PLR0911
             with helper_function_path.open(encoding="utf8") as f:
                 helper_code = f.read()
                 original_helper_code[helper_function_path] = helper_code
+
         if has_any_async_functions(code_context.read_writable_code):
             return Failure("Codeflash does not support async functions in the code to optimize.")
+        if check_optimization_status(self.function_to_optimize, code_context):
+            return Failure("This function has already been optimized, skipping.")
 
         code_print(code_context.read_writable_code)
         generated_test_paths = [