Update app.py

app.py

@@ -9,7 +9,7 @@ import re
 import pandas as pd
 from functools import lru_cache
 
-# Try different import approaches
+# Handle imports
 try:
     from transformers import pipeline
     has_pipeline = True
@@ -20,21 +20,11 @@ except ImportError:
     st.warning("Using basic transformers functionality instead of pipeline API")
 
 # Set page title and hide sidebar
-st.set_page_config(
-    page_title="Resume-Job Fit Analyzer",
-    initial_sidebar_state="collapsed"
-)
-
-# Hide sidebar completely with custom CSS
-st.markdown("""
-<style>
-    [data-testid="collapsedControl"] {display: none;}
-    section[data-testid="stSidebar"] {display: none;}
-</style>
-""", unsafe_allow_html=True)
+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)
 
 #####################################
-# Preload Models
+# Preload Models & Helper Functions
 #####################################
 @st.cache_resource(show_spinner=True)
 def load_models():
@@ -44,107 +34,67 @@ def load_models():
         
         # Load summarization model
         if has_pipeline:
-            # Use pipeline if available, now using the updated model
-            models['summarizer'] = pipeline(
-                "summarization", 
-                model="Falconsai/text_summarization", 
-                max_length=100,
-                truncation=True
-            )
+            models['summarizer'] = pipeline("summarization", model="Falconsai/text_summarization", max_length=100, truncation=True)
         else:
-            # Fall back to basic model loading using the updated summarization model
             try:
                 models['summarizer_model'] = AutoModelForSeq2SeqLM.from_pretrained("Falconsai/text_summarization")
                 models['summarizer_tokenizer'] = AutoTokenizer.from_pretrained("Falconsai/text_summarization")
             except Exception as e:
                 st.error(f"Error loading summarization model: {e}")
-                models['summarizer_model'] = None
-                models['summarizer_tokenizer'] = None
+                models['summarizer_model'] = models['summarizer_tokenizer'] = None
         
-        # Load sentiment model for evaluation - updated model
+        # Load evaluation model
         if has_pipeline:
-            # Use pipeline if available
-            models['evaluator'] = pipeline(
-                "sentiment-analysis", 
-                model="CR7CAD/RobertaFinetuned"
-            )
+            models['evaluator'] = pipeline("sentiment-analysis", model="CR7CAD/RobertaFinetuned")
         else:
-            # Fall back to basic model loading using the updated evaluation model
             try:
-                models['evaluator_model'] = AutoModelForSequenceClassification.from_pretrained(
-                    "CR7CAD/RobertaFinetuned"
-                )
-                models['evaluator_tokenizer'] = AutoTokenizer.from_pretrained(
-                    "CR7CAD/RobertaFinetuned"
-                )
+                models['evaluator_model'] = AutoModelForSequenceClassification.from_pretrained("CR7CAD/RobertaFinetuned")
+                models['evaluator_tokenizer'] = AutoTokenizer.from_pretrained("CR7CAD/RobertaFinetuned")
             except Exception as e:
                 st.error(f"Error loading sentiment model: {e}")
-                models['evaluator_model'] = None
-                models['evaluator_tokenizer'] = None
+                models['evaluator_model'] = models['evaluator_tokenizer'] = None
         
         return models
 
-# Custom text summarization function that works with or without pipeline
 def summarize_text(text, models, max_length=100):
-    """Summarize text using available models"""
+    """Summarize text using available models with fallbacks"""
     # Truncate input to prevent issues with long texts
-    input_text = text[:1024]  # Limit input length
+    input_text = text[:1024]
     
+    # Try pipeline first
     if has_pipeline and 'summarizer' in models:
-        # Use pipeline if available
         try:
-            summary = models['summarizer'](input_text)[0]['summary_text']
-            return summary
+            return models['summarizer'](input_text)[0]['summary_text']
         except Exception as e:
             st.warning(f"Error in pipeline summarization: {e}")
     
-    # Fall back to manual model inference
+    # Try manual model
     if 'summarizer_model' in models and 'summarizer_tokenizer' in models and models['summarizer_model']:
         try:
             tokenizer = models['summarizer_tokenizer']
             model = models['summarizer_model']
