Update app.py

app.py

@@ -2,57 +2,32 @@ import gradio as gr
 from pathlib import Path
 from PIL import Image, ExifTags
 import json
-import sys
 import os
 import logging
 import traceback
 import folium
-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)]
-)
+# Configure logging
+logging.basicConfig(level=logging.INFO)
 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
 SUPPORTED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.heic', '.tiff', '.bmp', '.webp'}
 
-# Convert GPS coordinates to decimal degrees
 def convert_to_degrees(value: tuple) -> Optional[float]:
+    """Convert GPS coordinates from DMS to decimal degrees."""
     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 float(d) + (float(m) / 60.0) + (float(s) / 3600.0)
+    except Exception as e:
+        logger.error(f"GPS conversion error: {e}")
         return None
 
-# Extract and format GPS metadata
 def extract_gps_info(gps_info: Dict[int, Any]) -> Optional[Dict[str, Any]]:
+    """Extract GPS data from EXIF."""
     if not isinstance(gps_info, dict):
-        logger.warning("GPSInfo is not a dictionary, skipping")
         return None
 
     gps_data = {}
@@ -64,63 +39,38 @@ def extract_gps_info(gps_info: Dict[int, Any]) -> Optional[Dict[str, Any]]:
         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
+            if gps_data.get('GPSLatitudeRef', 'N') == 'S':
+                lat = -lat
+            if gps_data.get('GPSLongitudeRef', 'E') == '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()}")
+        logger.error(f"GPS extraction error: {str(e)}")
         return None
 
-# 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)
-
-# Extract metadata from an image
 def get_image_metadata(image_path: Path) -> Dict[str, Any]:
+    """Extract metadata from a single image."""
     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"
+                "size": list(image.size)
             })
 
             exif_data = None
             try:
                 exif_data = image._getexif()
-            except AttributeError:
+            except Exception:
                 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():
@@ -129,537 +79,113 @@ def get_image_metadata(image_path: Path) -> Dict[str, Any]:
                         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
+                                metadata["gps_info"] = gps_info
+                    except Exception:
+                        pass
 
         return metadata
-
     except Exception as e:
-        logger.error(f"Error processing {image_path}: {traceback.format_exc()}")
+        logger.error(f"Error processing {image_path}: {str(e)}")
         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)
-    
-    if not image_dir.is_dir():
-        logger.error(f"Invalid or non-existent directory: {image_dir}")
-        return []
-
+def process_images(files) -> Tuple[str, List[Dict[str, Any]]]:
+    """Process uploaded image files."""
     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}")
-
+        # Create temp directory for uploads
+        temp_dir = Path("./temp_uploads")
+        temp_dir.mkdir(exist_ok=True)
+        
+        # Save and process uploaded files
+        for file in files:
+            # Handle byte content from Gradio uploads
+            if hasattr(file, "name") and hasattr(file, "read"):
+                file_path = temp_dir / file.name
+                with open(file_path, "wb") as f:
+                    f.write(file.read())
+                
+                if file_path.suffix.lower() in SUPPORTED_EXTENSIONS:
+                    metadata = get_image_metadata(file_path)
+                    if metadata:
+                        metadata_list.append(metadata)
+        
         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
-
+            return "No valid images found", []
+            
+        # Count geotagged images
+        geotagged = sum(1 for m in metadata_list if "gps_info" in m)
+        
+        return f"Processed {len(metadata_list)} images ({geotagged} geotagged)", metadata_list
+        
     except Exception as e:
-        logger.error(f"Failed to upload to Hugging Face: {traceback.format_exc()}")
-        return False
+        logger.error(f"Error processing uploads: {traceback.format_exc()}")
+        return f"Error: {str(e)}", []
 
-# Create a folium map with markers for geotagged images
-def create_geo_map(metadata_list: List[Dict[str, Any]]) -> str:
+def create_map(metadata_list: List[Dict[str, Any]]) -> str:
+    """Create a folium map with markers for geotagged images."""
     try:
-        # Filter entries that have GPS coordinates
-        geo_entries = []
+        # Extract coordinates
+        coords = []
         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")
-                })
+                coords.append((
+                    gps_info["Latitude"], 
+                    gps_info["Longitude"],
+                    os.path.basename(entry.get("file_name", "Unknown"))
+                ))
         
-        if not geo_entries:
+        if not coords:
             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()
+        # Calculate center
+        center_lat = sum(c[0] for c in coords) / len(coords)
+        center_lon = sum(c[1] for c in coords) / len(coords)
         
         # 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}
-            """
+        # Add markers
+        for lat, lon, name in coords:
             folium.Marker(
-                location=[row['latitude'], row['longitude']],
-                popup=folium.Popup(popup_text, max_width=300)
-            ).add_to(marker_cluster)
+                location=[lat, lon],
+                popup=f"<b>{name}</b><br>Location: {lat:.6f}, {lon:.6f}"
+            ).add_to(m)
         
-        # Save map to HTML string
+        # Convert to HTML
         map_html = m._repr_html_()
         return map_html
     
     except Exception as e:
-        logger.error(f"Error creating map: {traceback.format_exc()}")
+        logger.error(f"Error creating map: {str(e)}")
         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')
-        
-        # 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()
-"""
-        
-        return f'<img src="data:image/png;base64,{img_str}" alt="Embedding Visualization">', code_sample
+def ui_process_files(files):
+    """Handle file processing for the UI."""
+    if not files:
+        return "No files uploaded", None, "No data to display"
     
-    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
-            
-            # 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>
-            
-            <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>
-            
-            <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
-    
-    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)
-        
-        # 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)}", [], "", "", "", ""
-
-# 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)}", [], "", "", "", ""
-
-# 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"
+    status, metadata = process_images(files)
+    map_html = create_map(metadata) if metadata else "No map data available"
     
-    except Exception as e:
-        logger.error(f"Error uploading metadata: {traceback.format_exc()}")
-        return f"Error: {str(e)}"
+    return status, metadata, map_html
 
 # 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)
-            
-            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)
-            
-            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")
-            
-            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 demo
+demo = gr.Interface(
+    fn=ui_process_files,
+    inputs=gr.Files(label="Upload Images"),
+    outputs=[
+        gr.Textbox(label="Status"),
+        gr.JSON(label="Metadata"),
+        gr.HTML(label="Map")
+    ],
+    title="Simple Geotagged Image Analyzer",
+    description="Upload images to extract EXIF data and view locations on a map.",
+    examples=[],
+    cache_examples=False,
+    allow_flagging=False,
+)
 
-# Main entry point
 if __name__ == "__main__":
-    demo = create_interface()
     demo.launch()