Upload _script_for_eval.py

_script_for_eval.py

@@ -3,7 +3,13 @@ import os
 import random
 import pickle
 import time
+import datetime
+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 tqdm import tqdm
 from functools import partial
 import multiprocessing
@@ -24,6 +30,13 @@ def save_cache(cache):
     with open('cache.pkl', 'wb') as f:
         pickle.dump(cache, f)
 
+def has_all_comments(text):
+    lines=text.split('\n')
+    for line in lines:
+        if line != "" and not line.startswith("#"):
+            return False
+    return True
+
 def fetch_dataset_examples(prompt, num_examples=3, use_similarity=True):
     dataset = load_dataset("patched-codes/synth-vuln-fixes", split="train")
     
@@ -52,7 +65,21 @@ def fetch_dataset_examples(prompt, num_examples=3, use_similarity=True):
     
     return few_shot_messages
 
-def get_fixed_code_fine_tuned(prompt, few_shot_messages):
+def sanitize_filename(name):
+    # Replace ':' with '_', and any other non-alphanumeric characters (except '-' and '_') with '*'
+    sanitized = re.sub(r':', '_', name)
+    sanitized = re.sub(r'[^a-zA-Z0-9\-_]', '*', sanitized)
+    return sanitized
+
+def get_semgrep_version():
+    try:
+        result = subprocess.run(["semgrep", "--version"], capture_output=True, text=True)
+        version = result.stdout.strip().split()[-1]
+        return version
+    except Exception:
+        return "unknown"
+
+def get_fixed_code_fine_tuned(prompt, few_shot_messages, model_name):
     system_message = (
         "You are an AI assistant specialized in fixing code vulnerabilities. "
         "Your task is to provide corrected code that addresses the reported security issue. "
@@ -69,22 +96,31 @@ def get_fixed_code_fine_tuned(prompt, few_shot_messages):
     messages.extend(few_shot_messages)
     messages.append({"role": "user", "content": prompt})
 
-    response = client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        max_tokens=512,
-        temperature=0.2,
-        top_p=0.95
-    )
-
-    try:
-        return response.choices[0].message.content
-    except Exception as e:
-        raise Exception(f"API call failed: {str(e)}")
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=messages,
+                max_tokens=512,
+                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:
+            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):
+def process_file(test_case, cache, fixed_files, model_name):
     file_name = test_case["file_name"]
-    input_file = "staticeval/" + file_name
+    input_file = os.path.join("staticeval", file_name)
     
     if input_file in cache:
         tqdm.write(f"Skipping {input_file} (cached)")
@@ -95,99 +131,146 @@ def process_file(test_case, cache):
     output_file = input_file + "_fixed.py"
     tmp_file = input_file + ".output.json"
 
