Update app.py

app.py

@@ -135,98 +135,110 @@ def fetch_firms_data():
 def match_firms_to_inciweb(inciweb_df, firms_df, max_distance_km=50):
     """
     Match FIRMS hotspots to InciWeb incidents based on geographic proximity
-    
-    Args:
-        inciweb_df: DataFrame with InciWeb incident data (must have latitude/longitude)
-        firms_df: DataFrame with FIRMS hotspot data
-        max_distance_km: Maximum distance in km to consider a match
-    
-    Returns:
-        Enhanced inciweb_df with FIRMS data and activity status
+    Enhanced with better error handling
     """
     if firms_df.empty or inciweb_df.empty:
+        print("Warning: Empty dataframes passed to matching function")
         return inciweb_df
     
-    print(f"Matching {len(firms_df)} FIRMS hotspots to {len(inciweb_df)} InciWeb incidents...")
-    
-    # Initialize new columns
-    inciweb_df = inciweb_df.copy()
-    inciweb_df['firms_hotspots'] = 0
-    inciweb_df['total_frp'] = 0.0  # Fire Radiative Power
-    inciweb_df['avg_confidence'] = 0.0
-    inciweb_df['latest_hotspot'] = None
-    inciweb_df['is_active'] = False
-    inciweb_df['hotspot_coords'] = None
-    inciweb_df['activity_level'] = 'Unknown'
-    
-    # Only process incidents that have coordinates
-    incidents_with_coords = inciweb_df[
-        (inciweb_df['latitude'].notna()) & (inciweb_df['longitude'].notna())
-    ].copy()
-    
-    print(f"Processing {len(incidents_with_coords)} incidents with coordinates...")
-    
-    for idx, incident in incidents_with_coords.iterrows():
-        incident_coords = (incident['latitude'], incident['longitude'])
+    try:
+        print(f"Matching {len(firms_df)} FIRMS hotspots to {len(inciweb_df)} InciWeb incidents...")
         
-        # Find FIRMS hotspots within the specified distance
-        hotspot_distances = []
-        matched_hotspots = []
+        # Initialize new columns safely
+        inciweb_df = inciweb_df.copy()
+        inciweb_df['firms_hotspots'] = 0
+        inciweb_df['total_frp'] = 0.0  # Fire Radiative Power
+        inciweb_df['avg_confidence'] = 0.0
+        inciweb_df['latest_hotspot'] = None
+        inciweb_df['is_active'] = False
+        inciweb_df['hotspot_coords'] = None
+        inciweb_df['activity_level'] = 'Unknown'
         
-        for _, hotspot in firms_df.iterrows():
-            hotspot_coords = (hotspot['latitude'], hotspot['longitude'])
-            
+        # Only process incidents that have coordinates
+        incidents_with_coords = inciweb_df[
+            (inciweb_df['latitude'].notna()) & (inciweb_df['longitude'].notna())
+        ].copy()
+        
+        print(f"Processing {len(incidents_with_coords)} incidents with coordinates...")
+        
+        for idx, incident in incidents_with_coords.iterrows():
             try:
-                distance = geodesic(incident_coords, hotspot_coords).kilometers
-                if distance <= max_distance_km:
-                    hotspot_distances.append(distance)
-                    matched_hotspots.append(hotspot)
+                incident_coords = (incident['latitude'], incident['longitude'])
+                
+                # Find FIRMS hotspots within the specified distance
+                hotspot_distances = []
+                matched_hotspots = []
+                
+                for _, hotspot in firms_df.iterrows():
+                    try:
+                        hotspot_coords = (hotspot['latitude'], hotspot['longitude'])
+                        distance = geodesic(incident_coords, hotspot_coords).kilometers
+                        
+                        if distance <= max_distance_km:
+                            hotspot_distances.append(distance)
+                            matched_hotspots.append(hotspot)
+                    except Exception as e:
+                        continue  # Skip invalid coordinates
+                
+                if matched_hotspots:
+                    matched_df = pd.DataFrame(matched_hotspots)
+                    
+                    # Calculate aggregated metrics safely
+                    num_hotspots = len(matched_hotspots)
+                    total_frp = float(matched_df['frp'].sum()) if 'frp' in matched_df.columns else 0.0
+                    avg_confidence = float(matched_df['confidence'].mean()) if 'confidence' in matched_df.columns else 0.0
+                    latest_hotspot = matched_df['datetime'].max() if 'datetime' in matched_df.columns else None
+                    
+                    # Determine activity level based on hotspot count and FRP
+                    if num_hotspots >= 20 and total_frp >= 100:
+                        activity_level = 'Very High'
+                    elif num_hotspots >= 10 and total_frp >= 50:
+                        activity_level = 'High'
+                    elif num_hotspots >= 5 and total_frp >= 20:
+                        activity_level = 'Medium'
+                    elif num_hotspots >= 1:
+                        activity_level = 'Low'
+                    else:
+                        activity_level = 'Minimal'
+                    
+                    # Update the incident data
+                    inciweb_df.at[idx, 'firms_hotspots'] = num_hotspots
+                    inciweb_df.at[idx, 'total_frp'] = total_frp
+                    inciweb_df.at[idx, 'avg_confidence'] = avg_confidence
+                    inciweb_df.at[idx, 'latest_hotspot'] = latest_hotspot
+                    inciweb_df.at[idx, 'is_active'] = True
+                    inciweb_df.at[idx, 'activity_level'] = activity_level
+                    
+                    # Store hotspot coordinates for visualization (simplified)
+                    hotspot_coords = [(float(hs['latitude']), float(hs['longitude']), float(hs.get('frp', 1))) 
+                                    for hs in matched_hotspots[:10]]  # Limit to 10 for performance
+                    inciweb_df.at[idx, 'hotspot_coords'] = str(hotspot_coords)  # Store as string for safety
+                    
+                    print(f"  {incident['name']}: {num_hotspots} hotspots, {total_frp:.1f} FRP, {activity_level} activity")
+                    
             except Exception as e:
-                continue  # Skip invalid coordinates
+                print(f"  Error processing incident {incident.get('name', 'Unknown')}: {e}")
+                continue
         
