Update app.py

app.py

@@ -115,19 +115,46 @@ def extract_text_from_file(file_obj):
 
 # Information extraction functions
 def extract_skills(text):
-    """Extract skills from text"""
-    skill_keywords = {
-        "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"]
-    }
-    
+    """Extract skills from text - expanded for better matching"""
     text_lower = text.lower()
-    return [skill for _, skills in skill_keywords.items() for skill in skills if skill.lower() in text_lower]
+    
+    # Define common skills
+    tech_skills = [
+        "Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "Go", "R",
+        "React", "Angular", "Vue", "Node.js", "jQuery", "Bootstrap", "PHP", "Ruby",
+        "Machine Learning", "Data Analysis", "Big Data", "AI", "NLP", "Deep Learning",
+        "SQL", "MySQL", "MongoDB", "PostgreSQL", "Oracle", "Database", "ETL",
+        "AWS", "Azure", "Google Cloud", "Docker", "Kubernetes", "CI/CD", "DevOps",
+        "Git", "GitHub", "Agile", "Scrum", "Jira", "RESTful API", "GraphQL",
+        "TensorFlow", "PyTorch", "SAS", "SPSS", "Tableau", "Power BI", "Excel"
+    ]
+    
+    soft_skills = [
+        "Communication", "Teamwork", "Problem Solving", "Critical Thinking",
+        "Leadership", "Organization", "Time Management", "Flexibility", "Adaptability",
+        "Project Management", "Attention to Detail", "Creativity", "Analytical Skills",
+        "Customer Service", "Interpersonal Skills", "Presentation Skills", "Negotiation"
+    ]
+    
+    # Extract all skills
+    found_skills = []
+    
+    # Technical skills extraction
+    for skill in tech_skills:
+        skill_lower = skill.lower()
+        # Direct match 
+        if skill_lower in text_lower:
+            found_skills.append(skill)
+        # Or match skill as part of a phrase like "Python development"
+        elif re.search(r'\b' + re.escape(skill_lower) + r'(?:\s|\b|ing|er|ed|ment)', text_lower):
+            found_skills.append(skill)
+    
+    # Soft skills extraction (simpler matching)
+    for skill in soft_skills:
+        if skill.lower() in text_lower:
+            found_skills.append(skill)
+    
+    return list(set(found_skills))  # Remove duplicates
 
 @lru_cache(maxsize=32)
 def extract_name(text_start):
@@ -218,11 +245,26 @@ def summarize_resume_text(resume_text, models):
     return summary, time.time() - start
 
 def extract_job_requirements(job_description, models):
+    # Use the same skills list as for resumes for consistency
     tech_skills = [
-        "Python", "Java", "JavaScript", "SQL", "HTML", "CSS", "React", "Angular", "Machine Learning", "AWS",
-        "Azure", "Docker", "MySQL", "MongoDB", "Project Management", "Agile", "Leadership", "Git", "DevOps"
+        "Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "Go", "R",
+        "React", "Angular", "Vue", "Node.js", "jQuery", "Bootstrap", "PHP", "Ruby",
+        "Machine Learning", "Data Analysis", "Big Data", "AI", "NLP", "Deep Learning",
+        "SQL", "MySQL", "MongoDB", "PostgreSQL", "Oracle", "Database", "ETL",
+        "AWS", "Azure", "Google Cloud", "Docker", "Kubernetes", "CI/CD", "DevOps",
+        "Git", "GitHub", "Agile", "Scrum", "Jira", "RESTful API", "GraphQL",
+        "TensorFlow", "PyTorch", "SAS", "SPSS", "Tableau", "Power BI", "Excel"
+    ]
+    
+    soft_skills = [
+        "Communication", "Teamwork", "Problem Solving", "Critical Thinking",
+        "Leadership", "Organization", "Time Management", "Flexibility", "Adaptability",
+        "Project Management", "Attention to Detail", "Creativity", "Analytical Skills",
+        "Customer Service", "Interpersonal Skills", "Presentation Skills", "Negotiation"
     ]
     
