1pip install openai PyPDF2 python-dotenv pandas openpyxl tiktoken

1import PyPDF2
2from pathlib import Path
3from typing import Dict, List
4import logging
5
6logging.basicConfig(level=logging.INFO)
7logger = logging.getLogger(__name__)
8
9class ResumeParser:
10    """Extract text from PDF resumes"""
11    
12    def __init__(self, resumes_folder: str):
13        self.resumes_folder = Path(resumes_folder)
14        
15    def extract_text_from_pdf(self, pdf_path: Path) -> str:
16        """Extract all text from a PDF file"""
17        try:
18            with open(pdf_path, 'rb') as file:
19                pdf_reader = PyPDF2.PdfReader(file)
20                text = ""
21                
22                for page in pdf_reader.pages:
23                    text += page.extract_text() + "\n"
24                
25                return text.strip()
26                
27        except Exception as e:
28            logger.error(f"Error extracting {pdf_path.name}: {e}")
29            return ""
30    
31    def process_all_resumes(self) -> Dict[str, str]:
32        """Process all PDF files in resumes folder"""
33        resumes = {}
34        pdf_files = list(self.resumes_folder.glob("*.pdf"))
35        
36        logger.info(f"Found {len(pdf_files)} resume(s)")
37        
38        for pdf_path in pdf_files:
39            logger.info(f"Processing: {pdf_path.name}")
40            text = self.extract_text_from_pdf(pdf_path)
41            
42            if text:
43                resumes[pdf_path.stem] = text  # Use filename without extension as key
44            else:
45                logger.warning(f"No text extracted from {pdf_path.name}")
46        
47        return resumes
48    
49    def get_resume_preview(self, text: str, max_chars: int = 500) -> str:
50        """Get preview of resume text for logging"""
51        return text[:max_chars] + "..." if len(text) > max_chars else text
52
53# Test the parser
54if __name__ == "__main__":
55    parser = ResumeParser("resumes")
56    resumes = parser.process_all_resumes()
57    
58    print(f"\nProcessed {len(resumes)} resumes")
59    for name, text in resumes.items():
60        print(f"\n{name}:")
61        print(parser.get_resume_preview(text, 200))

1python resume_parser.py

