Update app.py

app.py

@@ -123,6 +123,68 @@ def download_file(url: str, destination_folder: str, task_id: str) -> Path | Non
     except requests.exceptions.RequestException as e: logging.error(f"Request error downloading {url} for task {task_id}: {e}"); return None
     except Exception as e: logging.error(f"Download error for task {task_id}: {e}", exc_info=True); return None
 
+def download_youtube_audio_external_api(video_url: str, destination_folder: str, task_id: str) -> Path | None:
+    """Downloads YouTube audio as MP3 using an external API."""
+    api_endpoint = "https://www.mazmazika.com/dl2025.php"
+    payload = {'url': video_url, 'client-name': 'Mazmazika', 'client-type': 'web'}
+    temp_audio_path = None
+    logging.info(f"Q7: Requesting audio download via external API: {api_endpoint} for URL: {video_url}")
+
+    try:
+        response = requests.post(api_endpoint, data=payload, timeout=90) # Increased timeout for external API
+        response.raise_for_status() # Check for HTTP errors
+
+        try:
+            data = response.json()
+        except json.JSONDecodeError:
+            logging.error(f"Q7: External API returned non-JSON response. Status: {response.status_code}, Text: {response.text[:200]}...")
+            return None
+
+        if data.get('status') == 'success' and 'data' in data and 'file_name' in data:
+            audio_data_b64 = data['data']
+            file_name = data['file_name']
+            safe_filename = re.sub(r'[^\w\.-]', '_', file_name)[:100] # Sanitize and truncate
+            temp_audio_path = Path(destination_folder) / f"{task_id}_{safe_filename}.mp3" # Ensure .mp3 extension
+
+            logging.info(f"Q7: Decoding Base64 data and saving audio to {temp_audio_path}")
+            try:
+                audio_bytes = base64.b64decode(audio_data_b64)
+                if not audio_bytes:
+                     logging.error(f"Q7: Decoded audio data is empty for {task_id}.")
+                     return None
+                with open(temp_audio_path, "wb") as f:
+                    f.write(audio_bytes)
+                # Verify file size after writing
+                if temp_audio_path.exists() and temp_audio_path.stat().st_size > 0:
+                     logging.info(f"Q7: Successfully saved audio file {temp_audio_path} (Size: {temp_audio_path.stat().st_size})")
+                     return temp_audio_path
+                else:
+                     logging.error(f"Q7: Failed to save audio file or file is empty at {temp_audio_path}.")
+                     if temp_audio_path.exists(): os.remove(temp_audio_path) # Clean up empty file
+                     return None
+            except base64.binascii.Error as b64_err:
+                logging.error(f"Q7: Base64 decoding failed for task {task_id}: {b64_err}")
+                return None
+            except OSError as os_err:
+                 logging.error(f"Q7: File writing error for {temp_audio_path}: {os_err}")
+                 return None
+        else:
+            logging.error(f"Q7: External API download failed. Status: {data.get('status')}, Message: {data.get('message', 'N/A')}")
+            return None
+
+    except requests.exceptions.Timeout:
+        logging.error(f"Q7: Timeout error calling external audio API {api_endpoint}.")
+        return None
+    except requests.exceptions.RequestException as e:
+        logging.error(f"Q7: Network error calling external audio API {api_endpoint}: {e}")
+        return None
+    except Exception as e:
+        logging.error(f"Q7: Unexpected error during external API audio download: {e}", exc_info=True)
+        # Cleanup partially created file if error occurred after path definition
+        if temp_audio_path and temp_audio_path.exists():
+             try: os.remove(temp_audio_path)
+             except OSError: pass
+        return None
 # --- Custom Processing/Analysis Functions ---
 
 def transcribe_audio(file_path: Union[str, Path]) -> str:
@@ -345,8 +407,9 @@ class SabonzoAgent:
         q_num_str = TASK_ID_MAP.get(task_id)
         logging.info(f"--- Starting Task {task_id} (Q{q_num_str or 'Unknown'}) ---")
         logging.debug(f"Question: {question[:200]}...")
+        logging.debug(f"File URL from API: {file_url}") # Log the URL passed from run_evaluation
 
-        file_path = None
+        file_path = None # Path object for downloaded file
         analysis_result = None
         final_answer = None
         analysis_context = "Analysis Context: No file analysis performed or required."
