app.py

'''import io

import os

import re

import tempfile

import traceback

from typing import Tuple, Dict



import fitz  # PyMuPDF

import docx  # python-docx



import numpy as np

from sklearn.metrics.pairwise import cosine_similarity

from sklearn.feature_extraction.text import TfidfVectorizer

import gradio as gr



# --------------------------

# Pre-load all heavy libraries and models at startup.

# --------------------------

print("Starting up: Loading transformer models...")

from sentence_transformers import SentenceTransformer

from transformers import BertTokenizer, BertModel

import torch



# Load models into memory once when the application starts

sentence_transformer = SentenceTransformer("all-MiniLM-L6-v2")

bert_tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

bert_model = BertModel.from_pretrained("bert-base-uncased")

bert_model.eval()

print("Transformer models loaded successfully.")



# --------------------------

# Built-in stopwords

# --------------------------

EN_STOPWORDS = {

    "a", "about", "above", "after", "again", "against", "all", "am", "an", "and", "any", "are", "as",

    "at", "be", "because", "been", "before", "being", "below", "between", "both", "but", "by",

    "could", "did", "do", "does", "doing", "down", "during", "each", "few", "for", "from", "further",

    "had", "has", "have", "having", "he", "her", "here", "hers", "herself", "him", "himself", "his",

    "how", "i", "if", "in", "into", "is", "it", "its", "itself", "just", "me", "more", "most", "my",

    "myself", "no", "nor", "not", "now", "of", "off", "on", "once", "only", "or", "other", "ought", "our",

    "ours", "ourselves", "out", "over", "own", "same", "she", "should", "so", "some", "such", "than",

    "that", "the", "their", "theirs", "them", "themselves", "then", "there", "these", "they", "this",

    "those", "through", "to", "too", "under", "until", "up", "very", "was", "we", "were", "what", "when",

    "where", "which", "while", "who", "whom", "why", "with", "would", "you", "your", "yours", "yourself",

    "yourselves", "resume", "job", "description", "work", "experience", "skill", "skills", "applicant", "application"

}



# --------------------------

# Job Suggestions Database

# --------------------------

JOB_SUGGESTIONS_DB = {

    "Data Scientist": {"python", "sql", "machine", "learning", "tensorflow", "pytorch", "analysis"},

    "Data Analyst": {"sql", "python", "excel", "tableau", "analysis", "statistics"},

    "Backend Developer": {"python", "java", "sql", "docker", "aws", "api", "git"},

    "Frontend Developer": {"react", "javascript", "html", "css", "git", "ui", "ux"},

    "Full-Stack Developer": {"python", "javascript", "react", "sql", "docker", "git"},

    "Machine Learning Engineer": {"python", "tensorflow", "pytorch", "machine", "learning", "docker", "cloud"},

    "Project Manager": {"agile", "scrum", "project", "management", "jira"}

}





# --------------------------

# Utilities: text extraction

# --------------------------

def extract_text_from_pdf_bytes(pdf_bytes: bytes) -> str:

    try:

        doc = fitz.open(stream=pdf_bytes, filetype="pdf")

        pages = [p.get_text("text") for p in doc]

        doc.close()

        return "\n".join(p for p in pages if p)

    except Exception as e:

        return f"[Error reading PDF: {e}]"





def extract_text_from_docx_bytes(docx_bytes: bytes) -> str:

    try:

        docx_io = io.BytesIO(docx_bytes)

        doc = docx.Document(docx_io)

        paragraphs = [p.text for p in doc.paragraphs if p.text]

        return "\n".join(paragraphs)

    except Exception as e:

        return f"[Error reading DOCX: {e}]"





def extract_text_from_fileobj(file_obj) -> Tuple[str, str]:

    fname = "uploaded_file"

    try:

        fname = os.path.basename(file_obj.name)

        with open(file_obj.name, "rb") as f:

            raw_bytes = f.read()

        ext = fname.split('.')[-1].lower()

        if ext == "pdf":

            return (extract_text_from_pdf_bytes(raw_bytes), fname)

        elif ext == "docx":

            return (extract_text_from_docx_bytes(raw_bytes), fname)

        else:

            return (raw_bytes.decode("utf-8", errors="ignore"), fname)

    except Exception as exc:

        return (f"[Error reading uploaded file: {exc}\n{traceback.format_exc()}]", fname)





# --------------------------

# Text preprocessing

# --------------------------

def preprocess_text(text: str, remove_stopwords: bool = True) -> str:

    if not text:

        return ""

    t = text.lower()

    t = re.sub(r"\s+", " ", t)

    t = re.sub(r"[^a-z0-9\s]", " ", t)

    words = t.split()

    if remove_stopwords:

        words = [w for w in words if w not in EN_STOPWORDS]

    return " ".join(words)





# --------------------------

# Embedding helpers

# --------------------------

def get_sentence_embedding(text: str, mode: str = "sbert") -> np.ndarray:

    if mode == "sbert":

        return sentence_transformer.encode([text], show_progress_bar=False)

    elif mode == "bert":

        tokens = bert_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)

        with torch.no_grad():

            out = bert_model(**tokens)

            cls = out.last_hidden_state[:, 0, :].numpy()

        return cls

    else:

        raise ValueError("Unsupported mode")





def calculate_similarity(resume_text: str, job_text: str, mode: str = "sbert") -> float:

    r_emb = get_sentence_embedding(resume_text, mode=mode)

    j_emb = get_sentence_embedding(job_text, mode=mode)

    sim = cosine_similarity(r_emb, j_emb)[0][0]

    return float(np.round(sim * 100, 2))





# --------------------------

# Keyword analysis

# --------------------------

DEFAULT_KEYWORDS = {

    "skills": {"python", "nlp", "java", "sql", "tensorflow", "pytorch", "docker", "git", "react", "cloud", "aws",

               "azure"},

    "concepts": {"machine", "learning", "data", "analysis", "nlp", "vision", "agile", "scrum"},

    "roles": {"software", "engineer", "developer", "manager", "scientist", "analyst", "architect"},

}





def analyze_resume_keywords(resume_text: str, job_description: str):

    clean_resume = preprocess_text(resume_text)

    clean_job = preprocess_text(job_description)

    resume_words = set(clean_resume.split())

    job_words = set(clean_job.split())

    missing = {}

    for cat, kws in DEFAULT_KEYWORDS.items():

        missing_from_cat = [kw for kw in kws if kw in job_words and kw not in resume_words]

        if missing_from_cat:

            missing[cat] = sorted(missing_from_cat)

    low_resume = (resume_text or "").lower()

    sections_present = {

        "skills": "skills" in low_resume,

        "experience": "experience" in low_resume or "employment" in low_resume,

        "summary": "summary" in low_resume or "objective" in low_resume,

    }

    suggestions = []

    if any(missing.values()):

        for cat, kws in missing.items():

            for kw in kws:

                if cat == "skills":

                    suggestions.append(f"Add keyword '{kw}' to your Skills section." if sections_present[

                        "skills"] else f"Consider creating a Skills section to include '{kw}'.")

                elif cat == "concepts":

                    suggestions.append(

                        f"Try to demonstrate your knowledge of '{kw}' in your Experience or Projects section.")

                elif cat == "roles":

                    suggestions.append(f"Align your Summary/Objective to mention the title '{kw}'.")

    else:

        suggestions.append("Great job! Your resume contains many of the keywords found in the job description.")

    return missing, "\n".join(f"- {s}" for s in suggestions)





# --------------------------

# Project Section Analysis

# --------------------------

def extract_projects_section(resume_text: str) -> str:

    project_headings = ["projects", "personal projects", "academic projects", "portfolio"]

    end_headings = [

        "skills", "technical skills", "experience", "work experience",

        "education", "awards", "certifications", "languages", "references"

    ]

    lines = resume_text.split('\n')

    start_index = -1

    end_index = len(lines)

    for i, line in enumerate(lines):

        cleaned_line = line.strip().lower()

        if cleaned_line in project_headings:

            start_index = i

            break

    if start_index == -1:

        return "Could not automatically identify a 'Projects' section in this resume."

    for i in range(start_index + 1, len(lines)):

        cleaned_line = line.strip().lower()

        if len(cleaned_line.split()) < 4 and cleaned_line in end_headings:

            end_index = i

            break

    project_section_lines = lines[start_index:end_index]

    return "\n".join(project_section_lines)





def analyze_projects_fit(projects_text: str, job_description_text: str, mode: str) -> str:

    if projects_text.startswith("Could not"):

        return "Cannot analyze project fit as no projects section was found."



    cleaned_projects = preprocess_text(projects_text)

    cleaned_job = preprocess_text(job_description_text)



    if not cleaned_projects:

        return "Projects section is empty or contains no relevant text to analyze."



    project_fit_score = calculate_similarity(cleaned_projects, cleaned_job, mode=mode)



    if project_fit_score >= 75:

        verdict = f"<p style='color:green;'>✅ **Highly Relevant ({project_fit_score:.2f}%):** The projects listed are an excellent match for this job's requirements.</p>"

    elif project_fit_score >= 50:

        verdict = f"<p style='color:limegreen;'>👍 **Relevant ({project_fit_score:.2f}%):** The projects show relevant skills and experience for this role.</p>"

    else:

        verdict = f"<p style='color:orange;'>⚠️ **Moderately Relevant ({project_fit_score:.2f}%):** The projects may not directly align with the key requirements. Consider highlighting different aspects of your work.</p>"



    return verdict





# --------------------------

# Formatting and Suggestion Functions

# --------------------------

def format_missing_keywords(missing: Dict) -> str:

    if not any(missing.values()):

        return "✅ No critical keywords seem to be missing. Great job!"

    output = "### 🔑 Keywords Missing From Your Resume\n"

    for category, keywords in missing.items():

        if keywords:

            output += f"**Missing {category.capitalize()}:** {', '.join(keywords)}\n"

    return output





def suggest_jobs(resume_text: str) -> str:

    resume_words = set(preprocess_text(resume_text).split())

    suggestions = []

    for job_title, required_skills in JOB_SUGGESTIONS_DB.items():

        matched_skills = resume_words.intersection(required_skills)

        if len(matched_skills) >= 3:

            suggestions.append(job_title)

    if not suggestions:

        return "Could not determine strong job matches from the resume. Try adding more specific skills and technologies."

    output = "### 🚀 Job Titles You May Be a Good Fit For\n"

    for job in suggestions:

        output += f"- {job}\n"

    return output





def extract_top_keywords(text: str, top_n: int = 15) -> str:

    if not text.strip():

        return "Not enough text provided."

    try:

        vectorizer = TfidfVectorizer(stop_words=list(EN_STOPWORDS))

        tfidf_matrix = vectorizer.fit_transform([text])

        feature_names = np.array(vectorizer.get_feature_names_out())

        scores = tfidf_matrix.toarray().flatten()

        top_indices = scores.argsort()[-top_n:][::-1]

        top_keywords = feature_names[top_indices]

        return ", ".join(top_keywords)

    except ValueError:

        return "Could not extract keywords (text may be too short)."





# --------------------------

# Main Gradio app logic

# --------------------------

def analyze_resumes(files, job_description: str, mode: str):

    if not files or not job_description.strip():

        return 0.0, "Please upload resumes and paste a job description.", "", "", "", "", "", "", "", ""



    results = []

    for file in files:

        try:

            resume_text, fname = extract_text_from_fileobj(file)

            if resume_text.strip().startswith("[Error"):

                continue  # Skip errored files

            cleaned_resume = preprocess_text(resume_text)

            cleaned_job = preprocess_text(job_description)

            sim_pct = calculate_similarity(cleaned_resume, cleaned_job, mode=mode)

            results.append((sim_pct, resume_text, fname))

        except Exception:

            continue  # Skip if any error



    if not results:

        return 0.0, "No valid resumes were provided.", "", "", "", "", "", "", "", ""



    # Select the best matching resume

    best = max(results, key=lambda x: x[0])  # highest similarity

    sim_pct, resume_text, fname = best



    missing_dict, suggestions_text = analyze_resume_keywords(resume_text, job_description)

    missing_formatted = format_missing_keywords(missing_dict)

    job_suggestions = suggest_jobs(resume_text)

    projects_section = extract_projects_section(resume_text)

    project_fit_verdict = analyze_projects_fit(projects_section, job_description, mode)

    resume_keywords_text = extract_top_keywords(preprocess_text(resume_text))

    jd_keywords_text = extract_top_keywords(preprocess_text(job_description))



    verdict = f"<h3 style='color:green;'>✅ Best Match: {fname} ({sim_pct:.2f}%)</h3>" if sim_pct >= 80 else \

        f"<h3 style='color:limegreen;'>👍 Best Match: {fname} ({sim_pct:.2f}%)</h3>" if sim_pct >= 60 else \

        f"<h3 style='color:orange;'>⚠️ Best Match: {fname} ({sim_pct:.2f}%)</h3>" if sim_pct >= 40 else \

        f"<h3 style='color:red;'>❌ Low Match: {fname} ({sim_pct:.2f}%)</h3>"



    return (

        float(sim_pct), verdict, missing_formatted, suggestions_text,

        job_suggestions, projects_section, project_fit_verdict, resume_keywords_text, jd_keywords_text, fname

    )





# --------------------------

# Clear Button Logic

# --------------------------

def clear_inputs():

    return None, "", "sbert", None, None, None, None, None, None, None, None





# --------------------------

# Build Gradio UI

# --------------------------

def build_ui():

    with gr.Blocks(theme=gr.themes.Default(), title="Resume ↔ Job Matcher") as demo:

        gr.Markdown("# 📄 Resume & Job Description Analyzer 🎯")

        gr.Markdown(

            "Upload a resume, paste a job description, and get an instant analysis, keyword suggestions, and potential job matches.")



        with gr.Row():

            with gr.Column(scale=2):

                file_in = gr.File(label="Upload resumes (PDF or DOCX)", file_count="multiple",

                  file_types=[".pdf", ".docx"])

                job_desc = gr.Textbox(lines=10, label="Job Description",

                                      placeholder="Paste the full job description here...")

                mode = gr.Radio(choices=["sbert", "bert"], value="sbert", label="Analysis Mode",

                                info="SBERT is faster, BERT is more detailed.")

                with gr.Row():

                    clear_btn = gr.Button("Clear")

                    run_btn = gr.Button("Analyze Resume", variant="primary")



            with gr.Column(scale=3):

                with gr.Tabs():

                    with gr.TabItem("📊 Analysis & Suggestions"):

                        score_slider = gr.Slider(value=0, minimum=0, maximum=100, step=0.01, interactive=False,

                                                 label="Similarity Score")

                        score_text = gr.Markdown()

                        suggestions_out = gr.Textbox(label="Suggestions to Improve Your Resume", interactive=False,

                                                     lines=5)

                        missing_out = gr.Markdown(label="Keywords Check")



                    with gr.TabItem("🛠️ Project Analysis"):

                        project_fit_out = gr.Markdown(label="Project Fit Verdict")

                        projects_out = gr.Textbox(label="Extracted Projects Section", interactive=False, lines=12)



                    with gr.TabItem("🚀 Job Suggestions"):

                        job_suggestions_out = gr.Markdown(label="Potential Job Roles")



                    with gr.TabItem("🔑 Top Keywords"):

                        resume_keywords_out = gr.Textbox(label="Top Resume Keywords")

                        jd_keywords_out = gr.Textbox(label="Top Job Description Keywords")



        run_btn.click(

            analyze_resumes,

            inputs=[file_in, job_desc, mode],

            outputs=[score_slider, score_text, missing_out, suggestions_out, job_suggestions_out, projects_out,

                    project_fit_out, resume_keywords_out, jd_keywords_out, gr.Textbox(label="Best Match Filename")],

            show_progress='full'

        )



        clear_btn.click(

            clear_inputs,

            inputs=[],

            outputs=[file_in, job_desc, mode, score_slider, score_text, missing_out, suggestions_out,

                     job_suggestions_out, projects_out, project_fit_out, resume_keywords_out, jd_keywords_out]

        )



    return demo





if __name__ == "__main__":

    demo = build_ui()

    demo.launch()

    #demo.launch(server_name="0.0.0.0")'''