-        if matched_hotspots:
-            matched_df = pd.DataFrame(matched_hotspots)
-            
-            # Calculate aggregated metrics
-            num_hotspots = len(matched_hotspots)
-            total_frp = matched_df['frp'].sum() if 'frp' in matched_df.columns else 0
-            avg_confidence = matched_df['confidence'].mean() if 'confidence' in matched_df.columns else 0
-            latest_hotspot = matched_df['datetime'].max() if 'datetime' in matched_df.columns else None
-            
-            # Determine activity level based on hotspot count and FRP
-            if num_hotspots >= 20 and total_frp >= 100:
-                activity_level = 'Very High'
-            elif num_hotspots >= 10 and total_frp >= 50:
-                activity_level = 'High'
-            elif num_hotspots >= 5 and total_frp >= 20:
-                activity_level = 'Medium'
-            elif num_hotspots >= 1:
-                activity_level = 'Low'
-            else:
-                activity_level = 'Minimal'
-            
-            # Update the incident data
-            inciweb_df.at[idx, 'firms_hotspots'] = num_hotspots
-            inciweb_df.at[idx, 'total_frp'] = total_frp
-            inciweb_df.at[idx, 'avg_confidence'] = avg_confidence
-            inciweb_df.at[idx, 'latest_hotspot'] = latest_hotspot
-            inciweb_df.at[idx, 'is_active'] = True
-            inciweb_df.at[idx, 'activity_level'] = activity_level
-            
-            # Store hotspot coordinates for visualization
-            hotspot_coords = [(hs['latitude'], hs['longitude'], hs.get('frp', 1)) 
-                            for hs in matched_hotspots]
-            inciweb_df.at[idx, 'hotspot_coords'] = hotspot_coords
-            
-            print(f"  {incident['name']}: {num_hotspots} hotspots, {total_frp:.1f} FRP, {activity_level} activity")
-    
-    # Mark incidents without recent hotspots as potentially inactive
-    active_count = (inciweb_df['is_active'] == True).sum()
-    total_with_coords = len(incidents_with_coords)
-    
-    print(f"Found {active_count} active incidents out of {total_with_coords} with coordinates")
-    
-    return inciweb_df
+        # Mark incidents without recent hotspots as potentially inactive
+        active_count = (inciweb_df['is_active'] == True).sum()
+        total_with_coords = len(incidents_with_coords)
+        
+        print(f"Found {active_count} active incidents out of {total_with_coords} with coordinates")
+        
+        return inciweb_df
+        
+    except Exception as e:
+        print(f"Error in match_firms_to_inciweb: {e}")
+        # Return original dataframe with safety columns
+        inciweb_df['firms_hotspots'] = 0
+        inciweb_df['total_frp'] = 0.0
+        inciweb_df['avg_confidence'] = 0.0
+        inciweb_df['latest_hotspot'] = None
+        inciweb_df['is_active'] = False
+        inciweb_df['hotspot_coords'] = None
+        inciweb_df['activity_level'] = 'Unknown'
+        return inciweb_df
 
 # Function to scrape InciWeb data from the accessible view page
 def fetch_inciweb_data():
@@ -284,9 +296,20 @@ def fetch_inciweb_data():
                     size_cell = row_cells[3] if len(row_cells) > 3 else None
                     if size_cell:
                         size_text = size_cell.text.strip()
-                        size_match = re.search(r'(\d+(?:,\d+)*)', size_text)
-                        if size_match:
-                            incident["size"] = int(size_match.group(1).replace(',', ''))
+                        
+                        # Clean up size text and handle various formats
+                        size_text = size_text.replace('nominal', '').strip()  # Remove 'nominal' text
+                        
+                        # Extract numeric value from size text
+                        if size_text and size_text != '':
+                            size_match = re.search(r'(\d+(?:,\d+)*)', size_text)
+                            if size_match:
+                                try:
+                                    incident["size"] = int(size_match.group(1).replace(',', ''))
+                                except ValueError:
+                                    incident["size"] = None
+                            else:
+                                incident["size"] = None
                         else:
                             incident["size"] = None
                     
@@ -301,12 +324,28 @@ def fetch_inciweb_data():
     
     df = pd.DataFrame(incidents)
     
-    # Ensure all expected columns exist
-    for col in ["size", "type", "location", "state", "updated"]:
+    # Ensure all expected columns exist with safe defaults
+    expected_columns = {
+        "size": None,
+        "type": "Unknown", 
+        "location": "Unknown",
+        "state": None,
+        "updated": "Unknown"
+    }
+    
+    for col, default_val in expected_columns.items():
         if col not in df.columns:
-            df[col] = None
+            df[col] = default_val
     
-    df["size"] = pd.to_numeric(df["size"], errors="coerce")
+    # Safe numeric conversion with better error handling
+    if 'size' in df.columns:
+        # Clean the size column first
+        df['size'] = df['size'].astype(str).str.replace('nominal', '', regex=False)
+        df['size'] = df['size'].str.replace(r'[^\d,]', '', regex=True)  # Keep only digits and commas
+        df['size'] = df['size'].replace('', None)  # Replace empty strings with None
+        
+        # Convert to numeric safely
+        df["size"] = pd.to_numeric(df["size"].str.replace(',', '') if df["size"].dtype == 'object' else df["size"], errors="coerce")
     
     print(f"Fetched {len(df)} incidents")
     return df
@@ -498,299 +537,379 @@ def add_coordinates_to_incidents(df, max_incidents=30):
 
 # Enhanced map generation with FIRMS data
 def generate_enhanced_map(df, firms_df):
