Update app.py

app.py

@@ -1,145 +1,665 @@
+import gradio as gr
+from pathlib import Path
+from PIL import Image, ExifTags
+import json
+import sys
 import os
-import torch
+import logging
+import traceback
 import folium
-from folium.plugins import HeatMap
-import gradio as gr
-from typing import Dict, List, Any
-from functools import lru_cache
+from folium.plugins import MarkerCluster
+import pandas as pd
+import io
+import base64
+from typing import Dict, List, Any, Optional, Tuple, Union
+import matplotlib.pyplot as plt
+import numpy as np
+from datasets import Dataset
+from geoclip import LocationEncoder
+import torch
+
+# Set up logging to capture all events and errors
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger(__name__)
+
+# Configuration with environment variable fallback
+DEFAULT_IMAGE_DIR = os.environ.get("IMAGE_DIR", "./images")
+OUTPUT_METADATA_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 image extensions
+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:  # Basic sanity check
+            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 is not a dictionary, 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 latitude or longitude, skipping GPS data")
+                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"Invalid GPS reference: {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"Error extracting GPS info: {traceback.format_exc()}")
+        return None
 
-# GeoCLIP dependencies
-from geoclip import GeoCLIP
-from transformers import CLIPTokenizer
+# Convert non-serializable objects to JSON-serializable types
+def make_serializable(value: Any) -> Any:
+    try:
+        if hasattr(value, 'numerator') and hasattr(value, 'denominator'):  # PIL IFDRational
+            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)  # Test serialization
+        return value
+    except Exception as e:
+        logger.warning(f"Converting to string due to serialization failure: {e}")
+        return str(value)
 
