Update app.py

app.py

@@ -1,6 +1,9 @@
 """
-Lanternfly Field Capture Space
+Lanternfly Field Capture Space - Resilient GPS (V9)
 A Gradio app for capturing photos with GPS coordinates and saving to Hugging Face datasets.
+
+This version incorporates all debugging fixes: safe handling of empty input, 
+resilient component selection, and relaxed GPS timeout settings.
 """
 
 import gradio as gr
@@ -11,62 +14,63 @@ from datetime import datetime
 from PIL import Image
 from huggingface_hub import HfApi, hf_hub_download, create_repo, file_exists, upload_file
 import io
+import time
+import requests
 
 # Configuration
-HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HF_TOKEN_SPACE")  # Try both token sources
-DATASET_REPO = os.getenv("DATASET_REPO", "rlogh/lanternfly-data")  # Default to your dataset
+# NOTE: Set HF_TOKEN environment variable in Colab or your Hugging Face Space settings.
+HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HF_TOKEN_SPACE") 
+DATASET_REPO = os.getenv("DATASET_REPO", "rlogh/lanternfly-data")
 
 # Initialize HF API only if credentials are available
 api = None
 if HF_TOKEN and DATASET_REPO:
-    api = HfApi(token=HF_TOKEN)
-    # Ensure dataset repo exists (idempotent)
     try:
+        # Initializing HfApi inside the running app environment
+        api = HfApi(token=HF_TOKEN)
         create_repo(DATASET_REPO, repo_type="dataset", exist_ok=True, token=HF_TOKEN)
         print("✅ Hugging Face credentials found - dataset saving enabled")
     except Exception as e:
-        print(f"⚠️  Error creating dataset repo: {e}")
+        print(f"⚠️ Error initializing HF API: {e}")
         api = None
 else:
-    print("⚠️  Running in test mode - no HF credentials (dataset saving disabled)")
+    print("⚠️ Running in test mode - no HF credentials (dataset saving disabled)")
 
 # Constants for file paths
 METADATA_PATH = "metadata/entries.jsonl"
 IMAGES_DIR = "images"
 
+# --- Utility Functions ---
+
 def get_current_time():
-    """Get current timestamp"""
+    """Get current timestamp in ISO format"""
     return datetime.now().isoformat()
 
 def _append_jsonl_in_repo(new_row: dict) -> None:
-    """
-    Appends a JSON line to metadata/entries.jsonl in the dataset repo.
-    Downloads the existing file (if any), appends, and uploads back.
-    """
-    # Create a temp file in memory to reupload
-    # First, try to download existing entries.jsonl (if present)
+    """Appends a JSON line to metadata/entries.jsonl in the dataset repo."""
+    if not api: return 
+    
     buf = io.BytesIO()
     existing_lines = []
-    try:
-        if file_exists(DATASET_REPO, METADATA_PATH, repo_type="dataset", token=HF_TOKEN):
-            local_path = hf_hub_download(
-                repo_id=DATASET_REPO, filename=METADATA_PATH,
-                repo_type="dataset", token=HF_TOKEN
-            )
-            with open(local_path, "r", encoding="utf-8") as f:
-                existing_lines = f.read().splitlines()
-    except Exception:
-        # If download fails for any reason, proceed as if file doesn't exist
-        existing_lines = []
+    
+    for i in range(3):
+        try:
+            if file_exists(DATASET_REPO, METADATA_PATH, repo_type="dataset", token=HF_TOKEN):
+                local_path = hf_hub_download(
+                    repo_id=DATASET_REPO, filename=METADATA_PATH,
+                    repo_type="dataset", token=HF_TOKEN
+                )
+                with open(local_path, "r", encoding="utf-8") as f:
+                    existing_lines = f.read().splitlines()
+                break
+        except Exception as e:
+            if i == 2: raise e
+            time.sleep(1 * (i + 1)) 
 
-    # Append our new row
     existing_lines.append(json.dumps(new_row, ensure_ascii=False))
-
-    # Write back to buffer
     data = "\n".join(existing_lines).encode("utf-8")
     buf.write(data); buf.seek(0)
 
