Update app.py

app.py

@@ -1,634 +1,166 @@
 import torch
 import numpy as np
 import folium
-from folium.plugins import HeatMap, MarkerCluster
+from folium.plugins import HeatMap
 import gradio as gr
 import os
 import PIL.Image
-from io import BytesIO
-import base64
 import json
 import time
-from typing import Tuple, List, Dict, Any, Optional, Union, Callable
+from typing import Dict, Any, Optional, Union
 from pathlib import Path
 from datasets import Dataset, load_dataset, concatenate_datasets
+from huggingface_hub import HfApi
 
 # GeoCLIP dependencies
 from geoclip import GeoCLIP
 from transformers import CLIPTokenizer, CLIPProcessor
-from huggingface_hub import HfApi
-
 
+# Initialize GeoCLIP core with vectorized execution path
 class GeoCLIPCore:
-    """
-    Vectorized GeoCLIP implementation with HuggingFace Hub integration.
-    
-    Implements tensor-optimized inference with persistent dataset storage:
-    1. Text-to-location prediction with confidence scoring
-    2. Image-to-location prediction with metadata extraction
-    3. Coordinate embedding generation for vector analysis
-    4. Cross-modal similarity computation
-    5. Dataset persistence to HuggingFace Hub
-    """
-    
-    def __init__(self, 
-                 device: Optional[str] = None,
-                 dataset_id: str = "latterworks/geo-metadata",
-                 token: Optional[str] = None) -> None:
-        """
-        Initialize model with optimal compute allocation and dataset connection.
-        
-        Args:
-            device: Target compute device (None for auto-detection)
-            dataset_id: HuggingFace dataset identifier
-            token: HuggingFace API token
-        """
+    def __init__(self, device=None, dataset_id="latterworks/geo-metadata", token=None):
         self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
         self.dataset_id = dataset_id
         self.token = token
-        
-        # Initialize HuggingFace API for dataset operations
-        self.api = HfApi(token=token)
-        
-        # Load and configure core model components with vectorized execution path
         self._model = GeoCLIP().to(self.device)
         self._tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
         self._processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")
-        
-        # Cache frequently accessed components for reduced latency
         self._location_encoder = self._model.location_encoder
-        self._image_encoder = self._model.image_encoder
-        self._gps_gallery = None  # Lazy-loaded on first prediction
+        self._gps_gallery = None  # Lazy-loaded for memory optimization
         
-        # Initialize local dataset cache
-        self._initialize_dataset()
-        
-        print(f"GeoCLIP initialized on {self.device} with Hub dataset: {dataset_id}")
-    
-    def _initialize_dataset(self) -> None:
-        """Initialize connection to HuggingFace dataset with atomic transaction handling."""
+        # Initialize dataset connection with error handling
         try:
-            # Attempt to load existing dataset
             self.dataset = load_dataset(self.dataset_id, split="train", token=self.token)
-            print(f"Loaded existing dataset with {len(self.dataset)} entries")
-        except Exception as e:
-            print(f"Creating new dataset: {e}")
-            # Create empty dataset with required schema
-            self.dataset = Dataset.from_dict({
-                "filename": [],
-                "classes": [],
-                "metadata": []
-            })
-    
-    def embed_text(self, text: str) -> torch.Tensor:
-        """
-        Generate normalized embedding for text input using vectorized operations.
-        
-        Args:
-            text: Text description to encode
-            
-        Returns:
-            L2-normalized embedding tensor (shape: [1, 512])
-        """
+        except Exception:
+            self.dataset = Dataset.from_dict({"filename": [], "classes": [], "metadata": []})
+
+    # Core tensor operations for embedding generation
+    def text_to_location(self, text, top_k=5):
         with torch.no_grad():
             tokens = self._tokenizer(text, return_tensors="pt", padding=True).to(self.device)
             embedding = self._model.image_encoder.mlp(
                 self._model.image_encoder.CLIP.get_text_features(**tokens)
             )
