Update app.py

app.py

@@ -4,6 +4,7 @@ import requests
 import os
 import pandas as pd
 import folium
+from folium import plugins
 from geopy.geocoders import Nominatim
 from geopy.exc import GeocoderTimedOut, GeocoderServiceError
 import time
@@ -11,10 +12,6 @@ import random
 from typing import List, Tuple, Optional
 import io
 
-# NuExtract API configuration
-API_URL = "https://api-inference.huggingface.co/models/numind/NuExtract-1.5"
-headers = {"Authorization": f"Bearer {os.environ.get('HF_TOKEN', '')}"}
-
 # Geocoding Service
 class GeocodingService:
     def __init__(self, user_agent: str = None, timeout: int = 10, rate_limit: float = 1.1):
@@ -92,55 +89,86 @@ class GeocodingService:
 # Mapping Functions
 def create_location_map(df: pd.DataFrame,
                        coordinates_col: str = 'coordinates',
-                       places_col: str = 'places',
+                       places_col: str = 'place_of_distribution',  # Updated to match your column name
                        title_col: Optional[str] = None) -> folium.Map:
+    """
+    Create an interactive map with individual markers for all locations.
+
+    Args:
+        df: DataFrame containing coordinates and location names
+        coordinates_col: Name of column containing coordinates
+        places_col: Name of column containing location names
+        title_col: Optional column name for additional marker information
+
+    Returns:
+        folium.Map object with all locations marked individually
+    """
     # Initialize the map
     m = folium.Map(location=[0, 0], zoom_start=2)
+    
+    # Add fullscreen option
+    plugins.Fullscreen().add_to(m)
+    
+    # Add search functionality 
+    plugins.Search(
+        layer=None,
+        geom_type="Point",
+        placeholder="Search for a place...",
+        collapsed=True,
+        search_label="name"
+    ).add_to(m)
+
+    # Keep track of all valid coordinates for setting bounds
     all_coords = []
 
     # Process each row in the DataFrame
     for idx, row in df.iterrows():
         coordinates = row[coordinates_col]
-        places_text = row[places_col] if pd.notna(row[places_col]) else ""
+        
+        # Handle places column - try different methods to parse places
+        try:
+            if pd.notna(row[places_col]):
+                if isinstance(row[places_col], str) and ',' in row[places_col]:
+                    places = [p.strip() for p in row[places_col].split(',')]
+                else:
+                    places = [str(row[places_col])]
+            else:
+                places = []
+        except Exception as e:
+            print(f"Error processing places for row {idx}: {e}")
+            places = []
+            
+        # Get optional title information
         title = row[title_col] if title_col and pd.notna(row[title_col]) else None
 
         # Skip if no coordinates
         if not coordinates:
             continue
 
-        # Parse places into a list
-        try:
-            places = [p.strip() for p in places_text.split(',') if p.strip()]
-        except:
-            # Fall back to treating it as a single place if splitting fails
-            places = [places_text] if places_text else []
-            
         # Ensure places and coordinates have compatible lengths
-        # If places is shorter, add placeholder names
         while len(places) < len(coordinates):
             places.append(f"Location {len(places) + 1}")
-            
-        # Add markers for each coordinate
+
+        # Add individual markers for each location
         for i, coord in enumerate(coordinates):
             if coord is not None:  # Skip None coordinates
                 lat, lon = coord
                 
                 # Get place name safely
-                if i < len(places):
-                    place_name = places[i]
-                else:
-                    place_name = f"Location {i + 1}"
+                place_name = places[i] if i < len(places) else f"Location {i + 1}"
 
                 # Create popup content
                 popup_content = f"<b>{place_name}</b>"
                 if title:
                     popup_content += f"<br>{title}"
 
-                # Add marker to the map
+                # Add marker directly to the map (not in a cluster)
                 folium.Marker(
                     location=[lat, lon],
                     popup=folium.Popup(popup_content, max_width=300),
                     tooltip=place_name,
+                    # Uncomment for different icons
+                    # icon=folium.Icon(color='red', icon='info-sign')
                 ).add_to(m)
 
                 all_coords.append([lat, lon])
