Update app.py

app.py

@@ -1,87 +1,174 @@
 import gradio as gr
-from art_explorer import ArtExplorer
-from visualization import create_map_visualization, create_timeline_visualization
+import json
+import os
 from dotenv import load_dotenv
+from art_explorer import ExplorationPathGenerator
+from typing import Dict, Any
 
 # Load environment variables
 load_dotenv()
 
-class ArtExplorerInterface:
-  def __init__(self):
-      self.explorer = ArtExplorer()
+# Initialize the generator
+generator = ExplorationPathGenerator(api_key=os.getenv("GROQ_API_KEY"))
 
-  def explore(self, query: str, zoom_level: int) -> tuple:
-      # Get exploration results
-      response = self.explorer.explore_art_period(query, zoom_level)
-      
-      if not response:
-          return "Error in exploration", None, None
-      
-      # Create visualizations
-      map_fig = create_map_visualization(self.explorer.get_location_data())
-      timeline_fig = create_timeline_visualization(self.explorer.get_timeline_data())
-      
-      # Format text response
-      text_response = f"""
-      Period: {response.time_period.name}
-      Years: {response.time_period.start_year} - {response.time_period.end_year}
-      
-      Cultural Context:
-      {response.cultural_context}
-      
-      Key Artists:
-      {', '.join(artist.name for artist in response.key_artists)}
-      
-      Notable Works:
-      {', '.join(work.title for work in response.notable_works)}
-      
-      Influence:
-      {response.influence_on_later_periods}
-      """
+def format_output(result: Dict[str, Any]) -> str:
+  """Format the exploration result for display"""
+  return json.dumps(result, indent=2)
+
+def parse_json_input(json_str: str, default_value: Any) -> Any:
+  """Safely parse JSON input with fallback to default value"""
+  try:
+      return json.loads(json_str) if json_str else default_value
+  except json.JSONDecodeError:
+      return default_value
+
+def explore(
+  query: str,
+  path_history: str = "[]",
+  parameters: str = "{}",
+  depth: int = 5,
+  domain: str = ""
+) -> str:
+  """
+  Generate exploration path based on user input
+  
+  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
+      domain (str): Specific domain context
+  
+  Returns:
+      str: Formatted JSON string of exploration results
+  """
+  # 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:
+      # Generate exploration path
+      result = generator.generate_exploration_path(
+          user_query=query,
+          selected_path=selected_path,
+          exploration_parameters=exploration_parameters
+      )
       
-      return text_response, map_fig, timeline_fig
+      # Format and return result
+      return format_output(result)
+  except Exception as e:
+      error_response = {
+          "error": str(e),
+          "status": "failed",
+          "message": "Failed to generate exploration path"
+      }
+      return format_output(error_response)
 
-  def create_interface(self):
-      with gr.Blocks(title="Art History Explorer") as interface:
-          gr.Markdown("# Art History Explorer")
-          
-          with gr.Row():
-              query_input = gr.Textbox(
-                  label="Enter your art history query",
-                  placeholder="e.g., Italian Renaissance in Florence"
-              )
-              zoom_level = gr.Slider(
-                  minimum=1,
-                  maximum=5,
-                  value=1,
-                  step=1,
-                  label="Zoom Level"
-              )
-          
-          explore_btn = gr.Button("Explore")
-          
-          with gr.Row():
-              text_output = gr.Textbox(
-                  label="Exploration Results",
-                  interactive=False
-              )
-          
-          with gr.Row():
-              map_output = gr.Plot(label="Geographic Context")
-              timeline_output = gr.Plot(label="Historical Timeline")
-          
-          explore_btn.click(
-              fn=self.explore,
-              inputs=[query_input, zoom_level],
-              outputs=[text_output, map_output, timeline_output]
-          )
+def create_interface() -> gr.Interface:
+  """Create and configure the Gradio interface"""
+  
+  # Define interface inputs
+  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
+      )
+  ]
+
+  # Define interface output
+  output = gr.Textbox(
+      label="Exploration Result",
+      lines=20
+  )
+
+  # Create and return interface
+  return gr.Interface(
+      fn=explore,
+      inputs=inputs,
+      outputs=output,
+      title="Art History Exploration Path Generator",
+      description="""
+      Generate structured exploration paths for art history queries.
       
-      return interface
+      - 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
+      """,
+      examples=[
+          [
+              "Explore the evolution of Renaissance painting techniques",
+              "[]",
+              "{}",
+              5,
+              "Renaissance"
+          ],
+          [
+              "Investigate the influence of Japanese art on Impressionism",
+              "[]",
+              "{}",
+              7,
+              "Impressionism"
+          ]
+      ],
+      theme="default"
+  )
+
+# Create and launch the interface
+iface = create_interface()
 
-def main():
-  app = ArtExplorerInterface()
-  interface = app.create_interface()
-  interface.launch(share=True)
+# Add custom CSS for better appearance
+css = """
+.gradio-container {
+  font-family: 'Arial', sans-serif;
+}
+.output-text {
+  font-family: 'Courier New', monospace;
+}
+"""
 
 if __name__ == "__main__":
-  main()
+  # Launch with custom configurations
+  iface.launch(
+      share=False,  # Set to True to create a public link
+      server_name="0.0.0.0",  # Listen on all network interfaces
+      server_port=7860,  # Default Gradio port
+      debug=True,
+      enable_queue=True,
+      max_threads=40,
+      custom_css=css
+  )