1pip install openai python-dotenv PyPDF2 docx2txt pandas

1import openai
2import os
3from dotenv import load_dotenv
4import PyPDF2
5import docx2txt
6
7load_dotenv()
8openai.api_key = os.getenv("OPENAI_API_KEY")

1def extract_resume_text(file_path):
2    """
3    Extract text from PDF or DOCX resume.
4    
5    Args:
6        file_path: Path to resume file
7    
8    Returns:
9        str: Extracted text content
10    """
11    try:
12        if file_path.endswith('.pdf'):
13            # Extract from PDF
14            with open(file_path, 'rb') as file:
15                pdf_reader = PyPDF2.PdfReader(file)
16                text = ""
17                for page in pdf_reader.pages:
18                    text += page.extract_text()
19                return text
20        
21        elif file_path.endswith('.docx'):
22            # Extract from Word document
23            text = docx2txt.process(file_path)
24            return text
25        
26        elif file_path.endswith('.txt'):
27            # Plain text resume
28            with open(file_path, 'r', encoding='utf-8') as file:
29                return file.read()
30        
31        else:
32            print(f"❌ Unsupported file format: {file_path}")
33            return None
34    
35    except Exception as e:
36        print(f"❌ Error extracting text: {e}")
37        return None
38
39
40def parse_resume_structure(resume_text):
41    """
42    Use AI to parse resume into structured data.
43    
44    Args:
45        resume_text: Raw text from resume
46    
47    Returns:
48        dict: Structured resume data
49    """
50    
51    prompt = f"""Parse this resume into structured JSON format:
52
53{resume_text}
54
55Extract and return ONLY valid JSON with these fields:
56{{
57    "name": "Candidate name",
58    "email": "Email address",
59    "phone": "Phone number",
60    "location": "City, State/Country",
61    "summary": "Professional summary (2-3 sentences)",
62    "years_of_experience": "Number",
63    "current_title": "Most recent job title",
64    "current_company": "Most recent company",
65    "education": ["Degree, Institution, Year"],
66    "skills": ["Skill1", "Skill2", ...],
67    "key_achievements": ["Achievement1", "Achievement2", ...],
68    "previous_companies": ["Company1", "Company2", ...]
69}}
70
71If information is not found, use null. Return ONLY the JSON, no other text.
72"""
73
74    try:
75        response = openai.ChatCompletion.create(
76            model="gpt-4",
77            messages=[
78                {"role": "system", "content": "You are a resume parser that extracts structured data. Return only valid JSON."},
79                {"role": "user", "content": prompt}
80            ],
81            temperature=0.1,
82            max_tokens=1000
83        )
84        
85        import json
86        parsed_data = json.loads(response.choices[0].message.content)
87        return parsed_data
88    
89    except Exception as e:
90        print(f"❌ Error parsing resume: {e}")
91        return None
92
93
94# Example usage
95resume_text = extract_resume_text("candidate_resume.pdf")
96if resume_text:
97    structured_data = parse_resume_structure(resume_text)
98    print(f"Candidate: {structured_data['name']}")
99    print(f"Years of experience: {structured_data['years_of_experience']}")

