Update app.py

app.py

@@ -1,152 +1,150 @@
+import os
+import openai
 import gradio as gr
 import json
-from groq import Groq
-import os
 
 class ArtExplorer:
     def __init__(self):
-        self.groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+        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": {
-                "temporal": None,
-                "geographical": None,
-                "style": None
-            }
+            "selections": {}
         }
 
-    def get_llm_configuration(self, query, zoom_level, current_selections=None):
-        prompt = f"""
-        User Query: {query}
-        Current Zoom Level: {zoom_level}
-        Current Selections: {json.dumps(current_selections) if current_selections else 'None'}
+    def get_llm_response(self, query: str, zoom_context: dict = None) -> dict:
+        system_prompt = """You are an art history expert. Generate a structured JSON configuration for an interactive art exploration interface."""
         
-        Generate configuration for interactive art exploration interface.
-        """
+        user_prompt = f"""
+        Query: {query}
+        Zoom Level: {self.current_state['zoom_level']}
+        Current Selections: {json.dumps(zoom_context) if zoom_context else 'None'}
         
-        response = self.groq_client.chat.completions.create(
+        Return a JSON object with configurations for temporal, geographical, and style axes.
+        """
+
+        response = self.client.chat.completions.create(
+            model="mixtral-8x7b-32768",
             messages=[
-                {"role": "system", "content": "You are an art history expert."},
-                {"role": "user", "content": prompt}
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
             ],
-            model="mixtral-8x7b-32768",
-            temperature=0.1
+            temperature=0.1,
+            max_tokens=1024
         )
         
         return json.loads(response.choices[0].message.content)
 
     def create_interface(self):
         with gr.Blocks() as demo:
-            gr.Markdown("# Interactive Art History Explorer")
+            gr.Markdown("# Art History Explorer")
             
-            # Initial query input
+            # Query and initial search
             with gr.Row():
-                query = gr.Textbox(label="Enter your art history query (e.g., 'Napoleon wars')")
+                query = gr.Textbox(
+                    label="Enter your art history query",
+                    placeholder="e.g., Napoleon wars, Renaissance Italy"
+                )
                 search_btn = gr.Button("Explore")
 
-            # Main display area
+            # Display areas for each axis
             with gr.Row():
-                # Time Period Column
+                # Temporal axis
                 with gr.Column():
-                    gr.Markdown("## Time Period")
                     time_slider = gr.Slider(
                         minimum=1000,
                         maximum=2024,
-                        label="Select Time Period",
+                        label="Time Period",
                         interactive=True
                     )
-                    time_explanation = gr.Markdown("Time period context will appear here")
-                    time_zoom = gr.Button("Zoom In - Timeline")
+                    time_explanation = gr.Markdown()
+                    time_zoom = gr.Button("🔍 Zoom Time Period")
 
-                # Geographic Column
+                # Geographical axis
                 with gr.Column():
-                    gr.Markdown("## Geographic Location")
-                    map_component = gr.Map(label="Select Locations")
-                    geo_explanation = gr.Markdown("Geographic context will appear here")
-                    geo_zoom = gr.Button("Zoom In - Geography")
+                    map_select = gr.Map(
+                        label="Geographic Location",
+                        interactive=True
+                    )
+                    geo_explanation = gr.Markdown()
+                    geo_zoom = gr.Button("🔍 Zoom Geography")
 
-            # Style Selection
+            # Style selection
             with gr.Row():
-                gr.Markdown("## Artistic Styles")
-                style_dropdown = gr.Dropdown(
+                style_select = gr.Dropdown(
                     multiselect=True,
-                    label="Select Styles"
+                    label="Artistic Styles"
                 )
-                style_explanation = gr.Markdown("Style context will appear here")
-                style_zoom = gr.Button("Zoom In - Styles")
+                style_explanation = gr.Markdown()
+                style_zoom = gr.Button("🔍 Zoom Styles")
 
-            # Initial search handler
             def initial_search(query):
-                config = self.get_llm_configuration(query, zoom_level=0)
+                config = self.get_llm_response(query)
+                self.current_state["selections"] = {}
+                self.current_state["zoom_level"] = 0
                 
-                # Update components with initial values
                 return {
                     time_slider: config["temporal"]["range"],
-                    map_component: config["geographical"]["locations"],
-                    style_dropdown: gr.Dropdown(choices=config["style"]["options"]),
+                    map_select: config["geographical"]["locations"],
+                    style_select: gr.Dropdown(choices=config["style"]["options"]),
                     time_explanation: config["temporal"]["explanation"],
                     geo_explanation: config["geographical"]["explanation"],
                     style_explanation: config["style"]["explanation"]
                 }
 
-            # Zoom handlers
-            def zoom_timeline(query, current_time):
-                config = self.get_llm_configuration(
-                    query,
-                    zoom_level=self.current_state["zoom_level"] + 1,
-                    current_selections={"temporal": current_time}
-                )
-                return {
-                    time_slider: config["temporal"]["range"],
-                    time_explanation: config["temporal"]["explanation"]
-                }
-
-            def zoom_geography(query, current_locations):
-                config = self.get_llm_configuration(
-                    query,
-                    zoom_level=self.current_state["zoom_level"] + 1,
-                    current_selections={"geographical": current_locations}
-                )
-                return {
-                    map_component: config["geographical"]["locations"],
-                    geo_explanation: config["geographical"]["explanation"]
-                }
-
-            def zoom_styles(query, current_styles):
-                config = self.get_llm_configuration(
+            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_level=self.current_state["zoom_level"] + 1,
-                    current_selections={"style": current_styles}
+                    zoom_context={axis_name: current_value}
                 )
-                return {
-                    style_dropdown: gr.Dropdown(choices=config["style"]["options"]),
-                    style_explanation: config["style"]["explanation"]
-                }
+                
+                updates = {}
+                if axis_name == "temporal":
+                    updates.update({
+                        time_slider: config["temporal"]["range"],
+                        time_explanation: config["temporal"]["explanation"]
+                    })
+                elif axis_name == "geographical":
+                    updates.update({
+                        map_select: config["geographical"]["locations"],
+                        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
 
             # Connect event handlers
             search_btn.click(
                 fn=initial_search,
                 inputs=[query],
-                outputs=[time_slider, map_component, style_dropdown,
+                outputs=[time_slider, map_select, style_select,
                         time_explanation, geo_explanation, style_explanation]
             )
 
             time_zoom.click(
-                fn=zoom_timeline,
+                fn=lambda q, v: zoom_axis(q, "temporal", v),
                 inputs=[query, time_slider],
                 outputs=[time_slider, time_explanation]
             )
 
             geo_zoom.click(
-                fn=zoom_geography,
-                inputs=[query, map_component],
-                outputs=[map_component, geo_explanation]
+                fn=lambda q, v: zoom_axis(q, "geographical", v),
+                inputs=[query, map_select],
+                outputs=[map_select, geo_explanation]
             )
 
             style_zoom.click(
-                fn=zoom_styles,
-                inputs=[query, style_dropdown],
-                outputs=[style_dropdown, style_explanation]
+                fn=lambda q, v: zoom_axis(q, "style", v),
+                inputs=[query, style_select],
+                outputs=[style_select, style_explanation]
             )
 
         return demo