-            return torch.nn.functional.normalize(embedding, dim=1)
-    
-    def embed_image(self, image: Union[str, PIL.Image.Image, np.ndarray]) -> torch.Tensor:
-        """
-        Generate normalized embedding for image input using vectorized operations.
-        
-        Args:
-            image: Input image (PIL Image, file path, or numpy array)
-            
-        Returns:
-            L2-normalized embedding tensor (shape: [1, 512])
-        """
-        with torch.no_grad():
-            # Process different image input types with type-specific optimizations
-            if isinstance(image, str):
-                # Path to image file
-                image = PIL.Image.open(image).convert("RGB")
-            elif isinstance(image, np.ndarray):
-                # Convert numpy array to PIL Image with optimal memory layout
-                image = PIL.Image.fromarray(np.uint8(image)).convert("RGB")
-            
-            # Process image using CLIP processor with tensor allocation
-            inputs = self._processor(images=image, return_tensors="pt").to(self.device)
-            embedding = self._model.image_encoder(inputs.pixel_values)
-            return torch.nn.functional.normalize(embedding, dim=1)
-    
-    def embed_coordinates(self, coords: Tuple[float, float]) -> torch.Tensor:
-        """
-        Generate normalized embedding for geographical coordinates.
-        
-        Args:
-            coords: Coordinate pair (latitude, longitude)
-            
-        Returns:
-            L2-normalized embedding tensor (shape: [1, 512])
-        """
-        with torch.no_grad():
-            coords_tensor = torch.tensor([coords], dtype=torch.float32).to(self.device)
-            embedding = self._location_encoder(coords_tensor)
-            return torch.nn.functional.normalize(embedding, dim=1)
-    
-    def _ensure_gps_gallery(self) -> None:
-        """Ensure GPS gallery is loaded and cached for efficient reuse."""
-        if self._gps_gallery is None:
-            self._gps_gallery = self._model.gps_gallery.to(self.device)
-    
-    def predict_location(self, 
-                         query_embedding: torch.Tensor, 
-                         top_k: int = 5) -> List[Dict[str, Any]]:
-        """
-        Execute cosine similarity-based location retrieval against GPS gallery.
-        
-        Args:
-            query_embedding: L2-normalized query embedding
-            top_k: Number of top predictions to return
+            embedding = torch.nn.functional.normalize(embedding, dim=1)
             
-        Returns:
-            List of prediction dictionaries with coordinates and confidence scores
-        """
-        with torch.no_grad():
-            # Ensure GPS gallery is loaded with resource pooling
-            self._ensure_gps_gallery()
+            # Ensure gallery is loaded with memory pooling
+            if self._gps_gallery is None:
+                self._gps_gallery = self._model.gps_gallery.to(self.device)
             
-            # Generate location embeddings with memory-efficient tensor operations
+            # Execute vectorized similarity computation
             location_embeddings = self._location_encoder(self._gps_gallery)
             location_embeddings = torch.nn.functional.normalize(location_embeddings, dim=1)
-            
-            # Calculate similarity with vectorized matrix multiplication
-            similarity = self._model.logit_scale.exp() * (query_embedding @ location_embeddings.T)
+            similarity = self._model.logit_scale.exp() * (embedding @ location_embeddings.T)
             probs = similarity.softmax(dim=-1)
             
-            # Extract top predictions with single tensor operation
+            # Extract predictions with single tensor operation
             top_values, top_indices = torch.topk(probs[0], min(top_k, len(self._gps_gallery)))
             
