Update app.py

app.py

@@ -6,8 +6,6 @@ import docx2txt
 import tempfile
 import time
 import re
-import math
-import concurrent.futures
 import pandas as pd
 from functools import lru_cache
 from transformers import pipeline
@@ -127,58 +125,6 @@ def extract_name(text_start):
 
     return "Unknown (please extract from resume)"
 
-def extract_age(text):
-    """Extract candidate age from resume text"""
-    # Simplified: just check a few common patterns
-    age_patterns = [
-        r'age:?\s*(\d{1,2})',
-        r'(\d{1,2})\s*years\s*old',
-    ]
-    
-    text_lower = text.lower()
-    for pattern in age_patterns:
-        matches = re.search(pattern, text_lower)
-        if matches:
-            return matches.group(1)
-    
-    return "Not specified"
-
-def extract_industry(text, base_summary):
-    """Extract expected job industry from resume"""
-    # Simplified industry keywords focused on the most common ones
-    industry_keywords = {
-        "technology": ["software", "programming", "developer", "IT", "tech", "computer"],
-        "finance": ["banking", "financial", "accounting", "finance", "analyst"],
-        "healthcare": ["medical", "health", "hospital", "clinical", "nurse", "doctor"],
-        "education": ["teaching", "teacher", "professor", "education", "university"],
-        "marketing": ["marketing", "advertising", "digital marketing", "social media"],
-        "engineering": ["engineer", "engineering"],
-        "data science": ["data science", "machine learning", "AI", "analytics"],
-        "information systems": ["information systems", "ERP", "systems management"]
-    }
-    
-    # Count occurrences of industry keywords - using the summary to speed up
-    combined_text = base_summary.lower()
-    
-    counts = {}
-    for industry, keywords in industry_keywords.items():
-        counts[industry] = sum(combined_text.count(keyword.lower()) for keyword in keywords)
-    
-    # Get the industry with the highest count
-    if counts:
-        likely_industry = max(counts.items(), key=lambda x: x[1])
-        if likely_industry[1] > 0:
-            return likely_industry[0].capitalize()
-    
-    # Check for educational background that might indicate industry
-    degrees = ["computer science", "business", "engineering", "medicine", "education", "finance", "marketing"]
-    
-    for degree in degrees:
-        if degree in combined_text:
-            return f"{degree.capitalize()}-related field"
-    
-    return "Not clearly specified"
-
 def extract_skills_and_work(text):
     """Extract both skills and work experience at once to save processing time"""
     # Common skill categories - reduced keyword list for speed
@@ -282,26 +228,26 @@ def summarize_resume_text(resume_text):
     text_to_summarize = resume_text[:min(len(resume_text), max_input_length)]
     base_summary = models['summarizer'](text_to_summarize)[0]['summary_text']
     
-    # Extract information in parallel where possible
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        # These can run in parallel
-        name_future = executor.submit(extract_name, resume_text[:500])  # Only use start of text
-        age_future = executor.submit(extract_age, resume_text)
-        industry_future = executor.submit(extract_industry, resume_text, base_summary)
-        skills_work_future = executor.submit(extract_skills_and_work, resume_text)
-        
-        # Get results
-        name = name_future.result()
-        age = age_future.result()
-        industry = industry_future.result()
-        skills, work_experience = skills_work_future.result()
+    # Extract name from the beginning of the resume
+    name = extract_name(resume_text[:500])
+    
+    # Extract skills and work experience
+    skills, work_experience = extract_skills_and_work(resume_text)
+    
+    # Extract education level - simplified approach
+    education_level = "Not specified"
+    education_terms = ["bachelor", "master", "phd", "doctorate", "mba", "degree"]
+    for term in education_terms:
+        if term in resume_text.lower():
+            education_level = "Higher education degree mentioned"
+            break
     
     # Format the structured summary
-    formatted_summary = f"Name: {name}\n"
-    formatted_summary += f"Age: {age}\n"
-    formatted_summary += f"Expected Job Industry: {industry}\n\n"
+    formatted_summary = f"Name: {name}\n\n"
+    formatted_summary += f"Summary: {base_summary}\n\n"
     formatted_summary += f"Previous Work Experience: {work_experience}\n\n"
