app.py

import gradio as gr
from transformers import pipeline
import PyPDF2
from PIL import Image
import matplotlib.pyplot as plt
from io import BytesIO
import pandas as pd  # For displaying rankings in a table
import re
import math

# Load the token classification pipeline
model_name = "jjzha/jobbert_knowledge_extraction"
pipe = pipeline("token-classification", model=model_name, aggregation_strategy="first")

# Aggregate overlapping or adjacent spans into 1 entity
def aggregate_span(results):
    new_results = []
    current_result = results[0]
    for result in results[1:]:
        if result["start"] == current_result["end"] + 1:
            current_result["word"] += " " + result["word"]
            current_result["end"] = result["end"]
        else:
            new_results.append(current_result)
            current_result = result
    new_results.append(current_result)
    return new_results

# Extract knowledge entities from job posting
def ner(text):
    output_knowledge = pipe(text)
    for result in output_knowledge:
        if result.get("entity_group"):
            result["entity"] = "Knowledge"
            del result["entity_group"]
    if len(output_knowledge) > 0:
        output_knowledge = aggregate_span(output_knowledge)

    return {"text": text, "entities": output_knowledge}

# Extract text from input PDF
def extract_pdf(pdf_file):
    reader = PyPDF2.PdfReader(pdf_file)
    text = ''
    for page in reader.pages:
        text += page.extract_text()
    return text

def rank_knowledge(entities, job_posting_text, resume_text):
    scores = {}
    priority_keywords = ["must-have", "required", "preferred", "key", "important"]

    for entity in entities:
        term = entity["word"].lower()
        term_score = 0

        # Count exact matches of the term in the job posting
        term_score += len(re.findall(rf'\b{re.escape(term)}\b', job_posting_text.lower()))

        # Proximity to priority keywords
        term_positions = [m.start() for m in re.finditer(rf'\b{re.escape(term)}\b', job_posting_text.lower())]
        for keyword in priority_keywords:
            keyword_positions = [m.start() for m in re.finditer(rf'\b{re.escape(keyword)}\b', job_posting_text.lower())]
            for t_pos in term_positions:
                for k_pos in keyword_positions:
                    if abs(t_pos - k_pos) < 20:  # Within 20 characters
                        term_score += 1

        scores[term] = term_score

    # Normalize
    max_score = max(scores.values(), default=1)
    ranked_entities = [
        {
            "Term": k,
            "Score": (math.log1p(v) / math.log1p(max_score)) * 100,  # Log scaling
            "In Resume": "Yes" if k in resume_text.lower() else "No"
        }
        for k, v in scores.items()
    ]

    ranked_entities.sort(key=lambda x: x["Score"], reverse=True)
    return ranked_entities
    
# Compare extracted knowledge entities with the resume
def compare_with_resume(output_knowledge, resume_file):
    resume_text = extract_pdf(resume_file) if resume_file else ''
    matched_knowledge = []
    unmatched_knowledge = []

    for entity in output_knowledge:
        if entity["word"].lower() in resume_text.lower():
            matched_knowledge.append(entity["word"])
        else:
            unmatched_knowledge.append(entity["word"])
    return matched_knowledge, unmatched_knowledge

def plot_comparison(matched_knowledge, unmatched_knowledge):
    labels = ['Matched', 'Unmatched']
    values = [len(matched_knowledge), len(unmatched_knowledge)]
    total = sum(values)
    percentages = [f"{(value / total * 100):.1f}%" for value in values]

    plt.figure(figsize=(6, 4))
    bars = plt.bar(labels, values, color=['green', 'red'])
    plt.xlabel('Knowledge Match Status')
    plt.ylabel('Count')
    plt.title('Knowledge Match Comparison')
    plt.tight_layout()

    # Add percentage labels above bars
    for bar, percentage in zip(bars, percentages):
        plt.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.1, percentage, ha='center', fontsize=10)

    buf = BytesIO()
    plt.savefig(buf, format='png')
    buf.seek(0)
    plt.close()

    return Image.open(buf)

def plot_pie_chart(ranked_knowledge, threshold=50):
    # Filter terms above the threshold
    filtered_terms = [term for term in ranked_knowledge if term["Score"] > threshold]
    matched_terms = sum(1 for term in filtered_terms if term["In Resume"] == "Yes")
    unmatched_terms = len(filtered_terms) - matched_terms

    # Data for pie chart
    labels = ['Matched', 'Unmatched']
    values = [matched_terms, unmatched_terms]

    # Create pie chart
    plt.figure(figsize=(6, 4))
    plt.pie(values, labels=labels, autopct='%1.1f%%', colors=['green', 'red'], startangle=90)
    plt.title(f"Terms Above Threshold (Score > {threshold})")
    buf = BytesIO()
    plt.savefig(buf, format='png')
    buf.seek(0)
    plt.close()
    return Image.open(buf)

def ner_and_compare_with_plot_and_rank(job_posting_text, resume_file):
    """Combined function to process NER, comparison, ranking, and visualization."""
    ner_result = ner(job_posting_text)
    resume_text = extract_pdf(resume_file) if resume_file else ''
    matched_knowledge, unmatched_knowledge = compare_with_resume(ner_result["entities"], resume_file)
    comparison_result = {
        "Matched Knowledge": matched_knowledge,
        "Unmatched Knowledge": unmatched_knowledge,
    }
    bar_plot = plot_comparison(matched_knowledge, unmatched_knowledge)

    # Ranking knowledge entities with "In Resume" column
    ranked_knowledge = rank_knowledge(ner_result["entities"], job_posting_text, resume_text)

    # Generate pie chart for a fixed threshold
    pie_chart = plot_pie_chart(ranked_knowledge, threshold=50)

    # Convert ranked knowledge to a DataFrame for better display
    ranked_df = pd.DataFrame(ranked_knowledge)

    return ner_result, ranked_df, bar_plot, pie_chart


# Gradio interface setup
interface = gr.Interface(
    fn=ner_and_compare_with_plot_and_rank,
    inputs=[
        gr.Textbox(label="Enter Job Posting Text", lines=20, placeholder="Paste job posting text here..."),
        gr.File(label="Upload a PDF of your resume")
    ],
    outputs=[
        "highlight",  # Highlighted job posting text with extracted entities
        gr.DataFrame(label="Ranked Knowledge"),  # Ranked knowledge table
        gr.Image(label="Pie Chart for Terms Above Threshold"),
        gr.Image(label="Comparison Chart"),  # Bar chart visualization       
    ],
    title="Resume vs Job Posting Knowledge Match with Highlights and Rankings",
    description="Upload your resume and enter a job posting. The app will highlight key knowledge from the job posting, check if they are present in your resume, visualize the comparison, and rank knowledge terms based on importance.",
)

# Launch the Gradio app
interface.launch()