Update app.py

app.py

@@ -1,11 +1,6 @@
-import os
-import io
+import os, io, re, time, tempfile
 import streamlit as st
-import docx
-import docx2txt
-import tempfile
-import time
-import re
+import docx, docx2txt
 import pandas as pd
 from functools import lru_cache
 
@@ -17,24 +12,21 @@ except ImportError:
     from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForSeq2SeqLM
     import torch
     has_pipeline = False
-    st.warning("Using basic transformers functionality instead of pipeline API")
 
-# Set page title and hide sidebar
+# Setup page
 st.set_page_config(page_title="Resume-Job Fit Analyzer", initial_sidebar_state="collapsed")
-st.markdown("""<style>[data-testid="collapsedControl"] {display: none;}section[data-testid="stSidebar"] {display: none;}</style>""", unsafe_allow_html=True)
+st.markdown("""<style>[data-testid="collapsedControl"],[data-testid="stSidebar"] {display: none;}</style>""", unsafe_allow_html=True)
 
 #####################################
-# Preload Models & Helper Functions
+# Model Loading & Text Processing
 #####################################
-@st.cache_resource(show_spinner=True)
+@st.cache_resource
 def load_models():
-    """Load models at startup"""
-    with st.spinner("Loading AI models... This may take a minute on first run."):
+    with st.spinner("Loading AI models..."):
         models = {}
-        
         # Load summarization model
         if has_pipeline:
-            models['summarizer'] = pipeline("summarization", model="Falconsai/text_summarization", max_length=100, truncation=True)
+            models['summarizer'] = pipeline("summarization", model="Falconsai/text_summarization", max_length=100)
         else:
             try:
                 models['summarizer_model'] = AutoModelForSeq2SeqLM.from_pretrained("Falconsai/text_summarization")
@@ -53,453 +45,430 @@ def load_models():
             except Exception as e:
                 st.error(f"Error loading sentiment model: {e}")
                 models['evaluator_model'] = models['evaluator_tokenizer'] = None
-        
         return models
 
 def summarize_text(text, models, max_length=100):
-    """Summarize text using available models with fallbacks"""
-    # Truncate input to prevent issues with long texts
+    """Summarize text with fallbacks"""
     input_text = text[:1024]
     
-    # Try pipeline first
+    # Try pipeline
     if has_pipeline and 'summarizer' in models:
         try:
             return models['summarizer'](input_text)[0]['summary_text']
-        except Exception as e:
-            st.warning(f"Error in pipeline summarization: {e}")
+        except: pass
     
     # Try manual model
-    if 'summarizer_model' in models and 'summarizer_tokenizer' in models and models['summarizer_model']:
+    if 'summarizer_model' in models and models['summarizer_model']:
         try:
             tokenizer = models['summarizer_tokenizer']
             model = models['summarizer_model']
             inputs = tokenizer(input_text, return_tensors="pt", truncation=True, max_length=1024)
-            summary_ids = model.generate(inputs.input_ids, max_length=max_length, min_length=30, num_beams=4, early_stopping=True)
+            summary_ids = model.generate(inputs.input_ids, max_length=max_length, min_length=30, num_beams=4)
             return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
-        except Exception as e:
-            st.warning(f"Error in manual summarization: {e}")
+        except: pass
     
-    # Fallback to basic summarization
-    return basic_summarize(text, max_length)
-
-def basic_summarize(text, max_length=100):
-    """Basic extractive text summarization"""
+    # Fallback - extract sentences
     sentences = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s', text)