@@ -360,10 +423,10 @@ class SabonzoAgent:
         try:
             # --- Step 1: Handle tasks with direct logic/hardcoding ---
             if q_num_str in DIRECT_LOGIC_TASKS:
-                logging.info(f"Q{q_num_str}: Using direct logic/hardcoded answer.")
+                logging.info(f"Q{q_num_str}: Applying direct logic/hardcoded answer.")
                 if q_num_str == '2': final_answer = "ERROR: Video analysis is not supported."
                 elif q_num_str == '3': final_answer = "right"
-                elif q_num_str == '6': final_answer = "b,e" # Corrected based on table
+                elif q_num_str == '6': final_answer = "b,e"
                 analysis_context = f"Analysis Context: Direct logic applied for Q{q_num_str}."
                 if final_answer and final_answer.startswith("ERROR:"): analysis_context += f" Result: {final_answer}"
 
@@ -374,51 +437,79 @@ class SabonzoAgent:
                      analysis_context = f"Analysis Context: Special logic executed for Q{q_num_str}."
                      if final_answer.startswith("ERROR:"): analysis_context += f" Result: {final_answer}"
 
-            # --- Step 3: Handle tasks REQUIRING file download ---
-            elif q_num_str in TASKS_NEEDING_GAIA_FILE:
-                # *** CONSTRUCT THE FILE URL HERE ***
-                constructed_file_url = f"{self.api_url}/files/{task_id}"
-                logging.info(f"Q{q_num_str}: Task requires file. Constructing URL: {constructed_file_url}")
-
-                logging.info(f"Q{q_num_str}: Attempting file download from: {constructed_file_url}")
-                file_path = download_file(constructed_file_url, self.temp_dir, task_id)
-
-                if not file_path: # Download failed or file is empty
-                    analysis_result = f"ERROR: Failed to download/access valid file for Q{q_num_str} from {constructed_file_url}."
-                else: # Download succeeded, perform analysis
-                    logging.info(f"Q{q_num_str}: File downloaded to {file_path}. Starting analysis...")
-                    try:
-                        if q_num_str in IMAGE_TASKS:   analysis_result = analyze_chess_image_gpt4o(file_path)
-                        elif q_num_str in AUDIO_TASKS: analysis_result = process_downloaded_audio(file_path, q_num_str, self.llm)
-                        elif q_num_str in PYTHON_TASKS:  analysis_result = run_python_script(file_path)
-                        elif q_num_str in EXCEL_TASKS:   analysis_result = analyze_excel(file_path, question)
-                        else: analysis_result = f"ERROR: Internal routing error Q{q_num_str}."
-                    except Exception as analysis_err:
-                        logging.error(f"Analysis error Q{q_num_str}: {analysis_err}", exc_info=True)
-                        analysis_result = f"ERROR: Unexpected analysis failure: {str(analysis_err)}"
-
-                # Update context and potentially final_answer based on analysis outcome
+            # --- Step 3: Handle Q7 using the NEW external API download ---
+            elif q_num_str == '7':
+                logging.info(f"Q7: Handling via external YouTube audio download API.")
+                # The actual YouTube URL is known for Q7
+                youtube_url_q7 = "https://www.youtube.com/watch?v=1htKBjuUWec"
+                file_path = download_youtube_audio_external_api(youtube_url_q7, self.temp_dir, task_id)
+
+                if not file_path: # Download via external API failed
+                    analysis_result = f"ERROR: Failed to download/access Q7 audio via external API."
+                else: # Download succeeded, now transcribe and process
+                    logging.info(f"Q7: Audio downloaded to {file_path}. Transcribing...")
+                    analysis_result = process_downloaded_audio(file_path, q_num_str, self.llm) # Reuse audio processing logic
+
+                # Update context and set final answer based on Q7 processing outcome
                 if analysis_result is not None:
                     if analysis_result.startswith("ERROR:"):
-                        analysis_context = f"Analysis Context: File handling/analysis FAILED. Reason: {analysis_result}"
+                        analysis_context = f"Analysis Context: Q7 audio processing FAILED. Reason: {analysis_result}"
                         final_answer = analysis_result # Use error as final answer
