Update app.py

app.py

@@ -1,112 +1,86 @@
 import gradio as gr
-from sentence_transformers import SentenceTransformer, util
-import docx
 import os
-from PyPDF2 import PdfReader
+import csv
+import re
 import requests
-import pandas as pd
+from sentence_transformers import SentenceTransformer, util
 
-# Load pre-trained model for sentence embedding
+# Initialize Sentence-Transformer model
 model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
 
-# Define maximum number of resumes
-MAX_RESUMES = 10
-
-# Function to fetch Google API key from environment variable
-def get_google_api_key():
-    api_key = os.getenv('GOOGLE_API_KEY')  # Fetching the API key from environment variables
-    if not api_key:
-        raise ValueError("Google API key not found in environment variables.")
-    return api_key
-
-# Function to extract text from resume (handles .txt, .pdf, .docx)
-def extract_text_from_resume(resume_file):
-    file_extension = os.path.splitext(resume_file)[1].lower()
-    if file_extension not in ['.txt', '.pdf', '.docx']:
-        return "Unsupported file format"
-
-    if file_extension == '.txt':
-        return read_text_file(resume_file)
-    elif file_extension == '.pdf':
-        return read_pdf_file(resume_file)
-    elif file_extension == '.docx':
-        return read_docx_file(resume_file)
-
-    return "Failed to read the resume text."
-
-def read_text_file(file_path):
-    with open(file_path, 'r') as file:
-        return file.read()
-
-def read_pdf_file(file_path):
-    reader = PdfReader(file_path)
-    text = ""
-    for page in reader.pages:
-        text += page.extract_text()
-    return text
-
-def read_docx_file(file_path):
-    doc = docx.Document(file_path)
-    text = ""
-    for para in doc.paragraphs:
-        text += para.text
-    return text
-
-# System prompt to extract candidate details from the resume
-def system_prompt_to_extract_info(resume_text):
-    prompt = f"""
-    Extract the following information from the resume:
-    1. Candidate's Full Name
-    2. Candidate's Email Address
-    3. Candidate's Contact Number
+# Define a function to extract leadership experience from resume text
+def extract_leadership_experience(resume_text):
+    # Define leadership-related keywords/phrases
+    leadership_keywords = [
+        "led", "managed", "team lead", "supervised", "coordinated", "directed", 
+        "oversaw", "responsible for", "led a team", "executed", "mentored", 
+        "project manager", "leadership role", "department head", "team captain"
+    ]
     
-    Resume Text: {resume_text}
+    # Convert resume text to lower case for case-insensitive matching
+    resume_text_lower = resume_text.lower()
     
-    Return the results in the following format:
-    - Name: [Extracted Name]
-    - Email: [Extracted Email]
-    - Contact: [Extracted Contact Number]
-    """
-    return prompt
-
-# Function to extract candidate information from resume text
+    # Look for matches in the resume text
+    leadership_experience = []
+    for keyword in leadership_keywords:
+        if re.search(r"\b" + re.escape(keyword) + r"\b", resume_text_lower):
+            leadership_experience.append(keyword)
+
+    # Return leadership experience as a string
+    if leadership_experience:
+        return ", ".join(set(leadership_experience))
+    else:
+        return "No leadership experience found"
+
+# Define a function to extract contact info using Gemini API (simulated here)
 def extract_entities_via_gemini(resume_text):
-    api_key = get_google_api_key()  # Fetch the API key from environment variables
-    endpoint = "https://gemini.googleapis.com/v1/documents:analyzeEntities"  # Placeholder API endpoint (adjust as necessary)
-
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json"
-    }
-
-    document = {
-        "document": {
-            "type": "PLAIN_TEXT",
-            "content": resume_text
-        }
-    }
+    # This is a simulation of the Google Gemini API. Replace with your actual API calls.
+    response = requests.post(
+        "https://your-gemini-api-endpoint.com",  # Replace with actual endpoint
+        data={"text": resume_text}
+    )
     
