Update app.py

app.py

@@ -1,28 +1,430 @@
-from transformers import Agent
+import os
 import gradio as gr
+import requests
+import pandas as pd
+import logging
+import time
+import json
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+import hashlib
+import re
+import tempfile
+from PIL import Image
+import soundfile as sf
+import numpy as np
 
-# Hardcoded username
-USERNAME = "dmfelder"
+# Core Hugging Face Imports
+from huggingface_hub import InferenceClient
+from transformers import pipeline
 
-# Initialize the agent
-agent = Agent(
-    "https://huggingface.co/spaces/transformers/Agent/tree/main",  # example agent space
-    remote=True,
+# --- Logging Setup ---
+log_file_name = f"agent_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+log_path = os.path.join(os.getcwd(), log_file_name)
+
+print(f"[INFO] Log file will be created at: {log_path}")
+
+logging.basicConfig(
+    filename=log_path,
+    filemode='w',
+    level=logging.DEBUG,
+    format='%(asctime)s | %(levelname)-8s | %(funcName)-15s | %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
 )
 
-def ask_agent(question):
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+console_formatter = logging.Formatter('%(levelname)s: %(message)s')
+console_handler.setFormatter(console_formatter)
+logging.getLogger().addHandler(console_handler)
+
+logging.info(f"===== Application Startup at {datetime.now().isoformat()} =====")
+logging.info(f"📂 Log file configured at: {log_path}")
+
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# Patterns for extracting the final answer from agent output
+ANSWER_PATTERNS = [
+    r"the answer is:\s*(.*)", 
+    r"final_answer\((.*)\)", 
+    r"final_answer\(\s*\"(.*?)\"\s*\)",
+    r"final_answer\(\s*'(.*?)'\s*\)", 
+    r"final_answer\(\s*```(.*?)```\s*\)",
+    r"final_answer\(\s*`(.*?)`\s*\)", 
+    r"final_answer\(\s*\[(.*?)\]\s*\)",
+    r"final_answer\(\s*\{(.*?)\}\s*\)", 
+    r"final_answer\(\s*(.*?)\s*\)",
+    r"answer is\s*(.*)", 
+    r"final answer is\s*(.*)", 
+    r"final answer:\s*(.*)",
+    r"final answer of the question is:\s*(.*)", 
+    r"the final answer is:\s*(.*)",
+    r"final answer\s*:\s*(.*)", 
+    r"final_answer\s*:\s*(.*)", 
+    r"final_answer is\s*(.*)",
+    r"the value is:\s*(.*)", 
+    r"The final answer is: (.*)",
+    r"final answer of the question is (.*)", 
+    r"final answer to the question is (.*)",
+    r"final response: (.*)", 
+    r"Final Response: (.*)", 
+    r"the final response is (.*)",
+    r"Final Response is: (.*)", 
+    r"Final Answer:\s*(.*)", 
+    r"Final Answer is:\s*(.*)",
+    r"Answer:\s*(.*)", 
+    r"The answer is:\s*(.*)", 
+    r"Final Answer\s*\[([^\]]+)\]",
+    r"The final answer is\s*\[([^\]]+)\]", 
+    r"The answer is\s*\[([^\]]+)\]",
+    r"Answer\s*\[([^\]]+)\]", 
+    r"```json\n\{\"answer\":\s*\"(.*?)\"\n\}```",
+    r"```json\n\{\"answer\":\s*(.*?)\n\}```", 
+    r"\"answer\":\s*\"(.*?)\"",
+    r"\"answer\":\s*(.*)", 
+    r"(\w[\w\s\.\-,\/]*)\s*$",  # Broad pattern to catch simple answers at the end
+]
+
+@dataclass
+class QuestionLog:
+    question_num: int
+    question_preview: str
+    question_type: str
+    answer: str
+    processing_time: float
+    status: str
+
+# --- SimpleAgent Class ---
+class SimpleAgent:
+    def __init__(self, username: str, http_session: requests.Session):
+        self.username = username
+        self.http_session = http_session
+        self.client = None
+        self.pipelines = {}
+        logging.info("SimpleAgent initialized.")
+
+    def setup(self):
+        """Initialize the inference client"""
+        logging.info("Setting up agent...")
+        try:
+            self.client = InferenceClient()
+            logging.info("Agent setup complete.")
+        except Exception as e:
+            logging.exception(f"Error during agent setup: {e}")
+            raise
+
+    def __call__(self, question: str, question_type: str, tools_code: Optional[List[Dict]] = None) -> str:
+        """Main method to process a question and return an answer"""
+        if not self.client:
+            raise ValueError("Agent not initialized. Call setup() first.")
+        
+        try:
+            # For now, we'll use a simple approach with the inference client
+            # In a real implementation, you'd want to use proper agent tools
+            
+            # Create a prompt that encourages the model to give a direct answer
+            prompt = f"""Question: {question}
+Question Type: {question_type}
+
+Please provide a direct answer to this question. End your response with "Final Answer: [your answer]"
+
+Response:"""
+            
+            # Use the inference client to get a response
+            response = self.client.text_generation(
+                prompt,
+                max_new_tokens=512,
+                temperature=0.1,
+                do_sample=True,
+                return_full_text=False
+            )
+            
+            # Extract the answer from the response
+            answer = self._extract_answer(response, question_type)
+            logging.info(f"Agent response for {question_type}: {answer}")
+            return answer
+            
+        except Exception as e:
+            logging.error(f"Error in agent execution: {e}")
+            return "ERROR"
+
+    def _extract_answer(self, raw_answer: str, question_type: str) -> str:
+        """Extract the final answer from the raw response"""
+        logging.debug(f"Extracting answer from raw_answer: {raw_answer}")
+        answer = "ERROR"
+        
+        for pattern in ANSWER_PATTERNS:
+            match = re.search(pattern, raw_answer, re.IGNORECASE | re.DOTALL)
+            if match:
+                extracted_content = match.group(1).strip()
+                extracted_content = extracted_content.replace("\\n", "").replace("\\", "")
+                if extracted_content.startswith('"') and extracted_content.endswith('"'):
+                    extracted_content = extracted_content[1:-1]
+                if extracted_content.startswith("'") and extracted_content.endswith("'"):
+                    extracted_content = extracted_content[1:-1]
+                answer = extracted_content
+                logging.debug(f"Extracted answer using pattern '{pattern}': {answer}")
+                break
+        
+        if answer == "ERROR" and raw_answer:
+            # If no pattern matched, try to use the raw answer if it's short and clean
+            if len(raw_answer) < 200 and not any(kw in raw_answer.lower() for kw in ["thought", "tool", "action", "observation"]):
+                answer = raw_answer.strip()
+                logging.debug(f"No pattern matched, using raw answer directly: {answer}")
+
+        if not answer:
+            answer = "ERROR"
+        
+        return answer
+
+    def cleanup(self):
+        """Clean up resources"""
+        logging.info("Cleaning up agent resources...")
+        self.pipelines.clear()
+        logging.info("SimpleAgent resources cleaned up.")
+
+# --- Main Run and Submit Function ---
+def run_and_submit_all(request: gr.Request):
+    """
+    Fetches all questions, runs the agent on them, submits all answers,
+    and displays the results.
+    """
+    # Get the user profile from the request
+    profile = request.oauth_profile if hasattr(request, 'oauth_profile') else None
+    
+    if not profile:
+        logging.info("User not logged in.")
+        yield "Please Login to Hugging Face with the button above.", pd.DataFrame([])
+        return
+
+    username = f"{profile.username}"
+    logging.info(f"User logged in: {username}")
+
+    api_url = DEFAULT_API_URL
+    
+    # Determine agent code URL for submission
+    space_id = os.getenv("SPACE_ID") 
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "N/A_LOCAL_RUN"
+    logging.info(f"Agent code URL for submission: {agent_code}")
+
+    # Configure HTTP session with retries
+    from requests.adapters import HTTPAdapter
+    from urllib3.util.retry import Retry
+    
+    retry_strategy = Retry(
+        total=5,
+        backoff_factor=1,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS", "TRACE"]
+    )
+    adapter = HTTPAdapter(max_retries=retry_strategy) 
+    
+    http_session = requests.Session()
+    http_session.mount("https://", adapter)
+    http_session.mount("http://", adapter)
+    
+    agent = None
+    results_log = []
+
     try:
-        response = agent.run(question)
-        return response
+        # 1. Instantiate and Setup Agent
+        agent = SimpleAgent(username=username, http_session=http_session)
+        agent.setup()
+
+        # Initial yield for Gradio progress display
+        yield "🚀 Initializing and fetching questions...", pd.DataFrame([])
+
+        # 2. Fetch Questions
+        questions_url = f"{api_url}/questions"
+        logging.info(f"Fetching questions from: {questions_url}")
+        response = http_session.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        
+        if not questions_data:
+            logging.warning("Fetched questions list is empty.")
+            yield "Fetched questions list is empty or invalid format.", pd.DataFrame([])
+            return
+            
+        logging.info(f"Fetched {len(questions_data)} questions.")
+
+        # 3. Process each question
+        answers_payload = []
+        logging.info(f"Running agent on {len(questions_data)} questions...")
+
+        for i, item in enumerate(questions_data, 1):
+            task_id = item.get("task_id")
+            question_text = item.get("question", "")
+            question_type = item.get("question_type", "")
+            question_preview = item.get("question_preview", question_text[:50] + "...")
+            tools_code = item.get("tools_code")  # This might be used in advanced implementations
+
+            if not task_id:
+                logging.warning(f"Skipping item with missing task_id: {item}")
+                results_log.append({
+                    "Task ID": "MISSING", 
+                    "Question": "ERROR: Missing task_id", 
+                    "Submitted Answer": "ERROR", 
+                    "Status": "ERROR"
+                })
+                continue
+            
+            start_time = time.time()
+            submitted_answer = "ERROR"
+            status = "ERROR"
+
+            try:
+                # Call the agent
+                submitted_answer = agent(question_text, question_type, tools_code)
+                processing_time = time.time() - start_time
+                status = "OK" if submitted_answer != "ERROR" else "ERROR"
+                
+                logging.info(f"Q{i} [{question_type}] Answer: {submitted_answer} (Took {processing_time:.2f}s)")
+
+                # Note: The API expects 'submitted_answer' not 'answer'
+                answers_payload.append({
+                    "task_id": task_id, 
+                    "submitted_answer": submitted_answer
+                })
+                
+                results_log.append({
+                    "Task ID": task_id, 
+                    "Question": question_preview, 
+                    "Submitted Answer": submitted_answer, 
+                    "Status": status
+                })
+
+            except Exception as e:
+                processing_time = time.time() - start_time
+                logging.exception(f"Error running agent on task {task_id}: {e}")
+                submitted_answer = f"AGENT ERROR: {str(e)}"
+                status = "ERROR"
+                
+                answers_payload.append({
+                    "task_id": task_id, 
+                    "submitted_answer": "ERROR"
+                })
+                
+                results_log.append({
+                    "Task ID": task_id, 
+                    "Question": question_preview, 
+                    "Submitted Answer": submitted_answer, 
+                    "Status": status
+                })
+
+            # Yield progressive updates to Gradio UI
+            yield (
+                f"Processing Q{i}/{len(questions_data)}. Last Answer: {submitted_answer[:100]}",
+                pd.DataFrame(results_log)
+            )
+
+        if not answers_payload:
+            logging.info("Agent did not produce any answers to submit.")
+            yield "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+            return
+
+        # 4. Submit answers
+        submission_data = {
+            "username": username.strip(), 
+            "agent_code": agent_code, 
+            "answers": answers_payload
+        }
+        
+        submit_url = f"{api_url}/submit"
+        logging.info(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+        
+        response = http_session.post(submit_url, json=submission_data, timeout=120)
+        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.')}"
+        )
+        logging.info("Submission successful.")
+        
+        yield final_status, pd.DataFrame(results_log)
+
+    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 requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        logging.error(status_message)
+        yield status_message, pd.DataFrame(results_log)
+        
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        logging.error(status_message)
+        yield status_message, pd.DataFrame(results_log)
+        
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        logging.error(status_message)
+        yield status_message, pd.DataFrame(results_log)
+        
     except Exception as e:
-        return f"Error: {str(e)}"
+        status_message = f"An unexpected error occurred during run or submission: {e}"
+        logging.exception(status_message)
+        yield status_message, pd.DataFrame(results_log)
+        
+    finally:
+        if agent:
+            agent.cleanup()
+
 
+# --- Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("### Simple Hugging Face Agent QA")
-    question = gr.Textbox(label="Question")
-    answer = gr.Textbox(label="Answer")
-    btn = gr.Button("Ask")
+    gr.Markdown("# Hugging Face Agent Certification Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        1. Log in to your Hugging Face account using the button below.
+        2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, and submit answers.
+        3. The process may take several minutes depending on the number of questions.
+        
+        **Note:** This is a simplified agent implementation. For better performance, consider implementing proper tool usage and more sophisticated reasoning.
+        """
+    )
+    
+    gr.LoginButton()  # Add the login button back
+    run_button = gr.Button("🚀 Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    btn.click(ask_agent, inputs=question, outputs=answer)
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table],
+        show_progress=True,
+    )
 
-demo.launch()
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+    
+    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(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 for Agent Evaluation...")
+    
+    demo.launch(debug=True, share=False)