Upload 2 files

_script_for_eval.py

@@ -0,0 +1,231 @@
+import os
+import argparse
+import json
+import numpy as np
+from tqdm import tqdm
+import nltk
+from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
+from rouge import Rouge
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import re
+from textstat import flesch_reading_ease
+from datasets import load_dataset
+import openai
+from datetime import datetime
+
+nltk.download('punkt', quiet=True)
+nltk.download('averaged_perceptron_tagger', quiet=True)
+
+def preprocess(text):
+    return nltk.word_tokenize(text.lower())
+
+def calculate_bleu(reference, candidate):
+    reference_tokens = preprocess(reference)
+    candidate_tokens = preprocess(candidate)
+    smoothie = SmoothingFunction().method1
+    return sentence_bleu([reference_tokens], candidate_tokens, smoothing_function=smoothie)
+
+def calculate_rouge(reference, candidate):
+    rouge = Rouge()
+    scores = rouge.get_scores(candidate, reference)
+    return {
+        'rouge-1': scores[0]['rouge-1']['f'],
+        'rouge-2': scores[0]['rouge-2']['f'],
+        'rouge-l': scores[0]['rouge-l']['f']
+    }
+
+def calculate_cosine_similarity(reference, candidate):
+    vectorizer = TfidfVectorizer()
+    tfidf_matrix = vectorizer.fit_transform([reference, candidate])
+    return cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])[0][0]
+
+def extract_sections(readme):
+    sections = []
+    current_section = ""
+    for line in readme.split('\n'):
+        if line.strip().startswith('#'):
+            if current_section:
+                sections.append(current_section.strip())
+            current_section = line + "\n"
+        else:
+            current_section += line + "\n"
+    if current_section:
+        sections.append(current_section.strip())
+    return sections
+
+def calculate_structural_similarity(reference, candidate):
+    ref_sections = extract_sections(reference)
+    cand_sections = extract_sections(candidate)
+    
+    section_diff = abs(len(ref_sections) - len(cand_sections))
+    
+    ref_titles = [s.split('\n')[0] for s in ref_sections]
+    cand_titles = [s.split('\n')[0] for s in cand_sections]
+    title_similarity = len(set(ref_titles) & set(cand_titles)) / max(len(ref_titles), len(cand_titles))
+    
+    return {
+        'section_difference': section_diff,
+        'title_similarity': title_similarity
+    }
+
+def information_retrieval_score(readme):
+    key_sections = ['installation', 'usage', 'api', 'example', 'license']
+    found_sections = sum(1 for section in key_sections if section in readme.lower())
+    return found_sections / len(key_sections)
+
+def code_readme_consistency(repo_content, readme):
+    code_elements = set(re.findall(r'def\s+(\w+)', repo_content) + 
+                        re.findall(r'class\s+(\w+)', repo_content))
+    
+    mentioned_elements = sum(1 for element in code_elements if element in readme)
+    
+    return mentioned_elements / len(code_elements) if code_elements else 0
+
+def calculate_readability(text):
+    return flesch_reading_ease(text) / 100
+
+def evaluate_readme(reference_readme, generated_readme, repo_content):
+    bleu_score = calculate_bleu(reference_readme, generated_readme)
+    rouge_scores = calculate_rouge(reference_readme, generated_readme)
+    cosine_sim = calculate_cosine_similarity(reference_readme, generated_readme)
+    structural_sim = calculate_structural_similarity(reference_readme, generated_readme)
+    info_retrieval = information_retrieval_score(generated_readme)
+    code_consistency = code_readme_consistency(repo_content, generated_readme)
+    readability = calculate_readability(generated_readme)
+    
+    weights = {
+        'bleu': 0.1,
+        'rouge-1': 0.1,
+        'rouge-2': 0.1,
+        'rouge-l': 0.1,
+        'cosine_similarity': 0.1,
+        'structural_similarity': 0.1,
+        'information_retrieval': 0.15,
+        'code_consistency': 0.15,
+        'readability': 0.1
+    }
+    
+    weighted_score = (
+        weights['bleu'] * bleu_score +
+        weights['rouge-1'] * rouge_scores['rouge-1'] +
+        weights['rouge-2'] * rouge_scores['rouge-2'] +
+        weights['rouge-l'] * rouge_scores['rouge-l'] +
+        weights['cosine_similarity'] * cosine_sim +
+        weights['structural_similarity'] * structural_sim['title_similarity'] +
+        weights['information_retrieval'] * info_retrieval +
+        weights['code_consistency'] * code_consistency +
+        weights['readability'] * readability
+    )
+    
+    return {
+        'bleu': bleu_score,
+        'rouge': rouge_scores,
+        'cosine_similarity': cosine_sim,
+        'structural_similarity': structural_sim,
+        'information_retrieval': info_retrieval,
+        'code_consistency': code_consistency,
+        'readability': readability,
+        'weighted_score': weighted_score
+    }
+
+def generate_readme(repo_content, model, client):
+    system_prompt = """You are an AI assistant tasked with creating a README.md file for a GitHub repository. 
+    Your response should contain ONLY the content of the README.md file, without any additional explanations or markdown code blocks. 
+    The README should include the following sections:
+    1. Project Title
+    2. Description
+    3. Installation
+    4. Usage
+    5. Features
+    6. Contributing
+    7. License
+    Ensure that your response is well-structured, informative, and directly usable as a README.md file."""
+
+    user_prompt = f"Here is the content of the repository:\n\n{repo_content}\n\nBased on this content, please generate a README.md file."
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+    )
+    
+    return response.choices[0].message.content
+
+def main(args):
+    openai.api_key = os.getenv("OPENAI_API_KEY")
+    if not openai.api_key:
+        raise ValueError("OPENAI_API_KEY environment variable is not set")
+
+    client = openai.OpenAI(base_url=args.base_url) if args.base_url else openai.OpenAI()
+
+    dataset = load_dataset("patched-codes/generate-readme-eval")
+    
+    results = []
+    
+    for item in tqdm(dataset['test'], desc="Processing repos"):
+        try:
+            generated_readme = generate_readme(item['repo_content'], args.model, client)
+            eval_result = evaluate_readme(item['repo_readme'], generated_readme, item['repo_content'])
+            # Add repo_name to the eval_result
+            eval_result['repo_name'] = item['repo_name']
+            results.append(eval_result)
+        except Exception as e:
+            print(f"Error processing repo {item['repo_name']}: {e}")
+            continue
+    
+    average_scores = {
+        'bleu': np.mean([r['bleu'] for r in results]),
+        'rouge-1': np.mean([r['rouge']['rouge-1'] for r in results]),
+        'rouge-2': np.mean([r['rouge']['rouge-2'] for r in results]),
+        'rouge-l': np.mean([r['rouge']['rouge-l'] for r in results]),
+        'cosine_similarity': np.mean([r['cosine_similarity'] for r in results]),
+        'title_similarity': np.mean([r['structural_similarity']['title_similarity'] for r in results]),
+        'information_retrieval': np.mean([r['information_retrieval'] for r in results]),
+        'code_consistency': np.mean([r['code_consistency'] for r in results]),
+        'readability': np.mean([r['readability'] for r in results]),
+        'weighted_score': np.mean([r['weighted_score'] for r in results])
+    }
+    
+    # Print results to console
+    print("\nEvaluation Results:")
+    for metric, score in average_scores.items():
+        print(f"{metric}: {score:.4f}")
+
+    # Save results to log file
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_filename = f"{args.model}_results_{timestamp}.log"
+    
+    with open(log_filename, 'w') as log_file:
+        log_file.write(f"Evaluation Results for model: {args.model}\n")
+        log_file.write(f"Timestamp: {timestamp}\n\n")
+        log_file.write("Average Scores:\n")
+        for metric, score in average_scores.items():
+            log_file.write(f"{metric}: {score:.4f}\n")
+        
+        log_file.write(f"\nDetailed Results:\n")
+        for result in results:
+            log_file.write(f"\nRepository: {result['repo_name']}\n")
+            log_file.write("Scores:\n")
+            log_file.write(f"  BLEU: {result['bleu']:.4f}\n")
+            log_file.write(f"  ROUGE-1: {result['rouge']['rouge-1']:.4f}\n")
+            log_file.write(f"  ROUGE-2: {result['rouge']['rouge-2']:.4f}\n")
+            log_file.write(f"  ROUGE-L: {result['rouge']['rouge-l']:.4f}\n")
+            log_file.write(f"  Cosine Similarity: {result['cosine_similarity']:.4f}\n")
+            log_file.write(f"  Title Similarity: {result['structural_similarity']['title_similarity']:.4f}\n")
+            log_file.write(f"  Information Retrieval: {result['information_retrieval']:.4f}\n")
+            log_file.write(f"  Code Consistency: {result['code_consistency']:.4f}\n")
+            log_file.write(f"  Readability: {result['readability']:.4f}\n")
+            log_file.write(f"  Weighted Score: {result['weighted_score']:.4f}\n")
+
+    print(f"\nResults saved to {log_filename}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate and evaluate README files using OpenAI API")
+    parser.add_argument("model", help="OpenAI model to use")
+    parser.add_argument("--base_url", help="Optional base URL for OpenAI API", default=None)
+    args = parser.parse_args()
+    
+    main(args)