-    # Upload to the same path (commit creates or updates the file)
     upload_file(
         path_or_fileobj=buf,
         path_in_repo=METADATA_PATH,
@@ -77,9 +81,9 @@ def _append_jsonl_in_repo(new_row: dict) -> None:
     )
 
 def _save_image_to_repo(pil_img: Image.Image, dest_rel_path: str) -> None:
-    """
-    Uploads a PIL image into the dataset repo (e.g., images/<uuid>.jpg).
-    """
+    """Uploads a PIL image into the dataset repo."""
+    if not api: return
+    
     img_bytes = io.BytesIO()
     pil_img.save(img_bytes, format="JPEG", quality=90)
     img_bytes.seek(0)
@@ -93,242 +97,237 @@ def _save_image_to_repo(pil_img: Image.Image, dest_rel_path: str) -> None:
         commit_message=f"Upload image {dest_rel_path}",
     )
 
-def handle_time_capture():
-    """Handle time capture and return status message"""
-    timestamp = get_current_time()
-    status_msg = f"🕐 **Time Captured**: {timestamp}"
-    return status_msg, timestamp
-
 def handle_gps_location(json_str):
-    """Handle GPS location data from JavaScript and return values for the textboxes"""
+    """
+    Handles GPS location data from JavaScript. 
+    Includes V8 fix to prevent crash on empty initial input.
+    """
+    # V8 FIX: Ignore empty input from initial component change event
+    if not json_str:
+        return gr.NoAction(), gr.NoAction(), gr.NoAction(), gr.NoAction(), gr.NoAction()
+    
     try:
         data = json.loads(json_str)
+
         if 'error' in data:
-            status_msg = f"❌ **GPS Error**: {data['error']}"
-            return status_msg, data['error'], "", "", ""
-        
+            # Map Geolocation API error codes for better user feedback
+            error_map = {
+                1: "Permission Denied (Check browser settings)",
+                2: "Position Unavailable (Poor signal/network)",
+                3: "Timeout Expired (Fix took too long)",
+                0: "Geolocation not supported",
+                'N/A': "Unknown Geolocation Error"
+            }
+            error_code = data.get('code', 'N/A')
+            error_msg = error_map.get(error_code, data.get('error', 'Unknown Error'))
+            
+            gr.Warning(f"GPS Error: Code {error_code} ({error_msg})")
+
+            status_msg = f"❌ **GPS Error (Code {error_code})**: {error_msg}"
+            return status_msg, "N/A", "N/A", "N/A", get_current_time()
+
         lat = str(data.get('latitude', ''))
         lon = str(data.get('longitude', ''))
         accuracy = str(data.get('accuracy', ''))
-        timestamp = data.get('timestamp', '')
-        
-        # Convert timestamp to ISO string if it's a number
-        if timestamp and isinstance(timestamp, (int, float)):
-            from datetime import datetime
-            timestamp = datetime.fromtimestamp(timestamp / 1000).isoformat()
+        timestamp = str(data.get('timestamp', ''))
         
-        status_msg = f"✅ **GPS Captured**: {lat[:8]}, {lon[:8]} (accuracy: {accuracy}m)"
+        try:
+            acc_display = f"{float(accuracy):.1f}"
+        except ValueError:
+            acc_display = "N/A"
+
+        status_msg = f"✅ **GPS Captured**: {lat[:8]}, {lon[:8]} (accuracy: {acc_display}m)"
         return status_msg, lat, lon, accuracy, timestamp
-        
+
     except Exception as e:
-        status_msg = f"❌ **Error**: {str(e)}"
-        return status_msg, f"Error parsing GPS data: {str(e)}", "", "", ""
+        # Catch unexpected JSON errors (shouldn't happen with V8 fix)
+        status_msg = f"❌ **Error**: Failed to process GPS JSON: {str(e)}"
+        gr.Error(status_msg)
+        return status_msg, "Error", "Error", "Error", "Error"
+
 
 def get_gps_js():
