Update app.py

app.py

@@ -1,68 +1,98 @@
-
-# Geo-Metadata Extractor (v1742324215)
 import gradio as gr
 from pathlib import Path
 from PIL import Image, ExifTags
 import json
 import os
 import logging
+import time
 from datasets import Dataset
 from huggingface_hub import HfApi
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+# Setup logging with timestamp
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("metadata_uploader.log")
+    ]
+)
 logger = logging.getLogger(__name__)
 
-# Token should be set as a secret in Space settings
+# Constants - put your shit here
 HF_TOKEN = os.environ.get("HF_TOKEN")
-HF_USERNAME = "latterworks"
-DATASET_NAME = "geo-metadata"
+HF_USERNAME = "latterworks"  # Your username
+DATASET_NAME = "geo-metadata"  # Your dataset name
 SUPPORTED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.heic', '.tiff', '.bmp', '.webp'}
 
+# Status tracking
+STATS = {
+    "uploads": 0,
+    "total_files": 0,
+    "files_with_gps": 0
+}
+
 def convert_to_degrees(value):
+    """Convert GPS coordinates to decimal degrees - handles all the edge cases"""
     try:
         if not isinstance(value, (tuple, list)) or len(value) != 3:
-            raise ValueError("GPS value must be a tuple of 3 elements")
+            raise ValueError(f"GPS needs 3 values, got {type(value)}")
+        
         d, m, s = value
-        degrees = float(d) + (float(m) / 60.0) + (float(s) / 3600.0)
+        # Convert from rational numbers if needed
+        d = d.numerator / d.denominator if hasattr(d, 'numerator') else float(d)
+        m = m.numerator / m.denominator if hasattr(m, 'numerator') else float(m)
+        s = s.numerator / s.denominator if hasattr(s, 'numerator') else float(s)
+        
+        degrees = d + (m / 60.0) + (s / 3600.0)
         if not -180 <= degrees <= 180:
-            raise ValueError("GPS degrees out of valid range")
+            logger.warning(f"GPS out of bounds: {degrees}°")
         return degrees
     except Exception as e:
-        logger.error(f"Failed to convert GPS coordinates: {e}")
+        logger.error(f"GPS conversion failed: {e}, value={value}")
         return None
 
 def extract_gps_info(gps_info):
+    """Extract and process GPS data from EXIF"""
     if not isinstance(gps_info, dict):
-        logger.warning("GPSInfo is not a dictionary, skipping")
         return None
+    
     gps_data = {}
     try:
+        # Extract tags
         for key, val in gps_info.items():
-            tag_name = ExifTags.GPSTAGS.get(key, f"unknown_gps_tag_{key}")
+            tag_name = ExifTags.GPSTAGS.get(key, f"gps_{key}")
             gps_data[tag_name] = val
+            
+        # Process lat/long if present
         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")
                 return None
+                
+            # Apply N/S/E/W reference
             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
+            
+            # Flip signs based on hemisphere
+            if lat_ref == 'S':
+                lat = -lat
+            if lon_ref == 'W':
+                lon = -lon
+                    
+            # Store clean coords with proper precision
+            gps_data['Latitude'] = round(lat, 6)
+            gps_data['Longitude'] = round(lon, 6)
+            
         return gps_data
     except Exception as e:
-        logger.error(f"Error extracting GPS info: {e}")
+        logger.error(f"GPS extraction error: {e}")
         return None
 
 def make_serializable(value):
+    """Make any value JSON serializable"""
     try:
         if hasattr(value, 'numerator') and hasattr(value, 'denominator'):
             return float(value.numerator) / float(value.denominator)
@@ -72,13 +102,13 @@ def make_serializable(value):
             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)
+        json.dumps(value)  # Test if serializable
         return value
-    except Exception as e:
-        logger.warning(f"Converting to string due to serialization failure: {e}")
+    except Exception:
         return str(value)
 
 def get_image_metadata(image_path):
+    """Extract all metadata from an image file"""
     metadata = {"file_name": str(Path(image_path).absolute())}
     try:
         with Image.open(image_path) as image:
@@ -87,13 +117,14 @@ def get_image_metadata(image_path):
                 "size": list(image.size),
                 "mode": image.mode or "unknown"
             })
+            
+            # Extract EXIF if available
             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)}"
+            except (AttributeError, Exception) as e:
+                metadata["exif_error"] = str(e)
+                
             if exif_data and isinstance(exif_data, dict):
                 for tag_id, value in exif_data.items():
                     try:
@@ -106,8 +137,13 @@ def get_image_metadata(image_path):
                             metadata[tag_name] = make_serializable(value)
                     except Exception as e:
                         metadata[f"error_tag_{tag_id}"] = str(e)
+                        
+        # Add file details
         metadata["file_size"] = os.path.getsize(image_path)
         metadata["file_extension"] = Path(image_path).suffix.lower()
+        metadata["extraction_timestamp"] = int(time.time())
+        
+        # Test serialization
         json.dumps(metadata)
         return metadata
     except Exception as e:
@@ -115,43 +151,132 @@ def get_image_metadata(image_path):
         return {"file_name": str(Path(image_path).absolute()), "error": str(e)}
 
 def process_images(image_files):
+    """Process images and upload metadata to Hugging Face"""
+    if not image_files:
+        return "🚫 Upload some fucking images first! 📷", None
+        
+    # Reset stats for this batch
+    batch_stats = {
+        "processed": 0,
+        "skipped": 0,
+        "errors": 0,
+        "with_gps": 0
+    }
+    
     metadata_list = []
+    filenames = []
+    
+    # Process each image
     for image_file in image_files:
-        if image_file and Path(image_file.name).suffix.lower() in SUPPORTED_EXTENSIONS:
-            logger.info(f"Processing: {image_file.name}")
+        if not image_file or not os.path.exists(image_file.name):
+            continue
+            
+        file_ext = Path(image_file.name).suffix.lower()
+        if file_ext not in SUPPORTED_EXTENSIONS:
+            logger.info(f"Skipping unsupported file: {image_file.name}")
+            batch_stats["skipped"] += 1
+            continue
+            
+        logger.info(f"Processing: {image_file.name}")
+        try:
             metadata = get_image_metadata(image_file.name)
             if metadata:
+                if "gps_info" in metadata:
+                    batch_stats["with_gps"] += 1
+                    STATS["files_with_gps"] += 1
                 metadata_list.append(metadata)
-    output_file = "metadata.jsonl"
+                filenames.append(Path(image_file.name).name)
+                batch_stats["processed"] += 1
+            else:
+                batch_stats["errors"] += 1
+        except Exception as e:
+            logger.error(f"Failed on {image_file.name}: {e}")
+            batch_stats["errors"] += 1
+    
+    # Exit if nothing processed
+    if not metadata_list:
+        return f"❌ No valid images. Skipped: {batch_stats['skipped']}, Errors: {batch_stats['errors']}", None
+    
+    # Generate unique filename
+    timestamp = int(time.time())
+    STATS["total_files"] += batch_stats["processed"]
+    output_file = f"metadata_{timestamp}.jsonl"
+    
+    # Save locally
     with open(output_file, 'w', encoding='utf-8') as f:
         for entry in metadata_list:
             f.write(json.dumps(entry, ensure_ascii=False) + '\n')
     
-    # Upload to Hugging Face
+    # Upload to HF
+    upload_status = "not uploaded (no token)"
     if HF_TOKEN:
-        dataset = Dataset.from_dict({
-            "images": [entry.get("file_name") for entry in metadata_list],
-            "metadata": metadata_list
-        })
-        dataset.push_to_hub(f"latterworks/geo-metadata", token=HF_TOKEN)
-        api = HfApi()
-        api.upload_file(
-            path_or_fileobj=output_file,
-            path_in_repo=f"metadata_{int(time.time())}.jsonl",
-            repo_id=f"latterworks/geo-metadata",
-            repo_type="dataset",
-            token=HF_TOKEN
-        )
-        return f"Processed {len(metadata_list)} images. Metadata saved to {output_file} and uploaded to latterworks/geo-metadata", output_file
-    return f"Processed {len(metadata_list)} images. Metadata saved to {output_file} but not uploaded (no token)", output_file
+        try:
+            logger.info(f"Uploading to {HF_USERNAME}/{DATASET_NAME}...")
+            
+            # Create dataset object with both filenames and full metadata
+            dataset = Dataset.from_dict({
+                "filename": filenames,
+                "metadata": metadata_list
+            })
+            
+            # Push to hub
+            dataset.push_to_hub(
+                f"{HF_USERNAME}/{DATASET_NAME}",
+                token=HF_TOKEN,
+                commit_message=f"Added metadata for {len(metadata_list)} images"
+            )
+            
+            # Upload raw JSONL file
+            api = HfApi()
+            api.upload_file(
+                path_or_fileobj=output_file,
+                path_in_repo=f"batches/metadata_{timestamp}.jsonl",
+                repo_id=f"{HF_USERNAME}/{DATASET_NAME}",
+                repo_type="dataset",
+                token=HF_TOKEN,
+                commit_message=f"Raw metadata batch {timestamp}"
+            )
+            
+            STATS["uploads"] += 1
+            upload_status = "✅ success"
+        except Exception as e:
+            logger.error(f"HF upload failed: {e}")
+            upload_status = f"❌ failed: {str(e)[:100]}..."
+    
+    # Return stats with all info
+    result = (
+        f"🔥 BATCH STATS 🔥\n"
+        f"✓ Processed: {batch_stats['processed']} images\n"
+        f"🌍 With GPS: {batch_stats['with_gps']}\n"
+        f"🚫 Skipped: {batch_stats['skipped']}\n"
+        f"⚠️ Errors: {batch_stats['errors']}\n"
+        f"☁️ Upload: {upload_status}\n\n"
+        f"📊 TOTAL STATS 📊\n"
+        f"Total files: {STATS['total_files']}\n"
+        f"Files with GPS: {STATS['files_with_gps']}\n"
+        f"Upload batches: {STATS['uploads']}"
+    )
+    
+    return result, output_file
 
+# Create the UI that actually fucking works
 demo = gr.Interface(
     fn=process_images,
-    inputs=gr.Files(label="Upload Images", file_types=["image"]),
-    outputs=[gr.Textbox(label="Status"), gr.File(label="Download Metadata")],
-    title="Geo-Metadata Extractor",
-    description=f"Upload images to extract metadata (including GPS) and automatically upload to latterworks/geo-metadata on Hugging Face Hub."
+    inputs=gr.Files(label="DROP IMAGES HERE 📸", file_types=["image"], file_count="multiple"),
+    outputs=[
+        gr.Textbox(label="Status Report", lines=10),
+        gr.File(label="Download Metadata JSONL")
+    ],
+    title="🌍 Geo-Metadata Extractor 🔥",
+    description=(
+        f"Upload images to extract all metadata including GPS coordinates. "
+        f"Supported formats: {', '.join(sorted(ext[1:] for ext in SUPPORTED_EXTENSIONS))}. "
+        f"Data automatically uploads to {HF_USERNAME}/{DATASET_NAME} on Hugging Face."
+    ),
+    allow_flagging="never",
+    theme="huggingface"
 )
 
+# Only launch when run directly
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)