-            # Format results with CPU offloading
-            predictions = []
-            for idx, confidence in zip(top_indices.cpu().numpy(), top_values.cpu().numpy()):
-                predictions.append({
-                    "coordinates": tuple(self._gps_gallery[idx].cpu().numpy()),
-                    "confidence": float(confidence)
-                })
-                
-            return predictions
-    
-    def text_to_location(self, text: str, top_k: int = 5) -> List[Dict[str, Any]]:
-        """
-        Primary entry point for text-to-location prediction pipeline.
-        
-        Args:
-            text: Text description to predict location for
-            top_k: Number of top predictions to return
-            
-        Returns:
-            List of prediction dictionaries with coordinates and confidence scores
-        """
-        embedding = self.embed_text(text)
-        return self.predict_location(embedding, top_k)
-    
-    def image_to_location(self, 
-                          image: Union[str, PIL.Image.Image, np.ndarray], 
-                          top_k: int = 5) -> List[Dict[str, Any]]:
-        """
-        Primary entry point for image-to-location prediction pipeline.
-        
-        Args:
-            image: Input image (PIL Image, file path, or numpy array)
-            top_k: Number of top predictions to return
-            
-        Returns:
-            List of prediction dictionaries with coordinates and confidence scores
-        """
-        embedding = self.embed_image(image)
-        return self.predict_location(embedding, top_k)
-    
-    def extract_image_metadata(self, image_path: str) -> Dict[str, Any]:
-        """
-        Extract comprehensive metadata from image file with GPS coordinates.
-        
-        Args:
-            image_path: Path to image file
-            
-        Returns:
-            Dictionary containing extracted metadata
-        """
-        try:
-            from PIL import Image, ExifTags
-            import piexif
-            
-            # Open image and extract EXIF data with efficient memory mapping
-            img = Image.open(image_path)
-            metadata = {"file_name": image_path, "file_size": os.path.getsize(image_path)}
-            
-            # Extract basic image properties
-            metadata["format"] = img.format
-            metadata["mode"] = img.mode
-            metadata["size"] = list(img.size)
-            
-            if hasattr(img, "_getexif") and img._getexif():
-                exif_dict = {}
-                for tag_id, value in img._getexif().items():
-                    tag = ExifTags.TAGS.get(tag_id, tag_id)
-                    exif_dict[tag.lower()] = value
-                
-                # Copy relevant EXIF data to metadata
-                for key, value in exif_dict.items():
-                    if isinstance(value, bytes):
-                        continue
-                    metadata[key] = value
-                
-                # Extract GPS data with specialized parsing
-                gps_info = {}
-                if "gpsinfo" in exif_dict:
-                    gps_data = exif_dict["gpsinfo"]
-                    for key, value in gps_data.items():
-                        tag = ExifTags.GPSTAGS.get(key, key)
-                        gps_info[tag] = value
-                    
-                    # Parse GPS coordinates to decimal format
-                    if "GPSLatitude" in gps_info and "GPSLongitude" in gps_info:
-                        lat = self._convert_to_decimal(
-                            gps_info["GPSLatitude"], 
-                            gps_info.get("GPSLatitudeRef", "N")
-                        )
-                        lon = self._convert_to_decimal(
-                            gps_info["GPSLongitude"], 
-                            gps_info.get("GPSLongitudeRef", "E")
-                        )
-                        gps_info["Latitude"] = lat
-                        gps_info["Longitude"] = lon
-                    
-                    metadata["gps_info"] = gps_info
-            
-            # Add file metadata
-            metadata["file_extension"] = os.path.splitext(image_path)[1]
-            metadata["extraction_timestamp"] = int(time.time())
-            
-            return metadata
-        except Exception as e:
-            print(f"Error extracting metadata: {e}")
-            return {"error": str(e), "file_name": image_path}
-    
-    def _convert_to_decimal(self, dms_coords, ref) -> float:
-        """
-        Convert GPS DMS (Degree, Minute, Second) to decimal format.
-        
-        Args:
-            dms_coords: Tuple of degrees, minutes, seconds
-            ref: Direction reference (N/S/E/W)
-            
-        Returns:
-            Decimal coordinate value
-        """
-        degrees = dms_coords[0]
-        minutes = dms_coords[1] / 60.0
-        seconds = dms_coords[2] / 3600.0
-        
-        decimal = degrees + minutes + seconds
-        
-        # Apply negative value for south or west coordinates
-        if ref in ['S', 'W']:
-            decimal = -decimal
-            
-        return decimal
-    
-    def add_to_dataset(self, 
-                       image_path: str, 
-                       classes: Optional[List[str]] = None,
-                       push_to_hub: bool = True) -> Dict[str, Any]:
-        """
-        Process image and add entry to dataset with optional HuggingFace Hub synchronization.
-        
-        Args:
-            image_path: Path to image file
-            classes: Optional list of class labels
-            push_to_hub: Whether to push changes to Hub
-            
-        Returns:
-            Dictionary containing the added entry
-        """
-        # Extract filename from path
-        filename = os.path.basename(image_path)
-        
-        # Extract comprehensive metadata with optimized parser
-        metadata = self.extract_image_metadata(image_path)
-        
-        # Prepare new entry
-        new_entry = {
-            "filename": filename,
-            "classes": classes or [],
-            "metadata": metadata
-        }
-        
-        # Add to local dataset with optimized append operation
-        self.dataset = concatenate_datasets([
-            self.dataset, 
-            Dataset.from_dict({
-                "filename": [new_entry["filename"]],
-                "classes": [new_entry["classes"]],
-                "metadata": [new_entry["metadata"]]
-            })
-        ])
-        
-        # Push updates to HuggingFace Hub
-        if push_to_hub:
-            self.push_dataset_to_hub()
-        
-        return new_entry
-    
-    def push_dataset_to_hub(self) -> None:
-        """Push dataset updates to HuggingFace Hub with atomic transaction."""
-        if self.token:
-            try:
-                self.dataset.push_to_hub(self.dataset_id, token=self.token)
-                print(f"Successfully pushed dataset with {len(self.dataset)} entries to {self.dataset_id}")
-            except Exception as e:
-                print(f"Error pushing to Hub: {e}")
-        else:
-            print("HuggingFace token not provided. Dataset not pushed to Hub.")
-    
-    def compute_similarity(self, embed1: torch.Tensor, embed2: torch.Tensor) -> float:
-        """
-        Compute cosine similarity between two embeddings.
-        
-        Args:
-            embed1: First embedding tensor
-            embed2: Second embedding tensor
-            
-        Returns:
-            Similarity score between 0 and 1
-        """
-        return float(torch.nn.functional.cosine_similarity(embed1, embed2).item())
-    
-    def create_map_visualization(self, 
-                                predictions: List[Dict[str, Any]], 
-                                title: str = "",
-                                cluster: bool = False) -> folium.Map:
-        """
-        Generate geospatial visualization of prediction results.
-        
-        Args:
-            predictions: List of prediction dictionaries
-            title: Optional map title
-            cluster: Whether to cluster nearby markers
-            
-        Returns:
-            Folium map object with marker and heatmap layers
-        """
-        # Initialize map centered on highest confidence prediction
-        center_coords = predictions[0]["coordinates"]
-        m = folium.Map(location=center_coords, zoom_start=5, tiles="OpenStreetMap")
-        
-        # Add title if provided
+            return [
+                {"coordinates": tuple(self._gps_gallery[idx].cpu().numpy()), 
+                 "confidence": float(conf)} 
+                for idx, conf in zip(top_indices.cpu().numpy(), top_values.cpu().numpy())
+            ]
+
+    # Generate map visualization with optimized rendering
+    def create_map_visualization(self, predictions, title=""):
+        m = folium.Map(location=predictions[0]["coordinates"], zoom_start=5)
         if title:
-            title_html = f'<h3 style="text-align:center">{title}</h3>'
-            m.get_root().html.add_child(folium.Element(title_html))
-        
-        # Create marker cluster if requested
-        marker_group = MarkerCluster() if cluster else m
+            m.get_root().html.add_child(folium.Element(f'<h3 style="text-align:center">{title}</h3>'))
         
         # Add markers with confidence metadata
         for i, pred in enumerate(predictions):
             color = 'red' if i == 0 else 'blue' if i < 3 else 'green'
-            
             folium.Marker(
                 location=pred["coordinates"],
                 popup=f"Prediction #{i+1}<br>Confidence: {pred['confidence']:.6f}",
                 icon=folium.Icon(color=color)
-            ).add_to(marker_group if cluster else m)
+            ).add_to(m)
         
-        # Add marker cluster to map if used
-        if cluster:
-            m.add_child(marker_group)
-        
-        # Add heatmap layer for visual density representation
+        # Add heatmap for density visualization
         if len(predictions) >= 3:
             heat_data = [[p["coordinates"][0], p["coordinates"][1], p["confidence"]] 
-                         for p in predictions]
+                        for p in predictions]
             HeatMap(heat_data, radius=15, blur=10).add_to(m)
         
         return m
 
-
-def launch_gradio_interface(hf_token: Optional[str] = None):
-    """
-    Deploy GeoCLIP with Gradio interface with Hub data persistence.
-    
-    Args:
-        hf_token: HuggingFace API token for dataset operations
-    """
-    # Initialize model with optimal compute configuration
+# Initialize GeoCLIP and codebase exemplars
+def initialize_gradio_interface(hf_token=None):
+    python_code = """def fib(n):
+    if n <= 0:
+        return 0
+    elif n == 1:
+        return 1
+    else:
+        return fib(n-1) + fib(n-2)
+"""
+    js_code = """function fib(n) {
+    if (n <= 0) return 0;
+    if (n === 1) return 1;
+    return fib(n - 1) + fib(n - 2);
+}
+"""
+    # Initialize GeoCLIP with optimized resource allocation
     geo_core = GeoCLIPCore(token=hf_token)
     