-# Singleton pattern for GeoCLIP engine
-class GeoCLIPEngine:
-    _instance = None
+# Extract metadata from an 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:
+                exif_data = image._getexif()
+            except AttributeError:
+                metadata["exif_error"] = "No EXIF data available"
+            except Exception as e:
+                metadata["exif_error"] = f"EXIF extraction failed: {str(e)}"
+
+            if exif_data and isinstance(exif_data, dict):
+                for tag_id, value in exif_data.items():
+                    try:
+                        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)
+                    except Exception as e:
+                        metadata[f"error_tag_{tag_id}"] = str(e)
+
+        metadata["file_size"] = image_path.stat().st_size
+        metadata["file_extension"] = image_path.suffix.lower()
+
+        try:
+            json.dumps(metadata)
+        except Exception as e:
+            logger.error(f"Serialization failed for {image_path}: {e}")
+            clean_metadata = {k: v for k, v in metadata.items() if k in {"file_name", "format", "size", "mode", "file_size", "file_extension"}}
+            clean_metadata["serialization_error"] = str(e)
+            return clean_metadata
+
+        return metadata
+
+    except Exception as e:
+        logger.error(f"Error processing {image_path}: {traceback.format_exc()}")
+        return {"file_name": str(image_path.absolute()), "error": str(e)}
+
+# Process all images in the directory
+def process_images(image_dir: Union[str, Path]) -> List[Dict[str, Any]]:
+    if isinstance(image_dir, str):
+        image_dir = Path(image_dir)
     
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(GeoCLIPEngine, cls).__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
+    if not image_dir.is_dir():
+        logger.error(f"Invalid or non-existent directory: {image_dir}")
+        return []
+
+    metadata_list = []
+    for image_path in image_dir.rglob("*"):  # Recursive search
+        if image_path.is_file() and image_path.suffix.lower() in SUPPORTED_EXTENSIONS:
+            logger.info(f"Processing: {image_path}")
+            try:
+                metadata = get_image_metadata(image_path)
+                if metadata:
+                    metadata_list.append(metadata)
+            except Exception as e:
+                logger.error(f"Unexpected error processing {image_path}: {traceback.format_exc()}")
+                metadata_list.append({"file_name": str(image_path.absolute()), "error": str(e)})
+
+    return metadata_list
+
+# Save metadata to JSONL file
+def save_metadata_to_jsonl(metadata_list: List[Dict[str, Any]], output_file: Path) -> bool:
+    try:
+        with output_file.open('w', encoding='utf-8') as f:
+            for entry in metadata_list:
+                try:
+                    f.write(json.dumps(entry, ensure_ascii=False) + '\n')
+                except Exception as e:
+                    logger.error(f"Failed to write entry for {entry.get('file_name', 'unknown')}: {e}")
+                    f.write(json.dumps({"file_name": entry.get("file_name", "unknown"), "error": str(e)}) + '\n')
+        logger.info(f"Metadata saved to {output_file} with {len(metadata_list)} entries")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to save metadata to {output_file}: {traceback.format_exc()}")
+        return False
+
+# Upload dataset to Hugging Face Hub
+def upload_to_huggingface(metadata_file: Path, username: str, dataset_name: str) -> bool:
+    try:
+        metadata_list = []
+        with metadata_file.open('r', encoding='utf-8') as f:
+            for line in f:
+                try:
+                    metadata_list.append(json.loads(line))
+                except json.JSONDecodeError as e:
+                    logger.error(f"Failed to parse line in {metadata_file}: {e}")
+
+        if not metadata_list:
+            logger.error("No valid metadata entries to upload")
+            return False
+
+        image_paths = [entry.get("file_name") for entry in metadata_list if entry.get("file_name")]
+        dataset = Dataset.from_dict({
+            "images": image_paths,
+            "metadata": metadata_list
+        })
+
+        logger.info("Attempting to upload dataset to Hugging Face Hub")
+        dataset.push_to_hub(f"{username}/{dataset_name}", private=False)
+        logger.info(f"Dataset successfully uploaded to {username}/{dataset_name}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to upload to Hugging Face: {traceback.format_exc()}")
+        return False
+
+# Create a folium map with markers for geotagged images
+def create_geo_map(metadata_list: List[Dict[str, Any]]) -> str:
+    try:
+        # Filter entries that have GPS coordinates
+        geo_entries = []
+        for entry in metadata_list:
+            gps_info = entry.get("gps_info", {})
+            if isinstance(gps_info, dict) and "Latitude" in gps_info and "Longitude" in gps_info:
+                geo_entries.append({
+                    "file_name": entry.get("file_name", "Unknown"),
+                    "latitude": gps_info["Latitude"],
+                    "longitude": gps_info["Longitude"],
+                    "date_time": entry.get("datetime", "Unknown")
+                })
+        
+        if not geo_entries:
+            return "No geotagged images found"
+        
+        # Create a DataFrame for easier handling
+        df = pd.DataFrame(geo_entries)
+        
+        # Calculate map center based on average coordinates
+        center_lat = df["latitude"].mean()
+        center_lon = df["longitude"].mean()
+        
+        # Create map
+        m = folium.Map(location=[center_lat, center_lon], zoom_start=10)
+        
+        # Add marker cluster
+        marker_cluster = MarkerCluster().add_to(m)
+        
+        # Add markers for each image
+        for _, row in df.iterrows():
+            popup_text = f"""
+            <strong>File:</strong> {os.path.basename(row['file_name'])}<br>
+            <strong>Date:</strong> {row['date_time']}<br>
+            <strong>Location:</strong> {row['latitude']:.6f}, {row['longitude']:.6f}
+            """
+            folium.Marker(
+                location=[row['latitude'], row['longitude']],
+                popup=folium.Popup(popup_text, max_width=300)
+            ).add_to(marker_cluster)
+        
+        # Save map to HTML string
+        map_html = m._repr_html_()
+        return map_html
     
