Add Gradio app

gradio_app.py

@@ -0,0 +1,590 @@
+import os
+import gradio as gr
+import json
+from datetime import datetime
+import tempfile
+
+# Import your existing modules
+from core.utils import FileProcessor, star_rating
+from core.question_generator import generate_question
+from core.answering_competitor import Answering_competitor
+from core.response_evaluator import scorer
+from core.summary_utils import custom_css, generate_text_summary, clean_json_response
+from core.generate_summary import generate_summary_content
+from core.speech_converter import text_to_audio, load_model
+
+# Initialize Whisper model
+whisper_model = load_model()
+
+# Global CSS for styling
+CUSTOM_CSS = """
+.gradio-container {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+
+.question-container {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    padding: 20px;
+    border-radius: 10px;
+    color: white;
+    margin: 10px 0;
+}
+
+.score-container {
+    background: #f8f9fa;
+    padding: 15px;
+    border-radius: 8px;
+    border-left: 4px solid #007bff;
+    margin: 10px 0;
+}
+
+.summary-section {
+    background: #ffffff;
+    padding: 20px;
+    border-radius: 10px;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+    margin: 15px 0;
+}
+
+.metric-card {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 20px;
+    border-radius: 10px;
+    text-align: center;
+    margin: 10px;
+}
+
+.strength-card {
+    background: #d4edda;
+    border: 1px solid #c3e6cb;
+    color: #155724;
+    padding: 15px;
+    border-radius: 8px;
+}
+
+.weakness-card {
+    background: #f8d7da;
+    border: 1px solid #f5c6cb;
+    color: #721c24;
+    padding: 15px;
+    border-radius: 8px;
+}
+"""
+
+def initialize_app_state():
+    """Initialize the application state"""
+    return {
+        'current_page': 'welcome',
+        'questions': [],
+        'current_question': 0,
+        'resume_text': '',
+        'jd_text': '',
+        'job_role': '',
+        'improve_percentage': 10,
+        'user_answers': [],
+        'ai_answers': [],
+        'scores': [],
+        'track_score': [],
+        'summary_data': None,
+        'questions_generated': False,
+        'competitor_initialized': False
+    }
+
+def process_files_and_generate_questions(resume_file, jd_file, jd_text, job_role, improve_percentage, app_state):
+    """Process uploaded files and generate questions"""
+    try:
+        # Process resume
+        if resume_file is None:
+            return "❌ Please upload a resume file", app_state, gr.update(visible=False)
+        
+        resume_text = FileProcessor.read_resume(resume_file)
+        
+        # Process job description
+        jd_content = ""
+        if jd_file is not None:
+            if jd_file.name.endswith('.pdf'):
+                jd_content = FileProcessor.read_job_description_pdf(jd_file)
+            elif jd_file.name.endswith('.txt'):
+                jd_content = FileProcessor.read_job_description_txt(jd_file)
+        elif jd_text and len(jd_text.strip()) > 10:
+            jd_content = jd_text.strip()
+        else:
+            return "❌ Please provide a job description", app_state, gr.update(visible=False)
+        
+        if not job_role or len(job_role.strip()) == 0:
+            return "❌ Please enter a job role", app_state, gr.update(visible=False)
+        
+        # Update state
+        app_state['resume_text'] = resume_text
+        app_state['jd_text'] = jd_content
+        app_state['job_role'] = job_role
+        app_state['improve_percentage'] = improve_percentage
+        app_state['current_page'] = 'loading'
+        
+        # Generate questions
+        questions = generate_question(resume_text, jd_content, job_role)
+        app_state['questions'] = questions
+        app_state['questions_generated'] = True
+        
+        # Initialize competitor
+        comp_ans_gen = Answering_competitor(
+            resume=resume_text,
+            job_description=jd_content,
+            difficulty_level=improve_percentage,
+            questions=questions
+        )
+        comp_ans_gen.extract_factors()
+        comp_ans_gen.determine_enhancement()
+        comp_ans_gen.generate_resume()
+        
+        # Generate competitor answers
+        comp_answers = comp_ans_gen.answer_questions()
+        app_state['ai_answers'] = list(comp_answers.values())
+        app_state['competitor_initialized'] = True
+        app_state['current_page'] = 'questions'
+        app_state['current_question'] = 0
+        
+        return "✅ Questions generated successfully! Starting interview...", app_state, gr.update(visible=True)
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}", app_state, gr.update(visible=False)
+
+def get_current_question_display(app_state):
+    """Get the current question display information"""
+    if not app_state['questions'] or app_state['current_question'] >= len(app_state['questions']):
+        return "No questions available", "", "", False, False, gr.update(visible=False)
+    
+    current_q = app_state['current_question']
+    question = app_state['questions'][current_q]
+    ai_answer = app_state['ai_answers'][current_q] if current_q < len(app_state['ai_answers']) else ""
+    
+    progress = f"Question {current_q + 1} of {len(app_state['questions'])}"
+    
+    show_prev = current_q > 0
+    show_next = current_q < len(app_state['questions']) - 1
+    show_summary = current_q == len(app_state['questions']) - 1
+    
+    return question, ai_answer, progress, show_prev, show_next or show_summary, gr.update(visible=True)
+
+def submit_answer(user_answer, audio_file, app_state):
+    """Submit user answer and get scoring"""
+    if not user_answer and not audio_file:
+        return "Please provide an answer", app_state, "", ""
+    
+    # Handle audio transcription if provided
+    final_answer = user_answer
+    if audio_file:
+        try:
+            # Create temporary file for audio processing
+            with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp_file:
+                # Save audio file
+                with open(audio_file, 'rb') as f:
+                    tmp_file.write(f.read())
+                tmp_file.flush()
+                
+                # Transcribe audio
+                transcribed = whisper_model.transcribe(tmp_file.name)["text"]
+                final_answer = transcribed if not user_answer else user_answer + " " + transcribed
+                
+                # Clean up
+                os.unlink(tmp_file.name)
+        except Exception as e:
+            return f"Audio transcription error: {str(e)}", app_state, "", ""
+    
+    current_q = app_state['current_question']
+    
+    # Ensure user_answers list is long enough
+    while len(app_state['user_answers']) <= current_q:
+        app_state['user_answers'].append("")
+    
+    app_state['user_answers'][current_q] = final_answer
+    
+    # Score the answer
+    try:
+        result_score = scorer(
+            jd=app_state['jd_text'],
+            ques=app_state['questions'][current_q],
+            user=final_answer,
+            competitor=app_state['ai_answers'][current_q]
+        )
+        
+        # Track user score
+        user_score = result_score["user"]
+        app_state['track_score'].append(user_score)
+        
+        # Format scoring display
+        user_scoring = f"""
+        **Your Score:**
+        Structure: {star_rating(user_score['structure_star']['score'])}
+        Depth: {star_rating(user_score['depth']['score'])}
+        Clarity: {star_rating(user_score['clarity']['score'])}
+        Correctness: {star_rating(user_score['correctness']['score'])}
+        """
+        
+        competitor_score = result_score["competitor"]
+        ai_scoring = f"""
+        **AI Competitor Score:**
+        Structure: {star_rating(competitor_score['structure_star']['score'])}
+        Depth: {star_rating(competitor_score['depth']['score'])}
+        Clarity: {star_rating(competitor_score['clarity']['score'])}
+        Correctness: {star_rating(competitor_score['correctness']['score'])}
+        """
+        
+        return "Answer submitted successfully!", app_state, user_scoring, ai_scoring
+        
+    except Exception as e:
+        return f"Scoring error: {str(e)}", app_state, "", ""
+
+def navigate_question(direction, app_state):
+    """Navigate between questions"""
+    if direction == "prev" and app_state['current_question'] > 0:
+        app_state['current_question'] -= 1
+    elif direction == "next" and app_state['current_question'] < len(app_state['questions']) - 1:
+        app_state['current_question'] += 1
+    elif direction == "summary":
+        app_state['current_page'] = 'summary'
+    
+    return app_state
+
+def generate_summary_display(app_state):
+    """Generate and display interview summary"""
+    if app_state['current_page'] != 'summary':
+        return "Summary not ready", app_state, "", gr.update(visible=False)
+    
+    try:
+        # Ensure all answers are collected
+        if not app_state['summary_data']:
+            # Calculate scores
+            app_state['scores'] = [
+                [
+                    int(track_score["structure_star"]["score"]),
+                    int(track_score["depth"]["score"]),
+                    int(track_score["clarity"]["score"]),
+                    int(track_score["correctness"]["score"])
+                ] 
+                for track_score in app_state['track_score']
+            ]
+            
+            # Generate summary
+            summary_json = generate_summary_content(
+                app_state['resume_text'],
+                app_state['jd_text'],
+                app_state['job_role'],
+                app_state['questions'],
+                app_state['user_answers'],
+                app_state['ai_answers'],
+                app_state['scores']
+            )
+            
+            cleaned_json = clean_json_response(summary_json)
+            summary_data = json.loads(cleaned_json)
+            app_state['summary_data'] = summary_data
+        
+        summary_data = app_state['summary_data']
+        
+        # Calculate average score
+        scores_list = app_state['scores']
+        avg_score = sum([sum(q_score) for q_score in scores_list]) / (len(scores_list) * 4) * 10 if scores_list else 0
+        
+        # Format summary display
+        summary_html = f"""
+        <div class="summary-section">
+            <h1>🎯 Interview Performance Summary</h1>
+            
+            <div class="metric-card">
+                <h2>Overall Score: {avg_score:.1f}/100</h2>
+                <p>Questions Analyzed: {len(summary_data.get("comparison_table", []))}</p>
+                <p>Topics Covered: {len(summary_data.get("topics_covered", []))}</p>
+            </div>
+            
+            <h2>📈 Performance Trends</h2>
+            <div class="score-container">
+                {summary_data.get("trends", "No trend data available")}
+            </div>
+            
+            <div style="display: flex; gap: 20px;">
+                <div style="flex: 1;">
+                    <h2>💪 Your Strengths</h2>
+                    <div class="strength-card">
+                        {summary_data.get("strengths", "No strengths data available")}
+                    </div>
+                </div>
+                
+                <div style="flex: 1;">
+                    <h2>🎯 Areas for Improvement</h2>
+                    <div class="weakness-card">
+                        {summary_data.get("weaknesses", "No weaknesses data available")}
+                    </div>
+                </div>
+            </div>
+            
+            <h2>📚 Recommended Resources</h2>
+            <div class="score-container">
+                {summary_data.get("resources", "No resources available")}
+            </div>
+        </div>
+        """
+        
+        # Generate text summary for download
+        text_summary = generate_text_summary(summary_data, scores_list)
+        
+        return summary_html, app_state, text_summary, gr.update(visible=True)
+        
+    except Exception as e:
+        return f"Error generating summary: {str(e)}", app_state, "", gr.update(visible=False)
+
+def create_gradio_interface():
+    """Create the main Gradio interface"""
+    
+    with gr.Blocks(css=CUSTOM_CSS, title="AI Job Matcher - HiredGPT Duel") as app:
+        # State management
+        app_state = gr.State(initialize_app_state())
+        
+        gr.Markdown("# 🤖 AI Job Matcher - HiredGPT Duel")
+        gr.Markdown("Test your interview skills against an AI competitor!")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("## 📄 Upload Your Resume")
+                resume_file = gr.File(label="Resume (PDF)", file_types=[".pdf"])
+                
+                gr.Markdown("## 📋 Job Description")
+                jd_method = gr.Radio(
+                    choices=["Upload File", "Paste Text"],
+                    value="Upload File",
+                    label="How to provide job description?"
+                )
+                
+                jd_file = gr.File(
+                    label="Job Description File (PDF/TXT)",
+                    file_types=[".pdf", ".txt"],
+                    visible=True
+                )
+                
+                jd_text = gr.Textbox(
+                    label="Job Description Text",
+                    lines=5,
+                    visible=False
+                )
+                
+                gr.Markdown("## ⭐ Competitor Settings")
+                improve_percentage = gr.Slider(
+                    minimum=10,
+                    maximum=100,
+                    step=10,
+                    value=10,
+                    label="AI Competitor Strength (%)"
+                )
+                
+                gr.Markdown("## 💼 Job Role")
+                job_role = gr.Textbox(label="Job Title/Role")
+                
+                start_btn = gr.Button("🚀 Start HiredGPT Duel", variant="primary")
+                status_msg = gr.Markdown("")
+            
+            with gr.Column(scale=2):
+                # Question Interface
+                question_interface = gr.Group(visible=False)
+                
+                with question_interface:
+                    progress_display = gr.Markdown("")
+                    question_display = gr.Markdown("")
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### 👤 Your Answer")
+                            user_answer = gr.Textbox(
+                                label="Type your answer",
+                                lines=6,
+                                placeholder="Enter your response here..."
+                            )
+                            audio_input = gr.Audio(
+                                label="Or record audio answer",
+                                type="filepath"
+                            )
+                            submit_answer_btn = gr.Button("Submit Answer", variant="primary")
+                            
+                            user_score_display = gr.Markdown("")
+                        
+                        with gr.Column():
+                            gr.Markdown("### 🤖 AI Competitor's Answer")
+                            ai_answer_display = gr.Markdown("")
+                            ai_score_display = gr.Markdown("")
+                    
+                    with gr.Row():
+                        prev_btn = gr.Button("⬅️ Previous", visible=False)
+                        next_btn = gr.Button("Next ➡️", visible=False)
+                        summary_btn = gr.Button("📊 View Summary", visible=False)
+                
+                # Summary Interface
+                summary_interface = gr.Group(visible=False)
+                
+                with summary_interface:
+                    summary_display = gr.HTML("")
+                    download_summary = gr.File(label="Download Summary", visible=False)
+                    restart_btn = gr.Button("🔄 Start New Interview", variant="secondary")
+        
+        # Event handlers
+        def toggle_jd_input(method):
+            if method == "Upload File":
+                return gr.update(visible=True), gr.update(visible=False)
+            else:
+                return gr.update(visible=False), gr.update(visible=True)
+        
+        jd_method.change(
+            toggle_jd_input,
+            inputs=[jd_method],
+            outputs=[jd_file, jd_text]
+        )
+        
+        def handle_start_click(resume, jd_file, jd_text, job_role, improve_pct, state):
+            msg, new_state, interface_update = process_files_and_generate_questions(
+                resume, jd_file, jd_text, job_role, improve_pct, state
+            )
+            
+            if new_state['current_page'] == 'questions':
+                question, ai_answer, progress, show_prev, show_next, _ = get_current_question_display(new_state)
+                return (
+                    msg, new_state, interface_update,
+                    f"**{progress}**", f"### {question}",
+                    "", ai_answer, "", "",
+                    gr.update(visible=show_prev), gr.update(visible=show_next),
+                    gr.update(visible=False), gr.update(visible=False)
+                )
+            
+            return (
+                msg, new_state, interface_update,
+                "", "", "", "", "", "",
+                gr.update(visible=False), gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=False)
+            )
+        
+        start_btn.click(
+            handle_start_click,
+            inputs=[resume_file, jd_file, jd_text, job_role, improve_percentage, app_state],
+            outputs=[
+                status_msg, app_state, question_interface,
+                progress_display, question_display,
+                user_answer, ai_answer_display, user_score_display, ai_score_display,
+                prev_btn, next_btn, summary_btn, summary_interface
+            ]
+        )
+        
+        def handle_submit_answer(user_ans, audio, state):
+            msg, new_state, user_scoring, ai_scoring = submit_answer(user_ans, audio, state)
+            
+            # Show AI answer after submission
+            current_q = new_state['current_question']
+            ai_answer = new_state['ai_answers'][current_q] if current_q < len(new_state['ai_answers']) else ""
+            
+            # Update navigation buttons
+            show_prev = current_q > 0
+            show_next = current_q < len(new_state['questions']) - 1
+            show_summary = current_q == len(new_state['questions']) - 1
+            
+            return (
+                new_state, ai_answer, user_scoring, ai_scoring,
+                gr.update(visible=show_prev),
+                gr.update(visible=show_next and not show_summary),
+                gr.update(visible=show_summary)
+            )
+        
+        submit_answer_btn.click(
+            handle_submit_answer,
+            inputs=[user_answer, audio_input, app_state],
+            outputs=[
+                app_state, ai_answer_display, user_score_display, ai_score_display,
+                prev_btn, next_btn, summary_btn
+            ]
+        )
+        
+        def handle_navigation(direction, state):
+            new_state = navigate_question(direction, state)
+            
+            if new_state['current_page'] == 'summary':
+                summary_html, updated_state, text_summary, summary_visible = generate_summary_display(new_state)
+                
+                # Create downloadable file
+                summary_file = None
+                if text_summary:
+                    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+                        f.write(text_summary)
+                        summary_file = f.name
+                
+                return (
+                    updated_state,
+                    gr.update(visible=False), summary_visible,
+                    summary_html, summary_file,
+                    "", "", "", "", "", "",
+                    gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+                )
+            else:
+                question, ai_answer, progress, show_prev, show_next, _ = get_current_question_display(new_state)
+                current_q = new_state['current_question']
+                user_ans = new_state['user_answers'][current_q] if current_q < len(new_state['user_answers']) else ""
+                
+                return (
+                    new_state,
+                    gr.update(visible=True), gr.update(visible=False),
+                    "", None,
+                    f"**{progress}**", f"### {question}", user_ans, ai_answer, "", "",
+                    gr.update(visible=show_prev), gr.update(visible=show_next),
+                    gr.update(visible=current_q == len(new_state['questions']) - 1)
+                )
+        
+        prev_btn.click(
+            lambda state: handle_navigation("prev", state),
+            inputs=[app_state],
+            outputs=[
+                app_state, question_interface, summary_interface,
+                summary_display, download_summary,
+                progress_display, question_display, user_answer, ai_answer_display,
+                user_score_display, ai_score_display,
+                prev_btn, next_btn, summary_btn
+            ]
+        )
+        
+        next_btn.click(
+            lambda state: handle_navigation("next", state),
+            inputs=[app_state],
+            outputs=[
+                app_state, question_interface, summary_interface,
+                summary_display, download_summary,
+                progress_display, question_display, user_answer, ai_answer_display,
+                user_score_display, ai_score_display,
+                prev_btn, next_btn, summary_btn
+            ]
+        )
+        
+        summary_btn.click(
+            lambda state: handle_navigation("summary", state),
+            inputs=[app_state],
+            outputs=[
+                app_state, question_interface, summary_interface,
+                summary_display, download_summary,
+                progress_display, question_display, user_answer, ai_answer_display,
+                user_score_display, ai_score_display,
+                prev_btn, next_btn, summary_btn
+            ]
+        )
+        
+        def restart_app():
+            return initialize_app_state(), gr.update(visible=False), gr.update(visible=False)
+        
+        restart_btn.click(
+            restart_app,
+            outputs=[app_state, question_interface, summary_interface]
+        )
+    
+    return app
+
+if __name__ == "__main__":
+    # Create and launch the Gradio app
+    app = create_gradio_interface()
+    app.launch(
+        
+        server_port=7860,
+        share=False,
+        debug=True
+    )