1import openai
2import os
3from dotenv import load_dotenv
4from typing import Dict, List
5import json
6import tiktoken
7
8load_dotenv()
9openai.api_key = os.getenv("OPENAI_API_KEY")
10
11class AIAnalyzer:
12    """Use ChatGPT to analyze resumes and extract structured data"""
13    
14    def __init__(self, model: str = "gpt-4o-mini"):
15        self.model = model
16        self.tokenizer = tiktoken.encoding_for_model(model)
17    
18    def count_tokens(self, text: str) -> int:
19        """Count tokens for cost estimation"""
20        return len(self.tokenizer.encode(text))
21    
22    def extract_candidate_info(self, resume_text: str) -> Dict:
23        """Extract structured information from resume"""
24        
25        prompt = f"""
26        Analyze this resume and extract the following information in JSON format:
27        
28        {{
29            "name": "Candidate's full name",
30            "email": "Email address",
31            "phone": "Phone number",
32            "years_of_experience": "Total years of professional experience (number)",
33            "current_title": "Most recent job title",
34            "skills": ["List", "of", "key", "technical", "skills"],
35            "education": ["Degrees earned with university names"],
36            "certifications": ["Professional certifications"],
37            "summary": "One paragraph summary of candidate's background and strengths"
38        }}
39        
40        Resume:
41        {resume_text[:4000]}
42        
43        Return ONLY valid JSON, no other text.
44        """
45        
46        try:
47            response = openai.chat.completions.create(
48                model=self.model,
49                messages=[
50                    {"role": "system", "content": "You are an expert recruiter extracting information from resumes. Return only valid JSON."},
51                    {"role": "user", "content": prompt}
52                ],
53                temperature=0.3,
54                max_tokens=1000
55            )
56            
57            result = response.choices[0].message.content.strip()
58            
59            # Remove markdown code blocks if present
60            if result.startswith("```json"):
61                result = result[7:]
62            if result.startswith("```"):
63                result = result[3:]
64            if result.endswith("```"):
65                result = result[:-3]
66            
67            return json.loads(result.strip())
68            
69        except Exception as e:
70            print(f"Error extracting candidate info: {e}")
71            return {}
72    
73    def score_candidate(self, resume_text: str, job_description: str) -> Dict:
74        """Score candidate against job requirements"""
75        
76        prompt = f"""
77        Job Description:
78        {job_description}
79        
80        Candidate Resume:
81        {resume_text[:4000]}
82        
83        Evaluate this candidate for the job. Provide scores (0-10) for:
84        1. Technical Skills Match
85        2. Experience Level Match
86        3. Education/Certifications Match
87        4. Overall Cultural/Role Fit
88        
89        Also provide:
90        - Key strengths (3-5 bullet points)
91        - Potential concerns (2-3 bullet points)
92        - Recommendation: "Strong Fit", "Good Fit", "Moderate Fit", or "Not a Fit"
93        
94        Return as JSON:
95        {{
96            "technical_skills_score": 0-10,
97            "experience_score": 0-10,
98            "education_score": 0-10,
99            "overall_fit_score": 0-10,
100            "strengths": ["strength1", "strength2", ...],
101            "concerns": ["concern1", "concern2", ...],
102            "recommendation": "Strong Fit/Good Fit/Moderate Fit/Not a Fit",
103            "reasoning": "2-3 sentence explanation"
104        }}
105        
106        Return ONLY valid JSON.
107        """
108        
109        try:
110            response = openai.chat.completions.create(
111                model=self.model,
112                messages=[
113                    {"role": "system", "content": "You are an expert recruiter evaluating candidates objectively. Return only valid JSON."},
114                    {"role": "user", "content": prompt}
115                ],
116                temperature=0.3,
117                max_tokens=800
118            )
119            
120            result = response.choices[0].message.content.strip()
121            
122            # Clean markdown
123            if result.startswith("```json"):
124                result = result[7:]
125            if result.startswith("```"):
126                result = result[3:]
127            if result.endswith("```"):
128                result = result[:-3]
129            
130            return json.loads(result.strip())
131            
132        except Exception as e:
133            print(f"Error scoring candidate: {e}")
134            return {}
135    
136    def estimate_cost(self, resume_count: int) -> float:
137        """Estimate API costs for processing resumes"""
138        # Rough estimate: 4000 input tokens + 800 output tokens per resume * 2 calls
139        tokens_per_resume = (4000 + 800) * 2
140        total_tokens = tokens_per_resume * resume_count
141        
142        # GPT-4o-mini pricing (as of 2026): ~$0.15 per 1M input tokens, $0.60 per 1M output
143        input_cost = (4000 * 2 * resume_count / 1_000_000) * 0.15
144        output_cost = (800 * 2 * resume_count / 1_000_000) * 0.60
145        
146        return round(input_cost + output_cost, 2)
147
148# Test the analyzer
149if __name__ == "__main__":
150    analyzer = AIAnalyzer()
151    
152    sample_resume = """
153    John Smith
154    john.smith@email.com | (555) 123-4567
155    
156    Senior Software Engineer with 8 years of experience in Python, Django, and React.
157    
158    EXPERIENCE:
159    Senior Software Engineer - Tech Corp (2020-Present)
160    - Led team of 5 developers building microservices architecture
161    - Reduced API response time by 60% through optimization
162    
163    Software Engineer - StartupXYZ (2016-2020)
164    - Built REST APIs using Python and Django
165    - Implemented CI/CD pipeline
166    
167    EDUCATION:
168    BS Computer Science - University of Technology (2016)
169    
170    SKILLS: Python, Django, React, PostgreSQL, Docker, Kubernetes, AWS
171    """
172    
173    job_desc = """
174    Looking for Senior Python Developer with 5+ years experience.
175    Must have: Python, Django, REST APIs, PostgreSQL, Docker
176    Nice to have: React, Kubernetes, AWS
177    """
178    
179    print("Extracting candidate info...")
180    info = analyzer.extract_candidate_info(sample_resume)
181    print(json.dumps(info, indent=2))
182    
183    print("\nScoring candidate...")
184    score = analyzer.score_candidate(sample_resume, job_desc)
185    print(json.dumps(score, indent=2))
186    
187    print(f"\nEstimated cost for 100 resumes: ${analyzer.estimate_cost(100)}")

