Update app.py

app.py

@@ -1,28 +1,17 @@
 import os
 import re
+import io
 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
 
-# --- Model Loading with Caching --- #
-class ModelCache:
-    _tokenizers = {}
-    _models = {}
-
-    @classmethod
-    def get_model(cls, model_name):
-        if model_name not in cls._models:
-            cls._models[model_name] = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-        return cls._models[model_name]
-
-    @classmethod
-    def get_tokenizer(cls, model_name):
-        if model_name not in cls._tokenizers:
-            cls._tokenizers[model_name] = AutoTokenizer.from_pretrained(model_name)
-        return cls._tokenizers[model_name]
+# 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):
@@ -35,98 +24,73 @@ def extract_text_from_file(file_path):
         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 logging for page extraction."""
-    text = []
+    """Extracts text from a PDF file."""
     with open(pdf_file_path, 'rb') as pdf_file:
         pdf_reader = PyPDF2.PdfReader(pdf_file)
-        for i, page in enumerate(pdf_reader.pages):
-            page_text = page.extract_text()
-            if page_text:
-                text.append(page_text)
-            else:
-                print(f"Warning: Page {i} could not be extracted.")
-    return ''.join(text)
+        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 Hugging Face --- #
-def extract_skills_huggingface(text):
-    """Extracts skills from the text using a Hugging Face model."""
-    model_name = "google/flan-t5-base"
-    tokenizer = ModelCache.get_tokenizer(model_name)
-    model = ModelCache.get_model(model_name)
-
-    input_text = f"Extract skills from the following text: {text}"
-    inputs = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True)
-    outputs = model.generate(**inputs)
-    skills = tokenizer.decode(outputs[0], skip_special_tokens=True).split(', ')  # Expecting a comma-separated list
-    return skills
-
-# --- Job Description Processing Function --- #
-def process_job_description(text):
-    """Extracts skills or relevant keywords from the job description."""
-    return extract_skills_huggingface(text)
-
-# --- Qualification and Experience Extraction --- #
-def extract_qualifications(text):
-    """Extracts qualifications from text (e.g., degrees, certifications)."""
-    qualifications = re.findall(r'\b(bachelor|master|phd|certified|degree|diploma|qualification|certification)\b', 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"
+# --- 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}")
+
+# --- Job Description Processing --- #
+def process_job_description(job_description_text):
+    """Processes the job description text and extracts relevant skills."""
+    job_description_text = preprocess_text(job_description_text)
+    return extract_skills_llama(job_description_text)
+
+# --- Text Preprocessing --- #
+def preprocess_text(text):
+    """Preprocesses text for analysis (lowercase, punctuation removal)."""
+    text = text.lower()
+    text = re.sub(r'[^\w\s]', '', text)  # Remove punctuation
+    return re.sub(r'\s+', ' ', text).strip()  # Remove extra whitespace
+
+# --- Resume Similarity Calculation --- #
+def calculate_resume_similarity(resume_text, job_description_text):
+    """Calculates similarity score between resume and job description using a sentence transformer model."""
+    model_name = "cross-encoder/stsb-roberta-base"
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(model_name)
+
+    inputs = tokenizer(resume_text, job_description_text, return_tensors="pt", padding=True, truncation=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+        similarity_score = torch.sigmoid(outputs.logits).item()  # Get the raw score
+    return similarity_score
 
-# --- 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."""
+# --- Communication Generation --- #
+def communication_generator(resume_skills, job_description_skills, similarity_score, max_length=150):
+    """Generates a communication response based on the extracted skills from the resume and job description."""
     model_name = "google/flan-t5-base"
-    tokenizer = ModelCache.get_tokenizer(model_name)
-    model = ModelCache.get_model(model_name)
+    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"
+    # Assess candidate fit based on similarity score
+    fit_status = "fit for the job" if similarity_score >= 0.7 else "not a fit for the job"
 
-    # Create a detailed communication message based on match levels
+    # Create a more detailed communication message
     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."
