Upload _script_for_eval.py

_script_for_eval.py

@@ -8,8 +8,7 @@ import subprocess
 import argparse
 import re
 from openai import OpenAI
-from openai.types.chat import ChatCompletion
-from openai.types import APIError, APIConnectionError, APIResponseValidationError, APIStatusError
+from openai import OpenAIError
 from tqdm import tqdm
 from functools import partial
 import multiprocessing
@@ -20,15 +19,16 @@ import numpy as np
 
 client = OpenAI()
 
-def load_cache():
-    if os.path.exists('cache.pkl'):
+def load_cache(use_cache):
+    if use_cache and os.path.exists('cache.pkl'):
         with open('cache.pkl', 'rb') as f:
             return pickle.load(f)
     return {}
 
-def save_cache(cache):
-    with open('cache.pkl', 'wb') as f:
-        pickle.dump(cache, f)
+def save_cache(cache, use_cache):
+    if use_cache:
+        with open('cache.pkl', 'wb') as f:
+            pickle.dump(cache, f)
 
 def has_all_comments(text):
     lines=text.split('\n')
@@ -37,7 +37,7 @@ def has_all_comments(text):
             return False
     return True
 
-def fetch_dataset_examples(prompt, num_examples=3, use_similarity=True):
+def fetch_dataset_examples(prompt, num_examples=0, use_similarity=False):
     dataset = load_dataset("patched-codes/synth-vuln-fixes", split="train")
     
     if use_similarity:
@@ -106,28 +106,22 @@ def get_fixed_code_fine_tuned(prompt, few_shot_messages, model_name):
                 temperature=0.2,
                 top_p=0.95
             )
-            if isinstance(response, ChatCompletion):
-                return response.choices[0].message.content
-            else:
-                raise ValueError("Unexpected response type from OpenAI API")
-        except (APIError, APIConnectionError, APIResponseValidationError) as e:
+            return response.choices[0].message.content
+        except OpenAIError as e:
             if attempt < max_retries - 1:
                 time.sleep(2 ** attempt)  # Exponential backoff
             else:
                 raise Exception(f"API call failed after {max_retries} attempts: {str(e)}")
-        except APIStatusError as e:
-            raise Exception(f"API call failed with status {e.status_code}: {str(e)}")
 
-def process_file(test_case, cache, fixed_files, model_name):
+def process_file(test_case, cache, fixed_files, model_name, use_cache, n_shot, use_similarity):
     file_name = test_case["file_name"]
     input_file = os.path.join("staticeval", file_name)
     
-    if input_file in cache:
+    if use_cache and input_file in cache:
         tqdm.write(f"Skipping {input_file} (cached)")
         return cache[input_file]
 
     file_text = test_case["source"]
-    test_cwe = test_case["cwe"].strip()
     output_file = input_file + "_fixed.py"
     tmp_file = input_file + ".output.json"
 
