Update app.py

app.py

@@ -1,521 +1,171 @@
-import json
-import PyPDF2
-import docx
-import streamlit as st
-import pandas as pd
-import plotly.express as px
-from io import BytesIO
-from reportlab.lib import colors
-from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-
-import google.generativeai as genai # Replaced openai import
-
-# Utility Functions
-def read_pdf(file):
-    pdf_reader = PyPDF2.PdfReader(file)
-    text = ""
-    for page in pdf_reader.pages:
-        text += page.extract_text()
-    return text
-
-
-def read_docx(file):
-    doc = docx.Document(file)
-    text = ""
-    for paragraph in doc.paragraphs:
-        text += paragraph.text + "\n"
-    return text
-
-
-def load_resume(uploaded_file):
-    if uploaded_file.name.endswith('.pdf'):
-        return read_pdf(uploaded_file)
-    elif uploaded_file.name.endswith('.docx'):
-        return read_docx(uploaded_file)
-    else:
-        st.error("Unsupported file format")
-        return None
-
-def generate_updated_resume(resume_text, match_analysis):
-    buffer = BytesIO()
-    doc = SimpleDocTemplate(buffer, pagesize=letter,
-                            rightMargin=40, leftMargin=40,
-                            topMargin=60, bottomMargin=40)
-    styles = getSampleStyleSheet()
-
-    # Custom styles
-    header_style = styles['Heading1']
-    header_style.fontSize = 16
-    header_style.spaceAfter = 18
-    header_style.textColor = colors.HexColor('#1a1a1a')
-
-    section_header_style = ParagraphStyle(
-        name='SectionHeader',
-        parent=styles['Heading2'],
-        fontSize=13,
-        spaceAfter=12,
-        textColor=colors.HexColor('#0d47a1'),
-        underlineWidth=1,
-        underlineOffset=-3
-    )
-
-    normal_style = ParagraphStyle(
-        name='NormalText',
-        parent=styles['Normal'],
-        fontSize=10,
-        leading=14,
-        spaceAfter=6,
-    )
-
-    bullet_style = ParagraphStyle(
-        name='BulletStyle',
-        parent=normal_style,
-        bulletFontName='Helvetica',
-        bulletFontSize=8,
-        bulletIndent=10,
-        leftIndent=20
-    )
-
-    recommendation_style = ParagraphStyle(
-        name='RecommendationStyle',
-        parent=styles['Normal'],
-        fontSize=9,
-        textColor=colors.HexColor('#00695c'),
-        leftIndent=25,
-        spaceAfter=4
-    )
-
-    content = []
-    content.append(Paragraph("Updated Resume", header_style))
-    content.append(Spacer(1, 12))
-
-    # Resume Content Parsing
-    resume_parts = resume_text.split("\n")
-    current_section = ""
-    bullets = []
-
-    def flush_bullets():
-        for bullet in bullets:
-            content.append(Paragraph(f"• {bullet.strip()}", bullet_style))
-        bullets.clear()
-
-    common_sections = ['EXPERIENCE', 'EDUCATION', 'SKILLS', 'PROJECTS', 'CERTIFICATIONS', 'SUMMARY', 'OBJECTIVE']
-
-    for line in resume_parts:
-        line = line.strip()
-        if not line:
-            continue
-
-        is_section = line.isupper() or any(section in line.upper() for section in common_sections)
-
-        if is_section:
-            flush_bullets()
-            current_section = line
-            content.append(Spacer(1, 12))
-            content.append(Paragraph(current_section, section_header_style))
+import gradio as gr
+import io
+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')
+    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:
-            bullets.append(line)
-
-    flush_bullets()
-
-    # ATS Recommendations
-    if match_analysis.get('ats_optimization_suggestions'):
-        content.append(Spacer(1, 20))
-        content.append(Paragraph("ATS Optimization Recommendations", section_header_style))
-        content.append(Spacer(1, 10))
-
-        for suggestion in match_analysis['ats_optimization_suggestions']:
-            section = suggestion.get('section', '')
-            current = suggestion.get('current_content', '')
-            suggested = suggestion.get('suggested_change', '')
-            keywords = ', '.join(suggestion.get('keywords_to_add', []))
-            formatting = suggestion.get('formatting_suggestion', '')
-            reason = suggestion.get('reason', '')
-            content.append(Paragraph(f"• Section: {section}", recommendation_style))
-            if current:
-                content.append(Paragraph(f" Current: {current}", recommendation_style))
-            content.append(Paragraph(f" Suggestion: {suggested}", recommendation_style))
-            if keywords:
-                content.append(Paragraph(f" Keywords to Add: {keywords}", recommendation_style))
-            if formatting:
-                content.append(Paragraph(f" Formatting: {formatting}", recommendation_style))
-            if reason:
-                content.append(Paragraph(f" Reason: {reason}", recommendation_style))
-            content.append(Spacer(1, 6))
-
-    doc.build(content)
-    buffer.seek(0)
-    return buffer
-
-def generate_updated_resume1(resume_text, match_analysis):
-    buffer = BytesIO()
-    doc = SimpleDocTemplate(buffer, pagesize=letter)
-    styles = getSampleStyleSheet()
-
-    # Modify existing styles
-    styles['Heading1'].fontSize = 14
-    styles['Heading1'].spaceAfter = 16
-    styles['Heading1'].textColor = colors.HexColor('#2c3e50')
-    styles['Heading2'].fontSize = 12
-    styles['Heading2'].spaceAfter = 12
-    styles['Heading2'].textColor = colors.HexColor('#34495e')
-    styles['Normal'].fontSize = 10
-    styles['Normal'].spaceAfter = 8
-    styles['Normal'].leading = 14
-
-    # Add a custom style for recommendations
-    styles.add(ParagraphStyle(
-        name='RecommendationStyle',
-        parent=styles['Normal'],
-        fontSize=10,
-        spaceAfter=8,
-        leading=14,
-        leftIndent=20,
-        textColor=colors.HexColor('#2980b9')
-    ))
-
-    # Create content
-    content = []
-
-    # Add header
-    content.append(Paragraph("Updated Resume", styles['Heading1']))
-    content.append(Spacer(1, 12))
-
-    # Add existing resume content with proper formatting
-    resume_parts = resume_text.split("\n")
-    current_section = None
-    for part in resume_parts:
-        if part.strip(): # Skip empty lines
-            # Detect section headers (uppercase or common section names)
-            common_sections = ['EXPERIENCE', 'EDUCATION', 'SKILLS', 'PROJECTS', 'CERTIFICATIONS']
-            is_section = part.isupper() or any(section in part.upper() for section in common_sections)
-
-            if is_section:
-                current_section = part
-                content.append(Paragraph(part, styles['Heading2']))
-            else:
-                content.append(Paragraph(part, styles['Normal']))
-            content.append(Spacer(1, 6))
-
-    # Add ATS optimization recommendations
-    if match_analysis.get('ats_optimization_suggestions'):
-        content.append(Spacer(1, 12))
-        content.append(Paragraph("ATS Optimization Recommendations", styles['Heading2']))
-        content.append(Spacer(1, 8))
-
-        for suggestion in match_analysis['ats_optimization_suggestions']:
-            content.append(Paragraph(f"• Section: {suggestion['section']}", styles['RecommendationStyle']))
-            if suggestion.get('current_content'):
-                content.append(Paragraph(f" Current: {suggestion['current_content']}", styles['RecommendationStyle']))
-            content.append(Paragraph(f" Suggestion: {suggestion['suggested_change']}", styles['RecommendationStyle']))
-            if suggestion.get('keywords_to_add'):
-                content.append(Paragraph(f" Keywords to Add: {', '.join(suggestion['keywords_to_add'])}", styles['RecommendationStyle']))
-            if suggestion.get('formatting_suggestion'):
-                content.append(
-                    Paragraph(f" Formatting: {suggestion['formatting_suggestion']}", styles['RecommendationStyle']))
-            content.append(Spacer(1, 6))
-
-    # Build PDF
-    doc.build(content)
-    buffer.seek(0)
-    return buffer
-
-
-class JobAnalyzer:
-    def __init__(self, api_key: str):
-        # Configure Google Generative AI
-        genai.configure(api_key=api_key)
-        self.model = genai.GenerativeModel("gemini-1.5-flash") # You can choose a different model
-
-    def analyze_job(self, job_description: str) -> dict:
-        prompt = """
-Analyze this job description and provide a detailed JSON with:
-1. Key technical skills required
-2. Soft skills required
-3. Years of experience required
-4. Education requirements
-5. Key responsibilities
-6. Company culture indicators
-7. Required certifications
-8. Industry type
-9. Job level (entry, mid, senior)
-10. Key technologies mentioned
-
-Format the response as a JSON object with these categories.
-Job Description: {description}
-"""
-        try:
-            response = self.model.generate_content(prompt.format(description=job_description))
-            # Assuming the response text is a valid JSON string
-            parsed_response = json.loads(response.text)
-            return parsed_response
-        except Exception as e:
-            st.error(f"Error analyzing job description: {str(e)}")
-            return {}
-
-    def analyze_resume(self, resume_text: str) -> dict:
-        prompt = """
-Analyze this resume and provide a detailed JSON with:
-1. Technical skills
-2. Soft skills
-3. Years of experience
-4. Education details
-5. Key achievements
-6. Core competencies
-7. Industry experience
-8. Leadership experience
-9. Technologies used
-10. Projects completed
-
-Format the response as a JSON object with these categories.
-Resume: {resume}
-"""
-        try:
-            response = self.model.generate_content(prompt.format(resume=resume_text))
-            # Assuming the response text is a valid JSON string
-            parsed_response = json.loads(response.text)
-            return parsed_response
-        except json.JSONDecodeError as e:
-            st.error(
-                f"Error parsing resume analysis response: {str(e)}. Please check the resume text for any formatting issues.")
-            return {}
-        except Exception as e:
-            st.error(f"Error analyzing resume: {str(e)}")
-            return {}
-
-    def analyze_match(self, job_analysis: dict, resume_analysis: dict) -> dict:
-        prompt = """You are a professional resume analyzer. Compare the provided job requirements and resume to generate a detailed analysis in valid JSON format. IMPORTANT: Respond ONLY with a valid JSON object and NO additional text or formatting.
-Job Requirements: {job}
-Resume Details: {resume}
-
-Generate a response following this EXACT structure:
-{{
-  "overall_match_percentage":"85%",
-  "matching_skills":[{{"skill_name":"Python","is_match":true}},{{"skill_name":"AWS","is_match":true}}],
-  "missing_skills":[{{"skill_name":"Docker","is_match":false,"suggestion":"Consider obtaining Docker certification"}}],
-  "skills_gap_analysis":{{"technical_skills":"Specific technical gap analysis","soft_skills":"Specific soft skills gap analysis"}},
-  "experience_match_analysis":"Detailed experience match analysis",
-  "education_match_analysis":"Detailed education match analysis",
-  "recommendations_for_improvement":[{{"recommendation":"Add metrics","section":"Experience","guidance":"Quantify achievements with specific numbers"}}],
-  "ats_optimization_suggestions":[{{"section":"Skills","current_content":"Current format","suggested_change":"Specific change needed","keywords_to_add":["keyword1","keyword2"],"formatting_suggestion":"Specific format change","reason":"Detailed reason"}}],
-  "key_strengths":"Specific key strengths",
-  "areas_of_improvement":"Specific areas to improve"
-}}
-
-Focus on providing detailed, actionable insights for each field. Keep the JSON structure exact but replace the example content with detailed analysis based on the provided job and resume."""
-        try:
-            response = self.model.generate_content(
-                prompt.format(
-                    job=json.dumps(job_analysis, indent=2),
-                    resume=json.dumps(resume_analysis, indent=2)
-                )
-            )
-            try:
-                # Clean up the response content
-                response_content = response.text.strip()
-                # Remove any leading/trailing whitespace or quotes
-                response_content = response_content.strip('"\'')
-                # Parse the JSON
-                parsed_response = json.loads(response_content)
-                return parsed_response
-            except json.JSONDecodeError as e:
-                st.error(f"Error parsing match analysis response. Please try again.")
-                print(f"Debug - Response content: {response.text}")
-                print(f"Debug - Error details: {str(e)}")
-                return {}
-            return parsed_response
-        except Exception as e:
-            st.error(f"Error analyzing match: {str(e)}")
-            return {}
-
-
-class CoverLetterGenerator:
-    def __init__(self, api_key: str):
-        # Configure Google Generative AI
-        genai.configure(api_key=api_key)
-        self.model = genai.GenerativeModel("gemini-1.5-flash") # You can choose a different model
-
-    def generate_cover_letter(self, job_analysis: dict, resume_analysis: dict, match_analysis: dict,
-                                tone: str = "professional") -> str:
-        prompt = """
-Generate a compelling cover letter using this information:
-Job Details: {job}
-Candidate Details: {resume}
-Match Analysis: {match}
-Tone: {tone}
-
-Requirements:
-1. Make it personal and specific
-2. Highlight the strongest matches
-3. Address potential gaps professionally
-4. Keep it concise but impactful
-5. Use the specified tone: {tone}
-6. Include specific examples from the resume
-7. Make it ATS-friendly
-8. Add a strong call to action
-"""
-        try:
-            response = self.model.generate_content(
-                prompt.format(
-                    job=json.dumps(job_analysis, indent=2),
-                    resume=json.dumps(resume_analysis, indent=2),
-                    match=json.dumps(match_analysis, indent=2),
-                    tone=tone
-                )
-            )
-            return response.text
-        except Exception as e:
-            st.error(f"Error generating cover letter: {str(e)}")
-            return ""
-
-
-def main():
-    st.set_page_config(page_title="LinkedIn Job Application Assistant - HireReady 📝", layout="wide")
-
-    # API key input
-    api_key = st.sidebar.text_input("Enter Google AI Studio API Key 🗝️", type="password") # Changed label
-    if not api_key:
-        st.warning("🔑 Please enter your Google AI Studio API key to continue.")
-        return
-
-    st.title("LinkedIn Job Application Assistant - HireReady 🚀")
-    st.markdown("""
-    Optimize your job application by analyzing job requirements 📋, matching your resume 📜, and generating tailored cover letters 💌.
-    """)
-
-    # Initialize analyzers
-    # Pass the API key during initialization
-    job_analyzer = JobAnalyzer(api_key)
-    cover_letter_gen = CoverLetterGenerator(api_key)
-
-    # File Upload Section
-    col1, col2 = st.columns(2)
-    with col1:
-        st.subheader("Job Description 📋")
-        job_desc = st.text_area("Paste the job description here", height=300)
-    with col2:
-        st.subheader("Your Resume 📜")
-        resume_file = st.file_uploader("Upload your resume", type=['pdf', 'docx'])
-
-    if job_desc and resume_file:
-        with st.spinner("🔍 Analyzing your application..."):
-            # Load and analyze resume
-            resume_text = load_resume(resume_file)
-            if resume_text:
-                # Perform analysis
-                job_analysis = job_analyzer.analyze_job(job_desc)
-                resume_analysis = job_analyzer.analyze_resume(resume_text)
-                match_analysis = job_analyzer.analyze_match(job_analysis, resume_analysis)
-
-                if not job_analysis or not resume_analysis or not match_analysis:
-                    st.error("Insufficient data returned from the API. Please try again.")
-                    return
-
-                # Display Results
-                st.header("Analysis Results 📊")
-
-                # Match Overview
-                col1, col2, col3 = st.columns(3)
-                with col1:
-                    st.metric(
-                        "Overall Match 🎯",
-                        f"{match_analysis.get('overall_match_percentage', '0%')}"
-                    )
-                with col2:
-                    st.metric(
-                        "Skills Match 🧠",
-                        f"{len(match_analysis.get('matching_skills', []))} skills"
-                    )
-                with col3:
-                    st.metric(
-                        "Skills to Develop 📈",
-                        f"{len(match_analysis.get('missing_skills', []))} skills"
-                    )
-
-                # Detailed Analysis Tabs
-                tab1, tab2, tab3, tab4, tab5 = st.tabs([
-                    "Skills Analysis 📊", "Experience Match 🗂️", "Recommendations 💡", "Cover Letter 💌", "Updated Resume 📝"
-                ])
-
-                with tab1:
-                    st.subheader("Matching Skills")
-                    for skill in match_analysis.get('matching_skills', []):
-                        st.success(f"✅ {skill['skill_name']}")
-
-                    st.subheader("Missing Skills")
-                    for skill in match_analysis.get('missing_skills', []):
-                        st.warning(f"⚠️ {skill['skill_name']}")
-                        st.info(f"Suggestion: {skill['suggestion']}")
-
-                    # Skills analysis graph
-                    matching_skills_count = len(match_analysis.get('matching_skills', []))
-                    missing_skills_count = len(match_analysis.get('missing_skills', []))
-                    skills_data = pd.DataFrame({
-                        'Status': ['Matching', 'Missing'],
-                        'Count': [matching_skills_count, missing_skills_count]
-                    })
-                    fig = px.bar(skills_data, x='Status', y='Count', color='Status',
-                                 color_discrete_sequence=['#5cb85c', '#d9534f'], title='Skills Analysis')
-                    fig.update_layout(xaxis_title='Status', yaxis_title='Count')
-                    st.plotly_chart(fig)
-
-                with tab2:
-                    st.write("### Experience Match Analysis 🗂️")
-                    st.write(match_analysis.get('experience_match_analysis', ''))
-                    st.write("### Education Match Analysis 🎓")
-                    st.write(match_analysis.get('education_match_analysis', ''))
-
-                with tab3:
-                    st.write("### Key Recommendations 🔑")
-                    for rec in match_analysis.get('recommendations_for_improvement', []):
-                        st.info(f"**{rec['recommendation']}**")
-                        st.write(f"**Section:** {rec['section']}")
-                        st.write(f"**Guidance:** {rec['guidance']}")
-
-                    st.write("### ATS Optimization Suggestions 🤖")
-                    for suggestion in match_analysis.get('ats_optimization_suggestions', []):
-                        st.write("---")
-                        st.warning(f"**Section to Modify:** {suggestion['section']}")
-                        if suggestion.get('current_content'):
-                            st.write(f"**Current Content:** {suggestion['current_content']}")
-                        st.write(f"**Suggested Change:** {suggestion['suggested_change']}")
-                        if suggestion.get('keywords_to_add'):
-                            st.write(f"**Keywords to Add:** {', '.join(suggestion['keywords_to_add'])}")
-                        if suggestion.get('formatting_suggestion'):
-                            st.write(f"**Formatting Changes:** {suggestion['formatting_suggestion']}")
-                        if suggestion.get('reason'):
-                            st.info(f"**Reason for Change:** {suggestion['reason']}")
-
-                with tab4:
-                    st.write("### Cover Letter Generator 🖊️")
-                    tone = st.selectbox("Select tone 🎭", ["Professional 👔", "Enthusiastic 😃", "Confident 😎", "Friendly 👋"])
-
-                    if st.button("Generate Cover Letter ✍️"):
-                        with st.spinner("✍️ Crafting your cover letter..."):
-                            cover_letter = cover_letter_gen.generate_cover_letter(
-                                job_analysis, resume_analysis, match_analysis, tone.lower().split()[0])
-                            st.markdown("### Your Custom Cover Letter 💌")
-                            st.text_area("", cover_letter, height=400)
-                            st.download_button(
-                                "Download Cover Letter 📥",
-                                cover_letter,
-                                "cover_letter.txt",
-                                "text/plain"
-                            )
-
-                with tab5:
-                    st.write("### Updated Resume 📝")
-                    updated_resume = generate_updated_resume(resume_text, match_analysis)
-                    # Provide a download button for the updated resume
-                    st.download_button(
-                        "Download Updated Resume 📥",
-                        updated_resume,
-                        "updated_resume.pdf",
-                        mime="application/pdf"
-                    )
-
-
-if __name__ == "__main__":
-    main()
+            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.", "", ""
+
+
+        if not resume_text:
+             return "Could not extract text from the uploaded file.", "", ""
+
+        # print(f"\nResume Content (partial):")
+        # print(resume_text[:500] + "...")
+
+        # 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.", "", ""
+
+
+        model = genai.GenerativeModel('gemini-1.5-flash-latest') # Use an appropriate model
+        print("Generative model initialized.")
+
+        # 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.
+
+        Job Description:
+        {job_description}
+
+        Resume:
+        {resume_text}
+
+        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.")
+
+        # 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.
+
+        Original Resume:
+        {resume_text}
+
+        Job Description:
+        {job_description}
+
+        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.")
+
+        # 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.
+
+        Job Description:
+        {job_description}
+
+        ATS-Optimized Resume:
+        {resume_output_text}
+
+        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.")
+
+    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()