-    
-    # Score and filter sentences
-    scored_sentences = []
-    for i, sentence in enumerate(sentences):
-        if len(sentence.split()) >= 4:
-            score = 1.0 / (i + 1) - (0.01 * max(0, len(sentence.split()) - 20))
-            scored_sentences.append((score, sentence))
-    
-    # Get top sentences
-    scored_sentences.sort(reverse=True)
-    summary_sentences = []
-    current_length = 0
-    
-    for _, sentence in scored_sentences:
-        if current_length + len(sentence.split()) <= max_length:
-            summary_sentences.append(sentence)
-            current_length += len(sentence.split())
-        else:
-            break
-    
-    # Restore original sentence order
-    if summary_sentences:
-        original_order = [(sentences.index(s), s) for s in summary_sentences]
-        original_order.sort()
-        summary_sentences = [s for _, s in original_order]
-    
-    return " ".join(summary_sentences)
+    scored = [(1.0/(i+1), s) for i, s in enumerate(sentences) if len(s.split()) >= 4]
+    scored.sort(reverse=True)
+    
+    result, length = [], 0
+    for _, sentence in scored:
+        if length + len(sentence.split()) <= max_length:
+            result.append(sentence)
+            length += len(sentence.split())
+    
+    if result:
+        ordered = sorted([(sentences.index(s), s) for s in result])
+        return " ".join(s for _, s in ordered)
+    return ""
 
 #####################################
-# Information Extraction Functions
+# File Processing & Information Extraction
 #####################################
-@st.cache_data(show_spinner=False)
+@st.cache_data
 def extract_text_from_file(file_obj):
-    """Extract text from uploaded document file"""
-    filename = file_obj.name
-    ext = os.path.splitext(filename)[1].lower()
+    ext = os.path.splitext(file_obj.name)[1].lower()
     
     if ext == ".docx":
         try:
             document = docx.Document(file_obj)
-            text = "\n".join(para.text for para in document.paragraphs if para.text.strip())
+            return "\n".join(para.text for para in document.paragraphs if para.text.strip())[:15000]
         except Exception as e:
             return f"Error processing DOCX file: {e}"
     elif ext == ".doc":
         try:
             with tempfile.NamedTemporaryFile(delete=False, suffix='.doc') as temp_file:
                 temp_file.write(file_obj.getvalue())
-                temp_path = temp_file.name
-            
-            text = docx2txt.process(temp_path)
-            os.unlink(temp_path)
+                text = docx2txt.process(temp_file.name)
+                os.unlink(temp_file.name)
+                return text[:15000]
         except Exception as e:
             return f"Error processing DOC file: {e}"
     elif ext == ".txt":
         try:
-            text = file_obj.getvalue().decode("utf-8")
+            return file_obj.getvalue().decode("utf-8")[:15000]
         except Exception as e:
             return f"Error processing TXT file: {e}"
     else:
         return "Unsupported file type. Please upload a .docx, .doc, or .txt file."
-    
-    return text[:15000] if text else text
 
+# Information extraction functions
 def extract_skills(text):
-    """Extract key skills from the resume"""
+    """Extract skills from text - expanded for better matching"""
+    # Expanded skill keywords dictionary
     skill_keywords = {
-        "Programming": ["Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "Go", "React", "Angular", "Vue", "Node.js"],
-        "Data Science": ["Machine Learning", "Data Analysis", "Statistics", "TensorFlow", "PyTorch", "AI", "Algorithms", "NLP", "Deep Learning"],
-        "Database": ["SQL", "MySQL", "MongoDB", "Database", "NoSQL", "PostgreSQL", "Oracle", "Redis"],
-        "Web Development": ["React", "Angular", "Node.js", "Frontend", "Backend", "Full-Stack", "REST API", "GraphQL"],
-        "Software Development": ["Agile", "Scrum", "Git", "DevOps", "Docker", "System Design", "CI/CD", "Jenkins"],
-        "Cloud": ["AWS", "Azure", "Google Cloud", "Cloud Computing", "Lambda", "S3", "EC2"],
-        "Security": ["Cybersecurity", "Network Security", "Encryption", "Security"],
-        "Business": ["Project Management", "Business Analysis", "Leadership", "Teamwork", "Agile", "Scrum"],
-        "Design": ["UX/UI", "User Experience", "Design Thinking", "Adobe", "Figma"]
+        "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"]
     }
     
     text_lower = text.lower()