@@ -148,6 +176,10 @@ def create_location_map(df: pd.DataFrame,
     # If we have coordinates, fit the map bounds to include all points
     if all_coords:
         m.fit_bounds(all_coords)
+        
+    # Add layer control and measure tool
+    folium.LayerControl().add_to(m)
+    plugins.MeasureControl(position='topright', primary_length_unit='kilometers').add_to(m)
 
     return m
 
@@ -177,7 +209,7 @@ def process_excel(file, places_column):
             return None, f"Column '{places_column}' not found in the Excel file. Available columns: {', '.join(df.columns)}", None
         
         # Initialize the geocoding service
-        geocoder = GeocodingService(user_agent="gradio_map_visualization_app")
+        geocoder = GeocodingService(user_agent="map_visualization_app")
         
         # Process locations and add coordinates
         print(f"Processing locations from column: {places_column}")
@@ -213,140 +245,84 @@ def process_excel(file, places_column):
         print(f"Error processing file: {e}\n{trace}")
         return None, f"Error processing file: {str(e)}", None
 
-# NuExtract Functions
-def extract_info(template, text):
-    try:
-        # Format prompt according to NuExtract-1.5 requirements
-        prompt = f"<|input|>\n### Template:\n{template}\n### Text:\n{text}\n\n<|output|>"
-        
-        # Call API
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "max_new_tokens": 1000,
-                "do_sample": False
-            }
-        }
-        
-        response = requests.post(API_URL, headers=headers, json=payload)
-        
-        # If the model is loading, inform the user
-        if response.status_code == 503:
-            response_json = response.json()
-            if "error" in response_json and "loading" in response_json["error"]:
-                estimated_time = response_json.get("estimated_time", "unknown")
-                return f"⏳ Model is loading (ETA: {int(float(estimated_time)) if isinstance(estimated_time, (int, float, str)) else 'unknown'} seconds)", "Please try again in a few minutes"
-        
-        if response.status_code != 200:
-            return f"❌ API Error: {response.status_code}", response.text
+# Create the Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Location Mapping Tool")
+    
+    with gr.Row():
+        with gr.Column():
+            excel_file = gr.File(label="Upload Excel File")
+            places_column = gr.Textbox(label="Places Column Name", value="place_of_distribution")
+            process_btn = gr.Button("Process and Map", variant="primary")
         
-        # Process result
-        result = response.json()
+        with gr.Column():
+            map_output = gr.HTML(label="Map Visualization")
+            stats_output = gr.Textbox(label="Statistics", lines=3)
+            processed_file = gr.File(label="Processed Data", visible=True, interactive=False)
+    
+    def process_and_map(file, column):
+        if file is None:
+            return None, "Please upload an Excel file", None
         
-        # Handle different response formats
         try:
-            if isinstance(result, list):
-                if len(result) > 0:
-                    result_text = result[0].get("generated_text", "")
-                else:
-                    return "❌ Empty result list", "{}"
-            else:
-                result_text = str(result)
+            map_path, stats, processed_path = process_excel(file, column)
             
-            # Split at output marker if present
-            if "<|output|>" in result_text:
-                parts = result_text.split("<|output|>")
-                if len(parts) > 1:
-                    json_text = parts[1].strip()
-                else:
-                    json_text = result_text
-            else:
-                json_text = result_text
-            
-            # Try to parse as JSON
-            try:
-                extracted = json.loads(json_text)
-                formatted = json.dumps(extracted, indent=2)
-            except json.JSONDecodeError:
-                return "❌ JSON parsing error", json_text
+            if map_path and processed_path:
+                with open(map_path, "r") as f:
+                    map_html = f.read()
                 
-            return "✅ Success", formatted
-        except Exception as inner_e:
-            return f"❌ Error processing result: {str(inner_e)}", "{}"
-    except Exception as e:
-        return f"❌ Error: {str(e)}", "{}"
+                return map_html, stats, processed_path
+            else:
+                return None, stats, None
+        except Exception as e:
+            import traceback
+            trace = traceback.format_exc()
+            print(f"Error in process_and_map: {e}\n{trace}")
+            return None, f"Error: {str(e)}", None
+    
+    process_btn.click(
+        fn=process_and_map,
+        inputs=[excel_file, places_column],
+        outputs=[map_output, stats_output, processed_file]
+    )
 