# app.py
import gradio as gr

from local_model import (
    extract_text_from_fileobj,
    preprocess_text,
    calculate_similarity,          # local (sbert/bert)
    analyze_resume_keywords,
    format_missing_keywords,
    suggest_jobs,
    extract_projects_section,
    extract_top_keywords,
)
from api_model import calculate_similarity_api, check_api_health  # API mode (HF Inference)

def _verdict_html(fname: str, sim_pct: float) -> str:
    if sim_pct >= 80:
        return f"<h3 style='color:green;'>✅ Best Match: {fname} ({sim_pct:.2f}%)</h3>"
    if sim_pct >= 60:
        return f"<h3 style='color:limegreen;'>👍 Best Match: {fname} ({sim_pct:.2f}%)</h3>"
    if sim_pct >= 40:
        return f"<h3 style='color:orange;'>⚠️ Best Match: {fname} ({sim_pct:.2f}%)</h3>"
    return f"<h3 style='color:red;'>❌ Low Match: {fname} ({sim_pct:.2f}%)</h3>"

def _project_fit_verdict_from_score(score: float) -> str:
    if score >= 75:
        return (f"<p style='color:green;'>✅ <b>Highly Relevant ({score:.2f}%)</b>: "
                f"The projects listed are an excellent match for this job's requirements.</p>")
    if score >= 50:
        return (f"<p style='color:limegreen;'>👍 <b>Relevant ({score:.2f}%)</b>: "
                f"The projects show relevant skills and experience for this role.</p>")
    return (f"<p style='color:orange;'>⚠️ <b>Moderately Relevant ({score:.2f}%)</b>: "
            f"The projects may not directly align with the key requirements. "
            f"Consider highlighting different aspects of your work.</p>")