-    """Generate map with both InciWeb incidents and FIRMS hotspots"""
-    # Create map centered on the US
-    m = folium.Map(location=[39.8283, -98.5795], zoom_start=4)
-    
-    # Add FIRMS heat map layer for all USA hotspots (even if no InciWeb coordinates)
-    if not firms_df.empty:
-        print(f"Adding {len(firms_df)} FIRMS hotspots to map...")
-        heat_data = [[row['latitude'], row['longitude'], min(row.get('frp', 1), 100)] 
-                    for _, row in firms_df.iterrows()]
-        
-        if heat_data:
-            HeatMap(
-                heat_data,
-                name="Fire Intensity Heatmap (NASA FIRMS)",
-                radius=15,
-                blur=10,
-                max_zoom=1,
-                gradient={0.2: 'blue', 0.4: 'lime', 0.6: 'orange', 1: 'red'}
-            ).add_to(m)
-            
-            # Add some sample FIRMS points as markers
-            sample_firms = firms_df.head(100)  # Show top 100 hotspots as individual markers
-            for _, hotspot in sample_firms.iterrows():
-                folium.CircleMarker(
-                    location=[hotspot['latitude'], hotspot['longitude']],
-                    radius=2 + min(hotspot.get('frp', 1) / 10, 8),
-                    popup=f"🔥 FIRMS Hotspot<br>FRP: {hotspot.get('frp', 'N/A')} MW<br>Confidence: {hotspot.get('confidence', 'N/A')}%<br>Time: {hotspot.get('acq_time', 'N/A')}",
-                    color='red',
-                    fillColor='orange',
-                    fillOpacity=0.7,
-                    weight=1
-                ).add_to(m)
-    
-    # Add incident markers if we have coordinates
-    incidents_with_coords = df[(df['latitude'].notna()) & (df['longitude'].notna())]
-    
-    if not incidents_with_coords.empty:
-        print(f"Adding {len(incidents_with_coords)} InciWeb incidents with coordinates to map...")
-        
-        # Add incident markers
-        incident_cluster = MarkerCluster(name="InciWeb Incidents").add_to(m)
-        
-        # Track statistics
+    """Generate map with both InciWeb incidents and FIRMS hotspots - with robust error handling"""
+    
+    try:
+        print("Starting map generation...")
+        
+        # Create map centered on the US
+        m = folium.Map(location=[39.8283, -98.5795], zoom_start=4)
+        
+        # Add FIRMS heat map layer for all USA hotspots (even if no InciWeb coordinates)
+        if not firms_df.empty:
+            print(f"Adding {len(firms_df)} FIRMS hotspots to map...")
+            try:
+                # Limit to first 1000 hotspots for performance
+                sample_firms = firms_df.head(1000)
+                heat_data = []
+                
+                for _, row in sample_firms.iterrows():
+                    try:
+                        lat, lon = float(row['latitude']), float(row['longitude'])
+                        frp = float(row.get('frp', 1))
+                        if -90 <= lat <= 90 and -180 <= lon <= 180:  # Valid coordinates
+                            heat_data.append([lat, lon, min(frp, 100)])
+                    except (ValueError, TypeError):
+                        continue
+                
+                if heat_data:
+                    HeatMap(
+                        heat_data,
+                        name="Fire Intensity Heatmap (NASA FIRMS)",
+                        radius=15,
+                        blur=10,
+                        max_zoom=1,
+                        gradient={0.2: 'blue', 0.4: 'lime', 0.6: 'orange', 1: 'red'}
+                    ).add_to(m)
+                    print(f"Added heatmap with {len(heat_data)} valid hotspots")
+                
+                # Add some sample FIRMS points as individual markers
+                for i, (_, hotspot) in enumerate(sample_firms.head(50).iterrows()):
+                    try:
+                        lat, lon = float(hotspot['latitude']), float(hotspot['longitude'])
+                        frp = float(hotspot.get('frp', 1))
+                        conf = hotspot.get('confidence', 'N/A')
+                        acq_time = hotspot.get('acq_time', 'N/A')
+                        
+                        if -90 <= lat <= 90 and -180 <= lon <= 180:
+                            folium.CircleMarker(
+                                location=[lat, lon],
+                                radius=2 + min(frp / 10, 8),
+                                popup=f"🔥 FIRMS Hotspot<br>FRP: {frp} MW<br>Confidence: {conf}%<br>Time: {acq_time}",
+                                color='red',
+                                fillColor='orange',
+                                fillOpacity=0.7,
+                                weight=1
+                            ).add_to(m)
+                    except (ValueError, TypeError, KeyError):
+                        continue
+                        
+            except Exception as e:
+                print(f"Error adding FIRMS data to map: {e}")
+        
+        # Add incident markers if we have coordinates
+        incidents_with_coords = df[(df['latitude'].notna()) & (df['longitude'].notna())] if not df.empty else pd.DataFrame()
+        
         active_incidents = 0
         inactive_incidents = 0
         
-        for _, row in incidents_with_coords.iterrows():
-            lat, lon = row['latitude'], row['longitude']
+        if not incidents_with_coords.empty:
+            print(f"Adding {len(incidents_with_coords)} InciWeb incidents with coordinates to map...")
             