-    with open(input_file, "w") as file_object:
-        file_object.write(file_text)
-
-    if os.path.exists(tmp_file):
-        os.remove(tmp_file)
-        
-    tqdm.write("Scanning file " + input_file + "...")
-    scan_command_input = f"semgrep --config p/python {input_file} --output {tmp_file} --json > /dev/null 2>&1"
-    os.system(scan_command_input)
-    
-    with open(tmp_file, 'r') as jf:
-        data = json.load(jf)
-    
-    if len(data["errors"]) == 0:
-        if len(data["results"]) == 0:
-            tqdm.write(input_file + " has no vulnerabilities")
-            result = False
-        else:
-            tqdm.write("Vulnerability found in " + input_file + "...")
-            cwe = data["results"][0]["extra"]["metadata"]["cwe"][0]
-            lines = data["results"][0]["extra"]["lines"]
-            message = data["results"][0]["extra"]["message"]
-            
-            prompt = f"""Vulnerability Report:
-- Type: {cwe}
-- Location: {lines}
-- Description: {message}
+    try:
+        os.makedirs(os.path.dirname(input_file), exist_ok=True)
 
-Original Code:
-```
-{file_text}
-```
+        with open(input_file, "w") as file_object:
+            file_object.write(file_text)
 
-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, 3, True)
-            response = get_fixed_code_fine_tuned(prompt, [])
+        if os.path.exists(tmp_file):
+            os.remove(tmp_file)
             
-            if "```python" in response:
-                idx = response.find("```python")
-                shift = len("```python")
-                fixed_code = response[idx + shift :]
-            else:
-                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()):
+        tqdm.write("Scanning file " + input_file + "...")
+        scan_command_input = f"semgrep --config p/python {input_file} --output {tmp_file} --json > /dev/null 2>&1"
+        os.system(scan_command_input)
+        
+        if not os.path.exists(tmp_file):
+            tqdm.write(f"Semgrep failed to create output file for {input_file}")
+            return False
+
+        with open(tmp_file, 'r') as jf:
+            data = json.load(jf)
+        
+        if len(data.get("errors", [])) == 0:
+            if len(data.get("results", [])) == 0:
+                tqdm.write(input_file + " has no vulnerabilities")
                 result = False
             else:
-                with open(output_file, 'w') as wf:
-                    wf.write(fixed_code)
+                tqdm.write("Vulnerability found in " + input_file + "...")
+                cwe = data["results"][0]["extra"]["metadata"]["cwe"][0]
+                lines = data["results"][0]["extra"]["lines"]
+                message = data["results"][0]["extra"]["message"]
                 
-                scan_command_output = f"semgrep --config p/python {output_file} --output {tmp_file} --json > /dev/null 2>&1"
-                os.system(scan_command_output)
+                prompt = f"""Vulnerability Report:
+    - Type: {cwe}
+    - Location: {lines}
+    - Description: {message}
+
+    Original Code:
+    ```
+    {file_text}
+    ```
+
+    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."""
                 
-                with open(tmp_file, 'r') as jf:
-                    data = json.load(jf)
+                few_shot_messages = fetch_dataset_examples(prompt, 8, True)
+                response = get_fixed_code_fine_tuned(prompt, few_shot_messages, model_name)
                 
-                if len(data["errors"]) == 0 and len(data["results"]) == 0:
-                    tqdm.write("Passing response for " + input_file + " at 1 ...")
-                    result = True
+                if "```python" in response:
+                    idx = response.find("```python")
+                    shift = len("```python")
+                    fixed_code = response[idx + shift :]
                 else:
+                    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()):
                     result = False
+                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
+        else:
+            tqdm.write(f"Semgrep reported errors for {input_file}")
+            result = False
 
-    if os.path.exists(tmp_file):
-        os.remove(tmp_file)
+        if os.path.exists(tmp_file):
+            os.remove(tmp_file)
 
-    cache[input_file] = result
-    save_cache(cache)
-    return 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):
-    return process_file(test_case, cache)
+def process_test_case(test_case, cache, fixed_files, model_name):
+    return process_file(test_case, cache, fixed_files, model_name)
 
 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")
+    args = parser.parse_args()
+
+    model_name = args.model
+    sanitized_model_name = sanitize_filename(model_name)
+
     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()
     total_tests = len(data)
 
-    process_func = partial(process_test_case, cache=cache)
+    semgrep_version = get_semgrep_version()
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_file_name = f"{sanitized_model_name}_semgrep_{semgrep_version}_{timestamp}.log"
+
+    manager = multiprocessing.Manager()
+    fixed_files = manager.list()
+
+    process_func = partial(process_test_case, cache=cache, fixed_files=fixed_files, model_name=model_name)
 
     with multiprocessing.Pool() as pool:
         results = list(tqdm(pool.imap_unordered(process_func, data), total=total_tests))
 
     passing_tests = sum(results)
+    score = passing_tests / total_tests * 100
+
+    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"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("Fixed Files:\n")
+        for file in fixed_files:
+            log_file.write(f"- {file}\n")
 
-    print(f"Results for StaticAnalysisEval: {passing_tests/total_tests*100}%")
+    print(f"Results for StaticAnalysisEval: {score:.2f}%")
+    print(f"Log file created: {log_file_name}")
 
 if __name__ == '__main__':
     main()