Update app.py

app.py

@@ -1,773 +1,243 @@
+from pathlib import Path
+from PIL import Image, ExifTags
+import json
+import sys
+import os
 import gradio as gr
-import torch
-import torch.nn.functional as F
-from functools import lru_cache
-import folium
-from folium.plugins import HeatMap, MarkerCluster
-from typing import List, Dict, Tuple, Optional, Union, Any
-import numpy as np
-import matplotlib.pyplot as plt
-import io
-import base64
-from dataclasses import dataclass
 import logging
-import warnings
-from transformers import CLIPTokenizer
-from geoclip import GeoCLIP
+from datasets import Dataset
+from typing import Dict, List, Any, Optional
+import traceback
 
-# Configure logging
+# Logging setup
 logging.basicConfig(
     level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s"
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)]
 )
 logger = logging.getLogger(__name__)
 
-# Suppress transformer warnings
-warnings.filterwarnings("ignore", message="weights_only=False")
-
-@dataclass
-class LocationPrediction:
-    """Structured container for geographic predictions with confidence metrics."""
-    coordinates: Tuple[float, float]
-    confidence: float
-
-
-class GeoCLIPAnalyzer:
-    """High-performance GeoCLIP analyzer with cached operations and optimized tensor handling."""
-    
-    def __init__(self, cache_enabled: bool = True, cache_size: int = 128):
-        """
-        Initialize the analyzer with configurable caching.
-        
-        Args:
-            cache_enabled: Toggle for LRU caching mechanism
-            cache_size: Maximum cache entries per method
-        """
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        logger.info(f"Initializing GeoCLIP on {self.device}")
-        
-        self.model = GeoCLIP().to(self.device)
-        self.tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
-        
-        # Apply LRU caching to high-compute methods
-        if cache_enabled:
-            self.predict_location = lru_cache(maxsize=cache_size)(self.predict_location)
-            self.analyze_temporal_variations = lru_cache(maxsize=cache_size)(self.analyze_temporal_variations)
-            self.find_related_locations = lru_cache(maxsize=cache_size)(self.find_related_locations)
-            logger.info(f"Method caching enabled with size {cache_size}")
-    
-    def predict_location(self, text: str, top_k: int = 5) -> List[LocationPrediction]:
-        """
-        Generate location predictions with confidence metrics for a text query.
-        
-        Args:
-            text: Descriptive location text query
-            top_k: Number of predictions to return
-            
-        Returns:
-            List of LocationPrediction objects sorted by confidence
-        """
-        with torch.no_grad():
-            # Generate text embeddings
-            text_inputs = self.tokenizer(text, return_tensors="pt", padding=True).to(self.device)
-            text_features = self.model.image_encoder.mlp(
-                self.model.image_encoder.CLIP.get_text_features(**text_inputs)
-            )
-            text_features = F.normalize(text_features, dim=1)
-            
-            # Retrieve and normalize location features
-            gps_gallery = self.model.gps_gallery.to(self.device)
-            location_features = self.model.location_encoder(gps_gallery)
-            location_features = F.normalize(location_features, dim=1)
-            
-            # Compute similarity and extract top predictions
-            similarity = self.model.logit_scale.exp() * (text_features @ location_features.T)
-            probs = similarity.softmax(dim=-1)
-            top_pred = torch.topk(probs[0], top_k)
-            
-            # Convert to Python native types for consistent serialization
-            predictions = []
-            for coord, conf in zip(
-                gps_gallery[top_pred.indices].cpu().numpy(),
-                top_pred.values.cpu().numpy()
-            ):
-                predictions.append(LocationPrediction(
-                    coordinates=(float(coord[0]), float(coord[1])),
-                    confidence=float(conf)
-                ))
-            
-            return predictions
-    
-    def create_location_map(
-        self, 
-        predictions: List[LocationPrediction], 
-        title: str, 
-        zoom: int = 5,
-        heatmap: bool = True,
-        cluster: bool = False
-    ) -> str:
-        """
-        Generate an interactive folium map visualization from location predictions.
-        
-        Args:
-            predictions: List of location predictions
-            title: Map title/description
-            zoom: Initial zoom level (higher = more zoomed in)
-            heatmap: Whether to add heatmap layer
-            cluster: Whether to cluster nearby markers
-            
-        Returns:
-            HTML string of rendered interactive map
-        """
-        # Calculate center from prediction distribution
-        center_lat = sum(p.coordinates[0] for p in predictions) / len(predictions)
-        center_lon = sum(p.coordinates[1] for p in predictions) / len(predictions)
-        
-        # Initialize map
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=zoom)
-        
-        # Add heatmap if requested
-        if heatmap and len(predictions) > 1:
-            heat_data = [
-                [pred.coordinates[0], pred.coordinates[1], pred.confidence]
-                for pred in predictions
-            ]
-            HeatMap(heat_data, radius=25, blur=15, min_opacity=0.4).add_to(m)
-        
-        # Add markers with clustering option
-        if cluster:
-            marker_cluster = MarkerCluster().add_to(m)
-            
-            for i, pred in enumerate(predictions):
-                popup_text = f"{title} #{i+1}<br>Coordinates: {pred.coordinates[0]:.6f}, {pred.coordinates[1]:.6f}<br>Confidence: {pred.confidence:.4f}"
-                
-                folium.Marker(
-                    location=pred.coordinates,
-                    popup=popup_text,
-                    icon=folium.Icon(color='red' if i == 0 else 'blue')
-                ).add_to(marker_cluster)
-        else:
-            # Add top prediction with distinctive marker
-            top_pred = predictions[0]
-            folium.Marker(
-                location=top_pred.coordinates,
-                popup=f"{title}<br>Confidence: {top_pred.confidence:.4f}",
-                icon=folium.Icon(color='red', icon='info-sign')
-            ).add_to(m)
-            
-            # Add remaining predictions with standard markers
-            for i, pred in enumerate(predictions[1:], 1):
-                folium.Marker(
-                    location=pred.coordinates,
-                    popup=f"{title} #{i+1}<br>Confidence: {pred.confidence:.4f}",
-                    icon=folium.Icon(color='blue')
-                ).add_to(m)
-        
-        # Return HTML
-        return m._repr_html_()
-    
-    def analyze_at_scales(self, text: str) -> Dict[str, str]:
-        """
-        Perform multi-scale geospatial analysis with optimized visualization parameters.
-        
-        Args:
-            text: Location description text
-            
-        Returns:
-            Dictionary mapping scale names to HTML map visualizations
-        """
-        # Generate predictions
-        predictions = self.predict_location(text, top_k=10)
-        
-        # Define scale parameters (zoom level, display radius)
-        scales = {
-            'Street': {'zoom': 17, 'radius': 10},
-            'Neighborhood': {'zoom': 14, 'radius': 15},
-            'City': {'zoom': 11, 'radius': 20},
-            'Region': {'zoom': 8, 'radius': 25},
-            'Country': {'zoom': 5, 'radius': 30}
-        }
-        
-        # Generate visualizations at each scale
-        visualizations = {}
-        for scale_name, params in scales.items():
-            map_html = self.create_location_map(
-                predictions=predictions,
-                title=f"{scale_name} view of {text}",
-                zoom=params['zoom'],
-                heatmap=True if scale_name in ['Region', 'Country'] else False
-            )
-            visualizations[scale_name] = map_html
-        
-        return visualizations
-    
-    def analyze_temporal_variations(
-        self, 
-        base_location: str, 
-        time_periods: List[str]
-    ) -> Tuple[List[Tuple[str, Tuple[float, float], float]], str]:
-        """
-        Analyze location shifts across time periods with trajectory visualization.
-        
-        Args:
-            base_location: Base location descriptor
-            time_periods: List of time period identifiers
-            
-        Returns:
-            Tuple of (analysis_results, map_html)
-        """
-        results = []
-        m = folium.Map(zoom_start=4)
-        colors = ['red', 'blue', 'green', 'purple', 'orange', 'darkred', 'darkblue', 'cadetblue', 'darkgreen']
-        
-        for period, color in zip(time_periods, colors * (1 + len(time_periods) // len(colors))):
-            query = f"{base_location} in {period}"
-            predictions = self.predict_location(query, top_k=1)
-            
-            if predictions:
-                pred = predictions[0]
-                coords = pred.coordinates
-                conf = pred.confidence
-                
-                # Add marker with period information
-                folium.Marker(
-                    location=coords,
-                    popup=f"{period}<br>Confidence: {conf:.4f}",
-                    icon=folium.Icon(color=color, icon='info-sign')
-                ).add_to(m)
-                
-                results.append((period, coords, conf))
-        
-        # Connect points chronologically with polyline
-        if len(results) > 1:
-            points = [coords for _, coords, _ in results]
-            folium.PolyLine(points, weight=2, color='gray', opacity=0.8, 
-                           dash_array='5, 5').add_to(m)
-        
-        # Center map on middle point for optimal visualization
-        if results:
-            center_point = results[len(results)//2][1]
-            m.location = center_point
-        
-        return results, m._repr_html_()
-    
-    def find_related_locations(
-        self, 
-        reference: str, 
-        candidates: List[str]
-    ) -> List[Tuple[str, float]]:
-        """
-        Identify semantically related locations using embedding cosine similarity.
-        
-        Args:
-            reference: Reference location or concept
-            candidates: List of candidate locations to compare
-            
-        Returns:
-            List of (location, similarity_score) tuples sorted by relevance
-        """
-        with torch.no_grad():
-            # Generate reference embedding
-            text_inputs = self.tokenizer(reference, return_tensors="pt", padding=True).to(self.device)
-            ref_features = self.model.image_encoder.mlp(
-                self.model.image_encoder.CLIP.get_text_features(**text_inputs)
-            )
-            ref_features = F.normalize(ref_features, dim=1)
-            
-            results = []
-            for candidate in candidates:
-                # Generate candidate embedding
-                text_inputs = self.tokenizer(candidate, return_tensors="pt", padding=True).to(self.device)
-                cand_features = self.model.image_encoder.mlp(
-                    self.model.image_encoder.CLIP.get_text_features(**text_inputs)
-                )
-                cand_features = F.normalize(cand_features, dim=1)
-                
-                # Compute similarity
-                similarity = F.cosine_similarity(
-                    ref_features, cand_features
-                ).item()
-                
-                results.append((candidate, similarity))
-            
-            # Sort by similarity (descending)
-            return sorted(results, key=lambda x: x[1], reverse=True)
-    
-    def visualize_related_locations(
-        self, 
-        reference: str, 
-        candidates: List[str]
-    ) -> Tuple[List[Tuple[str, float]], str]:
-        """
-        Visualize semantically related locations with map integration.
-        
-        Args:
-            reference: Reference location or concept
-            candidates: List of candidate locations
-            
-        Returns:
-            Tuple of (similarity_results, map_html)
-        """
-        # Compute similarities
-        related_results = self.find_related_locations(reference, candidates)
-        
-        # Predict coordinates for all locations
-        marker_data = []
-        ref_predictions = self.predict_location(reference, top_k=1)
-        
-        if ref_predictions:
-            ref_coords = ref_predictions[0].coordinates
-            ref_conf = ref_predictions[0].confidence
-            marker_data.append((reference, ref_coords, ref_conf, 'red', 1.0))
-        
-            # Get coordinates for each candidate
-            for candidate, similarity in related_results:
-                predictions = self.predict_location(candidate, top_k=1)
-                if predictions:
-                    coords = predictions[0].coordinates
-                    conf = predictions[0].confidence
-                    marker_data.append((candidate, coords, conf, 'blue', similarity))
-        
-            # Create map
-            m = folium.Map()
-            
-            for name, coords, conf, color, sim in marker_data:
-                # Scale marker size by similarity
-                radius = 8 + (sim * 10) if name != reference else 15
-                
-                # Add circle marker
-                folium.CircleMarker(
-                    location=coords,
-                    radius=radius,
-                    popup=f"{name}<br>Similarity: {sim:.4f}<br>Confidence: {conf:.4f}",
-                    color=color,
-                    fill=True,
-                    fill_color=color
-                ).add_to(m)
-                
-                # Connect to reference with line
-                if name != reference:
-                    folium.PolyLine(
-                        [ref_coords, coords], 
-                        color=color,
-                        weight=sim * 5,  # Scale line weight by similarity
-                        opacity=0.7
-                    ).add_to(m)
-            
-            # Fit bounds to include all markers
-            if marker_data:
-                all_lats = [coords[0] for _, coords, _, _, _ in marker_data]
-                all_lons = [coords[1] for _, coords, _, _, _ in marker_data]
-                sw = [min(all_lats), min(all_lons)]
-                ne = [max(all_lats), max(all_lons)]
-                m.fit_bounds([sw, ne])
-            
-            return related_results, m._repr_html_()
-        
-        return related_results, ""
-
-    def comprehensive_analysis(self, location: str) -> Dict[str, Any]:
-        """
-        Execute comprehensive multi-faceted location analysis pipeline.
-        
-        Args:
-            location: Target location description
-            
-        Returns:
-            Dictionary containing all analysis results
-        """
-        results = {
-            "query": location,
-            "timestamp": None,  # Can be filled with current timestamp
-        }
-        
-        # Basic prediction
-        predictions = self.predict_location(location, top_k=5)
-        results["predictions"] = predictions
-        
-        # Create basic map
-        results["basic_map"] = self.create_location_map(
-            predictions, 
-            f"'{location}' Predictions"
-        )
-        
-        # Multi-scale analysis
-        results["scale_maps"] = self.analyze_at_scales(location)
-        
-        # Temporal analysis
-        time_periods = ["ancient times", "middle ages", "19th century", "modern day"]
-        temporal_results, temporal_map = self.analyze_temporal_variations(location, time_periods)
-        results["temporal_analysis"] = temporal_results
-        results["temporal_map"] = temporal_map
-        
-        # Related locations analysis
-        candidates = [
-            f"{location} business district",
-            f"{location} historic center",
-            f"{location} tourist area",
-            f"{location} downtown",
-            f"{location} suburbs"
-        ]
-        similarity_results, similarity_map = self.visualize_related_locations(
-            location, candidates
-        )
-        results["similarity_analysis"] = similarity_results
-        results["similarity_map"] = similarity_map
-        
-        return results
-
-
-def create_temporal_analysis_ui(analyzer):
-    """Create the temporal analysis interface component."""
-    with gr.Column():
-        gr.Markdown("## Temporal Analysis")
-        gr.Markdown("Analyze how a location changes across different time periods.")
-        
-        with gr.Row():
-            with gr.Column():
-                base_location = gr.Textbox(label="Base Location", placeholder="e.g., Constantinople")
-                with gr.Row():
-                    time_periods = gr.Textbox(
-                        label="Time Periods (comma-separated)", 
-                        placeholder="ancient times, middle ages, 19th century, modern day",
-                        value="ancient times, middle ages, 19th century, modern day"
-                    )
-                temporal_btn = gr.Button("Analyze Temporal Variations", variant="primary")
-            
-            with gr.Column():
-                temporal_results = gr.Dataframe(
-                    headers=["Time Period", "Latitude", "Longitude", "Confidence"],
-                    label="Temporal Analysis Results"
-                )
-                temporal_map = gr.HTML(label="Temporal Map")
-    
-    def run_temporal_analysis(location, periods_text):
-        if not location:
-            return None, "Please enter a base location"
-        
-        periods = [p.strip() for p in periods_text.split(",") if p.strip()]
-        if not periods:
-            return None, "Please enter at least one time period"
-        
-        try:
-            # Run analysis
-            results, map_html = analyzer.analyze_temporal_variations(location, periods)
-            
-            # Format results for dataframe
-            df_data = [
-                [period, coords[0], coords[1], conf]
-                for period, coords, conf in results
-            ]
-            
-            return df_data, map_html
-        except Exception as e:
-            logger.error(f"Error in temporal analysis: {str(e)}")
-            return None, f"Error: {str(e)}"
-    
-    temporal_btn.click(
-        fn=run_temporal_analysis,
-        inputs=[base_location, time_periods],
-        outputs=[temporal_results, temporal_map]
-    )
-    
-    return base_location, time_periods, temporal_btn, temporal_results, temporal_map
-
-
-def create_related_locations_ui(analyzer):
-    """Create the related locations interface component."""
-    with gr.Column():
-        gr.Markdown("## Related Locations Analysis")
-        gr.Markdown("Find semantically related locations based on GeoCLIP embeddings.")
-        
-        with gr.Row():
-            with gr.Column():
-                reference_location = gr.Textbox(
-                    label="Reference Location/Concept", 
-                    placeholder="e.g., technology hub"
-                )
-                candidate_locations = gr.Textbox(
-                    label="Candidate Locations (comma-separated)",
-                    placeholder="Silicon Valley, Shenzhen China, Bangalore India",
-                    value="Silicon Valley, Shenzhen China, Bangalore India, Tel Aviv Israel, London financial district"
-                )
-                related_btn = gr.Button("Find Related Locations", variant="primary")
-            
-            with gr.Column():
-                similarity_results = gr.Dataframe(
-                    headers=["Location", "Similarity Score"],
-                    label="Similarity Results"
-                )
-                similarity_map = gr.HTML(label="Similarity Map")
-    
-    def run_similarity_analysis(reference, candidates_text):
-        if not reference:
-            return None, "Please enter a reference location or concept"
-        
-        candidates = [c.strip() for c in candidates_text.split(",") if c.strip()]
-        if not candidates:
-            return None, "Please enter at least one candidate location"
-        
-        try:
-            # Run analysis
-            results, map_html = analyzer.visualize_related_locations(reference, candidates)
-            
-            # Format results for dataframe
-            df_data = [
-                [location, similarity]
-                for location, similarity in results
-            ]
-            
-            return df_data, map_html
-        except Exception as e:
-            logger.error(f"Error in similarity analysis: {str(e)}")
-            return None, f"Error: {str(e)}"
-    
-    related_btn.click(
-        fn=run_similarity_analysis,
-        inputs=[reference_location, candidate_locations],
-        outputs=[similarity_results, similarity_map]
-    )
-    
-    return reference_location, candidate_locations, related_btn, similarity_results, similarity_map
-
-
-def create_comprehensive_analysis_ui(analyzer):
-    """Create the comprehensive analysis interface component."""
-    with gr.Column():
-        gr.Markdown("## Comprehensive Analysis")
-        gr.Markdown("Perform a full multi-faceted analysis of a location.")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                comp_location = gr.Textbox(
-                    label="Location", 
-                    placeholder="e.g., Tokyo Japan"
-                )
-                comp_btn = gr.Button("Run Comprehensive Analysis", variant="primary")
-            
-            with gr.Column(scale=3):
-                with gr.Tabs():
-                    with gr.TabItem("Basic Prediction"):
-                        basic_results = gr.Dataframe(
-                            headers=["Rank", "Latitude", "Longitude", "Confidence"],
-                            label="Top Predictions"
-                        )
-                        basic_map = gr.HTML(label="Map")
-                    
-                    with gr.TabItem("Multi-scale Analysis"):
-                        with gr.Tabs() as scale_tabs:
-                            scale_maps = {
-                                scale: gr.HTML(label=f"{scale} Scale")
-                                for scale in ["Street", "Neighborhood", "City", "Region", "Country"]
-                            }
-                    
-                    with gr.TabItem("Temporal Analysis"):
-                        comp_temporal_results = gr.Dataframe(
-                            headers=["Time Period", "Latitude", "Longitude", "Confidence"],
-                            label="Temporal Analysis"
-                        )
-                        comp_temporal_map = gr.HTML(label="Temporal Map")
-                    
-                    with gr.TabItem("Related Contexts"):
-                        comp_similarity_results = gr.Dataframe(
-                            headers=["Context", "Similarity Score"],
-                            label="Related Contexts"
-                        )
-                        comp_similarity_map = gr.HTML(label="Similarity Map")
-    
-    def run_comprehensive_analysis(location):
-        if not location:
-            return (
-                None, "", 
-                {"Street": "", "Neighborhood": "", "City": "", "Region": "", "Country": ""},
-                None, "", None, ""
-            )
-        
-        try:
-            # Run analysis
-            results = analyzer.comprehensive_analysis(location)
-            
-            # Format basic results
-            basic_df = [
-                [i+1, pred.coordinates[0], pred.coordinates[1], pred.confidence]
-                for i, pred in enumerate(results["predictions"])
-            ]
-            
-            # Format temporal results
-            temporal_df = [
-                [period, coords[0], coords[1], conf]
-                for period, coords, conf in results["temporal_analysis"]
-            ] if "temporal_analysis" in results else None
-            
-            # Format similarity results
-            similarity_df = [
-                [location, similarity]
-                for location, similarity in results["similarity_analysis"]
-            ] if "similarity_analysis" in results else None
-            
-            return (
-                basic_df, 
-                results["basic_map"],
-                results["scale_maps"],
-                temporal_df,
-                results["temporal_map"],
-                similarity_df,
-                results["similarity_map"]
-            )
-        except Exception as e:
-            logger.error(f"Error in comprehensive analysis: {str(e)}")
-            return (
-                None, f"Error: {str(e)}", 
-                {"Street": "", "Neighborhood": "", "City": "", "Region": "", "Country": ""},
-                None, "", None, ""
-            )
-    
-    comp_btn.click(
-        fn=run_comprehensive_analysis,
-        inputs=[comp_location],
-        outputs=[
-            basic_results, basic_map, 
-            gr.Dict(scale_maps),
-            comp_temporal_results, comp_temporal_map,
-            comp_similarity_results, comp_similarity_map
-        ]
-    )
-    
-    return comp_location, comp_btn, basic_results, basic_map, scale_maps, comp_temporal_results, comp_temporal_map, comp_similarity_results, comp_similarity_map
-
-
-def create_interface():
-    """Create the Gradio interface for the GeoCLIP Text-to-Location Analyzer."""
-    # Initialize the analyzer with caching
-    analyzer = GeoCLIPAnalyzer(cache_enabled=True)
-    
-    with gr.Blocks(title="GeoCLIP Text-to-Location Analyzer") as demo:
-        gr.Markdown("# 🌍 GeoCLIP Text-to-Location Analyzer")
-        gr.Markdown("""
-        This interface allows you to analyze geographic locations using GeoCLIP's text-to-location capabilities.
-        You can perform basic location predictions, temporal analysis, find related locations, and run comprehensive analyses.
-        """)
-        
-        # Basic prediction section
-        with gr.Column():
-            gr.Markdown("## Basic Location Prediction")
-            gr.Markdown("Enter a textual description of a location to get coordinate predictions.")
-            
-            with gr.Row():
-                with gr.Column():
-                    location_input = gr.Textbox(
-                        label="Location Description", 
-                        placeholder="e.g., Eiffel Tower Paris"
-                    )
-                    top_k = gr.Slider(
-                        minimum=1, maximum=10, value=5, step=1,
-                        label="Number of Predictions"
-                    )
-                    predict_btn = gr.Button("Predict Location", variant="primary")
-                
-                with gr.Column():
-                    prediction_results = gr.Dataframe(
-                        headers=["Rank", "Latitude", "Longitude", "Confidence"],
-                        label="Prediction Results"
-                    )
-                    map_output = gr.HTML(label="Map Visualization")
-        
-        # Add tab-based sections for different analyses
-        with gr.Tabs():
-            with gr.TabItem("Multi-scale Analysis"):
-                with gr.Row():
-                    with gr.Column():
-                        scale_location = gr.Textbox(
-                            label="Location Description", 
-                            placeholder="e.g., Central Park New York"
-                        )
-                        scale_btn = gr.Button("Analyze at Different Scales", variant="primary")
-                    
-                    with gr.Column():
-                        with gr.Tabs() as scale_tabs:
-                            street_map = gr.HTML(label="Street Level")
-                            neighborhood_map = gr.HTML(label="Neighborhood Level")
-                            city_map = gr.HTML(label="City Level")
-                            region_map = gr.HTML(label="Regional Level")
-                            country_map = gr.HTML(label="Country Level")
-            
-            with gr.TabItem("Temporal Analysis"):
-                base_location, time_periods, temporal_btn, temporal_results, temporal_map = create_temporal_analysis_ui(analyzer)
-            
-            with gr.TabItem("Related Locations"):
-                reference_location, candidate_locations, related_btn, similarity_results, similarity_map = create_related_locations_ui(analyzer)
-            
-            with gr.TabItem("Comprehensive Analysis"):
-                comp_location, comp_btn, basic_results, basic_map, scale_maps, comp_temporal_results, comp_temporal_map, comp_similarity_results, comp_similarity_map = create_comprehensive_analysis_ui(analyzer)
-        
-        # Basic prediction handler
-        def handle_prediction(text, k):
-            if not text:
-                return None, "Please enter a location description"
-            
-            try:
-                predictions = analyzer.predict_location(text, top_k=int(k))
-                
-                # Format for dataframe
-                df_data = [
-                    [i+1, pred.coordinates[0], pred.coordinates[1], pred.confidence]
-                    for i, pred in enumerate(predictions)
-                ]
-                
-                # Create map
-                map_html = analyzer.create_location_map(predictions, f"'{text}' Predictions")
-                
-                return df_data, map_html
-            except Exception as e:
-                logger.error(f"Error in prediction: {str(e)}")
-                return None, f"Error: {str(e)}"
-        
-        # Multi-scale analysis handler
-        def handle_scale_analysis(text):
-            if not text:
-                return "", "", "", "", ""
-            
+# Config with defaults (editable via UI or env vars)
+DEFAULT_IMAGE_DIR = Path(os.environ.get("IMAGE_DIR", "./images"))
+DEFAULT_OUTPUT_FILE = Path(os.environ.get("OUTPUT_METADATA_FILE", "./metadata.jsonl"))
+HF_USERNAME = os.environ.get("HF_USERNAME", "latterworks")
+DATASET_NAME = os.environ.get("DATASET_NAME", "geo-metadata")
+
+SUPPORTED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.heic', '.tiff', '.bmp', '.webp'}
+
+# Convert GPS coordinates to decimal degrees
+def convert_to_degrees(value: tuple) -> Optional[float]:
+    try:
+        if not isinstance(value, (tuple, list)) or len(value) != 3:
+            raise ValueError("GPS value must be a tuple of 3 elements")
+        d, m, s = value
+        degrees = float(d) + (float(m) / 60.0) + (float(s) / 3600.0)
+        if not -180 <= degrees <= 180:
+            raise ValueError("GPS degrees out of valid range")
+        return degrees
+    except (TypeError, ValueError) as e:
+        logger.error(f"Failed to convert GPS coordinates: {e}")
+        return None
+
+# Extract and format GPS metadata
+def extract_gps_info(gps_info: Dict[int, Any]) -> Optional[Dict[str, Any]]:
+    if not isinstance(gps_info, dict):
+        logger.warning("GPSInfo ain’t a dict, skipping")
+        return None
+
+    gps_data = {}
+    try:
+        for key, val in gps_info.items():
+            tag_name = ExifTags.GPSTAGS.get(key, f"unknown_gps_tag_{key}")
+            gps_data[tag_name] = val
+
+        if 'GPSLatitude' in gps_data and 'GPSLongitude' in gps_data:
+            lat = convert_to_degrees(gps_data['GPSLatitude'])
+            lon = convert_to_degrees(gps_data['GPSLongitude'])
+            if lat is None or lon is None:
+                logger.error("Failed to convert lat/lon, skipping GPS")
+                return None
+
+            lat_ref = gps_data.get('GPSLatitudeRef', 'N')
+            lon_ref = gps_data.get('GPSLongitudeRef', 'E')
+            if lat_ref not in {'N', 'S'} or lon_ref not in {'E', 'W'}:
+                logger.warning(f"Bad GPS ref: {lat_ref}, {lon_ref}")
+            else:
+                if lat_ref == 'S':
+                    lat = -lat
+                if lon_ref == 'W':
+                    lon = -lon
+
+            gps_data['Latitude'] = lat
+            gps_data['Longitude'] = lon
+
+        return gps_data
+    except Exception as e:
+        logger.error(f"GPS extraction crashed: {traceback.format_exc()}")
+        return None
+
+# Make stuff JSON-serializable
+def make_serializable(value: Any) -> Any:
+    try:
+        if hasattr(value, 'numerator') and hasattr(value, 'denominator'):
+            return float(value.numerator) / float(value.denominator)
+        elif isinstance(value, (tuple, list)):
+            return [make_serializable(item) for item in value]
+        elif isinstance(value, dict):
+            return {str(k): make_serializable(v) for k, v in value.items()}
+        elif isinstance(value, bytes):
+            return value.decode('utf-8', errors='replace')
+        json.dumps(value)
+        return value
+    except Exception as e:
+        logger.warning(f"Serialization failed, stringin’ it: {e}")
+        return str(value)
+
+# Extract metadata from one image
+def get_image_metadata(image_path: Path) -> Dict[str, Any]:
+    metadata = {"file_name": str(image_path.absolute())}
+    try:
+        with Image.open(image_path) as image:
+            metadata.update({
+                "format": image.format or "unknown",
+                "size": list(image.size),
+                "mode": image.mode or "unknown"
+            })
+
+            exif_data = None
             try:
-                scale_maps = analyzer.analyze_at_scales(text)
-                return (
-                    scale_maps.get("Street", ""),
-                    scale_maps.get("Neighborhood", ""),
-                    scale_maps.get("City", ""),
-                    scale_maps.get("Region", ""),
-                    scale_maps.get("Country", "")
-                )
+                exif_data = image._getexif()
+            except AttributeError:
+                metadata["exif_error"] = "No EXIF data"
             except Exception as e:
-                logger.error(f"Error in scale analysis: {str(e)}")
-                error_msg = f"<div class='error'>Error: {str(e)}</div>"
-                return error_msg, error_msg, error_msg, error_msg, error_msg
-        
-        # Set up event handlers
-        predict_btn.click(
-            fn=handle_prediction,
-            inputs=[location_input, top_k],
-            outputs=[prediction_results, map_output]
-        )
-        
-        scale_btn.click(
-            fn=handle_scale_analysis,
-            inputs=[scale_location],
-            outputs=[street_map, neighborhood_map, city_map, region_map, country_map]
-        )
-        
-        gr.Markdown("""
-        ## About GeoCLIP
-        
-        GeoCLIP is a CLIP-inspired model that aligns locations with images for effective worldwide geo-localization.
-        This interface uses GeoCLIP's text encoder to map textual descriptions to geographic coordinates.
-        
-        All operations use efficient LRU caching for improved performance on repeated queries.
-        
-        **Reference:** [GeoCLIP: Clip-Inspired Alignment between Locations and Images for Effective Worldwide Geo-localization](https://arxiv.org/abs/2309.16020)
-        """)
-    
-    return demo
-
+                metadata["exif_error"] = f"EXIF crashed: {str(e)}"
+
+            if exif_data and isinstance(exif_data, dict):
+                for tag_id, value in exif_data.items():
+                    tag_name = ExifTags.TAGS.get(tag_id, f"tag_{tag_id}").lower()
+                    if tag_name == "gpsinfo":
+                        gps_info = extract_gps_info(value)
+                        if gps_info:
+                            metadata["gps_info"] = make_serializable(gps_info)
+                    else:
+                        metadata[tag_name] = make_serializable(value)
+
+        metadata["file_size"] = image_path.stat().st_size
+        metadata["file_extension"] = image_path.suffix.lower()
+        return metadata
+    except Exception as e:
+        logger.error(f"Image {image_path} crashed: {traceback.format_exc()}")
+        return {"file_name": str(image_path.absolute()), "error": str(e)}
+
+# Process images (single file or directory)
+def process_images(input_data: str | Path) -> List[Dict[str, Any]]:
+    metadata_list = []
+    input_path = Path(input_data)
+
+    if input_path.is_file() and input_path.suffix.lower() in SUPPORTED_EXTENSIONS:
+        logger.info(f"Processing single image: {input_path}")
+        metadata = get_image_metadata(input_path)
+        if metadata:
+            metadata_list.append(metadata)
+    elif input_path.is_dir():
+        logger.info(f"Processing directory: {input_path}")
+        for image_path in input_path.rglob("*"):
+            if image_path.is_file() and image_path.suffix.lower() in SUPPORTED_EXTENSIONS:
+                logger.info(f"Processing: {image_path}")
+                metadata = get_image_metadata(image_path)
+                if metadata:
+                    metadata_list.append(metadata)
+    else:
+        logger.error(f"Invalid input: {input_data}")
+        return [{"error": f"Invalid input: {input_data}"}]
+
+    return metadata_list
+
+# Save to JSONL
+def save_metadata_to_jsonl(metadata_list: List[Dict[str, Any]], output_file: Path) -> bool:
+    try:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        with output_file.open('w', encoding='utf-8') as f:
+            for entry in metadata_list:
+                f.write(json.dumps(entry, ensure_ascii=False) + '\n')
+        logger.info(f"Saved {len(metadata_list)} entries to {output_file}")
+        return True
+    except Exception as e:
+        logger.error(f"Save crashed: {traceback.format_exc()}")
+        return False
+
+# Upload to Hugging Face
+def upload_to_huggingface(metadata_file: Path, username: str, dataset_name: str) -> str:
+    try:
+        metadata_list = []
+        with metadata_file.open('r', encoding='utf-8') as f:
+            for line in f:
+                metadata_list.append(json.loads(line))
+
+        if not metadata_list:
+            return "No metadata to upload, fam!"
+
+        dataset = Dataset.from_dict({
+            "images": [entry.get("file_name") for entry in metadata_list],
+            "metadata": metadata_list
+        })
+        dataset.push_to_hub(f"{username}/{dataset_name}", private=False)
+        return f"Uploaded to {username}/{dataset_name} with {len(metadata_list)} entries!"
+    except Exception as e:
+        logger.error(f"Upload crashed: {traceback.format_exc()}")
+        return f"Upload failed: {str(e)}"
+
+# Gradio processing function
+def gradio_process(image_file, dir_path: str, username: str, dataset_name: str) -> str:
+    output = []
+    metadata_list = []
+
+    # Process single image if uploaded
+    if image_file:
+        image_path = Path(image_file.name)  # Gradio gives temp file path
+        metadata_list = process_images(image_path)
+        output.append("Single Image Metadata:")
+        for entry in metadata_list:
+            output.append(json.dumps(entry, indent=2))
+
+    # Process directory if provided
+    if dir_path:
+        dir_path = Path(dir_path)
+        if dir_path.is_dir():
+            metadata_list.extend(process_images(dir_path))
+            output.append("Directory Metadata:")
+            for entry in metadata_list[-len(process_images(dir_path)):]:
+                output.append(json.dumps(entry, indent=2))
+        else:
+            output.append(f"Error: {dir_path} ain’t a directory, fam!")
+
+    # Save and upload if we got metadata
+    if metadata_list:
+        temp_output_file = Path("temp_metadata.jsonl")
+        if save_metadata_to_jsonl(metadata_list, temp_output_file):
+            output.append(f"Saved metadata to {temp_output_file}")
+            upload_result = upload_to_huggingface(temp_output_file, username, dataset_name)
+            output.append(upload_result)
+        else:
+            output.append("Save failed, dawg!")
+
+    return "\n\n".join(output) if output else "Drop an image or dir, fam!"
+
+# Gradio interface
+demo = gr.Interface(
+    fn=gradio_process,
+    inputs=[
+        gr.File(label="Upload Image", file_types=list(SUPPORTED_EXTENSIONS)),
+        gr.Textbox(label="Image Directory", placeholder=str(DEFAULT_IMAGE_DIR), value=str(DEFAULT_IMAGE_DIR)),
+        gr.Textbox(label="Hugging Face Username", value=HF_USERNAME),
+        gr.Textbox(label="Dataset Name", value=DATASET_NAME)
+    ],
+    outputs=gr.Textbox(label="Metadata Output"),
+    title="Geo-Metadata Extractor",
+    description="Upload an image or point to a directory to extract metadata and push to Hugging Face, Bay Area style!",
+    allow_flagging="never"
+)
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+    logger.info("Firin’ up the Gradio geo-metadata extractor...")
+    demo.launch(server_name="0.0.0.0", server_port=7860)