-    return [skill for category, skills in skill_keywords.items() 
-            for skill in skills if skill.lower() in 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
 
 @lru_cache(maxsize=32)
 def extract_name(text_start):
-    """Extract candidate name from the beginning of resume text"""
-    lines = text_start.split('\n')
-    potential_name_lines = [line.strip() for line in lines[:5] if line.strip()]
+    lines = [line.strip() for line in text_start.split('\n')[:5] if line.strip()]
     
-    if potential_name_lines:
-        first_line = potential_name_lines[0]
-        if 5 <= len(first_line) <= 40 and not any(x in first_line.lower() for x in ["resume", "cv", "curriculum", "vitae", "profile"]):
+    if lines:
+        first_line = lines[0]
+        if 5 <= len(first_line) <= 40 and not any(x in first_line.lower() for x in ["resume", "cv", "curriculum", "vitae"]):
             return first_line
     
-    for line in potential_name_lines[:3]:
+    for line in lines[:3]:
         if len(line.split()) <= 4 and not any(x in line.lower() for x in ["address", "phone", "email", "resume", "cv"]):
             return line
-
-    return "Unknown (please extract from resume)"
+    return "Unknown"
 
 def extract_age(text):
-    """Extract candidate age from resume text"""
-    age_patterns = [
-        r'age:?\s*(\d{1,2})',
-        r'(\d{1,2})\s*years\s*old',
-        r'dob:.*(\d{4})',
-        r'date of birth:.*(\d{4})'
-    ]
-    
-    text_lower = text.lower()
-    for pattern in age_patterns:
-        matches = re.search(pattern, text_lower)
-        if matches:
-            # Convert birth year to age if needed
-            if len(matches.group(1)) == 4:
-                try:
-                    return str(2025 - int(matches.group(1)))
-                except:
-                    pass
-            return matches.group(1)
-    
+    for pattern in [r'age:?\s*(\d{1,2})', r'(\d{1,2})\s*years\s*old', r'dob:.*(\d{4})', r'date of birth:.*(\d{4})']:
+        match = re.search(pattern, text.lower())
+        if match:
+            if len(match.group(1)) == 4:  # Birth year
+                try: return str(2025 - int(match.group(1)))
+                except: pass
+            return match.group(1)
     return "Not specified"
 
 def extract_industry(text):
-    """Extract expected job industry from resume"""
-    industry_keywords = {
+    industries = {
         "Technology": ["software", "programming", "developer", "IT", "tech", "computer", "digital"],
         "Finance": ["banking", "financial", "accounting", "finance", "analyst"],
-        "Healthcare": ["medical", "health", "hospital", "clinical", "nurse", "doctor", "patient"],
-        "Education": ["teaching", "teacher", "professor", "education", "university", "school", "academic"],
+        "Healthcare": ["medical", "health", "hospital", "clinical", "nurse", "doctor"],
+        "Education": ["teaching", "teacher", "professor", "education", "university", "school"],
         "Marketing": ["marketing", "advertising", "digital marketing", "social media", "brand"],
         "Engineering": ["engineer", "engineering", "mechanical", "civil", "electrical"],
         "Data Science": ["data science", "machine learning", "AI", "analytics", "big data"],
-        "Management": ["manager", "management", "leadership", "executive", "director"],
-        "Consulting": ["consultant", "consulting", "advisor"],
-        "Sales": ["sales", "business development", "account manager", "client relations"]
+        "Management": ["manager", "management", "leadership", "executive", "director"]
     }
     
     text_lower = text.lower()
-    industry_counts = {industry: sum(text_lower.count(keyword.lower()) for keyword in keywords) 
-                       for industry, keywords in industry_keywords.items()}
-    
-    return max(industry_counts.items(), key=lambda x: x[1])[0] if any(industry_counts.values()) else "Not clearly specified"
+    counts = {ind: sum(text_lower.count(kw) for kw in kws) for ind, kws in industries.items()}
+    return max(counts.items(), key=lambda x: x[1])[0] if any(counts.values()) else "Not specified"
 
 def extract_job_position(text):
-    """Extract expected job position from resume"""
-    objective_patterns = [
-        r'objective:?\s*(.*?)(?=\n\n|\n\w+:|\Z)',
-        r'career\s*objective:?\s*(.*?)(?=\n\n|\n\w+:|\Z)',
-        r'professional\s*summary:?\s*(.*?)(?=\n\n|\n\w+:|\Z)',
-        r'summary:?\s*(.*?)(?=\n\n|\n\w+:|\Z)',
-        r'seeking\s*(?:a|an)?\s*(?:position|role|opportunity)\s*(?:as|in)?\s*(?:a|an)?\s*([^.]*)'
-    ]
-    
     text_lower = text.lower()
-    for pattern in objective_patterns:
+    for pattern in [r'objective:?\s*(.*?)(?=\n\n|\n\w+:|\Z)', r'career\s*objective:?\s*(.*?)(?=\n\n|\n\w+:|\Z)', 
+                   r'summary:?\s*(.*?)(?=\n\n|\n\w+:|\Z)', r'seeking.*position.*as\s*([^.]*)']:
         match = re.search(pattern, text_lower, re.IGNORECASE | re.DOTALL)
         if match:
-            objective_text = match.group(1).strip()
-            job_titles = ["developer", "engineer", "analyst", "manager", "director", "specialist", 
-                          "coordinator", "consultant", "designer", "architect", "administrator"]
-            
-            for title in job_titles:
-                if title in objective_text:
-                    title_pattern = r'(?:a|an)?\s*(\w+\s+' + title + r'|\w+\s+\w+\s+' + title + r')'
-                    title_match = re.search(title_pattern, objective_text)
-                    if title_match:
-                        return title_match.group(1).strip().title()
-                    return title.title()
-            
-            if len(objective_text) > 10:
-                words = objective_text.split()
-                return " ".join(words[:10]).title() + "..." if len(words) > 10 else objective_text.title()
-    
-    job_patterns = [
-        r'experience:.*?(\w+\s+\w+(?:\s+\w+)?)(?=\s*at|\s*\(|\s*-|\s*,|\s*\d{4}|\n)',
-        r'(\w+\s+\w+(?:\s+\w+)?)\s*\(\s*current\s*\)',
-        r'(\w+\s+\w+(?:\s+\w+)?)\s*\(\s*present\s*\)'
-    ]
-    
-    for pattern in job_patterns:
+            text = match.group(1).strip()
+            for title in ["developer", "engineer", "analyst", "manager", "specialist", "designer"]:
+                if title in text:
+                    return next((m.group(1).strip().title() for m in 
+                               [re.search(r'(\w+\s+' + title + r')', text)] if m), title.title())
+            return " ".join(text.split()[:10]).title() + "..." if len(text.split()) > 10 else text.title()
+    
+    # Check for job title near experience
+    for pattern in [r'experience:.*?(\w+\s+\w+(?:\s+\w+)?)(?=\s*at|\s*\()', r'(\w+\s+\w+(?:\s+\w+)?)\s*\(\s*(?:current|present)']:
         match = re.search(pattern, text_lower, re.IGNORECASE)
-        if match:
-            return match.group(1).strip().title()
+        if match: return match.group(1).strip().title()
     
-    return "Not explicitly stated"
+    return "Not specified"
 
 #####################################
 # Core Analysis Functions
 #####################################
 def summarize_resume_text(resume_text, models):
-    """Generate a structured summary of resume text"""
-    start_time = time.time()
+    start = time.time()
     
-    # Extract critical information
+    # Basic info extraction
     name = extract_name(resume_text[:500])
     age = extract_age(resume_text)
     industry = extract_industry(resume_text)
     job_position = extract_job_position(resume_text)
     skills = extract_skills(resume_text)
     
-    # Generate overall summary
+    # Generate summary
     try:
         if has_pipeline and 'summarizer' in models:
-            model_summary = models['summarizer'](resume_text[:2000], max_length=100, min_length=30, do_sample=False)[0]['summary_text']
+            model_summary = models['summarizer'](resume_text[:2000], max_length=100, min_length=30)[0]['summary_text']
         else:
             model_summary = summarize_text(resume_text, models, max_length=100)
-    except Exception as e:
-        st.warning(f"Error in resume summarization: {e}")
-        model_summary = "Error generating summary. Please check the original resume."
-    
-    # Format the structured summary
-    formatted_summary = f"Name: {name}\n\n"
-    formatted_summary += f"Age: {age}\n\n"
-    formatted_summary += f"Expected Industry: {industry}\n\n"
-    formatted_summary += f"Expected Job Position: {job_position}\n\n"
-    formatted_summary += f"Skills: {', '.join(skills)}\n\n"
-    formatted_summary += f"Summary: {model_summary}"
-    
-    return formatted_summary, time.time() - start_time
+    except:
+        model_summary = "Error generating summary."
+    
+    # Format result
+    summary = f"Name: {name}\n\nAge: {age}\n\nExpected Industry: {industry}\n\n"
+    summary += f"Expected Job Position: {job_position}\n\nSkills: {', '.join(skills)}\n\nSummary: {model_summary}"
+    
+    return summary, time.time() - start
 
 def extract_job_requirements(job_description, models):
-    """Extract key requirements from a job description"""
-    # Combined skill list (abridged for brevity)
+    # Expanded technical skills list for better matching
     tech_skills = [
-        "Python", "Java", "C++", "JavaScript", "TypeScript", "SQL", "HTML", "CSS", "React", "Angular", 
-        "Machine Learning", "Data Science", "AI", "AWS", "Azure", "Docker", "Kubernetes", "MySQL", 
-        "MongoDB", "PostgreSQL", "Project Management", "Agile", "Scrum", "Leadership", "Communication",
-        "Problem Solving", "Git", "DevOps", "Full Stack", "Mobile Development", "Android", "iOS"
+        "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"
     ]
     
-    clean_job_text = job_description.lower()
+    clean_text = job_description.lower()
     
     # Extract job title
-    title_patterns = [
-        r'^([^:.\n]+?)(position|role|job|opening|vacancy)',
-        r'^([^:.\n]+?)\n',
-        r'(hiring|looking for(?: a| an)?|recruiting)(?: a| an)? ([^:.\n]+?)(:-|[.:]|\n|$)'
-    ]
-    
     job_title = "Not specified"
-    for pattern in title_patterns:
-        title_match = re.search(pattern, clean_job_text, re.IGNORECASE)
-        if title_match:
-            potential_title = title_match.group(1).strip() if len(title_match.groups()) >= 1 else title_match.group(2).strip()
-            if 3 <= len(potential_title) <= 50:
-                job_title = potential_title.capitalize()
+    for pattern in [r'^([^:.\n]+?)(position|role|job)', r'^([^:.\n]+?)\n', r'hiring.*? ([^:.\n]+?)(:-|[.:]|\n|$)']:
+        match = re.search(pattern, clean_text, re.IGNORECASE)
+        if match:
+            title = match.group(1).strip() if len(match.groups()) >= 1 else match.group(2).strip()
+            if 3 <= len(title) <= 50:
+                job_title = title.capitalize()
                 break
     
-    # Extract years of experience
-    exp_patterns = [
-        r'(\d+)(?:\+)?\s*(?:years|yrs)(?:\s*of)?\s*(?:experience|exp)',
-        r'experience\s*(?:of)?\s*(\d+)(?:\+)?\s*(?:years|yrs)'
-    ]
-    
+    # Extract years required
     years_required = 0
-    for pattern in exp_patterns:
-        exp_match = re.search(pattern, clean_job_text, re.IGNORECASE)
-        if exp_match:
+    for pattern in [r'(\d+)(?:\+)?\s*(?:years|yrs).*?experience', r'experience.*?(\d+)(?:\+)?\s*(?:years|yrs)']:
+        match = re.search(pattern, clean_text, re.IGNORECASE)
+        if match:
             try:
-                years_required = int(exp_match.group(1))
+                years_required = int(match.group(1))
                 break
-            except:
-                pass
+            except: pass
     
-    # 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)]
+    # Extract skills
+    required_skills = [skill for skill in tech_skills if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_text)]
     
     # Fallback if no skills found
     if not required_skills:
-        words = re.findall(r'\b\w{4,}\b', clean_job_text)
+        words = [w for w in re.findall(r'\b\w{4,}\b', clean_text) 
+                if w not in ["with", "that", "this", "have", "from", "they", "will", "what", "your"]]
         word_counts = {}
-        for word in words:
-            if word not in ["with", "that", "this", "have", "from", "they", "will", "what", "your", "their", "about"]:
-                word_counts[word] = word_counts.get(word, 0) + 1
-        sorted_words = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)
-        required_skills = [word.capitalize() for word, _ in sorted_words[:5]]
-    
-    job_summary = summarize_text(job_description, models, max_length=100)
+        for w in words: word_counts[w] = word_counts.get(w, 0) + 1
+        required_skills = [w.capitalize() for w, _ in sorted(word_counts.items(), key=lambda x: x[1], reverse=True)[:5]]
     
     return {
         "title": job_title,
         "years_experience": years_required,
         "required_skills": required_skills,
-        "summary": job_summary
+        "summary": summarize_text(job_description, models, max_length=100)
     }
 
 def evaluate_job_fit(resume_summary, job_requirements, models):