@@ -173,7 +167,7 @@ def process_file(test_case, cache, fixed_files, model_name):
 
     Task: Fix the vulnerability in the code above. Provide only the complete fixed code without explanations or comments. Make minimal changes necessary to address the security issue while preserving the original functionality."""
                 
-                few_shot_messages = fetch_dataset_examples(prompt, 8, True)
+                few_shot_messages = fetch_dataset_examples(prompt, n_shot, use_similarity)
                 response = get_fixed_code_fine_tuned(prompt, few_shot_messages, model_name)
                 
                 if "```python" in response:
@@ -184,61 +178,65 @@ def process_file(test_case, cache, fixed_files, model_name):
                     fixed_code = response
                 
                 stop_words = ["```", "assistant"]
+
                 for w in stop_words:
                     if w in fixed_code:
                         fixed_code = fixed_code[:fixed_code.find(w)]
-                
-                if len(fixed_code) < 400 or all(line.strip().startswith("#") for line in fixed_code.split('\n') if line.strip()):
+                if len(fixed_code) < 400:
                     result = False
+                if has_all_comments(fixed_code):
+                    result = False
+                if os.path.exists(output_file):
+                    os.remove(output_file)
+                with open(output_file, 'w') as wf:
+                    wf.write(fixed_code)
+                if os.path.exists(tmp_file):
+                    os.remove(tmp_file)
+                scan_command_output = f"semgrep --config p/python {output_file} --output {tmp_file} --json > /dev/null 2>&1"
+                os.system(scan_command_output)
+                with open(tmp_file, 'r') as jf:
+                    data = json.load(jf)
+                if len(data["errors"]) == 0 and len(data["results"]) == 0:
+                    tqdm.write("Passing response for " + input_file + " at 1 ...")
+                    result = True
+                    fixed_files.append(file_name)
                 else:
-                    with open(output_file, 'w') as wf:
-                        wf.write(fixed_code)
-                    
-                    scan_command_output = f"semgrep --config p/python {output_file} --output {tmp_file} --json > /dev/null 2>&1"
-                    os.system(scan_command_output)
-                    
-                    if not os.path.exists(tmp_file):
-                        tqdm.write(f"Semgrep failed to create output file for {output_file}")
-                        result = False
-                    else:
-                        with open(tmp_file, 'r') as jf:
-                            data = json.load(jf)
-                        
-                        if len(data.get("errors", [])) == 0 and len(data.get("results", [])) == 0:
-                            tqdm.write("Passing response for " + input_file + " at 1 ...")
-                            result = True
-                            fixed_files.append(file_name)
-                        else:
-                            result = False
+                    result = False
         else:
             tqdm.write(f"Semgrep reported errors for {input_file}")
             result = False
 
         if os.path.exists(tmp_file):
             os.remove(tmp_file)
+        if use_cache:
+            cache[input_file] = result
 
-        cache[input_file] = result
-        save_cache(cache)
         return result
     except Exception as e:
         tqdm.write(f"Error processing {input_file}: {str(e)}")
         return False
 
-def process_test_case(test_case, cache, fixed_files, model_name):
-    return process_file(test_case, cache, fixed_files, model_name)
+def process_test_case(test_case, cache, fixed_files, model_name, use_cache, n_shot, use_similarity):
+    return process_file(test_case, cache, fixed_files, model_name, use_cache, n_shot, use_similarity)
 
 def main():
     parser = argparse.ArgumentParser(description="Run Static Analysis Evaluation")
-    parser.add_argument("--model", type=str, default="gpt-4-0125-preview", help="OpenAI model to use")
+    parser.add_argument("--model", type=str, default="gpt-4o-mini", help="OpenAI model to use")
+    parser.add_argument("--cache", action="store_true", help="Enable caching of results")
+    parser.add_argument("--n_shot", type=int, default=0, help="Number of examples to use for few-shot learning")
+    parser.add_argument("--use_similarity", action="store_true", help="Use similarity for fetching dataset examples")
     args = parser.parse_args()
 
     model_name = args.model
-    sanitized_model_name = sanitize_filename(model_name)
+    use_cache = args.cache
+    n_shot = args.n_shot
+    use_similarity = args.use_similarity
+    sanitized_model_name = f"{sanitize_filename(model_name)}-{n_shot}-shot{'-sim' if use_similarity else ''}"
 
     dataset = load_dataset("patched-codes/static-analysis-eval", split="train")
     data = [{"file_name": item["file_name"], "source": item["source"], "cwe": item["cwe"]} for item in dataset]
 
-    cache = load_cache()
+    cache = load_cache(use_cache)
     total_tests = len(data)
 
     semgrep_version = get_semgrep_version()
@@ -248,23 +246,29 @@ def main():
     manager = multiprocessing.Manager()
     fixed_files = manager.list()
 
-    process_func = partial(process_test_case, cache=cache, fixed_files=fixed_files, model_name=model_name)
+    process_func = partial(process_test_case, cache=cache, fixed_files=fixed_files, model_name=model_name, use_cache=use_cache, n_shot=n_shot, use_similarity=use_similarity)
 
-    with multiprocessing.Pool() as pool:
-        results = list(tqdm(pool.imap_unordered(process_func, data), total=total_tests))
+    with multiprocessing.Pool(processes=4) as pool:
+        results = list(tqdm(pool.imap(process_func, data), total=total_tests))
 
     passing_tests = sum(results)
     score = passing_tests / total_tests * 100
 
+    if use_cache:
+        save_cache(cache, use_cache)
+
     with open(log_file_name, 'w') as log_file:
         log_file.write(f"Evaluation Run Log\n")
         log_file.write(f"==================\n\n")
         log_file.write(f"Date and Time: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
         log_file.write(f"Model: {model_name}\n")
-        log_file.write(f"Semgrep Version: {semgrep_version}\n\n")
+        log_file.write(f"Semgrep Version: {semgrep_version}\n")
+        log_file.write(f"Caching: {'Enabled' if use_cache else 'Disabled'}\n\n")
         log_file.write(f"Total Tests: {total_tests}\n")
         log_file.write(f"Passing Tests: {passing_tests}\n")
         log_file.write(f"Score: {score:.2f}%\n\n")
+        log_file.write(f"Number of few-shot examples: {n_shot}\n")
+        log_file.write(f"Use similarity for examples: {'Yes' if use_similarity else 'No'}\n")
         log_file.write("Fixed Files:\n")
         for file in fixed_files:
             log_file.write(f"- {file}\n")