Update app.py

app.py

@@ -3,199 +3,222 @@ import openai
 import gradio as gr
 import json
 import plotly.graph_objects as go
-from variables import *
+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
 
 class ArtExplorer:
-  def __init__(self):
+  def __init__(self, api_key: str = None, base_url: str = None):
+      """Initialize ArtExplorer with configurable API settings."""
       self.client = openai.OpenAI(
-          base_url="https://api.groq.com/openai/v1",
-          api_key=os.environ.get("GROQ_API_KEY")
+          base_url=base_url or "https://api.groq.com/openai/v1",
+          api_key=api_key or os.environ.get("GROQ_API_KEY")
       )
       self.current_state = {
           "zoom_level": 0,
           "selections": {}
       }
 
-  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}]
+  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]
 
       fig = go.Figure(go.Scattermapbox(
-          lat=[loc.get('lat') for loc in locations],
-          lon=[loc.get('lon') for loc in locations],
+          lat=[loc.lat for loc in locations],
+          lon=[loc.lon for loc in locations],
           mode='markers',
           marker=go.scattermapbox.Marker(size=10),
-          text=[loc.get('name') for loc in locations]
+          text=[loc.name for loc in locations]
       ))
 
       fig.update_layout(
           mapbox_style="open-street-map",
           mapbox=dict(
-              center=dict(lat=48.8566, lon=2.3522),
+              center=dict(lat=locations[0].lat, lon=locations[0].lon),
               zoom=4
           ),
           margin=dict(r=0, t=0, l=0, b=0)
       )
       return fig
 
-  def get_llm_response(self, query: str, zoom_context: dict = None) -> dict:
+  def get_llm_response(self, query: str, zoom_context: Optional[Dict] = None) -> Dict:
+      """Get response from LLM with error handling and logging."""
       try:
           current_zoom_states = {
-              "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": ""}
+              axis: ZoomState(self.current_state["zoom_level"], 
+                            zoom_context.get(axis, "") if zoom_context else "")
+              for axis in ["temporal", "geographical", "style", "subject"]
           }
 
-          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": CONTEXTUAL_ZOOM_PROMPT.format(
-                  user_query=query,
-                  current_zoom_states=json.dumps(current_zoom_states, indent=2)
-              )}
+              {"role": "user", "content": self._format_prompt(query, current_zoom_states)}
           ]
 
-          print(messages)
+          print(f"Sending request to LLM with query: {query}")
           response = self.client.chat.completions.create(
               model="mixtral-8x7b-32768",
               messages=messages,
               temperature=0.1,
               max_tokens=2048
           )
-          print(response)
-          result = json.loads(response.choices[0].message.content)
+          
+          # 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)}")
+          
           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"Error in LLM response: {str(e)}")
+          print(f"Unexpected error: {str(e)}")
           return self.get_default_response()
 
-  def get_default_response(self):
-      return CONTEXTUAL_ZOOM_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 create_interface(self):
-      with gr.Blocks() as demo:
-          gr.Markdown("# Art History Explorer")
+  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()
           
           with gr.Row():
-              query = gr.Textbox(
-                  label="Enter your art history query",
-                  placeholder="e.g., Napoleon wars, Renaissance Italy"
-              )
-              search_btn = gr.Button("Explore")
-
+              query, search_btn = self._create_search_section()
+          
           with gr.Row():
-              # 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")
-
+              time_controls = self._create_temporal_section()
+              geo_controls = self._create_geographical_section()
+          
           with gr.Row():
-              style_select = gr.Dropdown(
-                  multiselect=True,
-                  label="Artistic Styles"
-              )
-              style_explanation = gr.Markdown()
-              style_zoom = gr.Button("🔍 Zoom Styles")
-
-          def initial_search(query):
-              config = self.get_llm_response(query)
-              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_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 zoom_axis(query, axis_name, current_value):
-              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"]
-                  }
-
-          # Connect event handlers
-          search_btn.click(
-              fn=initial_search,
-              inputs=[query],
-              outputs=[
-                  time_slider,
-                  map_plot,
-                  style_select,
-                  time_explanation,
-                  geo_explanation,
-                  style_explanation
-              ]
+              style_controls = self._create_style_section()
+          
+          self._setup_event_handlers(
+              search_btn, query,
+              time_controls, geo_controls, style_controls
           )
+          
+          return demo
 
-          time_zoom.click(
-              fn=lambda q, v: zoom_axis(q, "temporal", v),
-              inputs=[query, time_slider],
-              outputs=[time_slider, time_explanation]
-          )
+  def _create_header(self):
+      """Create the header section of the interface."""
+      gr.Markdown(
+          """
+          # Art History Explorer
+          Explore art history through time, space, and style.
+          """
+      )
 
-          geo_zoom.click(
-              fn=lambda q, v: zoom_axis(q, "geographical", v),
-              inputs=[query, map_plot],
-              outputs=[map_plot, geo_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
           )
-
-          style_zoom.click(
-              fn=lambda q, v: zoom_axis(q, "style", v),
-              inputs=[query, style_select],
-              outputs=[style_select, style_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"
           )
+          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"]
+          ]
+      )
 
-          return demo
+      self._setup_zoom_handlers(query, time_controls, geo_controls, style_controls)
+
+  def _handle_search(self, query: str) -> Dict[str, Any]:
+      """Handle the search button click."""
+      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"]
+      
+      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"]
+      }
 
-if __name__ == "__main__":
-  print("Starting initialization...")
+def main():
+  """Main entry point for the application."""
   explorer = ArtExplorer()
-  print("Created ArtExplorer instance")
   demo = explorer.create_interface()
-  print("Created interface")
-  demo.launch()
-  print("Launched demo")
+  demo.launch(
+      server_name="0.0.0.0",
+      server_port=7860,
+      share=False
+  )
+
+if __name__ == "__main__":
+  main()