Merge pull request #1411 from codeflash-ai/init_caching

init caching enabled by instrumenting @codeflash_capture on __init__ [CF-496]

Author: alvin-r

code_to_optimize/bubble_sort_method.py

@@ -0,0 +1,12 @@
+class BubbleSorter:
+    def __init__(self, x=0):
+        self.x = x
+
+    def sorter(self, arr):
+        for i in range(len(arr)):
+            for j in range(len(arr) - 1):
+                if arr[j] > arr[j + 1]:
+                    temp = arr[j]
+                    arr[j] = arr[j + 1]
+                    arr[j + 1] = temp
+        return arr

code_to_optimize/remove_control_chars.py

@@ -0,0 +1,10 @@
+import re
+
+
+class CharacterRemover:
+    def __init__(self):
+        self.version = "0.1"
+
+    def remove_control_characters(self, s) -> str:
+        """Remove control characters from the string."""
+        return re.sub("[\\x00-\\x1F\\x7F]", "", s) if s else ""

code_to_optimize/text_processor.py

@@ -0,0 +1,190 @@
+class TextProcessor:
+    def __init__(self):
+        self.version = "0.1"
+
+    def find_unique_words(self, text):
+        stop_words = {
+            "a",
+            "about",
+            "above",
+            "after",
+            "again",
+            "against",
+            "ain",
+            "all",
+            "am",
+            "an",
+            "and",
+            "any",
+            "are",
+            "aren",
+            "aren't",
+            "as",
+            "at",
+            "be",
+            "because",
+            "been",
+            "before",
+            "being",
+            "below",
+            "between",
+            "both",
+            "but",
+            "by",
+            "can",
+            "couldn",
+            "couldn't",
+            "did",
+            "didn",
+            "didn't",
+            "do",
+            "does",
+            "doesn",
+            "doesn't",
+            "doing",
+            "don",
+            "don't",
+            "down",
+            "during",
+            "each",
+            "few",
+            "for",
+            "from",
+            "further",
+            "had",
+            "hadn",
+            "hadn't",
+            "has",
+            "hasn",
+            "hasn't",
+            "have",
+            "haven",
+            "haven't",
+            "having",
+            "he",
+            "her",
+            "here",
+            "hers",
+            "herself",
+            "him",
+            "himself",
+            "his",
+            "how",
+            "i",
+            "if",
+            "in",
+            "into",
+            "is",
+            "isn",
+            "isn't",
+            "it",
+            "it's",
+            "its",
+            "itself",
+            "just",
+            "ll",
+            "let's",
+            "ma",
+            "me",
+            "mightn",
+            "mightn't",
+            "more",
+            "most",
+            "mustn",
+            "mustn't",
+            "my",
+            "myself",
+            "needn",
+            "needn't",
+            "no",
+            "nor",
+            "not",
+            "now",
+            "o",
+            "of",
+            "off",
+            "on",
+            "once",
+            "only",
+            "or",
+            "other",
+            "our",
+            "ours",
+            "ourselves",
+            "out",
+            "over",
+            "own",
+            "re",
+            "s",
+            "same",
+            "shan",
+            "shan't",
+            "she",
+            "she's",
+            "should",
+            "should've",
+            "shouldn",
+            "shouldn't",
+            "so",
+            "some",
+            "such",
+            "t",
+            "than",
+            "that",
+            "that'll",
+            "the",
+            "their",
+            "theirs",
+            "them",
+            "themselves",
+            "then",
+            "there",
+            "these",
+            "they",
+            "this",
+            "those",
+            "through",
+            "to",
+            "too",
+            "under",
+            "until",
+            "up",
+            "ve",
+            "very",
+            "was",
+            "wasn",
+            "wasn't",
+            "we",
+            "were",
+            "weren",
+            "weren't",
+            "what",
+            "when",
+            "where",
+            "which",
+            "while",
+            "who",
+            "whom",
+            "why",
+            "will",
+            "with",
+            "won",
+            "won't",
+            "wouldn",
+            "wouldn't",
+            "y",
+            "you",
+            "you'd",
+            "you'll",
+            "you're",
+            "you've",
+            "your",
+            "yours",
+            "yourself",
+            "yourselves",
+        }
+
+        words = text.lower().split()
+        unique_words = [word for word in words if word not in stop_words]
+
+        return unique_words

codeflash/code_utils/code_replacer.py