-    """Evaluate how well a resume matches job requirements"""
-    start_time = time.time()
+    start = time.time()
     
-    # Extract information
+    # Basic extraction
     required_skills = job_requirements["required_skills"]
     years_required = job_requirements["years_experience"]
     job_title = job_requirements["title"]
     skills_mentioned = extract_skills(resume_summary)
     
-    # Calculate match percentages
+    # Calculate matches - IMPROVED MATCHING ALGORITHM
     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'
-    years_experience = 0
-    experience_match = re.search(experience_pattern, resume_summary, re.IGNORECASE)
-    if experience_match:
-        try:
-            years_experience = int(experience_match.group(1))
-        except:
-            pass
     
-    # Calculate match scores
-    exp_match_ratio = min(1.0, years_experience / max(1, years_required)) if years_required > 0 else 0.5
+    # 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
     
-    # Job title match score
-    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
+    # Extract experience
+    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
+    
+    # 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)
     
-    # Calculate individual scores
-    skill_score = min(2, skill_match_percentage * 3)
-    exp_score = min(2, exp_match_ratio * 2)
-    title_score = min(2, title_match * 2)
+    # 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_match = re.search(r'Name:\s*(.*?)(?=\n|\Z)', resume_summary)
-    name = name_match.group(1).strip() if name_match else "The candidate"
+    name = re.search(r'Name:\s*(.*?)(?=\n|\Z)', resume_summary)
+    name = name.group(1).strip() if name else "The candidate"
     
