Update app.py

app.py

@@ -1,87 +1,77 @@
 import gradio as gr
+import pdfplumber
 import torch
 from transformers import pipeline
-import pdfplumber
-import re
 import pandas as pd
+from huggingface_hub import login
 
-# Load a different pre-trained model for Named Entity Recognition (NER)
-nlp = pipeline("ner", model="huggingface/bert-base-cased", framework="pt")
+# Log in to Hugging Face using your API token (if needed for private models)
+# You can generate an API token from https://huggingface.co/settings/tokens
+login(token="your_huggingface_token")
+
+# Load the model for Named Entity Recognition (NER)
+# You can replace 'dbmdz/bert-large-cased-finetuned-conll03-english' with any other model if needed
+nlp = pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english", framework="pt")
 
 def extract_text_from_pdf(pdf_file):
-    """Extract text from the uploaded PDF resume."""
-    with pdfplumber.open(pdf_file) as pdf:
-        text = ""
+    """Extracts text from a PDF file using pdfplumber"""
+    with pdfplumber.open(pdf_file.name) as pdf:
+        text = ''
         for page in pdf.pages:
             text += page.extract_text()
     return text
 
-def parse_resume(resume_text):
-    """Parse the resume and extract details like name, email, phone, skills, etc."""
-    # Define regex for phone and email extraction
-    phone_pattern = r'\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}'
-    email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
-
-    # Extract phone and email using regex
-    phone = re.findall(phone_pattern, resume_text)
-    email = re.findall(email_pattern, resume_text)
-
-    # Extract named entities (e.g., skills, education, and experience)
-    entities = nlp(resume_text)
+def parse_resume(pdf_file):
+    """Parses the resume and extracts relevant information"""
+    # Extract text from PDF
+    resume_text = extract_text_from_pdf(pdf_file)
     
-    # For simplicity, we just list out the entities here
-    skills = []
-    experience = []
-    education = []
-    certifications = []
+    # Use the NER model to identify entities in the resume
+    entities = nlp(resume_text)
 
-    # Iterate through recognized entities and categorize them
+    # Initialize empty fields
+    name = email = phone = education = skills = experience = None
+
+    # Example parsing logic based on NER output
     for entity in entities:
-        if 'ORG' in entity['entity']:
-            experience.append(entity['word'])
-        elif 'MISC' in entity['entity']:
-            skills.append(entity['word'])
-        elif 'LOC' in entity['entity']:
-            education.append(entity['word'])
-        else:
-            certifications.append(entity['word'])
+        if entity['label'] == 'PER':
+            name = entity['word']  # If detected, use the first person name
+        elif entity['label'] == 'ORG':
+            experience = entity['word']  # Could be an organization name (e.g., employer)
+        elif entity['label'] == 'EMAIL':
+            email = entity['word']
+        elif entity['label'] == 'MISC':
+            skills = entity['word']  # Example for skills or qualifications
 
-    # Create a dictionary of parsed data
-    parsed_data = {
-        "Phone": phone[0] if phone else "Not found",
-        "Email": email[0] if email else "Not found",
-        "Skills": ", ".join(skills),
-        "Experience": ", ".join(experience),
-        "Education": ", ".join(education),
-        "Certifications": ", ".join(certifications)
+    return {
+        'Name': name,
+        'Email': email,
+        'Phone': phone,
+        'Education': education,
+        'Skills': skills,
+        'Experience': experience,
     }
 
-    return parsed_data
-
-def process_resumes(pdf_files):
-    """Process multiple resumes and output a single Excel file."""
-    all_parsed_data = []
-
-    # Loop through each uploaded PDF file and parse the data
+def batch_process_resumes(pdf_files):
+    """Process a batch of resume PDFs and output in a DataFrame"""
+    all_resumes = []
     for pdf_file in pdf_files:
-        resume_text = extract_text_from_pdf(pdf_file)
-        parsed_info = parse_resume(resume_text)
-        all_parsed_data.append(parsed_info)
-
-    # Convert the parsed data into a pandas DataFrame
-    df = pd.DataFrame(all_parsed_data)
-
-    # Save the DataFrame to an Excel file
-    output_file = "parsed_resumes.xlsx"
-    df.to_excel(output_file, index=False)
+        resume_info = parse_resume(pdf_file)
+        all_resumes.append(resume_info)
+    
+    # Convert to DataFrame
+    df = pd.DataFrame(all_resumes)
+    # Save to Excel
+    df.to_excel("parsed_resumes.xlsx", index=False)
+    return "Excel file with parsed resumes has been saved as 'parsed_resumes.xlsx'."
 
-    return output_file
+# Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("### AI Resume Parser")
+    file_input = gr.File(file_count="multiple", label="Upload Resumes (PDFs)")
+    output = gr.Textbox(label="Result")
+    process_button = gr.Button("Process Resumes")
+    
+    process_button.click(batch_process_resumes, inputs=file_input, outputs=output)
 
-# Define Gradio interface
-gr.Interface(
-    fn=process_resumes,
-    inputs=gr.File(file_count="multiple", label="Upload Resumes (PDFs)"),
-    outputs=gr.File(label="Download Parsed Data (Excel)"),
-    title="AI Resume Parser",
-    description="Upload multiple resumes (PDFs) to extract details like Name, Email, Phone, Skills, Experience, Education, and Certifications. The results will be saved in an Excel file."
-).launch()
+demo.launch()