Update app.py

app.py

@@ -1,11 +1,11 @@
+import os
 import gradio as gr
+import pandas as pd
 from sentence_transformers import SentenceTransformer, util
-import os
 from PyPDF2 import PdfReader
 import docx
 import re
 import google.generativeai as genai
-import pandas as pd
 import time
 import concurrent.futures
 
@@ -133,23 +133,50 @@ def extract_candidate_details(gemini_response):
 
     return name, email, contact
 
-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
+def calculate_role_score(role_keywords):
+    # Score based on the seniority of the leadership role
+    seniority_score = 0
+    role_hierarchy = {
+        "CEO": 5,
+        "CIO": 5,
+        "Director": 4,
+        "VP": 4,
+        "Manager": 3,
+        "Team Lead": 2,
+        "Junior": 1
+    }
+
+    for keyword, score in role_hierarchy.items():
+        if keyword.lower() in role_keywords.lower():
+            seniority_score = max(seniority_score, score)  # Highest score from role hierarchy
+    
+    return seniority_score
+
+def calculate_advanced_match(leadership_years, management_years, skills, required_skills, role_keywords, max_leadership_exp=10, max_management_exp=10):
+    # Assign weights for leadership, management, and skills
+    leadership_weight = 0.35  # 35% weight to leadership
+    management_weight = 0.35  # 35% weight to management
     skills_weight = 0.2      # 20% weight to skills
+    role_weight = 0.1        # 10% weight to role seniority
 
-    # Normalize years of experience to 100% scale (if maximum years of experience is 10 years)
+    # Normalize years of experience to a 100% scale
     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)
+    # Adjust for role seniority
+    role_score = calculate_role_score(role_keywords)  # Role score based on seniority of role
+    role_score = role_score * 100  # Normalize role score to 100 scale
 
-    skill_score = 100 if skill_match else 0
+    # Calculate skill match: percentage of required skills found in the resume
+    skills_matched = sum(1 for skill in required_skills if skill.lower() in skills.lower())
+    total_skills = len(required_skills)
+    skill_match_score = (skills_matched / total_skills) * 100
 
     # Calculate the overall match score
-    overall_match = (leadership_score * leadership_weight) + (management_score * management_weight) + (skill_score * skills_weight)
+    overall_match = (leadership_score * leadership_weight) + \
+                    (management_score * management_weight) + \
+                    (skill_match_score * skills_weight) + \
+                    (role_score * role_weight)
     return round(overall_match, 2)
 
 def process_resume(resume, job_desc, progress_callback):
@@ -170,8 +197,9 @@ def process_resume(resume, job_desc, progress_callback):
         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)
+        # Calculate overall match percentage using enhanced calculation
+        role_keywords = gemini_analysis.lower()
+        overall_match = calculate_advanced_match(leadership_years, management_years, skills, required_skills, role_keywords)
         # Extract candidate details
         name, email, contact = extract_candidate_details(gemini_analysis)
     except Exception as e:
@@ -190,48 +218,36 @@ def process_resume(resume, job_desc, progress_callback):
         "Gemini Analysis": gemini_analysis
     }
 
-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)
-
+# Main Gradio UI
+def analyze_resumes(resumes, job_desc):
+    progress = gr.Progress()
     results = []
-    total_resumes = len(resumes)
-
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        future_to_resume = {
-            executor.submit(process_resume, resume, job_desc, lambda p: None): resume for resume in resumes
-        }
-
-        for future in concurrent.futures.as_completed(future_to_resume):
-            result = future.result()
-            results.append(result)
     
-    # Create a pandas DataFrame for better formatting and downloadable output
-    df = pd.DataFrame(results)
-
-    # Output the DataFrame as a CSV file for download
-    output_file = "/tmp/analysis_results.csv"
-    df.to_csv(output_file, index=False)
+    # Check for maximum number of resumes
+    if len(resumes) > MAX_RESUMES:
+        return "Error: Cannot upload more than 10 resumes."
+    
+    # Process resumes concurrently
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = []
+        for resume in resumes:
+            futures.append(executor.submit(process_resume, resume, job_desc, progress.update))
+        
+        for future in concurrent.futures.as_completed(futures):
+            results.append(future.result())
 
-    return df, output_file
+    resume_count_message = f"{len(resumes)} resume(s) uploaded."
+    return pd.DataFrame(results), resume_count_message
 
 # 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.Textbox(label="Analysis Results", lines=30)
-
-interface = gr.Interface(
-    fn=process_resumes,
-    inputs=[job_desc_input, resumes_input],
-    outputs=[results_output, gr.File(label="Download Results CSV")],
-    title="Resume Analysis with Gemini API",
-    description="Upload a job description and resumes to evaluate candidates' leadership and management match."
+iface = gr.Interface(
+    fn=analyze_resumes,
+    inputs=[
+        gr.File(label="Upload Resumes (PDF, DOCX, TXT)", file_count="multiple"),
+        gr.Textbox(label="Job Description", lines=5)
+    ],
+    outputs=["dataframe", "text"],
+    live=True
 )
 
-interface.launch()
+iface.launch()