Update app.py

app.py

@@ -1,127 +1,134 @@
 import gradio as gr
-import requests
+from sentence_transformers import SentenceTransformer, util
 import os
-import csv
-from sentence_transformers import util
-
-# Set up API endpoint and API Key
-api_key = os.getenv("GOOGLE_API_KEY")  # Store your API Key in environment variables
-api_url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1-5-flash:embedText"  # Updated for Gemini 1.5 Flash model
-
-headers = {
-    "Authorization": f"Bearer {api_key}",
-    "Content-Type": "application/json"
-}
-
-def get_gemini_embeddings(text):
-    data = {
-        "model": "gemini-1-5-flash",  # Use the Gemini 1.5 Flash model
-        "text": text
-    }
-
-    # Send POST request to Gemini API
-    response = requests.post(api_url, headers=headers, json=data)
-    
-    if response.status_code == 200:
-        response_data = response.json()
-        return response_data.get("embeddings", [])
+from PyPDF2 import PdfReader
+import docx
+import re
+import google.generativeai as genai
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Load pre-trained embedding model for basic analysis
+sentence_model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
+
+# Configure Google API for Gemini 1.5 Flash
+api_key = os.getenv('GOOGLE_API_KEY')
+if not api_key:
+    raise ValueError("Google API key not found. Please set GOOGLE_API_KEY.")
+genai.configure(api_key=api_key)
+
+# Maximum resumes to process
+MAX_RESUMES = 10
+
+# Helper Functions
+def extract_text_from_file(file_path):
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext == ".txt":
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    elif ext == ".pdf":
+        reader = PdfReader(file_path)
+        return "".join(page.extract_text() for page in reader.pages)
+    elif ext == ".docx":
+        doc = docx.Document(file_path)
+        return " ".join(para.text for para in doc.paragraphs)
     else:
-        print(f"Error: {response.status_code} - {response.text}")
-        return []
-
-def extract_text_from_resume(resume_file):
-    # Extract text from resume (for example, using PyPDF2 or textract for PDFs)
-    # This placeholder should be replaced with actual code for resume text extraction
-    return "Sample resume text"
-
-def extract_leadership_experience(resume_text):
-    # Logic to extract leadership experience from resume text
-    return "Leadership Experience Example"
-
-def extract_entities_via_gemini(resume_text):
-    # Logic to extract named entities (e.g., Name, Email, Contact) using Gemini API
-    return {"name": "John Doe", "email": "john.doe@example.com", "contact": "123-456-7890"}
-
-def save_results_to_csv(results):
-    csv_file_path = "/tmp/results.csv"
-    with open(csv_file_path, mode='w', newline='') as file:
-        writer = csv.writer(file)
-        writer.writerow(["Resume Name", "Similarity Score (%)", "Eligibility", "Name", "Leadership Experience", "Email", "Contact"])
-        for result in results:
-            writer.writerow(result)
-    return csv_file_path
-
-def check_similarity(job_description, resume_files):
-    results = []
+        return ""
+
+def calculate_similarity(resume_text, job_desc):
+    resume_emb = sentence_model.encode(resume_text, convert_to_tensor=True)
+    job_emb = sentence_model.encode(job_desc, convert_to_tensor=True)
+    similarity = util.pytorch_cos_sim(resume_emb, job_emb)[0][0].item()
+    return round(similarity * 100, 2)
+
+def calculate_match_percentage(resume_text, job_desc):
+    docs = [resume_text, job_desc]
+    vectorizer = TfidfVectorizer(stop_words="english")
+    tfidf_matrix = vectorizer.fit_transform(docs)
+    cosine_sim = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])
+    return round(cosine_sim[0][0] * 100, 2)
+
+def analyze_with_gemini(resume_text, job_desc):
+    prompt = f"""
+    Analyze the resume with respect to the job description.
+    Resume: {resume_text}
+    Job Description: {job_desc}
+    Extract:
+    1. Candidate Name
+    2. Relevant Skills
+    3. Educational Background
+    4. Team Leadership Experience (years)
+    5. Management Experience (years)
+    6. Match Percentage
+    Provide a summary of qualifications in 5 bullet points.
+    """
+    response = genai.GenerativeModel('gemini-1.5-flash').generate_content(prompt)
+    return response.text.strip()
+
+def process_resumes(job_desc_file, resumes):
+    if not job_desc_file or not resumes:
+        return "Please upload a job description and resumes for analysis."
+
+    if len(resumes) > MAX_RESUMES:
+        return f"Please upload no more than {MAX_RESUMES} resumes."
+
+    # Load job description text
+    job_desc = extract_text_from_file(job_desc_file)
 