1from typing import Dict, List, Set
2import re
3
4class RequirementMatcher:
5    """Match resume content against job requirements"""
6    
7    def __init__(self, required_skills: List[str], preferred_skills: List[str] = None):
8        self.required_skills = [skill.lower() for skill in required_skills]
9        self.preferred_skills = [skill.lower() for skill in (preferred_skills or [])]
10    
11    def extract_skills_from_text(self, text: str) -> Set[str]:
12        """Extract mentioned skills from resume text"""
13        text_lower = text.lower()
14        found_skills = set()
15        
16        # Check required skills
17        for skill in self.required_skills + self.preferred_skills:
18            # Use word boundaries to avoid partial matches
19            if re.search(rf'\b{re.escape(skill)}\b', text_lower):
20                found_skills.add(skill)
21        
22        return found_skills
23    
24    def calculate_skill_match(self, resume_text: str) -> Dict:
25        """Calculate skill match percentage"""
26        found_skills = self.extract_skills_from_text(resume_text)
27        
28        # Required skills match
29        required_found = [skill for skill in self.required_skills if skill in found_skills]
30        required_match_pct = (len(required_found) / len(self.required_skills) * 100) if self.required_skills else 100
31        
32        # Preferred skills match
33        preferred_found = [skill for skill in self.preferred_skills if skill in found_skills]
34        preferred_match_pct = (len(preferred_found) / len(self.preferred_skills) * 100) if self.preferred_skills else 0
35        
36        # Overall match (required skills weighted 70%, preferred 30%)
37        overall_match = (required_match_pct * 0.7) + (preferred_match_pct * 0.3)
38        
39        return {
40            "required_skills_matched": required_found,
41            "required_skills_missing": [s for s in self.required_skills if s not in found_skills],
42            "required_match_percentage": round(required_match_pct, 1),
43            "preferred_skills_matched": preferred_found,
44            "preferred_match_percentage": round(preferred_match_pct, 1),
45            "overall_match_percentage": round(overall_match, 1)
46        }
47    
48    def get_missing_skills(self, resume_text: str) -> List[str]:
49        """Get list of required skills not mentioned in resume"""
50        found_skills = self.extract_skills_from_text(resume_text)
51        return [skill for skill in self.required_skills if skill not in found_skills]
52
53# Test the matcher
54if __name__ == "__main__":
55    required = ["Python", "Django", "REST API", "PostgreSQL", "Docker"]
56    preferred = ["React", "Kubernetes", "AWS"]
57    
58    matcher = RequirementMatcher(required, preferred)
59    
60    sample_resume = """
61    Skills: Python, Django, PostgreSQL, Docker, JavaScript, Git
62    Experience building REST APIs and deploying with Docker.
63    """
64    
65    result = matcher.calculate_skill_match(sample_resume)
66    
67    print("Skill Match Results:")
68    print(f"Required Match: {result['required_match_percentage']}%")
69    print(f"Matched: {result['required_skills_matched']}")
70    print(f"Missing: {result['required_skills_missing']}")
71    print(f"\nPreferred Match: {result['preferred_match_percentage']}%")
72    print(f"Matched: {result['preferred_skills_matched']}")
73    print(f"\nOverall Match: {result['overall_match_percentage']}%")