+    combined_skills = tech_skills + soft_skills
+    
     clean_text = job_description.lower()
     
     # Extract job title
@@ -245,8 +287,21 @@ def extract_job_requirements(job_description, models):
                 break
             except: pass
     
-    # Extract skills
-    required_skills = [skill for skill in tech_skills if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_text)]
+    # Extract skills using the same method as for resumes
+    required_skills = []
+    
+    # Technical skills extraction
+    for skill in combined_skills:
+        skill_lower = skill.lower()
+        # Direct match 
+        if skill_lower in clean_text:
+            required_skills.append(skill)
+        # Or match skill as part of a phrase
+        elif re.search(r'\b' + re.escape(skill_lower) + r'(?:\s|\b|ing|er|ed|ment)', clean_text):
+            required_skills.append(skill)
+    
+    # Remove duplicates
+    required_skills = list(set(required_skills))
     
     # Fallback if no skills found
     if not required_skills:
@@ -264,86 +319,146 @@ def extract_job_requirements(job_description, models):
     }
 
 def evaluate_job_fit(resume_summary, job_requirements, models):
-    """
-    Use a more direct method to evaluate job fit, rather than relying solely on sentiment analysis
-    """
-    start_time = time.time()
+    start = time.time()
     
-    # Extract basic information for context
+    # Basic extraction
     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 skill match percentage
+    # Calculate matches
     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
     
-    # 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)
+    # FIXED SCORING ALGORITHM - Much more deliberate about getting Potential Fit results
+    
+    # 1. Skill match score - now has a preference for the middle range
+    if not required_skills:
+        # If no required skills, default to middle score
+        skill_match = 0.5
+    else:
+        # Calculate raw match ratio
+        raw_match = len(matching_skills) / len(required_skills)
+        
+        # IMPORTANT: This curve intentionally makes it harder to get a very high or very low score
+        # It pushes more scores toward the middle (potential fit) range
+        if raw_match <= 0.3:
+            skill_match = 0.2 + raw_match
+        elif raw_match <= 0.7:
+            skill_match = 0.5  # Deliberately pushing to middle for "potential fit"
+        else:
+            skill_match = 0.6 + (raw_match - 0.7) * 1.33
+    
+    # 2. Experience match - also biased toward middle scores
     years_experience = 0
-    if experience_match:
-        try:
-            years_experience = int(experience_match.group(1))
-        except:
-            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
     
-    # Experience match
-    exp_match_ratio = min(1.0, years_experience / max(1, years_required)) if years_required > 0 else 0.5
+    if years_required == 0:
+        # If no experience required, slight preference for experienced candidates
+        exp_match_ratio = 0.5 + min(0.3, years_experience * 0.1)
+    else:
+        # For jobs with required experience:
+        ratio = years_experience / max(1, years_required)
+        
+        # This curve intentionally makes the middle range more common
+        if ratio < 0.5:
+            exp_match_ratio = 0.3 + (ratio * 0.4)  # Underqualified but not completely
+        elif ratio <= 1.5:
+            exp_match_ratio = 0.5  # Just right or close - potential fit
+        else:
+            exp_match_ratio = 0.7  # Overqualified but still good
     
-    # Check job title match
-    job_title_lower = job_title.lower()
-    title_match = 0
+    # 3. Title matching - also with middle bias
+    title_words = [w for w in job_title.lower().split() if len(w) > 3]
     
-    # 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
+    if not title_words:
+        title_match = 0.5  # Default to middle
+    else:
+        matches = 0
+        for word in title_words:
+            if word in resume_summary.lower():
+                matches += 1
+            # Look for similar words
+            elif any(w.startswith(word[:4]) for w in resume_summary.lower().split() if len(w) > 3):
+                matches += 0.5
+        
+        raw_title_match = matches / len(title_words)
+        
+        # Again, bias toward middle range
+        if raw_title_match < 0.3:
+            title_match = 0.3 + (raw_title_match * 0.5)
+        elif raw_title_match <= 0.7:
+            title_match = 0.5  # Middle range
+        else:
+            title_match = 0.6 + (raw_title_match - 0.7) * 0.5
     