-    # Get embeddings for the job description using Gemini 1.5 Flash
-    job_emb = get_gemini_embeddings(job_description)
-    
-    if not job_emb:
-        # In case of an error, return an empty DataFrame and an error message
-        return [["Error in embedding job description using Gemini 1.5 Flash API."]], None
-    
-    for resume_file in resume_files:
-        resume_text = extract_text_from_resume(resume_file)
-        if not resume_text:
-            results.append([resume_file.name, 0, "Not Eligible", None, "No leadership experience", "No Email", "No Contact"])
-            continue
-        
-        # Get embeddings for the resume using Gemini 1.5 Flash
-        resume_emb = get_gemini_embeddings(resume_text)
-        
-        if not resume_emb:
-            results.append([resume_file.name, 0, "Not Eligible", None, "No leadership experience", "No Email", "No Contact"])
+    results = []
+    for resume in resumes:
+        resume_text = extract_text_from_file(resume.name)
+
+        if not resume_text.strip():
+            results.append({
+                "Resume": resume.name,
+                "Similarity (Embed)": 0.0,
+                "Match Percentage (TF-IDF)": 0.0,
+                "Gemini Analysis": "Failed to extract text from resume."
+            })
             continue
-        
-        # Calculate similarity score between job description and resume
-        similarity_score = util.pytorch_cos_sim(job_emb, resume_emb)[0][0].item()
-        similarity_percentage = similarity_score * 100
-        
-        leadership_experience = extract_leadership_experience(resume_text)
-        contact_info = extract_entities_via_gemini(resume_text)
-
-        if similarity_score >= 0.50:
-            candidate_name = contact_info.get('name', 'Unknown Candidate')
-            results.append([
-                resume_file.name, 
-                similarity_percentage, 
-                "Eligible", 
-                candidate_name, 
-                leadership_experience,
-                contact_info.get('email', 'No Email'), 
-                contact_info.get('contact', 'No Contact')
-            ])
-        else:
-            results.append([
-                resume_file.name, 
-                similarity_percentage, 
-                "Not Eligible", 
-                None, 
-                leadership_experience,
-                contact_info.get('email', 'No Email'), 
-                contact_info.get('contact', 'No Contact')
-            ])
-    
-    # Save results to CSV and return them
-    csv_file_path = save_results_to_csv(results)
-    return results, csv_file_path
-
-# Gradio UI
-with gr.Blocks() as demo:
-    with gr.Row():
-        job_desc_input = gr.Textbox(label="Job Description", lines=3)
-        resume_input = gr.Files(label="Upload Resumes", file_count="multiple", file_types=[".pdf", ".txt"])
-
-    results_output = gr.Dataframe(headers=["Resume Name", "Similarity Score (%)", "Eligibility", "Name", "Leadership Experience", "Email", "Contact"])
-
-    check_button = gr.Button("Check Similarity")
-
-    # Set up button's action
-    check_button.click(
-        check_similarity, 
-        inputs=[job_desc_input, resume_input], 
-        outputs=[results_output, gr.File(label="Download CSV")]
+
+        # Calculate similarity using embeddings
+        embed_similarity = calculate_similarity(resume_text, job_desc)
+
+        # Calculate match percentage using TF-IDF
+        tfidf_match = calculate_match_percentage(resume_text, job_desc)
+
+        # Detailed analysis with Gemini API
+        try:
+            gemini_analysis = analyze_with_gemini(resume_text, job_desc)
+        except Exception as e:
+            gemini_analysis = f"Gemini analysis failed: {str(e)}"
+
+        results.append({
+            "Resume": resume.name,
+            "Similarity (Embed)": embed_similarity,
+            "Match Percentage (TF-IDF)": tfidf_match,
+            "Gemini Analysis": gemini_analysis
+        })
+
+    # Format results for display
+    output = "\n\n".join(
+        f"**{res['Resume']}**\n"
+        f"Similarity (Embed): {res['Similarity (Embed)']}%\n"
+        f"Match Percentage (TF-IDF): {res['Match Percentage (TF-IDF)']}%\n"
+        f"Gemini Analysis:\n{res['Gemini Analysis']}\n"
+        for res in results
     )
+    return output
+
+# Gradio Interface
+job_desc_input = gr.File(label="Upload Job Description (TXT, PDF, DOCX)", type="filepath")
+resumes_input = gr.Files(label="Upload Resumes (TXT, PDF, DOCX)", type="file")
+
+results_output = gr.Textbox(label="Analysis Results", lines=30)
+
+interface = gr.Interface(
+    fn=process_resumes,
+    inputs=[job_desc_input, resumes_input],
+    outputs=[results_output],
+    title="Resume Analysis with Gemini API",
+    description="Upload a job description and resumes to evaluate candidates' match."
+)
 
-demo.launch()
+interface.launch()