Add application file

app.py

@@ -0,0 +1,318 @@
+import gradio as gr
+import json
+from datetime import datetime
+import os
+import tempfile
+
+# Import the resume agent (assuming the previous code is saved as resume_agent.py)
+from resume_agent import ResumeAgent, get_sample_resume, get_sample_job_description
+
+class GradioResumeApp:
+    """Gradio interface for the Resume Optimization Agent"""
+    
+    def __init__(self):
+        self.agent = ResumeAgent()
+        self.sample_resume = get_sample_resume()
+        self.sample_job_desc = get_sample_job_description()
+    
+    def process_resume(self, resume_file, resume_text, job_file, job_text, api_key):
+        """Process resume optimization request"""
+        
+        # Validate API key
+        if not api_key or api_key.strip() == "":
+            return self._create_error_output("❌ Please provide a valid Gemini API key")
+        
+        # Set API key
+        import google.generativeai as genai
+        try:
+            genai.configure(api_key=api_key.strip())
+        except Exception as e:
+            return self._create_error_output(f"❌ Invalid API key: {str(e)}")
+        
+        # Get resume content
+        resume_content = self._get_content(resume_file, resume_text, self.sample_resume, "resume")
+        if not resume_content:
+            return self._create_error_output("❌ No resume content provided")
+        
+        # Get job description content
+        job_content = self._get_content(job_file, job_text, self.sample_job_desc, "job description")
+        
+        try:
+            # Process optimization
+            results = self.agent.optimize_resume(resume_content, job_content)
+            
+            # Format results for display
+            return self._format_results(results)
+            
+        except Exception as e:
+            return self._create_error_output(f"❌ Error during optimization: {str(e)}")
+    
+    def _get_content(self, file, text, sample, content_type):
+        """Extract content from file or text input"""
+        if file is not None:
+            try:
+                content = file.decode('utf-8') if isinstance(file, bytes) else file.read()
+                return content
+            except Exception as e:
+                print(f"Error reading {content_type} file: {str(e)}")
+        
+        if text and text.strip():
+            return text.strip()
+        
+        return sample
+    
+    def _create_error_output(self, error_message):
+        """Create error output tuple"""
+        return (
+            error_message,  # summary
+            "",  # experience_analysis
+            "",  # keyword_analysis
+            "",  # design_suggestions
+            "",  # editing_suggestions
+            ""   # full_results
+        )
+    
+    def _format_results(self, results):
+        """Format optimization results for Gradio display"""
+        
+        # New Summary
+        new_summary = results.get("new_summary", "No summary generated")
+        
+        # Experience Analysis
+        experience_analysis = ""
+        if "experience_matching" in results:
+            exp_data = results["experience_matching"]
+            if isinstance(exp_data, dict) and "ranked_experiences" in exp_data:
+                experience_analysis = "📊 **Experience Relevance Analysis:**\n\n"
+                for i, exp in enumerate(exp_data["ranked_experiences"][:3], 1):
+                    if isinstance(exp, dict):
+                        score = exp.get("relevance_score", "N/A")
+                        points = exp.get("matching_points", [])
+                        experience_analysis += f"**Experience {i}:** Score {score}/10\n"
+                        experience_analysis += f"Key matches: {', '.join(points[:3])}\n\n"
+            else:
+                experience_analysis = "Experience analysis completed"
+        
+        # Keyword Analysis
+        keyword_analysis = ""
+        if "keyword_optimization" in results:
+            kw_data = results["keyword_optimization"]
+            if isinstance(kw_data, dict):
+                ats_score = kw_data.get("ats_score", "N/A")
+                missing_kw = kw_data.get("missing_keywords", [])
+                keyword_analysis = f"🎯 **ATS Optimization Score:** {ats_score}/100\n\n"
+                if missing_kw:
+                    keyword_analysis += f"**Missing Keywords:** {', '.join(missing_kw[:10])}\n\n"
+                
+                recommendations = kw_data.get("recommendations", [])
+                if recommendations:
+                    keyword_analysis += "**Recommendations:**\n"
+                    for rec in recommendations[:3]:
+                        keyword_analysis += f"• {rec}\n"
+            else:
+                keyword_analysis = "Keyword optimization completed"
+        
+        # Design Suggestions
+        design_suggestions = ""
+        if "design_suggestions" in results:
+            design_data = results["design_suggestions"]
+            if isinstance(design_data, dict):
+                template = design_data.get("recommended_template", "Standard")
+                layout_tips = design_data.get("layout_suggestions", [])
+                design_suggestions = f"🎨 **Recommended Template:** {template}\n\n"
+                if layout_tips:
+                    design_suggestions += "**Layout Suggestions:**\n"
+                    for tip in layout_tips[:5]:
+                        design_suggestions += f"• {tip}\n"
+            else:
+                design_suggestions = "Design suggestions generated"
+        
+        # Editing Suggestions
+        editing_suggestions = ""
+        if "editing_suggestions" in results:
+            edit_data = results["editing_suggestions"]
+            if isinstance(edit_data, dict):
+                score = edit_data.get("overall_score", "N/A")
+                feedback = edit_data.get("summary_feedback", "")
+                editing_suggestions = f"✏️ **Overall Quality Score:** {score}/100\n\n"
+                if feedback:
+                    editing_suggestions += f"**Feedback:** {feedback}\n\n"
+                
+                grammar_errors = edit_data.get("grammar_errors", [])
+                if grammar_errors:
+                    editing_suggestions += "**Grammar Improvements:**\n"
+                    for error in grammar_errors[:3]:
+                        if isinstance(error, dict):
+                            original = error.get("original", "")
+                            corrected = error.get("corrected", "")
+                            editing_suggestions += f"• '{original}' → '{corrected}'\n"
+            else:
+                editing_suggestions = "Editing analysis completed"
+        
+        # Full Results (JSON)
+        full_results = json.dumps(results, indent=2, default=str)
+        
+        return (
+            new_summary,
+            experience_analysis,
+            keyword_analysis,
+            design_suggestions,
+            editing_suggestions,
+            full_results
+        )
+    
+    def create_interface(self):
+        """Create and return Gradio interface"""
+        
+        with gr.Blocks(
+            title="AI Resume Optimizer",
+            theme=gr.themes.Soft(),
+            css="""
+            .gradio-container {
+                max-width: 1200px !important;
+            }
+            .main-header {
+                text-align: center;
+                margin-bottom: 30px;
+            }
+            """
+        ) as interface:
+            
+            gr.HTML("""
+            <div class="main-header">
+                <h1>🚀 AI Resume Optimization Agent</h1>
+                <p>Upload your resume and job description to get AI-powered optimization suggestions</p>
+            </div>
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.HTML("<h2>📄 Input</h2>")
+                    
+                    # API Key input
+                    api_key = gr.Textbox(
+                        label="🔑 Gemini API Key",
+                        placeholder="Enter your Gemini API key here...",
+                        type="password",
+                        info="Get your free API key from Google AI Studio"
+                    )
+                    
+                    # Resume input
+                    with gr.Tab("Resume Upload"):
+                        resume_file = gr.File(
+                            label="Upload Resume (PDF/TXT/DOCX)",
+                            file_types=[".pdf", ".txt", ".docx"]
+                        )
+                    
+                    with gr.Tab("Resume Text"):
+                        resume_text = gr.Textbox(
+                            label="Paste Resume Text",
+                            placeholder="Paste your resume content here...",
+                            lines=8,
+                            value=self.sample_resume
+                        )
+                    
+                    # Job description input
+                    with gr.Tab("Job Description Upload"):
+                        job_file = gr.File(
+                            label="Upload Job Description",
+                            file_types=[".pdf", ".txt", ".docx"]
+                        )
+                    
+                    with gr.Tab("Job Description Text"):
+                        job_text = gr.Textbox(
+                            label="Paste Job Description",
+                            placeholder="Paste job description here...",
+                            lines=6,
+                            value=self.sample_job_desc
+                        )
+                    
+                    # Optimize button
+                    optimize_btn = gr.Button(
+                        "🚀 Optimize Resume",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column(scale=1):
+                    gr.HTML("<h2>📊 Results</h2>")
+                    
+                    with gr.Tab("✨ New Summary"):
+                        summary_output = gr.Textbox(
+                            label="Optimized Professional Summary",
+                            lines=4,
+                            interactive=False
+                        )
+                    
+                    with gr.Tab("📈 Experience Analysis"):
+                        experience_output = gr.Markdown(
+                            label="Experience Relevance Analysis"
+                        )
+                    
+                    with gr.Tab("🎯 Keywords & ATS"):
+                        keyword_output = gr.Markdown(
+                            label="Keyword Optimization & ATS Score"
+                        )
+                    
+                    with gr.Tab("🎨 Design Tips"):
+                        design_output = gr.Markdown(
+                            label="Design & Formatting Suggestions"
+                        )
+                    
+                    with gr.Tab("✏️ Editing Tips"):
+                        editing_output = gr.Markdown(
+                            label="Grammar & Content Improvements"
+                        )
+                    
+                    with gr.Tab("📋 Full Report"):
+                        full_output = gr.Code(
+                            label="Complete Analysis (JSON)",
+                            language="json"
+                        )
+            
+            # Event handlers
+            optimize_btn.click(
+                fn=self.process_resume,
+                inputs=[resume_file, resume_text, job_file, job_text, api_key],
+                outputs=[
+                    summary_output,
+                    experience_output,
+                    keyword_output,
+                    design_output,
+                    editing_output,
+                    full_output
+                ]
+            )
+            
+            # Example section
+            with gr.Row():
+                gr.HTML("""
+                <div style="margin-top: 30px; padding: 20px; background-color: #f8f9fa; border-radius: 10px;">
+                    <h3>💡 Quick Start Guide:</h3>
+                    <ol>
+                        <li>Get your free Gemini API key from <a href="https://makersuite.google.com/app/apikey" target="_blank">Google AI Studio</a></li>
+                        <li>Upload your resume or use the sample provided</li>
+                        <li>Add a job description you're targeting (optional)</li>
+                        <li>Click "Optimize Resume" to get AI-powered suggestions</li>
+                    </ol>
+                    <p><strong>Features:</strong> Professional Summary Generation • Experience Matching • ATS Optimization • Design Suggestions • Grammar & Style Improvements</p>
+                </div>
+                """)
+        
+        return interface
+
+def main():
+    """Launch the Gradio app"""
+    app = GradioResumeApp()
+    interface = app.create_interface()
+    
+    # Launch the app
+    interface.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7860,
+        share=True,  # Create public link
+        debug=True
+    )
+
+if __name__ == "__main__":
+    main()