Update app.py

app.py

@@ -486,5 +486,239 @@ def start_answer_generation(model_choice: str):
     thread.start()
     
     return f"Answer generation started using {model_choice}. Check progress."
+def get_generation_progress():
+    """
+    Get the current progress of answer generation.
+    """
+    if not processing_status["is_processing"] and processing_status["progress"] == 0:
+        return "Not started"
+    
+    if processing_status["is_processing"]:
+        progress = processing_status["progress"]
+        total = processing_status["total"]
+        status_msg = f"Generating answers... {progress}/{total} completed"
+        return status_msg
+    else:
+        # Generation completed
+        if cached_answers:
+            # Create DataFrame with results
+            display_data = []
+            for task_id, data in cached_answers.items():
+                display_data.append({
+                    "Task ID": task_id,
+                    "Question": data["question"][:100] + "..." if len(data["question"]) > 100 else data["question"],
+                    "Generated Answer": data["answer"][:200] + "..." if len(data["answer"]) > 200 else data["answer"]
+                })
+            
+            df = pd.DataFrame(display_data)
+            status_msg = f"Answer generation completed! {len(cached_answers)} answers ready for submission."
+            return status_msg, df
+        else:
+            return "Answer generation completed but no answers were generated."
+
+def submit_cached_answers(profile: gr.OAuthProfile | None):
+    """
+    Submit the cached answers to the evaluation API.
+    """
+    global cached_answers
+    
+    if not profile:
+        return "Please log in to Hugging Face first.", None
+    
+    if not cached_answers:
+        return "No cached answers available. Please generate answers first.", None
+    
+    username = profile.username
+    space_id = os.getenv("SPACE_ID")
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "Unknown"
+    
+    # Prepare submission payload
+    answers_payload = []
+    for task_id, data in cached_answers.items():
+        answers_payload.append({
+            "task_id": task_id,
+            "submitted_answer": data["answer"]
+        })
+    
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload
+    }
+    
+    # Submit to API
+    api_url = DEFAULT_API_URL
+    submit_url = f"{api_url}/submit"
+    
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        
+        # Create results DataFrame
+        results_log = []
+        for task_id, data in cached_answers.items():
+            results_log.append({
+                "Task ID": task_id,
+                "Question": data["question"],
+                "Submitted Answer": data["answer"]
+            })
+        
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+        
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except:
+            error_detail += f" Response: {e.response.text[:500]}"
+        return f"Submission Failed: {error_detail}", None
+        
+    except requests.exceptions.Timeout:
+        return "Submission Failed: The request timed out.", None
+        
+    except Exception as e:
+        return f"Submission Failed: {e}", None
 
-def get_generation_prog
+def clear_cache():
+    """
+    Clear all cached data.
+    """
+    global cached_answers, cached_questions, processing_status
+    cached_answers = {}
+    cached_questions = []
+    processing_status = {"is_processing": False, "progress": 0, "total": 0}
+    return "Cache cleared successfully.", None
+
+def test_media_processing(image_files, audio_files, question):
+    """
+    Test the media processing functionality with uploaded files.
+    """
+    if not question:
+        question = "What can you tell me about the uploaded media?"
+    
+    agent = IntelligentAgent(debug=True)
+    
+    # Convert file paths to lists
+    image_paths = [img.name for img in image_files] if image_files else None
+    audio_paths = [aud.name for aud in audio_files] if audio_files else None
+    
+    try:
+        result = agent(question, image_files=image_paths, audio_files=audio_paths)
+        return result
+    except Exception as e:
+        return f"Error processing media: {e}"
+
+# --- Enhanced Gradio Interface ---
+with gr.Blocks(title="Intelligent Agent with Media Processing") as demo:
+    gr.Markdown("# Intelligent Agent with Conditional Search and Media Processing")
+    gr.Markdown("This agent can process images and audio files, uses an LLM to decide when search is needed, optimizing for both accuracy and efficiency.")
+
+    with gr.Row():
+        gr.LoginButton()
+        clear_btn = gr.Button("Clear Cache", variant="secondary")
+
+    with gr.Tab("Media Processing Test"):
+        gr.Markdown("### Test Image and Audio Processing")
+        
+        with gr.Row():
+            with gr.Column():
+                image_upload = gr.File(
+                    label="Upload Images",
+                    file_types=["image"],
+                    file_count="multiple"
+                )
+                audio_upload = gr.File(
+                    label="Upload Audio Files",
+                    file_types=["audio"],
+                    file_count="multiple"
+                )
+                
+            with gr.Column():
+                test_question = gr.Textbox(
+                    label="Question about the media",
+                    placeholder="What can you tell me about these files?",
+                    lines=3
+                )
+                test_btn = gr.Button("Process Media", variant="primary")
+        
+        test_output = gr.Textbox(
+            label="Processing Result",
+            lines=10,
+            interactive=False
+        )
+        
+        test_btn.click(
+            fn=test_media_processing,
+            inputs=[image_upload, audio_upload, test_question],
+            outputs=test_output
+        )
+
+    with gr.Tab("Step 1: Fetch Questions"):
+        gr.Markdown("### Fetch Questions from API")
+        fetch_btn = gr.Button("Fetch Questions", variant="primary")
+        fetch_status = gr.Textbox(label="Fetch Status", lines=2, interactive=False)
+        questions_table = gr.DataFrame(label="Available Questions", wrap=True)
+        
+        fetch_btn.click(
+            fn=fetch_questions,
+            outputs=[fetch_status, questions_table]
+        )
+
+    with gr.Tab("Step 2: Generate Answers"):
+        gr.Markdown("### Generate Answers with Intelligent Search Decision")
+        
+        with gr.Row():
+            model_choice = gr.Dropdown(
+                choices=["Llama 3.1 8B", "Mistral 7B"],
+                value="Llama 3.1 8B",
+                label="Select Model"
+            )
+            generate_btn = gr.Button("Start Answer Generation", variant="primary")
+            refresh_btn = gr.Button("Refresh Progress", variant="secondary")
+        
+        generation_status = gr.Textbox(label="Generation Status", lines=2, interactive=False)
+        answers_table = gr.DataFrame(label="Generated Answers", wrap=True)
+        
+        generate_btn.click(
+            fn=start_answer_generation,
+            inputs=[model_choice],
+            outputs=generation_status
+        )
+        
+        refresh_btn.click(
+            fn=get_generation_progress,
+            outputs=[generation_status, answers_table]
+        )
+
+    with gr.Tab("Step 3: Submit Results"):
+        gr.Markdown("### Submit Generated Answers")
+        submit_btn = gr.Button("Submit Answers", variant="primary")
+        submit_status = gr.Textbox(label="Submission Status", lines=4, interactive=False)
+        results_table = gr.DataFrame(label="Submission Results", wrap=True)
+        
+        submit_btn.click(
+            fn=submit_cached_answers,
+            outputs=[submit_status, results_table]
+        )
+
+    # Clear cache functionality
+    clear_btn.click(
+        fn=clear_cache,
+        outputs=[fetch_status, questions_table]
+    )
+
+if __name__ == "__main__":
+    demo.launch()