app.py

import os
import re
from datetime import datetime
import PyPDF2
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForSeq2SeqLM
from sentence_transformers import SentenceTransformer, util
from groq import Groq
import gradio as gr
from docxtpl import DocxTemplate

# Set your API key for Groq
os.environ["GROQ_API_KEY"] = "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"
client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

# --- PDF/Text Extraction Functions --- #
def extract_text_from_file(file_path):
    """Extracts text from PDF or TXT files based on file extension."""
    if file_path.endswith('.pdf'):
        return extract_text_from_pdf(file_path)
    elif file_path.endswith('.txt'):
        return extract_text_from_txt(file_path)
    else:
        raise ValueError("Unsupported file type. Only PDF and TXT files are accepted.")

def extract_text_from_pdf(pdf_file_path):
    """Extracts text from a PDF file."""
    with open(pdf_file_path, 'rb') as pdf_file:
        pdf_reader = PyPDF2.PdfReader(pdf_file)
        text = ''.join(page.extract_text() for page in pdf_reader.pages if page.extract_text())
    return text

def extract_text_from_txt(txt_file_path):
    """Extracts text from a .txt file."""
    with open(txt_file_path, 'r', encoding='utf-8') as txt_file:
        return txt_file.read()

# --- Skill Extraction with Llama Model --- #
def extract_skills_llama(text):
    """Extracts skills from the text using the Llama model via Groq API."""
    try:
        response = client.chat.completions.create(
            messages=[{"role": "user", "content": f"Extract skills from the following text: {text}"}],
            model="llama3-70b-8192",
        )
        skills = response.choices[0].message.content.split(', ')  # Expecting a comma-separated list
        return skills
    except Exception as e:
        raise RuntimeError(f"Error during skill extraction: {e}")

# --- Qualification and Experience Extraction --- #
def extract_qualifications(text):
    """Extracts qualifications from text (e.g., degrees, certifications)."""
    qualifications = re.findall(r'(bachelor|master|phd|certified|degree)', text, re.IGNORECASE)
    return qualifications if qualifications else ['No specific qualifications found']

def extract_experience(text):
    """Extracts years of experience from the text."""
    experience_years = re.findall(r'(\d+)\s*(years|year) of experience', text, re.IGNORECASE)
    job_titles = re.findall(r'\b(software engineer|developer|manager|analyst)\b', text, re.IGNORECASE)
    experience_years = [int(year[0]) for year in experience_years]
    return experience_years, job_titles

# --- Semantic Similarity Calculation --- #
def calculate_semantic_similarity(text1, text2):
    """Calculates semantic similarity using a sentence transformer model and returns the score as a percentage."""
    model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
    embeddings1 = model.encode(text1, convert_to_tensor=True)
    embeddings2 = model.encode(text2, convert_to_tensor=True)
    similarity_score = util.pytorch_cos_sim(embeddings1, embeddings2).item()
    
    # Convert similarity score to percentage
    similarity_percentage = similarity_score * 100
    return similarity_percentage

# --- Thresholds --- #
def categorize_similarity(score):
    """Categorizes the similarity score into thresholds for better insights."""
    if score >= 80:
        return "High Match"
    elif score >= 50:
        return "Moderate Match"
    else:
        return "Low Match"

# --- Communication Generation with Enhanced Response --- #
def communication_generator(resume_skills, job_description_skills, skills_similarity, qualifications_similarity, experience_similarity, max_length=200):
    """Generates a more detailed communication response based on similarity scores."""
    model_name = "google/flan-t5-base"
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

    # Assess candidate fit based on similarity scores
    fit_status = "strong fit" if skills_similarity >= 80 and qualifications_similarity >= 80 and experience_similarity >= 80 else \
                 "moderate fit" if skills_similarity >= 50 else "weak fit"
    
    # Create a detailed communication message based on match levels
    message = (
        f"After a detailed analysis of the candidate's resume, we found the following insights:\n\n"
        f"- **Skills Match**: {skills_similarity:.2f}% ({categorize_similarity(skills_similarity)})\n"
        f"- **Qualifications Match**: {qualifications_similarity:.2f}% ({categorize_similarity(qualifications_similarity)})\n"
        f"- **Experience Match**: {experience_similarity:.2f}% ({categorize_similarity(experience_similarity)})\n\n"
        f"The overall assessment indicates that the candidate is a {fit_status} for the role. "
        f"Skills such as {', '.join(resume_skills)} align {categorize_similarity(skills_similarity).lower()} with the job's requirements of {', '.join(job_description_skills)}. "
        f"In terms of qualifications and experience, the candidate shows a {categorize_similarity(qualifications_similarity).lower()} match with the role's needs. "
        f"Based on these findings, we believe the candidate could potentially excel in the role, "
        f"but additional evaluation or interviews are recommended for further clarification."
    )

    inputs = tokenizer(message, return_tensors="pt", padding=True, truncation=True)
    response = model.generate(**inputs, max_length=max_length, num_beams=4, early_stopping=True)

    return tokenizer.decode(response[0], skip_special_tokens=True)