@@ -51,10 +51,13 @@ def __init__(
         self.new_functions: list[cst.FunctionDef] = []
         self.new_class_functions: dict[str, list[cst.FunctionDef]] = defaultdict(list)
         self.current_class = None
+        self.modified_init_functions: dict[str, cst.FunctionDef] = {}
 
     def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
         if (self.current_class, node.name.value) in self.function_names:
             self.modified_functions[(self.current_class, node.name.value)] = node
+        elif self.current_class and node.name.value == "__init__":
+            self.modified_init_functions[self.current_class] = node
         elif (
             self.preexisting_objects
             and (node.name.value, []) not in self.preexisting_objects
@@ -76,6 +79,7 @@ def visit_ClassDef(self, node: cst.ClassDef) -> bool:
                 and (child_node.name.value, parents) not in self.preexisting_objects
             ):
                 self.new_class_functions[node.name.value].append(child_node)
+
         return True
 
     def leave_ClassDef(self, node: cst.ClassDef) -> None:
@@ -89,11 +93,15 @@ def __init__(
         modified_functions: dict[tuple[str | None, str], cst.FunctionDef] = None,
         new_functions: list[cst.FunctionDef] = None,
         new_class_functions: dict[str, list[cst.FunctionDef]] = None,
+        modified_init_functions: dict[str, cst.FunctionDef] = None,
     ) -> None:
         super().__init__()
         self.modified_functions = modified_functions if modified_functions is not None else {}
         self.new_functions = new_functions if new_functions is not None else []
         self.new_class_functions = new_class_functions if new_class_functions is not None else defaultdict(list)
+        self.modified_init_functions: dict[str, cst.FunctionDef] = (
+            modified_init_functions if modified_init_functions is not None else {}
+        )
         self.current_class = None
 
     def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
@@ -103,6 +111,8 @@ def leave_FunctionDef(self, original_node: cst.FunctionDef, updated_node: cst.Fu
         if (self.current_class, original_node.name.value) in self.modified_functions:
             node = self.modified_functions[(self.current_class, original_node.name.value)]
             return updated_node.with_changes(body=node.body, decorators=node.decorators)
+        if original_node.name.value == "__init__" and self.current_class in self.modified_init_functions:
+            return self.modified_init_functions[self.current_class]
 
         return updated_node
 
@@ -173,6 +183,7 @@ def replace_functions_in_file(
         modified_functions=visitor.modified_functions,
         new_functions=visitor.new_functions,
         new_class_functions=visitor.new_class_functions,
+        modified_init_functions=visitor.modified_init_functions,
     )
     original_module = cst.parse_module(source_code)
     modified_tree = original_module.visit(transformer)
@@ -183,15 +194,14 @@ def replace_functions_and_add_imports(
     source_code: str,
     function_names: list[str],
     optimized_code: str,
-    file_path_of_module_with_function_to_optimize: Path,
     module_abspath: Path,
     preexisting_objects: list[tuple[str, list[FunctionParent]]],
     project_root_path: Path,
 ) -> str:
     return add_needed_imports_from_module(
         optimized_code,
         replace_functions_in_file(source_code, function_names, optimized_code, preexisting_objects),
-        file_path_of_module_with_function_to_optimize,
+        module_abspath,
         module_abspath,
         project_root_path,
     )
@@ -200,20 +210,13 @@ def replace_functions_and_add_imports(
 def replace_function_definitions_in_module(
     function_names: list[str],
     optimized_code: str,
-    file_path_of_module_with_function_to_optimize: Path,
     module_abspath: Path,
     preexisting_objects: list[tuple[str, list[FunctionParent]]],
     project_root_path: Path,
 ) -> bool:
     source_code: str = module_abspath.read_text(encoding="utf8")
     new_code: str = replace_functions_and_add_imports(
-        source_code,
-        function_names,
-        optimized_code,
-        file_path_of_module_with_function_to_optimize,
-        module_abspath,
-        preexisting_objects,
-        project_root_path,
+        source_code, function_names, optimized_code, module_abspath, preexisting_objects, project_root_path
     )
     if is_zero_diff(source_code, new_code):
         return False

codeflash/code_utils/instrument_existing_tests.py

@@ -10,6 +10,7 @@
 from codeflash.code_utils.code_utils import get_run_tmp_file, module_name_from_file_path
 from codeflash.discovery.functions_to_optimize import FunctionToOptimize
 from codeflash.models.models import FunctionParent, TestingMode
+from codeflash.verification.test_results import VerificationType
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -251,7 +252,7 @@ def visit_FunctionDef(self, node: ast.FunctionDef, test_class_name: str | None =
                                         ast.Constant(
                                             value="CREATE TABLE IF NOT EXISTS test_results (test_module_path TEXT,"
                                             " test_class_name TEXT, test_function_name TEXT, function_getting_tested TEXT,"
-                                            " loop_index INTEGER, iteration_id TEXT, runtime INTEGER, return_value BLOB)"
+                                            " loop_index INTEGER, iteration_id TEXT, runtime INTEGER, return_value BLOB, verification_type TEXT)"
                                         )
                                     ],
                                     keywords=[],
@@ -684,7 +685,7 @@ def create_wrapper_function(mode: TestingMode = TestingMode.BEHAVIOR) -> ast.Fun
                             value=ast.Name(id="codeflash_cur", ctx=ast.Load()), attr="execute", ctx=ast.Load()
                         ),
                         args=[
-                            ast.Constant(value="INSERT INTO test_results VALUES (?, ?, ?, ?, ?, ?, ?, ?)"),
+                            ast.Constant(value="INSERT INTO test_results VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"),
                             ast.Tuple(
                                 elts=[
                                     ast.Name(id="test_module_name", ctx=ast.Load()),
@@ -695,6 +696,7 @@ def create_wrapper_function(mode: TestingMode = TestingMode.BEHAVIOR) -> ast.Fun
                                     ast.Name(id="invocation_id", ctx=ast.Load()),
                                     ast.Name(id="codeflash_duration", ctx=ast.Load()),
                                     ast.Name(id="pickled_return_value", ctx=ast.Load()),
+                                    ast.Constant(value=VerificationType.FUNCTION_CALL.value),
                                 ],
                                 ctx=ast.Load(),
                             ),