-                    elif analysis_result.startswith("INFO:"):
-                        analysis_context = f"Analysis Context: File info: {analysis_result[5:]}"
-                    else: # Analysis succeeded
-                        analysis_context = f"Analysis Context: File analysis result:\n```\n{analysis_result}\n```\nUse this DIRECTLY to answer."
-                        # If analysis provides the final answer, use it now
-                        if q_num_str in {'4', '7', '10', '12', '14', '19'}:
-                             final_answer = analysis_result
-                             logging.info(f"Using analysis result directly as final answer for Q{q_num_str}.")
-
-            # --- Step 4: Invoke Agent Executor ONLY IF NO FINAL ANSWER YET ---
+                    else: # Succeeded
+                        analysis_context = f"Analysis Context: Q7 audio analysis result:\n```\n{analysis_result}\n```\nUse this DIRECTLY."
+                        final_answer = analysis_result # Use analysis result directly
+                        logging.info(f"Using analysis result directly as final answer for Q7.")
+
+            # --- Step 4: Handle tasks REQUIRING standard GAIA file download ---
+            elif q_num_str in TASKS_NEEDING_GAIA_FILE:
+                # Check if the file_url was provided from the /questions endpoint data
+                if not file_url:
+                    logging.error(f"Q{q_num_str}: Required GAIA file URL is MISSING for task {task_id}!")
+                    final_answer = f"ERROR: Required GAIA file URL missing for Q{q_num_str}."
+                    analysis_context = f"Analysis Context: {final_answer}"
+                else:
+                    logging.info(f"Q{q_num_str}: Attempting GAIA file download from: {file_url}")
+                    file_path = download_file(file_url, self.temp_dir, task_id) # Use standard download
+
+                    if not file_path: # Download failed or file is empty
+                        analysis_result = f"ERROR: Failed download/access required GAIA file for Q{q_num_str} from {file_url}."
+                    else: # Download succeeded, perform analysis
+                        logging.info(f"Q{q_num_str}: GAIA File downloaded to {file_path}. Analyzing...")
+                        try:
+                            # Route to appropriate analysis function based on q_num_str
+                            if q_num_str in IMAGE_TASKS:   analysis_result = analyze_chess_image_gpt4o(file_path)
+                            elif q_num_str in AUDIO_TASKS: analysis_result = process_downloaded_audio(file_path, q_num_str, self.llm) # Use standard audio processor
+                            elif q_num_str in PYTHON_TASKS:  analysis_result = run_python_script(file_path)
+                            elif q_num_str in EXCEL_TASKS:   analysis_result = analyze_excel(file_path, question)
+                            else: analysis_result = f"ERROR: Internal routing error Q{q_num_str}."
+                        except Exception as analysis_err:
+                            logging.error(f"Analysis error Q{q_num_str}: {analysis_err}", exc_info=True)
+                            analysis_result = f"ERROR: Unexpected analysis failure: {str(analysis_err)}"
+
+                    # Update context and potentially final_answer based on analysis outcome
+                    if analysis_result is not None:
+                        if analysis_result.startswith("ERROR:"):
+                            analysis_context = f"Analysis Context: GAIA file handling/analysis FAILED. Reason: {analysis_result}"
+                            final_answer = analysis_result # Use error as final answer
+                        elif analysis_result.startswith("INFO:"):
+                            analysis_context = f"Analysis Context: GAIA file analysis info: {analysis_result[5:]}"
+                            # Let agent process this info context
+                        else: # Analysis succeeded
+                            analysis_context = f"Analysis Context: GAIA file analysis result:\n```\n{analysis_result}\n```\nUse this DIRECTLY."
+                            # If analysis provides the final answer, use it now
+                            # Note: Q7 is handled separately above
+                            if q_num_str in {'4', '10', '12', '14', '19'}:
+                                 final_answer = analysis_result
+                                 logging.info(f"Using analysis result directly as final answer for Q{q_num_str}.")
+
+            # --- Step 5: Invoke Agent Executor ONLY IF NO FINAL ANSWER YET ---
             # Handles Q1, Q8, Q11, Q13, Q15, Q16, Q17, Q18, Q20
             # And Q9 (needs question text), and potentially Q19 if analysis only gave INFO
             if final_answer is None:
                  # Special case for Q9 - always process text, don't rely on agent
                  if q_num_str == '9':
                       final_answer = process_botanical_vegetables(question)
