Update app.py

app.py

@@ -3,217 +3,202 @@ import openai
 import gradio as gr
 import json
 import plotly.graph_objects as go
-from dataclasses import dataclass
-from typing import Dict, List, Optional, Any
-
-@dataclass
-class Location:
-  name: str
-  lat: float
-  lon: float
-  relevance: str = ""
-
-@dataclass
-class ZoomState:
-  level: int
-  selection: str
+from typing import Dict, Any
 
 class ArtExplorer:
-  def __init__(self, api_key: str = None, base_url: str = None):
-      """Initialize ArtExplorer with configurable API settings."""
+  def __init__(self):
       self.client = openai.OpenAI(
-          base_url=base_url or "https://api.groq.com/openai/v1",
-          api_key=api_key or os.environ.get("GROQ_API_KEY")
+          base_url="https://api.groq.com/openai/v1",
+          api_key=os.environ.get("GROQ_API_KEY")
       )
       self.current_state = {
           "zoom_level": 0,
           "selections": {}
       }
 
-  def create_map(self, locations: List[Location]) -> go.Figure:
-      """Create an interactive map visualization."""
-      default_location = Location("Paris", 48.8566, 2.3522, "Default location")
-      locations = locations or [default_location]
+  def create_map(self, locations):
+      """Create a Plotly map figure from location data"""
+      if not locations:
+          locations = [{"name": "Paris", "lat": 48.8566, "lon": 2.3522}]
 
       fig = go.Figure(go.Scattermapbox(
-          lat=[loc.lat for loc in locations],
-          lon=[loc.lon for loc in locations],
+          lat=[loc.get('lat') for loc in locations],
+          lon=[loc.get('lon') for loc in locations],
           mode='markers',
           marker=go.scattermapbox.Marker(size=10),
-          text=[loc.name for loc in locations]
+          text=[loc.get('name') for loc in locations]
       ))
 
       fig.update_layout(
           mapbox_style="open-street-map",
           mapbox=dict(
-              center=dict(lat=locations[0].lat, lon=locations[0].lon),
+              center=dict(lat=48.8566, lon=2.3522),
               zoom=4
           ),
           margin=dict(r=0, t=0, l=0, b=0)
       )
       return fig
 
-  def get_llm_response(self, query: str, zoom_context: Optional[Dict] = None) -> Dict:
-      """Get response from LLM with error handling and logging."""
+  def get_llm_response(self, query: str, zoom_context: dict = None) -> dict:
       try:
           current_zoom_states = {
-              axis: ZoomState(self.current_state["zoom_level"], 
-                            zoom_context.get(axis, "") if zoom_context else "")
-              for axis in ["temporal", "geographical", "style", "subject"]
+              "temporal": {"level": self.current_state["zoom_level"], "selection": ""},
+              "geographical": {"level": self.current_state["zoom_level"], "selection": ""},
+              "style": {"level": self.current_state["zoom_level"], "selection": ""},
+              "subject": {"level": self.current_state["zoom_level"], "selection": ""}
           }
 
+          if zoom_context:
+              for key, value in zoom_context.items():
+                  if key in current_zoom_states:
+                      current_zoom_states[key]["selection"] = value
+
           messages = [
               {"role": "system", "content": "You are an expert art historian specializing in interactive exploration."},
-              {"role": "user", "content": self._format_prompt(query, current_zoom_states)}
+              {"role": "user", "content": CONTEXTUAL_ZOOM_PROMPT.format(
+                  user_query=query,
+                  current_zoom_states=json.dumps(current_zoom_states, indent=2)
+              )}
           ]
 
-          print(f"Sending request to LLM with query: {query}")
+          print("Sending request to LLM...")
           response = self.client.chat.completions.create(
               model="mixtral-8x7b-32768",
               messages=messages,
               temperature=0.1,
               max_tokens=2048
           )
-          
-          # Clean and parse response
-          content = response.choices[0].message.content.strip()
-          print(f"Raw LLM response: {content}")
-          
-          result = json.loads(content)
-          print(f"Parsed response: {json.dumps(result, indent=2)}")
-          
+          print("Received response from LLM")
+          result = json.loads(response.choices[0].message.content)
           return result