-    formatted_summary += f"Skills: {skills}"
+    formatted_summary += f"Skills: {skills}\n\n"
+    formatted_summary += f"Education: {education_level}"
     
     execution_time = time.time() - start_time
     
@@ -312,19 +258,16 @@ def summarize_resume_text(resume_text):
 #####################################
 def extract_job_requirements(job_description):
     """
-    Extract key requirements and skills from a job description
+    Extract key requirements from a job description
     """
-    # Common technical skill categories to look for
-    tech_skill_categories = {
-        "programming_languages": ["Python", "Java", "C++", "JavaScript", "TypeScript", "Go", "Rust", "SQL", "Ruby", "PHP", "Swift", "Kotlin"],
-        "web_technologies": ["React", "Angular", "Vue", "Node.js", "HTML", "CSS", "Django", "Flask", "Spring", "REST API", "GraphQL"],
-        "data_tech": ["Machine Learning", "TensorFlow", "PyTorch", "Data Science", "AI", "Big Data", "Deep Learning", "NLP", "Computer Vision"],
-        "cloud_devops": ["AWS", "Azure", "GCP", "Docker", "Kubernetes", "CI/CD", "Jenkins", "GitHub Actions", "Terraform", "Serverless"],
-        "database": ["SQL", "MySQL", "PostgreSQL", "MongoDB", "Redis", "Elasticsearch", "DynamoDB", "Cassandra"],
-    }
-    
-    # Common soft skills to look for
-    soft_skills = ["Communication", "Leadership", "Teamwork", "Problem-solving", "Critical thinking", "Adaptability", "Creativity", "Time management"]
+    # Common technical skills to look for
+    tech_skills = [
+        "Python", "Java", "C++", "JavaScript", "TypeScript", "Go", "Rust", "SQL", "Ruby", "PHP", "Swift", "Kotlin",
+        "React", "Angular", "Vue", "Node.js", "HTML", "CSS", "Django", "Flask", "Spring", "REST API", "GraphQL",
+        "Machine Learning", "TensorFlow", "PyTorch", "Data Science", "AI", "Big Data", "Deep Learning", "NLP",
+        "AWS", "Azure", "GCP", "Docker", "Kubernetes", "CI/CD", "Jenkins", "GitHub Actions", "Terraform",
+        "MySQL", "PostgreSQL", "MongoDB", "Redis", "Elasticsearch", "DynamoDB", "Cassandra"
+    ]
     
     # Clean the text for processing
     clean_job_text = job_description.lower()
@@ -361,47 +304,18 @@ def extract_job_requirements(job_description):
             except:
                 pass
     
-    # Extract technical skills
-    found_tech_skills = {}
-    all_tech_skills = []
+    # Extract required skills
+    required_skills = [skill for skill in tech_skills if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_job_text)]
     
-    for category, skills in tech_skill_categories.items():
-        category_skills = []
-        for skill in skills:
-            if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_job_text):
-                category_skills.append(skill)
-                all_tech_skills.append(skill)
-        
-        if category_skills:
-            found_tech_skills[category] = category_skills
-    
-    # Extract soft skills
-    found_soft_skills = []
-    for skill in soft_skills:
-        if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_job_text):
-            found_soft_skills.append(skill)
-    
-    # Extract educational requirements
-    edu_patterns = [
-        r"bachelor'?s degree|bs|b\.s\.",
-        r"master'?s degree|ms|m\.s\.",
-        r"phd|ph\.d\.|doctorate", 
-        r"mba|m\.b\.a\."
-    ]
-    
-    education_required = []
-    for pattern in edu_patterns:
-        if re.search(pattern, clean_job_text, re.IGNORECASE):
-            edu_match = re.search(pattern, clean_job_text, re.IGNORECASE).group(0)
-            education_required.append(edu_match.capitalize())
+    # Create a simple summary of the job
+    job_summary = models['summarizer'](job_description[:1024])[0]['summary_text']
     
     # Format the job requirements
     job_requirements = {
         "title": job_title,
         "years_experience": years_required,
-        "technical_skills": all_tech_skills,
-        "soft_skills": found_soft_skills,
-        "education": education_required,
+        "required_skills": required_skills,
+        "summary": job_summary
     }
     
     return job_requirements