-    """JavaScript for GPS capture using hidden textbox approach"""
+    """JavaScript for robust, manually-triggered GPS capture."""
     return """
     () => {
-      // find the textarea element inside Gradio textbox by its elem_id
-      const textarea = document.querySelector('#hidden_gps_input textarea');
-      if (!textarea) {
-        console.log("Hidden GPS textbox not found");
-        return;
-      }
-      if (!navigator.geolocation) {
-        textarea.value = JSON.stringify({error: "Geolocation not supported"});
-        textarea.dispatchEvent(new Event('input', { bubbles: true }));
-        return;
-      }
-      navigator.geolocation.getCurrentPosition(
-        function(position) {
-          const data = {
-            latitude: position.coords.latitude,
-            longitude: position.coords.longitude,
-            accuracy: position.coords.accuracy,
-            timestamp: new Date().toISOString()
-          };
-          textarea.value = JSON.stringify(data);
-          // dispatch 'input' event so Gradio notices the change
-          textarea.dispatchEvent(new Event('input', { bubbles: true }));
-        },
-        function(err) {
-          textarea.value = JSON.stringify({ error: err.message });
-          textarea.dispatchEvent(new Event('input', { bubbles: true }));
-        },
-        { enableHighAccuracy: true, timeout: 10000 }
-      );
+        // Find the specific hidden textarea within the component container 
+        const container = document.querySelector('#hidden_gps_input');
+        let textarea = null;
+
+        if (container) {
+            // Find the actual textarea element inside the Gradio wrapper
+            textarea = container.querySelector('textarea');
+        }
+
+        if (!textarea) {
+            console.error("DEBUG: Fatal: Hidden GPS textbox cannot be found.");
+            return;
+        }
+        
+        if (!navigator.geolocation) {
+            console.error("DEBUG: Geolocation not supported by browser.");
+            textarea.value = JSON.stringify({error: "Geolocation not supported", code: 0});
+            textarea.dispatchEvent(new Event('input', { bubbles: true }));
+            return;
+        }
+        
+        console.log("DEBUG: Starting Geolocation request (60s timeout, low accuracy preferred).");
+
+        navigator.geolocation.getCurrentPosition(
+            function(position) {
+                console.log("DEBUG: Geolocation SUCCESS.", position.coords);
+                const data = {
+                    latitude: position.coords.latitude,
+                    longitude: position.coords.longitude,
+                    accuracy: position.coords.accuracy,
+                    timestamp: new Date(position.timestamp).toISOString()
+                };
+                
+                textarea.value = JSON.stringify(data);
+                textarea.dispatchEvent(new Event('input', { bubbles: true }));
+            },
+            function(err) {
+                // Pass the error code back to Python
+                console.error(`DEBUG: Geolocation FAILURE. Code: ${err.code}, Message: ${err.message}`);
+                textarea.value = JSON.stringify({ error: err.message, code: err.code });
+                textarea.dispatchEvent(new Event('input', { bubbles: true }));
+            },
+            // Options: enableHighAccuracy: false for faster fix, maximumAge for caching, 60s timeout
+            { enableHighAccuracy: false, timeout: 60000, maximumAge: 5000 }
+        );
     }
     """
 
 def save_to_dataset(image, lat, lon, accuracy_m, device_ts):
-    """
-    Save image and metadata to Hugging Face dataset
-    
-    Args:
-        image: PIL Image object
-        lat: latitude as string
-        lon: longitude as string  
-        accuracy_m: accuracy in meters as string
-        device_ts: device timestamp as string
-        
-    Returns:
-        tuple: (status_markdown, preview_json)
-    """
+    """Save image and metadata to Hugging Face dataset"""
     try:
-        # Validate inputs
         if image is None:
             return "❌ **Error**: No image captured. Please take a photo first.", ""
-        
-        # 🔒 Ensure PIL.Image
-        try:
-            from PIL import Image as _PILImage
-            import numpy as _np
-            if isinstance(image, _np.ndarray):
-                image = _PILImage.fromarray(image)
-        except Exception:
-            pass
-        
-        if not lat or not lon:
+        if lat == "N/A" or lon == "N/A":
             return "❌ **Error**: GPS coordinates missing. Please click 'Get GPS' first.", ""
-        
-        # Check if running in test mode
+
+        # Test Mode Check (If API is not initialized)
         if not api:
-            # Test mode - just preview the data without saving
             server_ts = datetime.now().isoformat()
             img_id = str(uuid.uuid4())
-            
             timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
             row = {
-                "id": img_id,
-                "image": f"lanternfly_{timestamp_str}_{img_id[:8]}.jpg",
-                "latitude": float(lat) if lat else None,
-                "longitude": float(lon) if lon else None,
-                "accuracy_m": float(accuracy_m) if accuracy_m else None,
-                "device_timestamp": device_ts if device_ts else None,
-                "server_timestamp_utc": server_ts,
-                "notes": ""
+                "id": img_id, "image": f"test_{timestamp_str}_{img_id[:8]}.jpg", 
+                "latitude": float(lat) if lat != 'N/A' else None, "longitude": float(lon) if lon != 'N/A' else None, 
+                "accuracy_m": accuracy_m, "device_timestamp": device_ts, 
+                "server_timestamp_utc": server_ts, "notes": ""
             }
-            
             status = f"🔍 **Test Mode**: Data validated successfully! Sample {img_id[:8]}"
             preview = json.dumps(row, indent=2)
             return status, preview
-        
-        # Build a unique ID and paths with timestamp for better visibility
+
+        # Normal Save Process
         sample_id = str(uuid.uuid4())
         timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
-        image_rel_path = f"lanternfly_{timestamp_str}_{sample_id[:8]}.jpg"
-        
-        # Save image first
-        try:
-            _save_image_to_repo(image, image_rel_path)
-        except Exception as e:
-            return f"❌ **Error**: Failed to upload image: {e}", ""
-        
-        # Server UTC timestamp
+        image_rel_path = f"{IMAGES_DIR}/lanternfly_{timestamp_str}_{sample_id[:8]}.jpg"
+
+        _save_image_to_repo(image, image_rel_path)
+
         server_ts_utc = datetime.now().isoformat() + "Z"
-        
-        # Construct metadata row
+
         row = {
-            "id": sample_id,
-            "image": image_rel_path,  # This will be visible in dataset viewer
-            "latitude": float(lat) if lat else None,
-            "longitude": float(lon) if lon else None,
-            "accuracy_m": float(accuracy_m) if accuracy_m else None,
-            "device_timestamp": device_ts if device_ts else None,
+            "id": sample_id, "image": image_rel_path,
+            "latitude": float(lat), "longitude": float(lon),
+            "accuracy_m": float(accuracy_m),
+            "device_timestamp": device_ts,
             "server_timestamp_utc": server_ts_utc,
-            "location": f"{lat}, {lon}" if lat and lon else None,  # Human-readable location
-            "notes": ""  # placeholder for future labels
+            "location": f"{lat}, {lon}",
+            "notes": ""
         }
-        
-        # Append metadata row
-        try:
-            _append_jsonl_in_repo(row)
-        except Exception as e:
-            return f"❌ **Error**: Image uploaded, but failed to append metadata: {e}", ""
-        
-        # Return success message and preview
+
+        _append_jsonl_in_repo(row)
+
         status = (
             "✅ **Success!** Saved to dataset!\n\n"
             f"- Image: `{image_rel_path}`\n"
-            f"- Lat/Lon: {row['latitude']}, {row['longitude']} (±{row['accuracy_m']} m)\n"
-            f"- Server time (UTC): {server_ts_utc}"
+            f"- Lat/Lon: {row['latitude']}, {row['longitude']} (±{row['accuracy_m']} m)"
         )
         preview = json.dumps(row, indent=2)
-        
         return status, preview
-        
+
     except Exception as e:
-        error_msg = f"❌ **Error**: {str(e)}"
+        error_msg = f"❌ **Critical Save Error**: {str(e)}"
+        gr.Error(error_msg)
         return error_msg, ""
 
-# Create Gradio interface
+# --- Gradio Interface ---
+
 with gr.Blocks(title="Lanternfly Field Capture") as app:
-    gr.Markdown("# 🦋 Lanternfly Field Capture")
-    gr.Markdown("Capture photos with GPS coordinates for field research data collection.")
+    gr.Markdown("# 🦋 Lanternfly Field Capture (Resilient GPS)")
+    gr.Markdown("Click **'📍 Get GPS'** to capture location. **You must allow location permission** in your browser.")
     