-    def __init__(self, device=None):
-        if self._initialized:
-            return
-            
-        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"Initializing GeoCLIP on {self.device}")
+    except Exception as e:
+        logger.error(f"Error creating map: {traceback.format_exc()}")
+        return f"Error creating map: {str(e)}"
+
+# Generate embedding visualization using GeoCLIP's LocationEncoder
+def generate_embedding_visualization(metadata_list: List[Dict[str, Any]]) -> Tuple[str, str]:
+    try:
+        # Filter entries that have GPS coordinates
+        geo_entries = []
+        for entry in metadata_list:
+            gps_info = entry.get("gps_info", {})
+            if isinstance(gps_info, dict) and "Latitude" in gps_info and "Longitude" in gps_info:
+                geo_entries.append({
+                    "file_name": os.path.basename(entry.get("file_name", "Unknown")),
+                    "latitude": gps_info["Latitude"],
+                    "longitude": gps_info["Longitude"]
+                })
+        
+        if len(geo_entries) < 2:
+            return "Not enough geotagged images for embedding visualization", None
+        
+        # Create a DataFrame
+        df = pd.DataFrame(geo_entries)
+        
+        # Initialize LocationEncoder
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        location_encoder = LocationEncoder().to(device)
+        
+        # Generate embeddings
+        coords = torch.tensor(df[["latitude", "longitude"]].values, dtype=torch.float32).to(device)
+        embeddings = location_encoder(coords).detach().cpu().numpy()
+        
+        # PCA visualization of embeddings
+        from sklearn.decomposition import PCA
+        pca = PCA(n_components=3)
+        pca_result = pca.fit_transform(embeddings)
+        
+        # Create 3D scatter plot
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111, projection='3d')
+        
+        scatter = ax.scatter(
+            pca_result[:, 0], 
+            pca_result[:, 1], 
+            pca_result[:, 2],
+            c=np.arange(len(pca_result)),
+            cmap='viridis',
+            s=100,
+            alpha=0.8
+        )
+        
+        # Add labels for each point
+        for i, filename in enumerate(df["file_name"]):
+            ax.text(pca_result[i, 0], pca_result[i, 1], pca_result[i, 2], filename, size=8)
+        
+        ax.set_title('GeoCLIP Embedding Visualization (PCA)')
+        ax.set_xlabel('PCA Component 1')
+        ax.set_ylabel('PCA Component 2')
+        ax.set_zlabel('PCA Component 3')
+        
+        # Convert plot to image
+        buffer = io.BytesIO()
+        plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
+        buffer.seek(0)
+        
+        # Convert to base64 for embedding in HTML
+        img_str = base64.b64encode(buffer.read()).decode('utf-8')
         
-        self._model = GeoCLIP().to(self.device)
-        self._tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
-        self._gps_gallery = None  # Lazy-loaded on first prediction
+        # Generate code for embedding space exploration
+        code_sample = """
+# GeoCLIP Location Encoder Exploration Code
+from geoclip import LocationEncoder
+import torch
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+import numpy as np
+
+# Initialize LocationEncoder
+device = "cuda" if torch.cuda.is_available() else "cpu"
+location_encoder = LocationEncoder().to(device)
+
+# Generate embeddings for your coordinates
+coords = torch.tensor([
+    [40.7128, -74.0060],  # New York
+    [34.0522, -118.2437], # Los Angeles
+    [51.5074, -0.1278],   # London
+    [35.6762, 139.6503],  # Tokyo
+    [28.6139, 77.2090],   # Delhi
+], dtype=torch.float32).to(device)
+
+embeddings = location_encoder(coords).detach().cpu().numpy()
+
+# Visualize with PCA
+pca = PCA(n_components=2)
+pca_result = pca.fit_transform(embeddings)
+
+plt.figure(figsize=(10, 8))
+plt.scatter(pca_result[:, 0], pca_result[:, 1], s=100)
+
+locations = ["New York", "Los Angeles", "London", "Tokyo", "Delhi"]
+for i, location in enumerate(locations):
+    plt.annotate(location, (pca_result[i, 0], pca_result[i, 1]), fontsize=12)
+
+plt.title('GeoCLIP Location Embeddings (PCA)')
+plt.xlabel('PCA Component 1')
+plt.ylabel('PCA Component 2')
+plt.grid(True, alpha=0.3)
+plt.show()
+"""
         