-          
-      except json.JSONDecodeError as e:
-          print(f"JSON parsing error: {str(e)}")
-          print(f"Problematic content: {content if 'content' in locals() else 'No content'}")
-          return self.get_default_response()
       except Exception as e:
-          print(f"Unexpected error: {str(e)}")
+          print(f"Error in LLM response: {str(e)}")
           return self.get_default_response()
 
-  def _format_prompt(self, query: str, zoom_states: Dict[str, ZoomState]) -> str:
-      """Format the prompt for LLM with current context."""
-      return CONTEXTUAL_ZOOM_PROMPT.format(
-          user_query=query,
-          current_zoom_states=json.dumps(zoom_states, indent=2)
-      )
+  def get_default_response(self):
+      return CONTEXTUAL_ZOOM_default_response
 
-  def create_interface(self) -> gr.Blocks:
-      """Create the Gradio interface with proper component organization."""
-      with gr.Blocks(title="Art History Explorer", theme="default") as demo:
-          self._create_header()
+  def create_interface(self):
+      with gr.Blocks() as demo:
+          gr.Markdown("# Art History Explorer")
           
           with gr.Row():
-              query, search_btn = self._create_search_section()
-          
+              query = gr.Textbox(
+                  label="Enter your art history query",
+                  placeholder="e.g., Napoleon wars, Renaissance Italy"
+              )
+              search_btn = gr.Button("Explore")
+
           with gr.Row():
-              time_controls = self._create_temporal_section()
-              geo_controls = self._create_geographical_section()
-          
+              # Temporal axis
+              with gr.Column():
+                  time_slider = gr.Slider(
+                      minimum=1000,
+                      maximum=2024,
+                      label="Time Period",
+                      interactive=True
+                  )
+                  time_explanation = gr.Markdown()
+                  time_zoom = gr.Button("🔍 Zoom Time Period")
+
+              # Geographical axis
+              with gr.Column():
+                  map_plot = gr.Plot(label="Geographic Location")
+                  geo_explanation = gr.Markdown()
+                  geo_zoom = gr.Button("🔍 Zoom Geography")
+
           with gr.Row():
