Upload _script_for_gen.py

_script_for_gen.py

@@ -0,0 +1,203 @@
+import os
+import json
+import random
+import string
+import subprocess
+import tempfile
+import logging
+import argparse
+from github import Github
+from git import Repo
+from datasets import load_dataset, Dataset
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Read GitHub API token from environment variable
+GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+if not GITHUB_TOKEN:
+    logger.error("GITHUB_TOKEN environment variable is not set.")
+    raise ValueError("GITHUB_TOKEN environment variable is not set. Please set it before running the script.")
+
+if not HF_TOKEN:
+    logger.error("HF_TOKEN environment variable is not set.")
+    raise ValueError("HF_TOKEN environment variable is not set. Please set it before running the script.")
+
+# Initialize GitHub API client
+g = Github(GITHUB_TOKEN)
+
+def search_top_repos():
+    """Search for top 100 Python repositories with at least 1000 stars and 100 forks."""
+    logger.info("Searching for top 100 Python repositories...")
+    query = "language:python stars:>=1000 forks:>=100"
+    repos = g.search_repositories(query=query, sort="stars", order="desc")
+    top_repos = list(repos[:100])
+    logger.info(f"Found {len(top_repos)} repositories")
+    return top_repos
+
+def clone_repo(repo, tmp_dir):
+    """Clone a repository to a temporary directory."""
+    logger.info(f"Cloning repository: {repo.full_name}")
+    repo_dir = os.path.join(tmp_dir, repo.name)
+    Repo.clone_from(repo.clone_url, repo_dir)
+    logger.info(f"Repository cloned to {repo_dir}")
+    return repo_dir
+
+def run_semgrep(repo_dir):
+    """Run Semgrep on the repository and return the JSON output."""
+    logger.info(f"Running Semgrep on {repo_dir}")
+    cmd = f"semgrep scan --config auto --json {repo_dir}"
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    logger.info("Semgrep scan completed")
+    return json.loads(result.stdout)
+
+def extract_vulnerable_files(semgrep_output):
+    """Extract files with exactly one vulnerability and their CWE."""
+    logger.info("Extracting vulnerable files from Semgrep output")
+    vulnerable_files = {}
+    total_vulns = 0
+    for result in semgrep_output.get("results", []):
+        file_path = result.get("path")
+        cwe = result.get("extra", {}).get("metadata", {}).get("cwe", "Unknown")
+        
+        if file_path not in vulnerable_files:
+            vulnerable_files[file_path] = {"count": 0, "cwe": cwe}
+        
+        vulnerable_files[file_path]["count"] += 1
+        total_vulns += 1
+    
+    single_vulnerability_files = {file: info["cwe"] for file, info in vulnerable_files.items() if info["count"] == 1}
+    logger.info(f"Found {total_vulns} total vulnerabilities")
+    logger.info(f"Found {len(single_vulnerability_files)} files with exactly one vulnerability")
+    return single_vulnerability_files, total_vulns
+
+def count_tokens(text):
+    """Approximate token count using whitespace splitting."""
+    return len(text.split())
+
+def generate_random_filename():
+    """Generate a random 6-digit filename with .py extension."""
+    return ''.join(random.choices(string.digits, k=6)) + ".py"
+
+def process_repository(repo, output_file):
+    """Process a single repository and append new data items to the output file."""
+    logger.info(f"Processing repository: {repo.full_name}")
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        repo_dir = clone_repo(repo, tmp_dir)
+        semgrep_output = run_semgrep(repo_dir)
+        vulnerable_files, total_vulns = extract_vulnerable_files(semgrep_output)
+        
+        items_added = 0
+        for file_path, cwe in vulnerable_files.items():
+            if items_added >= 3:
+                logger.info(f"Reached maximum of 3 items for repository {repo.full_name}. Stopping processing.")
+                break
+
+            full_path = os.path.join(repo_dir, file_path)
+            logger.info(f"Analyzing file: {file_path}")
+            with open(full_path, 'r') as f:
+                source_code = f.read()
+            
+            token_count = count_tokens(source_code)
+            if 512 <= token_count <= 1024:
+                new_item = {
+                    "source": source_code,
+                    "file_name": generate_random_filename(),
+                    "cwe": cwe
+                }
+                
+                with open(output_file, 'a') as f:
+                    json.dump(new_item, f)
+                    f.write('\n')
+                items_added += 1
+                logger.info(f"Added new item with CWE: {cwe}")
+            else:
+                logger.info(f"File skipped: token count ({token_count}) out of range")
+        
+        logger.info(f"Processed {repo.full_name}: found {total_vulns} vulnerabilities, added {items_added} new items")
+
+def preprocess_data(data):
+    """Ensure all fields are consistently typed across all items."""
+    if not data:
+        return data
+
+    # Identify fields that are sometimes lists
+    list_fields = set()
+    for item in data:
+        for key, value in item.items():
+            if isinstance(value, list):
+                list_fields.add(key)
+
+    # Ensure these fields are always lists
+    for item in data:
+        for key in list_fields:
+            if key not in item:
+                item[key] = []
+            elif not isinstance(item[key], list):
+                item[key] = [item[key]]
+
+    return data
+
+def merge_and_push_dataset(jsonl_file, new_dataset_name):
+    """Push to Hugging Face."""
+    logging.info("Starting dataset push process")
+
+    # Load the new data from the JSONL file
+    logging.info("Loading new data from JSONL file")
+    with open(jsonl_file, 'r') as f:
+        new_data = [json.loads(line) for line in f]
+
+    logging.info(f"Loaded {len(new_data)} records from JSONL file")
+
+    # Preprocess the data
+    logging.info("Preprocessing data")
+    preprocessed_data = preprocess_data(new_data)
+
+    # Create dataset from the preprocessed data
+    logging.info("Creating dataset")
+    try:
+        dataset = Dataset.from_list(preprocessed_data)
+    except pa.lib.ArrowInvalid as e:
+        logging.error(f"Error creating dataset: {str(e)}")
+        logging.info("Attempting to create dataset with type inference disabled")
+        dataset = Dataset.from_list(preprocessed_data, features=pa.schema([]))
+
+    # Push the dataset to the new repository
+    logging.info(f"Pushing dataset with {len(dataset)} records to Hugging Face")
+    dataset.push_to_hub(new_dataset_name, private=True, token=HF_TOKEN)
+
+    logging.info("Dataset push process completed")
+
+def main():
+    parser = argparse.ArgumentParser(description="Extend and upload static-analysis-eval dataset")
+    parser.add_argument("--push_to_dataset", help="Merge and push dataset to specified Hugging Face repository")
+    args = parser.parse_args()
+
+    if args.push_to_dataset:
+        # Merge and push the dataset
+        jsonl_file = "output.jsonl"
+        merge_and_push_dataset(jsonl_file, args.push_to_dataset)
+    else:
+        # Perform the regular dataset extension process
+        output_file = "static_analysis_eval.jsonl"
+        logger.info(f"Starting dataset extension process. Output file: {output_file}")
+        
+        # Ensure the output file exists
+        open(output_file, 'a').close()
+        
+        top_repos = search_top_repos()
+        
+        for i, repo in enumerate(top_repos, 1):
+            try:
+                logger.info(f"Processing repository {i} of {len(top_repos)}: {repo.full_name}")
+                process_repository(repo, output_file)
+            except Exception as e:
+                logger.error(f"Error processing repository {repo.full_name}: {str(e)}", exc_info=True)
+
+        logger.info("Dataset extension process completed")
+
+if __name__ == "__main__":
+    main()