_script_for_gen.py

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 Exception as e:
        logging.error(f"Error creating dataset: {str(e)}")

    # 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 = "static_analysis_eval.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()