-            # Determine marker color based on activity and type
-            if row.get('is_active', False):
-                active_incidents += 1
-                activity_level = row.get('activity_level', 'Unknown')
-                if activity_level == 'Very High':
-                    color = 'red'
-                    icon = 'fire'
-                elif activity_level == 'High':
-                    color = 'orange'
-                    icon = 'fire'
-                elif activity_level == 'Medium':
-                    color = 'yellow'
-                    icon = 'fire'
-                else:
-                    color = 'lightred'
-                    icon = 'fire'
-            else:
-                inactive_incidents += 1
-                color = 'gray'
-                icon = 'pause'
-            
-            # Create detailed popup
-            popup_content = f"""
-            <div style="width: 300px;">
-                <h4>{row.get('name', 'Unknown')}</h4>
-                <b>Type:</b> {row.get('type', 'N/A')}<br>
-                <b>Location:</b> {row.get('location', 'N/A')}<br>
-                <b>Size:</b> {row.get('size', 'N/A')} acres<br>
-                <b>Last Updated:</b> {row.get('updated', 'N/A')}<br>
-                
-                <hr style="margin: 10px 0;">
-                <h5>🔥 Fire Activity (NASA FIRMS)</h5>
-                <b>Status:</b> {'🔴 ACTIVE' if row.get('is_active', False) else '⚫ Inactive'}<br>
-                <b>Activity Level:</b> {row.get('activity_level', 'Unknown')}<br>
-                <b>Hotspots (24h):</b> {row.get('firms_hotspots', 0)}<br>
-                <b>Total Fire Power:</b> {row.get('total_frp', 0):.1f} MW<br>
-                <b>Avg Confidence:</b> {row.get('avg_confidence', 0):.1f}%<br>
+            # Add incident markers with error handling
+            try:
+                incident_cluster = MarkerCluster(name="InciWeb Incidents").add_to(m)
                 
-                <a href="{row.get('link', '#')}" target="_blank">📋 More Details</a>
+                for _, row in incidents_with_coords.iterrows():
+                    try:
+                        lat, lon = float(row['latitude']), float(row['longitude'])
+                        
+                        if not (-90 <= lat <= 90 and -180 <= lon <= 180):
+                            continue
+                        
+                        # Determine marker color based on activity and type
+                        is_active = row.get('is_active', False)
+                        if is_active:
+                            active_incidents += 1
+                            activity_level = row.get('activity_level', 'Unknown')
+                            if activity_level == 'Very High':
+                                color = 'red'
+                            elif activity_level == 'High':
+                                color = 'orange'
+                            elif activity_level == 'Medium':
+                                color = 'yellow'
+                            else:
+                                color = 'lightred'
+                        else:
+                            inactive_incidents += 1
+                            color = 'gray'
+                        
+                        # Create popup content safely
+                        name = str(row.get('name', 'Unknown'))
+                        incident_type = str(row.get('type', 'N/A'))
+                        location = str(row.get('location', 'N/A'))
+                        size = row.get('size', 'N/A')
+                        updated = str(row.get('updated', 'N/A'))
+                        
+                        firms_hotspots = int(row.get('firms_hotspots', 0))
+                        total_frp = float(row.get('total_frp', 0))
+                        avg_confidence = float(row.get('avg_confidence', 0))
+                        activity_level = str(row.get('activity_level', 'Unknown'))
+                        
+                        popup_content = f"""
+                        <div style="width: 300px;">
+                            <h4>{name}</h4>
+                            <b>Type:</b> {incident_type}<br>
+                            <b>Location:</b> {location}<br>
+                            <b>Size:</b> {size} acres<br>
+                            <b>Last Updated:</b> {updated}<br>
+                            
+                            <hr style="margin: 10px 0;">
+                            <h5>🔥 Fire Activity (NASA FIRMS)</h5>
+                            <b>Status:</b> {'🔴 ACTIVE' if is_active else '⚫ Inactive'}<br>
+                            <b>Activity Level:</b> {activity_level}<br>
+                            <b>Hotspots (24h):</b> {firms_hotspots}<br>
+                            <b>Total Fire Power:</b> {total_frp:.1f} MW<br>
+                            <b>Avg Confidence:</b> {avg_confidence:.1f}%<br>
+                        </div>
+                        """
+                        
+                        folium.Marker(
+                            location=[lat, lon],
+                            popup=folium.Popup(popup_content, max_width=350),
+                            icon=folium.Icon(color=color)
+                        ).add_to(incident_cluster)
+                        
+                    except Exception as e:
+                        print(f"Error adding incident marker: {e}")
+                        continue
+                        
+            except Exception as e:
+                print(f"Error creating incident markers: {e}")
+        else:
+            print("No InciWeb incidents have coordinates, showing FIRMS data only")
+            inactive_incidents = len(df) if not df.empty else 0
+        
+        # Add custom legend
+        total_hotspots = len(firms_df) if not firms_df.empty else 0
+        total_incidents = len(df) if not df.empty else 0
+        
+        legend_html = f'''
+        <div style="position: fixed; 
+                    bottom: 50px; left: 50px; width: 250px; height: 320px; 
+                    border:2px solid grey; z-index:9999; font-size:12px;
+                    background-color:white; padding: 10px;
+                    border-radius: 5px; font-family: Arial;">
+            <div style="font-weight: bold; margin-bottom: 8px; font-size: 14px;">🔥 Wildfire Activity Status</div>
+            
+            <div style="margin-bottom: 8px;"><b>InciWeb Incidents:</b></div>
+            <div style="display: flex; align-items: center; margin-bottom: 3px;">
+                <div style="background-color: red; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
+                <div>Very High Activity</div>
+            </div>
+            <div style="display: flex; align-items: center; margin-bottom: 3px;">
+                <div style="background-color: orange; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
+                <div>High Activity</div>
+            </div>
+            <div style="display: flex; align-items: center; margin-bottom: 3px;">
+                <div style="background-color: yellow; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
+                <div>Medium Activity</div>
+            </div>
+            <div style="display: flex; align-items: center; margin-bottom: 3px;">
+                <div style="background-color: lightcoral; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
+                <div>Low Activity</div>
+            </div>
+            <div style="display: flex; align-items: center; margin-bottom: 8px;">
+                <div style="background-color: gray; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
+                <div>Inactive/No Data</div>
             </div>
-            """
             
-            folium.Marker(
-                location=[lat, lon],
-                popup=folium.Popup(popup_content, max_width=350),
-                icon=folium.Icon(color=color, icon=icon, prefix='fa')
-            ).add_to(incident_cluster)
+            <div style="margin-bottom: 5px;"><b>NASA FIRMS Data:</b></div>
+            <div style="display: flex; align-items: center; margin-bottom: 3px;">
+                <div style="background-color: orange; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
+                <div>Fire Hotspots (24h)</div>
+            </div>
+            <div style="margin-bottom: 8px; font-style: italic;">Heat map shows fire intensity</div>
             