-        self._initialized = True
+        return f'<img src="data:image/png;base64,{img_str}" alt="Embedding Visualization">', code_sample
     
-    @lru_cache(maxsize=32)
-    def predict_location(self, text: str, top_k: int = 5) -> List[Dict[str, Any]]:
-        """Vectorized text-to-location prediction with tensor optimization."""
-        with torch.no_grad():
-            # Generate text embedding with optimal tensor allocation
-            tokens = 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(**tokens)
-            )
-            text_features = torch.nn.functional.normalize(text_features, dim=1)
-            
-            # Ensure GPS gallery is loaded with resource 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
-            location_features = self._model.location_encoder(self._gps_gallery)
-            location_features = torch.nn.functional.normalize(location_features, dim=1)
+    except Exception as e:
+        logger.error(f"Error generating embedding visualization: {traceback.format_exc()}")
+        return f"Error generating embedding visualization: {str(e)}", None
+
+# Function to analyze metadata and extract insights
+def analyze_metadata(metadata_list: List[Dict[str, Any]]) -> str:
+    try:
+        total_images = len(metadata_list)
+        if total_images == 0:
+            return "No images found in metadata"
+        
+        geotagged_count = sum(1 for entry in metadata_list if "gps_info" in entry and entry["gps_info"].get("Latitude") is not None)
+        camera_models = {}
+        capture_dates = []
+        
+        for entry in metadata_list:
+            # Extract camera model
+            model = entry.get("model", "Unknown")
+            camera_models[model] = camera_models.get(model, 0) + 1
             
-            # Calculate similarity with vectorized matrix multiplication
-            similarity = self._model.logit_scale.exp() * (text_features @ location_features.T)
-            probs = similarity.softmax(dim=-1)
+            # Extract capture dates
+            date_str = entry.get("datetime", "")
+            if date_str and isinstance(date_str, str):
+                try:
+                    # Simple extraction of date part (assuming format like "YYYY:MM:DD HH:MM:SS")
+                    date_part = date_str.split()[0] if " " in date_str else date_str
+                    capture_dates.append(date_part)
+                except:
+                    pass
+        
+        # Generate HTML report
+        html_report = f"""
+        <div style="font-family: Arial, sans-serif; padding: 20px; background-color: #f5f5f5; border-radius: 10px;">
+            <h2 style="color: #333;">Metadata Analysis Report</h2>
             
-            # Extract top predictions
-            top_values, top_indices = torch.topk(probs[0], min(top_k, len(self._gps_gallery)))
+            <div style="margin: 20px 0; padding: 15px; background-color: #fff; border-radius: 5px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
+                <h3 style="color: #0066cc;">Summary</h3>
+                <ul>
+                    <li><strong>Total Images:</strong> {total_images}</li>
+                    <li><strong>Geotagged Images:</strong> {geotagged_count} ({geotagged_count/total_images*100:.1f}%)</li>
+                    <li><strong>Unique Camera Models:</strong> {len(camera_models)}</li>
+                    <li><strong>Date Range:</strong> {min(capture_dates) if capture_dates else 'Unknown'} to {max(capture_dates) if capture_dates else 'Unknown'}</li>
+                </ul>
+            </div>
             
-            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())
-            ]
+            <div style="display: flex; flex-wrap: wrap; gap: 20px;">
+                <div style="flex: 1; min-width: 300px; margin: 10px 0; padding: 15px; background-color: #fff; border-radius: 5px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
+                    <h3 style="color: #0066cc;">Camera Models</h3>
+                    <ul>
+        """
+        
+        # Add top 5 camera models
+        for model, count in sorted(camera_models.items(), key=lambda x: x[1], reverse=True)[:5]:
+            html_report += f'<li><strong>{model}:</strong> {count} images ({count/total_images*100:.1f}%)</li>'
+        
+        html_report += """
+                    </ul>
+                </div>
+            </div>
+        </div>
+        """
+        
+        return html_report
     
