Update app.py

app.py

@@ -1,36 +1,47 @@
 import gradio as gr
 import pandas as pd
 import folium
-import requests
-import os
-import tempfile
-import time
-import json
 from geopy.geocoders import Nominatim
 from geopy.extra.rate_limiter import RateLimiter
+import tempfile
 from typing import Optional, Tuple
 import warnings
 
 # Suppress warnings
 warnings.filterwarnings("ignore")
 
-# --- Configuration ---
-API_URL = "https://api-inference.huggingface.co/models/numind/NuExtract-1.5"
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
+# Historical Tile Providers
+HISTORICAL_TILES = {
+    "David Rumsey (1790)": {
+        "url": "https://map1.davidrumsey.com/tiles/rumsey/SDSC1790/{z}/{x}/{y}.png",
+        "attr": "David Rumsey Map Collection",
+        "min_year": 1700,
+        "max_year": 1800
+    },
+    "David Rumsey (1860)": {
+        "url": "https://map1.davidrumsey.com/tiles/rumsey/SDSC1860/{z}/{x}/{y}.png",
+        "attr": "David Rumsey Map Collection", 
+        "min_year": 1801,
+        "max_year": 1900
+    },
+    "Stamen (1915)": {
+        "url": "https://stamen-tiles.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png",
+        "attr": "Stamen Maps",
+        "min_year": 1901,
+        "max_year": 1920
+    },
+    "OpenHistoricalMap": {
+        "url": "https://tile.openhistoricalmap.org/{z}/{x}/{y}.png",
+        "attr": "OpenHistoricalMap",
+        "min_year": 1700,
+        "max_year": 2023
+    }
+}
 
-# --- Geocoding Service ---
 class Geocoder:
     def __init__(self):
-        self.geolocator = Nominatim(
-            user_agent="historical_data_mapper_v2",
-            timeout=10
-        )
-        self.geocode = RateLimiter(
-            self.geolocator.geocode,
-            min_delay_seconds=1,
-            max_retries=2
-        )
+        self.geolocator = Nominatim(user_agent="historical_mapper", timeout=10)
+        self.geocode = RateLimiter(self.geolocator.geocode, min_delay_seconds=1)
         self.cache = {}
     
     def get_coords(self, location: str) -> Optional[Tuple[float, float]]:
@@ -51,55 +62,85 @@ class Geocoder:
         self.cache[location] = None
         return None
 
-# --- Map Generation ---
-def create_map(df: pd.DataFrame, location_col: str) -> str:
+def get_tile_layer(year: int):
+    """Select the most appropriate tile layer for the given year"""
+    for name, config in HISTORICAL_TILES.items():
+        if config["min_year"] <= year <= config["max_year"]:
+            return folium.TileLayer(
+                tiles=config["url"],
+                attr=config["attr"],
+                name=name,
+                overlay=False
+            )
+    return folium.TileLayer("OpenStreetMap")
+
+def create_historical_map(df: pd.DataFrame, location_col: str, year: int = 1900) -> str:
     geocoder = Geocoder()
-    m = folium.Map(tiles="CartoDB positron", control_scale=True)
-    coords_list = []
     
+    # Create map with historical base layer
+    base_layer = get_tile_layer(year)
+    m = folium.Map(location=[40, -10], zoom_start=2, control_scale=True)
+    base_layer.add_to(m)
+    
+    # Add all other historical layers as options
+    for name, config in HISTORICAL_TILES.items():
+        if config["url"] != base_layer.tiles:
+            folium.TileLayer(
+                tiles=config["url"],
+                attr=config["attr"],
+                name=f"{name} ({config['min_year']}-{config['max_year']})",
+                overlay=False
+            ).add_to(m)
+    
+    # Add markers with historical styling
+    coords_list = []
     for loc in df[location_col].dropna().unique():
         coords = geocoder.get_coords(str(loc))
         if coords:
             folium.Marker(
                 location=coords,
-                popup=loc,
-                icon=folium.Icon(color="blue")
+                popup=f"<b>{loc}</b><br>Year: {year}",
+                icon=folium.Icon(
+                    color="red",
+                    icon="info-sign",
+                    prefix="fa"
+                )
             ).add_to(m)
             coords_list.append(coords)
     
+    # Add layer control and fit bounds
+    folium.LayerControl().add_to(m)
     if coords_list:
         m.fit_bounds(coords_list)
-    else:
-        m.location = [20, 0]
-        return "<div style='color:red;text-align:center'>No valid locations found</div>"
     
     return m._repr_html_()
 
-# --- File Processing ---
-def process_file(file_obj, location_col: str):
+def process_file(file_obj, location_col, year):
     try:
-        # Read file
+        # Read input file
         df = pd.read_excel(file_obj.name)
         
-        # Validate column
+        # Validate column exists
         if location_col not in df.columns:
             return None, f"Column '{location_col}' not found", None
         