1import os
2from pathlib import Path
3import pandas as pd
4from dotenv import load_dotenv
5from resume_parser import ResumeParser
6from ai_analyzer import AIAnalyzer
7from matcher import RequirementMatcher
8import time
9import logging
10
11logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
12logger = logging.getLogger(__name__)
13
14load_dotenv()
15
16class ResumeScanner:
17    """Main application orchestrator"""
18    
19    def __init__(self, resumes_folder: str, job_description: str, 
20                 required_skills: list, preferred_skills: list = None):
21        self.parser = ResumeParser(resumes_folder)
22        self.analyzer = AIAnalyzer()
23        self.matcher = RequirementMatcher(required_skills, preferred_skills)
24        self.job_description = job_description
25        self.results = []
26    
27    def process_resume(self, filename: str, resume_text: str) -> dict:
28        """Process a single resume through the pipeline"""
29        logger.info(f"Processing: {filename}")
30        
31        # Extract candidate information
32        logger.info("  → Extracting candidate info...")
33        candidate_info = self.analyzer.extract_candidate_info(resume_text)
34        
35        # Calculate skill match
36        logger.info("  → Matching skills...")
37        skill_match = self.matcher.calculate_skill_match(resume_text)
38        
39        # Score candidate
40        logger.info("  → Scoring candidate...")
41        scoring = self.analyzer.score_candidate(resume_text, self.job_description)
42        
43        # Combine all results
44        result = {
45            "filename": filename,
46            "name": candidate_info.get("name", "Unknown"),
47            "email": candidate_info.get("email", ""),
48            "phone": candidate_info.get("phone", ""),
49            "years_experience": candidate_info.get("years_of_experience", 0),
50            "current_title": candidate_info.get("current_title", ""),
51            "skills": ", ".join(candidate_info.get("skills", [])),
52            "education": " | ".join(candidate_info.get("education", [])),
53            "certifications": ", ".join(candidate_info.get("certifications", [])),
54            "summary": candidate_info.get("summary", ""),
55            
56            "required_skills_match_pct": skill_match["required_match_percentage"],
57            "preferred_skills_match_pct": skill_match["preferred_match_percentage"],
58            "overall_skill_match_pct": skill_match["overall_match_percentage"],
59            "missing_required_skills": ", ".join(skill_match["required_skills_missing"]),
60            
61            "technical_score": scoring.get("technical_skills_score", 0),
62            "experience_score": scoring.get("experience_score", 0),
63            "education_score": scoring.get("education_score", 0),
64            "overall_fit_score": scoring.get("overall_fit_score", 0),
65            "ai_recommendation": scoring.get("recommendation", ""),
66            "strengths": " | ".join(scoring.get("strengths", [])),
67            "concerns": " | ".join(scoring.get("concerns", [])),
68            "ai_reasoning": scoring.get("reasoning", ""),
69            
70            # Calculate composite score (weighted average)
71            "composite_score": round(
72                (skill_match["overall_match_percentage"] * 0.3) +
73                (scoring.get("technical_skills_score", 0) * 10 * 0.25) +
74                (scoring.get("experience_score", 0) * 10 * 0.25) +
75                (scoring.get("overall_fit_score", 0) * 10 * 0.20),
76                1
77            )
78        }
79        
80        return result
81    
82    def scan_all_resumes(self):
83        """Process all resumes and generate results"""
84        # Parse all resumes
85        logger.info("Step 1: Parsing resumes...")
86        resumes = self.parser.process_all_resumes()
87        
88        if not resumes:
89            logger.error("No resumes found to process")
90            return
91        
92        # Estimate cost
93        estimated_cost = self.analyzer.estimate_cost(len(resumes))
94        logger.info(f"Estimated API cost: ${estimated_cost}")
95        
96        # Process each resume
97        logger.info(f"\nStep 2: Analyzing {len(resumes)} resume(s)...")
98        
99        for filename, resume_text in resumes.items():
100            try:
101                result = self.process_resume(filename, resume_text)
102                self.results.append(result)
103                time.sleep(1)  # Rate limiting
104            except Exception as e:
105                logger.error(f"Error processing {filename}: {e}")
106        
107        # Sort by composite score
108        self.results.sort(key=lambda x: x["composite_score"], reverse=True)
109        
110        logger.info(f"\nStep 3: Ranking complete!")
111        self.print_summary()
112    
113    def print_summary(self):
114        """Print summary of results"""
115        print("\n" + "="*80)
116        print("RESUME SCANNING RESULTS")
117        print("="*80)
118        
119        for i, result in enumerate(self.results[:10], 1):  # Top 10
120            print(f"\n#{i} - {result['name']} ({result['filename']})")
121            print(f"   Composite Score: {result['composite_score']}/100")
122            print(f"   Skills Match: {result['overall_skill_match_pct']}%")
123            print(f"   AI Recommendation: {result['ai_recommendation']}")
124            print(f"   Email: {result['email']}")
125            print(f"   Summary: {result['summary'][:150]}...")
126    
127    def export_to_excel(self, output_file: str = "results.xlsx"):
128        """Export results to Excel"""
129        df = pd.DataFrame(self.results)
130        
131        # Reorder columns for better readability
132        column_order = [
133            "name", "email", "phone", "composite_score",
134            "ai_recommendation", "overall_skill_match_pct",
135            "technical_score", "experience_score", "education_score",
136            "years_experience", "current_title", "skills",
137            "missing_required_skills", "strengths", "concerns",
138            "ai_reasoning", "summary", "education", "certifications",
139            "filename"
140        ]
141        
142        df = df[column_order]
143        
144        # Create Excel writer with formatting
145        with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
146            df.to_excel(writer, sheet_name='Ranked Candidates', index=False)
147            
148            # Get workbook and worksheet
149            workbook = writer.book
150            worksheet = writer.sheets['Ranked Candidates']
151            
152            # Auto-adjust column widths
153            for column in worksheet.columns:
154                max_length = 0
155                column = [cell for cell in column]
156                for cell in column:
157                    try:
158                        if len(str(cell.value)) > max_length:
159                            max_length = len(cell.value)
160                    except:
161                        pass
162                adjusted_width = min(max_length + 2, 50)  # Cap at 50
163                worksheet.column_dimensions[column[0].column_letter].width = adjusted_width
164        
165        logger.info(f"\nResults exported to: {output_file}")
166
167# Run the scanner
168if __name__ == "__main__":
169    # Define job requirements
170    JOB_DESCRIPTION = """
171    We are looking for a Senior Python Developer to join our backend team.
172    
173    Requirements:
174    - 5+ years of professional software development experience
175    - Strong expertise in Python and Django
176    - Experience building and deploying REST APIs
177    - Proficiency with PostgreSQL and database design
178    - Experience with Docker and containerization
179    - Strong understanding of software design patterns
180    
181    Preferred:
182    - React or frontend experience
183    - Kubernetes and cloud platforms (AWS/Azure)
184    - Experience with microservices architecture
185    - CI/CD pipeline experience
186    
187    We value candidates who are collaborative, detail-oriented, and passionate
188    about writing clean, maintainable code.
189    """
190    
191    REQUIRED_SKILLS = [
192        "Python", "Django", "REST API", "PostgreSQL", "Docker"
193    ]
194    
195    PREFERRED_SKILLS = [
196        "React", "Kubernetes", "AWS", "Azure", "Microservices", "CI/CD"
197    ]
198    
199    # Create and run scanner
200    scanner = ResumeScanner(
201        resumes_folder="resumes",
202        job_description=JOB_DESCRIPTION,
203        required_skills=REQUIRED_SKILLS,
204        preferred_skills=PREFERRED_SKILLS
205    )
206    
207    scanner.scan_all_resumes()
208    scanner.export_to_excel("ranked_candidates.xlsx")
209    
210    print("\n✅ Resume scanning complete!")
211    print(f"✅ Results saved to: ranked_candidates.xlsx")
212    print(f"✅ Processed {len(scanner.results)} candidates")

