Update app.py

app.py

@@ -11,20 +11,20 @@ warnings.filterwarnings("ignore")
 # Historical Basemap Configuration
 HISTORICAL_BASEMAPS = {
     "1700s": {
-        "url": "https://maps.georeferencer.com/georeferences/89B0E33D-9D3B-4B6D-8F7A-9F9A3B3E3C3D/{z}/{x}/{y}.png",
+        "url": "https://map1.davidrumsey.com/tiles/rumsey/SDSC1790/{z}/{x}/{y}.png",
         "attr": "Rumsey 1794",
         "year_range": (1700, 1800),
         "default_zoom": 2
     },
     "1800s": {
-        "url": "https://maps.georeferencer.com/georeferences/7A1B0C33-D4E5-4F6A-8B7C-9D8E0F1A2B3C/{z}/{x}/{y}.png",
+        "url": "https://map1.davidrumsey.com/tiles/rumsey/SDSC1860/{z}/{x}/{y}.png",
         "attr": "Colton 1865", 
         "year_range": (1801, 1900),
         "default_zoom": 3
     },
     "Early 1900s": {
-        "url": "https://maps.georeferencer.com/georeferences/5D4E3F2A-1B0C-9D8E-7F6A-5B4C3D2E1F0A/{z}/{x}/{y}.png",
-        "attr": "Rand McNally 1911",
+        "url": "https://stamen-tiles.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png",
+        "attr": "Stamen 1915",
         "year_range": (1901, 1920),
         "default_zoom": 4
     }
@@ -32,158 +32,153 @@ HISTORICAL_BASEMAPS = {
 
 class HistoricalGeocoder:
     def __init__(self):
-        self.geolocator = Nominatim(user_agent="historical_mapper_v3")
+        self.geolocator = Nominatim(user_agent="historical_mapper_v4")
         self.cache = {}
     
-    def get_historical_coords(self, location: str, year: int):
-        """Get coordinates adjusted for historical borders"""
+    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]
         
         try:
-            # First try modern coordinates as fallback
-            modern = self.geolocator.geocode(location, timeout=10)
-            if not modern:
+            result = self.geolocator.geocode(location, timeout=10)
+            if not result:
                 return None
             
-            # Adjust for historical border changes (simplified example)
-            lat, lon = modern.latitude, modern.longitude
+            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
             
-            # Europe border adjustments
-            if year < 1918 and 10 < lon < 30 and 40 < lat < 60:
-                lon += 0.5  # Austro-Hungarian Empire adjustment
-                
-            # Colonial adjustments
-            if year < 1947 and 65 < lon < 100 and 5 < lat < 40:
-                lat -= 0.3  # British India adjustment
-                
             self.cache[cache_key] = (lat, lon)
             return (lat, lon)
             
         except Exception as e:
-            print(f"Historical geocoding failed: {str(e)}")
+            print(f"Geocoding failed: {str(e)}")
             return None
 
-def get_historical_basemap(year: int):
-    """Select the most accurate historical map for the given year"""
-    for name, config in HISTORICAL_BASEMAPS.items():
-        if config["year_range"][0] <= year <= config["year_range"][1]:
-            return folium.TileLayer(
-                tiles=config["url"],
-                attr=config["attr"],
-                name=f"{name} ({config['year_range'][0]}-{config['year_range'][1]})",
-                zoom_start=config["default_zoom"]
-            )
-    # Default to earliest available
-    return list(HISTORICAL_BASEMAPS.values())[0]
-
-def create_authentic_historical_map(df, location_col, year):
+def create_historical_map(df, location_col, year):
     geocoder = HistoricalGeocoder()
-    basemap = get_historical_basemap(year)
     
-    # Initialize map with period-appropriate settings
+    # 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"]
+    )
+    
+    # Create map
     m = folium.Map(
-        location=[40, 20],
-        zoom_start=basemap.zoom_start,
-        control_scale=True,
-        crs="EPSG3857"
+        location=[40, 0],
+        zoom_start=basemap["default_zoom"],
+        tiles=basemap["url"],
+        attr=basemap["attr"],
+        control_scale=True
     )
-    basemap.add_to(m)
     
-    # Add all available historical layers
+    # Add all basemaps as layers
     for name, config in HISTORICAL_BASEMAPS.items():