-    industry_match = re.search(r'Expected Industry:\s*(.*?)(?=\n|\Z)', resume_summary)
-    industry = industry_match.group(1).strip() if industry_match else "unspecified industry"
+    industry = re.search(r'Expected Industry:\s*(.*?)(?=\n|\Z)', resume_summary)
+    industry = industry.group(1).strip() if industry else "unspecified industry"
     
-    # Calculate final weighted score
-    weighted_score = (skill_score * 0.5) + (exp_score * 0.3) + (title_score * 0.2)
+    # Calculate weighted score - ADJUSTED WEIGHTS
+    weighted_score = (skill_score * 0.45) + (exp_score * 0.35) + (title_score * 0.20)
     
-    # Determine fit score
-    if weighted_score >= 1.5:
+    # 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:
         fit_score = 2  # Good fit
-    elif weighted_score >= 0.8:
-        fit_score = 1  # Potential fit
+    elif weighted_score >= 0.6:
+        fit_score = 1  # Potential fit - wider range
     else:
         fit_score = 0  # Not a fit
     
-    # Generate assessment text
-    missing_skills = [skill for skill in required_skills if skill not in skills_mentioned]
+    # 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]
     
     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."
+        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, time.time() - start_time
+    return assessment, fit_score, time.time() - start
 
 def analyze_job_fit(resume_summary, job_description, models):
