Update app.py

app.py

@@ -1,171 +1,162 @@
+import os
+from io import BytesIO
 import gradio as gr
-import io
+import fitz  # PyMuPDF
+import docx  # python-docx
 import google.generativeai as genai
-import fitz  # Import PyMuPDF
-from google.colab import userdata
-
-# Access your API key from the Secrets Manager
-# In a Hugging Face Space, you would typically set this as a Space Secret
-# For local testing, you can keep this, but remember to remove it before deploying
-# or use the Hugging Face Secrets management.
-try:
-    GOOGLE_API_KEY = userdata.get('GOOGLE_API_KEY')
+
+# --- Configure Google Gemini API key from Space Secret ---
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "").strip()
+if GOOGLE_API_KEY:
     genai.configure(api_key=GOOGLE_API_KEY)
-except Exception as e:
-    print(f"Could not retrieve API key from Colab userdata. Make sure 'GOOGLE_API_KEY' is set in Colab secrets. Error: {e}")
-    print("For Hugging Face Spaces deployment, set this as a Space Secret.")
-    # You might want to handle this more robustly in a production app
-
-
-def analyze_resume_gradio(job_description, resume_file):
-    """
-    Analyzes a resume against a job description using Google Generative AI.
-
-    Args:
-        job_description (str): The text of the job description.
-        resume_file (gr.File): The uploaded resume file object from Gradio.
-
-    Returns:
-        tuple: A tuple containing three strings:
-               - Analysis of missing items.
-               - ATS-optimized resume text.
-               - Tailored cover letter text.
-    """
-    print("--- analyze_resume_gradio function started ---")
-
-    analysis_text = ""
-    resume_output_text = ""
-    cover_letter_text = ""
-
-    if not job_description:
-        return "Please provide a job description.", "", ""
-    if not resume_file:
-        return "Please upload a resume file.", "", ""
-
-    resume_text = ""
-    try:
-        # Gradio's File component provides the file path in the 'name' attribute
-        file_path = resume_file.name
-        print(f"Processing file: {file_path}")
-
-        # Determine file type based on extension or mime type (Gradio might provide mime_type)
-        # For simplicity, let's infer from extension for now
-        if file_path.lower().endswith('.pdf'):
-            print("Attempting to read PDF file.")
-            # Read PDF content from the file path provided by Gradio
-            pdf_document = fitz.open(file_path)
-            for page_num in range(pdf_document.page_count):
-                page = pdf_document.load_page(page_num)
-                resume_text += page.get_text()
-            pdf_document.close()
-            print("Successfully read text from PDF.")
-
-        elif file_path.lower().endswith(('.txt', '.doc', '.docx')):
-             # For .txt, .doc, .docx, we'll attempt to read as text.
-             # For .doc/.docx, a more robust solution might need libraries like python-docx or textract
-             # but for a basic example, reading as text might work for some cases.
-             print("Attempting to read text/doc/docx file.")
-             with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
-                 resume_text = f.read()
-             print("File read successfully as text.")
-        else:
-            print(f"Unsupported file type for Gradio: {file_path}")
-            return f"Unsupported file type: {file_path}. Please upload a PDF, .txt, .doc or .docx file.", "", ""
 
+# Create the model lazily so we can show a friendly error if the key is missing
+def get_model():
+    if not GOOGLE_API_KEY:
+        raise RuntimeError(
+            "Missing GOOGLE_API_KEY secret. Go to Settings → Variables and secrets and add it."
+        )
+    # Use a fast model. You can switch to "gemini-1.5-pro" if you prefer.
+    return genai.GenerativeModel("gemini-1.5-flash")
+
+# --- Helpers to read resume files ---
+def extract_text_from_resume(file_path: str) -> str:
+    if not file_path:
+        return ""
+
+    file_path_lower = file_path.lower()
+    try:
+        if file_path_lower.endswith(".pdf"):
+            text = ""
+            with open(file_path, "rb") as f:
+                pdf_bytes = f.read()
+            doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+            for page in doc:
+                text += page.get_text() or ""
+            doc.close()
+            return text
+
+        elif file_path_lower.endswith(".docx"):
+            # python-docx can open a path directly
+            d = docx.Document(file_path)
+            return "\n".join(p.text for p in d.paragraphs)
+
+        elif file_path_lower.endswith(".txt"):
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                return f.read()
 
-        if not resume_text:
-             return "Could not extract text from the uploaded file.", "", ""
+        else:
+            raise ValueError("Unsupported file type. Please upload .pdf, .docx, or .txt.")
+    except Exception as e:
+        raise RuntimeError(f"Failed to read resume: {e}")
 
-        # print(f"\nResume Content (partial):")
-        # print(resume_text[:500] + "...")
+# --- Main analysis function ---
+def analyze_resume(job_description: str, resume_file_path: str):
+    try:
+        model = get_model()
+    except Exception as e:
+        return (f"❌ {e}", "", "")
 
-        # Use the generative model to analyze the resume
-        # Ensure API key is configured. If not, the genai.GenerativeModel call might fail.
-        if 'genai' not in globals() or genai.api_key is None:
-             return "Google API Key is not configured. Please set it up.", "", ""
+    if not job_description.strip():
+        return ("❌ Please paste a job description.", "", "")
 
+    if not resume_file_path:
+        return ("❌ Please upload a resume file.", "", "")
 
-        model = genai.GenerativeModel('gemini-1.5-flash-latest') # Use an appropriate model
-        print("Generative model initialized.")
+    try:
+        resume_text = extract_text_from_resume(resume_file_path)
+    except Exception as e:
+        return (f"⚠️ {e}", "", "")
 
