import google.generativeai as genai import fitz # PyMuPDF for PDF text extraction import streamlit as st import spacy from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline from docx import Document import re import dateparser from datetime import datetime import os from typing import List, Dict import logging # Configure logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # Load SpaCy model for dependency parsing and NER nlp_spacy = spacy.load('en_core_web_sm') # Load the NER model tokenizer = AutoTokenizer.from_pretrained("Babelscape/wikineural-multilingual-ner") model = AutoModelForTokenClassification.from_pretrained("Babelscape/wikineural-multilingual-ner") nlp_ner = pipeline('ner', model=model, tokenizer=tokenizer, aggregation_strategy="simple") def authenticate_gemini() -> genai.GenerativeModel: api_key = "AIzaSyCG-qpFRqJc0QOJT-AcAaO5XIEdE-nk3Tc" if not api_key: st.error("Google Gemini API key not found. Please set it in the Hugging Face Spaces secrets.") return None try: genai.configure(api_key=api_key) model = genai.GenerativeModel(model_name="gemini-pro") st.success("Gemini API successfully configured.") return model except Exception as e: logger.error(f"Error configuring Gemini API: {e}") st.error(f"Error configuring Gemini API. Please check your API key and try again.") return None def refine_org_entities(entities: List[str]) -> List[str]: refined_entities = set() company_suffixes = ['Inc', 'LLC', 'Corporation', 'Corp', 'Ltd', 'Co', 'GmbH', 'S.A.', 'Company', 'Group'] for entity in entities: # Remove common prefixes that might interfere with company names entity = re.sub(r'^(The|A|An)\s+', '', entity).strip() if any(entity.endswith(suffix) for suffix in company_suffixes): refined_entities.add(entity) elif re.match(r'([A-Z][a-z]+\s?)+', entity): # Match sequences of capitalized words refined_entities.add(entity) return list(refined_entities) def extract_orgs(text: str) -> List[str]: ner_results = nlp_ner(text) orgs = set() for entity in ner_results: if entity['entity_group'] == 'ORG': orgs.add(entity['word']) return refine_org_entities(orgs) def extract_text_from_pdf(pdf_file) -> str: try: doc = fitz.open(stream=pdf_file.read(), filetype="pdf") text = "" for page_num in range(doc.page_count): page = doc.load_page(page_num) text += page.get_text() return text except Exception as e: logger.error(f"Error extracting text from PDF: {e}") return "" def extract_text_from_doc(doc_file) -> str: try: doc = Document(doc_file) text = '\n'.join([para.text for para in doc.paragraphs]) return text except Exception as e: logger.error(f"Error extracting text from DOCX: {e}") return "" def generate_summary(text: str, model: genai.GenerativeModel) -> str: prompt = f"Summarize the following resume in 100 words, highlighting key skills and experiences:\n\n{text}" try: response = model.generate_content(prompt) return response.text except Exception as e: logger.error(f"Error generating summary: {e}") return "Error generating summary. Please try again." def extract_experience(text: str) -> str: # Patterns to match experience in years and months experience_patterns = [ r'(\d+)\s*(?:years?|yrs?)', # e.g., 5 years, 2 yrs r'(\d+)\s*(?:months?|mos?)', # e.g., 6 months r'(\d+)\s*(?:years?|yrs?)\s*(?:and)?\s*(\d+)\s*(?:months?|mos?)' # e.g., 2 years and 6 months ] # Extract and prioritize years of experience total_years = 0 for pattern in experience_patterns: matches = re.findall(pattern, text, re.IGNORECASE) for match in matches: if len(match) == 1: # Only years or months value = int(match[0]) if 'year' in pattern: total_years += value # We ignore months in this case elif len(match) == 2: # Years and months years, _ = int(match[0]), int(match[1]) total_years += years # Return only the number of years (ignore months) if total_years > 0: return f"{total_years} years" else: return "Experience not found" def extract_phone(text: str) -> str: phone_patterns = [ r'\b(?:\+?1[-.\s]?)?(?:\(\d{3}\)|\d{3})[-.\s]?\d{3}[-.\s]?\d{4}\b', r'\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b' ] for pattern in phone_patterns: match = re.search(pattern, text) if match: return match.group() return "Not found" def extract_email(text: str) -> str: email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b' match = re.search(email_pattern, text) return match.group() if match else "Not found" def extract_colleges(doc) -> List[str]: colleges = set() edu_keywords = ["university", "college", "institute", "school"] for ent in doc.ents: if ent.label_ == "ORG" and any(keyword in ent.text.lower() for keyword in edu_keywords): colleges.add(ent.text) return list(colleges) def extract_linkedin(text: str) -> str: linkedin_patterns = [ r'(?:https?:)?\/\/(?:[\w]+\.)?linkedin\.com\/in\/[A-z0-9_-]+\/?', r'linkedin\.com\/in\/[A-z0-9_-]+', r'@[A-z0-9_-]+\s+\(LinkedIn\)' ] for pattern in linkedin_patterns: match = re.search(pattern, text, re.IGNORECASE) if match: return match.group() return "Not found" def analyze_resume(text: str, model: genai.GenerativeModel) -> Dict: doc = nlp_spacy(text) return { "companies": extract_orgs(text), "summary": generate_summary(text, model), "experience": extract_experience(text), "phone": extract_phone(text), "email": extract_email(text), "colleges": extract_colleges(doc), "linkedin": extract_linkedin(text) } def main(): st.title("Enhanced Resume Analyzer") st.write("Upload a resume to extract information, generate a summary, and analyze details.") model = authenticate_gemini() if model is None: return uploaded_file = st.file_uploader("Choose a PDF or DOCX file", type=["pdf", "docx", "doc"]) if uploaded_file is not None: try: file_ext = uploaded_file.name.split('.')[-1].lower() if file_ext == 'pdf': resume_text = extract_text_from_pdf(uploaded_file) elif file_ext in ['docx', 'doc']: resume_text = extract_text_from_doc(uploaded_file) else: st.error("Unsupported file format.") return if not resume_text.strip(): st.error("The resume appears to be empty or couldn't be read.") return with st.spinner("Analyzing resume..."): results = analyze_resume(resume_text, model) st.subheader("Extracted Information") st.write(f"Experience: {results['experience']}") st.write("Companies Worked For:") st.write(", ".join(results['companies'])) st.write(f"Phone Number: {results['phone']}") st.write(f"Email ID: {results['email']}") st.write("Colleges Attended:") st.write(", ".join(results['colleges'])) st.write(f"LinkedIn: {results['linkedin']}") st.subheader("Generated Summary") st.write(results['summary']) except Exception as e: logger.error(f"Error during resume analysis: {e}") st.error("An error occurred during resume analysis. Please try again or contact support if the issue persists.") if __name__ == "__main__": main()