1python main.py

1def detect_potential_bias(self, resume_text: str, candidate_info: dict) -> dict:
2    """Check for factors that might introduce bias"""
3    
4    prompt = f"""
5    Analyze this resume for information that might introduce unconscious bias:
6    
7    Resume: {resume_text[:2000]}
8    
9    Identify if the resume contains:
10    - Gender indicators
11    - Age indicators (graduation dates, years of experience suggesting age)
12    - Ethnicity/nationality indicators
13    - Photos or physical descriptions
14    - Geographic location that might trigger bias
15    
16    Return JSON:
17    {{
18        "contains_photo": true/false,
19        "gender_indicators": ["list of indicators found"],
20        "age_indicators": ["list of indicators"],
21        "bias_risk_level": "Low/Medium/High",
22        "recommendations": ["Remove X", "Anonymize Y"]
23    }}
24    """
25    
26    # Add to AIAnalyzer class

1from tqdm import tqdm
2
3def scan_all_resumes(self):
4    resumes = self.parser.process_all_resumes()
5    
6    # Add progress bar
7    for filename, resume_text in tqdm(resumes.items(), desc="Processing resumes"):
8        result = self.process_resume(filename, resume_text)
9        self.results.append(result)
10        time.sleep(1)

1import smtplib
2from email.mime.text import MIMEText
3from email.mime.multipart import MIMEMultipart
4
5def email_top_candidates(self, top_n: int = 10):
6    """Send email with top N candidates to hiring manager"""
7    
8    top_candidates = self.results[:top_n]
9    
10    # Create HTML email body
11    html = "<h2>Top Candidates for Review</h2><ul>"
12    for i, candidate in enumerate(top_candidates, 1):
13        html += f"""
14        <li>
15            <strong>#{i}: {candidate['name']}</strong> 
16            (Score: {candidate['composite_score']}/100)<br>
17            Email: {candidate['email']}<br>
18            Recommendation: {candidate['ai_recommendation']}<br>
19            Strengths: {candidate['strengths']}<br>
20        </li>
21        """
22    html += "</ul>"
23    
24    # Send email (configure SMTP settings)
25    # Implementation depends on your email provider