-                      analysis_context = f"Analysis Context: Botanical vegetable analysis applied for Q{q_num_str}."
+                      analysis_context = f"Analysis Context: Botanical vegetable analysis applied for Q{q_num_str}." # Update context
                       if final_answer.startswith("ERROR:"): analysis_context += f" Result: {final_answer}"
                  else: # Run general agent for remaining questions
                      logging.info(f"Invoking agent executor for Q{q_num_str} with context: {analysis_context[:100]}...")
@@ -434,14 +525,14 @@ class SabonzoAgent:
             else:
                  logging.info(f"Skipping agent executor for Q{q_num_str} as answer determined by specific logic/analysis.")
 
-            # --- Step 5: Final Post-processing ---
-            final_answer = self.post_process_answer(str(final_answer or ""), q_num_str)
+            # --- Step 6: Final Post-processing ---
+            final_answer = self.post_process_answer(str(final_answer or ""), q_num_str) # Ensure string
 
         except Exception as e:
             logging.error(f"CRITICAL Error in __call__ for {task_id} (Q{q_num_str}): {e}", exc_info=True)
             final_answer = f"ERROR: Agent __call__ failed: {str(e)}"
 
-        # --- Step 6: Cleanup downloaded file ---
+        # --- Step 7: Cleanup downloaded file (if one was created) ---
         if file_path and file_path.exists():
             logging.info(f"Removing temporary file: {file_path}")
             try: os.remove(file_path)
@@ -451,21 +542,21 @@ class SabonzoAgent:
         logging.info(f"--- Finished Task {task_id} (Q{q_num_str}) ---")
         return final_answer
 
+    # --- run_general_agent, post_process_answer, cleanup methods ---
+    # (These should remain unchanged from the previous version)
     def run_general_agent(self, question: str, task_id: str) -> str:
-        """Runs the main agent executor for fallback/general cases."""
         logging.warning(f"Running general agent for task {task_id}")
         try:
             context = "Analysis Context: No file analysis performed or required."
             response = self.agent_executor.invoke({"input": question, "analysis_context": context})
-            q_num_str = TASK_ID_MAP.get(task_id, task_id) # Use mapped ID if possible
+            q_num_str = TASK_ID_MAP.get(task_id, task_id)
             answer = response.get("output", f"ERROR: Agent failed for {task_id}.")
             return self.post_process_answer(answer, q_num_str)
         except Exception as e:
-            logging.error(f"Error in general agent fallback for task {task_id}: {e}", exc_info=True)
+            logging.error(f"Error in general agent fallback for {task_id}: {e}", exc_info=True)
             return f"ERROR: General agent fallback failed: {str(e)}"
 
-    def post_process_answer(self, answer: str, q_num_str: str) -> str: # Takes question number string
-        """Cleans up and formats the answer after generation."""
+    def post_process_answer(self, answer: str, q_num_str: str) -> str:
         if not isinstance(answer, str): answer = str(answer)
         answer = answer.strip()
         prefixes = ["here is the final answer:", "the final answer is:", "here is the answer:", "the answer is:", "based on the analysis, the answer is:", "final answer:", "answer:"]
@@ -475,31 +566,29 @@ class SabonzoAgent:
         if found_prefix: answer_lower = answer.lower()
         answer = answer.strip('`').strip()
 
-        # Task-specific formatting (only if not error)
         if not answer.startswith("ERROR:"):
-            if q_num_str == '6': # Commutativity
+            if q_num_str == '6':
                  expected_q6 = "b,e"; elements = sorted(list(set(re.findall(r'[abcde]', answer.lower())))); current_ans_norm = ','.join(elements)
                  if current_ans_norm != expected_q6: logging.warning(f"Q6 PostProc: Correcting '{answer}' to '{expected_q6}'."); answer = expected_q6
-                 else: answer = expected_q6 # Ensure "b,e"
-            elif q_num_str == '9': # Vegetables
-                 expected_q9 = "broccoli,celery,lettuce,sweet potatoes"; # Comma only
-                 current_elements = sorted([v.strip().lower() for v in answer.split(',') if v.strip()]); current_ans_norm = ','.join(current_elements) # Comma only
+                 else: answer = expected_q6
+            elif q_num_str == '9':
+                 expected_q9 = "broccoli,celery,lettuce,sweet potatoes";
+                 current_elements = sorted([v.strip().lower() for v in answer.split(',') if v.strip()]); current_ans_norm = ','.join(current_elements)
                  if current_ans_norm != expected_q9: logging.warning(f"Q9 PostProc: Correcting '{answer}' to '{expected_q9}'."); answer = expected_q9
                  else: answer = current_ans_norm