-# Create the Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Historical Data Analysis Tools")
+# For direct use in Jupyter or standalone Python scripts
+def create_map_from_excel(file_path, places_column='place_of_distribution'):
+    """
+    Function to create a map directly from an Excel file without using Gradio.
+    Useful for Jupyter notebooks or standalone scripts.
     
-    with gr.Tabs():
-        with gr.TabItem("Text Extraction"):
-            gr.Markdown("## NuExtract-1.5 Structured Data Extraction")
-            
-            with gr.Row():
-                with gr.Column():
-                    template = gr.Textbox(
-                        label="JSON Template", 
-                        value='{"earthquake location": "", "dateline location": ""}',
-                        lines=5
-                    )
-                    text = gr.Textbox(
-                        label="Text to Extract From",
-                        value="Neues Erdbeben in Japan. Aus Tokio wird berichtet, daß in Yokohama bei einem Erdbeben sechs Personen getötet und 22 verwundet, in Tokio vier getötet und 22 verwundet wurden. In Yokohama seien 6VV Häuser zerstört worden. Die telephonische und telegraphische Verbindung zwischen Tokio und Osaka ist unterbrochen worden. Der Trambahnverkehr in Tokio liegt still. Auch der Eisenbahnverkehr zwischen Tokio und Yokohama ist unterbrochen. In Sngamo, einer Vorstadt von Tokio sind Brände ausgebrochen. Ein Eisenbahnzug stürzte in den Vajugawafluß zwischen Gotemba und Tokio. Sechs Züge wurden umgeworfen. Mit dem letzten japanischen Erdbeben sind seit eineinhalb Jahrtausenden bis heute in Japan 229 größere Erdbeben zu verzeichnen gewesen.",
-                        lines=8
-                    )
-                    extract_btn = gr.Button("Extract Information", variant="primary")
-                
-                with gr.Column():
-                    status = gr.Textbox(label="Status")
-                    output = gr.Textbox(label="Output", lines=10)
-            
-            extract_btn.click(
-                fn=extract_info,
-                inputs=[template, text],
-                outputs=[status, output]
-            )
+    Args:
+        file_path: Path to the Excel file
+        places_column: Name of the column containing location names
         
-        with gr.TabItem("Geocoding & Mapping"):
-            gr.Markdown("## Location Mapping Tool")
-            
-            with gr.Row():
-                with gr.Column():
-                    excel_file = gr.File(label="Upload Excel File")
-                    places_column = gr.Textbox(label="Places Column Name", value="places")
-                    process_btn = gr.Button("Process and Map", variant="primary")
-                
-                with gr.Column():
-                    map_output = gr.HTML(label="Map Visualization")
-                    stats_output = gr.Textbox(label="Statistics", lines=3)
-                    processed_file = gr.File(label="Processed Data", visible=True, interactive=False)
-            
-            def process_and_map(file, column):
-                if file is None:
-                    return None, "Please upload an Excel file", None
-                
-                try:
-                    map_path, stats, processed_path = process_excel(file, column)
-                    
-                    if map_path and processed_path:
-                        with open(map_path, "r") as f:
-                            map_html = f.read()
-                        
-                        return map_html, stats, processed_path
-                    else:
-                        return None, stats, None
-                except Exception as e:
-                    import traceback
-                    trace = traceback.format_exc()
-                    print(f"Error in process_and_map: {e}\n{trace}")
-                    return None, f"Error: {str(e)}", None
-            
-            process_btn.click(
-                fn=process_and_map,
-                inputs=[excel_file, places_column],
-                outputs=[map_output, stats_output, processed_file]
-            )
+    Returns:
+        folium.Map object
+    """
+    try:
+        # Read Excel file
+        df = pd.read_excel(file_path)
+        
+        # Check if column exists
+        if places_column not in df.columns:
+            print(f"Column '{places_column}' not found. Available columns: {', '.join(df.columns)}")
+            return None
+        
+        # Initialize geocoder
+        geocoder = GeocodingService(user_agent="jupyter_map_app")
+        
+        # Process locations
+        df['coordinates'] = df[places_column].apply(geocoder.process_locations)
+        
+        # Create map
+        map_obj = create_location_map(df, coordinates_col='coordinates', places_col=places_column)
+        
+        return map_obj
+    
+    except Exception as e:
+        print(f"Error creating map: {e}")
+        return None
 
+# For use in Hugging Face Spaces
 if __name__ == "__main__":
     demo.launch()