Upload 4 files

ai_summarizer.py

@@ -0,0 +1,82 @@
+from typing import Dict, List, Optional
+from .hf_api import hf_summarize
+
+def summarize_resume(resume_data: Dict, *, hf_model: str, hf_token: Optional[str]) -> str:
+    """
+    Generate a summary of the resume using a Hugging Face text summarization model
+    via the Inference API.
+    
+    Args:
+        resume_data: Parsed resume dictionary containing 'raw_text' and optional fields.
+        hf_model: Model repo id, e.g. 'facebook/bart-large-cnn' or 'sshleifer/distilbart-cnn-12-6'.
+        hf_token: Optional HF API token. Required for rate limits or private models.
+    Returns:
+        str: Generated summary text.
+    """
+    name = resume_data.get('name', 'The candidate')
+    skills: List[str] = resume_data.get('skills', []) or []
+    raw_text: str = resume_data.get('raw_text', '')
+
+    if not raw_text or len(raw_text.strip()) == 0:
+        return generate_template_summary(resume_data)
+
+    # The Inference API has input length limits; truncate long text conservatively.
+    # We'll keep about ~2000 characters to stay safe across most summarization models.
+    truncated = raw_text.strip()
+    if len(truncated) > 2000:
+        truncated = truncated[:2000]
+
+    prompt = truncated
+    try:
+        summary = hf_summarize(prompt, model=hf_model, api_token=hf_token)
+    except Exception:
+        # Fallback to template summary on any API failure
+        return generate_template_summary(resume_data)
+
+    # Optionally append skills
+    if skills:
+        summary = summary.strip() + f"\n\nKey Skills: {', '.join(skills[:10])}"
+    return summary
+
+def generate_extractive_summary(*args, **kwargs) -> str:
+    """Deprecated placeholder. We now use the Hugging Face Inference API."""
+    raise NotImplementedError("Use summarize_resume with hf_model and hf_token instead.")
+
+def generate_template_summary(resume_data: Dict) -> str:
+    """Generate a template-based summary when there's not enough text for extractive summarization."""
+    name = resume_data.get('name', 'The candidate')
+    skills = resume_data.get('skills', [])
+    
+    summary = f"{name} "
+    
+    if skills:
+        summary += f"is proficient in {', '.join(skills[:5])}."
+    else:
+        summary += "has submitted a resume for review."
+    
+    return summary
+
+# For testing
+if __name__ == "__main__":
+    test_resume = {
+        'name': 'John Doe',
+        'email': 'john.doe@example.com',
+        'phone': '(123) 456-7890',
+        'skills': ['Python', 'Machine Learning', 'Data Analysis'],
+        'raw_text': """John Doe
+        Senior Data Scientist
+        
+        Experienced data scientist with 5+ years of experience in machine learning and data analysis. 
+        Proficient in Python, R, and SQL. Strong background in statistical modeling and data visualization.
+        
+        Experience:
+        - Data Scientist at Tech Corp (2020-Present)
+        - Junior Data Analyst at Data Systems (2018-2020)
+        
+        Education:
+        - MS in Computer Science, University of Technology
+        - BS in Mathematics, State University
+        """
+    }
+    
+    print(summarize_resume(test_resume))

hf_api.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from huggingface_hub import InferenceClient
+
+
+def hf_summarize(text: str, *, model: str, api_token: Optional[str] = None, max_new_tokens: int = 200) -> str:
+    """
+    Call the Hugging Face Inference API for summarization.
+
+    Args:
+        text: Input text to summarize.
+        model: Hugging Face model repo id (e.g., 'facebook/bart-large-cnn').
+        api_token: Optional HF API token for higher rate limits / private models.
+        max_new_tokens: Maximum tokens to generate in the summary.
+
+    Returns:
+        The summarized text.
+    """
+    client = InferenceClient(model=model, token=api_token)
+    # The library returns either a string or a dict depending on the task helper used.
+    # Using the summarization task helper yields a string.
+    result = client.summarization(text, max_new_tokens=max_new_tokens)
+    if isinstance(result, str):
+        return result.strip()
+    # Fallback if a different payload format is returned
+    if isinstance(result, dict) and 'summary_text' in result:
+        return str(result['summary_text']).strip()
+    return str(result).strip()

resume_parser.py

@@ -0,0 +1,78 @@
+import os
+import re
+import PyPDF2
+from docx import Document
+from typing import Dict, List
+
+def extract_text_from_pdf(file_path: str) -> str:
+    """Extract text from PDF file."""
+    with open(file_path, 'rb') as file:
+        reader = PyPDF2.PdfReader(file)
+        text = ""
+        for page in reader.pages:
+            text += page.extract_text() + "\n"
+    return text
+
+def extract_text_from_docx(file_path: str) -> str:
+    """Extract text from DOCX file."""
+    doc = Document(file_path)
+    return "\n".join([paragraph.text for paragraph in doc.paragraphs])
+
+def extract_contact_info(text: str) -> Dict[str, str]:
+    """Extract contact information from text."""
+    # Email pattern
+    email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
+    # Phone pattern (supports various formats)
+    phone_pattern = r'(\+\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}'
+    
+    email = re.search(email_pattern, text)
+    phone = re.search(phone_pattern, text)
+    
+    return {
+        'email': email.group(0) if email else '',
+        'phone': phone.group(0) if phone else ''
+    }
+
+def extract_skills(text: str) -> List[str]:
+    """Extract skills by keyword scan (lightweight, no external NLP)."""
+    skills_list = [
+        'python', 'java', 'javascript', 'c++', 'c#', 'sql', 'html', 'css',
+        'machine learning', 'deep learning', 'data science', 'data analysis',
+        'project management', 'team leadership', 'agile', 'scrum', 'devops',
+        'cloud', 'aws', 'azure', 'gcp', 'docker', 'kubernetes', 'git', 'rest api',
+        'graphql', 'mongodb', 'postgresql', 'mysql', 'tensorflow', 'pytorch',
+        'pandas', 'numpy', 'spark', 'hadoop', 'nlp'
+    ]
+    text_lower = text.lower()
+    found = set()
+    for skill in skills_list:
+        if skill in text_lower:
+            found.add(skill)
+    return sorted(found)
+
+def parse_resume(file_path: str) -> Dict:
+    """Main function to parse resume and extract information."""
+    # Determine file type and extract text
+    file_ext = os.path.splitext(file_path)[1].lower()
+    
+    if file_ext == '.pdf':
+        text = extract_text_from_pdf(file_path)
+    elif file_ext == '.docx':
+        text = extract_text_from_docx(file_path)
+    else:
+        raise ValueError("Unsupported file format. Please upload a PDF or DOCX file.")
+    
+    # Extract information
+    contact_info = extract_contact_info(text)
+    skills = extract_skills(text)
+    
+    # Extract name (simple approach - first line is often the name)
+    name = text.split('\n')[0].strip()
+    
+    return {
+        'name': name,
+        'email': contact_info['email'],
+        'phone': contact_info['phone'],
+        'skills': skills,
+        'raw_text': text
+    }