Update app.py

app.py

@@ -115,53 +115,19 @@ def extract_text_from_file(file_obj):
 
 # Information extraction functions
 def extract_skills(text):
-    """Extract skills from text - expanded for better matching"""
-    # Expanded skill keywords dictionary
+    """Extract skills from text"""
     skill_keywords = {
-        "Programming": ["Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "React", "Angular", "Vue", 
-                      "PHP", "Ruby", "Swift", "Kotlin", "Go", "TypeScript", "Node.js", "jQuery", "Bootstrap"],
-        "Data Science": ["Machine Learning", "Data Analysis", "Statistics", "TensorFlow", "PyTorch", "AI", "NLP",
-                        "Data Mining", "Big Data", "Data Visualization", "Statistical Analysis", "R", "SPSS", "SAS",
-                        "Regression", "Classification", "Clustering", "Neural Networks", "Deep Learning"],
-        "Database": ["SQL", "MySQL", "MongoDB", "PostgreSQL", "Oracle", "Redis", "DynamoDB", "SQLite", "NoSQL", 
-                    "Database Design", "SQL Server", "Database Administration", "ETL", "Data Warehousing"],
-        "Web Dev": ["React", "Angular", "Node.js", "Frontend", "Backend", "Full-Stack", "REST API", "GraphQL",
-                  "Web Development", "WordPress", "Drupal", "CMS", "SEO", "UI/UX", "Responsive Design", "AJAX"],
-        "Software Dev": ["Agile", "Scrum", "Git", "DevOps", "Docker", "CI/CD", "Jenkins", "Software Development",
-                       "Object-Oriented Programming", "Design Patterns", "Testing", "QA", "Software Architecture",
-                       "Version Control", "JIRA", "Microservices", "Code Review", "Debugging"],
-        "Cloud": ["AWS", "Azure", "Google Cloud", "Lambda", "S3", "EC2", "Cloud Computing", "Serverless", 
-                "Infrastructure as Code", "Cloud Architecture", "Cloud Security", "Kubernetes", "Load Balancing"],
-        "Business": ["Project Management", "Leadership", "Teamwork", "Agile", "Scrum", "Business Analysis",
-                    "Requirements Gathering", "Client Relations", "Communication", "Presentation", "Meeting Facilitation",
-                    "Strategic Planning", "Process Improvement", "Problem Solving", "Decision Making", "Stakeholder Management"]
+        "Programming": ["Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "React", "Angular"],
+        "Data Science": ["Machine Learning", "Data Analysis", "Statistics", "TensorFlow", "PyTorch", "AI", "NLP"],
+        "Database": ["SQL", "MySQL", "MongoDB", "PostgreSQL", "Oracle", "Redis"],
+        "Web Dev": ["React", "Angular", "Node.js", "Frontend", "Backend", "Full-Stack", "REST API"],
+        "Software Dev": ["Agile", "Scrum", "Git", "DevOps", "Docker", "CI/CD", "Jenkins"],
+        "Cloud": ["AWS", "Azure", "Google Cloud", "Lambda", "S3", "EC2"],
+        "Business": ["Project Management", "Leadership", "Teamwork", "Agile", "Scrum"]
     }
     
     text_lower = text.lower()
-    
-    # Method 1: Look for exact matches
-    exact_skills = [skill for _, skills in skill_keywords.items() for skill in skills if skill.lower() in text_lower]
-    
-    # Method 2: Use regex for more flexible matching (accounts for variations)
-    more_skills = []
-    for category, skills in skill_keywords.items():
-        for skill in skills:
-            # This handles cases like "Python developer" or "experienced in Python"
-            if re.search(r'\b' + re.escape(skill.lower()) + r'(?:\s|\b|ing|er|ed)', text_lower):
-                more_skills.append(skill)
-    
-    # Combine both methods and remove duplicates
-    all_skills = list(set(exact_skills + more_skills))
-    
-    # Add soft skill detection
-    soft_skills = ["Communication", "Teamwork", "Problem Solving", "Critical Thinking", 
-                  "Leadership", "Organization", "Time Management", "Flexibility", "Adaptability"]
-    
-    for skill in soft_skills:
-        if skill.lower() in text_lower or re.search(r'\b' + re.escape(skill.lower()) + r'(?:\s|$)', text_lower):
-            all_skills.append(skill)
-    
-    return all_skills
+    return [skill for _, skills in skill_keywords.items() for skill in skills if skill.lower() in text_lower]
 
 @lru_cache(maxsize=32)
 def extract_name(text_start):
@@ -252,19 +218,9 @@ def summarize_resume_text(resume_text, models):
     return summary, time.time() - start
 
 def extract_job_requirements(job_description, models):
-    # Expanded technical skills list for better matching
     tech_skills = [
-        "Python", "Java", "JavaScript", "SQL", "HTML", "CSS", "React", "Angular", "Vue", "Node.js",
-        "Machine Learning", "Data Science", "AI", "Deep Learning", "NLP", "Statistics", "TensorFlow", 
-        "AWS", "Azure", "Google Cloud", "Docker", "Kubernetes", "CI/CD", "DevOps",
-        "MySQL", "MongoDB", "PostgreSQL", "Oracle", "NoSQL", "Database", "Data Analysis",
-        "Project Management", "Agile", "Scrum", "Leadership", "Communication", "Teamwork",
-        "Git", "Software Development", "Full Stack", "Frontend", "Backend", "RESTful API",
-        "Mobile Development", "Android", "iOS", "Swift", "Kotlin", "React Native", "Flutter",
-        "Business Analysis", "Requirements", "UX/UI", "Design", "Product Management",
-        "Testing", "QA", "Security", "Cloud Computing", "Networking", "System Administration",
-        "Linux", "Windows", "Excel", "PowerPoint", "Word", "Microsoft Office",
-        "Problem Solving", "Critical Thinking", "Analytical Skills"
+        "Python", "Java", "JavaScript", "SQL", "HTML", "CSS", "React", "Angular", "Machine Learning", "AWS",
+        "Azure", "Docker", "MySQL", "MongoDB", "Project Management", "Agile", "Leadership", "Git", "DevOps"
     ]
     
     clean_text = job_description.lower()
@@ -308,108 +264,86 @@ def extract_job_requirements(job_description, models):
     }
 
 def evaluate_job_fit(resume_summary, job_requirements, models):
