Update app.py

app.py

@@ -5,6 +5,8 @@ from dotenv import load_dotenv
 from art_explorer import ExplorationPathGenerator
 from typing import Dict, Any, Optional, Union
 from datetime import datetime
+import networkx as nx
+import matplotlib.pyplot as plt
 
 # Load environment variables
 load_dotenv()
@@ -19,6 +21,57 @@ except Exception as e:
   print(f"Error initializing ExplorationPathGenerator: {e}")
   raise
 
+def create_graph_visualization(nodes):
+  """Create a graph visualization from exploration nodes"""
+  try:
+      # Create a new directed graph
+      G = nx.DiGraph()
+      
+      # Add nodes to the graph
+      for node in nodes:
+          G.add_node(node['id'], 
+                    title=node['title'],
+                    description=node['description'],
+                    depth=node['depth'])
+      
+      # Add edges based on connections
+      for node in nodes:
+          for conn in node['connections']:
+              G.add_edge(node['id'], 
+                        conn['target_id'], 
+                        weight=conn.get('relevance_score', 0))
+      
+      # Create the plot
+      plt.figure(figsize=(12, 8))
+      
+      # Use different colors for different depths
+      colors = ['#FF9999', '#99FF99', '#9999FF', '#FFFF99']
+      node_colors = [colors[G.nodes[node]['depth'] % len(colors)] for node in G.nodes()]
+      
+      # Create layout
+      pos = nx.spring_layout(G, k=1, iterations=50)
+      
+      # Draw the graph
+      nx.draw(G, pos,
+              node_color=node_colors,
+              with_labels=True,
+              labels={node: G.nodes[node]['title'] for node in G.nodes()},
+              node_size=2000,
+              font_size=8,
+              font_weight='bold',
+              arrows=True,
+              edge_color='gray',
+              width=1)
+      
+      # Save to a temporary file
+      plt.savefig('temp_graph.png', format='png', dpi=300, bbox_inches='tight')
+      plt.close()
+      
+      return 'temp_graph.png'
+  except Exception as e:
+      print(f"Error creating graph visualization: {e}")
+      return None
+
 def format_output(result: Dict[str, Any]) -> str:
   """Format the exploration result for display with error handling"""
   try:
@@ -31,13 +84,7 @@ def format_output(result: Dict[str, Any]) -> str:
       }, indent=2)
 
 def parse_json_input(json_str: str, default_value: Any) -> Any:
-  """
-  Safely parse JSON input with detailed error handling
-  
-  Args:
-      json_str: JSON string to parse
-      default_value: Fallback value if parsing fails
-  """
+  """Safely parse JSON input with detailed error handling"""
   if not json_str or json_str.strip() in ('', '{}', '[]'):
       return default_value
   try:
@@ -53,7 +100,7 @@ def validate_parameters(
 ) -> Dict[str, Any]:
   """Validate and merge exploration parameters"""
   validated_params = {
-      "depth": max(1, min(10, depth)),  # Clamp depth between 1-10
+      "depth": max(1, min(10, depth)),
       "domain": domain if domain.strip() else None,
       "previous_explorations": []
   }
@@ -67,48 +114,34 @@ def explore(
   parameters: str = "{}",
   depth: int = 5,
   domain: str = ""
-) -> str:
-  """
-  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 (1-10)
-      domain (str): Specific domain context
-  
-  Returns:
-      str: Formatted JSON string of exploration results or error message
-  """
+) -> tuple[str, Optional[str]]:
+  """Generate exploration path and visualization"""
   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 - FIXED HERE: changed user_query to query
       result = generator.generate_exploration_path(
-          query=query,  # Changed from user_query to query
+          query=query,
           selected_path=selected_path,
           exploration_parameters=exploration_parameters
       )
       
-      # Validate result
       if not isinstance(result, dict):
           raise ValueError("Invalid response format from generator")
       