def analyze_resumes(files, job_description: str, mode: str):
    if not files or not job_description.strip():
        return 0.0, "Please upload resumes and paste a job description.", "", "", "", "", "", "", "", ""

    # Fast fail if API mode is selected but HF token/model is not ready
    if mode == "api":
        ok, msg = check_api_health()
        if not ok:
            return (0.0,
                    f"<p style='color:red;'>HF Inference API error: {msg}</p>",
                    "", "", "", "", "", "", "", "")

    results = []
    first_error = None

    for file in files:
        try:
            resume_text, fname = extract_text_from_fileobj(file)
            if resume_text.strip().startswith("[Error"):
                # file read failure — skip file but note error
                first_error = first_error or resume_text
                continue

            cleaned_resume = preprocess_text(resume_text)
            cleaned_job    = preprocess_text(job_description)

            if mode == "api":
                sim_pct = calculate_similarity_api(cleaned_resume, cleaned_job)
            else:
                sim_pct = calculate_similarity(cleaned_resume, cleaned_job, mode=mode)

            results.append((sim_pct, resume_text, fname))

        except Exception as e:
            # Capture first embedding/API error so the user gets a useful message
            if first_error is None:
                first_error = f"{type(e).__name__}: {e}"
            continue

    if not results:
        # If everything failed, surface the first error instead of a vague message
        msg = first_error or "No valid resumes were provided."
        return (0.0,
                f"<p style='color:red;'>Analysis failed: {msg}</p>",
                "", "", "", "", "", "", "", "")

    # Best match
    best = max(results, key=lambda x: x[0])
    sim_pct, resume_text, fname = best

    missing_dict, suggestions_text = analyze_resume_keywords(resume_text, job_description)
    missing_formatted = format_missing_keywords(missing_dict)
    job_suggestions = suggest_jobs(resume_text)
    projects_section = extract_projects_section(resume_text)

    # Project fit
    if projects_section.startswith("Could not"):
        project_fit_verdict = "Cannot analyze project fit as no projects section was found."
    else:
        cleaned_projects = preprocess_text(projects_section)
        cleaned_job      = preprocess_text(job_description)
        if cleaned_projects:
            try:
                if mode == "api":
                    pscore = calculate_similarity_api(cleaned_projects, cleaned_job)
                else:
                    pscore = calculate_similarity(cleaned_projects, cleaned_job, mode=mode)
                project_fit_verdict = _project_fit_verdict_from_score(pscore)
            except Exception as e:
                project_fit_verdict = f"Could not compute project fit (embedding error: {type(e).__name__}: {e})."
        else:
            project_fit_verdict = "Projects section is empty or contains no relevant text to analyze."

    resume_keywords_text = extract_top_keywords(preprocess_text(resume_text))
    jd_keywords_text     = extract_top_keywords(preprocess_text(job_description))
    verdict = _verdict_html(fname, sim_pct)

    return (
        float(sim_pct), verdict, missing_formatted, suggestions_text,
        job_suggestions, projects_section, project_fit_verdict, resume_keywords_text, jd_keywords_text, fname
    )

