Update app.py

app.py

@@ -1,172 +1,162 @@
 import os
 import pandas as pd
 import google.generativeai as genai
-import PyPDF2 as pdf
+import PyPDF2
 import io
 import re
 import streamlit as st
-from transformers import AutoModelForTokenClassification, AutoTokenizer, pipeline
+from transformers import pipeline
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
 
-# Set API key for Google Generative AI
+# Configure API Key
 api_key = os.getenv("GOOGLE_API_KEY")
 if not api_key:
     st.error("API key not found. Please set GOOGLE_API_KEY in your environment variables.")
     st.stop()
 
-# Initialize Google Generative AI
 genai.configure(api_key=api_key)
 
-# Function for text generation using Google Generative AI
+# Text Generation Function
 def generate_response(prompt, model="text-bison-001", max_output_tokens=256):
+    """
+    Generate text response using Google Generative AI.
+
+    Args:
+        prompt (str): Input prompt for AI.
+        model (str): Model to use for generation.
+        max_output_tokens (int): Maximum token limit.
+
+    Returns:
+        str: Generated text or error message.
+    """
     try:
-        # Use the correct method for generating text (may vary based on API update)
         response = genai.chat(
             model=model,
             messages=[{"role": "user", "content": prompt}],
-            temperature=0.7,  # You can adjust temperature for more creative responses
+            temperature=0.7,
             max_output_tokens=max_output_tokens
         )
-        return response.result['content']  # Correct response structure
+        return response.result['content']
     except Exception as e:
         return f"Error generating text: {str(e)}"
 
-# Extract text from uploaded PDF file
-def input_pdf_text(uploaded_file):
+# PDF Text Extraction
+def extract_text_from_pdf(file):
+    """
+    Extract text from uploaded PDF.
+
+    Args:
+        file (UploadedFile): PDF file uploaded via Streamlit.
+
+    Returns:
+        str: Extracted text or error message.
+    """
     try:
-        file_stream = io.BytesIO(uploaded_file.read())
-        reader = pdf.PdfReader(file_stream)
-        text = ""
-        for page in reader.pages:
-            text += page.extract_text()
+        reader = PyPDF2.PdfReader(io.BytesIO(file.read()))
+        text = ''.join(page.extract_text() for page in reader.pages)
         return text.strip()
     except Exception as e:
         st.error(f"Error extracting text from PDF: {str(e)}")
         return ""
 
-# Extract email and phone numbers using regex
-def extract_contact_info(resume_text):
-    email_regex = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
-    phone_regex = r"\+?[\d\s().-]{7,15}"
+# Extract Contact Information
+def extract_contact_info(text):
+    """
+    Extract email and phone number from text using regex.
 
-    email_match = re.search(email_regex, resume_text)
-    email = email_match.group(0) if email_match else "Not Available"
+    Args:
+        text (str): Input text.
 
-    contact_match = re.search(phone_regex, resume_text)
-    contact = contact_match.group(0) if contact_match else "Not Available"
+    Returns:
+        tuple: Extracted email and phone number or "Not Available".
+    """
+    email = re.search(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", text)
+    phone = re.search(r"\+?[\d\s().-]{7,15}", text)
 
-    return email, contact
+    return (email.group(0) if email else "Not Available",
+            phone.group(0) if phone else "Not Available")
 
-# Extract management and team leadership experience
+# Management Experience Extraction
 def extract_management_experience(text):
-    management_keywords = [
-        "manager", "team lead", "director", "executive", "head of", "supervisor", "leadership", "head"
-    ]
-    leadership_patterns = [
+    """
+    Extract management and leadership keywords and years.
+
+    Args:
+        text (str): Input resume text.
+
+    Returns:
+        tuple: Total years of experience and matching keywords.
+    """
+    keywords = ["manager", "team lead", "director", "executive", "supervisor", "leadership", "head"]
+    patterns = [
         r"(\d+)\s?(years|yrs|year)\s?of\s?(management|leadership)",
-        r"(\d+)\s?(years|yrs|year)\s?experience\s?(managing|leading)",
-        r"led\s?(\d+)\s?teams",
-        r"(\d+)\s?team\s?(members|leaders)"
+        r"(\d+)\s?(years|yrs|year)\s?experience\s?(managing|leading)"
     ]
 
-    management_years = 0
-    leadership_experience = []
-    for keyword in management_keywords:
-        if keyword.lower() in text.lower():
-            leadership_experience.append(keyword)
-
-    for pattern in leadership_patterns:
-        matches = re.findall(pattern, text)
-        for match in matches:
-            if len(match) == 2 and match[0].isdigit():
-                management_years += int(match[0])
-            elif len(match) == 1 and match[0].isdigit():
-                management_years += int(match[0])
+    found_keywords = [kw for kw in keywords if kw in text.lower()]
+    years = sum(int(match[0]) for pattern in patterns for match in re.findall(pattern, text))
 
-    management_experience = ', '.join(set(leadership_experience)) if leadership_experience else "Not Available"
-    return management_years, management_experience
+    return years, ", ".join(found_keywords) if found_keywords else "Not Available"
 
-# Calculate match percentage using TF-IDF and cosine similarity
+# TF-IDF Match Percentage
 def calculate_match_percentage(resume_text, job_description):
-    try:
-        documents = [resume_text, job_description]
-        tfidf_vectorizer = TfidfVectorizer(stop_words='english')
-        tfidf_matrix = tfidf_vectorizer.fit_transform(documents)
-        cosine_sim = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])
-        return round(cosine_sim[0][0] * 100, 2) if cosine_sim.any() else 0.0
-    except Exception:
-        return 0.0
+    """
+    Calculate similarity between resume and job description using TF-IDF.
+
+    Args:
+        resume_text (str): Resume content.
+        job_description (str): Job description.
 
-# Generate analysis from Google Generative AI
-def get_gemini_response(input_text, job_description):
+    Returns:
+        float: Match percentage (0-100).
+    """
     try:
-        prompt = f"""
-        Analyze the resume with respect to the job description.
-        Resume Text: {input_text}
-        Job Description: {job_description}
-        Extract details:
-        - Name
-        - Skills
-        - Education
-        - Management and Team Leadership Experience (years)
-        - Match percentage
-        """
-        return generate_response(prompt)
+        vectorizer = TfidfVectorizer(stop_words='english')
+        tfidf_matrix = vectorizer.fit_transform([resume_text, job_description])
+        cosine_sim = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])
+        return round(cosine_sim[0][0] * 100, 2)
     except Exception as e:
-        st.error(f"Error generating response from Google Generative AI: {str(e)}")
-        return ""
+        st.error(f"Error calculating match percentage: {str(e)}")
+        return 0.0
 
-# Streamlit interface
-st.title("Resume ATS Analysis Tool - Management & Leadership Experience Focus")
-st.markdown("### Upload a Resume and Provide a Job Description")
+# Streamlit Interface
+st.title("Resume Analysis Tool: Management & Leadership Focus")
+st.markdown("### Upload Resume PDF and Enter Job Description")
 
 uploaded_file = st.file_uploader("Upload Resume PDF", type=["pdf"])
-job_description = st.text_area("Job Description (Required)", height=200)
+job_description = st.text_area("Job Description", height=200)
 
 if uploaded_file and job_description.strip():
-    if not uploaded_file.name.endswith('.pdf'):
-        st.error("Only PDF files are supported.")
-        st.stop()
-
-    analyze_button = st.button("Analyze")
-    if analyze_button:
-        resume_text = input_pdf_text(uploaded_file)
-
+    if st.button("Analyze"):
+        resume_text = extract_text_from_pdf(uploaded_file)
         if not resume_text:
-            st.error("No text found in the uploaded file.")
+            st.error("Failed to extract text from PDF. Ensure the file is valid.")
             st.stop()
 
-        # Extract management and leadership experience
-        management_years, management_experience = extract_management_experience(resume_text)
-
-        # Generate analysis
-        gemini_response = get_gemini_response(resume_text, job_description)
-
-        # Extract data and calculate metrics
-        email, contact = extract_contact_info(resume_text)
+        email, phone = extract_contact_info(resume_text)
+        management_years, management_keywords = extract_management_experience(resume_text)
         match_percentage = calculate_match_percentage(resume_text, job_description)
 
-        # Prepare results
+        prompt = f"""
+        Analyze the resume with respect to the job description.
+        Resume Text: {resume_text}
+        Job Description: {job_description}
+        Include: Name, Skills, Education, Experience, and Match Percentage.
+        """
+        gemini_response = generate_response(prompt)
+
         results = {
             "Email": email,
-            "Contact": contact,
+            "Contact": phone,
             "Management Experience (Years)": management_years,
-            "Management & Leadership Keywords": management_experience,
+            "Keywords": management_keywords,
             "Match Percentage": match_percentage,
-            "Gemini Response Summary": gemini_response
+            "AI Summary": gemini_response
         }
 
-        # Display results
         st.write(pd.DataFrame([results]))
-
-        # Enable CSV download
         csv = pd.DataFrame([results]).to_csv(index=False)
-        st.download_button(
-            label="Download Results as CSV",
-            data=csv,
-            file_name="resume_analysis_results.csv",
-            mime="text/csv"
-        )
+        st.download_button("Download Results", data=csv, file_name="resume_analysis.csv", mime="text/csv")
 else:
-    st.write("Please upload a resume and provide a job description.")
+    st.info("Upload a resume and provide a job description to begin analysis.")