Update app.py

app.py

@@ -8,133 +8,126 @@ from datetime import datetime
 
 warnings.filterwarnings("ignore")
 
-# Historical Basemap Configuration
-HISTORICAL_BASEMAPS = {
-    "1700s": {
-        "url": "https://map1.davidrumsey.com/tiles/rumsey/SDSC1790/{z}/{x}/{y}.png",
-        "attr": "Rumsey 1794",
-        "year_range": (1700, 1800),
-        "default_zoom": 2
-    },
-    "1800s": {
+# Reliable Historical Tile Providers with fallbacks
+HISTORICAL_TILES = {
+    "Colton 1865": {
         "url": "https://map1.davidrumsey.com/tiles/rumsey/SDSC1860/{z}/{x}/{y}.png",
-        "attr": "Colton 1865", 
-        "year_range": (1801, 1900),
-        "default_zoom": 3
+        "attr": "David Rumsey Map Collection",
+        "fallback": "https://stamen-tiles.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png",
+        "years": (1800, 1900)
     },
-    "Early 1900s": {
+    "Stamen 1915": {
         "url": "https://stamen-tiles.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png",
-        "attr": "Stamen 1915",
-        "year_range": (1901, 1920),
-        "default_zoom": 4
+        "attr": "Stamen Maps",
+        "fallback": "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+        "years": (1901, 1920)
+    },
+    "OpenStreetMap": {
+        "url": "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+        "attr": "OpenStreetMap",
+        "fallback": None,
+        "years": (1700, 2023)
     }
 }
 
-class HistoricalGeocoder:
+class SafeGeocoder:
     def __init__(self):
-        self.geolocator = Nominatim(user_agent="historical_mapper_v4")
-        self.cache = {}
+        self.geolocator = Nominatim(user_agent="historical_mapper_v6", timeout=10)
     
-    def get_coords(self, location: str, year: int):
-        """Get coordinates with simple historical adjustments"""
-        cache_key = f"{location}_{year}"
-        if cache_key in self.cache:
-            return self.cache[cache_key]
-        
+    def get_coords(self, location: str):
         try:
-            result = self.geolocator.geocode(location, timeout=10)
-            if not result:
-                return None
-            
-            lat, lon = result.latitude, result.longitude
-            
-            # Simple historical adjustments (example only)
-            if year < 1800:
-                # Older maps often had shifted coordinates
-                lon += 0.2
-                lat += 0.1
-            elif year < 1900:
-                lon += 0.1
-            
-            self.cache[cache_key] = (lat, lon)
-            return (lat, lon)
-            
-        except Exception as e:
-            print(f"Geocoding failed: {str(e)}")
+            result = self.geolocator.geocode(location)
+            return (result.latitude, result.longitude) if result else None
+        except:
             return None
 
-def create_historical_map(df, location_col, year):
-    geocoder = HistoricalGeocoder()
-    
-    # Select appropriate basemap
-    basemap = next(
-        (bm for bm in HISTORICAL_BASEMAPS.values() 
-         if bm["year_range"][0] <= year <= bm["year_range"][1]),
-        HISTORICAL_BASEMAPS["1800s"]
+def create_reliable_map(df, location_col, year):
+    # Select appropriate tile configuration
+    tile_config = next(
+        (t for t in HISTORICAL_TILES.values() 
+         if t["years"][0] <= year <= t["years"][1]),
+        HISTORICAL_TILES["OpenStreetMap"]
     )
     
-    # Create map
-    m = folium.Map(
-        location=[40, 0],
-        zoom_start=basemap["default_zoom"],
-        tiles=basemap["url"],
-        attr=basemap["attr"],
-        control_scale=True
-    )
+    # Initialize map with fallback support
+    m = folium.Map(location=[51.5, -0.1], zoom_start=5, control_scale=True)
     
-    # Add all basemaps as layers
-    for name, config in HISTORICAL_BASEMAPS.items():
-        if config["url"] != basemap["url"]:
-            folium.TileLayer(
-                tiles=config["url"],
-                attr=config["attr"],
-                name=f"{name} ({config['year_range'][0]}-{config['year_range'][1]})",
-                overlay=False
-            ).add_to(m)
+    # Try primary tile layer
+    primary_layer = folium.TileLayer(
+        tiles=tile_config["url"],
+        attr=tile_config["attr"],
+        name=f"Primary ({year})",
+        control=False
+    ).add_to(m)
+    
+    # Add fallback layer
+    if tile_config["fallback"]:
+        folium.TileLayer(
+            tiles=tile_config["fallback"],
+            attr=f"{tile_config['attr']} (Fallback)",
+            name="Fallback Tiles",
+            control=False
+        ).add_to(m)
+    
+    # Add OpenStreetMap as backup
+    osm_layer = folium.TileLayer(
+        tiles=HISTORICAL_TILES["OpenStreetMap"]["url"],
+        attr=HISTORICAL_TILES["OpenStreetMap"]["attr"],
+        name="OpenStreetMap",
+        control=True
+    ).add_to(m)
     
     # Add markers
+    geocoder = SafeGeocoder()
     coords = []
     for loc in df[location_col].dropna().unique():
-        point = geocoder.get_coords(str(loc), year)
+        point = geocoder.get_coords(str(loc))
         if point:
             folium.Marker(
                 location=point,
-                popup=f"<b>{loc}</b><br><i>As of {year}</i>",
-                icon=folium.Icon(
-                    color="red" if year < 1850 else "blue",
-                    icon="history" if year < 1850 else "info-sign",
-                    prefix="fa"
-                )
+                popup=f"<b>{loc}</b><br><i>Historical View ({year})</i>",
+                icon=folium.Icon(color="blue")
             ).add_to(m)
             coords.append(point)
     
-    # Add layer control and fit bounds
+    # Layer control and bounds
     folium.LayerControl().add_to(m)
     if coords:
         m.fit_bounds(coords)
     
+    # Force tile reload as workaround for gray tiles
+    m.get_root().html.add_child(folium.Element("""
+    <script>
+    setTimeout(function() {
+        const tiles = document.querySelectorAll('.leaflet-tile-loaded');
+        tiles.forEach(tile => {
+            const src = tile.src;
+            tile.src = '';
+            tile.src = src;
+        });
+    }, 1000);
+    </script>
+    """))
+    
     return m._repr_html_()
 
-def process_file(file_obj, location_col, year):
+def process_data(file_obj, location_col, year):
     try:
-        # Read file
         df = pd.read_excel(file_obj.name)
         
-        # Validate column
         if location_col not in df.columns:
-            return None, f"Column '{location_col}' not found"
+            return None, f"Column '{location_col}' not found", None
         
-        # Create map
-        map_html = create_historical_map(df, location_col, year)
+        map_html = create_reliable_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
         
+        stats = f"Displaying {len(df)} locations from {year}"
         return (
-            f"<div style='width:100%; height:70vh'>{map_html}</div>",
-            f"Map Year: {year}\nLocations: {len(df)}",
+            f"<div style='width:100%; height:70vh; border:1px solid #ddd'>{map_html}</div>",
+            stats,
             processed_path
         )
     
@@ -142,26 +135,26 @@ def process_file(file_obj, location_col, year):
         return None, f"Error: {str(e)}", None
 
 # Gradio Interface
-with gr.Blocks(title="Historical Map Explorer", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# Historical Location Mapper")
+with gr.Blocks(title="Reliable Historical Maps", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# Historical Map Viewer")
     
     with gr.Row():
         with gr.Column():
             file_input = gr.File(
                 label="1. Upload Excel File",
-                file_types=[".xlsx", ".xls"],
+                file_types=[".xlsx"],
                 type="filepath"
             )
             location_col = gr.Textbox(
                 label="2. Location Column Name",
                 value="location",
-                interactive=True
+                placeholder="e.g., 'city' or 'address'"
             )
             year = gr.Slider(
-                label="3. Select Map Year",
+                label="3. Map Year",
                 minimum=1700,
                 maximum=1920,
-                value=1850,
+                value=1865,
                 step=1
             )
             btn = gr.Button("Generate Map", variant="primary")
@@ -169,14 +162,14 @@ with gr.Blocks(title="Historical Map Explorer", theme=gr.themes.Soft()) as app:
         with gr.Column():
             map_display = gr.HTML(
                 label="Historical Map",
-                value="<div style='text-align:center;padding:2em;color:gray'>"
-                      "Map will appear here</div>"
+                value="<div style='text-align:center;padding:2em;color:gray;border:1px solid #ddd'>"
+                      "Map will appear here after generation</div>"
             )
-            stats = gr.Textbox(label="Map Info")
-            download = gr.File(label="Download Processed Data", visible=True)
+            stats = gr.Textbox(label="Map Information")
+            download = gr.File(label="Download Processed Data")
     
     btn.click(
-        process_file,
+        process_data,
         inputs=[file_input, location_col, year],
         outputs=[map_display, stats, download]
     )