Update app.py

app.py

@@ -136,6 +136,7 @@ Current Zoom States: {
 Generate only the JSON response, maintaining strict JSON format."""
 
 
+
 class ArtExplorer:
     def __init__(self):
         self.client = openai.OpenAI(
@@ -149,140 +150,108 @@ class ArtExplorer:
 
     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],
-            hovertemplate='<b>%{text}</b><extra></extra>'
+            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),  # Default to Paris
+                center=dict(lat=48.8566, lon=2.3522),
                 zoom=4
             ),
-            margin=dict(r=0, t=0, l=0, b=0),
-            showlegend=False
+            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:
-            # Format the CONTEXTUAL_ZOOM_PROMPT with current values
-            formatted_prompt = CONTEXTUAL_ZOOM_PROMPT.format(
-                user_query=query,
-                current_zoom_states={
-                    "temporal": {
-                        "level": self.current_state.get("zoom_level", ""),
-                        "selection": zoom_context.get("temporal") if zoom_context else ""
-                    },
-                    "geographical": {
-                        "level": self.current_state.get("zoom_level", ""),
-                        "selection": zoom_context.get("geographical") if zoom_context else ""
-                    },
-                    "style": {
-                        "level": self.current_state.get("zoom_level", ""),
-                        "selection": zoom_context.get("style") if zoom_context else ""
-                    },
-                    "subject": {
-                        "level": self.current_state.get("zoom_level", ""),
-                        "selection": zoom_context.get("subject") if zoom_context else ""
-                    }
-                }
-            )
-    
+            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": ""}
+            }
+            
+            if zoom_context:
+                for key, value in zoom_context.items():
+                    if key in current_zoom_states:
+                        current_zoom_states[key]["selection"] = value
+
             response = self.client.chat.completions.create(
                 model="mixtral-8x7b-32768",
                 messages=[
-                    {
-                        "role": "system",
-                        "content": "You are an expert art historian specializing in interactive exploration."
-                    },
-                    {
-                        "role": "user",
-                        "content": formatted_prompt
-                    }
+                    {"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)
+                    )}
                 ],
                 temperature=0.1,
                 max_tokens=2048
             )
             
             result = json.loads(response.choices[0].message.content)
-            
-            # Validate response structure
-            if "axis_configurations" not in result:
-                raise KeyError("Missing axis_configurations in LLM response")
-                
             return result
             
         except Exception as e:
             print(f"Error in LLM response: {str(e)}")
-            # Return default structure following the same format as the prompt
-            return {
-                "analysis": {
-                    "query_focus": "Default focus",
-                    "historical_context": "Default historical context"
-                },
-                "axis_configurations": {
-                    "temporal": {
-                        "component": "st.slider",
-                        "current_zoom": {
-                            "level": "century",
-                            "range": [1700, 2000],
-                            "explanation": "Default time range"
-                        },
-                        "available_zooms": {
-                            "in": {
-                                "range": [1800, 1900],
-                                "explanation": "Zoom in to see more detail"
-                            },
-                            "out": {
-                                "range": [1500, 2024],
-                                "explanation": "Broader historical context"
-                            }
-                        },
-                        "impacted_by": {
-                            "geographical": "Location affects time period",
-                            "style": "Style affects time period"
-                        }
+            return self.get_default_response()
+
+    def get_default_response(self):
+        return {
+            "analysis": {
+                "query_focus": "Default focus",
+                "historical_context": "Default historical context"
+            },
+            "axis_configurations": {
+                "temporal": {
+                    "component": "st.slider",
+                    "current_zoom": {
+                        "level": "century",
+                        "range": [1700, 2000],
+                        "explanation": "Default time range"
                     },
-                    "geographical": {
-                        "component": "st.map",
-                        "current_zoom": {
-                            "level": "continent",
-                            "locations": [
-                                {
-                                    "name": "Paris",
-                                    "lat": 48.8566,
-                                    "lon": 2.3522,
-                                    "relevance": "Default location"
-                                }
-                            ]
+                    "available_zooms": {
+                        "in": {
+                            "range": [1800, 1900],
+                            "explanation": "Zoom in to see more detail"
                         },
-                        "available_zooms": {
-                            "in": {
-                                "locations": ["Paris", "London", "Rome"],
-                                "explanation": "Major art centers"
-                            },
-                            "out": {
-                                "locations": ["Europe", "Americas", "Asia"],
-                                "explanation": "Global art movements"
-                            }
-                        }
-                    },
-                    "style": {
-                        "component": "st.multiselect",
-                        "current_zoom": {
-                            "level": "movement",
-                            "options": ["Classical", "Modern"],
-                            "explanation": "Default art movements"
+                        "out": {
+                            "range": [1500, 2024],
+                            "explanation": "Broader historical context"
                         }
                     }
+                },
+                "geographical": {
+                    "current_zoom": {
+                        "level": "continent",
+                        "locations": [
+                            {
+                                "name": "Paris",
+                                "lat": 48.8566,
+                                "lon": 2.3522,
+                                "relevance": "Default location"
+                            }
+                        ]
+                    }
+                },
+                "style": {
+                    "current_zoom": {
+                        "level": "movement",
+                        "options": ["Classical", "Modern"],
+                        "explanation": "Default art movements"
+                    }
                 }
             }
+        }
 
     def create_interface(self):
         with gr.Blocks() as demo:
@@ -323,55 +292,62 @@ class ArtExplorer:
 
             def initial_search(query):
                 config = self.get_llm_response(query)
-                self.current_state["selections"] = {}
-                self.current_state["zoom_level"] = 0
                 
-                # Create map figure from locations
-                map_fig = self.create_map(config["geographical"]["locations"])
+                # Access the correct nested structure
+                temporal_config = config["axis_configurations"]["temporal"]["current_zoom"]
+                geographical_config = config["axis_configurations"]["geographical"]["current_zoom"]
+                style_config = config["axis_configurations"]["style"]["current_zoom"]
+                
+                # Create map figure
+                map_fig = self.create_map(geographical_config["locations"])
                 
                 return {
-                    time_slider: config["temporal"]["range"],
+                    time_slider: temporal_config["range"],
                     map_plot: map_fig,
-                    style_select: gr.Dropdown(choices=config["style"]["options"]),
-                    time_explanation: config["temporal"]["explanation"],
-                    geo_explanation: config["geographical"]["explanation"],
-                    style_explanation: config["style"]["explanation"]
+                    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
-                self.current_state["selections"][axis_name] = current_value
-                
                 config = self.get_llm_response(
                     query,
                     zoom_context={axis_name: current_value}
                 )
                 
-                updates = {}
+                axis_config = config["axis_configurations"][axis_name]["current_zoom"]
+                
                 if axis_name == "temporal":
-                    updates.update({
-                        time_slider: config["temporal"]["range"],
-                        time_explanation: config["temporal"]["explanation"]
-                    })
+                    return {
+                        time_slider: axis_config["range"],
+                        time_explanation: axis_config["explanation"]
+                    }
                 elif axis_name == "geographical":
-                    map_fig = self.create_map(config["geographical"]["locations"])
-                    updates.update({
+                    map_fig = self.create_map(axis_config["locations"])
+                    return {
                         map_plot: map_fig,
-                        geo_explanation: config["geographical"]["explanation"]
-                    })
-                elif axis_name == "style":
-                    updates.update({
-                        style_select: gr.Dropdown(choices=config["style"]["options"]),
-                        style_explanation: config["style"]["explanation"]
-                    })
-                return updates
+                        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]
+                outputs=[
+                    time_slider, 
+                    map_plot, 
+                    style_select,
+                    time_explanation, 
+                    geo_explanation, 
+                    style_explanation
+                ]
             )
 
             time_zoom.click(