Update app.py

app.py

@@ -5,10 +5,7 @@ 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
 import pandas as pd
-import json
 
 # Load pre-trained embedding model for basic analysis
 sentence_model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
@@ -37,19 +34,6 @@ def extract_text_from_file(file_path):
     else:
         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.
@@ -57,37 +41,53 @@ def analyze_with_gemini(resume_text, job_desc):
     Job Description: {job_desc}
     Extract:
     1. Candidate Name
-    2. Relevant Skills
-    3. Educational Background
-    4. Team Leadership Experience (years)
-    5. Management Experience (years)
-    6. Management Skills (leadership + management)
-    Provide a summary of qualifications in 5 bullet points in JSON format.
+    2. Email Address
+    3. Contact Number
+    4. Relevant Skills
+    5. Educational Background
+    6. Team Leadership Experience (years)
+    7. Management Experience (years)
+    8. Management Skills (e.g. strategic planning, team management, project management, etc.)
+    9. Match Percentage (leadership and management focus)
+    Provide a summary of qualifications in 5 bullet points.
     """
     response = genai.GenerativeModel('gemini-1.5-flash').generate_content(prompt)
-    try:
-        # Parse the JSON output
-        analysis = json.loads(response.text.strip())
-        return {
-            "Candidate Name": analysis.get("Candidate Name", "Unknown"),
-            "Relevant Skills": analysis.get("Relevant Skills", "Not Extracted"),
-            "Educational Background": analysis.get("Educational Background", "Not Extracted"),
-            "Leadership Experience (years)": analysis.get("Team Leadership Experience (years)", "Not Extracted"),
-            "Management Experience (years)": analysis.get("Management Experience (years)", "Not Extracted"),
-            "Management Skills": analysis.get("Management Skills (leadership + management)", "Not Extracted"),
-            "Summary": analysis.get("Summary", "Not Extracted")
-        }
-    except json.JSONDecodeError:
-        # Handle parsing errors
-        return {
-            "Candidate Name": "Unknown",
-            "Relevant Skills": "Failed",
-            "Educational Background": "Failed",
-            "Leadership Experience (years)": "Failed",
-            "Management Experience (years)": "Failed",
-            "Management Skills": "Failed",
-            "Summary": response.text.strip()
-        }
+    return response.text.strip()
+
+def extract_management_details(gemini_response):
+    # Regular expressions for extracting leadership and management details
+    leadership_exp_pattern = r"Team Leadership Experience \(years\):\s*(\d+)"
+    management_exp_pattern = r"Management Experience \(years\):\s*(\d+)"
+    management_skills_pattern = r"Management Skills\s*[:\-]?\s*(.*?)(?=\n|$)"
+
+    leadership_match = re.search(leadership_exp_pattern, gemini_response)
+    management_match = re.search(management_exp_pattern, gemini_response)
+    skills_match = re.search(management_skills_pattern, gemini_response)
+
+    leadership_years = int(leadership_match.group(1)) if leadership_match else 0
+    management_years = int(management_match.group(1)) if management_match else 0
+    skills = skills_match.group(1) if skills_match else ""
+
+    return leadership_years, management_years, skills
+
+def calculate_overall_match(leadership_years, management_years, skills, required_skills, max_leadership_exp=10, max_management_exp=10):
+    # Assign weight to leadership, management, and relevant skills
+    leadership_weight = 0.4  # 40% weight to leadership
+    management_weight = 0.4   # 40% weight to management
+    skills_weight = 0.2      # 20% weight to skills
+
+    # Normalize years of experience to 100% scale (if maximum years of experience is 10 years)
+    leadership_score = min(leadership_years / max_leadership_exp, 1.0) * 100
+    management_score = min(management_years / max_management_exp, 1.0) * 100
+
+    # Calculate skill match (based on whether any required skills are present in the resume)
+    skill_match = any(skill.lower() in skills.lower() for skill in required_skills)
+
+    skill_score = 100 if skill_match else 0
+
+    # Calculate the overall match score
+    overall_match = (leadership_score * leadership_weight) + (management_score * management_weight) + (skill_score * skills_weight)
+    return round(overall_match, 2)
 
 def process_resumes(job_desc_file, resumes):
     if not job_desc_file or not resumes:
@@ -99,6 +99,9 @@ def process_resumes(job_desc_file, resumes):
     # Load job description text
     job_desc = extract_text_from_file(job_desc_file)
 
+    # Define the key leadership and management skills you're looking for
+    required_skills = ["strategic planning", "team management", "project management", "decision making", "communication"]
+
     results = []
     for resume in resumes:
         resume_text = extract_text_from_file(resume.name)
@@ -106,83 +109,57 @@ def process_resumes(job_desc_file, resumes):
         if not resume_text.strip():
             results.append({
                 "Resume": resume.name,
-                "Similarity (Embed)": 0.0,
-                "Match Percentage (TF-IDF)": 0.0,
+                "Candidate Name": "N/A",
+                "Email": "N/A",
+                "Contact": "N/A",
+                "Overall Match Percentage": 0.0,
                 "Gemini Analysis": "Failed to extract text from resume."
             })
             continue
 
-        # 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)
+            # Extract leadership and management details
+            leadership_years, management_years, skills = extract_management_details(gemini_analysis)
+            # Calculate overall match percentage
+            overall_match = calculate_overall_match(leadership_years, management_years, skills, required_skills)
+            # Extract candidate details
+            name, email, contact = extract_candidate_details(gemini_analysis)
         except Exception as e:
-            gemini_analysis = {
-                "Candidate Name": "Unknown",
-                "Relevant Skills": "Failed",
-                "Educational Background": "Failed",
-                "Leadership Experience (years)": "Failed",
-                "Management Experience (years)": "Failed",
-                "Management Skills": "Failed",
-                "Summary": f"Gemini analysis failed: {str(e)}"
-            }
-
-        # Assign weights to Leadership, Management, and Management Skills
-        try:
-            leadership_years = float(gemini_analysis.get("Leadership Experience (years)", 0))
-            management_years = float(gemini_analysis.get("Management Experience (years)", 0))
-            management_skills = float(gemini_analysis.get("Management Skills", 0))
-        except ValueError:
-            leadership_years = 0.0
-            management_years = 0.0
-            management_skills = 0.0
-
-        # Define weights for each metric
-        overall_score = (
-            0.3 * embed_similarity +  # 30% weight to embedding similarity
-            0.3 * tfidf_match +       # 30% weight to TF-IDF match
-            0.2 * leadership_years +  # 20% weight to leadership experience (years)
-            0.1 * management_years +  # 10% weight to management experience (years)
-            0.1 * management_skills   # 10% weight to management skills (combined leadership + management)
-        )
+            gemini_analysis = f"Gemini analysis failed: {str(e)}"
+            name, email, contact = "N/A", "N/A", "N/A"
+            overall_match = 0.0
 
         results.append({
             "Resume": resume.name,
-            "Overall Score": round(overall_score, 2),
-            "Similarity (Embed)": embed_similarity,
-            "Match Percentage (TF-IDF)": tfidf_match,
-            "Leadership Experience (years)": leadership_years,
-            "Management Experience (years)": management_years,
-            "Management Skills": management_skills,
-            "Gemini Analysis": gemini_analysis["Summary"]
+            "Candidate Name": name,
+            "Email": email,
+            "Contact": contact,
+            "Overall Match Percentage": overall_match,
+            "Gemini Analysis": gemini_analysis
         })
 
-    # Convert results to pandas DataFrame
+    # Create a pandas DataFrame for better formatting and downloadable output
     df = pd.DataFrame(results)
 
-    # Save DataFrame to CSV
-    csv_file = "/tmp/analysis_results.csv"
-    df.to_csv(csv_file, index=False)
+    # Output the DataFrame as a CSV file for download
+    output_file = "/tmp/analysis_results.csv"
+    df.to_csv(output_file, index=False)
 
-    return csv_file
+    return df, output_file
 
 # 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="filepath")
-
-results_output = gr.File(label="Download Analysis Results (CSV)")
+results_output = gr.Dataframe(label="Analysis Results", headers=["Resume", "Candidate Name", "Email", "Contact", "Overall Match Percentage", "Gemini Analysis"], show_label=False)
 
 interface = gr.Interface(
     fn=process_resumes,
     inputs=[job_desc_input, resumes_input],
-    outputs=[results_output],
+    outputs=[results_output, gr.File(label="Download CSV Results")],
     title="Resume Analysis with Gemini API",
-    description="Upload a job description and resumes to evaluate candidates' match."
+    description="Upload a job description and resumes to evaluate candidates' match focusing on leadership and management."
 )
 
 interface.launch()