@@ -412,94 +326,24 @@ def extract_job_requirements(job_description):
 def analyze_job_fit(resume_summary, job_description):
     """
     Analyze how well the candidate fits the job requirements with the DistilBERT sentiment model.
+    Returns a fit score (0-2) and an assessment.
     """
     start_time = time.time()
     
     # Extract job requirements
     job_requirements = extract_job_requirements(job_description)
     
-    # Define skill categories to evaluate against
+    # Now prepare a comparison text for sentiment analysis
     resume_lower = resume_summary.lower()
-    job_lower = job_description.lower()
-    
-    # Define keyword categories based on the job description
-    # We'll dynamically build these based on the job requirements
-    skill_keywords = {
-        "technical_skills": job_requirements["technical_skills"],
-        "soft_skills": job_requirements["soft_skills"],
-        "education": job_requirements["education"],
-    }
     
-    # Add additional keywords from the job description for comprehensive analysis
-    additional_keywords = {
-        "problem_solving": ["problem solving", "analytical", "critical thinking", "troubleshooting", "debugging", 
-                           "optimization", "solution", "resolve", "analyze"],
-        "domain_knowledge": ["industry", "experience", "expertise", "knowledge", "familiar with", "understanding of"],
-        "collaboration": ["team", "collaborate", "cooperation", "cross-functional", "communication", "stakeholder"]
-    }
+    # Extract skills mentioned in resume
+    skills_in_resume = []
+    for skill in job_requirements["required_skills"]:
+        if skill.lower() in resume_lower:
+            skills_in_resume.append(skill)
     
-    # Merge the keywords
-    skill_keywords.update(additional_keywords)
-    
-    # Category weights with descriptive labels
-    category_weights = {
-        "technical_skills": {"weight": 0.40, "label": "Technical Skills"},
-        "soft_skills": {"weight": 0.15, "label": "Soft Skills"},
-        "education": {"weight": 0.10, "label": "Education"},
-        "problem_solving": {"weight": 0.15, "label": "Problem Solving"},
-        "domain_knowledge": {"weight": 0.10, "label": "Domain Knowledge"},
-        "collaboration": {"weight": 0.10, "label": "Collaboration"}
-    }
-    
-    # Calculate category scores and store detailed information
-    category_scores = {}
-    category_details = {}
-    found_skills = {}
-    
-    for category, keywords in skill_keywords.items():
-        if not keywords:  # Skip empty categories
-            category_scores[category] = 0.0
-            category_details[category] = {
-                "raw_percentage": 0,
-                "adjusted_score": 0,
-                "matching_keywords": [],
-                "total_keywords": 0,
-                "matches": 0
-            }
-            found_skills[category] = []
-            continue
-            
-        # Find the specific matching keywords for feedback
-        category_matches = []
-        for keyword in keywords:
-            if keyword.lower() in resume_lower:
-                category_matches.append(keyword)
-        
-        found_skills[category] = category_matches
-        
-        # Count matches but cap at a reasonable level
-        matches = len(category_matches)
-        total_keywords = len(keywords)
-        
-        # Calculate raw percentage for this category
-        raw_percentage = int((matches / max(1, total_keywords)) * 100)
-        
-        # Apply logarithmic scaling for more realistic scores
-        if matches == 0:
-            adjusted_score = 0.0
-        else:
-            # Logarithmic scaling to prevent perfect scores
-            adjusted_score = min(0.95, (math.log(matches + 1) / math.log(min(total_keywords, 8) + 1)))
-        
-        # Store both raw and adjusted scores for feedback
-        category_scores[category] = adjusted_score
-        category_details[category] = {
-            "raw_percentage": raw_percentage,
-            "adjusted_score": int(adjusted_score * 100),
-            "matching_keywords": category_matches,
-            "total_keywords": total_keywords,
-            "matches": matches
-        }
+    # Count how many required skills are found in the resume
+    skills_match_percentage = int((len(skills_in_resume) / max(1, len(job_requirements["required_skills"]))) * 100)
     
     # Check for years of experience match
     years_required = job_requirements["years_experience"]
@@ -540,96 +384,53 @@ def analyze_job_fit(resume_summary, job_description):
             
             experience_years = total_years
     