def clear_inputs():
    # MUST return one value per output we wire in clear_btn.click
    # outputs: file_in, job_desc, mode, score_slider, score_text, missing_out, suggestions_out,
    #          job_suggestions_out, projects_out, project_fit_out, resume_keywords_out, jd_keywords_out, best_fname_out
    return (None, "", "sbert", 0.0, "", "", "", "", "", "", "", "", "")

def build_ui():
    with gr.Blocks(theme=gr.themes.Default(), title="Resume ↔ Job Matcher") as demo:
        gr.Markdown("# 📄 Resume & Job Description Analyzer 🎯")
        gr.Markdown(
            "Upload a resume, paste a job description, and get an instant analysis, keyword suggestions, and potential job matches."
        )

        with gr.Row():
            with gr.Column(scale=2):
                file_in = gr.File(
                    label="Upload resumes (PDF or DOCX)",
                    file_count="multiple",
                    file_types=[".pdf", ".docx"]
                )
                job_desc = gr.Textbox(
                    lines=10, label="Job Description",
                    placeholder="Paste the full job description here..."
                )
                mode = gr.Radio(
                    choices=["sbert", "bert", "api"],
                    value="sbert",
                    label="Analysis Mode",
                    info="SBERT/BERT use local models; API uses Hugging Face Inference API."
                )
                with gr.Row():
                    clear_btn = gr.Button("Clear")
                    run_btn = gr.Button("Analyze Resume", variant="primary")

            with gr.Column(scale=3):
                with gr.Tabs():
                    with gr.TabItem("📊 Analysis & Suggestions"):
                        score_slider = gr.Slider(value=0, minimum=0, maximum=100, step=0.01,
                                                 interactive=False, label="Similarity Score")
                        score_text = gr.Markdown()
                        suggestions_out = gr.Textbox(label="Suggestions to Improve Your Resume",
                                                     interactive=False, lines=5)
                        missing_out = gr.Markdown(label="Keywords Check")

                    with gr.TabItem("🛠️ Project Analysis"):
                        project_fit_out = gr.Markdown(label="Project Fit Verdict")
                        projects_out = gr.Textbox(label="Extracted Projects Section", interactive=False, lines=12)

                    with gr.TabItem("🚀 Job Suggestions"):
                        job_suggestions_out = gr.Markdown(label="Potential Job Roles")

                    with gr.TabItem("🔑 Top Keywords"):
                        resume_keywords_out = gr.Textbox(label="Top Resume Keywords")
                        jd_keywords_out = gr.Textbox(label="Top Job Description Keywords")

                best_fname_out = gr.Textbox(label="Best Match Filename", interactive=False)

        run_btn.click(
            analyze_resumes,
            inputs=[file_in, job_desc, mode],
            outputs=[  # 10 outputs
                score_slider, score_text, missing_out, suggestions_out, job_suggestions_out,
                projects_out, project_fit_out, resume_keywords_out, jd_keywords_out, best_fname_out
            ],
            show_progress='full'
        )

        clear_btn.click(
            clear_inputs,
            inputs=[],
            outputs=[  # 13 outputs; keep in sync with clear_inputs()
                file_in, job_desc, mode, score_slider, score_text, missing_out, suggestions_out,
                job_suggestions_out, projects_out, project_fit_out, resume_keywords_out, jd_keywords_out, best_fname_out
            ]
        )

    return demo

if __name__ == "__main__":
    demo = build_ui()
    demo.launch()
    # demo.launch(server_name="0.0.0.0")