-            
-            # Prepare inputs
             inputs = tokenizer(input_text, return_tensors="pt", truncation=True, max_length=1024)
-            
-            # Generate summary
-            summary_ids = model.generate(
-                inputs.input_ids, 
-                max_length=max_length, 
-                min_length=30, 
-                num_beams=4, 
-                early_stopping=True
-            )
-            
-            summary = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
-            return summary
+            summary_ids = model.generate(inputs.input_ids, max_length=max_length, min_length=30, num_beams=4, early_stopping=True)
+            return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
         except Exception as e:
             st.warning(f"Error in manual summarization: {e}")
     
-    # If all else fails, extract first few sentences
+    # Fallback to basic summarization
     return basic_summarize(text, max_length)
 
-# Basic text summarization as last fallback
 def basic_summarize(text, max_length=100):
-    """Basic text summarization by extracting key sentences"""
-    # Split into sentences
+    """Basic extractive text summarization"""
     sentences = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s', text)
     
-    # Score sentences by position (earlier is better) and length
+    # Score and filter sentences
     scored_sentences = []
     for i, sentence in enumerate(sentences):
-        # Skip very short sentences
-        if len(sentence.split()) < 4:
-            continue
-        
-        # Simple scoring: earlier sentences get higher scores, penalize very long sentences
-        score = 1.0 / (i + 1) - (0.01 * max(0, len(sentence.split()) - 20))
-        scored_sentences.append((score, sentence))
+        if len(sentence.split()) >= 4:
+            score = 1.0 / (i + 1) - (0.01 * max(0, len(sentence.split()) - 20))
+            scored_sentences.append((score, sentence))
     
-    # Sort by score
+    # Get top sentences
     scored_sentences.sort(reverse=True)
-    
-    # Get top sentences until we reach max_length
     summary_sentences = []
     current_length = 0
     
@@ -155,183 +105,109 @@ def basic_summarize(text, max_length=100):
         else:
             break
     
-    # Re-order sentences to match original order if we have more than one
+    # Restore original sentence order
     if summary_sentences:
-        original_order = []
-        for sentence in summary_sentences:
-            original_order.append((sentences.index(sentence), sentence))
+        original_order = [(sentences.index(s), s) for s in summary_sentences]
         original_order.sort()
         summary_sentences = [s for _, s in original_order]
     
-    # Combine into a summary
-    summary = " ".join(summary_sentences)
-    return summary
-
-# Modified job fit evaluation function that uses a direct scoring approach
-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()
-    
-    # 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 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
-    
-    # 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
-    if experience_match:
-        try:
-            years_experience = int(experience_match.group(1))
-        except:
-            years_experience = 0
-    
-    # Experience match
-    exp_match_ratio = min(1.0, years_experience / max(1, years_required)) if years_required > 0 else 0.5
-    
-    # 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.8:
-        fit_score = 1  # Potential fit
-    else:
-        fit_score = 0  # Not a fit
-    
-    # Generate assessment text based on score
-    missing_skills = [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."
-    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."
-    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
-    
-    return fit_assessment, fit_score, execution_time
+    return " ".join(summary_sentences)
 
 #####################################
-# Function: Extract Text from File
+# Information Extraction Functions
 #####################################
 @st.cache_data(show_spinner=False)
 def extract_text_from_file(file_obj):
-    """
-    Extract text from .docx and .doc files.
-    Returns the extracted text or an error message if extraction fails.
-    """
+    """Extract text from uploaded document file"""
     filename = file_obj.name
     ext = os.path.splitext(filename)[1].lower()
-    text = ""
-
+    
     if ext == ".docx":
         try:
             document = docx.Document(file_obj)
             text = "\n".join(para.text for para in document.paragraphs if para.text.strip())
         except Exception as e:
-            text = f"Error processing DOCX file: {e}"
+            return f"Error processing DOCX file: {e}"
     elif ext == ".doc":
         try:
-            # For .doc files, we need to save to a temp file
             with tempfile.NamedTemporaryFile(delete=False, suffix='.doc') as temp_file:
                 temp_file.write(file_obj.getvalue())
                 temp_path = temp_file.name
-        
-            # Use docx2txt which is generally faster
-            try:
-                text = docx2txt.process(temp_path)
-            except Exception:
-                text = "Could not process .doc file. Please convert to .docx format."
-        
-            # Clean up temp file
+            
+            text = docx2txt.process(temp_path)
             os.unlink(temp_path)
         except Exception as e:
-            text = f"Error processing DOC file: {e}"
+            return f"Error processing DOC file: {e}"
     elif ext == ".txt":
         try:
             text = file_obj.getvalue().decode("utf-8")
         except Exception as e:
-            text = f"Error processing TXT file: {e}"
+            return f"Error processing TXT file: {e}"
     else:
-        text = "Unsupported file type. Please upload a .docx, .doc, or .txt file."
+        return "Unsupported file type. Please upload a .docx, .doc, or .txt file."
     
-    # Limit text size for faster processing
     return text[:15000] if text else text
 
-#####################################
-# Functions for Information Extraction
-#####################################
+def extract_skills(text):
+    """Extract key skills from the resume"""
+    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"]
+    }
+    
+    text_lower = text.lower()
+    return [skill for category, skills in skill_keywords.items() 
+            for skill in skills if skill.lower() in text_lower]
+
+@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()]
+    
+    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"]):
+            return first_line
+    
+    for line in potential_name_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)"
 