-    def predict_from_text(text_query, top_k):
-        """Process text query and generate visualization with vector operations."""
-        if not text_query.strip():
-            return None, "Please enter a location description."
-        
-        # Execute prediction pipeline with tensor acceleration
-        predictions = geo_core.text_to_location(text_query, top_k=int(top_k))
-        
-        # Generate map visualization
-        m = geo_core.create_map_visualization(
-            predictions, 
-            title=f"Predictions for: {text_query}"
-        )
-        
-        # Create HTML representation
-        map_html = m._repr_html_()
-        
-        # Format textual results
-        result_text = f"Top predictions for: '{text_query}'\n\n"
-        for i, pred in enumerate(predictions, 1):
-            coords = pred["coordinates"]
-            conf = pred["confidence"]
-            result_text += f"{i}. ({coords[0]:.6f}, {coords[1]:.6f}) - confidence: {conf:.6f}\n"
-        
-        return map_html, result_text
-    
-    def process_image(image, image_path, save_to_hub, top_k):
-        """
-        Process image for prediction and metadata extraction with Hub integration.
-        
-        Returns map visualization, prediction results, and metadata.
-        """
-        if image is None:
-            return None, "Please upload an image.", "{}"
-        
-        # Execute prediction pipeline with tensor acceleration
-        predictions = geo_core.image_to_location(image, top_k=int(top_k))
-        
-        # Generate map visualization
-        m = geo_core.create_map_visualization(
-            predictions, 
-            title="Predictions from Image"
-        )
-        
-        # Create HTML representation
-        map_html = m._repr_html_()
-        
-        # Format textual results
-        result_text = "Top predictions from image:\n\n"
-        for i, pred in enumerate(predictions, 1):
-            coords = pred["coordinates"]
-            conf = pred["confidence"]
-            result_text += f"{i}. ({coords[0]:.6f}, {coords[1]:.6f}) - confidence: {conf:.6f}\n"
-        
-        # Extract metadata if image was uploaded and path is available
-        metadata = {}
-        if image_path:
-            # Add to dataset if requested
-            if save_to_hub:
-                entry = geo_core.add_to_dataset(
-                    image_path, 
-                    classes=["location"], 
-                    push_to_hub=True
-                )
-                metadata = entry["metadata"]
-            else:
-                # Just extract metadata without saving
-                metadata = geo_core.extract_image_metadata(image_path)
-        
-        # Format metadata as JSON
-        metadata_json = json.dumps(metadata, indent=2)
-        
-        return map_html, result_text, metadata_json
-    
-    def compute_text_similarity(text1, text2):
-        """Compute semantic similarity between two text descriptions."""
-        if not text1.strip() or not text2.strip():
-            return "Please enter both text descriptions."
-        
-        embed1 = geo_core.embed_text(text1)
-        embed2 = geo_core.embed_text(text2)
-        
-        similarity = geo_core.compute_similarity(embed1, embed2)
-        return f"Similarity between the texts: {similarity:.4f} (range: 0-1)"
-    
-    # Create Gradio interface with tabs for different functions
-    with gr.Blocks(title="GeoCLIP Location Intelligence") as demo:
-        gr.Markdown("# GeoCLIP Location Intelligence with Hub Integration")
-        gr.Markdown("Predict locations from text descriptions or images with dataset persistence.")
-        
-        with gr.Tabs():
-            with gr.TabItem("Text → Location"):
-                with gr.Row():
-                    with gr.Column():
-                        text_input = gr.Textbox(
-                            lines=3, 
-                            placeholder="Enter location description...",
-                            label="Location Description"
-                        )
-                        text_top_k = gr.Slider(
-                            minimum=1, 
-                            maximum=20, 
-                            value=10, 
-                            step=1, 
-                            label="Number of Predictions"
-                        )
-                        text_submit = gr.Button("Predict Location")
+    # Message handler with multimodal dispatch logic
+    def chat(message, history):
+        if "python" in message.lower():
+            return "Type Python or JavaScript to see the code.", gr.Code(language="python", value=python_code)
+        elif "javascript" in message.lower():
+            return "Type Python or JavaScript to see the code.", gr.Code(language="javascript", value=js_code)
+        elif any(kw in message.lower() for kw in ["location", "where", "place", "predict"]):
+            # Extract location query with pattern matching
+            for term in ["location", "where", "place", "find", "predict"]:
+                if term in message.lower():
+                    query = message.lower().split(term, 1)[1].strip()
+                    if not query:
+                        return "Please provide a location description.", None
                     