+        f"After a thorough review of the candidate's resume, we found a significant alignment "
+        f"between their skills and the job description requirements. The candidate possesses the following "
+        f"key skills: {', '.join(resume_skills)}. These align well with the job requirements, particularly in areas such as "
+        f"{', '.join(job_description_skills)}. The candidate’s diverse expertise suggests they would make a valuable addition to our team. "
+        f"We believe the candidate is {fit_status}. If further evaluation is needed, please let us know how we can assist."
     )
 
     inputs = tokenizer(message, return_tensors="pt", padding=True, truncation=True)
@@ -136,10 +100,10 @@ def communication_generator(resume_skills, job_description_skills, skills_simila
 
 # --- Sentiment Analysis --- #
 def sentiment_analysis(text):
-    """Analyzes the sentiment of the text using a Hugging Face model."""
-    model_name = "distilbert-base-uncased-finetuned-sst-2-english"
-    tokenizer = ModelCache.get_tokenizer(model_name)
-    model = ModelCache.get_model(model_name)
+    """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():
@@ -147,63 +111,70 @@ def sentiment_analysis(text):
         predicted_sentiment = torch.argmax(outputs.logits).item()
     return ["Negative", "Neutral", "Positive"][predicted_sentiment]
 
-# --- Updated Resume Analysis Function --- #
+# --- 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
+    """Analyzes the resume and job description, returning similarity score, skills, and communication response."""
+    # Extract resume text based on file type
     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_huggingface(resume_text)
+    # Analyze texts
     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
+    resume_skills = extract_skills_llama(resume_text)
+    similarity_score = calculate_resume_similarity(resume_text, job_description_text)
+    communication_response = communication_generator(resume_skills, job_description_skills, similarity_score)
     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)})",
+        f"Similarity Score: {similarity_score * 100:.2f}%",  # Convert to percentage
         communication_response,
-        f"Sentiment Analysis: {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(map(str, resume_experience))} years, Titles: {', '.join(resume_job_titles)}",
-        f"Job Description Experience: {', '.join(map(str, job_description_experience))} years, Titles: {', '.join(job_description_titles)}"
+        f"Sentiment: {sentiment}",
+        ", ".join(resume_skills),
+        ", ".join(job_description_skills),
     )
 
+# --- Offer Letter Generation --- #
+def generate_offer_letter(template_file, candidate_name, role, start_date, hours):
+    """Generates an offer letter from a template."""
+    try:
+        start_date = datetime.strptime(start_date, "%Y-%m-%d").strftime("%B %d, %Y")
+    except ValueError:
+        return "Invalid date format. Please use YYYY-MM-DD."
+
+    context = {
+        'candidate_name': candidate_name,
+        'role': role,
+        'start_date': start_date,
+        'hours': hours
+    }
+
+    doc = DocxTemplate(template_file)
+    doc.render(context)
+
+    offer_letter_path = f"{candidate_name.replace(' ', '_')}_offer_letter.docx"
+    doc.save(offer_letter_path)
+
+    return offer_letter_path
+
 # --- Gradio Interface --- #
 iface = gr.Interface(
     fn=analyze_resume,
-    inputs=["file", "file"],
+    inputs=[
+        gr.File(label="Upload Resume (PDF/TXT)"),
+        gr.File(label="Upload Job Description (PDF/TXT)")
+    ],
     outputs=[
-        "text", "text", "text", "text", "text", "text", "text", "text", "text", "text", "text"
+        gr.Textbox(label="Similarity Score"),
+        gr.Textbox(label="Communication Response"),
+        gr.Textbox(label="Sentiment Analysis"),
+        gr.Textbox(label="Extracted Resume Skills"),
+        gr.Textbox(label="Extracted Job Description Skills"),
     ],
-    title="Resume Analysis Tool",
-    description="Analyze a resume against a job description to evaluate skills, qualifications, experience, and sentiment."
+    title="Resume and Job Description Analyzer",
+    description="This tool analyzes a resume against a job description to extract skills, calculate similarity, and generate communication responses."
 )
 
-if __name__ == "__main__":
-    iface.launch()
+iface.launch()