-    start = time.time()
+    """
+    Use a more direct method to evaluate job fit, rather than relying solely on sentiment analysis
+    """
+    start_time = time.time()
     
-    # Basic extraction
+    # Extract basic information for context
     required_skills = job_requirements["required_skills"]
     years_required = job_requirements["years_experience"]
     job_title = job_requirements["title"]
+    job_summary = job_requirements["summary"]
+    
+    # Extract skills from resume
     skills_mentioned = extract_skills(resume_summary)
     
-    # Calculate matches - IMPROVED MATCHING ALGORITHM
+    # Calculate skill match percentage
     matching_skills = [skill for skill in required_skills if skill in skills_mentioned]
+    skill_match_percentage = len(matching_skills) / len(required_skills) if required_skills else 0
     
-    # More balanced skill match calculation:
-    # - If no required skills, default to 0.5 (neutral)
-    # - Otherwise calculate percentage but with diminishing returns
-    if not required_skills:
-        skill_match = 0.5
-    else:
-        raw_match = len(matching_skills) / len(required_skills)
-        # Apply a more gradual scaling to avoid big jumps
-        skill_match = raw_match ** 0.7  # Using power < 1 gives more weight to partial matches
-    
-    # Extract experience
+    # Extract experience level from resume
+    experience_pattern = r'(\d+)\+?\s*years?\s*(?:of)?\s*experience'
+    experience_match = re.search(experience_pattern, resume_summary, re.IGNORECASE)
     years_experience = 0
-    exp_match = re.search(r'(\d+)\+?\s*years?\s*(?:of)?\s*experience', resume_summary, re.IGNORECASE)
-    if exp_match:
-        try: years_experience = int(exp_match.group(1))
-        except: pass
+    if experience_match:
+        try:
+            years_experience = int(experience_match.group(1))
+        except:
+            years_experience = 0
     
-    # Calculate scores with smoother transitions
-    # Experience matching: more balanced, handles the case where job requires no experience
-    if years_required == 0:
-        # If no experience required, having 1+ years is good, 0 is neutral
-        exp_match_ratio = min(1.0, years_experience / 2 + 0.5)
-    else:
-        # For jobs requiring experience, use a more gradual scale
-        exp_match_ratio = min(1.0, (years_experience / max(1, years_required)) ** 0.8)
+    # Experience match
+    exp_match_ratio = min(1.0, years_experience / max(1, years_required)) if years_required > 0 else 0.5
     