-        if config["url"] != basemap.tiles:
+        if config["url"] != basemap["url"]:
             folium.TileLayer(
                 tiles=config["url"],
                 attr=config["attr"],
-                name=name,
+                name=f"{name} ({config['year_range'][0]}-{config['year_range'][1]})",
                 overlay=False
             ).add_to(m)
     
-    # Add historical markers
+    # Add markers
     coords = []
-    for idx, row in df.iterrows():
-        location = str(row[location_col])
-        if not location or pd.isna(location):
-            continue
-            
-        point = geocoder.get_historical_coords(location, year)
+    for loc in df[location_col].dropna().unique():
+        point = geocoder.get_coords(str(loc), year)
         if point:
             folium.Marker(
                 location=point,
-                popup=f"""<b>{location}</b><br>
-                       <i>As of {year}</i><br>
-                       Modern coordinates: {point[0]:.4f}, {point[1]:.4f}""",
+                popup=f"<b>{loc}</b><br><i>As of {year}</i>",
                 icon=folium.Icon(
-                    color="red" if year < 1900 else "blue",
-                    icon="bookmark" if year < 1900 else "info-sign",
+                    color="red" if year < 1850 else "blue",
+                    icon="history" if year < 1850 else "info-sign",
                     prefix="fa"
                 )
             ).add_to(m)
             coords.append(point)
     
-    # Add historical boundaries layer
-    if year < 1914:
-        folium.GeoJson(
-            "https://raw.githubusercontent.com/historical-boundaries/geojson/main/pre-ww1.json",
-            name="1913 Borders",
-            style_function=lambda x: {"color": "#ff7800", "weight": 2}
-        ).add_to(m)
-    
+    # Add layer control and fit bounds
     folium.LayerControl().add_to(m)
-    
     if coords:
         m.fit_bounds(coords)
     
     return m._repr_html_()
 
+def process_file(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"
+        
+        # Create 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
+        
+        return (
+            f"<div style='width:100%; height:70vh'>{map_html}</div>",
+            f"Map Year: {year}\nLocations: {len(df)}",
+            processed_path
+        )
+    
+    except Exception as e:
+        return None, f"Error: {str(e)}", None
+
 # Gradio Interface
-with gr.Blocks(title="True Historical Mapper", theme=gr.themes.Soft()) as app:
-    gr.Markdown("""# True Historical Map Generator
-    <p style="color:gray">Locations are adjusted for historical borders</p>
-    """)
+with gr.Blocks(title="Historical Map Explorer", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# Historical Location Mapper")
     
     with gr.Row():
         with gr.Column():
             file_input = gr.File(
                 label="1. Upload Excel File",
-                file_types=[".xlsx"],
+                file_types=[".xlsx", ".xls"],
                 type="filepath"
             )
             location_col = gr.Textbox(
                 label="2. Location Column Name",
-                value="city",
+                value="location",
                 interactive=True
             )
             year = gr.Slider(
-                label="3. Select Year",
+                label="3. Select Map Year",
                 minimum=1700,
-                maximum=datetime.now().year,
+                maximum=1920,
                 value=1850,
-                step=1,
-                interactive=True
+                step=1
             )
-            btn = gr.Button("Generate Historical Map", variant="primary")
+            btn = gr.Button("Generate Map", variant="primary")
             
         with gr.Column():
             map_display = gr.HTML(
                 label="Historical Map",
                 value="<div style='text-align:center;padding:2em;color:gray'>"
-                      "Map will render here</div>"
+                      "Map will appear here</div>"
             )
-            gr.Markdown("### Map Controls")
-            with gr.Row():
-                gr.Button("Zoom In", size="sm").click(
-                    None, _js="() => { map.zoomIn(); }")
-                gr.Button("Zoom Out", size="sm").click(
-                    None, _js="() => { map.zoomOut(); }")
-            stats = gr.Textbox(label="Map Details")
+            stats = gr.Textbox(label="Map Info")
+            download = gr.File(label="Download Processed Data", visible=True)
     
     btn.click(
-        create_authentic_historical_map,
+        process_file,
         inputs=[file_input, location_col, year],
-        outputs=[map_display]
+        outputs=[map_display, stats, download]
     )
 
 if __name__ == "__main__":