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()