Update app.py

app.py

@@ -1,186 +1,174 @@
 # app.py
+import gradio as gr
+import asyncio
 import sys
 import os
-import importlib.util  # Import the utility
-import traceback       # Import traceback for detailed error printing
-
-print("--- DETAILED DEBUG INFO ---")
-print(f"Python Version: {sys.version}")
-print(f"Current Working Directory: {os.getcwd()}")
-print("sys.path:")
-for p in sys.path:
-    print(f"  - {p}")
-
-print("\n--- Checking Directory Structure ---")
-root_contents = []
-try:
-    root_contents = os.listdir('.')
-except Exception as e:
-    print(f"[ERROR] Could not list root directory contents: {e}")
-print(f"Root Directory Contents: {root_contents}")
-
-src_path = os.path.join(os.getcwd(), 'src')
-if os.path.exists(src_path) and os.path.isdir(src_path):
-    print(f"\n[OK] src Directory ('{src_path}') Exists.")
-    try:
-        src_contents = os.listdir(src_path)
-        print(f"     src Contents: {src_contents}")
-
-        chimera_path = os.path.join(src_path, 'chimera')
-        if os.path.exists(chimera_path) and os.path.isdir(chimera_path):
-            print(f"  [OK] chimera Directory ('{chimera_path}') Exists.")
-            try:
-                chimera_contents = os.listdir(chimera_path)
-                print(f"       chimera Contents: {chimera_contents}")
-
-                # Explicitly check for __init__.py in chimera
-                chimera_init_path = os.path.join(chimera_path, '__init__.py')
-                if os.path.exists(chimera_init_path):
-                     print("       [OK] src/chimera/__init__.py Exists.")
-                else:
-                     print("       [ERROR] src/chimera/__init__.py MISSING!")
-
-                core_path = os.path.join(chimera_path, 'core')
-                if os.path.exists(core_path) and os.path.isdir(core_path):
-                    print(f"    [OK] core Directory ('{core_path}') Exists.")
-                    try:
-                        core_contents = os.listdir(core_path)
-                        print(f"         core Contents: {core_contents}")
-
-                        # Explicitly check for __init__.py in core
-                        core_init_path = os.path.join(core_path, '__init__.py')
-                        if os.path.exists(core_init_path):
-                            print("         [OK] src/chimera/core/__init__.py Exists.")
-                        else:
-                            print("         [ERROR] src/chimera/core/__init__.py MISSING!")
-
-                        orchestrator_path = os.path.join(core_path, 'orchestrator.py')
-                        if os.path.exists(orchestrator_path):
-                             print(f"      [OK] orchestrator.py ('{orchestrator_path}') Exists.")
-                        else:
-                             print(f"      [ERROR] orchestrator.py ('{orchestrator_path}') MISSING!")
-                    except Exception as e:
-                        print(f"    [ERROR] Could not list core directory contents: {e}")
-                else:
-                    print(f"    [ERROR] core Directory ('{core_path}') MISSING or is not a directory.")
-            except Exception as e:
-                print(f"  [ERROR] Could not list chimera directory contents: {e}")
-        else:
-            print(f"  [ERROR] chimera Directory ('{chimera_path}') MISSING or is not a directory.")
-    except Exception as e:
-        print(f"\n[ERROR] Could not list src directory contents: {e}")
-else:
-    print(f"\n[ERROR] src Directory ('{src_path}') MISSING or is not a directory.")
-
+import traceback # Import traceback for detailed error logging if needed
 
-# --- Test importability using importlib ---
-module_name_to_test = "src.chimera.core.orchestrator"
-print(f"\n--- Testing importability of '{module_name_to_test}' using importlib ---")
-spec = None
+# --- Attempt to import necessary components for the actual app ---
 try:
-    # Clear any previous import attempts from sys.modules that might interfere
-    if module_name_to_test in sys.modules:
-        del sys.modules[module_name_to_test]
-    # Also potentially clear parent modules if issues persist
-    # if "src.chimera.core" in sys.modules: del sys.modules["src.chimera.core"]
-    # if "src.chimera" in sys.modules: del sys.modules["src.chimera"]
-    # if "src" in sys.modules: del sys.modules["src"]
-
-    spec = importlib.util.find_spec(module_name_to_test)
-except Exception as e:
-    print(f"[ERROR] Exception during importlib.util.find_spec: {type(e).__name__}: {e}")
+    from src.chimera.core.orchestrator import run_analysis
+    from src.chimera.utils.logging_config import setup_logging, logger
+    from src.chimera.config import GEMINI_API_KEY, SERPAPI_API_KEY # Import API keys to check configuration
+
+    # --- Perform initial setup ---
+    setup_logging() # Initialize logging system
+    logger.info("Logging initialized.")
+
+    # --- Configuration Checks ---
+    CONFIG_ERRORS = []
+    if not GEMINI_API_KEY:
+        CONFIG_ERRORS.append("GEMINI_API_KEY is not set.")
+        logger.error("CRITICAL CONFIG ERROR: GEMINI_API_KEY is not set.")
+    if not SERPAPI_API_KEY:
+        # Assuming SERP is essential, make it critical too
+        CONFIG_ERRORS.append("SERPAPI_API_KEY is not set.")
+        logger.error("CRITICAL CONFIG ERROR: SERPAPI_API_KEY is not set.")
+    # Add checks for other essential API keys here
+
+    # --- Set flag based on configuration status ---
+    IS_CONFIGURED_PROPERLY = not CONFIG_ERRORS
+
+except ImportError as e:
+    # Handle case where core modules cannot be imported - app cannot function
+    print(f"FATAL IMPORT ERROR: {e}")
+    print("Could not import necessary Chimera components. Ensure structure is correct and __init__.py files exist.")
     traceback.print_exc()
-
-if spec is None:
-    print(f"[FAIL] importlib.util.find_spec could NOT find module '{module_name_to_test}'.")
-    print("       This means Python's import machinery cannot locate this module.")
-    print("       Double-check directory names, __init__.py files, and potential typos.")
-else:
-    print(f"[OK] importlib.util.find_spec found module '{module_name_to_test}'.")
-    print(f"     Module Location Hint: {spec.origin}")
-    # If found, try to actually import it to see if loading fails
-    print(f"\n--- Attempting direct import of '{module_name_to_test}' using importlib.import_module ---")
+    # Define dummy elements to allow the script to potentially reach the end
+    # but indicate a non-functional state
+    run_analysis = None
+    setup_logging = lambda: print("!!! Logging setup skipped due to import error !!!")
+    logger = type('DummyLogger', (object,), {'info': print, 'warning': print, 'error': print, 'exception': print})()
+    logger.error("!!! Logging is not properly configured due to import errors !!!")
+    IS_CONFIGURED_PROPERLY = False
+    CONFIG_ERRORS = ["Core application modules failed to import."]
+    print("!!! Application will not function correctly due to import errors !!!")
+
+
+# --- Define the core Gradio interface function ---
+async def chimera_interface(query: str):
+    """
+    Wrapper function for Gradio to call the async orchestrator.
+    Handles input validation, configuration checks, and calls the backend.
+    """
+    # 1. Check if the application backend is fundamentally broken (import errors)
+    if run_analysis is None:
+        logger.error("Attempted analysis but run_analysis function failed to import during startup.")
+        # Provide a clear error message in the UI
+        return "## Error: Application Backend Failed\n\nThe core analysis function could not be loaded. Please check the application logs."
+
+    # 2. Check if essential configuration (API Keys) is missing
+    if not IS_CONFIGURED_PROPERLY:
+         logger.error(f"Attempted analysis with missing configuration: {', '.join(CONFIG_ERRORS)}")
+         error_list = "\n".join([f"- {err}" for err in CONFIG_ERRORS])
+         # Provide a clear error message in the UI
+         return f"## Error: Application Not Configured\n\nThe following essential configurations are missing:\n{error_list}\nPlease check the application secrets/environment variables."
+
+    # 3. Check for empty user input
+    if not query or not query.strip():
+        logger.warning("Received empty query.")
+        # Provide guidance in the UI
+        return "Please enter a query in the text box above."
+
+    # 4. If all checks pass, proceed with the analysis
+    logger.info(f"Gradio interface received query: '{query[:100]}...'") # Log snippet
     try:
-        imported_module = importlib.import_module(module_name_to_test)
-        print(f"[OK] Successfully imported '{module_name_to_test}'. Module type: {type(imported_module)}")
-        # Try accessing the function
-        if hasattr(imported_module, 'run_analysis'):
-             print("[OK] Function 'run_analysis' found in the imported module.")
-        else:
-             print("[ERROR] Function 'run_analysis' NOT FOUND in the imported module!")
+        # Gradio handles running the async function correctly
+        result = await run_analysis(query)
+        logger.info("Gradio interface processing complete.")
+        # Return the result (expecting markdown formatted string from backend)
+        return result
     except Exception as e:
-        print(f"[FAIL] Error occurred DURING import of '{module_name_to_test}':")
-        traceback.print_exc() # Print the full traceback for the import error
+        # Log the full error details for debugging
+        logger.exception(f"Unexpected error during run_analysis for query: '{query[:100]}...'")
+        # Provide a user-friendly error message in the UI
+        # Avoid exposing raw exception details directly unless intended for debugging UI
+        return f"## Error: Analysis Failed\n\nAn unexpected error occurred while processing your request.\nDetails have been logged by the application administrator.\n\n*(Error type: {type(e).__name__})*"
 
-print("\n--- Attempting original failing import ---")
+
+# --- Gradio UI Definition ---
+# Use a try-except block to catch errors during UI construction
+demo = None # Initialize demo to None
 try:
-    # Ensure sys.modules cache is clean before this attempt too
-    if module_name_to_test in sys.modules: del sys.modules[module_name_to_test]
+    with gr.Blocks(theme=gr.themes.Soft(), title="Project Chimera") as demo:
+        # Display configuration errors prominently if they exist
+        if not IS_CONFIGURED_PROPERLY:
+             config_error_msg = "\n".join([f"- {err}" for err in CONFIG_ERRORS])
+             gr.Markdown(
+                 f"""
+                 ## ⚠️ Application Configuration Error
+                 The application cannot function correctly because the following configurations are missing:
+                 {config_error_msg}
+                 Please contact the administrator or check the environment secrets.
+                 """,
+                 elem_id="config_error_banner"
+             )
+
+        # Main UI components
+        gr.Markdown(
+            """
+            # Project Chimera : Real-Time Global Analysis Engine
+            Enter your query to analyze real-time data from SERP and other sources using Gemini.
+            *(Example: "Analyze recent news about renewable energy investments in the US")*
+            """
+        )
+        with gr.Row():
+            query_input = gr.Textbox(
+                label="Your Query:",
+                placeholder="Type your complex question or analysis request here...",
+                lines=3,
+                elem_id="query_input_box"
+            )
+        submit_button = gr.Button("Analyze", variant="primary", elem_id="submit_button")
+        with gr.Row():
+            # Using Markdown for output allows richer formatting (like headers from error messages)
+            output_display = gr.Markdown(label="Chimera Analysis:", elem_id="output_display_markdown")
+
+        # Link the button click to the interface function
+        submit_button.click(
+            fn=chimera_interface,
+            inputs=[query_input],
+            outputs=[output_display],
+            # Add API name for potential tracking/analytics if needed by Gradio
+            # api_name="chimera_analysis"
+        )
+
+        # Example usage display
+        gr.Examples(
+            examples=[
+                "Search recent news about AI impact on healthcare.",
+                "What are the latest developments in fusion energy according to recent searches?",
+                "Summarize the latest discussion around supply chain disruptions.",
+                "What are recent news headlines mentioning 'geopolitical tensions'?"
+            ],
+            inputs=[query_input],
+            outputs=[output_display],
+            fn=chimera_interface, # Make examples clickable
+            cache_examples=False, # Avoid caching as results depend on real-time data
+            elem_id="examples_section"
+        )
 