-    # Send request to Gemini or another NLP API
-    response = requests.post(endpoint, headers=headers, json=document)
+    # Simulate successful response with mock data
+    if response.status_code == 200:
+        data = response.json()
+        return {
+            "name": data.get("name", "Unknown"),
+            "email": data.get("email", "No Email"),
+            "contact": data.get("contact", "No Contact")
+        }
+    else:
+        return {
+            "name": "Unknown",
+            "email": "No Email",
+            "contact": "No Contact"
+        }
 
-    if response.status_code != 200:
-        return {"error": "Failed to extract entities from resume", "status_code": response.status_code, "response": response.text}
-    
-    # Process the response from the Gemini API (or similar NLP API)
-    entities = response.json().get('entities', [])
-    extracted_info = {"name": "Unknown Candidate", "email": "No Email", "contact": "No Contact"}
-
-    for entity in entities:
-        if entity['type'] == 'PERSON':
-            extracted_info['name'] = entity['name']
-        if entity['type'] == 'EMAIL':
-            extracted_info['email'] = entity['name']
-        if entity['type'] == 'PHONE_NUMBER':
-            extracted_info['contact'] = entity['name']
-    
-    return extracted_info
+# Function to extract text from resumes (assumes .pdf or .txt files)
+def extract_text_from_resume(resume_file):
+    # Add your extraction logic here based on the file type (e.g., PDF, DOCX, TXT)
+    try:
+        if resume_file.name.endswith('.txt'):
+            with open(resume_file.name, 'r') as file:
+                return file.read()
+        elif resume_file.name.endswith('.pdf'):
+            # Add logic to extract text from PDF
+            return "Extracted text from PDF file"
+        else:
+            return ""
+    except Exception as e:
+        return ""
 
-# Function to check similarity between resumes and job description
+# Function to save results to CSV
+def save_results_to_csv(results):
+    csv_file_path = "/tmp/resume_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
+
+# Function to check similarity and process resumes
 def check_similarity(job_description, resume_files):
     results = []
     job_emb = model.encode(job_description, convert_to_tensor=True)
@@ -157,37 +131,24 @@ def check_similarity(job_description, resume_files):
     csv_file_path = save_results_to_csv(results)
     return results, csv_file_path
 
-# Function to save results to CSV
-def save_results_to_csv(results):
-    df = pd.DataFrame(results, columns=["Resume File", "Similarity Score (%)", "Eligibility", "Candidate Name", "Leadership Experience", "Email", "Contact"])
-    csv_file = "/tmp/results.csv"
-    df.to_csv(csv_file, index=False)
-    return csv_file  # Return the file path
-
-# Gradio Interface Components
-job_desc_input = gr.File(label="Upload Job Description (TXT)", type="filepath")
-resumes_input = gr.Files(label="Upload Resumes (TXT, DOCX, PDF)", type="filepath")
-
-# Gradio Outputs
-results_output = gr.Dataframe(headers=[
-    "Resume File", 
-    "Similarity Score (%)", 
-    "Eligibility", 
-    "Candidate Name", 
-    "Leadership Experience", 
-    "Email", 
-    "Contact"], 
-    label="Analysis Results"
-)
-
-# Gradio Interface
-interface = gr.Interface(
-    fn=check_similarity,
-    inputs=[job_desc_input, resumes_input],
-    outputs=[results_output, gr.File(label="Download CSV")],  # Now works properly without value
-    title="HR Assistant - Resume Screening & Leadership Experience",
-    description="Upload job description and resumes to screen candidates for managerial and team leadership roles and extract candidate details.",
-    allow_flagging="never"
-)
-
-interface.launch()
+# Function to download the results as a CSV file
+def download_results(results):
+    return save_results_to_csv(results)
+
+# Define Gradio Interface
+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"])
+    
+    # Define the button to trigger similarity check
+    check_button = gr.Button("Check Similarity")
+    
+    # Set up the button's action
+    check_button.click(check_similarity, inputs=[job_desc_input, resume_input], outputs=[results_output, gr.File(label="Download CSV", file=download_results)])
+
+# Launch the Gradio interface
+demo.launch()
+