-# Extract age 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',
-        r'dob:.*(\d{4})', # Year of birth
-        r'date of birth:.*(\d{4})' # Year of birth
+        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:
-            # If it's a year of birth, calculate approximate age
-            if len(matches.group(1)) == 4:  # It's a year
+            # Convert birth year to age if needed
+            if len(matches.group(1)) == 4:
                 try:
-                    birth_year = int(matches.group(1))
-                    current_year = 2025  # Current year
-                    return str(current_year - birth_year)
+                    return str(2025 - int(matches.group(1)))
                 except:
                     pass
             return matches.group(1)
     
     return "Not specified"
 
-# Extract industry preference
 def extract_industry(text):
     """Extract expected job industry from resume"""
-    # Common industry keywords
     industry_keywords = {
         "Technology": ["software", "programming", "developer", "IT", "tech", "computer", "digital"],
         "Finance": ["banking", "financial", "accounting", "finance", "analyst"],
@@ -346,23 +222,13 @@ def extract_industry(text):
     }
     
     text_lower = text.lower()
-    industry_counts = {}
-    
-    for industry, keywords in industry_keywords.items():
-        count = sum(text_lower.count(keyword.lower()) for keyword in keywords)
-        if count > 0:
-            industry_counts[industry] = count
-    
-    if industry_counts:
-        # Return the industry with the highest keyword count
-        return max(industry_counts.items(), key=lambda x: x[1])[0]
+    industry_counts = {industry: sum(text_lower.count(keyword.lower()) for keyword in keywords) 
+                       for industry, keywords in industry_keywords.items()}
     
-    return "Not clearly specified"
+    return max(industry_counts.items(), key=lambda x: x[1])[0] if any(industry_counts.values()) else "Not clearly specified"
 
-# Extract job position preference
 def extract_job_position(text):
     """Extract expected job position from resume"""