-    def create_map_visualization(self, predictions: List[Dict[str, Any]], title: str = "") -> folium.Map:
-        """Generate geospatial visualization."""
-        # Initialize map centered on highest confidence prediction
-        center_coords = predictions[0]["coordinates"]
-        m = folium.Map(location=center_coords, zoom_start=5, tiles="OpenStreetMap")
-        
-        # Add markers and heatmap
-        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(m)
-            
-        if len(predictions) >= 3:
-            heat_data = [[p["coordinates"][0], p["coordinates"][1], p["confidence"]] 
-                        for p in predictions]
-            HeatMap(heat_data, radius=15, blur=10).add_to(m)
+    except Exception as e:
+        logger.error(f"Error analyzing metadata: {traceback.format_exc()}")
+        return f"Error analyzing metadata: {str(e)}"
+
+# Function to process a batch of uploaded files
+def process_uploaded_files(files) -> Tuple[str, List[Dict[str, Any]], str, str, str]:
+    try:
+        if not files:
+            return "No files uploaded", [], "", "", ""
+        
+        # Create temporary directory for uploaded files
+        temp_dir = Path("./temp_uploads")
+        temp_dir.mkdir(exist_ok=True)
         
-        return m
+        # Save uploaded files to temp directory
+        for file in files:
+            file_path = temp_dir / file.name
+            with open(file_path, "wb") as f:
+                f.write(file.read())
+        
+        # Process the images
+        metadata_list = process_images(temp_dir)
+        
+        if not metadata_list:
+            return "No valid images found in uploads", [], "", "", ""
+        
+        # Generate analysis and visualizations
+        analysis_html = analyze_metadata(metadata_list)
+        map_html = create_geo_map(metadata_list)
+        embedding_viz, code_sample = generate_embedding_visualization(metadata_list)
+        
+        # Save metadata to file
+        output_file = Path("./uploaded_metadata.jsonl")
+        save_metadata_to_jsonl(metadata_list, output_file)
+        
+        return f"Processed {len(metadata_list)} images successfully", metadata_list, analysis_html, map_html, embedding_viz, code_sample
+    
+    except Exception as e:
+        logger.error(f"Error processing uploaded files: {traceback.format_exc()}")
+        return f"Error: {str(e)}", [], "", "", "", ""
 
-# Initialize global singleton
-engine = GeoCLIPEngine()
+# Function to process an existing directory
+def process_directory(directory_path: str) -> Tuple[str, List[Dict[str, Any]], str, str, str]:
+    try:
+        if not directory_path or not os.path.isdir(directory_path):
+            return "Invalid directory path", [], "", "", "", ""
+        
+        # Process the images in the directory
+        metadata_list = process_images(directory_path)
+        
+        if not metadata_list:
+            return "No valid images found in directory", [], "", "", "", ""
+        
+        # Generate analysis and visualizations
+        analysis_html = analyze_metadata(metadata_list)
+        map_html = create_geo_map(metadata_list)
+        embedding_viz, code_sample = generate_embedding_visualization(metadata_list)
+        
+        # Save metadata to file
+        output_file = Path("./directory_metadata.jsonl")
+        save_metadata_to_jsonl(metadata_list, output_file)
+        
+        return f"Processed {len(metadata_list)} images successfully", metadata_list, analysis_html, map_html, embedding_viz, code_sample
+    
+    except Exception as e:
+        logger.error(f"Error processing directory: {traceback.format_exc()}")
+        return f"Error: {str(e)}", [], "", "", "", ""
 