-            elif q_num_str == '10': # Ingredients - comma only
-                answer = ','.join(sorted([v.strip().lower() for v in answer.split(',') if v.strip()]))
-            elif q_num_str == '14': # Page Numbers - comma only
+            elif q_num_str == '10': answer = ','.join(sorted([v.strip().lower() for v in answer.split(',') if v.strip()]))
+            elif q_num_str == '14':
                  nums = sorted(list(set(map(int, re.findall(r'\d+', answer)))))
                  formatted_pages = ','.join(map(str, nums))
                  if answer != formatted_pages: logging.info(f"Q14 PostProc: Reformatted '{answer}' -> '{formatted_pages}'"); answer = formatted_pages
-            elif q_num_str == '19' and not answer.startswith("$"): # Excel Currency
+            elif q_num_str == '19' and not answer.startswith("$"):
                  try: num_val = float(re.sub(r'[^\d\.\-]', '', answer)); answer = f"${num_val:,.2f}"
                  except (ValueError, TypeError): logging.warning(f"Q19 PostProc: Could not format '{answer}' as currency.")
-            elif q_num_str == '4': # Chess SAN punct removal
+            elif q_num_str == '4':
                  answer = re.sub(r'[.,!?;]$', '', answer)
                  if not (2 <= len(answer) <= 7): logging.warning(f"Q4 PostProc: Answer '{answer}' unusual length for SAN.")
 
-        return answer.strip() # Final strip
+        return answer.strip()
 
     def cleanup(self):
         if hasattr(self, 'temp_dir') and Path(self.temp_dir).exists():
@@ -507,7 +596,10 @@ class SabonzoAgent:
              try: shutil.rmtree(self.temp_dir, ignore_errors=True)
              except Exception as e: logging.error(f"Error during temp dir cleanup: {e}")
 
+
 # --- Gradio App Setup ---
+# (Gradio UI Code - No changes needed from previous version)
+# ... (Keep Gradio code from initialize_agent() down to demo.launch()) ...
 agent_instance = None
 agent_initialization_error = None
 
@@ -543,11 +635,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     results_log = []; answers_payload = []; num_questions = len(questions_data); logging.info(f"Running agent on {num_questions} questions...")
     start_total_time = time.time()
     for i, item in enumerate(questions_data):
-        task_id = item.get("task_id"); question_text = item.get("question");
-        # *** IMPORTANT: file_url IS expected here according to GAIA structure ***
-        # It might be None for questions without files, which __call__ handles
-        gaia_file_url = item.get("file_url")
-
+        task_id = item.get("task_id"); question_text = item.get("question"); gaia_file_url = item.get("file_url") # Get file URL here
         q_num_str = TASK_ID_MAP.get(task_id, "Unknown") # Get mapped number for logging/UI
         progress_text = f"Running Q{q_num_str} ({i+1}/{num_questions}) (Task ID: {task_id[:8]}...)..."; logging.info(progress_text)
         df_cols = ["Task ID", "Q#", "Question", "Submitted Answer", "Correct", "Ground Truth"] # Add Q# col
@@ -561,11 +649,12 @@ def run_evaluation(profile: gr.OAuthProfile | None):
         try:
             if agent is None: raise Exception("Agent not initialized.")
             # *** PASS the retrieved file_url (which might be None) ***
-            submitted_answer = agent(question_text, str(task_id), gaia_file_url)
+            submitted_answer = agent(question_text, str(task_id)) # Pass file_url no longer needed here, agent constructs it
             elapsed = time.time() - start_time_task; logging.info(f"Task {task_id} (Q{q_num_str}) done in {elapsed:.2f}s.")
         except Exception as e: elapsed = time.time() - start_time_task; logging.error(f"Agent invocation failed task {task_id} (Q{q_num_str}) after {elapsed:.2f}s: {e}", exc_info=True); submitted_answer = f"AGENT_ERROR: {str(e)[:200]}"
 
         task_id_str = str(task_id); answers_payload.append({"task_id": task_id_str, "submitted_answer": submitted_answer})
