Update app.py

app.py

@@ -100,19 +100,18 @@ def process_excel(file, places_column):
         if places_column not in df.columns:
             return None, f"Spalte '{places_column}' wurde in der Excel-Datei nicht gefunden. Verfügbare Spalten: {', '.join(df.columns)}", None
         
-        # Create coordinates columns
-        df['latitude'] = None
-        df['longitude'] = None
-        # Add column for structured location data
-        df['location_data'] = None
+        # Create a new DataFrame to store expanded rows
+        expanded_rows = []
         
         geocoder = SafeGeocoder()
         coords = []
         processed_count = 0
         
-        # Process each location and store as JSON
+        # Process each row
         for idx, row in df.iterrows():
             if pd.isna(row[places_column]):
+                # Keep rows with no location as-is
+                expanded_rows.append(row.to_dict())
                 continue
                 
             location = str(row[places_column]).strip()
@@ -124,121 +123,61 @@ def process_excel(file, places_column):
             except:
                 locations = [location]
             
-            # Process all locations and store as JSON
-            location_data = []
+            # Process each location in the comma-separated list
+            location_rows_added = False
             for loc in locations:
                 point = geocoder.get_coords(loc)
                 if point:
-                    location_data.append({
-                        'location': loc,
-                        'latitude': point[0],
-                        'longitude': point[1]
-                    })
+                    # Create a new row for this location
+                    new_row = row.copy()
+                    new_row_dict = new_row.to_dict()
+                    new_row_dict[places_column] = loc  # Replace with just this location
+                    new_row_dict['latitude'] = point[0]
+                    new_row_dict['longitude'] = point[1]
+                    
+                    # Add the row to our expanded rows list
+                    expanded_rows.append(new_row_dict)
+                    
                     coords.append(point)
                     processed_count += 1
+                    location_rows_added = True
             
-            if location_data:
-                df.at[idx, 'location_data'] = json.dumps(location_data)
-                # Store first location's coordinates in main columns for compatibility
-                df.at[idx, 'latitude'] = location_data[0]['latitude']
-                df.at[idx, 'longitude'] = location_data[0]['longitude']
+            # If none of the locations could be geocoded, keep the original row
+            if not location_rows_added:
+                expanded_rows.append(row.to_dict())
+        
+        # Convert the list of dictionaries to a DataFrame
+        expanded_df = pd.DataFrame(expanded_rows)
         
         # Create the map
-        map_html, _ = create_map(df, places_column)
+        m = folium.Map(
+            location=[20, 0],
+            zoom_start=2, 
+            control_scale=True
+        )
         
-        # Save the updated DataFrame to a new Excel file
-        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
-            processed_path = tmp.name
-            df.to_excel(processed_path, index=False)
+        folium.TileLayer(
+            tiles=MAP_TILES["GreenMap"]["url"],
+            attr=MAP_TILES["GreenMap"]["attr"],
+            name="GreenMap",
+            overlay=False,
+            control=False
+        ).add_to(m)
         
-        total_locations = df[places_column].count()
-        success_rate = (processed_count / total_locations * 100) if total_locations > 0 else 0
+        Fullscreen().add_to(m)
+        MeasureControl(position='topright', primary_length_unit='kilometers').add_to(m)
         
-        stats = f"Gefunden: {processed_count} von {total_locations} Orten ({success_rate:.1f}%)"
+        # Add markers directly here
+        marker_cluster = MarkerCluster(name="Locations").add_to(m)
         
-        return map_html, stats, processed_path
-    except Exception as e:
-        import traceback
-        trace = traceback.format_exc()
-        print(f"Error processing file: {e}\n{trace}")
-        return None, f"Fehler bei der Verarbeitung der Datei: {str(e)}", None
-
-
-def create_map(df, location_col):
-    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)
-    
-    Fullscreen().add_to(m)
-    MeasureControl(position='topright', primary_length_unit='kilometers').add_to(m)
-    
-    coords = []
-    marker_cluster = MarkerCluster(name="Locations").add_to(m)
-    processed_count = 0
-    
-    for idx, row in df.iterrows():
-        # Check if we have JSON location data
-        if 'location_data' in df.columns and not pd.isna(row['location_data']):
-            try:
-                # Parse the JSON location data
-                location_data = json.loads(row['location_data'])
+        for idx, row in expanded_df.iterrows():
+            if 'latitude' in row and 'longitude' in row and not pd.isna(row['latitude']) and not pd.isna(row['longitude']):
+                location = row[places_column] if not pd.isna(row[places_column]) else "Unknown"
                 