-    from src.chimera.core.orchestrator import run_analysis
-    print("[OK] Original 'from ... import ...' statement SUCCEEDED.")
-    # If this succeeds now, the issue might have been temporary or fixed by restart
-except ModuleNotFoundError:
-    print("[FAIL] Original 'from ... import ...' statement FAILED with ModuleNotFoundError.")
-    print("       Refer to the importlib test above for clues.")
-    traceback.print_exc() # Also print traceback for ModuleNotFoundError
 except Exception as e:
-    print(f"[FAIL] Original 'from ... import ...' statement FAILED with a different error:")
+    logger.exception("FATAL: Failed to build Gradio interface.")
+    # demo remains None if gr.Blocks fails
+    print(f"Error creating Gradio Blocks: {e}")
     traceback.print_exc()
 
-print("\n--- End of Debug Script ---")
-
-# Prevent Gradio from starting since imports might have failed
-# ===============================================================
-# == COMMENT OUT OR REMOVE GRADIO CODE BELOW FOR THIS TEST RUN ==
-# ===============================================================
-# import gradio as gr
-# from src.chimera.utils.logging_config import setup_logging, logger # This import would also fail if orchestrator fails
-# from src.chimera.config import GEMINI_API_KEY
-
-# # Setup logging as soon as the app starts
-# # setup_logging() # Comment out if logging_config import fails
-
-# # Check essential configurations on startup
-# # if not GEMINI_API_KEY:
-# #     # logger.error("CRITICAL: GEMINI_API_KEY is not set. The application might not function correctly.")
-# #     print("CRITICAL: GEMINI_API_KEY is not set.") # Use print during early debug
-
-# async def chimera_interface(query: str):
-#     # Placeholder implementation for debugging
-#     print(f"Gradio interface received query (debug): {query}")
-#     if not query:
-#         return "Please enter a query."
-#     # logger.info(f"Gradio interface received query: {query}")
-#     try:
-#         # Need to import run_analysis successfully first
-#         from src.chimera.core.orchestrator import run_analysis
-#         result = await run_analysis(query)
-#         # logger.info("Gradio interface processing complete.")
-#         print("Gradio interface processing complete (debug).")
-#         return result
-#     except NameError:
-#         print("Error: run_analysis could not be imported for Gradio.")
-#         return "Error: Backend function 'run_analysis' is not available due to import issues."
-#     except Exception as e:
-#         # logger.exception("Error in Gradio interface call to run_analysis.")
-#         print(f"Error in Gradio interface call (debug): {e}")
-#         traceback.print_exc()
-#         return f"An unexpected error occurred in the backend: {e}"
-
-# # --- Gradio UI Definition ---
-# with gr.Blocks(theme=gr.themes.Soft(), title="Project Chimera (Debug Mode)") as demo:
-#     gr.Markdown(
-#         """
-#         # Project Chimera : Real-Time Global Analysis Engine (DEBUG MODE)
-#         Enter your query to analyze real-time data from SERP and other sources using Gemini.
-#         (Example: "Analyze recent news about renewable energy investments in the US")
-#         """
-#     )
-#     # ... rest of your Gradio UI definition ...
-
-# # --- Launching the App ---
-# if __name__ == "__main__":
-#     # logger.info("Starting Gradio application...")
-#     print("Starting Gradio application (debug)...")
-#     # demo.launch() # Don't launch Gradio if imports fail
+
+# --- Launching the App ---
+if __name__ == "__main__":
+    if demo and IS_CONFIGURED_PROPERLY and run_analysis is not None:
+        # Only launch if Gradio Blocks were created AND config is okay AND core function loaded
+        logger.info("Starting Gradio application...")
+        # Standard launch for Hugging Face Spaces
+        # queue() can be added for better handling of concurrent users if needed: demo.queue().launch()
+        demo.launch()
+    elif not demo:
+        logger.error("Gradio application blocks failed to initialize. Cannot launch.")
+        print("Application launch aborted due to UI build errors.")
+    else:
+        # Handles cases where config failed or run_analysis didn't import
+        logger.error("Application launch aborted due to configuration errors or failed imports.")
+        print("Application launch aborted. Please check configuration and import logs.")
+        # Keep the container running but without the app interface (or exit)
+        # Depending on HF Spaces behavior, it might restart or just show logs