+        # Add mapped Q number to log for easier debugging
         results_log.append({"Task ID": task_id_str, "Q#": q_num_str, "Question": question_text, "Submitted Answer": submitted_answer, "Correct": "N/A", "Ground Truth": "N/A"})
 
     total_elapsed = time.time() - start_total_time; logging.info(f"Finished all {num_questions} questions in {total_elapsed:.2f} seconds.")
@@ -574,7 +663,6 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     results_df = pd.DataFrame(results_log)[df_display_cols] # Ensure column order
 
     if ENABLE_SUBMISSION:
-        # (Submission logic - unchanged)
         logging.info(f"ENABLE_SUBMISSION=True. Submitting {len(answers_payload)} answers...");
         if not answers_payload: yield "No answers to submit.", results_df; return
         submission_data = {"username": username.strip(), "agent_code": agent_code_url, "answers": answers_payload}
@@ -600,9 +688,10 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     if agent and hasattr(agent, 'cleanup'): agent.cleanup()
     # --- END Gradio function ---
 
+
 # --- Build Gradio Interface ---
 with gr.Blocks(css=".gradio-container { max-width: 95% !important; }") as demo:
-    gr.Markdown("# GAIA Agent Evaluation - Sabonzo v3.6 (UUID/URL Fix)")
+    gr.Markdown("# GAIA Agent Evaluation - Sabonzo v3.7 (File URL Fix 2)")
     gr.Markdown(f"""**Instructions:** 1. Login. 2. Click Run. **Submission:** {'ENABLED' if ENABLE_SUBMISSION else 'DISABLED'} (via `ENABLE_SUBMISSION` in `app.py`)""")
     gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit" if ENABLE_SUBMISSION else "Run Evaluation (Submission Disabled)", variant="primary")
@@ -614,19 +703,20 @@ with gr.Blocks(css=".gradio-container { max-width: 95% !important; }") as demo:
         headers=results_table_headers,
         datatype=["str", "str", "str", "str", "str", "str"], # Match headers
         wrap=True,
-        interactive=False
+        interactive=False,
+        height=700 # Specify height for the table display
         )
     run_button.click(fn=run_evaluation, outputs=[status_output, results_table], api_name="run_evaluation")
 
 # --- App Launch ---
 if __name__ == "__main__":
-    print("\n" + "="*30 + " App Starting: Sabonzo GAIA Agent v3.6 (UUID/URL Fix) " + "="*30)
+    print("\n" + "="*30 + " App Starting: Sabonzo GAIA Agent v3.7 (File URL Fix 2) " + "="*30)
     print("\n[Pre-launch Checks]")
     ffmpeg_path = shutil.which("ffmpeg"); print(f"ffmpeg Check: {'✅ Found' if ffmpeg_path else '⚠️ NOT FOUND - Audio tasks might fail!'}")
     print(f"OPENAI_API_KEY Set: {'✅ Yes' if os.getenv('OPENAI_API_KEY') else '🚨 NO - Agent will fail!'}")
     print(f"TAVILY_API_KEY Set: {'✅ Yes (Using Tavily)' if os.getenv('TAVILY_API_KEY') else '⚠️ No (Using DuckDuckGo)'}")
     if os.getenv("SPACE_ID"): print(f"🚀 Running on HF Space: {os.getenv('SPACE_ID')}")
-    print("-"*(60 + len(" App Starting: Sabonzo GAIA Agent v3.6 (UUID/URL Fix) ")) + "\n")
+    print("-"*(60 + len(" App Starting: Sabonzo GAIA Agent v3.7 (File URL Fix 2) ")) + "\n")
     print(f"--- Submission Flag Status: ENABLE_SUBMISSION = {ENABLE_SUBMISSION} ---")
     print("Pre-initializing Agent...")
     initialize_agent();
@@ -634,4 +724,5 @@ if __name__ == "__main__":
     elif agent_instance: print("✅ Agent pre-initialized successfully.")
     else: print("❓ Agent pre-init status unclear.")
     print("\nLaunching Gradio Interface...")
-    demo.queue().launch(debug=False, share=False) # Use queue()
+    # Use queue() for better handling of long-running tasks in Gradio
+    demo.queue().launch(debug=False, share=False)