-        # Prompt for analysis of missing items
-        analysis_prompt = f"""Analyze the following resume based on the provided job description.
-        Identify any missing keywords, skills, or experience mentioned in the job description that are not present in the resume.
+    if not resume_text.strip():
+        return ("⚠️ Could not extract text from the resume.", "", "")
 
-        Job Description:
-        {job_description}
+    # ---------- Gemini prompts (your Colab logic, adapted) ----------
+    try:
+        # 1) Analysis of missing items
+        analysis_prompt = f"""
+Analyze the following resume based on the provided job description.
+Identify missing keywords, skills, or experience mentioned in the job description
+that are not present in the resume. Return a clear, readable list.
 
-        Resume:
-        {resume_text}
+Job Description:
+{job_description}
 
-        Provide a clear list of what is missing from the resume compared to the job description.
-        """
-        print("Sending analysis prompt to model.")
-        analysis_response = model.generate_content(analysis_prompt)
-        analysis_text = analysis_response.text
-        print("Analysis response received.")
+Resume:
+{resume_text}
+"""
+        analysis_resp = model.generate_content(analysis_prompt)
+        analysis_text = (getattr(analysis_resp, "text", "") or "").strip()
 
-        # Prompt to generate an ATS-optimized resume
-        resume_prompt = f"""Based on the following original resume, job description, and the analysis of missing items,
-        generate a new ATS-optimized resume. Focus on incorporating the missing keywords and skills in a natural way.
+        # 2) ATS-optimized resume
+        resume_prompt = f"""
+Based on the original resume, job description, and the missing items analysis,
+rewrite the resume to be ATS-optimized. Incorporate missing keywords/skills naturally.
+Use concise bullet points and clear section headings.
 
-        Original Resume:
-        {resume_text}
+Original Resume:
+{resume_text}
 
-        Job Description:
-        {job_description}
+Job Description:
+{job_description}
 
-        Missing Items Analysis:
-        {analysis_text}
+Missing Items Analysis:
+{analysis_text}
 
-        Generate the new ATS-optimized resume:
-        """
-        print("Sending resume prompt to model.")
-        resume_response = model.generate_content(resume_prompt)
-        resume_output_text = resume_response.text
-        print("Resume response received.")
+Generate the new ATS-optimized resume:
+"""
+        resume_resp = model.generate_content(resume_prompt)
+        optimized_resume = (getattr(resume_resp, "text", "") or "").strip()
 
-        # Prompt to generate a cover letter
-        cover_letter_prompt = f"""Based on the following job description and the generated ATS-optimized resume,
-        write a tailored cover letter. Highlight how the candidate's skills and experience match the job requirements.
+        # 3) Tailored cover letter
+        cover_letter_prompt = f"""
+Write a tailored cover letter that aligns the candidate's experience to the job.
+Keep it 200–350 words, professional, specific, and with a strong call to action.
 
-        Job Description:
-        {job_description}
+Job Description:
+{job_description}
 
-        ATS-Optimized Resume:
-        {resume_output_text}
+ATS-Optimized Resume:
+{optimized_resume}
+"""
+        cover_letter_resp = model.generate_content(cover_letter_prompt)
+        cover_letter_text = (getattr(cover_letter_resp, "text", "") or "").strip()
 
-        Write the cover letter:
-        """
-        print("Sending cover letter prompt to model.")
-        cover_letter_response = model.generate_content(cover_letter_prompt)
-        cover_letter_text = cover_letter_response.text
-        print("Cover letter response received.")
+        return (analysis_text, optimized_resume, cover_letter_text)
 
     except Exception as e:
-        print(f"\nAn error occurred during file processing or analysis: {e}")
-        return f"An error occurred: {e}", "", ""
-
-    return analysis_text, resume_output_text, cover_letter_text
-
-
-# Create the Gradio interface
-iface = gr.Interface(
-    fn=analyze_resume_gradio,
-    inputs=[
-        gr.Textbox(lines=10, label="Job Description"),
-        gr.File(label="Upload Resume (PDF, TXT, DOC, DOCX)") # Allow multiple file types
-    ],
-    outputs=[
-        gr.Textbox(label="Analysis of Missing Items"),
-        gr.Textbox(label="ATS-Optimized Resume"),
-        gr.Textbox(label="Tailored Cover Letter")
-    ],
-    title="Resume Analyzer",
-    description="Upload your resume and paste a job description to get an analysis, an ATS-optimized resume, and a cover letter."
-)
-
-# Launch the Gradio app
-# In a Hugging Face Space, this will be handled automatically.
-# For local testing, you can use iface.launch()
-# iface.launch()
+        return (f"⚠️ Error analyzing with Gemini: {e}", "", "")
+
+# --- Gradio UI ---
+with gr.Blocks() as demo:
+    gr.Markdown("## 📊 HireReady — Resume & Job Match Analyzer (Google Gemini)")
+
+    with gr.Row():
+        job_desc = gr.Textbox(
+            label="Job Description",
+            placeholder="Paste the job description here...",
+            lines=10
+        )
+
+    with gr.Row():
+        resume_file = gr.File(
+            label="Upload Resume (.pdf, .docx, .txt)",
+            file_count="single",
+            file_types=[".pdf", ".docx", ".txt"],
+            type="filepath"  # returns a temp file path (string)
+        )
+
+    analyze_btn = gr.Button("🔍 Analyze")
+    analysis_output = gr.Textbox(label="Analysis of Missing Items", lines=14)
+    resume_output = gr.Textbox(label="ATS-Optimized Resume", lines=18)
+    cover_letter_output = gr.Textbox(label="Tailored Cover Letter", lines=16)
+
+    analyze_btn.click(
+        fn=analyze_resume,
+        inputs=[job_desc, resume_file],
+        outputs=[analysis_output, resume_output, cover_letter_output]
+    )
+
+# For Spaces
+if __name__ == "__main__":
+    demo.launch()