-    """End-to-end job fit analysis"""
-    start_time = time.time()
+    start = time.time()
     job_requirements = extract_job_requirements(job_description, models)
-    assessment, fit_score, execution_time = evaluate_job_fit(resume_summary, job_requirements, models)
-    return assessment, fit_score, time.time() - start_time
+    assessment, fit_score, _ = evaluate_job_fit(resume_summary, job_requirements, models)
+    return assessment, fit_score, time.time() - start
 
 #####################################
 # Main Function
 #####################################
 def main():
-    """Main function for the Streamlit application"""
+    # 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 with the job requirements.")
+    st.markdown("Upload your resume file in **.docx**, **.doc**, or **.txt** format and enter a job description to see how well you match.")
 
-    # Load models
+    # Load models and get inputs
     models = load_models()
-    
-    # User inputs
-    uploaded_file = st.file_uploader("Upload your resume (.docx, .doc, or .txt)", type=["docx", "doc", "txt"])
+    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...")
 
     # Process when button clicked
-    if uploaded_file is not None and job_description and st.button("Analyze Job Fit"):
-        progress_bar = st.progress(0)
-        status_text = st.empty()
+    if uploaded_file and job_description and st.button("Analyze Job Fit"):
+        progress = st.progress(0)
+        status = st.empty()
         
         # Step 1: Extract text
