Spaces:
Sleeping
Sleeping
| 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 | |
| ##################################### | |
| 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 | |
| ) | |
| # Load T5-small model for evaluation with optimized settings | |
| models['evaluator'] = pipeline( | |
| "text-generation", | |
| model="facebook/opt-1.3b", | |
| max_length=200, | |
| num_beams=2, | |
| early_stopping=True | |
| ) | |
| return models | |
| # Preload models immediately when app starts | |
| models = load_models() | |
| ##################################### | |
| # Function: Extract Text from File | |
| ##################################### | |
| 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 | |
| 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"] | |
| } | |
| # Count occurrences of industry keywords - using the summary to speed up | |
| 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: | |
| # Just take the first 5-7 lines of the work section as a summary | |
| work_lines = [] | |
| company_count = 0 | |
| current_company = "" | |
| for line in work_section: | |
| # New company entry often has a date | |
| if re.search(r'(19|20)\d{2}', line): | |
| company_count += 1 | |
| if company_count <= 3: # Limit to 3 most recent positions | |
| current_company = line | |
| work_lines.append(f"**{line}**") | |
| else: | |
| break | |
| elif company_count <= 3 and len(work_lines) < 10: # Limit total lines | |
| 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 pre-loaded model | |
| max_input_length = 1024 # Model limit | |
| # Only summarize the first portion of text for speed | |
| text_to_summarize = resume_text[:min(len(resume_text), max_input_length)] | |
| base_summary = models['summarizer'](text_to_summarize)[0]['summary_text'] | |
| # Extract information in parallel where possible | |
| with concurrent.futures.ThreadPoolExecutor() as executor: | |
| # These can run in parallel | |
| name_future = executor.submit(extract_name, resume_text[:500]) # Only use 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) # Maximum possible matches | |
| # Count matches (unique keywords found) | |
| matches = sum(1 for keyword in keywords if keyword in summary_lower) | |
| # Calculate category score (0-1 range) | |
| if max_possible > 0: | |
| raw_score = matches / max_possible | |
| # Apply a curve to reward having more matches | |
| category_scores[category] = min(1.0, raw_score * 1.5) | |
| else: | |
| category_scores[category] = 0 | |
| # Calculate weighted overall score | |
| overall_score = sum( | |
| score * google_categories[category]["weight"] | |
| for category, score in category_scores.items() | |
| ) | |
| # Ensure overall score is in 0-1 range | |
| 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. | |
| """ | |
| start_time = time.time() | |
| # Sort categories by score | |
| sorted_categories = sorted(category_scores.items(), key=lambda x: x[1], reverse=True) | |
| top_categories = sorted_categories[:2] | |
| bottom_categories = sorted_categories[-2:] | |
| # More detailed template-based feedback for top category | |
| 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." | |
| ] | |
| } | |
| # More detailed template-based feedback for bottom categories | |
| 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." | |
| ] | |
| } | |
| # Generate feedback with more detailed templates | |
| import random | |
| # Get top strength feedback | |
| top_category = top_categories[0][0] | |
| top_score = top_categories[0][1] | |
| top_feedback = random.choice(top_feedback_templates.get(top_category, ["shows notable skills"])) | |
| # Get improvement area feedback | |
| bottom_category = bottom_categories[0][0] | |
| bottom_score = bottom_categories[0][1] | |
| bottom_feedback = random.choice(bottom_feedback_templates.get(bottom_category, ["could improve their skills"])) | |
| # Construct full feedback | |
| feedback = f"This candidate {top_feedback} " | |
| # Add second strength if it's good | |
| 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} " | |
| # Add improvement feedback | |
| feedback += f"However, the candidate {bottom_feedback} " | |
| # Add conclusion based on overall score | |
| 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 | |
| ##################################### | |
| # Function: Generate Aspect-Based Feedback with T5 - Enhanced with Fallback | |
| ##################################### | |
| def generate_aspect_feedback(candidate_summary, category_scores, _evaluator=None): | |
| """ | |
| Use T5-small model to generate feedback with robust fallback to template-based feedback. | |
| """ | |
| start_time = time.time() | |
| evaluator = _evaluator or models['evaluator'] | |
| # Sort categories by score | |
| sorted_categories = sorted(category_scores.items(), key=lambda x: x[1], reverse=True) | |
| top_categories = sorted_categories[:2] | |
| bottom_categories = sorted_categories[-2:] | |
| # Create a more explicit prompt for T5 | |
| prompt = f""" | |
| Generate a complete paragraph evaluating a job candidate for Google. | |
| The candidate is strong in: {', '.join([cat for cat, _ in top_categories])}. | |
| The candidate needs improvement in: {', '.join([cat for cat, _ in bottom_categories])}. | |
| Start with 'This candidate' and write at least 3 sentences about their fit for Google. | |
| """ | |
| # Generate focused feedback with error handling | |
| try: | |
| feedback_result = evaluator(prompt, max_length=200, do_sample=False) | |
| feedback = feedback_result[0]['generated_text'] | |
| # Validate the response - ensure it's not empty or too short | |
| if len(feedback.strip()) < 20 or feedback.strip() == "This candidate" or feedback.strip() == "This candidate.": | |
| # Fall back to template-based if T5 output is too short | |
| return generate_template_feedback(category_scores) | |
| # Ensure third-person tone | |
| if not any(feedback.lower().startswith(start) for start in ["the candidate", "this candidate"]): | |
| feedback = f"This candidate {feedback}" | |
| except Exception as e: | |
| # Fall back to template if there's an error | |
| print(f"Error generating T5 feedback: {e}") | |
| return generate_template_feedback(category_scores) | |
| 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"]) | |
| # Add a checkbox for template-based feedback (faster) | |
| use_template_feedback = st.checkbox("Use faster template-based feedback (no ML)", value=False, | |
| help="Generate feedback using pre-defined templates instead of T5 model") | |
| # Process button with optimized flow | |
| if uploaded_file is not None and st.button("Analyze My Google Fit"): | |
| # Create a placeholder for the progress bar | |
| 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) | |
| # Display summary | |
| 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) | |
| # Choose feedback generation method based on checkbox | |
| if use_template_feedback: | |
| feedback, feedback_time = generate_template_feedback(category_scores) | |
| else: | |
| feedback, feedback_time = generate_aspect_feedback( | |
| summary, category_scores, _evaluator=models['evaluator'] | |
| ) | |
| progress_bar.progress(100) | |
| # Clear status messages | |
| status_text.empty() | |
| # Display Google fit results | |
| st.subheader("Google Fit Assessment") | |
| # Display overall score with appropriate color and emoji | |
| 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}% 🔍") | |
| # Display score breakdown | |
| st.markdown("### Score Calculation") | |
| st.markdown(score_breakdown) | |
| # Display focused feedback | |
| st.markdown("### Expert Assessment") | |
| st.markdown(feedback) | |
| st.info(f"Assessment completed in {feedback_time:.2f} seconds") | |
| # Add potential next steps based on the score | |
| st.subheader("Recommended Next Steps") | |
| # Find the weakest categories | |
| 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 | |
| """) |