1def analyze_resume_fit(resume_data, job_description, requirements):
2    """
3    Analyze how well candidate matches job requirements.
4    
5    Args:
6        resume_data: Structured resume data
7        job_description: Full job description text
8        requirements: Dict with required skills, experience, etc.
9    
10    Returns:
11        dict: Analysis with scores and explanations
12    """
13    
14    prompt = f"""You are an expert technical recruiter. Analyze this candidate's fit for the role.
15
16JOB REQUIREMENTS:
17{job_description}
18
19Must-have qualifications:
20{requirements}
21
22CANDIDATE PROFILE:
23Name: {resume_data['name']}
24Experience: {resume_data['years_of_experience']} years
25Current Role: {resume_data['current_title']} at {resume_data['current_company']}
26Skills: {', '.join(resume_data['skills'])}
27Education: {', '.join(resume_data['education'])}
28
29Provide detailed analysis:
30
311. SKILLS MATCH (0-100):
32   - Required skills present: [list]
33   - Required skills missing: [list]
34   - Nice-to-have skills present: [list]
35   - Overall skills score: X/100
36
372. EXPERIENCE MATCH (0-100):
38   - Years of relevant experience: X years
39   - Seniority level fit: [junior/mid/senior/lead]
40   - Industry experience relevance: [score]
41   - Overall experience score: X/100
42
433. EDUCATION MATCH (0-100):
44   - Degree requirement met: yes/no
45   - Relevant certifications: [list]
46   - Overall education score: X/100
47
484. ACHIEVEMENTS & IMPACT:
49   - Notable achievements relevant to role: [list top 3]
50   - Leadership indicators: [evidence]
51   - Innovation/initiative: [evidence]
52
535. CULTURE FIT INDICATORS:
54   - Company size experience: [startups/scale-ups/enterprise]
55   - Working style indicators: [remote/hybrid/office experience]
56   - Team collaboration evidence: [yes/no with examples]
57
586. RED FLAGS (if any):
59   - [List concerns: gaps, short tenures, missing requirements, etc.]
60
617. GREEN FLAGS (strengths):
62   - [List standout positives]
63
648. OVERALL RECOMMENDATION:
65   - Score: X/100
66   - Recommendation: [Strong Yes / Yes / Maybe / No / Strong No]
67   - Reasoning: [2-3 sentences]
68   - Next steps: [phone screen / technical interview / pass]
69
70Be objective and thorough. Focus on qualifications, not demographics.
71"""
72
73    try:
74        response = openai.ChatCompletion.create(
75            model="gpt-4",
76            messages=[
77                {"role": "system", "content": "You are an expert recruiter who provides objective, thorough candidate assessments."},
78                {"role": "user", "content": prompt}
79            ],
80            temperature=0.3,
81            max_tokens=1500
82        )
83        
84        analysis = response.choices[0].message.content
85        return analysis
86    
87    except Exception as e:
88        print(f"❌ Analysis error: {e}")
89        return None

1def score_candidate(resume_data, job_requirements):
2    """
3    Score candidate on multiple dimensions.
4    
5    Args:
6        resume_data: Parsed resume data
7        job_requirements: Dict with scoring criteria
8    
9    Returns:
10        dict: Scores for each dimension and total
11    """
12    
13    scores = {
14        'technical_skills': 0,
15        'experience': 0,
16        'education': 0,
17        'achievements': 0,
18        'communication': 0,
19        'total': 0
20    }
21    
22    # Technical Skills Score (0-30 points)
23    required_skills = job_requirements.get('required_skills', [])
24    candidate_skills = [s.lower() for s in resume_data.get('skills', [])]
25    
26    matched_skills = sum(1 for req_skill in required_skills 
27                        if any(req_skill.lower() in cs for cs in candidate_skills))
28    
29    scores['technical_skills'] = min(30, (matched_skills / len(required_skills)) * 30)
30    
31    # Experience Score (0-30 points)
32    years_required = job_requirements.get('years_required', 0)
33    years_candidate = resume_data.get('years_of_experience', 0)
34    
35    if years_candidate >= years_required:
36        scores['experience'] = 30
37    elif years_candidate >= years_required * 0.7:
38        scores['experience'] = 20
39    else:
40        scores['experience'] = 10
41    
42    # Education Score (0-15 points)
43    education_required = job_requirements.get('education_required', '')
44    candidate_education = ' '.join(resume_data.get('education', []))
45    
46    if education_required.lower() in candidate_education.lower():
47        scores['education'] = 15
48    else:
49        scores['education'] = 5
50    
51    # Achievements Score (0-15 points)
52    num_achievements = len(resume_data.get('key_achievements', []))
53    scores['achievements'] = min(15, num_achievements * 3)
54    
55    # Communication Score (0-10 points)
56    # Based on resume quality (would need more sophisticated analysis)
57    scores['communication'] = 8  # Placeholder
58    
59    # Calculate total
60    scores['total'] = sum([v for k, v in scores.items() if k != 'total'])
61    
62    return scores
63
64
65def rank_candidates(candidates_data, job_requirements):
66    """
67    Score and rank all candidates.
68    
69    Args:
70        candidates_data: List of parsed resume data
71        job_requirements: Job requirements dict
72    
73    Returns:
74        List of tuples: (candidate_name, total_score, detailed_scores)
75    """
76    
77    ranked = []
78    
79    for candidate in candidates_data:
80        scores = score_candidate(candidate, job_requirements)
81        ranked.append((
82            candidate['name'],
83            scores['total'],
84            scores
85        ))
86    
87    # Sort by total score (highest first)
88    ranked.sort(key=lambda x: x[1], reverse=True)
89    
90    return ranked