1import redis
2import json
3import hashlib
4
5class CachedAIAnalyzer(AIAnalyzer):
6    def __init__(self):
7        super().__init__()
8        self.cache = redis.Redis(host='localhost', port=6379, db=0)
9    
10    def extract_candidate_info(self, resume_text: str) -> dict:
11        # Create cache key from resume hash
12        cache_key = f"resume:{hashlib.md5(resume_text.encode()).hexdigest()}"
13        
14        # Check cache first
15        cached = self.cache.get(cache_key)
16        if cached:
17            return json.loads(cached)
18        
19        # If not cached, get from API
20        result = super().extract_candidate_info(resume_text)
21        
22        # Cache for 7 days
23        self.cache.setex(cache_key, 604800, json.dumps(result))
24        
25        return result

1class OptimizedAIAnalyzer(AIAnalyzer):
2    def __init__(self):
3        self.cheap_model = "gpt-4o-mini"  # For extraction
4        self.premium_model = "gpt-4o"  # For scoring
5    
6    def extract_candidate_info(self, resume_text: str) -> dict:
7        # Use cheap model for structured extraction
8        # (override with cheap_model)
9        pass
10    
11    def score_candidate(self, resume_text: str, job_desc: str) -> dict:
12        # Use premium model for nuanced evaluation
13        # (use premium_model for better reasoning)
14        pass

1def extract_batch(self, resumes: dict) -> list:
2    """Process multiple resumes in single API call"""
3    
4    # Combine up to 10 resumes per request
5    batch_size = 10
6    results = []
7    
8    for i in range(0, len(resumes), batch_size):
9        batch = list(resumes.items())[i:i+batch_size]
10        # Create combined prompt for batch processing
11        # Parse combined response
12    
13    return results