-            # Add hotspot visualization for active incidents
-            if row.get('is_active', False) and row.get('hotspot_coords'):
-                hotspot_coords = row.get('hotspot_coords', [])
-                if hotspot_coords:
-                    # Add individual hotspot markers (smaller, less intrusive)
-                    for coord in hotspot_coords[:20]:  # Limit to 20 hotspots per incident
-                        folium.CircleMarker(
-                            location=[coord[0], coord[1]],
-                            radius=3 + min(coord[2] / 20, 10),  # Size based on FRP
-                            popup=f"🔥 Hotspot<br>FRP: {coord[2]:.1f} MW",
-                            color='red',
-                            fillColor='orange',
-                            fillOpacity=0.7
-                        ).add_to(m)
-    else:
-        print("No InciWeb incidents have coordinates, showing FIRMS data only")
-        active_incidents = 0
-        inactive_incidents = len(df)
-    
-    # Add custom legend
-    total_hotspots = len(firms_df) if not firms_df.empty else 0
-    total_incidents = len(df)
-    
-    legend_html = f'''
-    <div style="position: fixed; 
-                bottom: 50px; left: 50px; width: 250px; height: 320px; 
-                border:2px solid grey; z-index:9999; font-size:12px;
-                background-color:white; padding: 10px;
-                border-radius: 5px; font-family: Arial;">
-        <div style="font-weight: bold; margin-bottom: 8px; font-size: 14px;">🔥 Wildfire Activity Status</div>
-        
-        <div style="margin-bottom: 8px;"><b>InciWeb Incidents:</b></div>
-        <div style="display: flex; align-items: center; margin-bottom: 3px;">
-            <div style="background-color: red; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
-            <div>Very High Activity</div>
-        </div>
-        <div style="display: flex; align-items: center; margin-bottom: 3px;">
-            <div style="background-color: orange; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
-            <div>High Activity</div>
-        </div>
-        <div style="display: flex; align-items: center; margin-bottom: 3px;">
-            <div style="background-color: yellow; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
-            <div>Medium Activity</div>
-        </div>
-        <div style="display: flex; align-items: center; margin-bottom: 3px;">
-            <div style="background-color: lightcoral; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
-            <div>Low Activity</div>
-        </div>
-        <div style="display: flex; align-items: center; margin-bottom: 8px;">
-            <div style="background-color: gray; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
-            <div>Inactive/No Data</div>
+            <div style="font-size: 11px; margin-top: 10px; padding-top: 5px; border-top: 1px solid #ccc;">
+                <b>Statistics:</b><br>
+                🔴 Active InciWeb: {active_incidents}<br>
+                ⚫ Inactive InciWeb: {inactive_incidents}<br>
+                📍 Total InciWeb: {total_incidents}<br>
+                🌡️ Total FIRMS Hotspots: {total_hotspots}<br>
+                📊 Incidents with Coords: {len(incidents_with_coords)}
+            </div>
         </div>
+        '''
         