-# Fixed chat function with proper output handling
-def loc_chat(message, history):
-    """Chat function that avoids returning Code objects."""
-    # Process location queries
-    if any(term in message.lower() for term in ["location", "where", "place", "find"]):
-        try:
-            # Execute prediction with tensor acceleration
-            predictions = engine.predict_location(message, top_k=5)
+# Upload metadata to Hugging Face
+def upload_metadata(metadata_list: List[Dict[str, Any]], username: str, dataset_name: str) -> str:
+    try:
+        if not metadata_list:
+            return "No metadata to upload"
+        
+        # Save metadata to temporary file
+        output_file = Path(f"./{dataset_name}_metadata.jsonl")
+        save_metadata_to_jsonl(metadata_list, output_file)
+        
+        # Upload to Hugging Face
+        success = upload_to_huggingface(output_file, username, dataset_name)
+        
+        if success:
+            return f"Successfully uploaded dataset to {username}/{dataset_name}"
+        else:
+            return "Failed to upload dataset to Hugging Face"
+    
+    except Exception as e:
+        logger.error(f"Error uploading metadata: {traceback.format_exc()}")
+        return f"Error: {str(e)}"
+
+# Create the Gradio interface
+def create_interface():
+    with gr.Blocks(title="GeoCLIP Image Metadata Analyzer") as demo:
+        gr.Markdown("# 🌍 GeoCLIP Image Metadata Analyzer")
+        gr.Markdown("This tool extracts and analyzes EXIF metadata from images, with a focus on geolocation data. It leverages GeoCLIP embeddings to visualize geographic relationships.")
+        
+        with gr.Tabs():
+            with gr.TabItem("Upload Files"):
+                with gr.Row():
+                    with gr.Column():
+                        upload_files = gr.Files(label="Upload Images", file_count="multiple")
+                        upload_button = gr.Button("Process Uploaded Files")
+                    
+                    with gr.Column():
+                        status_output = gr.Textbox(label="Status")
+                
+                with gr.Accordion("Raw Metadata", open=False):
+                    metadata_json = gr.JSON(label="Extracted Metadata")
+                
+                with gr.Row():
+                    with gr.Column():
+                        analysis_html = gr.HTML(label="Analysis Report")
+                    with gr.Column():
+                        map_html = gr.HTML(label="Geographic Map")
+                
+                with gr.Row():
+                    with gr.Column():
+                        embedding_viz = gr.HTML(label="GeoCLIP Embedding Visualization")
+                    with gr.Column():
+                        embedding_code = gr.Code(language="python", label="GeoCLIP Exploration Code", lines=20)
             
-            # Generate map visualization
-            m = engine.create_map_visualization(predictions, f"Predictions for: {message}")
+            with gr.TabItem("Process Directory"):
+                with gr.Row():
+                    with gr.Column():
+                        dir_path = gr.Textbox(label="Directory Path", placeholder=DEFAULT_IMAGE_DIR)
+                        dir_button = gr.Button("Process Directory")
+                    
+                    with gr.Column():
+                        dir_status = gr.Textbox(label="Status")
+                
+                with gr.Accordion("Raw Metadata", open=False):
+                    dir_metadata_json = gr.JSON(label="Extracted Metadata")
+                
+                with gr.Row():
+                    with gr.Column():
+                        dir_analysis_html = gr.HTML(label="Analysis Report")
+                    with gr.Column():
+                        dir_map_html = gr.HTML(label="Geographic Map")
+                
+                with gr.Row():
+                    with gr.Column():
+                        dir_embedding_viz = gr.HTML(label="GeoCLIP Embedding Visualization")
+                    with gr.Column():
+                        dir_embedding_code = gr.Code(language="python", label="GeoCLIP Exploration Code", lines=20)
             
