Update app.py

app.py

@@ -607,170 +607,119 @@ You have access to the following tools to gather information and perform actions
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
+    Fetches MOCK questions, runs the BasicAgent on them, simulates submission prep,
+    and displays the results. DOES NOT SUBMIT.
     """
     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
+        # For local testing without login, create a dummy username
+        username = "local_test_user"
+        print("User not logged in, using dummy username for testing.")
+        # return "Please Login to Hugging Face with the button.", None # Don't block local test
 
     api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+    # questions_url = f"{api_url}/questions" # Skip fetching
+    submit_url = f"{api_url}/submit" # Keep for context
 
     print("Instantiating agent...")
     try:
+        # This assumes the BasicAgent class is defined in the same scope
+        # when this function is actually run in the full app.py
         agent = BasicAgent()
-        if agent.asr_pipeline is None:
-             print("⚠️ ASR Pipeline failed to load during agent init. Audio questions will likely fail.")
+        if not hasattr(agent, 'asr_pipeline') or agent.asr_pipeline is None:
+             print("⚠️ ASR Pipeline might not have loaded correctly. Audio questions could fail.")
 
     except Exception as e:
         print(f"Error instantiating agent: {e}")
-        import traceback
-        traceback.print_exc() # Print full traceback for init errors
+        import traceback; traceback.print_exc()
         return f"Error initializing agent: {e}", None
     print("Agent instantiated successfully.")
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "local_run"
     print(f"Agent code URL: {agent_code}")
 
-    print(f"Fetching questions from: {questions_url}")
-    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
-        print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-    except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
-    except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+    # ==================== MOCK QUESTIONS SECTION ====================
+    print("--- USING MOCK QUESTIONS FOR TESTING ---")
+    mock_questions_data = [
+        {
+            "task_id": "mock_task_search_001",
+            "question": "What is the capital of France?"
+        },
+        {
+            "task_id": "mock_task_code_001",
+            "question": "Calculate 15 factorial using python. Only output the final number."
+        },
+        # Add more mock questions here if needed, e.g., for file/audio/youtube
+        # {
+        #     "task_id": "mock_task_audio_001",
+        #     "question": "Transcribe the audio file 'sample.mp3'", # Make sure sample.mp3 exists
+        #     "file_path": "sample.mp3"
+        # },
+    ]
+    questions_data = mock_questions_data
+    print(f"Using {len(questions_data)} mock questions.")
+    # =============================================================
 
     results_log = []
     answers_payload = []
     total_questions = len(questions_data)
-    print(f"Running agent on {total_questions} questions...")
+    print(f"Running agent on {total_questions} mock questions...")
 
-    # --- Limit for Testing ---
-    # question_limit = 5 # Uncomment and set a number (e.g., 5) to test fewer questions
-    # questions_to_run = questions_data[:question_limit]
-    # print(f"--- RUNNING WITH QUESTION LIMIT: {question_limit} ---")
-    questions_to_run = questions_data # Comment this line out if using the limit above
+    questions_to_run = questions_data # Use the mock data
 
     for i, item in enumerate(questions_to_run):
         task_id = item.get("task_id")
         question_text = item.get("question")
-        if not task_id or question_text is None:
-            print(f"Skipping item {i+1} with missing task_id or question: {item}")
-            continue
+        if not task_id or question_text is None: print(f"Skipping item {i+1}: missing task_id or question: {item}"); continue
 
-        print(f"\n--- Running Task {i+1}/{len(questions_to_run)} (ID: {task_id}) ---")
+        print(f"\n--- Running Mock Task {i+1}/{len(questions_to_run)} (ID: {task_id}) ---")
         try:
             file_path = item.get("file_path")
+            question_text_with_context = question_text
             if file_path:
                  # Check existence relative to script dir first, then CWD
-                 script_dir = os.path.dirname(os.path.realpath(__file__))
+                 try: script_dir = os.path.dirname(os.path.realpath(__file__))
+                 except NameError: script_dir = os.getcwd()
                  potential_script_path = os.path.join(script_dir, file_path)
                  potential_cwd_path = os.path.join(os.getcwd(), file_path) # Check CWD too
 
-                 if os.path.exists(potential_script_path):
-                     file_context = f"[Attached File (exists): {file_path}]" # Path relative to script is good enough for agent
-                 elif os.path.exists(potential_cwd_path):
-                     file_context = f"[Attached File (exists in cwd): {file_path}]" # Path relative to cwd
-                 else:
-                     file_context = f"[Attached File (path provided): {file_path}]" # Agent needs to handle finding it
+                 if os.path.exists(potential_script_path): file_context = f"[Attached File (exists): {file_path}]"
+                 elif os.path.exists(potential_cwd_path): file_context = f"[Attached File (exists in cwd): {file_path}]"
+                 else: file_context = f"[Attached File (path provided, NOT FOUND): {file_path}]" # Indicate if not found
 
                  question_text_with_context = f"{question_text}\n\n{file_context}"
                  print(f"Question includes file reference: {file_path}")
-            else:
-                 question_text_with_context = question_text
 
             submitted_answer = agent(question_text_with_context)
-            # Ensure answer is a string, even if agent returns None or other types
             submitted_answer_str = str(submitted_answer) if submitted_answer is not None else ""
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer_str})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer_str})
-            print(f"--- Task {task_id} Complete ---")
+            print(f"--- Mock Task {task_id} Complete ---")
         except Exception as e:
-             print(f"FATAL ERROR running agent graph on task {task_id}: {e}")
-             import traceback
-             traceback.print_exc()
+             print(f"FATAL ERROR running agent graph on mock task {task_id}: {e}")
+             import traceback; traceback.print_exc()
              submitted_answer = f"AGENT CRASH ERROR: {e}"
              answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
              results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
 
-    if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+    if not answers_payload: print("Agent did not produce any answers."); return "Agent did not produce answers.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission
+    # 4. Prepare Submission Data (for display only)
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    status_update = f"Agent finished processing mock questions. Prepared {len(answers_payload)} answers for user '{username}'."
     print(status_update)
+    print("--- MOCK RUN COMPLETE - SUBMISSION SKIPPED ---")
 
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
-    try:
-        response = requests.post(submit_url, json=submission_data, timeout=120) # Increased timeout
-        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.')}"
-        )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        # Add score details if available
-        if 'scores' in result_data:
-             scores_dict = {item['task_id']: item['score'] for item in result_data['scores']}
-             results_df['Correct'] = results_df['Task ID'].map(lambda x: scores_dict.get(x, None))
-             results_df['Correct'] = results_df['Correct'].apply(lambda x: 'Yes' if x == 1 else ('No' if x == 0 else 'N/A'))
-
-
-        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 requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The submission request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error during submission - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except Exception as e:
-        status_message = f"An unexpected error occurred during submission processing: {e}"
-        print(status_message)
-        import traceback
-        traceback.print_exc()
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+    # 5. Skip Actual Submission for Mock Run
+    final_status = "--- MOCK RUN COMPLETE ---\n" + status_update + "\nSubmission to the scoring server was SKIPPED."
+    results_df = pd.DataFrame(results_log)
+    # Add a column indicating mock status
+    results_df['Correct'] = 'N/A (Mock)'
+
+    return final_status, results_df
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo: