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()