Create app.py

app.py

@@ -0,0 +1,200 @@
+import os
+import gradio as gr
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+from fuzzywuzzy import fuzz
+from typing import List, Dict, Any
+import fitz  # PyMuPDF for PDF extraction
+import docx
+import re
+from pathlib import Path
+
+# Configuration class for constants
+class Config:
+    MAX_RESUMES = 10
+    MAX_LEADERSHIP_EXP = 10
+    MAX_MANAGEMENT_EXP = 10
+    MODEL_NAME = 'paraphrase-MiniLM-L6-v2'
+
+class ResumeAnalyzer:
+    def __init__(self):
+        self.config = Config()  # Initialize configuration
+        self._initialize_models()
+        self.required_skills = self._load_required_skills()
+        self.role_hierarchy = self._load_role_hierarchy()
+
+    def _initialize_models(self):
+        """Initialize the sentence transformer model."""
+        self.sentence_model = SentenceTransformer(self.config.MODEL_NAME)
+
+    def _load_required_skills(self) -> List[str]:
+        """Load the list of required skills for leadership and management roles."""
+        return [
+            "strategic planning", "team management", "project management",
+            "decision making", "communication", "leadership",
+            "conflict resolution", "delegation", "performance management",
+            "budget management", "resource allocation", "staff development",
+            "change management", "risk management", "problem solving",
+            "negotiation", "executive leadership", "organizational skills",
+            "business development", "stakeholder management", "collaboration",
+            "emotional intelligence", "coaching", "mentoring",
+            "time management", "cross-functional team leadership", "innovation",
+            "organizational culture", "team motivation", "employee engagement",
+            "organizational design", "continuous improvement",
+            "decision-making under pressure", "adaptability", "accountability",
+            "team building", "succession planning", "strategic partnerships",
+            "executive presence", "influencing", "visionary leadership"
+        ]
+    
+    def _load_role_hierarchy(self) -> Dict[str, int]:
+        """Load role hierarchy to calculate seniority scores."""
+        return {
+            "CEO": 5, "CIO": 5, "CFO": 5, "COO": 5,
+            "Director": 4, "VP": 4, "Head": 4,
+            "Manager": 3, "Senior": 3,
+            "Team Lead": 2, "Lead": 2,
+            "Junior": 1, "Associate": 1
+        }
+
+    def extract_text_from_file(self, file_path: str) -> str:
+        """Extract text from different file formats (PDF, DOCX, TXT)."""
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        ext = file_path.suffix.lower()
+        if ext == ".txt":
+            return file_path.read_text(encoding='utf-8')
+        elif ext == ".pdf":
+            return self._extract_text_from_pdf(file_path)
+        elif ext == ".docx":
+            return self._extract_text_from_docx(file_path)
+        else:
+            raise ValueError(f"Unsupported file format: {ext}")
+    
+    def _extract_text_from_pdf(self, file_path: Path) -> str:
+        """Extract text from a PDF using PyMuPDF."""
+        doc = fitz.open(file_path)
+        text = ""
+        for page in doc:
+            text += page.get_text("text")
+        return text
+
+    def _extract_text_from_docx(self, file_path: Path) -> str:
+        """Extract text from a DOCX file."""
+        doc = docx.Document(file_path)
+        text = ""
+        for para in doc.paragraphs:
+            text += para.text + "\n"
+        return text
+
+    def analyze_with_gemini(self, resume_text: str, job_desc: str) -> str:
+        """Simulated analysis with Gemini model (or other model)."""
+        # In a real-world scenario, this method would send data to an external model/API.
+        # Here, we'll simply return a placeholder analysis (mock-up for now).
+        return f"Candidate Name: John Doe\nEmail Address: john.doe@example.com\nContact Number: 123-456-7890\n" \
+               f"Skills: leadership, project management, team building\n" \
+               f"Team Leadership Experience (years): 5\nManagement Experience (years): 3\nManagement Skills: leadership, management, team building"
+
+    def extract_management_details(self, gemini_response: str) -> tuple:
+        """Extract leadership and management details from the analysis."""
+        patterns = {
+            'leadership': r"Team Leadership Experience \(years\):\s*(\d+)",
+            'management': r"Management Experience \(years\):\s*(\d+)",
+            'skills': r"Management Skills\s*[:\-]?\s*(.*?)(?=\n|$)"
+        }
+
+        matches = {
+            key: re.search(pattern, gemini_response)
+            for key, pattern in patterns.items()
+        }
+
+        leadership_years = int(matches['leadership'].group(1)) if matches['leadership'] else 0
+        management_years = int(matches['management'].group(1)) if matches['management'] else 0
+        skills = matches['skills'].group(1) if matches['skills'] else ""
+
+        return leadership_years, management_years, skills
+
+    def calculate_role_score(self, role_keywords: str) -> float:
+        """Calculate seniority score based on role keywords."""
+        seniority_score = 0
+        for keyword, score in self.role_hierarchy.items():
+            if fuzz.partial_ratio(keyword.lower(), role_keywords.lower()) > 80:
+                seniority_score = max(seniority_score, score)
+        return seniority_score
+
+    def calculate_advanced_match(self, leadership_years, management_years, skills, role_keywords) -> float:
+        """Calculate overall match percentage using weighted criteria."""
+        weights = {
+            'leadership': 0.35,
+            'management': 0.35,
+            'skills': 0.20,
+            'role': 0.10
+        }
+
+        leadership_score = min(leadership_years / self.config.MAX_LEADERSHIP_EXP, 1.0) * 100
+        management_score = min(management_years / self.config.MAX_MANAGEMENT_EXP, 1.0) * 100
+
+        role_score = self.calculate_role_score(role_keywords) * 20  # Scale to 100
+
+        skills_matched = sum(1 for skill in self.required_skills 
+                             if fuzz.partial_ratio(skill.lower(), skills.lower()) > 80)
+        skill_match_score = (skills_matched / len(self.required_skills)) * 100
+
+        overall_match = sum([
+            leadership_score * weights['leadership'],
+            management_score * weights['management'],
+            skill_match_score * weights['skills'],
+            role_score * weights['role']
+        ])
+        
+        return round(overall_match, 2)
+
+    def process_resume(self, resume, job_desc) -> Dict[str, Any]:
+        """Process a single resume and return analysis results."""
+        resume_text = self.extract_text_from_file(resume.name)
+        gemini_analysis = self.analyze_with_gemini(resume_text, job_desc)
+        leadership_years, management_years, skills = self.extract_management_details(gemini_analysis)
+        overall_match = self.calculate_advanced_match(leadership_years, management_years, skills, job_desc)
+        
+        return {
+            "Resume": resume.name,
+            "Leadership Experience": leadership_years,
+            "Management Experience": management_years,
+            "Skills": skills,
+            "Match Percentage": f"{overall_match}%"  # Match percentage formatted as a string with "%"
+        }
+
+# Gradio Interface function to handle multiple resumes and job description
+def process_uploaded_resumes(resume_files: list, job_desc: str):
+    """Process multiple uploaded resumes and compare them against a job description."""
+    results = []
+    for resume in resume_files:
+        result = analyzer.process_resume(resume, job_desc)
+        results.append(result)
+    return pd.DataFrame(results)
+
+# Create the Gradio interface
+def create_gradio_interface():
+    """Creates and launches a Gradio interface for the ResumeAnalyzer."""
+    resume_input = gr.inputs.File(label="Upload Resumes (PDF, DOCX, TXT)", type="file", multiple=True)
+    job_desc_input = gr.inputs.Textbox(label="Enter Job Description", lines=6)
+    output = gr.outputs.Dataframe(label="Resume Analysis Results")
+
+    interface = gr.Interface(
+        fn=process_uploaded_resumes,
+        inputs=[resume_input, job_desc_input],
+        outputs=[output],
+        title="Resume Match Analysis",
+        description="Upload resumes and provide a job description to see how well the resumes match the required skills, experience, and role.",
+        allow_flagging="never",  # Disable flagging (can be enabled if needed)
+    )
+
+    return interface
+
+# Initialize the ResumeAnalyzer and Gradio interface
+analyzer = ResumeAnalyzer()  # Initialize the ResumeAnalyzer
+gradio_interface = create_gradio_interface()  # Create Gradio interface
+
+# Launch the Gradio interface
+gradio_interface.launch(share=True)  # share=True for generating a public URL to share