-      return format_output(result)
+      # Create graph visualization if we have nodes
+      graph_path = None
+      if result.get("nodes"):
+          graph_path = create_graph_visualization(result["nodes"])
+      
+      return format_output(result), graph_path
 
   except Exception as e:
       error_response = {
@@ -122,101 +155,88 @@ def explore(
           }
       }
       print(f"Error in explore function: {e}")
-      return format_output(error_response)
+      return format_output(error_response), None
 
-def create_interface() -> gr.Interface:
-  """Create and configure the Gradio interface with enhanced examples and documentation"""
+def create_interface() -> gr.Blocks:
+  """Create and configure the Gradio interface"""
   
-  inputs = [
-      gr.Textbox(
-          label="Exploration Query",
-          placeholder="Enter your art history exploration query...",
-          lines=2
-      ),
-      gr.Textbox(
-          label="Path History (JSON)",
-          placeholder="[]",
-          lines=3,
-          value="[]"
-      ),
-      gr.Textbox(
-          label="Additional Parameters (JSON)",
-          placeholder="{}",
-          lines=3,
-          value="{}"
-      ),
-      gr.Slider(
-          label="Exploration Depth",
-          minimum=1,
-          maximum=10,
-          value=5,
-          step=1
-      ),
-      gr.Textbox(
-          label="Domain Context",
-          placeholder="Optional: Specify art history period or movement",
-          lines=1
-      )
-  ]
-
-  output = gr.Textbox(
-      label="Exploration Result",
-      lines=20
-  )
-
-  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,
-      outputs=output,
-      title="Art History Exploration Path Generator",
-      description="""Generate structured exploration paths for art history queries.
+  with gr.Blocks(title="Art History Exploration Path Generator") as interface:
+      gr.Markdown("""# Art History Exploration Path Generator
       
 ## Features:
 - Dynamic exploration path generation
 - Contextual understanding of art history
 - Multi-dimensional analysis
 - Customizable exploration depth
+- Interactive visualization
 
 ## Usage:
 1. Enter your art history query
 2. Adjust exploration depth (1-10)
 3. Optionally specify domain context
-4. View generated exploration path""",
-      examples=examples,
-      theme="default",
-      analytics_enabled=False
-  )
+4. View generated exploration path and visualization""")
+      
+      with gr.Row():
+          with gr.Column():
+              query_input = gr.Textbox(
+                  label="Exploration Query",
+                  placeholder="Enter your art history exploration query...",
+                  lines=2
+              )
+              path_history = gr.Textbox(
+                  label="Path History (JSON)",
+                  placeholder="[]",
+                  lines=3,
+                  value="[]"
+              )
+              parameters = gr.Textbox(
+                  label="Additional Parameters (JSON)",
+                  placeholder="{}",
+                  lines=3,
+                  value="{}"
+              )
+              depth = gr.Slider(
+                  label="Exploration Depth",
+                  minimum=1,
+                  maximum=10,
+                  value=5,
+                  step=1
+              )
+              domain = gr.Textbox(
+                  label="Domain Context",
+                  placeholder="Optional: Specify art history period or movement",
+                  lines=1
+              )
+              generate_btn = gr.Button("Generate Exploration Path")
+
+          with gr.Column():
+              text_output = gr.JSON(label="Exploration Result")
+              graph_output = gr.Image(label="Exploration Graph")
+
+      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"]
+      ]
+
+      gr.Examples(
+          examples=examples,
+          inputs=[query_input, path_history, parameters, depth, domain]
+      )
+
+      generate_btn.click(
+          fn=explore,
+          inputs=[query_input, path_history, parameters, depth, domain],
+          outputs=[text_output, graph_output]
+      )
+
+  return interface
 
 if __name__ == "__main__":
   try:
       print(f"===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
-      # Create interface
-      iface = create_interface()
-      # Launch with custom configurations
-      iface.launch()
+      # Create and launch interface
+      demo = create_interface()
+      demo.launch()
   except Exception as e:
       print(f"Failed to launch interface: {e}")