-    # Calculate experience match score
-    if years_required > 0:
-        if experience_years >= years_required:
-            exp_score = 1.0
-        else:
-            exp_score = experience_years / years_required
-    else:
-        exp_score = 1.0  # If no specific years required, assume full match
-    
-    category_scores["experience"] = exp_score
-    category_details["experience"] = {
-        "raw_percentage": int(exp_score * 100),
-        "adjusted_score": int(exp_score * 100),
-        "candidate_years": experience_years,
-        "required_years": years_required
-    }
-    
-    # Calculate weighted score
-    weighted_score = 0
-    for category, score in category_scores.items():
-        if category in category_weights:
-            weighted_score += score * category_weights[category]["weight"]
+    # Check experience match
+    experience_match = "sufficient" if experience_years >= years_required else "insufficient"
     
-    # Add experience separately (not in the original weights)
-    weighted_score = (weighted_score * 0.8) + (category_scores["experience"] * 0.2)
-    
-    # Apply final curve to keep scores in a realistic range
-    match_percentage = min(95, max(35, int(weighted_score * 100)))
-    
-    # Prepare input for sentiment analysis
-    # Create a structured summary of the match for sentiment model
-    match_summary = f"""
+    # Prepare a comparison summary for sentiment analysis
+    comparison_text = f"""
     Job title: {job_requirements['title']}
-    Match percentage: {match_percentage}%
     
-    Technical skills match: {category_details['technical_skills']['adjusted_score']}%
-    Required technical skills: {', '.join(job_requirements['technical_skills'][:5])}
-    Candidate has: {', '.join(found_skills['technical_skills'][:5])}
+    Job summary: {job_requirements['summary']}
     
-    Experience match: {category_details['experience']['adjusted_score']}%
-    Required years: {job_requirements['years_experience']}
-    Candidate years: {experience_years}
+    Candidate summary: {resume_summary[:500]}
     
-    Education match: {category_details['education']['adjusted_score']}%
+    Required skills: {', '.join(job_requirements['required_skills'])}
+    Skills in resume: {', '.join(skills_in_resume)}
+    Skills match: {skills_match_percentage}%
     
-    Overall profile match: The candidate's skills and experience appear to {match_percentage >= 70 and "match well with" or "partially match with"} the job requirements.
-    """
+    Required experience: {years_required} years
+    Candidate experience: {experience_years} years
+    Experience match: {experience_match}
     
-    # Use the sentiment model to get a fit classification
-    sentiment_result = models['evaluator'](match_summary)
+    Overall assessment: The candidate's skills and experience {"appear to match well with" if skills_match_percentage >= 60 and experience_match == "sufficient" else "have some gaps compared to"} the job requirements.
+    """
     
-    # Map sentiment analysis to our score:
-    # NEGATIVE = 0 (poor fit)
-    # POSITIVE = 1 (good fit)
-    score_mapping = {
-        "NEGATIVE": 0,
-        "POSITIVE": 1
-    }
+    # Use sentiment analysis model to evaluate the comparison
+    sentiment_result = models['evaluator'](comparison_text)
     
-    # Get the sentiment score
-    sentiment_score = score_mapping.get(sentiment_result[0]['label'], 0)
+    # Map sentiment to score: NEGATIVE = 0, POSITIVE = 1
+    sentiment_score = 1 if sentiment_result[0]['label'] == 'POSITIVE' else 0
     
-    # Adjust the score based on the match percentage to get our 0,1,2 scale
-    if sentiment_score == 1 and match_percentage >= 85:
-        final_score = 2  # Excellent fit
-    elif sentiment_score == 1:
-        final_score = 1  # Good fit
+    # Derive final score based on sentiment and match metrics
+    if sentiment_score == 1 and skills_match_percentage >= 70 and experience_match == "sufficient":
+        final_score = 2  # Good fit
+    elif sentiment_score == 1 and skills_match_percentage >= 50:
+        final_score = 1  # Potential fit
     else:
-        final_score = 0  # Poor fit
-    
-    # Map to fit status
-    fit_status_map = {
-        0: "NOT FIT",
-        1: "POTENTIAL FIT",
-        2: "STRONG FIT"
-    }
+        final_score = 0  # Not fit
     