1def pre_filter_resumes(self, resumes: dict) -> dict:
2    """Quick keyword filter before expensive AI processing"""
3    
4    filtered = {}
5    
6    for filename, text in resumes.items():
7        # Quick keyword check
8        skill_match = self.matcher.calculate_skill_match(text)
9        
10        # Only process if meets minimum threshold
11        if skill_match["required_match_percentage"] >= 40:
12            filtered[filename] = text
13        else:
14            logger.info(f"Skipping {filename} - insufficient skill match")
15    
16    return filtered

1try:
2    import pytesseract
3    from pdf2image import convert_from_path
4    
5    def extract_text_from_pdf(self, pdf_path: Path) -> str:
6        # Try regular extraction first
7        text = super().extract_text_from_pdf(pdf_path)
8        
9        # If empty, try OCR
10        if not text or len(text) < 50:
11            logger.info(f"  → Performing OCR on {pdf_path.name}")
12            images = convert_from_path(pdf_path)
13            text = ""
14            for image in images:
15                text += pytesseract.image_to_string(image)
16        
17        return text
18except ImportError:
19    logger.warning("pytesseract not installed - OCR unavailable")

1def truncate_resume_intelligently(self, text: str, max_tokens: int = 4000) -> str:
2    """Keep most relevant parts of resume within token limit"""
3    
4    # Split into sections
5    sections = {
6        "contact": text[:500],  # Always keep contact info
7        "experience": "",
8        "education": "",
9        "skills": ""
10    }
11    
12    # Extract sections (improved logic needed)
13    # Prioritize: Skills > Recent Experience > Education
14    # Truncate oldest experience if needed
15    
16    return combined_text

1def extract_text(self, file_path: Path) -> str:
2    """Handle PDF, DOCX, and TXT formats"""
3    
4    if file_path.suffix == '.pdf':
5        return self.extract_text_from_pdf(file_path)
6    elif file_path.suffix == '.docx':
7        from docx import Document
8        doc = Document(file_path)
9        return "\n".join([para.text for para in doc.paragraphs])
10    elif file_path.suffix == '.txt':
11        with open(file_path, 'r', encoding='utf-8') as f:
12            return f.read()
13    else:
14        logger.warning(f"Unsupported format: {file_path.suffix}")
15        return ""

1# config.py
2import os
3from dotenv import load_dotenv
4
5load_dotenv()
6
7class Config:
8    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
9    RESUMES_FOLDER = os.getenv("RESUMES_FOLDER", "resumes")
10    OUTPUT_FOLDER = os.getenv("OUTPUT_FOLDER", "output")
11    LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
12    
13    # Validate required settings
14    if not OPENAI_API_KEY:
15        raise ValueError("OPENAI_API_KEY environment variable not set")

1import logging
2from logging.handlers import RotatingFileHandler
3
4def setup_logging():
5    logger = logging.getLogger()
6    logger.setLevel(logging.INFO)
7    
8    # File handler (rotate at 10MB)
9    file_handler = RotatingFileHandler(
10        'resume_scanner.log',
11        maxBytes=10*1024*1024,
12        backupCount=5
13    )
14    file_handler.setFormatter(
15        logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
16    )
17    logger.addHandler(file_handler)
18    
19    # Console handler
20    console_handler = logging.StreamHandler()
21    console_handler.setFormatter(
22        logging.Formatter('%(levelname)s - %(message)s')
23    )
24    logger.addHandler(console_handler)

