Update app.py

app.py

@@ -3,45 +3,46 @@ import openai
 import gradio as gr
 import json
 import plotly.graph_objects as go
-
-from variables import *
-
+from variables import CONTEXTUAL_ZOOM_PROMPT, CONTEXTUAL_ZOOM_default_response
 
 class ArtExplorer:
-    def __init__(self):
-        self.client = openai.OpenAI(
-            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):
-        """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.get('lat') for loc in locations],
-            lon=[loc.get('lon') for loc in locations],
-            mode='markers',
-            marker=go.scattermapbox.Marker(size=10),
-            text=[loc.get('name') for loc in locations]
-        ))
-
-        fig.update_layout(
-            mapbox_style="open-street-map",
-            mapbox=dict(
-                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: dict = None) -> dict:
+  def __init__(self):
+      print("Initializing ArtExplorer...")
+      self.client = openai.OpenAI(
+          base_url="https://api.groq.com/openai/v1",
+          api_key=os.environ.get("GROQ_API_KEY")
+      )
+      print("OpenAI client initialized")
+      self.current_state = {
+          "zoom_level": 0,
+          "selections": {}
+      }
+      print("Current state initialized")
+
+  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.get('lat') for loc in locations],
+          lon=[loc.get('lon') for loc in locations],
+          mode='markers',
+          marker=go.scattermapbox.Marker(size=10),
+          text=[loc.get('name') for loc in locations]
+      ))
+
+      fig.update_layout(
+          mapbox_style="open-street-map",
+          mapbox=dict(
+              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: dict = None) -> dict:
       try:
           current_zoom_states = {
               "temporal": {"level": self.current_state["zoom_level"], "selection": ""},
@@ -49,12 +50,12 @@ class ArtExplorer:
               "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": CONTEXTUAL_ZOOM_PROMPT.format(
@@ -62,155 +63,151 @@ class ArtExplorer:
                   current_zoom_states=json.dumps(current_zoom_states, indent=2)
               )}
           ]
-    
-          # Print the messages being sent to the LLM for debugging
+
           print("Messages sent to LLM:")
-          for message in messages:
-              print(f"{message['role']}: {message['content']}")
-    
+          print(messages)
+          
           response = self.client.chat.completions.create(
               model="mixtral-8x7b-32768",
               messages=messages,
               temperature=0.1,
               max_tokens=2048
           )
-    
-          # Print the raw response from the LLM for debugging
+          
           print("Raw response from LLM:")
           print(response)
-    
+          
           result = json.loads(response.choices[0].message.content)
-    
-          # Print the parsed result for debugging
-          print("Parsed result from LLM:")
+          
+          print("Parsed result:")
           print(result)
-    
+          
           return result
-      except json.JSONDecodeError as json_err:
-          print(f"JSON decode error: {str(json_err)}")
-          print(f"Response content: {response.choices[0].message.content}")
-          return self.get_default_response()
       except Exception as e:
           print(f"Error in LLM response: {str(e)}")
           return self.get_default_response()
 
-    def get_default_response(self):
-        return CONTEXTUAL_ZOOM_default_response
-
-    def create_interface(self):
-        with gr.Blocks() as demo:
-            gr.Markdown("# Art History Explorer")
-            
-            with gr.Row():
-                query = gr.Textbox(
-                    label="Enter your art history query",
-                    placeholder="e.g., Napoleon wars, Renaissance Italy"
-                )
-                search_btn = gr.Button("Explore")
-
-            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")
-
-            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
-                ]
-            )
-
-            time_zoom.click(
-                fn=lambda q, v: zoom_axis(q, "temporal", v),
-                inputs=[query, time_slider],
-                outputs=[time_slider, time_explanation]
-            )
-
-            geo_zoom.click(
-                fn=lambda q, v: zoom_axis(q, "geographical", v),
-                inputs=[query, map_plot],
-                outputs=[map_plot, geo_explanation]
-            )
-
-            style_zoom.click(
-                fn=lambda q, v: zoom_axis(q, "style", v),
-                inputs=[query, style_select],
-                outputs=[style_select, style_explanation]
-            )
-
-        return demo
+  def get_default_response(self):
+      return CONTEXTUAL_ZOOM_default_response
+
+  def create_interface(self):
+      with gr.Blocks() as demo:
+          gr.Markdown("# Art History Explorer")
+          
+          with gr.Row():
+              query = gr.Textbox(
+                  label="Enter your art history query",
+                  placeholder="e.g., Napoleon wars, Renaissance Italy"
+              )
+              search_btn = gr.Button("Explore")
+
+          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")
+
+          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
+              ]
+          )
+
+          time_zoom.click(
+              fn=lambda q, v: zoom_axis(q, "temporal", v),
+              inputs=[query, time_slider],
+              outputs=[time_slider, time_explanation]
+          )
+
+          geo_zoom.click(
+              fn=lambda q, v: zoom_axis(q, "geographical", v),
+              inputs=[query, map_plot],
+              outputs=[map_plot, geo_explanation]
+          )
+
+          style_zoom.click(
+              fn=lambda q, v: zoom_axis(q, "style", v),
+              inputs=[query, style_select],
+              outputs=[style_select, style_explanation]
+          )
+
+          return demo
 
 if __name__ == "__main__":
-    explorer = ArtExplorer()
-    demo = explorer.create_interface()
-    demo.launch()
+  print("Starting initialization...")
+  explorer = ArtExplorer()
+  print("Created ArtExplorer instance")
+  demo = explorer.create_interface()
+  print("Created interface")
+  demo.launch()
+  print("Launched demo")