-            # Format response with structured information
-            result_text = f"Top predictions for: '{message}'\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"
+            with gr.TabItem("Upload to HuggingFace"):
+                with gr.Row():
+                    with gr.Column():
+                        hf_username = gr.Textbox(label="HuggingFace Username", value=HF_USERNAME)
+                        hf_dataset = gr.Textbox(label="Dataset Name", value=DATASET_NAME)
+                        hf_source = gr.Radio(["From Uploaded Files", "From Directory"], label="Source", value="From Uploaded Files")
+                        hf_upload_button = gr.Button("Upload to HuggingFace")
+                    
+                    with gr.Column():
+                        hf_status = gr.Textbox(label="Upload Status")
+        
+        # Define event handlers
+        upload_button.click(
+            fn=process_uploaded_files,
+            inputs=[upload_files],
+            outputs=[status_output, metadata_json, analysis_html, map_html, embedding_viz, embedding_code]
+        )
+        
+        dir_button.click(
+            fn=process_directory,
+            inputs=[dir_path],
+            outputs=[dir_status, dir_metadata_json, dir_analysis_html, dir_map_html, dir_embedding_viz, dir_embedding_code]
+        )
+        
+        def handle_hf_upload(username, dataset_name, source):
+            if source == "From Uploaded Files":
+                metadata_file = Path("./uploaded_metadata.jsonl")
+            else:
+                metadata_file = Path("./directory_metadata.jsonl")
             
-            # Return only string and HTML types to avoid validation errors
-            return result_text, gr.HTML(value=m._repr_html_())
-        except Exception as e:
-            return f"Error: {str(e)}", None
+            if not metadata_file.exists():
+                return "No metadata file found. Please process images first."
+            
+            try:
+                metadata_list = []
+                with metadata_file.open('r', encoding='utf-8') as f:
+                    for line in f:
+                        try:
+                            metadata_list.append(json.loads(line))
+                        except json.JSONDecodeError:
+                            pass
+                
+                return upload_metadata(metadata_list, username, dataset_name)
+            except Exception as e:
+                return f"Error: {str(e)}"
+        
+        hf_upload_button.click(
+            fn=handle_hf_upload,
+            inputs=[hf_username, hf_dataset, hf_source],
+            outputs=[hf_status]
+        )
+        
+        gr.Markdown("""
+        ## About this Tool
+        
+        This application integrates **GeoCLIP** location embeddings to analyze and visualize geographic relationships between images. 
+        
+        GeoCLIP is a CLIP-inspired model that aligns locations with images for effective worldwide geo-localization.
+        
+        **Features:**
+        - Extract EXIF metadata from images, including geolocation data
+        - Visualize image locations on an interactive map
+        - Generate GeoCLIP embeddings for geographic coordinates
+        - Upload processed metadata to Hugging Face datasets
+        
+        **Reference:** [GeoCLIP: Clip-Inspired Alignment between Locations and Images for Effective Worldwide Geo-localization](https://arxiv.org/abs/2309.16020)
+        """)
     
-    return "Ask about a location like 'Where is the Eiffel Tower?'", None
+    return demo
 
-# Interface with minimal dependencies
-with gr.Blocks() as demo:
-    map_output = gr.HTML(render=False)
-    
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("<h1>GeoCLIP Location Intelligence</h1>")
-            
-            chatbot = gr.ChatInterface(
-                loc_chat,
-                examples=["Where is the Eiffel Tower?", "Find ancient pyramids in desert"],
-                additional_outputs=[map_output],
-                type="messages"  # Critical: use messages type to avoid deprecation
-            )
-        
-        with gr.Column():
-            gr.Markdown("<h1>Map Visualization</h1>")
-            map_output.render()
-
-# Main entrypoint with error mitigation configuration
+# Main entry point
 if __name__ == "__main__":
-    demo.launch(
-        share=True,
-        server_name="0.0.0.0",
-        cache_examples=False,  # Critical: Disable example caching
-        show_error=True
-    )
+    demo = create_interface()
+    demo.launch()