Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| import re | |
| from sentence_transformers import SentenceTransformer | |
| from sklearn.metrics.pairwise import cosine_similarity | |
| import spacy | |
| from collections import Counter | |
| import json | |
| import PyPDF2 | |
| import docx | |
| import io | |
| from pathlib import Path | |
| import os | |
| import google.generativeai as genai | |
| from typing import Dict, Any | |
| # Configure Gemini API | |
| genai.configure(api_key=os.environ.get("GEMINI_API_KEY")) | |
| class ATSScorer: | |
| def __init__(self): | |
| # Load pre-trained models | |
| print("Loading models...") | |
| self.sentence_model = SentenceTransformer('all-MiniLM-L6-v2') | |
| # Try to load spaCy model, fallback if not available | |
| try: | |
| self.nlp = spacy.load("en_core_web_sm") | |
| except OSError: | |
| print("spaCy model not found. Install with: python -m spacy download en_core_web_sm") | |
| self.nlp = None | |
| # Scoring weights from your requirements | |
| self.weights = { | |
| 'relevant_skills': 0.25, | |
| 'work_experience': 0.20, | |
| 'education': 0.10, | |
| 'certifications': 0.07, | |
| 'projects': 0.10, | |
| 'keywords_match': 0.10, | |
| 'tools_tech': 0.10, | |
| 'soft_skills': 0.08 | |
| } | |
| # Enhanced skill categories with domain-specific grouping | |
| self.skill_categories = { | |
| 'programming': ['python', 'java', 'javascript', 'c++', 'c#', 'go', 'rust', 'php', 'ruby', 'kotlin', 'swift', 'typescript', 'dart'], | |
| 'data_science': ['machine learning', 'deep learning', 'data analysis', 'statistics', 'pandas', 'numpy', 'tensorflow', 'pytorch', 'scikit-learn', 'matplotlib', 'seaborn'], | |
| 'web_development': ['html', 'css', 'react', 'vue', 'angular', 'node.js', 'express', 'django', 'flask', 'next.js', 'nuxt.js', 'svelte', 'bootstrap', 'tailwind'], | |
| 'mobile_development': ['react native', 'flutter', 'android studio', 'ios', 'swift', 'kotlin', 'xamarin', 'ionic', 'cordova', 'firebase'], | |
| 'cybersecurity': ['malware analysis', 'penetration testing', 'vulnerability assessment', 'ida pro', 'ghidra', 'wireshark', 'burp suite', 'metasploit', 'nmap', 'reverse engineering', 'oscp', 'cissp', 'ceh', 'security', 'threat', 'exploit'], | |
| 'databases': ['sql', 'mysql', 'postgresql', 'mongodb', 'redis', 'elasticsearch', 'oracle', 'sqlite', 'cassandra', 'dynamodb'], | |
| 'cloud': ['aws', 'azure', 'gcp', 'docker', 'kubernetes', 'terraform', 'jenkins', 'ci/cd', 'devops', 'microservices'], | |
| 'ui_ux_design': ['figma', 'sketch', 'adobe xd', 'photoshop', 'illustrator', 'wireframing', 'prototyping', 'user research', 'usability testing', 'interaction design', 'visual design', 'design thinking', 'user journey', 'persona', 'a/b testing'], | |
| 'business_analysis': ['business analysis', 'requirements gathering', 'stakeholder management', 'process mapping', 'gap analysis', 'user stories', 'acceptance criteria', 'brd', 'frd', 'visio', 'lucidchart', 'jira', 'confluence', 'agile', 'scrum', 'waterfall'], | |
| 'marketing': ['digital marketing', 'content marketing', 'social media marketing', 'seo', 'sem', 'ppc', 'google ads', 'facebook ads', 'email marketing', 'marketing automation', 'analytics', 'google analytics', 'hubspot', 'salesforce', 'brand management', 'campaign management'], | |
| 'consultancy': ['strategic planning', 'business strategy', 'change management', 'project management', 'stakeholder engagement', 'process improvement', 'risk assessment', 'financial analysis', 'market research', 'competitive analysis', 'presentation skills', 'client management'], | |
| 'ai_ml_engineering': ['artificial intelligence', 'machine learning', 'deep learning', 'neural networks', 'nlp', 'computer vision', 'tensorflow', 'pytorch', 'keras', 'opencv', 'transformers', 'bert', 'gpt', 'llm', 'mlops', 'model deployment', 'feature engineering', 'hyperparameter tuning'], | |
| 'soft_skills': ['leadership', 'teamwork', 'communication', 'problem solving', 'project management', 'collaboration', 'analytical', 'creative'] | |
| } | |
| # Fixed domain indicators with better separation and priority scoring | |
| self.domain_indicators = { | |
| 'web_development': { | |
| 'high_priority': ['web developer', 'frontend developer', 'backend developer', 'full stack developer', 'full-stack developer', 'web development', 'frontend development', 'backend development', 'fullstack'], | |
| 'medium_priority': ['web', 'frontend', 'backend', 'full stack', 'website development', 'web application development', 'web app', 'spa', 'single page application'], | |
| 'low_priority': ['html', 'css', 'javascript', 'react', 'vue', 'angular', 'node.js', 'express', 'django', 'flask', 'responsive design'] | |
| }, | |
| 'ui_ux_design': { | |
| 'high_priority': ['ui designer', 'ux designer', 'ui/ux designer', 'product designer', 'user experience designer', 'user interface designer', 'design lead', 'visual designer'], | |
| 'medium_priority': ['ui design', 'ux design', 'user experience', 'user interface', 'interaction design', 'visual design', 'product design'], | |
| 'low_priority': ['figma', 'sketch', 'adobe xd', 'wireframing', 'prototyping', 'user research', 'usability testing'] | |
| }, | |
| 'mobile_development': { | |
| 'high_priority': ['mobile developer', 'android developer', 'ios developer', 'mobile app developer', 'app developer'], | |
| 'medium_priority': ['mobile', 'android', 'ios', 'app development', 'mobile application', 'cross-platform'], | |
| 'low_priority': ['react native', 'flutter', 'swift', 'kotlin', 'xamarin'] | |
| }, | |
| 'data_science': { | |
| 'high_priority': ['data scientist', 'data analyst', 'machine learning engineer', 'data engineer'], | |
| 'medium_priority': ['data science', 'machine learning', 'analytics', 'data analysis', 'ai', 'artificial intelligence'], | |
| 'low_priority': ['python', 'pandas', 'numpy', 'tensorflow', 'pytorch'] | |
| }, | |
| 'cybersecurity': { | |
| 'high_priority': ['security analyst', 'cybersecurity specialist', 'security engineer', 'penetration tester', 'security researcher'], | |
| 'medium_priority': ['security', 'malware', 'vulnerability', 'penetration', 'threat', 'exploit', 'cybersecurity', 'infosec', 'reverse engineering'], | |
| 'low_priority': ['wireshark', 'burp suite', 'metasploit', 'nmap'] | |
| }, | |
| 'devops': { | |
| 'high_priority': ['devops engineer', 'site reliability engineer', 'infrastructure engineer', 'cloud engineer'], | |
| 'medium_priority': ['devops', 'infrastructure', 'deployment', 'ci/cd', 'automation', 'cloud'], | |
| 'low_priority': ['docker', 'kubernetes', 'terraform', 'jenkins'] | |
| }, | |
| 'game_development': { | |
| 'high_priority': ['game developer', 'game programmer', 'unity developer', 'unreal developer'], | |
| 'medium_priority': ['game', 'unity', 'unreal', 'gaming', 'game development', '3d', 'graphics'], | |
| 'low_priority': ['c#', 'c++', 'opengl', 'directx'] | |
| }, | |
| 'business_analysis': { | |
| 'high_priority': ['business analyst', 'systems analyst', 'functional analyst', 'requirements analyst'], | |
| 'medium_priority': ['business analysis', 'requirements', 'stakeholder', 'process', 'analyst', 'functional requirements', 'business requirements'], | |
| 'low_priority': ['jira', 'confluence', 'visio', 'lucidchart'] | |
| }, | |
| 'marketing': { | |
| 'high_priority': ['marketing manager', 'digital marketing specialist', 'marketing analyst', 'content marketer'], | |
| 'medium_priority': ['marketing', 'digital marketing', 'content marketing', 'social media', 'seo', 'brand', 'campaign', 'advertising', 'promotion', 'market research'], | |
| 'low_priority': ['google ads', 'facebook ads', 'hubspot', 'salesforce'] | |
| }, | |
| 'consultancy': { | |
| 'high_priority': ['consultant', 'management consultant', 'strategy consultant', 'business consultant'], | |
| 'medium_priority': ['consulting', 'advisory', 'strategy', 'strategic', 'transformation', 'change management', 'business consulting', 'management consulting'], | |
| 'low_priority': ['powerpoint', 'excel', 'presentation'] | |
| }, | |
| 'ai_ml_engineering': { | |
| 'high_priority': ['ai engineer', 'ml engineer', 'machine learning engineer', 'ai specialist', 'nlp engineer'], | |
| 'medium_priority': ['artificial intelligence', 'deep learning', 'neural networks', 'nlp engineer', 'computer vision', 'mlops'], | |
| 'low_priority': ['tensorflow', 'pytorch', 'keras', 'opencv'] | |
| } | |
| } | |
| self.education_keywords = ['bachelor', 'master', 'phd', 'degree', 'university', 'college', 'education', 'graduated'] | |
| self.certification_keywords = ['certified', 'certification', 'certificate', 'licensed', 'accredited'] | |
| self.project_keywords = ['project', 'developed', 'built', 'created', 'implemented', 'designed'] | |
| # Extended education patterns for undergraduates | |
| self.education_patterns = { | |
| 'undergraduate': ['undergraduate', 'pursuing', 'currently enrolled', 'final year', 'third year', 'fourth year', 'sophomore', 'junior', 'senior'], | |
| 'year_indicators': ['first year', 'second year', 'third year', 'fourth year', 'final year', 'sophomore', 'junior', 'senior'], | |
| 'degree_types': ['bachelor', 'bs', 'ba', 'btech', 'bsc', 'be', 'master', 'ms', 'ma', 'mtech', 'msc', 'phd', 'doctorate', 'mba', 'bba', 'bfa', 'mfa'] | |
| } | |
| # Soft skills inference from interests and activities | |
| self.interest_skill_mapping = { | |
| 'creativity': ['art', 'drawing', 'painting', 'design', 'photography', 'music', 'writing', 'creative', 'sketch'], | |
| 'leadership': ['captain', 'president', 'head', 'leader', 'coordinator', 'organizer', 'mentor', 'ncc', 'scouts'], | |
| 'teamwork': ['team', 'collaboration', 'group projects', 'sports', 'football', 'basketball', 'cricket', 'volleyball'], | |
| 'dedication': ['marathon', 'athletics', 'gym', 'fitness', 'ncc', 'volunteer', 'community service', 'consistent'], | |
| 'analytical': ['chess', 'puzzle', 'mathematics', 'strategy', 'analysis', 'research', 'debate'], | |
| 'communication': ['debate', 'public speaking', 'presentation', 'writing', 'blog', 'theater', 'drama'], | |
| 'adaptability': ['travel', 'different cultures', 'international', 'languages', 'diverse'], | |
| 'persistence': ['marathon', 'long distance', 'endurance', 'consistent', 'regular', 'discipline'] | |
| } | |
| # Project category patterns for better classification | |
| self.project_categories = { | |
| 'web_development': [ | |
| 'website', 'web app', 'web application', 'e-commerce', 'blog', 'portfolio', 'dashboard', | |
| 'frontend', 'backend', 'full stack', 'responsive', 'landing page', 'cms', | |
| 'online store', 'booking system', 'social media', 'chat app', 'forum' | |
| ], | |
| 'mobile_development': [ | |
| 'mobile app', 'android app', 'ios app', 'flutter app', 'react native', 'mobile application', | |
| 'app development', 'cross-platform', 'native app', 'hybrid app', 'mobile game' | |
| ], | |
| 'data_science': [ | |
| 'machine learning', 'data analysis', 'prediction model', 'recommendation system', | |
| 'data visualization', 'analytics', 'ai model', 'neural network', 'classification', | |
| 'regression', 'clustering', 'sentiment analysis', 'nlp', 'computer vision' | |
| ], | |
| 'cybersecurity': [ | |
| 'security tool', 'vulnerability scanner', 'penetration testing', 'malware analysis', | |
| 'encryption', 'security audit', 'threat detection', 'firewall', 'intrusion detection', | |
| 'security framework', 'ethical hacking', 'forensics' | |
| ], | |
| 'game_development': [ | |
| 'game', 'unity', 'unreal', '2d game', '3d game', 'mobile game', 'web game', | |
| 'game engine', 'graphics', 'animation', 'gameplay', 'level design' | |
| ], | |
| 'devops': [ | |
| 'ci/cd', 'deployment', 'automation', 'infrastructure', 'monitoring', 'containerization', | |
| 'orchestration', 'pipeline', 'cloud deployment', 'server management' | |
| ], | |
| 'desktop_application': [ | |
| 'desktop app', 'gui application', 'desktop software', 'system tool', 'utility', | |
| 'desktop game', 'productivity tool', 'file manager', 'text editor' | |
| ], | |
| 'api_backend': [ | |
| 'api', 'rest api', 'backend service', 'microservice', 'web service', 'server', | |
| 'database integration', 'authentication system', 'payment gateway' | |
| ], | |
| 'ui_ux_design': [ | |
| 'ui design', 'ux design', 'user interface', 'user experience', 'wireframe', 'prototype', | |
| 'mockup', 'design system', 'user research', 'usability testing', 'interaction design', | |
| 'visual design', 'app design', 'website design' | |
| ], | |
| 'business_analysis': [ | |
| 'business analysis', 'requirements gathering', 'process mapping', 'workflow design', | |
| 'business process', 'system analysis', 'gap analysis', 'stakeholder analysis', | |
| 'business requirements', 'functional requirements' | |
| ], | |
| 'marketing': [ | |
| 'marketing campaign', 'digital marketing', 'social media campaign', 'content strategy', | |
| 'seo optimization', 'brand campaign', 'market research', 'customer analysis', | |
| 'marketing automation', 'email campaign' | |
| ], | |
| 'ai_ml_engineering': [ | |
| 'ai system', 'ml pipeline', 'deep learning model', 'neural network', 'nlp system', | |
| 'computer vision', 'recommendation engine', 'chatbot', 'ai application', | |
| 'model deployment', 'mlops', 'feature engineering' | |
| ] | |
| } | |
| def analyze_cv(self, cv_text: str, job_description: str) -> Dict[str, Any]: | |
| """ | |
| Analyze CV against job description using Gemini AI | |
| """ | |
| try: | |
| prompt = f"""You are a smart and unbiased AI CV screening assistant. Your task is to evaluate how well a candidate's resume (CV) matches a job description. The job description may include one or more roles and may contain responsibilities, expectations, and skill requirements. | |
| Carefully review both the CV and the Job Description, and provide the output as a **valid JSON object** with the following keys: | |
| 1. **reasoning** (string): Provide a concise but insightful explanation of how well the candidate matches the job requirements — mention key matching points like role alignment, experience, and relevant technologies. | |
| 2. **skills_available** (array of 6 or fewer strings): List up to 6 skills or competencies from the CV that strongly align with the job description. | |
| 3. **missing** (array of 6 or fewer strings): List up to 6 important skills, experiences, or qualifications the candidate lacks based on the job description. If nothing is missing, return a single string in the array: "You are good to go". | |
| CV: | |
| \"\"\" | |
| {cv_text} | |
| \"\"\" | |
| Job Description: | |
| \"\"\" | |
| {job_description} | |
| \"\"\" | |
| """ | |
| model = genai.GenerativeModel('gemini-2.0-flash-exp') | |
| response = model.generate_content(prompt) | |
| # Extract JSON from response | |
| text = response.text | |
| json_start = text.find("{") | |
| json_end = text.rfind("}") + 1 | |
| if json_start != -1 and json_end != -1: | |
| json_string = text[json_start:json_end] | |
| parsed_result = json.loads(json_string) | |
| return {"success": True, "result": parsed_result} | |
| else: | |
| return {"success": False, "message": "Could not parse JSON response"} | |
| except Exception as e: | |
| print(f'Error analyzing CV: {e}') | |
| return {"success": False, "message": f"Error: {str(e)}"} | |
| def format_analysis_output(self, analysis_result: Dict[str, Any]) -> str: | |
| """ | |
| Format the analysis result for display in Gradio | |
| """ | |
| if not analysis_result.get("success"): | |
| return f"❌ **Error:** {analysis_result.get('message', 'Unknown error')}" | |
| result = analysis_result["result"] | |
| output = "## 📊 **AI-Powered CV Analysis**\n\n" | |
| # Reasoning section | |
| output += "### 🔍 **Analysis & Reasoning**\n" | |
| output += f"{result.get('reasoning', 'No reasoning provided')}\n\n" | |
| # Skills available | |
| output += "### ✅ **Matching Skills Found**\n" | |
| skills = result.get('skills_available', []) | |
| if skills: | |
| for skill in skills: | |
| output += f"• {skill}\n" | |
| else: | |
| output += "• No matching skills identified\n" | |
| output += "\n" | |
| # Missing skills | |
| output += "### ⚠️ **Areas for Improvement**\n" | |
| missing = result.get('missing', []) | |
| if missing: | |
| if len(missing) == 1 and missing[0] == "You are good to go": | |
| output += "🎉 **Excellent! You are good to go!**\n" | |
| else: | |
| for item in missing: | |
| output += f"• {item}\n" | |
| else: | |
| output += "• No gaps identified\n" | |
| return output | |
| def extract_text_from_pdf(self, pdf_file): | |
| """Extract text from PDF file""" | |
| try: | |
| pdf_reader = PyPDF2.PdfReader(pdf_file) | |
| text = "" | |
| for page in pdf_reader.pages: | |
| text += page.extract_text() + "\n" | |
| return text.strip() | |
| except Exception as e: | |
| raise Exception(f"Error reading PDF: {str(e)}") | |
| def extract_text_from_docx(self, docx_file): | |
| """Extract text from DOCX file""" | |
| try: | |
| doc = docx.Document(docx_file) | |
| text = "" | |
| for paragraph in doc.paragraphs: | |
| text += paragraph.text + "\n" | |
| return text.strip() | |
| except Exception as e: | |
| raise Exception(f"Error reading DOCX: {str(e)}") | |
| def extract_text_from_file(self, file): | |
| """Extract text from uploaded file (PDF or DOCX)""" | |
| if file is None: | |
| return "" | |
| file_path = Path(file) | |
| file_extension = file_path.suffix.lower() | |
| try: | |
| if file_extension == '.pdf': | |
| return self.extract_text_from_pdf(file) | |
| elif file_extension in ['.docx', '.doc']: | |
| return self.extract_text_from_docx(file) | |
| else: | |
| raise Exception(f"Unsupported file format: {file_extension}. Please upload PDF or DOCX files.") | |
| except Exception as e: | |
| raise Exception(f"Error processing file: {str(e)}") | |
| def preprocess_text(self, text): | |
| """Clean and preprocess text""" | |
| # Convert to lowercase | |
| text = text.lower() | |
| # Remove extra whitespace | |
| text = re.sub(r'\s+', ' ', text) | |
| # Remove special characters but keep important ones | |
| text = re.sub(r'[^\w\s\-\+\#\.]', ' ', text) | |
| return text.strip() | |
| def extract_skills_from_text(self, text, domain=None): | |
| """Extract skills from text based on domain""" | |
| text = self.preprocess_text(text) | |
| found_skills = [] | |
| # If domain is specified, prioritize skills from that domain | |
| if domain and domain in self.skill_categories: | |
| domain_skills = self.skill_categories[domain] | |
| for skill in domain_skills: | |
| if skill.lower() in text: | |
| found_skills.append(skill) | |
| # Also check all skill categories | |
| for category, skills in self.skill_categories.items(): | |
| for skill in skills: | |
| if skill.lower() in text and skill not in found_skills: | |
| found_skills.append(skill) | |
| return list(set(found_skills)) | |
| def detect_domain(self, text): | |
| """Detect the primary domain/field from text""" | |
| text = self.preprocess_text(text) | |
| domain_scores = {} | |
| for domain, priorities in self.domain_indicators.items(): | |
| score = 0 | |
| # High priority keywords | |
| for keyword in priorities['high_priority']: | |
| if keyword in text: | |
| score += 3 | |
| # Medium priority keywords | |
| for keyword in priorities['medium_priority']: | |
| if keyword in text: | |
| score += 2 | |
| # Low priority keywords | |
| for keyword in priorities['low_priority']: | |
| if keyword in text: | |
| score += 1 | |
| domain_scores[domain] = score | |
| # Return the domain with highest score | |
| if domain_scores: | |
| return max(domain_scores, key=domain_scores.get) | |
| return None | |
| def calculate_relevant_skills_score(self, job_description, resume): | |
| """Calculate relevant skills score""" | |
| # Detect domain from job description | |
| job_domain = self.detect_domain(job_description) | |
| # Extract skills from both texts | |
| job_skills = self.extract_skills_from_text(job_description, job_domain) | |
| resume_skills = self.extract_skills_from_text(resume, job_domain) | |
| if not job_skills: | |
| return 50 # Default score if no skills detected in job description | |
| # Calculate overlap | |
| matching_skills = set(job_skills) & set(resume_skills) | |
| skill_match_ratio = len(matching_skills) / len(job_skills) | |
| # Bonus for domain-specific skills | |
| domain_bonus = 0 | |
| if job_domain and job_domain in self.skill_categories: | |
| domain_skills = self.skill_categories[job_domain] | |
| domain_matches = [skill for skill in matching_skills if skill in domain_skills] | |
| domain_bonus = min(15, len(domain_matches) * 3) | |
| # Calculate base score | |
| base_score = min(85, skill_match_ratio * 100) | |
| final_score = min(100, base_score + domain_bonus) | |
| return final_score | |
| def extract_experience_years(self, text): | |
| """Extract years of experience from text""" | |
| text = self.preprocess_text(text) | |
| # Patterns for experience extraction | |
| patterns = [ | |
| r'(\d+)\+?\s*years?\s*(?:of\s*)?experience', | |
| r'(\d+)\+?\s*years?\s*(?:of\s*)?(?:work\s*)?experience', | |
| r'experience\s*(?:of\s*)?(\d+)\+?\s*years?', | |
| r'(\d+)\+?\s*years?\s*(?:in|of|with)', | |
| r'over\s*(\d+)\s*years?', | |
| r'more\s*than\s*(\d+)\s*years?' | |
| ] | |
| years = [] | |
| for pattern in patterns: | |
| matches = re.findall(pattern, text) | |
| years.extend([int(match) for match in matches]) | |
| # Also look for date ranges in experience section | |
| date_patterns = [ | |
| r'(\d{4})\s*-\s*(\d{4})', | |
| r'(\d{4})\s*to\s*(\d{4})', | |
| r'(\d{4})\s*–\s*(\d{4})' | |
| ] | |
| current_year = 2024 | |
| for pattern in date_patterns: | |
| matches = re.findall(pattern, text) | |
| for start, end in matches: | |
| start_year = int(start) | |
| end_year = int(end) if end != 'present' else current_year | |
| if end_year > start_year: | |
| years.append(end_year - start_year) | |
| return max(years) if years else 0 | |
| def calculate_work_experience_score(self, job_description, resume): | |
| """Calculate work experience score""" | |
| # Extract required experience from job description | |
| job_experience = self.extract_experience_years(job_description) | |
| resume_experience = self.extract_experience_years(resume) | |
| # Look for experience-related keywords in resume | |
| experience_keywords = ['experience', 'worked', 'employed', 'position', 'role', 'job', 'internship', 'intern'] | |
| resume_lower = resume.lower() | |
| experience_mentions = sum(1 for keyword in experience_keywords if keyword in resume_lower) | |
| # Calculate score based on experience match | |
| if job_experience == 0: | |
| # If no specific experience required, base on mentions | |
| return min(80, 40 + experience_mentions * 8) | |
| if resume_experience >= job_experience: | |
| return min(100, 80 + (resume_experience - job_experience) * 2) | |
| elif resume_experience >= job_experience * 0.7: | |
| return 70 | |
| elif resume_experience >= job_experience * 0.5: | |
| return 60 | |
| else: | |
| return max(30, 30 + experience_mentions * 5) | |
| def calculate_education_score(self, job_description, resume): | |
| """Calculate education score""" | |
| resume_lower = resume.lower() | |
| job_lower = job_description.lower() | |
| # Check for degree types | |
| degree_score = 0 | |
| for degree in self.education_patterns['degree_types']: | |
| if degree in resume_lower: | |
| degree_score += 20 | |
| break | |
| # Check for education keywords | |
| education_mentions = sum(1 for keyword in self.education_keywords if keyword in resume_lower) | |
| education_score = min(30, education_mentions * 10) | |
| # Check for undergraduate patterns | |
| undergraduate_score = 0 | |
| for pattern in self.education_patterns['undergraduate']: | |
| if pattern in resume_lower: | |
| undergraduate_score = 15 | |
| break | |
| # Year indicators | |
| year_score = 0 | |
| for year in self.education_patterns['year_indicators']: | |
| if year in resume_lower: | |
| year_score = 10 | |
| break | |
| # Bonus for relevant field | |
| field_bonus = 0 | |
| domain = self.detect_domain(job_description) | |
| if domain: | |
| domain_keywords = [domain.replace('_', ' '), domain.replace('_', '')] | |
| for keyword in domain_keywords: | |
| if keyword in resume_lower: | |
| field_bonus = 20 | |
| break | |
| total_score = degree_score + education_score + undergraduate_score + year_score + field_bonus | |
| return min(100, max(40, total_score)) | |
| def calculate_certifications_score(self, job_description, resume): | |
| """Calculate certifications score""" | |
| resume_lower = resume.lower() | |
| # Check for certification keywords | |
| cert_mentions = sum(1 for keyword in self.certification_keywords if keyword in resume_lower) | |
| # Look for specific certification patterns | |
| cert_patterns = [ | |
| r'certified\s+\w+', | |
| r'\w+\s+certification', | |
| r'\w+\s+certificate', | |
| r'licensed\s+\w+', | |
| r'accredited\s+\w+' | |
| ] | |
| pattern_matches = 0 | |
| for pattern in cert_patterns: | |
| if re.search(pattern, resume_lower): | |
| pattern_matches += 1 | |
| # Domain-specific certifications | |
| domain = self.detect_domain(job_description) | |
| domain_cert_bonus = 0 | |
| if domain == 'cybersecurity': | |
| cyber_certs = ['cissp', 'ceh', 'oscp', 'comptia', 'security+'] | |
| for cert in cyber_certs: | |
| if cert in resume_lower: | |
| domain_cert_bonus += 15 | |
| elif domain == 'cloud': | |
| cloud_certs = ['aws', 'azure', 'gcp', 'cloud practitioner'] | |
| for cert in cloud_certs: | |
| if cert in resume_lower: | |
| domain_cert_bonus += 15 | |
| base_score = min(60, cert_mentions * 15 + pattern_matches * 10) | |
| total_score = min(100, base_score + domain_cert_bonus) | |
| return max(40, total_score) if cert_mentions > 0 or pattern_matches > 0 else 40 | |
| def categorize_projects(self, project_text): | |
| """Categorize projects based on content""" | |
| project_text = self.preprocess_text(project_text) | |
| categories = [] | |
| for category, keywords in self.project_categories.items(): | |
| for keyword in keywords: | |
| if keyword in project_text: | |
| categories.append(category) | |
| break | |
| return categories | |
| def calculate_projects_score(self, job_description, resume): | |
| """Calculate projects score""" | |
| resume_lower = resume.lower() | |
| # Extract project mentions | |
| project_mentions = sum(1 for keyword in self.project_keywords if keyword in resume_lower) | |
| # Look for project sections | |
| project_section_indicators = ['projects', 'personal projects', 'academic projects', 'work projects'] | |
| has_project_section = any(indicator in resume_lower for indicator in project_section_indicators) | |
| # Categorize projects | |
| project_categories = self.categorize_projects(resume) | |
| job_domain = self.detect_domain(job_description) | |
| # Calculate relevance | |
| relevance_bonus = 0 | |
| if job_domain and job_domain in project_categories: | |
| relevance_bonus = 25 | |
| # Calculate base score | |
| base_score = min(50, project_mentions * 8) | |
| section_bonus = 20 if has_project_section else 0 | |
| category_bonus = min(15, len(project_categories) * 3) | |
| total_score = base_score + section_bonus + category_bonus + relevance_bonus | |
| return min(100, max(30, total_score)) | |
| def calculate_keywords_match_score(self, job_description, resume): | |
| """Calculate keyword matching score using semantic similarity""" | |
| try: | |
| # Preprocess texts | |
| job_text = self.preprocess_text(job_description) | |
| resume_text = self.preprocess_text(resume) | |
| # Get embeddings | |
| job_embedding = self.sentence_model.encode([job_text]) | |
| resume_embedding = self.sentence_model.encode([resume_text]) | |
| # Calculate cosine similarity | |
| similarity = cosine_similarity(job_embedding, resume_embedding)[0][0] | |
| # Convert to percentage | |
| similarity_score = similarity * 100 | |
| # Add keyword overlap bonus | |
| job_words = set(job_text.split()) | |
| resume_words = set(resume_text.split()) | |
| # Filter out common words | |
| common_words = {'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'can', 'must', 'shall', 'a', 'an', 'this', 'that', 'these', 'those'} | |
| job_words = job_words - common_words | |
| resume_words = resume_words - common_words | |
| if job_words: | |
| overlap = len(job_words & resume_words) / len(job_words) | |
| overlap_bonus = overlap * 20 | |
| else: | |
| overlap_bonus = 0 | |
| final_score = min(100, similarity_score + overlap_bonus) | |
| return max(30, final_score) | |
| except Exception as e: | |
| print(f"Error in keyword matching: {e}") | |
| # Fallback to simple word matching | |
| job_words = set(job_description.lower().split()) | |
| resume_words = set(resume.lower().split()) | |
| if job_words: | |
| overlap = len(job_words & resume_words) / len(job_words) | |
| return min(100, max(30, overlap * 100)) | |
| return 50 | |
| def calculate_tools_tech_score(self, job_description, resume): | |
| """Calculate tools and technology score""" | |
| # Extract tools and technologies from both texts | |
| job_tools = self.extract_skills_from_text(job_description) | |
| resume_tools = self.extract_skills_from_text(resume) | |
| # Focus on technical skills | |
| technical_categories = ['programming', 'databases', 'cloud', 'web_development', 'mobile_development', 'data_science', 'cybersecurity', 'ai_ml_engineering'] | |
| job_tech_skills = [] | |
| resume_tech_skills = [] | |
| for category in technical_categories: | |
| if category in self.skill_categories: | |
| category_skills = self.skill_categories[category] | |
| job_tech_skills.extend([skill for skill in job_tools if skill in category_skills]) | |
| resume_tech_skills.extend([skill for skill in resume_tools if skill in category_skills]) | |
| if not job_tech_skills: | |
| return 60 # Default score if no technical skills in job description | |
| # Calculate overlap | |
| matching_tools = set(job_tech_skills) & set(resume_tech_skills) | |
| tool_match_ratio = len(matching_tools) / len(job_tech_skills) | |
| # Bonus for having more tools than required | |
| extra_tools_bonus = min(15, max(0, len(resume_tech_skills) - len(job_tech_skills)) * 2) | |
| base_score = tool_match_ratio * 85 | |
| final_score = min(100, base_score + extra_tools_bonus) | |
| return max(40, final_score) | |
| def infer_soft_skills(self, text): | |
| """Infer soft skills from interests and activities""" | |
| text = self.preprocess_text(text) | |
| inferred_skills = [] | |
| for skill, indicators in self.interest_skill_mapping.items(): | |
| for indicator in indicators: | |
| if indicator in text: | |
| inferred_skills.append(skill) | |
| break | |
| return inferred_skills | |
| def calculate_soft_skills_score(self, job_description, resume): | |
| """Calculate soft skills score""" | |
| # Direct soft skills from skill categories | |
| job_soft_skills = [skill for skill in self.skill_categories['soft_skills'] if skill in job_description.lower()] | |
| resume_soft_skills = [skill for skill in self.skill_categories['soft_skills'] if skill in resume.lower()] | |
| # Inferred soft skills from activities and interests | |
| inferred_skills = self.infer_soft_skills(resume) | |
| # Combine direct and inferred skills | |
| all_resume_soft_skills = list(set(resume_soft_skills + inferred_skills)) | |
| if not job_soft_skills: | |
| # If no specific soft skills mentioned in job, give credit for having any | |
| return min(80, 50 + len(all_resume_soft_skills) * 5) | |
| # Calculate overlap | |
| matching_soft_skills = set(job_soft_skills) & set(all_resume_soft_skills) | |
| if job_soft_skills: | |
| soft_skill_ratio = len(matching_soft_skills) / len(job_soft_skills) | |
| else: | |
| soft_skill_ratio = 0.6 # Default ratio | |
| # Bonus for having diverse soft skills | |
| diversity_bonus = min(20, len(all_resume_soft_skills) * 3) | |
| base_score = soft_skill_ratio * 70 | |
| final_score = min(100, base_score + diversity_bonus) | |
| return max(50, final_score) | |
| def calculate_final_score(self, job_description, resume): | |
| """Calculate the weighted final score""" | |
| scores = {} | |
| # Calculate individual dimension scores | |
| scores['relevant_skills'] = self.calculate_relevant_skills_score(job_description, resume) | |
| scores['work_experience'] = self.calculate_work_experience_score(job_description, resume) | |
| scores['education'] = self.calculate_education_score(job_description, resume) | |
| scores['certifications'] = self.calculate_certifications_score(job_description, resume) | |
| scores['projects'] = self.calculate_projects_score(job_description, resume) | |
| scores['keywords_match'] = self.calculate_keywords_match_score(job_description, resume) | |
| scores['tools_tech'] = self.calculate_tools_tech_score(job_description, resume) | |
| scores['soft_skills'] = self.calculate_soft_skills_score(job_description, resume) | |
| # Calculate weighted final score | |
| final_score = sum(scores[dim] * self.weights[dim] for dim in scores) | |
| return final_score, scores | |
| # Initialize the scorer | |
| scorer = ATSScorer() | |
| def score_resume(job_description, resume_file, resume_text): | |
| """Enhanced function to score resume and provide AI analysis""" | |
| if not job_description.strip(): | |
| return "Please provide a job description.", "", "" | |
| # Determine resume source | |
| resume_content = "" | |
| if resume_file is not None: | |
| try: | |
| resume_content = scorer.extract_text_from_file(resume_file) | |
| if not resume_content.strip(): | |
| return "Could not extract text from the uploaded file. Please check the file format.", "", "" | |
| except Exception as e: | |
| return f"Error processing file: {str(e)}", "", "" | |
| elif resume_text.strip(): | |
| resume_content = resume_text.strip() | |
| else: | |
| return "Please provide either a resume file (PDF/DOCX) or paste resume text.", "", "" | |
| try: | |
| # Get ATS score | |
| final_score, dimension_scores = scorer.calculate_final_score(job_description, resume_content) | |
| # Get AI analysis | |
| analysis_result = scorer.analyze_cv(resume_content, job_description) | |
| ai_analysis = scorer.format_analysis_output(analysis_result) | |
| # Create ATS breakdown | |
| ats_breakdown = f""" | |
| ## Overall ATS Score: {final_score:.1f}/100 | |
| ### Dimension Breakdown: | |
| - **Relevant Skills** (25%): {dimension_scores['relevant_skills']:.1f}/100 | |
| - **Work Experience** (20%): {dimension_scores['work_experience']:.1f}/100 | |
| - **Education** (10%): {dimension_scores['education']:.1f}/100 | |
| - **Certifications & Courses** (7%): {dimension_scores['certifications']:.1f}/100 | |
| - **Projects** (10%): {dimension_scores['projects']:.1f}/100 | |
| - **Keywords Match** (10%): {dimension_scores['keywords_match']:.1f}/100 | |
| - **Tools & Technologies** (10%): {dimension_scores['tools_tech']:.1f}/100 | |
| - **Soft Skills Indicators** (8%): {dimension_scores['soft_skills']:.1f}/100 | |
| ### Score Interpretation: | |
| - **90-100**: Excellent match | |
| - **76-89**: Very good match | |
| - **56-75**: Good match | |
| - **45-55**: Fair match | |
| - **Below 40**: Poor match | |
| """ | |
| # Create score chart data | |
| chart_data = pd.DataFrame({ | |
| 'Dimension': [ | |
| 'Relevant Skills', 'Work Experience', 'Education', | |
| 'Certifications', 'Projects', 'Keywords Match', | |
| 'Tools & Tech', 'Soft Skills' | |
| ], | |
| 'Score': [ | |
| dimension_scores['relevant_skills'], | |
| dimension_scores['work_experience'], | |
| dimension_scores['education'], | |
| dimension_scores['certifications'], | |
| dimension_scores['projects'], | |
| dimension_scores['keywords_match'], | |
| dimension_scores['tools_tech'], | |
| dimension_scores['soft_skills'] | |
| ], | |
| 'Weight (%)': [25, 20, 10, 7, 10, 10, 10, 8] | |
| }) | |
| return ats_breakdown, ai_analysis, chart_data | |
| except Exception as e: | |
| return f"Error processing resume: {str(e)}", "", "" | |
| # Create Enhanced Gradio interface | |
| with gr.Blocks(title="Enhanced ATS Resume Scorer", theme=gr.themes.Soft()) as demo: | |
| gr.Markdown(""" | |
| # 🎯 Enhanced ATS Resume Scorer with AI Analysis | |
| This tool provides **dual analysis** of your resume: | |
| 1. **ATS Score** - Technical matching across 8 dimensions | |
| 2. **AI Analysis** - Intelligent insights and recommendations | |
| **📄 Resume Input:** Upload PDF/DOCX file OR paste text manually | |
| **📋 Job Description:** Paste as text | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| job_desc_input = gr.Textbox( | |
| label="📋 Job Description", | |
| placeholder="Paste the complete job description here...", | |
| lines=12, | |
| max_lines=20 | |
| ) | |
| with gr.Column(): | |
| gr.Markdown("### 📄 Resume Input") | |
| with gr.Tab("Upload File (PDF/DOCX)"): | |
| resume_file_input = gr.File( | |
| label="Upload Resume", | |
| file_types=[".pdf", ".docx", ".doc"], | |
| type="filepath" | |
| ) | |
| gr.Markdown("*Supported formats: PDF, DOCX, DOC*") | |
| with gr.Tab("Paste Text"): | |
| resume_text_input = gr.Textbox( | |
| label="Resume Text", | |
| placeholder="Or paste your resume text here...", | |
| lines=10, | |
| max_lines=15 | |
| ) | |
| score_btn = gr.Button("🚀 Analyze Resume", variant="primary", size="lg") | |
| with gr.Row(): | |
| with gr.Column(): | |
| ats_output = gr.Markdown(label="ATS Scoring Results") | |
| with gr.Column(): | |
| ai_output = gr.Markdown(label="AI Analysis Results") | |
| with gr.Row(): | |
| chart_output = gr.Dataframe( | |
| label="Dimension Scores", | |
| headers=['Dimension', 'Score', 'Weight (%)'], | |
| datatype=['str', 'number', 'number'] | |
| ) | |
| score_btn.click( | |
| fn=score_resume, | |
| inputs=[job_desc_input, resume_file_input, resume_text_input], | |
| outputs=[ats_output, ai_output, chart_output] | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch() | |