Spaces:
Build error
Build error
| import os | |
| import gradio as gr | |
| import requests | |
| import inspect | |
| import pandas as pd | |
| # from agents import LlamaIndexAgent | |
| from langgraph_agent_system import run_agent_system # Updated: use the latest multi-agent system | |
| from observability import flush_traces, shutdown_observability # Add cleanup functions | |
| import asyncio | |
| import aiohttp | |
| from langfuse.langchain import CallbackHandler | |
| from langchain_core.messages import HumanMessage | |
| import tempfile | |
| import uuid | |
| # Initialize Langfuse CallbackHandler for LangGraph/Langchain (tracing) | |
| langfuse_handler = CallbackHandler() | |
| # (Keep Constants as is) | |
| # --- Constants --- | |
| DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space" | |
| # --- Basic Agent Definition --- | |
| # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------ | |
| class BasicAgent: | |
| """Wrapper that executes the latest multi-agent LangGraph system.""" | |
| def __init__(self): | |
| print("BasicAgent (latest multi-agent system) initialized.") | |
| async def aquery(self, question: str) -> str: | |
| """Run the latest async multi-agent system directly.""" | |
| print(f"Agent received question (first 50 chars): {question[:50]}...") | |
| try: | |
| # Generate unique session ID for this query | |
| session_id = f"app_session_{uuid.uuid4().hex[:8]}" | |
| # Call the latest async agent system directly | |
| answer = await run_agent_system( | |
| query=question, | |
| user_id="gradio_app_user", | |
| session_id=session_id, | |
| max_iterations=3 | |
| ) | |
| print(f"Agent returning answer: {answer}") | |
| return answer | |
| except Exception as e: | |
| print(f"Exception in aquery: {e}") | |
| return f"AGENT ERROR: {e}" | |
| # Global cache for answers (in-memory) | |
| cached_answers = None | |
| cached_results_log = None | |
| cached_questions = None | |
| async def generate_answers(profile: gr.OAuthProfile | None, progress=gr.Progress(track_tqdm=True)): | |
| """ | |
| Fetches all questions, runs the BasicAgent on them asynchronously, and returns the answers and log. | |
| """ | |
| global cached_answers, cached_results_log, cached_questions | |
| space_id = os.getenv("SPACE_ID") | |
| if profile: | |
| username = f"{profile.username}" | |
| print(f"User logged in: {username}") | |
| else: | |
| print("User not logged in.") | |
| return ( | |
| "Please Login to Hugging Face with the button.", | |
| None, | |
| gr.update(interactive=False), # Disable submit button | |
| gr.update(value=None, visible=False), # Hide download button | |
| ) | |
| api_url = DEFAULT_API_URL | |
| questions_url = f"{api_url}/questions" | |
| try: | |
| response = requests.get(questions_url, timeout=15) | |
| response.raise_for_status() | |
| questions_data = response.json() | |
| if not questions_data: | |
| print("Fetched questions list is empty.") | |
| return ( | |
| "Fetched questions list is empty or invalid format.", | |
| None, | |
| gr.update(interactive=False), | |
| gr.update(value=None, visible=False), | |
| ) | |
| print(f"Fetched {len(questions_data)} questions.") | |
| except Exception as e: | |
| print(f"Error fetching questions: {e}") | |
| return ( | |
| f"Error fetching questions: {e}", | |
| None, | |
| gr.update(interactive=False), | |
| gr.update(value=None, visible=False), | |
| ) | |
| agent = BasicAgent() | |
| results_log = [] | |
| answers_payload = [] | |
| cached_questions = questions_data | |
| total = len(questions_data) | |
| progress(0, desc="Starting answer generation...") | |
| semaphore = asyncio.Semaphore(3) # Limit concurrency to 3 | |
| async def answer_one(item): | |
| async with semaphore: | |
| task_id = item.get("task_id") | |
| question_text = item.get("question") | |
| if not task_id or question_text is None: | |
| print(f"Skipping item with missing task_id or question: {item}") | |
| return {"Task ID": task_id, "Question": question_text, "Submitted Answer": "SKIPPED"}, None | |
| try: | |
| submitted_answer = await agent.aquery(question_text) | |
| # Ensure consistent data types for payload | |
| safe_task_id = str(task_id) | |
| safe_answer = str(submitted_answer) | |
| return {"Task ID": safe_task_id, "Question": question_text, "Submitted Answer": safe_answer}, {"task_id": safe_task_id, "submitted_answer": safe_answer} | |
| except Exception as e: | |
| print(f"Error running agent on task {task_id}: {e}") | |
| return {"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"}, None | |
| tasks = [answer_one(item) for item in questions_data] | |
| results_log = [] | |
| answers_payload = [] | |
| for idx, coro in enumerate(asyncio.as_completed(tasks)): | |
| log, answer = await coro | |
| results_log.append(log) | |
| if answer: | |
| answers_payload.append(answer) | |
| progress(int((idx+1)/total*100), desc=f"Answered {idx+1}/{total}") | |
| cached_answers = answers_payload | |
| cached_results_log = results_log | |
| progress(100, desc="Done.") | |
| results_df = pd.DataFrame(results_log) | |
| # Save answers to a temporary CSV so user can download | |
| try: | |
| with tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode="w", newline="", encoding="utf-8") as tmp_csv: | |
| results_df.to_csv(tmp_csv.name, index=False) | |
| csv_path = tmp_csv.name | |
| print(f"CSV saved to {csv_path}") | |
| except Exception as e: | |
| print(f"Failed to write CSV: {e}") | |
| csv_path = None | |
| return ( | |
| "Answer generation complete. Review and submit.", | |
| results_df, | |
| gr.update(interactive=True), # Enable submit button | |
| gr.update(value=csv_path, visible=bool(csv_path)), # Show download button if csv written | |
| ) | |
| def submit_answers(profile: gr.OAuthProfile | None): | |
| """ | |
| Submits cached answers and returns the result. | |
| """ | |
| global cached_answers, cached_results_log, cached_questions | |
| space_id = os.getenv("SPACE_ID") | |
| if profile: | |
| username = f"{profile.username}" | |
| print(f"User logged in: {username}") | |
| else: | |
| print("User not logged in.") | |
| return "Please Login to Hugging Face with the button.", None | |
| if not cached_answers: | |
| print("No answers to submit.") | |
| return "No answers to submit. Please generate answers first.", None | |
| api_url = DEFAULT_API_URL | |
| submit_url = f"{api_url}/submit" | |
| agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" | |
| # Detailed logging for the submission payload (only first 3 answers to avoid clutter) | |
| preview_answers = cached_answers[:3] if cached_answers else [] | |
| print("\n--- Submission Payload Preview ---") | |
| print(f"Username: {username.strip()}") | |
| print(f"Agent Code: {agent_code}") | |
| print(f"Total Answers: {len(cached_answers)}") | |
| print(f"First Answers Sample: {preview_answers}") | |
| print("----------------------------------\n") | |
| submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": cached_answers} | |
| print(f"Submitting {len(cached_answers)} answers to: {submit_url}") | |
| try: | |
| response = requests.post(submit_url, json=submission_data, timeout=60) | |
| response.raise_for_status() | |
| print(f"Submit endpoint status code: {response.status_code}") | |
| print(f"Raw response text: {response.text[:500]}") | |
| # Attempt to parse JSON regardless of status for troubleshooting | |
| try: | |
| result_data = response.json() | |
| except Exception as json_err: | |
| print(f"Error parsing JSON response: {json_err}") | |
| raise | |
| 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.')}" | |
| ) | |
| results_df = pd.DataFrame(cached_results_log) | |
| return final_status, results_df | |
| except Exception as e: | |
| print(f"Submission error: {e}") | |
| results_df = pd.DataFrame(cached_results_log) | |
| return f"Submission Failed: {e}", results_df | |
| # --- Build Gradio Interface using Blocks --- | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# Basic Agent Evaluation Runner") | |
| gr.Markdown( | |
| """ | |
| **Instructions:** | |
| 1. Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ... | |
| 2. Log in to your Hugging Face account using the button below. This uses your HF username for submission. | |
| 3. Click 'Generate Answers' to fetch questions and run your agent. Review the answers, then click 'Submit Answers' to submit them and see your score. | |
| --- | |
| **Disclaimers:** | |
| Generating answers may take some time. This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance, you could cache the answers and submit in a separate action or answer the questions asynchronously. | |
| """ | |
| ) | |
| gr.LoginButton() | |
| with gr.Row(): | |
| generate_button = gr.Button("Generate Answers") | |
| submit_button = gr.Button("Submit Answers", interactive=False) | |
| status_output = gr.Textbox(label="Status / Submission Result", lines=5, interactive=False) | |
| results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True) | |
| # Download button appears after answers are generated | |
| download_button = gr.DownloadButton(label="Download Answers CSV", visible=False) | |
| generate_button.click( | |
| fn=generate_answers, | |
| inputs=[], | |
| outputs=[status_output, results_table, submit_button, download_button], | |
| api_name="generate_answers" | |
| ) | |
| submit_button.click( | |
| fn=submit_answers, | |
| inputs=[], | |
| outputs=[status_output, results_table], | |
| api_name="submit_answers", | |
| ) | |
| def cleanup_agent_system(): | |
| """Cleanup function for the agent system.""" | |
| try: | |
| flush_traces(background=False) | |
| shutdown_observability() | |
| print("✅ Agent system cleanup completed") | |
| except Exception as e: | |
| print(f"⚠️ Cleanup warning: {e}") | |
| if __name__ == "__main__": | |
| print("\n" + "-"*30 + " App Starting " + "-"*30) | |
| # Check for SPACE_HOST and SPACE_ID at startup for information | |
| space_host_startup = os.getenv("SPACE_HOST") | |
| space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup | |
| if space_host_startup: | |
| print(f"✅ SPACE_HOST found: {space_host_startup}") | |
| print(f" Runtime URL should be: https://{space_host_startup}.hf.space") | |
| else: | |
| print("ℹ️ SPACE_HOST environment variable not found (running locally?).") | |
| if space_id_startup: # Print repo URLs if SPACE_ID is found | |
| print(f"✅ SPACE_ID found: {space_id_startup}") | |
| print(f" Repo URL: https://huggingface.co/spaces/{space_id_startup}") | |
| print(f" Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main") | |
| else: | |
| print("ℹ️ SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.") | |
| print("-"*(60 + len(" App Starting ")) + "\n") | |
| print("Launching Gradio Interface with Latest Multi-Agent System...") | |
| print("🤖 Using: LangGraph Multi-Agent System (Lead → Research → Code → Formatter)") | |
| print("📊 Features: Langfuse v3 observability, iterative workflows, GAIA compliance") | |
| try: | |
| demo.launch(debug=True, share=False) | |
| except KeyboardInterrupt: | |
| print("\n🛑 Shutting down gracefully...") | |
| cleanup_agent_system() | |
| except Exception as e: | |
| print(f"❌ Error during app execution: {e}") | |
| cleanup_agent_system() | |
| raise |