1def detect_red_flags(resume_data, resume_text):
2    """
3    Identify potential red flags in resume.
4    
5    Args:
6        resume_data: Structured resume data
7        resume_text: Raw resume text
8    
9    Returns:
10        list: Red flags with severity (high/medium/low)
11    """
12    
13    red_flags = []
14    
15    # Employment gaps (more than 6 months)
16    # (Would need date parsing logic)
17    
18    # Frequent job hopping (more than 4 jobs in 3 years)
19    companies = resume_data.get('previous_companies', [])
20    if len(companies) > 4:
21        red_flags.append({
22            'type': 'job_hopping',
23            'severity': 'medium',
24            'description': f'Candidate has worked at {len(companies)} companies'
25        })
26    
27    # Typos and errors (use AI to detect)
28    prompt = f"""Analyze this resume for quality issues:
29
30{resume_text[:2000]}  # First 2000 chars
31
32Identify:
331. Spelling/grammar errors (count)
342. Formatting inconsistencies
353. Vague or unclear descriptions
364. Missing quantifiable achievements
375. Overall resume quality: [Excellent/Good/Average/Poor]
38
39Return concise assessment.
40"""
41    
42    try:
43        response = openai.ChatCompletion.create(
44            model="gpt-3.5-turbo",
45            messages=[{"role": "user", "content": prompt}],
46            temperature=0.2,
47            max_tokens=300
48        )
49        
50        quality_assessment = response.choices[0].message.content
51        
52        if 'poor' in quality_assessment.lower():
53            red_flags.append({
54                'type': 'poor_quality',
55                'severity': 'medium',
56                'description': 'Resume has quality issues'
57            })
58    
59    except:
60        pass
61    
62    # Check for skill mismatches or exaggerations
63    # (Would need more sophisticated logic)
64    
65    return red_flags