-    # Title matching - improved to find partial matches
-    title_words = [w for w in job_title.lower().split() if len(w) > 3]
-    if not title_words:
-        title_match = 0.5  # Neutral if no meaningful title words
-    else:
-        matches = 0
-        for word in title_words:
-            if word in resume_summary.lower():
-                matches += 1
-            # Look for similar words (prefixes) for partial matching
-            elif any(w.startswith(word[:4]) for w in resume_summary.lower().split() if len(w) > 3):
-                matches += 0.5
-        title_match = matches / len(title_words)
-    
-    # Calculate final scores with more reasonable ranges
-    skill_score = skill_match * 2.0  # 0-2 scale
-    exp_score = exp_match_ratio * 2.0  # 0-2 scale
-    title_score = title_match * 2.0  # 0-2 scale
-    
-    # Extract candidate info
-    name = re.search(r'Name:\s*(.*?)(?=\n|\Z)', resume_summary)
-    name = name.group(1).strip() if name else "The candidate"
-    
-    industry = re.search(r'Expected Industry:\s*(.*?)(?=\n|\Z)', resume_summary)
-    industry = industry.group(1).strip() if industry else "unspecified industry"
-    
-    # Calculate weighted score - ADJUSTED WEIGHTS
-    weighted_score = (skill_score * 0.45) + (exp_score * 0.35) + (title_score * 0.20)
-    
-    # IMPROVED THRESHOLDS to get more "Potential Fit" results
-    # Good Fit: 1.25+ (was 1.5)
-    # Potential Fit: 0.6-1.25 (was 0.8-1.5)
-    # No Fit: <0.6 (was <0.8)
-    if weighted_score >= 1.25:
+    # Check job title match
+    job_title_lower = job_title.lower()
+    title_match = 0
+    
+    # Look for job title words in resume
+    title_words = [word for word in job_title_lower.split() if len(word) > 3]
+    title_matches = sum(1 for word in title_words if word in resume_summary.lower())
+    title_match = title_matches / len(title_words) if title_words else 0
+    
+    # Calculate scores for each dimension
+    skill_score = min(2, skill_match_percentage * 3)  # 0-2 scale
+    exp_score = min(2, exp_match_ratio * 2)  # 0-2 scale
+    title_score = min(2, title_match * 2)  # 0-2 scale
+    
+    # Extract name, age, industry from resume summary
+    name_match = re.search(r'Name:\s*(.*?)(?=\n|\Z)', resume_summary)
+    name = name_match.group(1).strip() if name_match else "The candidate"
+    
+    age_match = re.search(r'Age:\s*(.*?)(?=\n|\Z)', resume_summary)
+    age = age_match.group(1).strip() if age_match else "unspecified age"
+    
+    industry_match = re.search(r'Expected Industry:\s*(.*?)(?=\n|\Z)', resume_summary)
+    industry = industry_match.group(1).strip() if industry_match else "unspecified industry"
+    
+    # Calculate weighted final score
+    # Skills: 50%, Experience: 30%, Title match: 20%
+    weighted_score = (skill_score * 0.5) + (exp_score * 0.3) + (title_score * 0.2)
+    
+    # Convert to integer score (0-2)
+    if weighted_score >= 1.5:
         fit_score = 2  # Good fit
-    elif weighted_score >= 0.6:
-        fit_score = 1  # Potential fit - wider range
+    elif weighted_score >= 0.8:
+        fit_score = 1  # Potential fit
     else:
         fit_score = 0  # Not a fit
     
-    # Add logging to help debug the scoring
-    st.session_state['debug_scores'] = {
-        'skill_match': skill_match,
-        'skill_score': skill_score,
-        'exp_match_ratio': exp_match_ratio,
-        'exp_score': exp_score,
-        'title_match': title_match,
-        'title_score': title_score,
-        'weighted_score': weighted_score,
-        'fit_score': fit_score,
-        'matching_skills': matching_skills,
-        'required_skills': required_skills
-    }
-    
-    # Generate assessment
-    missing = [skill for skill in required_skills if skill not in skills_mentioned]
+    # Generate assessment text based on score
+    missing_skills = [skill for skill in required_skills if skill not in skills_mentioned]
     
     if fit_score == 2:
-        assessment = f"{fit_score}: GOOD FIT - {name} demonstrates strong alignment with the {job_title} position. Their background in {industry} appears well-suited for this role's requirements."
+        fit_assessment = f"{fit_score}: GOOD FIT - {name} demonstrates strong alignment with the {job_title} position. Their background in {industry} and professional experience appear well-suited for this role's requirements. The technical expertise matches what the position demands."
     elif fit_score == 1:
-        assessment = f"{fit_score}: POTENTIAL FIT - {name} shows potential for the {job_title} role but has gaps in certain areas. Additional training might be needed in {', '.join(missing[:2])}."
+        fit_assessment = f"{fit_score}: POTENTIAL FIT - {name} shows potential for the {job_title} role with some relevant experience, though there are gaps in certain technical areas. Their {industry} background provides partial alignment with the position requirements. Additional training might be needed in {', '.join(missing_skills[:2])} if pursuing this opportunity."
     else:
-        assessment = f"{fit_score}: NO FIT - {name}'s background shows limited alignment with this {job_title} position. Their experience and skills differ significantly from the requirements."
+        fit_assessment = f"{fit_score}: NO FIT - {name}'s current background shows limited alignment with this {job_title} position. Their experience level and technical background differ significantly from the role requirements. A position better matching their {industry} expertise might be more suitable."
     
-    return assessment, fit_score, time.time() - start
+    execution_time = time.time() - start_time
+    
+    return fit_assessment, fit_score, execution_time
 
 def analyze_job_fit(resume_summary, job_description, models):
     start = time.time()
@@ -421,10 +355,6 @@ def analyze_job_fit(resume_summary, job_description, models):
 # Main Function
 #####################################
 def main():
-    # Initialize session state for debug info
-    if 'debug_scores' not in st.session_state:
-        st.session_state['debug_scores'] = {}
-        
     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.")
 
@@ -487,10 +417,6 @@ def main():
                 - If interested in this field, focus on developing the required skills
                 - Consider similar roles with fewer experience requirements
                 """)
-            
-            # Show debug scores if needed (uncomment this to debug scoring)
-            # st.subheader("Debug Information")
-            # st.json(st.session_state['debug_scores'])
 
 if __name__ == "__main__":
     main()