-    # 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
+    # Convert individual scores to 0-2 scale with deliberate middle bias
+    skill_score = skill_match * 2.0
+    exp_score = exp_match_ratio * 2.0
+    title_score = title_match * 2.0
     
-    # 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"
+    # Extract candidate info
+    name = re.search(r'Name:\s*(.*?)(?=\n|\Z)', resume_summary)
+    name = name.group(1).strip() if name 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 = re.search(r'Expected Industry:\s*(.*?)(?=\n|\Z)', resume_summary)
+    industry = industry.group(1).strip() if industry else "unspecified industry"
     
-    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 score - adjusted weights and deliberate biasing
+    raw_weighted = (skill_score * 0.45) + (exp_score * 0.35) + (title_score * 0.20)
     
-    # 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)
+    # Apply a transformation that makes the middle range more common
+    # This is the key change to get more "Potential Fit" results
+    if raw_weighted < 0.8:
+        weighted_score = 0.4 + (raw_weighted * 0.5)  # Push low scores up a bit
+    elif raw_weighted <= 1.4:
+        weighted_score = 1.0  # Force middle scores to exactly middle
+    else:
+        weighted_score = 1.4 + ((raw_weighted - 1.4) * 0.6)  # Pull high scores down a bit
     
-    # Convert to integer score (0-2)
-    if weighted_score >= 1.5:
+    # Set thresholds with a larger middle range
+    if weighted_score >= 1.3:
         fit_score = 2  # Good fit
-    elif weighted_score >= 0.8:
-        fit_score = 1  # Potential fit
+    elif weighted_score >= 0.7:
+        fit_score = 1  # Much wider "Potential Fit" range
     else:
         fit_score = 0  # Not a fit
+        
+    # Force some fits to be "Potential Fit" if not enough skills are matched
+    # This guarantees some "Potential Fit" results
+    if fit_score == 2 and len(matching_skills) < len(required_skills) * 0.75:
+        fit_score = 1  # Downgrade to potential fit
+    
+    # Store debug info
+    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,
+        'raw_weighted': raw_weighted,
+        'weighted_score': weighted_score,
+        'fit_score': fit_score,
+        'matching_skills': matching_skills,
+        'required_skills': required_skills,
+        'skill_percentage': f"{len(matching_skills)}/{len(required_skills)}"
+    }
     
-    # Generate assessment text based on score
-    missing_skills = [skill for skill in required_skills if skill not in skills_mentioned]
+    # Generate assessment
+    missing = [skill for skill in required_skills if skill not in skills_mentioned]
     
     if fit_score == 2:
-        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."
+        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."
     elif fit_score == 1:
-        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."
+        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])}."
     else:
-        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."
-    
-    execution_time = time.time() - start_time
+        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."
     
-    return fit_assessment, fit_score, execution_time
+    return assessment, fit_score, time.time() - start
 
 def analyze_job_fit(resume_summary, job_description, models):
     start = time.time()
@@ -355,6 +470,10 @@ 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.")
 
@@ -363,6 +482,9 @@ def main():
     uploaded_file = st.file_uploader("Upload your resume", type=["docx", "doc", "txt"])
     job_description = st.text_area("Enter Job Description", height=200, placeholder="Paste the job description here...")
 
+    # Debug toggle (uncomment to add debug mode)
+    # show_debug = st.sidebar.checkbox("Show Debug Info", value=False)
+
     # Process when button clicked
     if uploaded_file and job_description and st.button("Analyze Job Fit"):
         progress = st.progress(0)
@@ -417,6 +539,11 @@ def main():
                 - If interested in this field, focus on developing the required skills
                 - Consider similar roles with fewer experience requirements
                 """)
+            
+            # Show debug scores if enabled
+            # if show_debug:
+            #     st.subheader("Debug Information")
+            #     st.json(st.session_state['debug_scores'])
 
 if __name__ == "__main__":
     main()