Update app.py

app.py

@@ -3,25 +3,63 @@ import json
 import os
 from dotenv import load_dotenv
 from art_explorer import ExplorationPathGenerator
-from typing import Dict, Any
+from typing import Dict, Any, Optional, Union
 
 # Load environment variables
 load_dotenv()
 
-# Initialize the generator
-generator = ExplorationPathGenerator(api_key=os.getenv("GROQ_API_KEY"))
+# Initialize the generator with error handling
+try:
+  api_key = os.getenv("GROQ_API_KEY")
+  if not api_key:
+      raise ValueError("GROQ_API_KEY not found in environment variables")
+  generator = ExplorationPathGenerator(api_key=api_key)
+except Exception as e:
+  print(f"Error initializing ExplorationPathGenerator: {e}")
+  raise
 
 def format_output(result: Dict[str, Any]) -> str:
-  """Format the exploration result for display"""
-  return json.dumps(result, indent=2)
+  """Format the exploration result for display with error handling"""
+  try:
+      return json.dumps(result, indent=2, ensure_ascii=False)
+  except Exception as e:
+      return json.dumps({
+          "error": str(e),
+          "status": "failed",
+          "message": "Failed to format output"
+      }, indent=2)
 
 def parse_json_input(json_str: str, default_value: Any) -> Any:
-  """Safely parse JSON input with fallback to default value"""
+  """
+  Safely parse JSON input with detailed error handling
+  
+  Args:
+      json_str: JSON string to parse
+      default_value: Fallback value if parsing fails
+  """
+  if not json_str or json_str.strip() in ('', '{}', '[]'):
+      return default_value
   try:
-      return json.loads(json_str) if json_str else default_value
-  except json.JSONDecodeError:
+      return json.loads(json_str)
+  except json.JSONDecodeError as e:
+      print(f"JSON parse error: {e}")
       return default_value
 
+def validate_parameters(
+  depth: int,
+  domain: str,
+  parameters: Dict[str, Any]
+) -> Dict[str, Any]:
+  """Validate and merge exploration parameters"""
+  validated_params = {
+      "depth": max(1, min(10, depth)),  # Clamp depth between 1-10
+      "domain": domain if domain.strip() else None,
+      "previous_explorations": []
+  }
+  if isinstance(parameters, dict):
+      validated_params.update(parameters)
+  return validated_params
+
 def explore(
   query: str,
   path_history: str = "[]",
@@ -30,32 +68,34 @@ def explore(
   domain: str = ""
 ) -> str:
   """
-  Generate exploration path based on user input
+  Generate exploration path based on user input with comprehensive error handling
   
   Args:
       query (str): User's exploration query
       path_history (str): JSON string of previous exploration path
       parameters (str): JSON string of exploration parameters
-      depth (int): Exploration depth parameter
+      depth (int): Exploration depth parameter (1-10)
       domain (str): Specific domain context
   
   Returns:
-      str: Formatted JSON string of exploration results
+      str: Formatted JSON string of exploration results or error message
   """
-  # Parse path history
-  selected_path = parse_json_input(path_history, [])
-  
-  # Parse and merge parameters
-  base_parameters = {
-      "depth": depth,
-      "domain": domain if domain else None,
-      "previous_explorations": []
-  }
-  
-  custom_parameters = parse_json_input(parameters, {})
-  exploration_parameters = {**base_parameters, **custom_parameters}
-
   try:
+      # Input validation
+      if not query.strip():
+          raise ValueError("Query cannot be empty")
+
+      # Parse and validate inputs
+      selected_path = parse_json_input(path_history, [])
+      custom_parameters = parse_json_input(parameters, {})
+      
+      # Validate and merge parameters
+      exploration_parameters = validate_parameters(depth, domain, custom_parameters)
+
+      # Debug logging
+      print(f"Processing query: {query}")
+      print(f"Parameters: {json.dumps(exploration_parameters, indent=2)}")
+
       # Generate exploration path
       result = generator.generate_exploration_path(
           user_query=query,
@@ -63,20 +103,29 @@ def explore(
           exploration_parameters=exploration_parameters
       )
       
-      # Format and return result
+      # Validate result
+      if not isinstance(result, dict):
+          raise ValueError("Invalid response format from generator")
+      
       return format_output(result)
+
   except Exception as e:
       error_response = {
           "error": str(e),
           "status": "failed",
-          "message": "Failed to generate exploration path"
+          "message": "Failed to generate exploration path",
+          "details": {
+              "query": query,
+              "depth": depth,
+              "domain": domain
+          }
       }
+      print(f"Error in explore function: {e}")
       return format_output(error_response)
 
 def create_interface() -> gr.Interface:
-  """Create and configure the Gradio interface"""
+  """Create and configure the Gradio interface with enhanced examples and documentation"""
   
-  # Define interface inputs
   inputs = [
       gr.Textbox(
           label="Exploration Query",
@@ -109,13 +158,35 @@ def create_interface() -> gr.Interface:
       )
   ]
 
-  # Define interface output
   output = gr.Textbox(
       label="Exploration Result",
       lines=20
   )
 
-  # Create and return interface
+  examples = [
+      [
+          "Explore the evolution of Renaissance painting techniques",
+          "[]",
+          "{}",
+          5,
+          "Renaissance"
+      ],
+      [
+          "Investigate the influence of Japanese art on Impressionism",
+          "[]",
+          "{}",
+          7,
+          "Impressionism"
+      ],
+      [
+          "Analyze the development of Cubism through Picasso's work",
+          "[]",
+          "{}",
+          6,
+          "Cubism"
+      ]
+  ]
+
   return gr.Interface(
       fn=explore,
       inputs=inputs,
@@ -124,35 +195,32 @@ def create_interface() -> gr.Interface:
       description="""
       Generate structured exploration paths for art history queries.
       
-      - Enter your query about any art history topic
-      - Optionally provide previous exploration path as JSON
-      - Adjust exploration parameters as needed
-      - View the generated exploration path with multiple dimensions
+      ## Features:
+      - Dynamic exploration path generation
+      - Contextual understanding of art history
+      - Multi-dimensional analysis
+      - Customizable exploration depth
+      
+      ## Usage:
+      1. Enter your art history query
+      2. Adjust exploration depth (1-10)
+      3. Optionally specify domain context
+      4. View generated exploration path
       """,
-      examples=[
-          [
-              "Explore the evolution of Renaissance painting techniques",
-              "[]",
-              "{}",
-              5,
-              "Renaissance"
-          ],
-          [
-              "Investigate the influence of Japanese art on Impressionism",
-              "[]",
-              "{}",
-              7,
-              "Impressionism"
-          ]
-      ],
-      theme="default"
+      examples=examples,
+      theme="default",
+      analytics_enabled=False
   )
 
-# Create and launch the interface
-iface = create_interface()
-
-
-
 if __name__ == "__main__":
-  # Launch with custom configurations
-  iface.launch()
+  try:
+      # Create interface
+      iface = create_interface()
+      # Launch with custom configurations
+      iface.launch(
+          server_name="0.0.0.0",
+          share=False,
+          debug=True
+      )
+  except Exception as e:
+      print(f"Failed to launch interface: {e}")