-        # Generate map
-        map_html = create_map(df, location_col)
+        # Create historical map
+        map_html = create_historical_map(df, location_col, year)
         
         # Save processed data
         with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
             df.to_excel(tmp.name, index=False)
             processed_path = tmp.name
         
+        # Generate stats
         stats = (
-            f"Total rows: {len(df)}\n"
-            f"Unique locations: {df[location_col].nunique()}"
+            f"Total locations: {len(df)}\n"
+            f"Unique places: {df[location_col].nunique()}\n"
+            f"Map year: {year}"
         )
         
         return (
-            f"<div style='width:100%; height:65vh'>{map_html}</div>",
+            f"<div style='width:100%; height:70vh'>{map_html}</div>",
             stats,
             processed_path
         )
@@ -107,92 +148,45 @@ def process_file(file_obj, location_col: str):
     except Exception as e:
         return None, f"Error: {str(e)}", None
 
-# --- NuExtract API ---
-def extract_info(template: str, text: str):
-    try:
-        prompt = f"<|input|>\n### Template:\n{template}\n### Text:\n{text}\n\n<|output|>"
-        response = requests.post(
-            API_URL,
-            headers=HEADERS,
-            json={"inputs": prompt, "parameters": {"max_new_tokens": 1000}}
-        )
-        
-        if response.status_code == 503:
-            return "⏳ Model is loading...", "Try again later"
-        
-        result = response.json()
-        if isinstance(result, list):
-            output = result[0].get("generated_text", "").split("<|output|>")[-1].strip()
-            try:
-                json.loads(output)  # Validate JSON
-                return "✅ Success", output
-            except:
-                return "⚠️ Partial Output", output
-        return "❌ Unexpected Response", str(result)
-    
-    except Exception as e:
-        return f"❌ Error: {str(e)}", ""
-
-# --- Gradio Interface ---
-with gr.Blocks(title="Historical Data Tools", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# Historical Data Analysis Tools")
+# Gradio Interface
+with gr.Blocks(title="Historical Map Explorer", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# Historical Location Mapper")
     
-    with gr.Tabs():
-        with gr.Tab("Text Extraction"):
-            gr.Markdown("## NuExtract-1.5 Structured Data Extraction")
-            with gr.Row():
-                with gr.Column():
-                    template = gr.Textbox(
-                        label="JSON Template",
-                        value='{"location": "", "date": ""}',
-                        lines=5
-                    )
-                    input_text = gr.Textbox(
-                        label="Input Text",
-                        value="The earthquake occurred in San Francisco on April 18, 1906.",
-                        lines=5
-                    )
-                    extract_btn = gr.Button("Extract", variant="primary")
-                
-                with gr.Column():
-                    status = gr.Textbox(label="Status")
-                    output = gr.Textbox(label="Extracted Data", lines=10)
-            
-            extract_btn.click(
-                extract_info,
-                inputs=[template, input_text],
-                outputs=[status, output]
+    with gr.Row():
+        with gr.Column():
+            file_input = gr.File(
+                label="Upload Excel File",
+                file_types=[".xlsx", ".xls"],
+                type="filepath"
+            )
+            location_col = gr.Textbox(
+                label="Location Column Name",
+                value="locations",
+                placeholder="Enter exact column name with locations"
             )
+            year = gr.Slider(
+                minimum=1700,
+                maximum=2023,
+                value=1900,
+                step=1,
+                label="Map Year"
+            )
+            map_btn = gr.Button("Generate Historical Map", variant="primary")
         
-        with gr.Tab("Location Mapping"):
-            gr.Markdown("## Geocode and Map Locations")
-            with gr.Row():
-                with gr.Column():
-                    file_input = gr.File(
-                        label="Upload Excel File",
-                        file_types=[".xlsx", ".xls"]
-                    )
-                    location_col = gr.Textbox(
-                        label="Location Column Name",
-                        value="locations",
-                        placeholder="Enter exact column name"
-                    )
-                    map_btn = gr.Button("Generate Map", variant="primary")
-                
-                with gr.Column():
-                    map_display = gr.HTML(
-                        label="Interactive Map",
-                        value="<div style='text-align:center;padding:20px;'>"
-                              "Map will appear here</div>"
-                    )
-                    stats = gr.Textbox(label="Statistics")
-                    download = gr.File(label="Processed Data", visible=False)
-            
-            map_btn.click(
-                process_file,
-                inputs=[file_input, location_col],
-                outputs=[map_display, stats, download]
+        with gr.Column():
+            map_display = gr.HTML(
+                label="Historical Map",
+                value="<div style='text-align:center;padding:20px;'>"
+                      "Map will appear here after processing</div>"
             )
+            stats_output = gr.Textbox(label="Statistics")
+            download_output = gr.File(label="Download Processed Data")
+
+    map_btn.click(
+        process_file,
+        inputs=[file_input, location_col, year],
+        outputs=[map_display, stats_output, download_output]
+    )
 
 if __name__ == "__main__":
     app.launch()