-                # Process each location in the JSON data
-                for loc_item in location_data:
-                    location_name = loc_item['location']
-                    point = (loc_item['latitude'], loc_item['longitude'])
-                    
-                    # Create additional info for popup
-                    additional_info = ""
-                    for col in df.columns:
-                        if col not in [location_col, 'location_data', 'latitude', 'longitude'] and not pd.isna(row[col]):
-                            additional_info += f"<br><b>{col}:</b> {row[col]}"
-                    
-                    # Add marker to map
-                    popup_content = f"""
-                    <div style="min-width: 200px; max-width: 300px">
-                        <h4 style="font-family: 'Source Sans Pro', sans-serif; margin-bottom: 5px;">{location_name}</h4>
-                        <div style="font-family: 'Source Sans Pro', sans-serif; font-size: 14px;">
-                            {additional_info}
-                        </div>
-                    </div>
-                    """
-                    
-                    folium.Marker(
-                        location=point,
-                        popup=folium.Popup(popup_content, max_width=300),
-                        tooltip=location_name,
-                        icon=folium.Icon(color="blue", icon="info-sign")
-                    ).add_to(marker_cluster)
-                    
-                    coords.append(point)
-                    processed_count += 1
-            except (json.JSONDecodeError, KeyError) as e:
-                print(f"Error processing JSON location data for row {idx}: {e}")
-                # Continue with fallback method if JSON processing fails
-        
-        # Fallback to the old method if no JSON data is present
-        elif not pd.isna(row[location_col]):
-            location = str(row[location_col]).strip()
-            
-            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]}"
-            
-            # If we have latitude and longitude directly
-            if 'latitude' in df.columns and 'longitude' in df.columns and not pd.isna(row['latitude']) and not pd.isna(row['longitude']):
-                point = (row['latitude'], row['longitude'])
+                additional_info = ""
+                for col in expanded_df.columns:
+                    if col not in [places_column, 'latitude', 'longitude'] and not pd.isna(row[col]):
+                        additional_info += f"<br><b>{col}:</b> {row[col]}"
                 
                 popup_content = f"""
                 <div style="min-width: 200px; max-width: 300px">
@@ -250,36 +189,48 @@ def create_map(df, location_col):
                 """
                 
                 folium.Marker(
-                    location=point,
+                    location=(row['latitude'], row['longitude']),
                     popup=folium.Popup(popup_content, max_width=300),
                     tooltip=location,
                     icon=folium.Icon(color="blue", icon="info-sign")
                 ).add_to(marker_cluster)
-                
-                coords.append(point)
-                processed_count += 1
-    
-    if coords:
-        m.fit_bounds(coords)
-    
-    custom_css = """
-    <style>
-    @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600&display=swap');
-    .leaflet-container {
-        font-family: 'Source Sans Pro', sans-serif;
-    }
-    .leaflet-popup-content {
-        font-family: 'Source Sans Pro', sans-serif;
-    }
-    .leaflet-popup-content h4 {
-        font-weight: 600;
-        margin-bottom: 8px;
-    }
-    </style>
-    """
-    m.get_root().header.add_child(folium.Element(custom_css))
-    
-    return m._repr_html_(), processed_count
+        
+        if coords:
+            m.fit_bounds(coords)
+        
+        custom_css = """
+        <style>
+        @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600&display=swap');
+        .leaflet-container {
+            font-family: 'Source Sans Pro', sans-serif;
+        }
+        .leaflet-popup-content {
+            font-family: 'Source Sans Pro', sans-serif;
+        }
+        .leaflet-popup-content h4 {
+            font-weight: 600;
+            margin-bottom: 8px;
+        }
+        </style>
+        """
+        m.get_root().header.add_child(folium.Element(custom_css))
+        
+        # Save the expanded DataFrame to Excel
+        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
+            processed_path = tmp.name
+            expanded_df.to_excel(processed_path, index=False)
+        
+        total_locations = df[places_column].count()
+        success_rate = (processed_count / total_locations * 100) if total_locations > 0 else 0
+        
+        stats = f"Gefunden: {processed_count} von {total_locations} Orten ({success_rate:.1f}%)"
+        
+        return m._repr_html_(), stats, processed_path
+    except Exception as e:
+        import traceback
+        trace = traceback.format_exc()
+        print(f"Error processing file: {e}\n{trace}")
+        return None, f"Fehler bei der Verarbeitung der Datei: {str(e)}", None
 
 # Corrected model loading function based on official usage example