Update app.py

app.py

@@ -347,120 +347,124 @@ def extract_info(template, text):
         print(f"Error in extract_info: {e}\n{trace}")
         return f"❌ Fehler: {str(e)}", "{}"
 @spaces.GPU
-@spaces.GPU
-def create_map(df, location_col):
-    # Start a simple log to track execution
-    with open("map_debug.log", "w") as log:
-        log.write(f"Starting map creation at {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
-    
-    m = folium.Map(
-        location=[20, 0],
-        zoom_start=2, 
-        control_scale=True
-    )
-    
-    folium.TileLayer(
-        tiles=MAP_TILES["GreenMap"]["url"],
-        attr=MAP_TILES["GreenMap"]["attr"],
-        name="GreenMap",
-        overlay=False,
-        control=False
-    ).add_to(m)
+
+# Instead of using folium directly with Gradio's HTML component,
+# try this alternative approach using Plotly for maps
+
+def create_map_plotly(df, location_col):
+    """
+    Creates an interactive map using Plotly instead of Folium
+    which should be more stable in Gradio applications
+    """
+    import plotly.graph_objects as go
+    import pandas as pd
     
-    Fullscreen().add_to(m)
-    MeasureControl(position='topright', primary_length_unit='kilometers').add_to(m)
+    # Track processing for debugging
+    print(f"Processing {len(df)} rows with location column: {location_col}")
     
+    # Initialize geocoder and tracking variables
     geocoder = SafeGeocoder()
-    coords = []
-    marker_cluster = MarkerCluster(name="Locations").add_to(m)
     processed_count = 0
+    all_lats = []
+    all_lons = []
+    hover_texts = []
     
-    with open("map_debug.log", "a") as log:
-        log.write(f"Processing {len(df)} rows from dataframe\n")
-    
+    # Process each row
     for idx, row in df.iterrows():
         if pd.isna(row[location_col]):
             continue
             
         location = str(row[location_col]).strip()
         
-        # Log the location being processed
-        with open("map_debug.log", "a") as log:
-            log.write(f"Processing location: {location}\n")
-        
+        # Build additional info for hover text
         additional_info = ""
         for col in df.columns:
             if col != location_col and not pd.isna(row[col]):
                 additional_info += f"<br><b>{col}:</b> {row[col]}"
         
+        # Split location if it contains multiple comma-separated places
         try:
             locations = [loc.strip() for loc in location.split(',') if loc.strip()]
             if not locations:
                 locations = [location]
         except Exception as e:
-            with open("map_debug.log", "a") as log:
-                log.write(f"Error splitting location '{location}': {str(e)}\n")
+            print(f"Error splitting location '{location}': {str(e)}")
             locations = [location]
-        
-        # Log the parsed locations
-        with open("map_debug.log", "a") as log:
-            log.write(f"Split into locations: {locations}\n")
             
+        # Process each individual location
         for loc in locations:
             try:
-                # Log the current location
-                with open("map_debug.log", "a") as log:
-                    log.write(f"Getting coordinates for: {loc}\n")
-                
+                # Get coordinates
                 point = geocoder.get_coords(loc)
                 
                 if point:
-                    # Log the found coordinates
-                    with open("map_debug.log", "a") as log:
-                        log.write(f"Found coordinates for {loc}: {point}\n")
-                    
-                    # Create popup HTML - this is the part that was disappearing
-                    popup_content = f"""
-                    <div style="min-width: 200px; max-width: 300px">
-                        <h4 style="font-family: 'Source Sans Pro', sans-serif; margin-bottom: 5px;">{loc}</h4>
-                        <div style="font-family: 'Source Sans Pro', sans-serif; font-size: 14px;">
-                            {additional_info}
-                        </div>
-                    </div>
-                    """
+                    lat, lon = point
+                    all_lats.append(lat)
+                    all_lons.append(lon)
                     
-                    # Log popup creation
-                    with open("map_debug.log", "a") as log:
-                        log.write(f"Created popup for {loc}\n")
+                    # Create hover text with location name and info
+                    hover_text = f"<b>{loc}</b>{additional_info}"
+                    hover_texts.append(hover_text)
                     
-                    # Add marker with popup
-                    folium.Marker(
-                        location=point,
-                        popup=folium.Popup(popup_content, max_width=300),
-                        tooltip=loc,
-                        icon=folium.Icon(color="blue", icon="info-sign")
-                    ).add_to(marker_cluster)
-                    
-                    # Log marker addition
-                    with open("map_debug.log", "a") as log:
-                        log.write(f"Added marker for {loc}\n")
-                    
-                    coords.append(point)
                     processed_count += 1
-                else:
-                    # Log geocoding failure
-                    with open("map_debug.log", "a") as log:
-                        log.write(f"No coordinates found for {loc}\n")
             except Exception as e:
-                # Log any errors in processing this location
-                with open("map_debug.log", "a") as log:
-                    log.write(f"Error processing {loc}: {str(e)}\n")
-                    log.write(traceback.format_exc() + "\n")
-    
-    # Fit map bounds if we have coordinates
-    if coords:
-        m.fit_bounds(coords)
+                print(f"Error processing location {loc}: {str(e)}")
     
+    # Create Plotly map
+    if len(all_lats) > 0:
+        fig = go.Figure()
+        
+        # Add scatter mapbox points
+        fig.add_trace(go.Scattermapbox(
+            lat=all_lats,
+            lon=all_lons,
+            mode='markers',
+            marker=go.scattermapbox.Marker(
+                size=10,
+                color='blue'
+            ),
+            text=hover_texts,
+            hoverinfo="text"
+        ))
+        
+        # Configure map layout
+        fig.update_layout(
+            mapbox_style="open-street-map",
+            mapbox=dict(
+                center={"lat": sum(all_lats)/len(all_lats) if all_lats else 20, 
+                        "lon": sum(all_lons)/len(all_lons) if all_lons else 0},
+                zoom=3
+            ),
+            margin={"r":0,"t":0,"l":0,"b":0},
+            height=600
+        )
+        
+        return fig, processed_count
+    else:
+        # Create empty figure if no coordinates found
+        fig = go.Figure()
+        fig.update_layout(
+            mapbox_style="open-street-map",
+            mapbox=dict(
+                center={"lat": 20, "lon": 0},
+                zoom=2
+            ),
+            margin={"r":0,"t":0,"l":0,"b":0},
+            height=600,
+            annotations=[
+                dict(
+                    text="No locations found to display",
+                    showarrow=False,
+                    xref="paper",
+                    yref="paper",
+                    x=0.5,
+                    y=0.5
+                )
+            ]
+        )
+        return fig, 0
+
+
     # Custom CSS for map
     custom_css = """
     <style>
@@ -801,6 +805,124 @@ Die Katastrophe in <span style="background-color: #a8e6cf; font-weight: bold; pa
                 """)
         
     