1import time
2from functools import wraps
3
4def rate_limit(calls_per_minute=60):
5    """Decorator to enforce rate limiting"""
6    min_interval = 60.0 / calls_per_minute
7    last_called = [0.0]
8    
9    def decorator(func):
10        @wraps(func)
11        def wrapper(*args, **kwargs):
12            elapsed = time.time() - last_called[0]
13            if elapsed < min_interval:
14                time.sleep(min_interval - elapsed)
15            result = func(*args, **kwargs)
16            last_called[0] = time.time()
17            return result
18        return wrapper
19    return decorator
20
21class AIAnalyzer:
22    @rate_limit(calls_per_minute=30)  # OpenAI rate limit
23    def extract_candidate_info(self, resume_text: str) -> dict:
24        # Your existing code
25        pass

1# test_resume_scanner.py
2import unittest
3from resume_parser import ResumeParser
4from ai_analyzer import AIAnalyzer
5from matcher import RequirementMatcher
6
7class TestResumeScanner(unittest.TestCase):
8    def setUp(self):
9        self.parser = ResumeParser("test_resumes")
10        self.analyzer = AIAnalyzer()
11        self.matcher = RequirementMatcher(
12            required_skills=["Python", "Django"],
13            preferred_skills=["React"]
14        )
15    
16    def test_skill_matching(self):
17        resume_text = "Skills: Python, Django, JavaScript"
18        result = self.matcher.calculate_skill_match(resume_text)
19        self.assertEqual(result["required_match_percentage"], 100.0)
20    
21    def test_missing_skills(self):
22        resume_text = "Skills: JavaScript, HTML, CSS"
23        missing = self.matcher.get_missing_skills(resume_text)
24        self.assertIn("python", missing)
25        self.assertIn("django", missing)
26
27if __name__ == "__main__":
28    unittest.main()

1def calculate_composite_score(self, skill_match: dict, ai_scores: dict) -> float:
2    """Calculate weighted composite score - adjust weights for your needs"""
3    
4    weights = {
5        "skill_match": 0.35,          # 35% weight
6        "technical_score": 0.25,      # 25% weight
7        "experience_score": 0.20,     # 20% weight
8        "education_score": 0.10,      # 10% weight
9        "overall_fit": 0.10           # 10% weight
10    }
11    
12    score = (
13        skill_match["overall_match_percentage"] * weights["skill_match"] +
14        ai_scores.get("technical_skills_score", 0) * 10 * weights["technical_score"] +
15        ai_scores.get("experience_score", 0) * 10 * weights["experience_score"] +
16        ai_scores.get("education_score", 0) * 10 * weights["education_score"] +
17        ai_scores.get("overall_fit_score", 0) * 10 * weights["overall_fit"]
18    )
19    
20    return round(score, 1)

1class RoleSpecificScanner(ResumeScanner):
2    """Different configurations for different roles"""
3    
4    @classmethod
5    def for_senior_engineer(cls, resumes_folder: str):
6        return cls(
7            resumes_folder=resumes_folder,
8            job_description=SENIOR_ENGINEER_JD,
9            required_skills=["Python", "System Design", "Leadership"],
10            preferred_skills=["Kubernetes", "AWS"],
11            scoring_weights={"experience": 0.35, "technical": 0.30, "leadership": 0.20}
12        )
13    
14    @classmethod
15    def for_junior_engineer(cls, resumes_folder: str):
16        return cls(
17            resumes_folder=resumes_folder,
18            job_description=JUNIOR_ENGINEER_JD,
19            required_skills=["Python", "SQL"],
20            preferred_skills=["Django", "Git"],
21            scoring_weights={"education": 0.30, "technical": 0.35, "potential": 0.20}
22        )

1# Track which prompts produce best results
2def evaluate_prompt_quality(self, candidates: list) -> dict:
3    """Measure if AI scoring correlates with human interview decisions"""
4    
5    # After interviews, compare:
6    # - AI top 10 vs actual top 10 hired
7    # - AI scores vs interview performance
8    # - Adjust prompts based on mismatches
9    
10    return {
11        "accuracy": 0.85,  # 85% of AI top 10 made it to final round
12        "false_positives": 2,  # AI recommended but performed poorly
13        "false_negatives": 1   # AI rejected but should have interviewed
14    }