+    # Hidden input for GPS data - MUST retain this ID for the JavaScript selector to work
+    hidden_gps_input = gr.Textbox(visible=False, elem_id="hidden_gps_input")
+
     with gr.Row():
         with gr.Column(scale=1):
             # Camera input
             camera = gr.Image(
                 streaming=False,
                 height=380,
-                label="📷 Upload Photo (or use camera)",
+                label="📷 Capture or Upload Photo",
                 type="pil",
                 sources=["webcam", "upload"]
             )
             
-            # GPS data capture
-            gr.Markdown("### 📍 GPS Coordinates")
-            gr.Markdown("Click the button below to automatically capture your location and timestamp.")
+            # --- GPS Capture Section ---
+            gr.Markdown("### 📍 Location Capture")
             
             # GPS capture button
             gps_btn = gr.Button("📍 Get GPS", variant="primary")
             
-            # Hidden input for GPS data
-            hidden_gps_input = gr.Textbox(visible=False, elem_id="hidden_gps_input")
-            
-            with gr.Row():
-                lat_box = gr.Textbox(label="Latitude", interactive=True, elem_id="lat")
-                lon_box = gr.Textbox(label="Longitude", interactive=True, elem_id="lon")
-            
-            with gr.Row():
-                accuracy_box = gr.Textbox(label="Accuracy (meters)", interactive=True, elem_id="accuracy")
-                device_ts_box = gr.Textbox(label="Device Timestamp", interactive=True, elem_id="device_ts")
-            
             # Time capture button
             time_btn = gr.Button("🕐 Get Current Time", variant="secondary")
             
             # Save button
-            save_btn = gr.Button("💾 Save to Dataset", variant="secondary")
-        
+            save_btn = gr.Button("💾 Save Photo and Data to Dataset", variant="stop")
+
         with gr.Column(scale=1):
             # Status display
-            status = gr.Markdown("🔄 **Ready to capture data...** Click 'Get GPS' to start or upload a photo.")
+            status = gr.Markdown("🔄 **Ready to capture data...**")
+            
+            # Location Data Fields
+            gr.Markdown("### Captured Data")
+            with gr.Row():
+                lat_box = gr.Textbox(label="Latitude", interactive=True, value="N/A")
+                lon_box = gr.Textbox(label="Longitude", interactive=True, value="N/A")
+            with gr.Row():
+                accuracy_box = gr.Textbox(label="Accuracy (meters)", interactive=True, value="N/A")
+                device_ts_box = gr.Textbox(label="Device Timestamp", interactive=True, value="N/A")
             
             # Preview JSON
-            preview = gr.JSON(label="Preview JSON", visible=True)
-    
-    # Event handlers
+            preview = gr.JSON(label="Preview Data Payload", visible=True)
+
+    # --- Event Handlers ---
+
+    # 1. GPS Button Click triggers JavaScript injection to run Geolocation API
     gps_btn.click(
         fn=None,
         inputs=[],
         outputs=[],
         js=get_gps_js()
     )
-    
-    # When the hidden GPS input changes, populate the visible fields
+
+    # 2. Hidden GPS input change triggers Python backend processing (safe from empty string crash)
     hidden_gps_input.change(
         fn=handle_gps_location,
         inputs=[hidden_gps_input],
         outputs=[status, lat_box, lon_box, accuracy_box, device_ts_box]
     )
-    
+
+    # 3. Time Button Click
     time_btn.click(
         fn=handle_time_capture,
         inputs=[],
         outputs=[status, device_ts_box]
     )
-    
+
+    # 4. Save button click
     save_btn.click(
         fn=save_to_dataset,
         inputs=[camera, lat_box, lon_box, accuracy_box, device_ts_box],
@@ -337,4 +336,5 @@ with gr.Blocks(title="Lanternfly Field Capture") as app:
 
 # Launch the app
 if __name__ == "__main__":
-    app.launch()
+    # In Colab, share=True is mandatory for HTTPS
+    app.launch(share=True)