-    # Look for objective or summary section
     objective_patterns = [
         r'objective:?\s*(.*?)(?=\n\n|\n\w+:|\Z)',
         r'career\s*objective:?\s*(.*?)(?=\n\n|\n\w+:|\Z)',
@@ -376,28 +242,21 @@ def extract_job_position(text):
         match = re.search(pattern, text_lower, re.IGNORECASE | re.DOTALL)
         if match:
             objective_text = match.group(1).strip()
-            # Look for job titles in the objective
             job_titles = ["developer", "engineer", "analyst", "manager", "director", "specialist", 
                           "coordinator", "consultant", "designer", "architect", "administrator"]
             
             for title in job_titles:
                 if title in objective_text:
-                    # Try to get the full title with context
                     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 no specific title found but we have objective text, return a summary
             if len(objective_text) > 10:
-                # Truncate and clean up objective
                 words = objective_text.split()
-                if len(words) > 10:
-                    return " ".join(words[:10]).title() + "..."
-                return objective_text.title()
+                return " ".join(words[:10]).title() + "..." if len(words) > 10 else objective_text.title()
     
-    # Check current/most recent job 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*\)',
@@ -411,64 +270,11 @@ def extract_job_position(text):
     
     return "Not explicitly stated"
 
-# Extract name
-@lru_cache(maxsize=32)
-def extract_name(text_start):
-    """Extract candidate name from the beginning of resume text"""
-    # Only use the first 500 characters to speed up processing
-    lines = text_start.split('\n')
-    
-    # Check first few non-empty lines for potential names
-    potential_name_lines = [line.strip() for line in lines[:5] if line.strip()]
-    
-    if potential_name_lines:
-        # First line is often the name if it's short and doesn't contain common headers
-        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"]):
-            return first_line
-    
-    # Look for lines that might contain a name
-    for line in potential_name_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)"
-
-# Extract skills
-def extract_skills(text):
-    """Extract key skills from the resume"""
-    # Common skill categories - reduced keyword list for speed
-    skill_categories = {
-        "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"]
-    }
-    
-    # Process everything at once
-    text_lower = text.lower()
-    
-    # Skills extraction
-    all_skills = []
-    for category, skills in skill_categories.items():
-        for skill in skills:
-            if skill.lower() in text_lower:
-                all_skills.append(skill)
-    
-    return all_skills
-
 #####################################
-# Function: Summarize Resume Text
+# Core Analysis Functions
 #####################################
 def summarize_resume_text(resume_text, models):
-    """
-    Generates a structured summary of the resume text with the critical information
-    """
+    """Generate a structured summary of resume text"""
     start_time = time.time()
     
     # Extract critical information
@@ -478,27 +284,17 @@ def summarize_resume_text(resume_text, models):
     job_position = extract_job_position(resume_text)
     skills = extract_skills(resume_text)
     
-    # Generate overall summary using the pipeline model if available
+    # Generate overall summary
     try:
         if has_pipeline and 'summarizer' in models:
-            # Truncate text to avoid issues with very long resumes
-            truncated_text = resume_text[:2000]  # Limit input to 2000 chars
-            
-            # Use pipeline model to generate the summary
-            model_summary = models['summarizer'](
-                truncated_text,
-                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, do_sample=False)[0]['summary_text']
         else:
-            # Fallback if pipeline is not available
             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 with different paragraphs for each critical piece
+    # 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"
@@ -506,33 +302,18 @@ def summarize_resume_text(resume_text, models):
     formatted_summary += f"Skills: {', '.join(skills)}\n\n"
     formatted_summary += f"Summary: {model_summary}"
     
-    execution_time = time.time() - start_time
-    
-    return formatted_summary, execution_time
+    return formatted_summary, time.time() - start_time
 
-#####################################
-# Function: Extract Job Requirements
-#####################################
 def extract_job_requirements(job_description, models):
-    """
-    Extract key requirements from a job description
-    """
-    # Common technical skills to look for - expanded list for better matching
+    """Extract key requirements from a job description"""
+    # Combined skill list (abridged for brevity)
     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", "Oracle",
-        "Project Management", "Agile", "Scrum", "UX/UI", "Design", "Leadership", "Team Management",
-        "Communication Skills", "Problem Solving", "Critical Thinking", "Blockchain", "Information Security",
-        "Networking", "Linux", "Windows Server", "Excel", "PowerPoint", "Word", "Tableau", "Power BI", "R",
-        "SPSS", "SAS", "Spark", "Hadoop", "JIRA", "Confluence", "Git", "SVN", "Testing", "QA", "DevOps",
-        "Full Stack", "Mobile Development", "Android", "iOS", "React Native", "Flutter", "SEO", "Marketing",
-        "Sales", "Customer Service", "Business Analysis", "Data Analysis", "Accounting", "Finance"
+        "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"
     ]
     
-    # Clean the text for processing
     clean_job_text = job_description.lower()
     
     # Extract job title
@@ -547,7 +328,7 @@ def extract_job_requirements(job_description, models):
         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:  # Reasonable title length
+            if 3 <= len(potential_title) <= 50:
                 job_title = potential_title.capitalize()
                 break
     
@@ -570,52 +351,98 @@ def extract_job_requirements(job_description, models):
     # 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)]
     