-    fit_status = fit_status_map[final_score]
-    
-    # Generate assessment summary based on the score
+    # Generate assessment text based on the score
     if final_score == 2:
-        assessment = f"{final_score}: The candidate is a strong match for this {job_requirements['title']} position, with excellent alignment in technical skills and experience. Their background demonstrates the required expertise in key areas such as {', '.join(found_skills['technical_skills'][:3]) if found_skills['technical_skills'] else 'relevant technical domains'}, and they possess the necessary {experience_years} years of experience (required: {years_required})."
+        assessment = f"{final_score}: The candidate is a good match for this {job_requirements['title']} position. They have the required {experience_years} years of experience and demonstrate proficiency in key skills including {', '.join(skills_in_resume[:5])}. Their background aligns well with the job requirements."
     elif final_score == 1:
-        assessment = f"{final_score}: The candidate shows potential for this {job_requirements['title']} position, with some good matches in required skills. They demonstrate experience with {', '.join(found_skills['technical_skills'][:2]) if found_skills['technical_skills'] else 'some relevant technologies'}, but may need development in areas like {', '.join(set(job_requirements['technical_skills']) - set(found_skills['technical_skills']))[:2] if set(job_requirements['technical_skills']) - set(found_skills['technical_skills']) else 'specific technical requirements'}."
+        assessment = f"{final_score}: The candidate shows potential for this {job_requirements['title']} position, but has some skill gaps. They match on {skills_match_percentage}% of required skills including {', '.join(skills_in_resume[:3]) if skills_in_resume else 'minimal required skills'}, and their experience is {experience_match}."
     else:
-        assessment = f"{final_score}: The candidate does not appear to be a strong match for this {job_requirements['title']} position. Their profile shows limited alignment with key requirements, particularly in {', '.join(set(job_requirements['technical_skills']) - set(found_skills['technical_skills']))[:3] if set(job_requirements['technical_skills']) - set(found_skills['technical_skills']) else 'required technical skills'}, and they have {experience_years} years of experience (required: {years_required})."
+        assessment = f"{final_score}: The candidate does not appear to be a good match for this {job_requirements['title']} position. Their profile shows limited alignment with key requirements, matching only {skills_match_percentage}% of required skills, and their experience level is {experience_match}."
     
     execution_time = time.time() - start_time
     
-    return assessment, final_score, match_percentage, category_details, job_requirements, execution_time
+    return assessment, final_score, execution_time
 
 #####################################
 # Main Streamlit Interface
@@ -637,10 +438,7 @@ def analyze_job_fit(resume_summary, job_description):
 st.title("Resume-Job Fit Analyzer")
 st.markdown(
     """
-Upload your resume file in **.docx**, **.doc**, or **.txt** format and enter a job description to see how well you match with the job requirements. The app performs the following tasks:
-1. Extracts text from your resume.
-2. Uses AI to generate a structured candidate summary.
-3. Analyzes how well your profile fits the specific job requirements.
+Upload your resume file in **.docx**, **.doc**, or **.txt** format and enter a job description to see how well you match with the job requirements.
 """
 )
 