-        <div style="margin-bottom: 5px;"><b>NASA FIRMS Data:</b></div>
-        <div style="display: flex; align-items: center; margin-bottom: 3px;">
-            <div style="background-color: orange; width: 12px; height: 12px; margin-right: 5px; border-radius: 50%;"></div>
-            <div>Fire Hotspots (24h)</div>
-        </div>
-        <div style="margin-bottom: 8px; font-style: italic;">Heat map shows fire intensity</div>
-        
-        <div style="font-size: 11px; margin-top: 10px; padding-top: 5px; border-top: 1px solid #ccc;">
-            <b>Statistics:</b><br>
-            🔴 Active InciWeb: {active_incidents}<br>
-            ⚫ Inactive InciWeb: {inactive_incidents}<br>
-            📍 Total InciWeb: {total_incidents}<br>
-            🌡️ Total FIRMS Hotspots: {total_hotspots}<br>
-            📊 Incidents with Coords: {len(incidents_with_coords)}
-        </div>
-    </div>
-    '''
-    
-    # Add layer control
-    folium.LayerControl().add_to(m)
-    
-    # Get map HTML and add legend
-    map_html = m._repr_html_()
-    map_with_legend = map_html.replace('</body>', legend_html + '</body>')
-    
-    return map_with_legend
+        # Add layer control
+        try:
+            folium.LayerControl().add_to(m)
+        except Exception as e:
+            print(f"Error adding layer control: {e}")
+        
+        # Get map HTML and add legend
+        try:
+            map_html = m._repr_html_()
+            map_with_legend = map_html.replace('</body>', legend_html + '</body>')
+            print("Map generation completed successfully")
+            return map_with_legend
+        except Exception as e:
+            print(f"Error generating final map HTML: {e}")
+            return f"<div style='padding: 20px; text-align: center;'>Map generation error: {str(e)}</div>"
+        
+    except Exception as e:
+        print(f"Critical error in map generation: {e}")
+        import traceback
+        traceback.print_exc()
+        return f"<div style='padding: 20px; text-align: center;'>Critical map error: {str(e)}</div>"
 
 # Enhanced visualization functions
 def generate_enhanced_visualizations(df, firms_df):
-    """Generate enhanced visualizations with FIRMS data integration"""
+    """Generate enhanced visualizations with FIRMS data integration - with robust error handling"""
     figures = []
     
-    if df.empty:
-        return [px.bar(title="No data available")]
-    
-    # 1. Activity Status Overview
-    if 'is_active' in df.columns:
-        activity_summary = df['is_active'].value_counts().reset_index()
-        activity_summary.columns = ['is_active', 'count']
-        activity_summary['status'] = activity_summary['is_active'].map({True: 'Active (FIRMS detected)', False: 'Inactive/Unknown'})
-        
-        fig1 = px.pie(
-            activity_summary,
-            values='count',
-            names='status',
-            title="🔥 Wildfire Activity Status (Based on NASA FIRMS Data)",
-            color_discrete_map={'Active (FIRMS detected)': 'red', 'Inactive/Unknown': 'gray'}
-        )
-        fig1.update_traces(textinfo='label+percent+value')
-    else:
-        fig1 = px.bar(title="Activity status data not available")
-    figures.append(fig1)
-    
-    # 2. Activity Level Distribution
-    if 'activity_level' in df.columns and df['activity_level'].notna().any():
-        activity_levels = df[df['activity_level'] != 'Unknown']['activity_level'].value_counts().reset_index()
-        activity_levels.columns = ['activity_level', 'count']
-        
-        # Define order and colors
-        level_order = ['Very High', 'High', 'Medium', 'Low', 'Minimal']
-        color_map = {'Very High': 'darkred', 'High': 'red', 'Medium': 'orange', 'Low': 'yellow', 'Minimal': 'lightblue'}
-        
-        fig2 = px.bar(
-            activity_levels,
-            x='activity_level',
-            y='count',
-            title="📊 Fire Activity Levels (NASA FIRMS Intensity)",
-            labels={'activity_level': 'Activity Level', 'count': 'Number of Incidents'},
-            color='activity_level',
-            color_discrete_map=color_map,
-            category_orders={'activity_level': level_order}
-        )
-    else:
-        fig2 = px.bar(title="Activity level data not available")
-    figures.append(fig2)
-    
-    # 3. Fire Radiative Power vs Incident Size
-    if 'total_frp' in df.columns and 'size' in df.columns:
-        active_df = df[(df['is_active'] == True) & (df['total_frp'] > 0) & (df['size'].notna())].copy()
-        
-        if not active_df.empty:
-            fig3 = px.scatter(
-                active_df,
-                x='size',
-                y='total_frp',
-                size='firms_hotspots',
-                color='activity_level',
-                hover_data=['name', 'state', 'firms_hotspots'],
-                title="🔥 Fire Intensity vs Incident Size (Active Fires Only)",
-                labels={'size': 'Incident Size (acres)', 'total_frp': 'Total Fire Radiative Power (MW)'},
-                color_discrete_map={'Very High': 'darkred', 'High': 'red', 'Medium': 'orange', 'Low': 'yellow'}
-            )
-            fig3.update_layout(xaxis_type="log", yaxis_type="log")
-        else:
-            fig3 = px.bar(title="No active fires with size and intensity data")
-    else:
-        fig3 = px.bar(title="Fire intensity vs size data not available")
-    figures.append(fig3)
-    
-    # 4. Hotspot Detection Over Time (if FIRMS data available)
-    if not firms_df.empty and 'datetime' in firms_df.columns:
-        # Group by hour to show detection pattern
-        firms_df['hour'] = firms_df['datetime'].dt.floor('H')
-        hourly_detections = firms_df.groupby('hour').size().reset_index(name='detections')
-        
-        fig4 = px.line(
-            hourly_detections,
-            x='hour',
-            y='detections',
-            title="🕐 Fire Hotspot Detections Over Time (Last 24 Hours)",
-            labels={'hour': 'Time', 'detections': 'Number of Hotspots Detected'}
-        )
-        fig4.update_traces(line_color='red')
-    else:
-        fig4 = px.bar(title="FIRMS temporal data not available")
-    figures.append(fig4)
-    
-    # 5. State-wise Active vs Inactive Breakdown
-    if 'state' in df.columns and 'is_active' in df.columns:
-        state_activity = df.groupby(['state', 'is_active']).size().reset_index(name='count')
-        state_activity['status'] = state_activity['is_active'].map({True: 'Active', False: 'Inactive'})
-        
-        # Get top 10 states by total incidents
-        top_states = df['state'].value_counts().head(10).index.tolist()
-        state_activity_filtered = state_activity[state_activity['state'].isin(top_states)]
-        
-        if not state_activity_filtered.empty:
-            fig5 = px.bar(
-                state_activity_filtered,
-                x='state',
-                y='count',
-                color='status',
-                title="🗺️ Active vs Inactive Incidents by State (Top 10)",
-                labels={'state': 'State', 'count': 'Number of Incidents'},
-                color_discrete_map={'Active': 'red', 'Inactive': 'gray'}
-            )
-        else:
-            fig5 = px.bar(title="State activity data not available")
-    else:
-        fig5 = px.bar(title="State activity data not available")
-    figures.append(fig5)
-    
-    return figures
+    try:
+        print("Starting visualization generation...")
+        
+        if df.empty:
+            print("Warning: Empty dataframe for visualizations")
+            return [px.bar(title="No data available")]
+        
+        # 1. Activity Status Overview
+        try:
+            if 'is_active' in df.columns:
+                activity_counts = df['is_active'].value_counts()
+                if not activity_counts.empty:
+                    activity_summary = activity_counts.reset_index()
+                    activity_summary.columns = ['is_active', 'count']
+                    activity_summary['status'] = activity_summary['is_active'].map({
+                        True: 'Active (FIRMS detected)', 
+                        False: 'Inactive/Unknown'
+                    })
+                    
+                    fig1 = px.pie(
+                        activity_summary,
+                        values='count',
+                        names='status',
+                        title="🔥 Wildfire Activity Status (Based on NASA FIRMS Data)",
+                        color_discrete_map={
+                            'Active (FIRMS detected)': 'red', 
+                            'Inactive/Unknown': 'gray'
+                        }
+                    )
+                    fig1.update_traces(textinfo='label+percent+value')
+                else:
+                    fig1 = px.bar(title="No activity status data available")
+            else:
+                fig1 = px.bar(title="Activity status data not available")
+        except Exception as e:
+            print(f"Error creating activity status chart: {e}")
+            fig1 = px.bar(title=f"Activity status error: {str(e)}")
+        figures.append(fig1)
+        
+        # 2. Incident Type Distribution (Simple fallback)
+        try:
+            if 'type' in df.columns and df['type'].notna().any():
+                type_counts = df['type'].value_counts().head(10).reset_index()
+                type_counts.columns = ['incident_type', 'count']
+                
+                fig2 = px.bar(
+                    type_counts,
+                    x='incident_type',
+                    y='count',
+                    title="📊 Incidents by Type",
+                    labels={'incident_type': 'Incident Type', 'count': 'Count'}
+                )
+            else:
+                fig2 = px.bar(title="No incident type data available")
+        except Exception as e:
+            print(f"Error creating type distribution chart: {e}")
+            fig2 = px.bar(title=f"Type distribution error: {str(e)}")
+        figures.append(fig2)
+        
+        # 3. State Distribution
+        try:
+            if 'state' in df.columns and df['state'].notna().any():
+                state_counts = df['state'].value_counts().head(10).reset_index()
+                state_counts.columns = ['state_name', 'count']
+                
+                fig3 = px.bar(
+                    state_counts,
+                    x='state_name',
+                    y='count',
+                    title="🗺️ Incidents by State (Top 10)",
+                    labels={'state_name': 'State', 'count': 'Count'}
+                )
+            else:
+                fig3 = px.bar(title="No state data available")
+        except Exception as e:
+            print(f"Error creating state distribution chart: {e}")
+            fig3 = px.bar(title=f"State distribution error: {str(e)}")
+        figures.append(fig3)
+        
+        # 4. FIRMS Hotspot Timeline (if available)
+        try:
+            if not firms_df.empty and 'datetime' in firms_df.columns:
+                # Group by hour to show detection pattern
+                firms_df_copy = firms_df.copy()
+                firms_df_copy['hour'] = pd.to_datetime(firms_df_copy['datetime']).dt.floor('H')
+                hourly_detections = firms_df_copy.groupby('hour').size().reset_index(name='detections')
+                
+                if not hourly_detections.empty:
+                    fig4 = px.line(
+                        hourly_detections,
+                        x='hour',
+                        y='detections',
+                        title="🕐 Fire Hotspot Detections Over Time (Last 24 Hours)",
+                        labels={'hour': 'Time', 'detections': 'Number of Hotspots Detected'}
+                    )
+                    fig4.update_traces(line_color='red')
+                else:
+                    fig4 = px.bar(title="No FIRMS temporal data available")
+            else:
+                fig4 = px.bar(title="FIRMS temporal data not available")
+        except Exception as e:
+            print(f"Error creating FIRMS timeline chart: {e}")
+            fig4 = px.bar(title=f"FIRMS timeline error: {str(e)}")
+        figures.append(fig4)
+        
+        # 5. Fire Activity Level Distribution (if available)
+        try:
+            if 'activity_level' in df.columns and df['activity_level'].notna().any():
+                # Filter out Unknown values
+                activity_df = df[df['activity_level'] != 'Unknown']
+                if not activity_df.empty and activity_df['activity_level'].notna().any():
+                    activity_levels = activity_df['activity_level'].value_counts().reset_index()
+                    activity_levels.columns = ['activity_level', 'count']
+                    
+                    # Define order and colors
+                    level_order = ['Very High', 'High', 'Medium', 'Low', 'Minimal']
+                    color_map = {
+                        'Very High': 'darkred', 
+                        'High': 'red', 
+                        'Medium': 'orange', 
+                        'Low': 'yellow', 
+                        'Minimal': 'lightblue'
+                    }
+                    
+                    fig5 = px.bar(
+                        activity_levels,
+                        x='activity_level',
+                        y='count',
+                        title="📊 Fire Activity Levels (NASA FIRMS Intensity)",
+                        labels={'activity_level': 'Activity Level', 'count': 'Number of Incidents'},
+                        color='activity_level',
+                        color_discrete_map=color_map,
+                        category_orders={'activity_level': level_order}
+                    )
+                else:
+                    fig5 = px.bar(title="No activity level data with known values")
+            else:
+                fig5 = px.bar(title="Activity level data not available")
+        except Exception as e:
+            print(f"Error creating activity level chart: {e}")
+            fig5 = px.bar(title=f"Activity level error: {str(e)}")
+        figures.append(fig5)
+        
+        print(f"Generated {len(figures)} visualizations")
+        return figures
+        
+    except Exception as e:
+        print(f"Critical error in visualization generation: {e}")
+        import traceback
+        traceback.print_exc()
+        return [px.bar(title=f"Critical visualization error: {str(e)}")]
 
 # Main application function
 def create_enhanced_wildfire_app():
@@ -848,58 +967,139 @@ def create_enhanced_wildfire_app():
         app_state = gr.State({})
         
         def fetch_and_process_data():
-            """Main data processing function"""
+            """Main data processing function with comprehensive error handling and debugging"""
             try:
                 yield "📡 Fetching InciWeb incident data...", None, None, None, None, None, None
                 
-                # Fetch InciWeb data
-                inciweb_df = fetch_inciweb_data()
-                if inciweb_df.empty:
-                    yield "❌ Failed to fetch InciWeb data", None, None, None, None, None, None
+                # Fetch InciWeb data with error handling
+                try:
+                    print("Step 1: Fetching InciWeb data...")
+                    inciweb_df = fetch_inciweb_data()
+                    if inciweb_df.empty:
+                        yield "❌ Failed to fetch InciWeb data", None, None, None, None, None, None
+                        return
+                    print(f"Step 1 SUCCESS: Got {len(inciweb_df)} incidents")
+                except Exception as e:
+                    print(f"Step 1 ERROR: {e}")
+                    yield f"❌ Error fetching InciWeb data: {str(e)}", None, None, None, None, None, None
                     return
                 
                 yield f"✅ Found {len(inciweb_df)} InciWeb incidents. Getting coordinates...", None, None, None, None, None, None
                 
-                # Get coordinates for sample incidents
-                inciweb_df = add_coordinates_to_incidents(inciweb_df, max_incidents=15)
+                # Get coordinates for sample incidents with error handling
+                try:
+                    print("Step 2: Getting coordinates...")
+                    inciweb_df = add_coordinates_to_incidents(inciweb_df, max_incidents=15)
+                    coords_count = len(inciweb_df[(inciweb_df['latitude'].notna()) & (inciweb_df['longitude'].notna())])
+                    print(f"Step 2 SUCCESS: Got coordinates for {coords_count} incidents")
+                except Exception as e:
+                    print(f"Step 2 ERROR: {e}")
+                    # Continue with the data we have
                 
                 yield "🛰️ Fetching NASA FIRMS fire detection data...", None, None, None, None, None, None
                 
-                # Fetch FIRMS data
-                firms_df = fetch_firms_data()
-                if firms_df.empty:
-                    yield "⚠️ FIRMS data unavailable, proceeding with InciWeb only", None, None, inciweb_df, firms_df, None, None
+                # Fetch FIRMS data with error handling
+                try:
+                    print("Step 3: Fetching FIRMS data...")
+                    firms_df = fetch_firms_data()
+                    if firms_df.empty:
+                        print("Step 3 WARNING: FIRMS data empty")
+                        # Still useful to show InciWeb data even without FIRMS
+                        yield "⚠️ FIRMS data unavailable, generating basic visualization...", None, None, None, None, None, None
+                        
+                        # Generate basic map and visualizations without FIRMS data
+                        try:
+                            print("Generating basic map without FIRMS...")
+                            map_html = generate_enhanced_map(inciweb_df, pd.DataFrame())
+                            print("Generating basic visualizations...")
+                            plots = generate_enhanced_visualizations(inciweb_df, pd.DataFrame())
+                            
+                            # Create CSV file
+                            import tempfile
+                            csv_file = tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False)
+                            inciweb_df.to_csv(csv_file.name, index=False)
+                            csv_file.close()
+                            
+                            final_status = f"✅ Partial success! Found {len(inciweb_df)} InciWeb incidents (FIRMS data unavailable)"
+                            yield (final_status, map_html, plots[0], inciweb_df, pd.DataFrame(), csv_file.name, 
+                                   {"inciweb_df": inciweb_df, "firms_df": pd.DataFrame(), "plots": plots})
+                            return
+                        except Exception as e:
+                            print(f"Error in basic visualization: {e}")
+                            yield f"❌ Error in basic visualization: {str(e)}", None, None, inciweb_df, pd.DataFrame(), None, None
+                            return
+                        
+                    print(f"Step 3 SUCCESS: Got {len(firms_df)} FIRMS hotspots")
+                        
+                except Exception as e:
+                    print(f"Step 3 ERROR: {e}")
+                    yield f"❌ Error fetching FIRMS data: {str(e)}", None, None, inciweb_df, pd.DataFrame(), None, None
                     return
                 
                 yield f"✅ Found {len(firms_df)} USA fire hotspots. Matching with incidents...", None, None, None, None, None, None
                 
-                # Match FIRMS data to InciWeb incidents
-                enhanced_df = match_firms_to_inciweb(inciweb_df, firms_df)
+                # Match FIRMS data to InciWeb incidents with error handling
+                try:
+                    print("Step 4: Matching FIRMS to InciWeb...")
+                    enhanced_df = match_firms_to_inciweb(inciweb_df, firms_df)
+                    print(f"Step 4 SUCCESS: Enhanced {len(enhanced_df)} incidents")
+                except Exception as e:
+                    print(f"Step 4 ERROR: {e}")
+                    # Use original data if matching fails
+                    enhanced_df = inciweb_df
+                    print("Using original InciWeb data without FIRMS matching")
                 
                 yield "🗺️ Generating enhanced map...", None, None, None, None, None, None
                 
-                # Generate map and visualizations
-                map_html = generate_enhanced_map(enhanced_df, firms_df)
-                plots = generate_enhanced_visualizations(enhanced_df, firms_df)
+                # Generate map and visualizations with error handling
+                try:
+                    print("Step 5: Generating map...")
+                    map_html = generate_enhanced_map(enhanced_df, firms_df)
+                    print("Step 5a SUCCESS: Map generated")
+                    
+                    print("Step 5: Generating visualizations...")
+                    plots = generate_enhanced_visualizations(enhanced_df, firms_df)
+                    print("Step 5b SUCCESS: Visualizations generated")
+                except Exception as e:
+                    print(f"Step 5 ERROR: {e}")
+                    # Create fallback simple content
+                    map_html = f"<div style='padding: 20px; text-align: center;'>Map generation failed: {str(e)}<br>Data is available in tables below.</div>"
+                    plots = [px.bar(title=f"Visualization generation failed: {str(e)}")]
                 
                 # Prepare export data - create temporary files
-                import tempfile
-                
-                # Create CSV file
-                csv_file = tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False)
-                enhanced_df.to_csv(csv_file.name, index=False)
-                csv_file.close()
+                try:
+                    print("Step 6: Creating CSV export...")
+                    import tempfile
+                    csv_file = tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False)
+                    enhanced_df.to_csv(csv_file.name, index=False)
+                    csv_file.close()
+                    print("Step 6 SUCCESS: CSV created")
+                except Exception as e:
+                    print(f"Step 6 ERROR: {e}")
+                    csv_file = None
                 
-                active_count = (enhanced_df.get('is_active', pd.Series([False])) == True).sum()
-                total_hotspots = len(firms_df)
-                
-                final_status = f"✅ Complete! Found {active_count} active fires with {total_hotspots} total hotspots"
-                
-                yield (final_status, map_html, plots[0], enhanced_df, firms_df, csv_file.name, 
-                       {"inciweb_df": enhanced_df, "firms_df": firms_df, "plots": plots})
+                # Calculate final statistics
+                try:
+                    active_count = (enhanced_df.get('is_active', pd.Series([False])) == True).sum()
+                    total_hotspots = len(firms_df) if not firms_df.empty else 0
+                    coords_count = len(enhanced_df[(enhanced_df['latitude'].notna()) & (enhanced_df['longitude'].notna())])
+                    
+                    final_status = f"✅ Complete! {active_count} active fires, {total_hotspots} hotspots, {coords_count} with coordinates"
+                    print(f"FINAL SUCCESS: {final_status}")
+                    
+                    yield (final_status, map_html, plots[0], enhanced_df, firms_df, csv_file.name if csv_file else None, 
+                           {"inciweb_df": enhanced_df, "firms_df": firms_df, "plots": plots})
+                except Exception as e:
+                    print(f"Error calculating final statistics: {e}")
+                    final_status = "✅ Process completed with some errors"
+                    yield (final_status, map_html, plots[0], enhanced_df, firms_df, csv_file.name if csv_file else None, 
+                           {"inciweb_df": enhanced_df, "firms_df": firms_df, "plots": plots})
                 
             except Exception as e:
-                yield f"❌ Error: {str(e)}", None, None, None, None, None, None
+                import traceback
+                error_details = traceback.format_exc()
+                print(f"CRITICAL ERROR in main process: {error_details}")
+                yield f"❌ Critical Error: {str(e)}", None, None, None, None, None, None
         
         def update_plot(plot_name, state_data):
             """Update plot based on selection"""