# --- Sentiment Analysis --- #
def sentiment_analysis(text):
    """Analyzes the sentiment of the text."""
    model_name = "mrm8488/distiluse-base-multilingual-cased-v2-finetuned-stsb_multi_mt-es"
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSequenceClassification.from_pretrained(model_name)

    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    with torch.no_grad():
        outputs = model(**inputs)
        predicted_sentiment = torch.argmax(outputs.logits).item()
    return ["Negative", "Neutral", "Positive"][predicted_sentiment]

# --- Updated Resume Analysis Function --- #
def analyze_resume(resume_file, job_description_file):
    """Analyzes the resume and job description, returning similarity score, skills, qualifications, and experience matching."""
    # Extract resume and job description text
    try:
        resume_text = extract_text_from_file(resume_file.name)
        job_description_text = extract_text_from_file(job_description_file.name)
    except ValueError as ve:
        return str(ve)

    # Extract skills, qualifications, and experience
    resume_skills = extract_skills_llama(resume_text)
    job_description_skills = process_job_description(job_description_text)
    resume_qualifications = extract_qualifications(resume_text)
    job_description_qualifications = extract_qualifications(job_description_text)
    resume_experience, resume_job_titles = extract_experience(resume_text)
    job_description_experience, job_description_titles = extract_experience(job_description_text)

    # Calculate semantic similarity for different sections in percentages
    skills_similarity = calculate_semantic_similarity(' '.join(resume_skills), ' '.join(job_description_skills))
    qualifications_similarity = calculate_semantic_similarity(' '.join(resume_qualifications), ' '.join(job_description_qualifications))
    experience_similarity = calculate_semantic_similarity(' '.join([str(e) for e in resume_experience]), ' '.join([str(e) for e in job_description_experience]))

    # Generate a communication response based on the similarity percentages
    communication_response = communication_generator(
        resume_skills, job_description_skills, 
        skills_similarity, qualifications_similarity, experience_similarity
    )

    # Perform Sentiment Analysis
    sentiment = sentiment_analysis(resume_text)

    # Return the results including thresholds and percentage scores
    return (
        f"Skills Similarity: {skills_similarity:.2f}% ({categorize_similarity(skills_similarity)})",
        f"Qualifications Similarity: {qualifications_similarity:.2f}% ({categorize_similarity(qualifications_similarity)})",
        f"Experience Similarity: {experience_similarity:.2f}% ({categorize_similarity(experience_similarity)})",
        communication_response,
        f"Sentiment: {sentiment}",
        f"Resume Skills: {', '.join(resume_skills)}",
        f"Job Description Skills: {', '.join(job_description_skills)}",
        f"Resume Qualifications: {', '.join(resume_qualifications)}",
        f"Job Description Qualifications: {', '.join(job_description_qualifications)}",
        f"Resume Experience: {', '.join([f'{y} years' for y, _ in resume_experience])}",
        f"Job Description Experience: {', '.join([f'{y} years' for y, _ in job_description_experience])}"
    )

# --- Gradio Interface --- #
def main():
    """Runs the Gradio application for resume analysis."""
    interface = gr.Interface(
        fn=analyze_resume,
        inputs=[gr.File(label="Upload Resume (PDF/TXT)"), gr.File(label="Upload Job Description (PDF/TXT)")],
        outputs=[
            gr.Textbox(label="Skills Similarity"),
            gr.Textbox(label="Qualifications Similarity"),
            gr.Textbox(label="Experience Similarity"),
            gr.Textbox(label="Communication Response"),
            gr.Textbox(label="Sentiment Analysis"),
            gr.Textbox(label="Resume Skills"),
            gr.Textbox(label="Job Description Skills"),
            gr.Textbox(label="Resume Qualifications"),
            gr.Textbox(label="Job Description Qualifications"),
            gr.Textbox(label="Resume Experience"),
            gr.Textbox(label="Job Description Experience")
        ],
        title="Resume and Job Description Analysis",
        description="Analyze a resume against a job description to evaluate skills, qualifications, experience, and generate communication insights."
    )

    interface.launch()

if __name__ == "__main__":
    main()