_script_for_gen.py

@@ -0,0 +1,132 @@
+import os
+import subprocess
+import json
+import logging
+from github import Github
+import tiktoken
+from pathlib import Path
+import shutil
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Initialize GitHub client
+github_token = os.getenv('GITHUB_TOKEN')
+if not github_token:
+    raise ValueError("GITHUB_TOKEN environment variable is not set")
+g = Github(github_token)
+
+# Initialize tokenizer
+tokenizer = tiktoken.get_encoding("cl100k_base")
+
+def clone_repo(repo_url, repo_name):
+    tmp_dir = f"/tmp/{repo_name}"
+    subprocess.run(["git", "clone", "--depth", "1", repo_url, tmp_dir], check=True)
+    return tmp_dir
+
+def get_repo_content(repo_dir):
+    content = []
+    for root, dirs, files in os.walk(repo_dir):
+        if "test" in root.lower() or "example" in root.lower():
+            continue
+        for file in files:
+            if file.endswith('.py'):
+                file_path = os.path.join(root, file)
+                relative_path = os.path.relpath(file_path, repo_dir)
+                with open(file_path, 'r') as f:
+                    file_content = f.read()
+                content.append(f"File: {relative_path}\n\n{file_content}\n\n")
+    return "\n".join(content)
+
+def count_tokens(text):
+    return len(tokenizer.encode(text))
+
+def process_repo(repo):
+    repo_name = repo.name
+    repo_url = repo.clone_url
+    logging.info(f"Processing repository: {repo_name}")
+
+    try:
+        tmp_dir = clone_repo(repo_url, repo_name)
+        readme_path = os.path.join(tmp_dir, "README.md")
+        
+        if not os.path.exists(readme_path):
+            logging.info(f"README.md not found in {repo_name}")
+            return None
+
+        repo_content = get_repo_content(tmp_dir)
+        if count_tokens(repo_content) >= 100000:
+            logging.info(f"Repository {repo_name} content exceeds 100k tokens")
+            return None
+
+        with open(readme_path, 'r') as f:
+            readme_content = f.read()
+
+        repo_commit = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=tmp_dir).decode().strip()
+
+        return {
+            "repo_name": repo_name,
+            "repo_commit": repo_commit,
+            "repo_content": repo_content,
+            "repo_readme": readme_content
+        }
+    except Exception as e:
+        logging.error(f"Error processing repository {repo_name}: {str(e)}")
+        return None
+    finally:
+        if 'tmp_dir' in locals():
+            shutil.rmtree(tmp_dir)
+
+def load_existing_data(filename):
+    existing_data = {}
+    if os.path.exists(filename):
+        with open(filename, "r") as f:
+            for line in f:
+                item = json.loads(line)
+                existing_data[item['repo_name']] = item
+    return existing_data
+
+def save_dataset(filename, dataset, mode='a'):
+    with open(filename, mode) as f:
+        for item in dataset:
+            json.dump(item, f)
+            f.write("\n")
+
+def main():
+    g = Github(os.getenv('GITHUB_TOKEN'))
+    filename = "generate-readme-eval.jsonl"
+    existing_data = load_existing_data(filename)
+    
+    new_dataset = []
+    updated_count = 0
+    skipped_count = 0
+
+    repos = g.search_repositories(query="language:python stars:>1000 forks:>100", sort="stars", order="desc")
+
+    for i, repo in enumerate(repos[200:400]):
+        if repo.full_name in existing_data:
+            existing_item = existing_data[repo.full_name]
+            if existing_item['repo_commit'] == repo.get_commits()[0].sha:
+                skipped_count += 1
+                logging.info(f"Skipped {repo.full_name}: Already processed with same commit")
+                continue
+            else:
+                logging.info(f"Updating {repo.full_name}: Commit changed")
+                updated_count += 1
+        
+        item = process_repo(repo)
+        if item:
+            new_dataset.append(item)
+        
+        if i % 10 == 0:
+            logging.info(f"Processed {i+1} repositories")
+
+    # Append new and updated items to the file
+    save_dataset(filename, new_dataset, mode='a')
+
+    logging.info(f"Dataset updated with {len(new_dataset)} new/updated items")
+    logging.info(f"Skipped {skipped_count} repositories (no changes)")
+    logging.info(f"Updated {updated_count} repositories")
+
+if __name__ == "__main__":
+    main()