-    # If no skills found, use some default important ones to avoid empty lists
+    # Fallback if no skills found
     if not required_skills:
-        # Extract some common words that might be skills
         words = re.findall(r'\b\w{4,}\b', clean_job_text)
         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
-        
-        # Get the top 5 most common words as potential skills
         sorted_words = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)
         required_skills = [word.capitalize() for word, _ in sorted_words[:5]]
     
-    # Create a simple summary of the job using the summarize_text function
     job_summary = summarize_text(job_description, models, max_length=100)
     
-    # Format the job requirements
-    job_requirements = {
+    return {
         "title": job_title,
         "years_experience": years_required,
         "required_skills": required_skills,
         "summary": job_summary
     }
-    
-    return job_requirements
 
-#####################################
-# Function: Analyze Job Fit
-#####################################
-def analyze_job_fit(resume_summary, job_description, models):
-    """
-    Analyze how well the candidate fits the job requirements.
-    Returns a fit score (0-2) and an assessment.
-    """
+def evaluate_job_fit(resume_summary, job_requirements, models):
+    """Evaluate how well a resume matches job requirements"""
     start_time = time.time()
     
-    # Extract job requirements
-    job_requirements = extract_job_requirements(job_description, models)
+    # Extract information
+    required_skills = job_requirements["required_skills"]
+    years_required = job_requirements["years_experience"]
+    job_title = job_requirements["title"]
+    skills_mentioned = extract_skills(resume_summary)
     
-    # Use our more thorough evaluation function
-    assessment, fit_score, execution_time = evaluate_job_fit(resume_summary, job_requirements, models)
+    # Calculate match percentages
+    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
     
-    return assessment, fit_score, execution_time
+    # 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
+    
+    # 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)
+    
+    # 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"
+    
+    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 final weighted score
+    weighted_score = (skill_score * 0.5) + (exp_score * 0.3) + (title_score * 0.2)
+    
+    # Determine fit score
+    if weighted_score >= 1.5:
+        fit_score = 2  # Good fit
+    elif weighted_score >= 0.8:
+        fit_score = 1  # Potential fit
+    else:
+        fit_score = 0  # Not a fit
+    
+    # Generate assessment text
+    missing_skills = [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."
+    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."
+    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."
+    
+    return fit_assessment, fit_score, time.time() - start_time
 
-# Load models at startup
-models = load_models()
+def analyze_job_fit(resume_summary, job_description, models):
+    """End-to-end job fit analysis"""
+    start_time = 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
 
 #####################################
 # Main Function
@@ -623,21 +450,17 @@ models = load_models()
 def main():
     """Main function for the Streamlit application"""
     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 with the job requirements.")
 
-    # Resume upload
+    # Load models
+    models = load_models()
+    
+    # User inputs
     uploaded_file = st.file_uploader("Upload your resume (.docx, .doc, or .txt)", type=["docx", "doc", "txt"])
-
-    # Job description input
     job_description = st.text_area("Enter Job Description", height=200, placeholder="Paste the job description here...")
 
-    # Process button with optimized flow
+    # Process when button clicked
     if uploaded_file is not None and job_description and st.button("Analyze Job Fit"):
-        # Create a placeholder for the progress bar
         progress_bar = st.progress(0)
         status_text = st.empty()
         
@@ -662,31 +485,19 @@ def main():
             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)
-
-            # Clear status messages
             status_text.empty()
 
-            # Display job fit results
+            # Display results
             st.subheader("Job Fit Assessment")
-
-            # Display fit score with label
-            fit_labels = {
-                0: "NOT FIT",
-                1: "POTENTIAL FIT",
-                2: "GOOD FIT"
-            }
             
-            # Show the score prominently with appropriate coloring
-            score_label = fit_labels[fit_score]
+            # 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]};'>{score_label}</h2>", unsafe_allow_html=True)
-
-            # Display assessment
+            st.markdown(f"<h2 style='color: {score_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")
             
-            # Add potential next steps based on the fit score
+            # Recommendations
             st.subheader("Recommended Next Steps")
             
             if fit_score == 2:
@@ -708,6 +519,5 @@ def main():
                 - Consider similar roles with fewer experience requirements
                 """)
 
-# Run the main function
 if __name__ == "__main__":
     main()