@@ -672,11 +470,10 @@ if uploaded_file is not None and job_description and st.button("Analyze Job Fit"
         # Display summary
         st.subheader("Your Resume Summary")
         st.markdown(summary)
-        st.info(f"Summary generated in {summarization_time:.2f} seconds")
         
         # Step 3: Generate job fit assessment
         status_text.text("Step 3/3: Evaluating job fit...")
-        assessment, fit_score, match_percentage, category_details, job_requirements, assessment_time = analyze_job_fit(summary, job_description)
+        assessment, fit_score, assessment_time = analyze_job_fit(summary, job_description)
         progress_bar.progress(100)
 
         # Clear status messages
@@ -689,92 +486,35 @@ if uploaded_file is not None and job_description and st.button("Analyze Job Fit"
         fit_labels = {
             0: "NOT FIT ❌",
             1: "POTENTIAL FIT ⚠️",
-            2: "STRONG FIT ✅"
+            2: "GOOD FIT ✅"
         }
         
         # Show the score prominently
-        st.markdown(f"## Overall Result: {fit_labels[fit_score]}")
-
-        # Display match percentage
-        if match_percentage >= 85:
-            st.success(f"**Match Score:** {match_percentage}% 🌟")
-        elif match_percentage >= 70:
-            st.success(f"**Match Score:** {match_percentage}% ✅")
-        elif match_percentage >= 50:
-            st.warning(f"**Match Score:** {match_percentage}% ⚠️")
-        else:
-            st.error(f"**Match Score:** {match_percentage}% 🔍")
+        st.markdown(f"## {fit_labels[fit_score]}")
 
         # Display assessment
-        st.markdown("### Assessment")
         st.markdown(assessment)
 
-        # Add detailed score breakdown
-        st.markdown("### Score Breakdown")
-
-        # Create a neat table with category scores
-        breakdown_data = []
-        for category, details in category_details.items():
-            if category == "experience":
-                label = "Experience"
-                matching_info = f"{details['candidate_years']} years (Required: {details['required_years']} years)"
-            else:
-                # Get the nice label for the category
-                label = {"technical_skills": "Technical Skills",
-                        "soft_skills": "Soft Skills",
-                        "education": "Education",
-                        "problem_solving": "Problem Solving",
-                        "domain_knowledge": "Domain Knowledge",
-                        "collaboration": "Collaboration"}[category]
-                
-                matching_info = ", ".join(details["matching_keywords"][:3]) if details.get("matching_keywords") else "None detected"
-    
-            # Add formatted breakdown row
-            breakdown_data.append({
-                "Category": label,
-                "Score": f"{details['adjusted_score']}%",
-                "Matching Items": matching_info
-            })
-
-        # Convert to DataFrame and display
-        breakdown_df = pd.DataFrame(breakdown_data)
-        # Remove the index column entirely
-        st.table(breakdown_df.set_index('Category').reset_index())  # This removes the numerical index
-
-        # Show a note about how scores are calculated
-        with st.expander("How are these scores calculated?"):
-            st.markdown("""
-            - **Technical Skills** (40% of total): Evaluates programming languages, software tools, and technical requirements
-            - **Soft Skills** (15% of total): Assesses communication, teamwork, and interpersonal abilities
-            - **Education** (10% of total): Compares educational requirements with candidate's background
-            - **Problem Solving** (15% of total): Measures analytical thinking and approach to challenges
-            - **Domain Knowledge** (10% of total): Evaluates industry-specific experience and knowledge
-            - **Collaboration** (10% of total): Assesses team skills and cross-functional collaboration
-            - **Experience** (20% overall modifier): Years of relevant experience compared to job requirements
-    
-            Scores are calculated based on keyword matches in your resume, with diminishing returns applied (first few skills matter more than later ones).
-            """)
-
-        st.info(f"Assessment completed in {assessment_time:.2f} seconds")
+        st.info(f"Analysis completed in {(summarization_time + assessment_time):.2f} seconds")
         
         # Add potential next steps based on the fit score
         st.subheader("Recommended Next Steps")
         
         if fit_score == 2:
             st.markdown("""
-            - Consider applying for this position as you appear to be a strong match
-            - Prepare for technical interviews by focusing on your strongest skills
-            - Review the job description again to prepare for specific interview questions
+            - Apply for this position as you appear to be a good match
+            - Prepare for interviews by focusing on your relevant experience
+            - Highlight your matching skills in your cover letter
             """)
         elif fit_score == 1:
             st.markdown("""
-            - Focus on highlighting your strongest matching skills in your application
-            - Consider addressing skill gaps in your cover letter by connecting your experience to the requirements
-            - Prepare to discuss how your transferable skills apply to this position
+            - Consider applying but address skill gaps in your cover letter
+            - Emphasize transferable skills and relevant experience
+            - Prepare to discuss how you can quickly develop missing skills
             """)
         else:
             st.markdown("""
-            - This position may not be the best fit for your current skills and experience
-            - Consider roles that better align with your demonstrated strengths
-            - If you're set on this type of position, focus on developing skills in the areas mentioned in the job description
+            - Look for positions better aligned with your current skills
+            - If interested in this field, focus on developing the required skills
+            - Consider similar roles with fewer experience requirements
             """)