-                    with gr.Column():
-                        text_examples = gr.Examples(
-                            examples=[
-                                "ancient pyramids in desert",
-                                "Eiffel Tower in Paris",
-                                "beach resort with palm trees",
-                                "technology hub with startups",
-                                "busy downtown with skyscrapers",
-                                "mountain with snow and ski slopes",
-                                "tropical island with clear water"
-                            ],
-                            inputs=text_input
-                        )
-                
-                text_map_output = gr.HTML(label="Map Visualization")
-                text_result_output = gr.Textbox(label="Prediction Results")
-                
-                text_submit.click(
-                    predict_from_text, 
-                    inputs=[text_input, text_top_k], 
-                    outputs=[text_map_output, text_result_output]
-                )
-            
-            with gr.TabItem("Image → Location with Hub Integration"):
-                with gr.Row():
-                    with gr.Column():
-                        image_input = gr.Image(type="pil", label="Upload Image")
-                        save_to_hub = gr.Checkbox(
-                            label="Save to HuggingFace Dataset", 
-                            value=True
-                        )
-                        image_top_k = gr.Slider(
-                            minimum=1, 
-                            maximum=20, 
-                            value=10, 
-                            step=1, 
-                            label="Number of Predictions"
-                        )
-                        image_submit = gr.Button("Process Image")
-                
-                image_map_output = gr.HTML(label="Map Visualization")
-                image_result_output = gr.Textbox(label="Prediction Results")
-                metadata_output = gr.JSON(label="Image Metadata")
-                
-                image_submit.click(
-                    process_image, 
-                    inputs=[image_input, image_input.upload_path, save_to_hub, image_top_k], 
-                    outputs=[image_map_output, image_result_output, metadata_output]
-                )
+                    # Execute prediction with tensor acceleration
+                    predictions = geo_core.text_to_location(query, top_k=5)
+                    m = geo_core.create_map_visualization(predictions, f"Predictions for: {query}")
+                    
+                    # Format response with structured data
+                    result = f"Top predictions for: '{query}'\n\n"
+                    for i, pred in enumerate(predictions, 1):
+                        coords = pred["coordinates"]
+                        result += f"{i}. ({coords[0]:.6f}, {coords[1]:.6f}) - conf: {pred['confidence']:.6f}\n"
+                    
+                    return result, gr.HTML(value=m._repr_html_())
             
-            with gr.TabItem("Semantic Similarity"):
-                text1_input = gr.Textbox(
-                    lines=2, 
-                    placeholder="Enter first description...",
-                    label="Text Description 1"
-                )
-                text2_input = gr.Textbox(
-                    lines=2, 
-                    placeholder="Enter second description...",
-                    label="Text Description 2"
-                )
-                similarity_submit = gr.Button("Compute Similarity")
-                similarity_output = gr.Textbox(label="Similarity Result")
-                
-                similarity_submit.click(
-                    compute_text_similarity, 
-                    inputs=[text1_input, text2_input], 
-                    outputs=similarity_output
+            return "Couldn't process your location query. Please try again.", None
+        else:
+            return "I can show code examples or predict locations. Try 'Where is the Eiffel Tower?'", None
+    
+    # Build gradio blocks with structured layout
+    with gr.Blocks() as demo:
+        code = gr.Code(render=False)
+        map_output = gr.HTML(render=False)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("<center><h1>GeoCLIP + Code Examples</h1></center>")
+                chatbot = gr.ChatInterface(
+                    chat,
+                    examples=["Python", "JavaScript", "Where is the Eiffel Tower?"],
+                    additional_outputs=[code, map_output]
                 )
             
-            with gr.TabItem("Dataset Status"):
-                dataset_info = gr.Markdown(f"Current dataset: {geo_core.dataset_id}")
-                dataset_count = gr.Markdown(f"Number of entries: {len(geo_core.dataset)}")
-                update_status = gr.Button("Refresh Dataset Status")
-                
-                def update_dataset_status():
-                    return (
-                        f"Current dataset: {geo_core.dataset_id}",
-                        f"Number of entries: {len(geo_core.dataset)}"
-                    )
-                
-                update_status.click(
-                    update_dataset_status,
-                    inputs=[],
-                    outputs=[dataset_info, dataset_count]
-                )
+            with gr.Column(scale=1):
+                gr.Markdown("<center><h1>Output Artifacts</h1></center>")
+                with gr.Tab("Code"):
+                    code.render()
+                with gr.Tab("Location Map"):
+                    map_output.render()
+        
+        gr.Markdown(f"<center>Connected to dataset: {geo_core.dataset_id}</center>")
     
-    # Launch Gradio interface with optimized server settings
-    demo.launch(share=True)
-
+    return demo
 
+# Entry point with environmental token acquisition
 if __name__ == "__main__":
-    # Read API token from environment variable 
     hf_token = os.environ.get("HF_TOKEN")
-    
-    # Execute vectorized deployment pipeline
-    launch_gradio_interface(hf_token=hf_token)
+    demo = initialize_gradio_interface(hf_token)
+    demo.launch()