+            # Instead of using folium directly with Gradio's HTML component,
+# try this alternative approach using Plotly for maps
+
+def create_map_plotly(df, location_col):
+    """
+    Creates an interactive map using Plotly instead of Folium
+    which should be more stable in Gradio applications
+    """
+    import plotly.graph_objects as go
+    import pandas as pd
+    
+    # Track processing for debugging
+    print(f"Processing {len(df)} rows with location column: {location_col}")
+    
+    # Initialize geocoder and tracking variables
+    geocoder = SafeGeocoder()
+    processed_count = 0
+    all_lats = []
+    all_lons = []
+    hover_texts = []
+    
+    # Process each row
+    for idx, row in df.iterrows():
+        if pd.isna(row[location_col]):
+            continue
+            
+        location = str(row[location_col]).strip()
+        
+        # Build additional info for hover text
+        additional_info = ""
+        for col in df.columns:
+            if col != location_col and not pd.isna(row[col]):
+                additional_info += f"<br><b>{col}:</b> {row[col]}"
+        
+        # Split location if it contains multiple comma-separated places
+        try:
+            locations = [loc.strip() for loc in location.split(',') if loc.strip()]
+            if not locations:
+                locations = [location]
+        except Exception as e:
+            print(f"Error splitting location '{location}': {str(e)}")
+            locations = [location]
+            
+        # Process each individual location
+        for loc in locations:
+            try:
+                # Get coordinates
+                point = geocoder.get_coords(loc)
+                
+                if point:
+                    lat, lon = point
+                    all_lats.append(lat)
+                    all_lons.append(lon)
+                    
+                    # Create hover text with location name and info
+                    hover_text = f"<b>{loc}</b>{additional_info}"
+                    hover_texts.append(hover_text)
+                    
+                    processed_count += 1
+            except Exception as e:
+                print(f"Error processing location {loc}: {str(e)}")
+    
+    # Create Plotly map
+    if len(all_lats) > 0:
+        fig = go.Figure()
+        
+        # Add scatter mapbox points
+        fig.add_trace(go.Scattermapbox(
+            lat=all_lats,
+            lon=all_lons,
+            mode='markers',
+            marker=go.scattermapbox.Marker(
+                size=10,
+                color='blue'
+            ),
+            text=hover_texts,
+            hoverinfo="text"
+        ))
+        
+        # Configure map layout
+        fig.update_layout(
+            mapbox_style="open-street-map",
+            mapbox=dict(
+                center={"lat": sum(all_lats)/len(all_lats) if all_lats else 20, 
+                        "lon": sum(all_lons)/len(all_lons) if all_lons else 0},
+                zoom=3
+            ),
+            margin={"r":0,"t":0,"l":0,"b":0},
+            height=600
+        )
+        
+        return fig, processed_count
+    else:
+        # Create empty figure if no coordinates found
+        fig = go.Figure()
+        fig.update_layout(
+            mapbox_style="open-street-map",
+            mapbox=dict(
+                center={"lat": 20, "lon": 0},
+                zoom=2
+            ),
+            margin={"r":0,"t":0,"l":0,"b":0},
+            height=600,
+            annotations=[
+                dict(
+                    text="No locations found to display",
+                    showarrow=False,
+                    xref="paper",
+                    yref="paper",
+                    x=0.5,
+                    y=0.5
+                )
+            ]
+        )
+        return fig, 0
+
+# To use this in your Gradio app, modify your code to use gr.Plot instead of gr.HTML:
+
         with gr.TabItem("📍 Visualisierung von strukturierten Daten"):
             gr.HTML("""
             <div class="info-box">
@@ -834,37 +956,39 @@ Die Katastrophe in <span style="background-color: #a8e6cf; font-weight: bold; pa
                     )
                 
                 with gr.Column():
-                    map_output = gr.HTML(
-                        label="Interaktive Karte",
-                        value="""
-                        <div style="text-align:center; height:20vh; width:100%; display:flex; align-items:center; justify-content:center; 
-                                background-color:#f5f5f5; border:1px solid #e0e0e0; border-radius:8px;">
-                            <div>
-                                <img src="https://cdn-icons-png.flaticon.com/512/854/854878.png" width="100">
-                                <p style="margin-top:20px; color:#666;">Your map will appear here after processing</p>
-                            </div>
-                        </div>
-                        """,
-                        elem_id="map-container"
+                    # Replace HTML with Plot component
+                    map_output = gr.Plot(
+                        label="Interaktive Karte"
                     )
-                    
             
+            # Modify your process_and_map function to use the new create_map_plotly function
             def process_and_map(file, column):
                 if file is None:
                     return None, "Hier bitte die Excel-Tabelle hochladen", None
                 
                 try:
-                    map_html, stats, processed_path = process_excel(file, column)
-                    
-                    if map_html and processed_path:
-                        responsive_html = f"""
-                        <div style="width:100%; height:20vh; margin:0; padding:0; border:1px solid #e0e0e0; border-radius:8px; overflow:hidden;">
-                            {map_html}
-                        </div>
-                        """
-                        return responsive_html, stats, processed_path
+                    # Load the Excel file
+                    if hasattr(file, 'name'):
+                        df = pd.read_excel(file.name)
+                    elif isinstance(file, bytes):
+                        df = pd.read_excel(io.BytesIO(file))
                     else:
-                        return None, stats, None
+                        df = pd.read_excel(file)
+                    
+                    if column not in df.columns:
+                        return None, f"Spalte '{column}' wurde in der Excel-Datei nicht gefunden.", None
+                    
+                    # Create map using Plotly
+                    fig, processed_count = create_map_plotly(df, column)
+                    
+                    # Save processed data to Excel
+                    with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
+                        processed_path = tmp.name
+                        df.to_excel(processed_path, index=False)
+                    
+                    stats = f"Gefunden: {processed_count} Orte"
+                    
+                    return fig, stats, processed_path
                 except Exception as e:
                     import traceback
                     trace = traceback.format_exc()
@@ -876,6 +1000,7 @@ Die Katastrophe in <span style="background-color: #a8e6cf; font-weight: bold; pa
                 inputs=[excel_file, places_column],
                 outputs=[map_output, stats_output, processed_file]
             )
+"""
     
     gr.HTML("""
     <div style="text-align: center; margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #eee; font-size: 0.9rem; color: #666;">