Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,154 @@
+import gradio as gr
+from pathlib import Path
+from PIL import Image, ExifTags
+import json
+import os
+import logging
+from datasets import Dataset
+from huggingface_hub import HfApi
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_USERNAME = "latterworks"
+DATASET_NAME = "geo-metadata"
+SUPPORTED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.heic', '.tiff', '.bmp', '.webp'}
+
+def convert_to_degrees(value):
+    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 Exception as e:
+        logger.error(f"Failed to convert GPS coordinates: {e}")
+        return None
+
+def extract_gps_info(gps_info):
+    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")
+                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: {e}")
+        return None
+
+def make_serializable(value):
+    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"Converting to string due to serialization failure: {e}")
+        return str(value)
+
+def get_image_metadata(image_path):
+    metadata = {"file_name": str(Path(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"] = os.path.getsize(image_path)
+        metadata["file_extension"] = Path(image_path).suffix.lower()
+        json.dumps(metadata)
+        return metadata
+    except Exception as e:
+        logger.error(f"Error processing {image_path}: {e}")
+        return {"file_name": str(Path(image_path).absolute()), "error": str(e)}
+
+def process_images(image_files):
+    metadata_list = []
+    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}")
+            metadata = get_image_metadata(image_file.name)
+            if metadata:
+                metadata_list.append(metadata)
+    output_file = "metadata.jsonl"
+    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
+    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"{HF_USERNAME}/{DATASET_NAME}", token=HF_TOKEN)
+        api = HfApi()
+        api.upload_file(
+            path_or_fileobj=output_file,
+            path_in_repo="metadata.jsonl",
+            repo_id=f"{HF_USERNAME}/{DATASET_NAME}",
+            repo_type="dataset",
+            token=HF_TOKEN
+        )
+        return f"Processed {len(metadata_list)} images. Metadata saved to {output_file} and uploaded to {HF_USERNAME}/{DATASET_NAME}", output_file
+    return f"Processed {len(metadata_list)} images. Metadata saved to {output_file}", output_file
+
+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="Upload images to extract metadata (including GPS) and upload to Hugging Face Hub."
+)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)