Upload 2 files

_script_for_eval.py

@@ -1,231 +1,132 @@
 import os
-import argparse
+import subprocess
 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}")
+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)
     
-    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")
+    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)
         
-        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 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__":
-    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)
+    main()

_script_for_gen.py

@@ -1,132 +1,411 @@
 import os
-import subprocess
+import argparse
 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
+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
+import time
+from datetime import datetime
+import google.generativeai as genai
+import traceback
+
+SLEEP_INTERVAL = 30
+
+nltk.download('punkt', quiet=True)
+nltk.download('averaged_perceptron_tagger', quiet=True)
+
+def create_client(model_name, base_url):
+    if model_name.lower().startswith('gemini'):
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            raise ValueError("GOOGLE_API_KEY environment variable is not set")
+        genai.configure(api_key=api_key)
+        return 'gemini'
+    else:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable is not set")
+        return openai.OpenAI(api_key=api_key) if base_url is None else openai.OpenAI(api_key=api_key, base_url=base_url)
+
+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)
+    
+    # Calculate section difference
+    max_sections = max(len(ref_sections), len(cand_sections))
+    section_diff = abs(len(ref_sections) - len(cand_sections))
+    section_similarity = 1 - (section_diff / max_sections) if max_sections > 0 else 0
+    
+    # Calculate title similarity
+    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)) if ref_titles or cand_titles else 0
+    
+    # Combine section and title similarity
+    structural_similarity = (section_similarity + title_similarity) / 2
+    
+    return structural_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.033,
+        'rouge-2': 0.033,
+        'rouge-l': 0.034,
+        'cosine_similarity': 0.1,
+        'structural_similarity': 0.1,
+        'information_retrieval': 0.2,
+        'code_consistency': 0.2,
+        'readability': 0.2
+    }
+    
+    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 +
+        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_openai(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 generate_readme_gemini(repo_content, model):
+    safe = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE",
+    },
+    ]
+    prompt = f"""Create a README.md file for a GitHub repository based on the following repository content. 
+    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.
+
+    Repository content:
+
+    {repo_content}
+    """
+
+    model = genai.GenerativeModel(model,safety_settings=safe)
+    response = model.generate_content(prompt)
+    
+    return response.text
+
+def generate_readme(repo_content, model_name, client):
+    if client == 'gemini':
+        return generate_readme_gemini(repo_content, model_name)
+    else:
+        return generate_readme_openai(repo_content, model_name, client)
+
+def main(args):
+    dataset = load_dataset("patched-codes/generate-readme-eval")
+    
+    results = []
+
+    if args.generate_fine_tune_jsonl:
+        output_file = f"fine_tune_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jsonl"
+        generate_fine_tune_jsonl(dataset, output_file)
+        print(f"Fine-tune JSONL file generated: {output_file}")
+        return
+    
+    if args.oracle:
+        model_name = "oracle"
+    else:
+        model_name = args.model
+        client = create_client(model_name, args.base_url)
+
+    for item in tqdm(dataset['test'], desc="Processing repos"):
+        try:
+            if args.oracle:
+                # Use the existing README as both reference and generated
+                generated_readme = item['repo_readme']
+            elif args.n_shot > 0:
+                generated_readme = generate_readme_n_shot(item['repo_content'], model_name, client, dataset['train'], args.n_shot)
             else:
-                logging.info(f"Updating {repo.full_name}: Commit changed")
-                updated_count += 1
-        
-        item = process_repo(repo)
-        if item:
-            new_dataset.append(item)
+                generated_readme = generate_readme(item['repo_content'], model_name, client)
+            
+            eval_result = evaluate_readme(item['repo_readme'], generated_readme, item['repo_content'])
+            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
+        if model_name.lower().startswith('gemini'):
+            time.sleep(SLEEP_INTERVAL)
+    
+    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]),
+        'structural_similarity': np.mean([r['structural_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"{model_name}_results_{timestamp}.log"
+    
+    with open(log_filename, 'w') as log_file:
+        log_file.write(f"Evaluation Results for model: {model_name}\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")
         
-        if i % 10 == 0:
-            logging.info(f"Processed {i+1} repositories")
+        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"  Structural Similarity: {result['structural_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")
 
-    # Append new and updated items to the file
-    save_dataset(filename, new_dataset, mode='a')
+    print(f"\nResults saved to {log_filename}")
 
-    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")
+def generate_fine_tune_jsonl(dataset, output_file):
+    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."""
+
+    with open(output_file, 'w') as f:
+        for item in tqdm(dataset['train'], desc="Generating fine-tune data"):
+            user_prompt = f"Here is the content of the repository:\n\n{item['repo_content']}\n\nBased on this content, please generate a README.md file."
+            
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+                {"role": "assistant", "content": item['repo_readme']}
+            ]
+            
+            json.dump({"messages": messages}, f)
+            f.write('\n')
+
+def find_similar_examples(repo_content, train_dataset, n):
+    vectorizer = TfidfVectorizer()
+    train_contents = [item['repo_content'] for item in train_dataset]
+    train_vectors = vectorizer.fit_transform(train_contents)
+    query_vector = vectorizer.transform([repo_content])
+    
+    similarities = cosine_similarity(query_vector, train_vectors).flatten()
+    top_n_indices = similarities.argsort()[-n:][::-1]
+    
+    return [train_dataset[int(i)] for i in top_n_indices]
+
+def generate_readme_n_shot(repo_content, model_name, client, train_dataset, n_shot):
+    similar_examples = find_similar_examples(repo_content, train_dataset, n_shot)
+    
+    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."""
+
+    few_shot_examples = ""
+    for example in similar_examples:
+        few_shot_examples += f"Repository content:\n\n{example['repo_content']}\n\n"
+        few_shot_examples += f"Generated README:\n\n{example['repo_readme']}\n\n---\n\n"
+
+    user_prompt = f"""Here are some examples of repository contents and their corresponding README files:
+
+{few_shot_examples}
+Now, here is the content of the repository you need to create a README for:
+
+{repo_content}
+
+Based on this content and the examples provided, please generate a README.md file."""
+
+    if client == 'gemini':
+        safe = [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+        ]
+        model = genai.GenerativeModel(model_name, safety_settings=safe)
+        response = model.generate_content(user_prompt)
+        return response.text
+    else:
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        return response.choices[0].message.content
 
 if __name__ == "__main__":
-    main()
+    parser = argparse.ArgumentParser(description="Generate and evaluate README files using OpenAI or Gemini API, or compute oracle scores")
+    parser.add_argument("model", nargs='?', help="Model to use (e.g., 'gpt-4o-mini' for OpenAI or 'gemini-1.5-flash' for Google)")
+    parser.add_argument("--base_url", help="Optional base URL for OpenAI API", default=None)
+    parser.add_argument("--oracle", action="store_true", help="Compute oracle scores using existing READMEs")
+    parser.add_argument("--generate-fine-tune-jsonl", action="store_true", help="Generate a JSONL file for fine-tuning")
+    parser.add_argument("--n_shot", type=int, default=0, help="Number of examples to use for few-shot learning")
+    args = parser.parse_args()
+    
+    if args.generate_fine_tune_jsonl:
+        if args.oracle or args.model:
+            parser.error("--generate-fine-tune-jsonl flag cannot be used with --oracle or model specification")
+    elif args.oracle and args.model:
+        parser.error("--oracle flag cannot be used with a model specification")
+    elif not args.oracle and not args.model:
+        parser.error("Either --oracle flag or a model name must be provided")
+    
+    main(args)