1#!/usr/bin/env python3
2"""
3AI Resume Screening System
4Automate candidate evaluation and ranking.
5"""
6
7import openai
8import os
9from pathlib import Path
10import json
11
12
13class AIResumeScreener:
14    """Automated resume screening and ranking system."""
15    
16    def __init__(self, api_key, job_description, requirements):
17        """
18        Initialize the screener.
19        
20        Args:
21            api_key: OpenAI API key
22            job_description: Full job description
23            requirements: Dict with required skills, experience, etc.
24        """
25        openai.api_key = api_key
26        self.job_description = job_description
27        self.requirements = requirements
28        self.candidates = []
29    
30    def process_resume(self, file_path):
31        """Extract, parse, and analyze a single resume."""
32        
33        print(f"📄 Processing: {Path(file_path).name}")
34        
35        # Extract text
36        resume_text = extract_resume_text(file_path)
37        if not resume_text:
38            return None
39        
40        # Parse structure
41        resume_data = parse_resume_structure(resume_text)
42        if not resume_data:
43            return None
44        
45        # Analyze fit
46        analysis = analyze_resume_fit(
47            resume_data,
48            self.job_description,
49            self.requirements
50        )
51        
52        # Score candidate
53        scores = score_candidate(resume_data, self.requirements)
54        
55        # Detect red flags
56        red_flags = detect_red_flags(resume_data, resume_text)
57        
58        candidate_profile = {
59            'file': Path(file_path).name,
60            'data': resume_data,
61            'analysis': analysis,
62            'scores': scores,
63            'red_flags': red_flags
64        }
65        
66        self.candidates.append(candidate_profile)
67        
68        print(f"✅ Scored: {scores['total']}/100")
69        
70        return candidate_profile
71    
72    def process_folder(self, folder_path):
73        """Process all resumes in a folder."""
74        
75        resume_files = []
76        for ext in ['*.pdf', '*.docx', '*.txt']:
77            resume_files.extend(Path(folder_path).glob(ext))
78        
79        print(f"\n🔍 Found {len(resume_files)} resumes to process\n")
80        
81        for file_path in resume_files:
82            self.process_resume(str(file_path))
83        
84        print(f"\n✅ Processed {len(self.candidates)} candidates")
85    
86    def get_shortlist(self, top_n=10):
87        """Get top N candidates."""
88        
89        # Sort by total score
90        sorted_candidates = sorted(
91            self.candidates,
92            key=lambda x: x['scores']['total'],
93            reverse=True
94        )
95        
96        return sorted_candidates[:top_n]
97    
98    def export_results(self, output_file='screening_results.json'):
99        """Export all screening results to JSON."""
100        
101        with open(output_file, 'w') as f:
102            json.dump(self.candidates, f, indent=2)
103        
104        print(f"📊 Results exported to {output_file}")
105    
106    def generate_report(self):
107        """Generate human-readable screening report."""
108        
109        shortlist = self.get_shortlist(10)
110        
111        report = "=" * 60 + "\n"
112        report += "AI RESUME SCREENING REPORT\n"
113        report += "=" * 60 + "\n\n"
114        
115        report += f"Total Candidates Reviewed: {len(self.candidates)}\n"
116        report += f"Recommended for Interview: {len(shortlist)}\n\n"
117        
118        report += "TOP CANDIDATES:\n"
119        report += "-" * 60 + "\n\n"
120        
121        for i, candidate in enumerate(shortlist, 1):
122            data = candidate['data']
123            scores = candidate['scores']
124            
125            report += f"{i}. {data['name']}\n"
126            report += f"   Score: {scores['total']}/100\n"
127            report += f"   Current Role: {data['current_title']}\n"
128            report += f"   Experience: {data['years_of_experience']} years\n"
129            report += f"   Skills Score: {scores['technical_skills']:.1f}/30\n"
130            
131            if candidate['red_flags']:
132                report += f"   ⚠️  Red Flags: {len(candidate['red_flags'])}\n"
133            
134            report += "\n"
135        
136        return report
137
138
139def main():
140    """Example usage."""
141    
142    # Define job requirements
143    job_description = """
144    Senior Software Engineer
145    
146    We're seeking an experienced software engineer to join our platform team.
147    You'll work on scalable backend systems, mentor junior engineers, and 
148    drive technical decisions.
149    
150    Requirements:
151    - 5+ years of software development experience
152    - Strong proficiency in Python and/or Java
153    - Experience with cloud platforms (AWS/Azure/GCP)
154    - Database design and optimization skills
155    - Proven track record of leading technical projects
156    """
157    
158    requirements = {
159        'required_skills': ['Python', 'Java', 'AWS', 'Azure', 'GCP', 'SQL'],
160        'years_required': 5,
161        'education_required': "Bachelor's degree in Computer Science or related field",
162        'must_have': ['backend development', 'cloud experience', 'leadership']
163    }
164    
165    # Initialize screener
166    screener = AIResumeScreener(
167        api_key=os.getenv("OPENAI_API_KEY"),
168        job_description=job_description,
169        requirements=requirements
170    )
171    
172    # Process all resumes in folder
173    screener.process_folder("./resumes")
174    
175    # Generate report
176    report = screener.generate_report()
177    print(report)
178    
179    # Export detailed results
180    screener.export_results()
181
182
183if __name__ == "__main__":
184    main()

1import requests
2
3def export_to_greenhouse(candidate_profile, greenhouse_api_key):
4    """Send top candidates to Greenhouse ATS."""
5    
6    url = "https://harvest.greenhouse.io/v1/candidates"
7    headers = {
8        "Authorization": f"Basic {greenhouse_api_key}",
9        "Content-Type": "application/json"
10    }
11    
12    payload = {
13        "first_name": candidate_profile['data']['name'].split()[0],
14        "last_name": candidate_profile['data']['name'].split()[-1],
15        "email": candidate_profile['data']['email'],
16        "phone": candidate_profile['data']['phone'],
17        "resume_text": candidate_profile['data']['summary'],
18        "custom_fields": {
19            "ai_score": candidate_profile['scores']['total']
20        }
21    }
22    
23    response = requests.post(url, headers=headers, json=payload)
24    return response.status_code == 201

1def anonymize_resume(resume_data):
2    """Remove potentially biasing information."""
3    
4    anonymized = resume_data.copy()
5    anonymized['name'] = f"Candidate_{hash(resume_data['name'])}"
6    anonymized['email'] = "***@***"
7    anonymized['phone'] = "***-***-****"
8    anonymized['location'] = "***"
9    
10    # Keep only graduation years, not school names
11    anonymized['education'] = [
12        edu.split(',')[-1] for edu in resume_data['education']
13    ]
14    
15    return anonymized