-        status_text.text("Step 1/3: Extracting text from resume...")
+        status.text("Step 1/3: Extracting text from resume...")
         resume_text = extract_text_from_file(uploaded_file)
-        progress_bar.progress(25)
+        progress.progress(25)
         
         if resume_text.startswith("Error") or resume_text == "Unsupported file type. Please upload a .docx, .doc, or .txt file.":
             st.error(resume_text)
         else:
             # Step 2: Generate summary
-            status_text.text("Step 2/3: Analyzing resume and generating summary...")
-            summary, summarization_time = summarize_resume_text(resume_text, models)
-            progress_bar.progress(50)
-            
-            # Display summary
+            status.text("Step 2/3: Analyzing resume...")
+            summary, summary_time = summarize_resume_text(resume_text, models)
+            progress.progress(50)
             st.subheader("Your Resume Summary")
             st.markdown(summary)
             
-            # Step 3: Generate job fit assessment
-            status_text.text("Step 3/3: Evaluating job fit (this will take a moment)...")
-            assessment, fit_score, assessment_time = analyze_job_fit(summary, job_description, models)
-            progress_bar.progress(100)
-            status_text.empty()
+            # Step 3: Evaluate fit
+            status.text("Step 3/3: Evaluating job fit...")
+            assessment, fit_score, eval_time = analyze_job_fit(summary, job_description, models)
+            progress.progress(100)
+            status.empty()
 
             # Display results
             st.subheader("Job Fit Assessment")
-            
-            # Display score with appropriate styling
             fit_labels = {0: "NOT FIT", 1: "POTENTIAL FIT", 2: "GOOD FIT"}
-            score_colors = {0: "red", 1: "orange", 2: "green"}
-            st.markdown(f"<h2 style='color: {score_colors[fit_score]};'>{fit_labels[fit_score]}</h2>", unsafe_allow_html=True)
+            colors = {0: "red", 1: "orange", 2: "green"}
+            st.markdown(f"<h2 style='color: {colors[fit_score]};'>{fit_labels[fit_score]}</h2>", unsafe_allow_html=True)
             st.markdown(assessment)
-            st.info(f"Analysis completed in {(summarization_time + assessment_time):.2f} seconds")
+            st.info(f"Analysis completed in {(summary_time + eval_time):.2f} seconds")
             
             # Recommendations
             st.subheader("Recommended Next Steps")
-            
             if fit_score == 2:
                 st.markdown("""
                 - Apply for this position as you appear to be a good match
@@ -518,6 +487,10 @@ 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()