app.py

import os
import io
import streamlit as st
import docx
import docx2txt
import tempfile
import time
import re
import concurrent.futures
from functools import lru_cache
from transformers import pipeline

# Set page title and hide sidebar
st.set_page_config(
    page_title="Resume-Google Job Match 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)

# Pre-defined company description for Google
GOOGLE_DESCRIPTION = """Google LLC, a global leader in technology and innovation, specializes in internet services, cloud computing, artificial intelligence, and software development. As part of Alphabet Inc., Google seeks candidates with strong problem-solving skills, adaptability, and collaboration abilities. Technical roles require proficiency in programming languages such as Python, Java, C++, Go, or JavaScript, with expertise in data structures, algorithms, and system design. Additionally, skills in AI, cybersecurity, UX/UI design, and digital marketing are highly valued. Google fosters a culture of innovation, expecting candidates to demonstrate creativity, analytical thinking, and a passion for cutting-edge technology."""

#####################################
# Preload Models - Optimized
#####################################
@st.cache_resource(show_spinner=True)
def load_models():
    """Load models at startup - using smaller/faster models"""
    with st.spinner("Loading AI models... This may take a minute on first run."):
        models = {}
        # Use bart-base instead of bart-large-cnn for faster processing
        models['summarizer'] = pipeline(
            "summarization", 
            model="facebook/bart-base", 
            max_length=100,
            truncation=True
        )
        # We don't need T5 model anymore since we're using template-based feedback
        return models

# Preload models immediately when app starts
models = load_models()

#####################################
# Function: Extract Text from File
#####################################
@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.
    """
    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}"
    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
            os.unlink(temp_path)
        except Exception as e:
            text = 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}"
    else:
        text = "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 - Optimized
#####################################

# Cache the extraction functions to avoid reprocessing
@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)"

def extract_age(text):
    """Extract candidate age from resume text"""
    # Simplified: just check a few common patterns
    age_patterns = [
        r'age:?\s*(\d{1,2})',
        r'(\d{1,2})\s*years\s*old',
    ]
    
    text_lower = text.lower()
    for pattern in age_patterns:
        matches = re.search(pattern, text_lower)
        if matches:
            return matches.group(1)
    
    return "Not specified"

def extract_industry(text, base_summary):
    """Extract expected job industry from resume"""
    # Simplified industry keywords focused on the most common ones
    industry_keywords = {
        "technology": ["software", "programming", "developer", "IT", "tech", "computer"],
        "finance": ["banking", "financial", "accounting", "finance", "analyst"],
        "healthcare": ["medical", "health", "hospital", "clinical", "nurse", "doctor"],
        "education": ["teaching", "teacher", "professor", "education", "university"],
        "marketing": ["marketing", "advertising", "digital marketing", "social media"],
        "engineering": ["engineer", "engineering"],
        "data science": ["data science", "machine learning", "AI", "analytics"],
        "information systems": ["information systems", "ERP", "systems management"]
    }
    
    # Use the base summary (already lowercased) to speed up matching
    combined_text = base_summary.lower()
    
    counts = {}
    for industry, keywords in industry_keywords.items():
        counts[industry] = sum(combined_text.count(keyword.lower()) for keyword in keywords)
    
    # Get the industry with the highest count
    if counts:
        likely_industry = max(counts.items(), key=lambda x: x[1])
        if likely_industry[1] > 0:
            return likely_industry[0].capitalize()
    
    # Check for educational background that might indicate industry
    degrees = ["computer science", "business", "engineering", "medicine", "education", "finance", "marketing"]
    
    for degree in degrees:
        if degree in combined_text:
            return f"{degree.capitalize()}-related field"
    
    return "Not clearly specified"

def extract_skills_and_work(text):
    """Extract both skills and work experience at once to save processing time"""
    # Common skill categories - reduced keyword list for speed
    skill_categories = {
        "Programming": ["Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "Go"],
        "Data Science": ["Machine Learning", "Data Analysis", "Statistics", "TensorFlow", "PyTorch", "AI", "Algorithms"],
        "Database": ["SQL", "MySQL", "MongoDB", "Database", "NoSQL", "PostgreSQL"],
        "Web Development": ["React", "Angular", "Node.js", "Frontend", "Backend", "Full-Stack"],
        "Software Development": ["Agile", "Scrum", "Git", "DevOps", "Docker", "System Design"],
        "Cloud": ["AWS", "Azure", "Google Cloud", "Cloud Computing"],
        "Security": ["Cybersecurity", "Network Security", "Encryption", "Security"],
        "Business": ["Project Management", "Business Analysis", "Leadership", "Teamwork"],
        "Design": ["UX/UI", "User Experience", "Design Thinking", "Adobe"]
    }
    
    # Work experience extraction
    work_headers = [
        "work experience", "professional experience", "employment history", 
        "work history", "experience"
    ]
    
    next_section_headers = [
        "education", "skills", "certifications", "projects", "achievements"
    ]
    
    # Process everything at once
    lines = text.split('\n')
    text_lower = text.lower()
    
    # Skills extraction
    found_skills = []
    for category, skills in skill_categories.items():
        category_skills = []
        for skill in skills:
            if skill.lower() in text_lower:
                category_skills.append(skill)
        if category_skills:
            found_skills.append(f"{category}: {', '.join(category_skills)}")
    
    # Work experience extraction - simplified approach
    work_section = []
    in_work_section = False
    
    for idx, line in enumerate(lines):
        line_lower = line.lower().strip()
        # Start of work section
        if not in_work_section:
            if any(header in line_lower for header in work_headers):
                in_work_section = True
                continue
        # End of work section
        elif in_work_section:
            if any(header in line_lower for header in next_section_headers):
                break
            if line.strip():
                work_section.append(line.strip())
    
    # Simplified work formatting
    if not work_section:
        work_experience = "Work experience not clearly identified"
    else:
        work_lines = []
        company_count = 0
        for line in work_section:
            if re.search(r'(19|20)\d{2}', line):
                company_count += 1
                if company_count <= 3:  # Limit to 3 most recent positions
                    work_lines.append(f"**{line}**")
                else:
                    break
            elif company_count <= 3 and len(work_lines) < 10:
                work_lines.append(line)
        
        work_experience = "\n• " + "\n• ".join(work_lines[:7]) if work_lines else "Work experience not clearly structured"
    
    skills_formatted = "\n• " + "\n• ".join(found_skills) if found_skills else "No specific technical skills clearly identified"
    
    return skills_formatted, work_experience

#####################################
# Function: Summarize Resume Text - Optimized
#####################################
def summarize_resume_text(resume_text):
    """
    Generates a structured summary of the resume text - optimized for speed
    """
    start_time = time.time()
    
    # First, generate a quick summary using the preloaded model
    max_input_length = 1024  # Model limit
    # Only summarize the first 1024 characters for speed
    text_to_summarize = resume_text[:max_input_length]
    base_summary = models['summarizer'](text_to_summarize, truncation=True)[0]['summary_text']
    
    # Extract information in parallel where possible
    # Limit the number of workers to reduce overhead
    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
        name_future = executor.submit(extract_name, resume_text[:500])  # Only use the start of text
        age_future = executor.submit(extract_age, resume_text)
        industry_future = executor.submit(extract_industry, resume_text, base_summary)
        skills_work_future = executor.submit(extract_skills_and_work, resume_text)
        
        # Get results
        name = name_future.result()
        age = age_future.result()
        industry = industry_future.result()
        skills, work_experience = skills_work_future.result()
    
    # Format the structured summary
    formatted_summary = f"Name: {name}\n"
    formatted_summary += f"Age: {age}\n"
    formatted_summary += f"Expected Job Industry: {industry}\n\n"
    formatted_summary += f"Previous Work Experience: {work_experience}\n\n"
    formatted_summary += f"Skills: {skills}"
    
    execution_time = time.time() - start_time
    return formatted_summary, execution_time

#####################################
# Function: Calculate Google Match Score - Detailed Breakdown
#####################################
def calculate_google_match_score(candidate_summary):
    """
    Calculate a detailed match score breakdown based on skills and experience in the candidate summary
    compared with what Google requires.
    Returns:
    - overall_score: A normalized score between 0 and 1
    - category_scores: A dictionary with scores for each category
    - score_breakdown: A formatted string explanation of the scoring
    """
    # Define categories that Google values with specific keywords
    google_categories = {
        "Technical Skills": {
            "keywords": ["python", "java", "c++", "go", "javascript", "sql", "nosql", 
                         "algorithms", "data structures", "system design"],
            "weight": 0.35
        },
        "Advanced Technologies": {
            "keywords": ["artificial intelligence", "machine learning", "cloud computing", 
                         "ai", "ml", "cloud", "data science", "big data", 
                         "tensorflow", "pytorch", "deep learning"],
            "weight": 0.25
        },
        "Problem Solving": {
            "keywords": ["problem solving", "algorithms", "analytical", "critical thinking",
                         "debugging", "troubleshooting", "optimization"],
            "weight": 0.20
        },
        "Innovation & Creativity": {
            "keywords": ["innovation", "creative", "creativity", "novel", "cutting-edge", 
                        "research", "design thinking", "innovative"],
            "weight": 0.10
        },
        "Teamwork & Leadership": {
            "keywords": ["team", "leadership", "collaborate", "collaboration", "communication",
                        "mentoring", "lead", "coordinate", "agile", "scrum"],
            "weight": 0.10
        }
    }
    
    summary_lower = candidate_summary.lower()
    
    # Calculate scores for each category
    category_scores = {}
    for category, details in google_categories.items():
        keywords = details["keywords"]
        max_possible = len(keywords)
        matches = sum(1 for keyword in keywords if keyword in summary_lower)
        
        if max_possible > 0:
            raw_score = matches / max_possible
            category_scores[category] = min(1.0, raw_score * 1.5)
        else:
            category_scores[category] = 0
    
    overall_score = sum(
        score * google_categories[category]["weight"] 
        for category, score in category_scores.items()
    )
    overall_score = min(1.0, max(0.0, overall_score))
    
    # Create score breakdown explanation
    score_breakdown = "**Score Breakdown by Category:**\n\n"
    
    for category, score in category_scores.items():
        percentage = int(score * 100)
        weight = int(google_categories[category]["weight"] * 100)
        score_breakdown += f"• **{category}** ({weight}% of total): {percentage}%\n"
    
    return overall_score, category_scores, score_breakdown

#####################################
# Function: Generate Robust Feedback - Template-Based
#####################################
def generate_template_feedback(category_scores):
    """
    Generate comprehensive template-based feedback without using ML model for speed and reliability.
    """
    start_time = time.time()
    import random
    
    sorted_categories = sorted(category_scores.items(), key=lambda x: x[1], reverse=True)
    top_categories = sorted_categories[:2]
    bottom_categories = sorted(category_scores.items(), key=lambda x: x[1])[:2]
    
    top_feedback_templates = {
        "Technical Skills": [
            "demonstrates strong technical skills with proficiency in programming languages and technical tools that Google values.",
            "shows excellent technical capabilities that align well with Google's engineering requirements.",
            "possesses the technical expertise needed for Google's development environment."
        ],
        "Advanced Technologies": [
            "has valuable experience with cutting-edge technologies that Google prioritizes in its innovation efforts.",
            "demonstrates knowledge in advanced technological areas that align with Google's future direction.",
            "shows proficiency in modern technologies that Google uses in its products and services."
        ],
        "Problem Solving": [
            "exhibits strong problem-solving abilities which are fundamental to Google's engineering culture.",
            "demonstrates analytical thinking and problem-solving skills that Google seeks in candidates.",
            "shows the problem-solving aptitude that would be valuable in Google's collaborative environment."
        ],
        "Innovation & Creativity": [
            "shows the creative thinking and innovation mindset that Google values in its workforce.",
            "demonstrates the innovative approach that would fit well with Google's creative culture.",
            "exhibits creativity that could contribute to Google's product development process."
        ],
        "Teamwork & Leadership": [
            "demonstrates leadership qualities and teamwork skills that Google looks for in potential employees.",
            "shows collaborative abilities that would integrate well with Google's team-based structure.",
            "exhibits the interpersonal skills needed to thrive in Google's collaborative environment."
        ]
    }
    
    bottom_feedback_templates = {
        "Technical Skills": [
            "should strengthen their technical skills, particularly in programming languages commonly used at Google such as Python, Java, or C++.",
            "would benefit from developing more depth in technical tools and programming capabilities to meet Google's standards.",
            "needs to enhance their technical expertise to better align with Google's engineering requirements."
        ],
        "Advanced Technologies": [
            "would benefit from gaining more experience with AI, machine learning, or cloud technologies that Google prioritizes.",
            "should develop more expertise in advanced technologies like machine learning or data science to increase their value to Google.",
            "needs more exposure to the cutting-edge technologies that drive Google's innovation."
        ],
        "Problem Solving": [
            "should strengthen their problem-solving abilities, particularly with algorithms and data structures that are crucial for Google interviews.",
            "would benefit from developing stronger analytical and problem-solving skills to match Google's expectations.",
            "needs to improve their approach to complex problem-solving to meet Google's standards."
        ],
        "Innovation & Creativity": [
            "could develop a more innovative mindset to better align with Google's creative culture.",
            "should work on demonstrating more creative thinking in their approach to match Google's innovation focus.",
            "would benefit from cultivating more creativity and out-of-the-box thinking valued at Google."
        ],
        "Teamwork & Leadership": [
            "should focus on developing stronger leadership and teamwork skills to thrive in Google's collaborative environment.",
            "would benefit from more experience in collaborative settings to match Google's team-oriented culture.",
            "needs to strengthen their interpersonal and leadership capabilities to align with Google's expectations."
        ]
    }
    
    top_category = top_categories[0][0]
    top_feedback = random.choice(top_feedback_templates.get(top_category, ["shows notable skills"]))
    
    bottom_category = bottom_categories[0][0]
    bottom_feedback = random.choice(bottom_feedback_templates.get(bottom_category, ["could improve their skills"]))
    
    feedback = f"This candidate {top_feedback} "
    
    if top_categories[1][1] >= 0.6:
        second_top = top_categories[1][0]
        second_top_feedback = random.choice(top_feedback_templates.get(second_top, ["has good abilities"]))
        feedback += f"The candidate also {second_top_feedback} "
    
    feedback += f"However, the candidate {bottom_feedback} "
    
    overall_score = sum(score * weight for (category, score), weight in 
                       zip(category_scores.items(), [0.35, 0.25, 0.20, 0.10, 0.10]))
    
    if overall_score >= 0.75:
        feedback += "Overall, this candidate shows strong potential for success at Google."
    elif overall_score >= 0.6:
        feedback += "With these improvements, the candidate could be a good fit for Google."
    else:
        feedback += "The candidate would need significant development to meet Google's standards."
    
    execution_time = time.time() - start_time
    return feedback, execution_time

#####################################
# Main Streamlit Interface - with Progress Reporting
#####################################
st.title("Google Resume Match Analyzer")
st.markdown(
    """
Upload your resume file in **.docx**, **.doc**, or **.txt** format to see how well you match with Google's hiring requirements. The app performs the following tasks:
1. Extracts text from your resume.
2. Uses AI to generate a structured candidate summary.
3. Evaluates your fit for Google across key hiring criteria with a detailed score breakdown.
"""
)

# Display Google's requirements
with st.expander("Google's Requirements", expanded=False):
    st.write(GOOGLE_DESCRIPTION)

# File uploader
uploaded_file = st.file_uploader("Upload your resume (.docx, .doc, or .txt)", type=["docx", "doc", "txt"])

# Process button with optimized flow
if uploaded_file is not None and st.button("Analyze My Google Fit"):
    progress_bar = st.progress(0)
    status_text = st.empty()
    
    # Step 1: Extract text
    status_text.text("Step 1/3: Extracting text from resume...")
    resume_text = extract_text_from_file(uploaded_file)
    progress_bar.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)
        progress_bar.progress(50)
        
        st.subheader("Your Resume Summary")
        st.markdown(summary)
        st.info(f"Summary generated in {summarization_time:.2f} seconds")
        
        # Step 3: Calculate scores and generate feedback
        status_text.text("Step 3/3: Calculating Google fit scores...")
        overall_score, category_scores, score_breakdown = calculate_google_match_score(summary)
        feedback, feedback_time = generate_template_feedback(category_scores)
            
        progress_bar.progress(100)
        status_text.empty()
        
        st.subheader("Google Fit Assessment")
        score_percent = int(overall_score * 100)
        if overall_score >= 0.85:
            st.success(f"**Overall Google Match Score:** {score_percent}% 🌟")
        elif overall_score >= 0.70:
            st.success(f"**Overall Google Match Score:** {score_percent}% ✅")
        elif overall_score >= 0.50:
            st.warning(f"**Overall Google Match Score:** {score_percent}% ⚠️")
        else:
            st.error(f"**Overall Google Match Score:** {score_percent}% 🔍")
        
        st.markdown("### Score Calculation")
        st.markdown(score_breakdown)
        
        st.markdown("### Expert Assessment")
        st.markdown(feedback)
        
        st.info(f"Assessment completed in {feedback_time:.2f} seconds")
        
        st.subheader("Recommended Next Steps")
        weakest_categories = sorted(category_scores.items(), key=lambda x: x[1])[:2]
        
        if overall_score >= 0.80:
            st.markdown("""
            - Consider applying for positions at Google that match your experience
            - Prepare for technical interviews by practicing algorithms and system design
            - Review Google's interview process and STAR method for behavioral questions
            """)
        elif overall_score >= 0.60:
            improvement_areas = ", ".join([cat for cat, _ in weakest_categories])
            st.markdown(f"""
            - Focus on strengthening these areas: {improvement_areas}
            - Work on projects that demonstrate your skills in Google's key technology areas
            - Consider taking additional courses in algorithms, system design, or other Google focus areas
            """)
        else:
            improvement_areas = ", ".join([cat for cat, _ in weakest_categories])
            st.markdown(f"""
            - Build experience in these critical areas: {improvement_areas}
            - Develop projects showcasing problem-solving abilities and technical skills
            - Consider gaining more experience before applying, or target specific Google roles that better match your profile
            """)