-              style_controls = self._create_style_section()
-          
-          self._setup_event_handlers(
-              search_btn, query,
-              time_controls, geo_controls, style_controls
+              style_select = gr.Dropdown(
+                  multiselect=True,
+                  label="Artistic Styles"
+              )
+              style_explanation = gr.Markdown()
+              style_zoom = gr.Button("🔍 Zoom Styles")
+
+          # Set up event handlers
+          search_btn.click(
+              fn=self._handle_search,
+              inputs=[query],
+              outputs=[
+                  time_slider,
+                  map_plot,
+                  style_select,
+                  time_explanation,
+                  geo_explanation,
+                  style_explanation
+              ]
           )
-          
-          return demo
 
-  def _create_header(self):
-      """Create the header section of the interface."""
-      gr.Markdown(
-          """
-          # Art History Explorer
-          Explore art history through time, space, and style.
-          """
-      )
+          time_zoom.click(
+              fn=lambda q, v: self._handle_zoom("temporal", q, v),
+              inputs=[query, time_slider],
+              outputs=[time_slider, time_explanation]
+          )
 
-  def _create_search_section(self):
-      """Create the search input section."""
-      query = gr.Textbox(
-          label="Enter your art history query",
-          placeholder="e.g., Napoleon wars, Renaissance Italy",
-          lines=2
-      )
-      search_btn = gr.Button("Explore", variant="primary")
-      return query, search_btn
-
-  def _create_temporal_section(self):
-      """Create the temporal control section."""
-      with gr.Column():
-          slider = gr.Slider(
-              minimum=1000,
-              maximum=2024,
-              label="Time Period",
-              interactive=True
+          geo_zoom.click(
+              fn=lambda q, v: self._handle_zoom("geographical", q, v),
+              inputs=[query, map_plot],
+              outputs=[map_plot, geo_explanation]
           )
-          explanation = gr.Markdown()
-          zoom_btn = gr.Button("🔍 Zoom Time Period")
-          return {"slider": slider, "explanation": explanation, "zoom": zoom_btn}
-
-  def _create_geographical_section(self):
-      """Create the geographical control section."""
-      with gr.Column():
-          map_plot = gr.Plot(label="Geographic Location")
-          explanation = gr.Markdown()
-          zoom_btn = gr.Button("🔍 Zoom Geography")
-          return {"map": map_plot, "explanation": explanation, "zoom": zoom_btn}
-
-  def _create_style_section(self):
-      """Create the style control section."""
-      with gr.Column():
-          select = gr.Dropdown(
-              multiselect=True,
-              label="Artistic Styles"
+
+          style_zoom.click(
+              fn=lambda q, v: self._handle_zoom("style", q, v),
+              inputs=[query, style_select],
+              outputs=[style_select, style_explanation]
           )
-          explanation = gr.Markdown()
-          zoom_btn = gr.Button("🔍 Zoom Styles")
-          return {"select": select, "explanation": explanation, "zoom": zoom_btn}
-
-  def _setup_event_handlers(self, search_btn, query, time_controls, geo_controls, style_controls):
-      """Set up all event handlers for the interface."""
-      search_btn.click(
-          fn=self._handle_search,
-          inputs=[query],
-          outputs=[
-              time_controls["slider"],
-              geo_controls["map"],
-              style_controls["select"],
-              time_controls["explanation"],
-              geo_controls["explanation"],
-              style_controls["explanation"]
-          ]
-      )
 
-      self._setup_zoom_handlers(query, time_controls, geo_controls, style_controls)
+          return demo
 
   def _handle_search(self, query: str) -> Dict[str, Any]:
-      """Handle the search button click."""
+      """Handle the initial search query"""
       config = self.get_llm_response(query)
-      return self._process_configuration(config)
-
-  def _process_configuration(self, config: Dict) -> Dict[str, Any]:
-      """Process the configuration returned by the LLM."""
-      axis_config = config["axis_configurations"]
-      temporal = axis_config["temporal"]["current_zoom"]
-      geographical = axis_config["geographical"]["current_zoom"]
-      style = axis_config["style"]["current_zoom"]
+      temporal_config = config["axis_configurations"]["temporal"]["current_zoom"]
+      geographical_config = config["axis_configurations"]["geographical"]["current_zoom"]
+      style_config = config["axis_configurations"]["style"]["current_zoom"]
+      
+      map_fig = self.create_map(geographical_config["locations"])
       
       return {
-          "time_slider": temporal["range"],
-          "map_plot": self.create_map([Location(**loc) for loc in geographical["locations"]]),
-          "style_select": gr.Dropdown(choices=style["options"]),
-          "time_explanation": temporal["explanation"],
-          "geo_explanation": geographical.get("explanation", ""),
-          "style_explanation": style["explanation"]
+          "time_slider": temporal_config["range"],
+          "map_plot": map_fig,
+          "style_select": gr.Dropdown(choices=style_config["options"]),
+          "time_explanation": temporal_config["explanation"],
+          "geo_explanation": geographical_config.get("explanation", ""),
+          "style_explanation": style_config["explanation"]
       }
 
+  def _handle_zoom(self, axis_name: str, query: str, current_value: Any) -> Dict[str, Any]:
+      """Handle zoom events for any axis"""
+      self.current_state["zoom_level"] += 1
+      config = self.get_llm_response(
+          query,
+          zoom_context={axis_name: current_value}
+      )
+      axis_config = config["axis_configurations"][axis_name]["current_zoom"]
+      
+      if axis_name == "temporal":
+          return {
+              "time_slider": axis_config["range"],
+              "time_explanation": axis_config["explanation"]
+          }
+      elif axis_name == "geographical":
+          map_fig = self.create_map(axis_config["locations"])
+          return {
+              "map_plot": map_fig,
+              "geo_explanation": axis_config.get("explanation", "")
+          }
+      else:  # style
+          return {
+              "style_select": gr.Dropdown(choices=axis_config["options"]),
+              "style_explanation": axis_config["explanation"]
+          }
+
 def main():
-  """Main entry point for the application."""
+  print("Starting initialization...")
   explorer = ArtExplorer()
+  print("Created ArtExplorer instance")
   demo = explorer.create_interface()
+  print("Created interface")
   demo.launch(
       server_name="0.0.0.0",
       server_port=7860,