get it working

Author: misrasaurabh1

codeflash/api/cfapi.py

@@ -3,19 +3,19 @@
 import json
 import os
 import sys
-import git
 from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, List
+from typing import TYPE_CHECKING, Any, Optional
 
+import git
 import requests
 import sentry_sdk
 from pydantic.json import pydantic_encoder
 
 from codeflash.cli_cmds.console import console, logger
 from codeflash.code_utils.env_utils import ensure_codeflash_api_key, get_codeflash_api_key, get_pr_number
-from codeflash.version import __version__
 from codeflash.code_utils.git_utils import get_repo_owner_and_name
+from codeflash.version import __version__
 
 if TYPE_CHECKING:
     from requests import Response
@@ -194,7 +194,9 @@ 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(owner: str, repo: str, pr_number: int, code_contexts: List[Dict[str, str]]) -> Dict:
+def is_function_being_optimized_again(
+    owner: str, repo: str, pr_number: int, code_contexts: list[dict[str, str]]
+) -> dict:
     """Check if the function being optimized is being optimized again."""
     response = make_cfapi_request(
         "/is-already-optimized",
@@ -204,8 +206,9 @@ def is_function_being_optimized_again(owner: str, repo: str, pr_number: int, cod
     response.raise_for_status()
     return response.json()
 
-def add_code_context_hash( code_context_hash: str):
-    """Add code context to the DB cache"""
+
+def add_code_context_hash(code_context_hash: str) -> None:
+    """Add code context to the DB cache."""
     pr_number = get_pr_number()
     if pr_number is None:
         return
@@ -215,16 +218,9 @@ def add_code_context_hash( code_context_hash: str):
     except git.exc.InvalidGitRepositoryError:
         return
 
-
     if owner and repo and pr_number is not None:
         make_cfapi_request(
             "/add-code-hash",
             "POST",
-            {
-                "owner": owner,
-                "repo": repo,
-                "pr_number": pr_number,
-                "code_context_hash": code_context_hash
-            }
+            {"owner": owner, "repo": repo, "pr_number": pr_number, "code_hash": code_context_hash},
         )
-

codeflash/context/code_context_extractor.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hashlib
 import os
 from collections import defaultdict
 from itertools import chain
@@ -132,12 +133,15 @@ def get_code_optimization_context(
         testgen_context_code_tokens = encoded_tokens_len(testgen_context_code)
         if testgen_context_code_tokens > testgen_token_limit:
             raise ValueError("Testgen code context has exceeded token limit, cannot proceed")
+    code_hash_context = hashing_code_context.markdown
+    code_hash = hashlib.sha256(code_hash_context.encode("utf-8")).hexdigest()
 
     return CodeOptimizationContext(
         testgen_context_code=testgen_context_code,
         read_writable_code=final_read_writable_code,
         read_only_context_code=read_only_context_code,
-        hashing_code_context=hashing_code_context.markdown,
+        hashing_code_context=code_hash_context,
+        hashing_code_context_hash=code_hash,
         helper_functions=helpers_of_fto_list,
         preexisting_objects=preexisting_objects,
     )

codeflash/discovery/functions_to_optimize.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import ast
-import hashlib
 import os
 import random
 import warnings
@@ -446,7 +445,7 @@ def check_optimization_status(function_to_optimize: FunctionToOptimize, code_con
 
     code_contexts = []
 
-    func_hash = hashlib.sha256(code_context.hashing_code_context.encode("utf-8")).hexdigest()
+    func_hash = code_context.hashing_code_context_hash
     # Use a unique path identifier that includes function info
 
     code_contexts.append(

codeflash/models/models.py

@@ -158,6 +158,7 @@ class CodeOptimizationContext(BaseModel):
     read_writable_code: str = Field(min_length=1)
     read_only_context_code: str = ""
     hashing_code_context: str = ""
+    hashing_code_context_hash: str = ""
     helper_functions: list[FunctionSource]
     preexisting_objects: set[tuple[str, tuple[FunctionParent, ...]]]
 

codeflash/optimization/function_optimizer.py

@@ -156,7 +156,7 @@ def optimize_function(self) -> Result[BestOptimization, str]:  # noqa: PLR0911
         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.")
+            return Failure("This function has previously been optimized, skipping.")
 
         code_print(code_context.read_writable_code)
         generated_test_paths = [
@@ -377,7 +377,7 @@ def optimize_function(self) -> Result[BestOptimization, str]:  # noqa: PLR0911
 
         # Add function to code context hash if in gh actions
 
-        add_code_context_hash(self.function_to_optimize.get_code_context_hash())
+        add_code_context_hash(code_context.hashing_code_context_hash)
 
         if self.args.override_fixtures:
             restore_conftest(original_conftest_content)
@@ -689,6 +689,7 @@ def get_code_optimization_context(self) -> Result[CodeOptimizationContext, str]:
                 read_writable_code=new_code_ctx.read_writable_code,
                 read_only_context_code=new_code_ctx.read_only_context_code,
                 hashing_code_context=new_code_ctx.hashing_code_context,
+                hashing_code_context_hash=new_code_ctx.hashing_code_context_hash,
                 helper_functions=new_code_ctx.helper_functions,  # only functions that are read writable
                 preexisting_objects=new_code_ctx.preexisting_objects,
             )