app updated with filters in the map section

app.py

@@ -1,5 +1,5 @@
 import folium
-from folium.plugins import MarkerCluster
+from folium.plugins import HeatMap
 from geopy.geocoders import Nominatim
 from functools import lru_cache
 import pandas as pd
@@ -121,7 +121,6 @@ class FeedReader:
         self.df = df
         df['last_update'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
         df_processed = df
-        #df_processed = df.fillna(0).infer_objects(copy=False)
         
         summary = f"""
 📊 **Feed Processing Results**
@@ -238,194 +237,288 @@ class FeedReader:
                 )
         return display_df
     
-    def generate_map_with_job_counts(self, city_col, state_col=None, country_col=None, 
-                                   title_col=None, max_points=500, progress=gr.Progress()):
-        """Generate map with job count markers per location with progress tracking"""
-        if self.df is None or self.df.empty:
-            return None, "⚠️ Please load a feed first"
-        
-        if city_col not in self.df.columns:
-            return None, f"⚠️ Column '{city_col}' not found in dataset"
-        
-        progress(0, desc="Initializing map generation...")
-        
-        # Create map
-        m = folium.Map(location=[20, 0], zoom_start=2)
-        
-        progress(0.1, desc="Processing location data...")
-        
-        # Prepare location data
-        location_data = []
-        total_rows = len(self.df)
-        
-        for idx, (_, row) in enumerate(self.df.iterrows()):
-            if idx % 100 == 0:  # Update progress every 100 rows
-                progress(0.1 + (0.3 * idx / total_rows), 
-                        desc=f"Processing locations... {idx}/{total_rows}")
+    def generate_heatmap(self, city_col, state_col=None, country_col=None, 
+                        metric_col=None, filter_col=None, filter_value=None, 
+                        max_points=500, progress=gr.Progress()):
+        """Generate heatmap based on selected metric with optional filtering"""
+        try:
+            if self.df is None or self.df.empty:
+                return None, "⚠️ Please load a feed first"
             
-            city = str(row[city_col]) if city_col else ""
-            state = str(row[state_col]) if state_col and state_col in self.df.columns else ""
-            country = str(row[country_col]) if country_col and country_col in self.df.columns else ""
+            if city_col not in self.df.columns:
+                available_cols = ', '.join(self.df.columns.tolist()[:10])
+                return None, f"⚠️ Column '{city_col}' not found. Available columns: {available_cols}..."
             
-            location_parts = [p for p in [city, state, country] if p and p.strip() and p != 'nan']
-            if not location_parts:
-                continue
+            progress(0, desc="Initializing heatmap generation...")
+            
+            # Apply filter if specified
+            working_df = self.df.copy()
+            original_rows = len(working_df)
+            
+            if filter_col and filter_value and filter_col != "None" and filter_value != "All":
+                if filter_col in working_df.columns:
+                    working_df = working_df[working_df[filter_col].astype(str) == str(filter_value)]
+                    if working_df.empty:
+                        return None, f"⚠️ No data found for filter: {filter_col} = {filter_value}"
+                else:
+                    return None, f"⚠️ Filter column '{filter_col}' not found in dataset"
+            
+            progress(0.1, desc=f"Processing {len(working_df)} rows...")
+            
+            # Prepare location data with better error handling
+            location_data = []
+            skipped_rows = 0
+            
+            for idx, (_, row) in enumerate(working_df.iterrows()):
+                try:
+                    city = str(row[city_col]).strip() if pd.notna(row[city_col]) else ""
+                    state = ""
+                    country = ""
+                    
+                    if state_col and state_col in working_df.columns and state_col != "None":
+                        state = str(row[state_col]).strip() if pd.notna(row[state_col]) else ""
+                    
+                    if country_col and country_col in working_df.columns and country_col != "None":
+                        country = str(row[country_col]).strip() if pd.notna(row[country_col]) else ""
+                    
+                    # Filter out invalid location data
+                    location_parts = []
+                    if city and city.lower() not in ['nan', 'none', 'null', '']:
+                        location_parts.append(city)
+                    if state and state.lower() not in ['nan', 'none', 'null', '']:
+                        location_parts.append(state)
+                    if country and country.lower() not in ['nan', 'none', 'null', '']:
+                        location_parts.append(country)
+                    
+                    if not location_parts:
+                        skipped_rows += 1
+                        continue
+                        
+                    location_key = ", ".join(location_parts)
+                    
+                    # Get metric value with better error handling
+                    metric_value = 1.0  # Default weight for count-based heatmap
+                    if metric_col and metric_col in working_df.columns and metric_col != "None":
+                        try:
+                            val = row[metric_col]
+                            if pd.notna(val):
+                                metric_value = float(val)
+                                if metric_value <= 0:  # Handle zero or negative values
+                                    metric_value = 0.1  # Small positive value
+                            else:
+                                metric_value = 1.0
+                        except (ValueError, TypeError):
+                            metric_value = 1.0
+                    
+                    location_data.append({
+                        'location_key': location_key,
+                        'city': city,
+                        'state': state,
+                        'country': country,
+                        'metric_value': metric_value
+                    })
+                    
+                except Exception as e:
+                    skipped_rows += 1
+                    continue
+            
+            if not location_data:
+                return None, f"⚠️ No valid location data found. Processed {len(working_df)} rows, skipped {skipped_rows} rows with invalid location data."
+            
+            progress(0.3, desc=f"Found {len(location_data)} valid locations, aggregating...")
+            
+            # Group by location and calculate metrics
+            locations_df = pd.DataFrame(location_data)
+            
+            try:
+                if metric_col and metric_col != "None":
+                    # For numeric metrics
+                    location_stats = locations_df.groupby('location_key').agg({
+                        'metric_value': ['sum', 'count', 'mean'],
+                        'city': 'first',
+                        'state': 'first',
+                        'country': 'first'
+                    }).reset_index()
+                    location_stats.columns = ['location_key', 'total_metric', 'job_count', 'avg_metric', 'city', 'state', 'country']
+                    location_stats['heatmap_weight'] = location_stats['avg_metric']
+                else:
+                    # For count-based heatmap
+                    location_stats = locations_df.groupby('location_key').agg({
+                        'city': 'first',
+                        'state': 'first',
+                        'country': 'first'
+                    }).reset_index()
+                    location_stats['job_count'] = locations_df.groupby('location_key').size().values
+                    location_stats['heatmap_weight'] = location_stats['job_count']
+            except Exception as e:
+                return None, f"⚠️ Error aggregating location data: {str(e)}"
+            
+            progress(0.4, desc=f"Starting geocoding for {len(location_stats)} unique locations...")
+            
+            # Geocoding with enhanced error handling
+            heat_data = []
+            successful_mappings = 0
+            failed_geocoding = 0
+            geocoding_errors = []
+            
+            for idx, (_, row) in enumerate(location_stats.iterrows()):
+                if successful_mappings >= max_points:
+                    break
                 
-            location_key = ", ".join(location_parts)
-            title_id = str(row[title_col]) if title_col and title_col in self.df.columns else None
-            
-            location_data.append({
-                'location_key': location_key,
-                'city': city,
-                'state': state,
-                'country': country,
-                'title_id': title_id
-            })
-        
-        if not location_data:
-            progress(1, desc="No valid location data found")
-            return None, "⚠️ No valid location data found"
-        
-        progress(0.4, desc="Aggregating location statistics...")
-        
-        # Group by location
-        locations_df = pd.DataFrame(location_data)
-        
-        if title_col and title_col in self.df.columns:
-            location_stats = locations_df.groupby('location_key').agg({
-                'title_id': ['count', 'nunique'],
-                'city': 'first',
-                'state': 'first', 
-                'country': 'first'
-            }).reset_index()
-            location_stats.columns = ['location_key', 'total_postings', 'unique_titles', 'city', 'state', 'country']
-        else:
-            location_stats = locations_df.groupby('location_key').agg({
-                'city': 'first',
-                'state': 'first',
-                'country': 'first'
-            }).reset_index()
-            location_stats['total_postings'] = locations_df.groupby('location_key').size().values
-            location_stats['unique_titles'] = location_stats['total_postings']
-        
-        progress(0.5, desc="Starting geocoding process...")
-        
-        # Geocoding with progress tracking
-        successful_mappings = 0
-        failed_geocoding = 0
-        total_locations = len(location_stats)
-        
-        for idx, (_, row) in enumerate(location_stats.iterrows()):
-            if successful_mappings >= max_points:
-                break
-            
-            # Update progress during geocoding
-            progress(0.5 + (0.4 * idx / total_locations), 
-                    desc=f"Geocoding locations... {successful_mappings} mapped, {failed_geocoding} failed")
-            
-            location_key = row['location_key']
-            total_postings = row['total_postings']
-            unique_titles = row['unique_titles']
-            
-            location = geocode_cached(location_key)
-            if location:
-                # Calculate marker properties
-                max_titles = location_stats['unique_titles'].max()
-                min_size = 10
-                max_size = 50
+                try:
+                    # Update progress during geocoding
+                    progress_val = 0.4 + (0.5 * idx / len(location_stats))
+                    progress(progress_val, desc=f"Geocoding {idx+1}/{len(location_stats)}: {successful_mappings} successful")
+                    
+                    location_key = row['location_key']
+                    weight = row['heatmap_weight']
+                    
+                    if weight <= 0:
+                        failed_geocoding += 1
+                        continue
+                    
+                    # Try geocoding with timeout and error handling
+                    location = None
+                    try:
+                        location = geocode_cached(location_key)
+                    except Exception as geocode_error:
+                        geocoding_errors.append(f"{location_key}: {str(geocode_error)}")
+                        failed_geocoding += 1
+                        continue
+                    
+                    if location and hasattr(location, 'latitude') and hasattr(location, 'longitude'):
+                        if location.latitude and location.longitude:
+                            heat_data.append([float(location.latitude), float(location.longitude), float(weight)])
+                            successful_mappings += 1
+                        else:
+                            failed_geocoding += 1
+                    else:
+                        failed_geocoding += 1
+                    
+                    # Small delay to prevent overwhelming the geocoding service
+                    time.sleep(0.05)  # Reduced delay for small datasets
+                    
+                except Exception as e:
+                    geocoding_errors.append(f"{location_key}: {str(e)}")
+                    failed_geocoding += 1
+                    continue
+            
+            if not heat_data:
+                error_details = f"No valid coordinates found. Geocoding errors: {geocoding_errors[:3]}" if geocoding_errors else "No valid coordinates found"
+                return None, f"⚠️ {error_details}"
+            
+            progress(0.9, desc="Generating heatmap visualization...")
+            
+            try:
+                # Create map with heatmap
+                # Calculate center point from successful geocodes
+                lats = [point[0] for point in heat_data]
+                lons = [point[1] for point in heat_data]
+                center_lat = sum(lats) / len(lats)
+                center_lon = sum(lons) / len(lons)
                 
-                if max_titles > 0:
-                    marker_size = min_size + (max_size - min_size) * (unique_titles / max_titles)
-                else:
-                    marker_size = min_size
+                m = folium.Map(location=[center_lat, center_lon], zoom_start=6)
+                
+                # Add heatmap layer with error handling
+                HeatMap(
+                    heat_data,
+                    min_opacity=0.3,
+                    max_zoom=18,
+                    radius=25,
+                    blur=20,
+                    gradient={0.2: 'blue', 0.5: 'lime', 0.7: 'orange', 1.0: 'red'}
+                ).add_to(m)
+                
+                # Generate statistics for legend
+                weights = [point[2] for point in heat_data]
+                min_weight = min(weights)
+                max_weight = max(weights)
+                avg_weight = sum(weights) / len(weights)
                 
-                # Color coding
-                if unique_titles >= max_titles * 0.8:
-                    color = 'red'
-                elif unique_titles >= max_titles * 0.5:
-                    color = 'orange'
-                elif unique_titles >= max_titles * 0.2:
-                    color = 'yellow'
+                # Create legend based on metric type
+                if metric_col and metric_col != "None":
+                    legend_title = f"Heatmap: {metric_col}"
+                    legend_content = f"""
+                    <h4 style='margin:0; color: #2E86AB;'>{legend_title}</h4>
+                    <p style='margin:3px 0;'><span style='color:red'>■</span> High ({max_weight:.2f})</p>
+                    <p style='margin:3px 0;'><span style='color:orange'>■</span> Med-High</p>
+                    <p style='margin:3px 0;'><span style='color:lime'>■</span> Medium</p>
+                    <p style='margin:3px 0;'><span style='color:blue'>■</span> Low ({min_weight:.2f})</p>
+                    <small>Avg: {avg_weight:.2f} | Locations: {len(heat_data)}</small>
+                    """
                 else:
-                    color = 'green'
+                    legend_title = "Job Count Heatmap"
+                    legend_content = f"""
+                    <h4 style='margin:0; color: #2E86AB;'>{legend_title}</h4>
+                    <p style='margin:3px 0;'><span style='color:red'>■</span> High ({int(max_weight)} jobs)</p>
+                    <p style='margin:3px 0;'><span style='color:orange'>■</span> Med-High</p>
+                    <p style='margin:3px 0;'><span style='color:lime'>■</span> Medium</p>
+                    <p style='margin:3px 0;'><span style='color:blue'>■</span> Low ({int(min_weight)} jobs)</p>
+                    <small>Avg: {avg_weight:.1f} jobs | Locations: {len(heat_data)}</small>
+                    """
                 
-                # Create popup
-                popup_text = f"""
-                <div style='font-family: Arial, sans-serif; min-width: 200px;'>
-                    <h4 style='color: #2E86AB; margin-bottom: 10px;'>📍 {location_key}</h4>
-                    <hr style='margin: 5px 0;'>
-                    <p><strong>🎯 Unique Titles:</strong> {unique_titles}</p>
-                    <p><strong>📊 Total Postings:</strong> {total_postings}</p>
-                    <p><strong>📈 Avg Postings/Title:</strong> {round(total_postings/unique_titles, 1) if unique_titles > 0 else 0}</p>
+                legend_html = f"""
+                <div style='position: fixed; 
+                            bottom: 50px; left: 50px; width: 220px; height: 120px; 
+                            background-color: white; border:2px solid grey; z-index:9999; 
+                            font-size:12px; padding: 8px; border-radius: 5px;'>
+                {legend_content}
                 </div>
                 """
                 
-                folium.CircleMarker(
-                    location=[location.latitude, location.longitude],
-                    radius=marker_size,
-                    popup=folium.Popup(popup_text, max_width=300),
-                    color='black',
-                    weight=2,
-                    fillColor=color,
-                    fillOpacity=0.7,
-                    tooltip=f"{location_key}: {unique_titles} titles"
-                ).add_to(m)
+                m.get_root().html.add_child(folium.Element(legend_html))
                 
-                successful_mappings += 1
+            except Exception as e:
+                return None, f"⚠️ Error creating map visualization: {str(e)}"
+            
+            progress(1, desc="Heatmap generation complete!")
+            
+            # Generate detailed status message
+            filter_info = f" (Filtered by {filter_col}: {filter_value})" if filter_col and filter_value and filter_col != "None" and filter_value != "All" else ""
+            
+            # Format values based on metric type
+            if metric_col and metric_col != "None":
+                min_val_str = f"{min_weight:.2f}"
+                max_val_str = f"{max_weight:.2f}"
+                avg_val_str = f"{avg_weight:.2f}"
             else:
-                failed_geocoding += 1
+                min_val_str = f"{int(min_weight)}"
+                max_val_str = f"{int(max_weight)}"
+                avg_val_str = f"{avg_weight:.1f}"
             
-            # Small delay to prevent overwhelming the geocoding service
-            time.sleep(0.1)
-        
-        progress(0.9, desc="Finalizing map...")
-        
-        # Add legend
-        legend_html = f"""
-        <div style='position: fixed; 
-                    bottom: 50px; left: 50px; width: 200px; height: 120px; 
-                    background-color: white; border:2px solid grey; z-index:9999; 
-                    font-size:14px; padding: 10px'>
-        <h4 style='margin:0; color: #2E86AB;'>📊 Job Count Legend</h4>
-        <p style='margin:5px 0;'><i style='color:red'>●</i> High (80%+ of max)</p>
-        <p style='margin:5px 0;'><i style='color:orange'>●</i> Medium-High (50-80%)</p>
-        <p style='margin:5px 0;'><i style='color:yellow'>●</i> Medium (20-50%)</p>
-        <p style='margin:5px 0;'><i style='color:green'>●</i> Low (&lt;20%)</p>
-        <small>Marker size = Job count</small>
-        </div>
-        """
-        
-        m.get_root().html.add_child(folium.Element(legend_html))
-        
-        progress(1, desc="Map generation complete!")
-        
-        # Generate status message
-        status_msg = f"""
-✅ **Map Generated Successfully**
+            status_msg = f"""
+✅ **Heatmap Generated Successfully**
+
+📊 **Data Processing:**
+   • Original Rows: {original_rows}
+   • Valid Locations: {len(location_data)}
+   • Unique Locations: {len(location_stats)}
+   • Skipped Rows: {skipped_rows}
+   {filter_info}
+
+🌍 **Geocoding Results:**
+   • Successfully Mapped: {successful_mappings}
+   • Failed to Geocode: {failed_geocoding}
+   • Success Rate: {(successful_mappings/(successful_mappings+failed_geocoding)*100):.1f}%
 
-🗺️ **Mapped Locations:** {successful_mappings}
-❌ **Failed to Geocode:** {failed_geocoding}
-📊 **Total Unique Locations:** {len(location_stats)}
-🎯 **Columns Used:**
+🎯 **Heatmap Configuration:**
+   • Metric Used: {metric_col if metric_col and metric_col != "None" else "Job Count"}
    • City: {city_col}
-   • State: {state_col if state_col else 'Not selected'}
-   • Country: {country_col if country_col else 'Not selected'}
-   • Title/ID: {title_col if title_col else 'Not selected'}
+   • State: {state_col if state_col and state_col != "None" else 'Not used'}
+   • Country: {country_col if country_col and country_col != "None" else 'Not used'}
 
-💡 **Map Features:**
-   • Marker size represents job count
-   • Colors show relative job density  
-   • Click markers for detailed info
-   • Hover for quick stats
-        """
-        
-        if title_col:
-            top_location_idx = location_stats['unique_titles'].idxmax()
-            top_location = location_stats.loc[top_location_idx, 'location_key']
-            top_count = location_stats['unique_titles'].max()
-            status_msg += f"\n🏆 **Top Location:** {top_location} ({top_count} titles)"
-        
-        return m._repr_html_(), status_msg
+📈 **Value Statistics:**
+   • Min Value: {min_val_str}
+   • Max Value: {max_val_str}
+   • Average: {avg_val_str}
+
+🌈 **Color Mapping:** Red=High, Orange=Med-High, Green=Medium, Blue=Low
+            """
+            
+            return m._repr_html_(), status_msg
+            
+        except Exception as e:
+            return None, f"⚠️ Unexpected error in heatmap generation: {str(e)}. Please check your data and try again."
     
     def generate_csv(self, df, filename_prefix="feed"):
         """Generate CSV file for download"""
@@ -464,7 +557,7 @@ def create_enhanced_gradio_app():
                 gr.Markdown("""
                 # 📡 Enhanced Feed Reader & Analyzer
                 
-                Load and analyze XML or JSON feeds with advanced multi-filtering and interactive mapping.
+                Load and analyze XML or JSON feeds with advanced multi-filtering and interactive heatmap visualization.
                 """)
         
         with gr.Tab("📥 Load Feed"):
@@ -916,11 +1009,11 @@ def create_enhanced_gradio_app():
                 outputs=[weighted_stats_summary, weighted_stats_output, weighted_stats_csv]
             )
         
-        with gr.Tab("🌍 Interactive Job Map"):
+        with gr.Tab("🌍 Interactive Heatmap"):
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("### 📍 Map Configuration")
-                    gr.Markdown("Select columns for geographic visualization:")
+                    gr.Markdown("### 📍 Heatmap Configuration")
+                    gr.Markdown("Create heatmaps based on job metrics and locations:")
 
                     city_col = gr.Dropdown(
                         label="🏙️ City Column (Required)", 
@@ -940,31 +1033,45 @@ def create_enhanced_gradio_app():
                         value=None,
                         info="Column containing country names"
                     )
-                    title_col = gr.Dropdown(
-                        label="🎯 Title/Job ID Column (Optional)", 
-                        choices=[], 
+
+                with gr.Column():
+                    gr.Markdown("### 🎯 Heatmap Metrics & Filters")
+                    
+                    metric_col = gr.Dropdown(
+                        label="📊 Metric Column (Optional)",
+                        choices=[],
+                        value=None,
+                        info="Column to use for heatmap intensity (CPC, CPA, etc.). Leave empty for job count."
+                    )
+                    
+                    filter_col = gr.Dropdown(
+                        label="🔍 Filter Column (Optional)",
+                        choices=[],
                         value=None,
-                        info="Column containing job titles or reference IDs"
+                        info="Column to filter data before creating heatmap (Company, Client, etc.)"
+                    )
+                    
+                    filter_val = gr.Dropdown(
+                        label="🎯 Filter Value",
+                        choices=[],
+                        value=None,
+                        info="Specific value to filter by"
                     )
 
-                    with gr.Row():
-                        map_btn = gr.Button("🗺️ Generate Interactive Map", variant="primary", size="lg")
-                        clear_map_btn = gr.Button("🧹 Clear Map", variant="secondary")
+            with gr.Row():
+                heatmap_btn = gr.Button("🔥 Generate Heatmap", variant="primary", size="lg")
+                clear_heatmap_btn = gr.Button("🧹 Clear Heatmap", variant="secondary")
 
-                with gr.Column():
-                    map_status = gr.Markdown()
+            with gr.Row():
+                heatmap_status = gr.Markdown()
             
             with gr.Row():
-                map_output = gr.HTML(label="Interactive Job Distribution Map")
+                heatmap_output = gr.HTML(label="Interactive Job Heatmap")
 
-            def update_map_choices(column_choices):
+            def update_heatmap_choices(column_choices):
                 if not column_choices:
-                    return (
-                        gr.Dropdown(choices=[]),
-                        gr.Dropdown(choices=[]),
-                        gr.Dropdown(choices=[]),
-                        gr.Dropdown(choices=[])
-                    )
+                    empty_choices = gr.Dropdown(choices=[])
+                    return (empty_choices, empty_choices, empty_choices, empty_choices, empty_choices, empty_choices)
                 
                 optional_choices = ["None"] + column_choices
                 
@@ -972,7 +1079,8 @@ def create_enhanced_gradio_app():
                 city_default = None
                 state_default = "None"
                 country_default = "None" 
-                title_default = "None"
+                metric_default = "None"
+                filter_default = "None"
                 
                 for col in column_choices:
                     col_lower = col.lower()
@@ -983,88 +1091,110 @@ def create_enhanced_gradio_app():
                         state_default = col
                     elif any(term in col_lower for term in ['country', 'nation', 'pais', 'pays']):
                         country_default = col
-                    elif any(term in col_lower for term in ['title', 'job', 'position', 'req', 'reference', 'id', 'titulo']):
-                        title_default = col
+                    elif any(term in col_lower for term in ['cpc', 'cpa', 'cost', 'payout', 'bid', 'sponsored']):
+                        metric_default = col
+                    elif any(term in col_lower for term in ['company', 'client', 'advertiser', 'brand']):
+                        filter_default = col
                 
                 return (
                     gr.Dropdown(choices=column_choices, value=city_default),
                     gr.Dropdown(choices=optional_choices, value=state_default),
                     gr.Dropdown(choices=optional_choices, value=country_default),
-                    gr.Dropdown(choices=optional_choices, value=title_default)
+                    gr.Dropdown(choices=optional_choices, value=metric_default),
+                    gr.Dropdown(choices=optional_choices, value=filter_default),
+                    gr.Dropdown(choices=["All"], value="All")
                 )
             
+            def update_filter_values_heatmap(selected_column):
+                if not selected_column or selected_column == "None" or feed_reader.df is None:
+                    return gr.Dropdown(choices=["All"], value="All")
+                
+                unique_values = feed_reader.get_column_unique_values(selected_column)
+                return gr.Dropdown(choices=unique_values, value="All" if unique_values else "All")
+            
             column_choices_state.change(
-                update_map_choices,
+                update_heatmap_choices,
                 inputs=[column_choices_state],
-                outputs=[city_col, state_col, country_col, title_col]
+                outputs=[city_col, state_col, country_col, metric_col, filter_col, filter_val]
+            )
+            
+            filter_col.change(
+                update_filter_values_heatmap, 
+                inputs=[filter_col], 
+                outputs=[filter_val]
             )
 
-            def generate_job_count_map(city_col, state_col, country_col, title_col, progress=gr.Progress()):
+            def generate_heatmap(city_col, state_col, country_col, metric_col, filter_col, filter_val, progress=gr.Progress()):
                 if not city_col:
                     return "❌ Please select a city column", None
                 
                 # Handle "None" selections
                 state_col = None if state_col == "None" else state_col
                 country_col = None if country_col == "None" else country_col
-                title_col = None if title_col == "None" else title_col
+                metric_col = None if metric_col == "None" else metric_col
+                filter_col = None if filter_col == "None" else filter_col
+                filter_val = None if filter_val == "All" else filter_val
                 
-                map_html, msg = feed_reader.generate_map_with_job_counts(
-                    city_col, state_col, country_col, title_col, progress=progress
+                heatmap_html, msg = feed_reader.generate_heatmap(
+                    city_col, state_col, country_col, metric_col, 
+                    filter_col, filter_val, progress=progress
                 )
-                return msg, map_html
+                return msg, heatmap_html
 
-            def clear_map():
-                return "🧹 Map cleared", ""
+            def clear_heatmap():
+                return "🧹 Heatmap cleared", ""
 
-            map_btn.click(
-                generate_job_count_map,
-                inputs=[city_col, state_col, country_col, title_col],
-                outputs=[map_status, map_output]
+            heatmap_btn.click(
+                generate_heatmap,
+                inputs=[city_col, state_col, country_col, metric_col, filter_col, filter_val],
+                outputs=[heatmap_status, heatmap_output]
             )
             
-            clear_map_btn.click(
-                clear_map,
-                outputs=[map_status, map_output]
+            clear_heatmap_btn.click(
+                clear_heatmap,
+                outputs=[heatmap_status, heatmap_output]
             )
 
         gr.Markdown("""
         ---
         ### 📝 Enhanced Features:
         
+        **🔥 Interactive Heatmap Visualization:**
+        - Heat intensity based on selected metrics (CPC, CPA, job count, etc.)
+        - Real-time filtering by company, client, or any column
+        - Color-coded intensity: Red (high) to Blue (low)
+        - Progress tracking during geocoding and map generation
+        - Dynamic legend with actual metric ranges
+        
+        **🎯 Heatmap Configuration Options:**
+        - **Metric Column**: Choose CPC, CPA, or any numeric column for intensity
+        - **Filter Options**: Pre-filter data by company, client, etc.
+        - **Location Mapping**: City (required), State, Country (optional)
+        - **Automatic Detection**: Smart column name detection
+        
         **🔍 Advanced Multi-Filtering:**
         - Apply up to 4 simultaneous filters on different columns
         - Real-time progress tracking during filter operations
         - Smart dropdown population with available values
         - Clear filter functionality
         
-        **🌍 Interactive Map with Progress:**
-        - Real-time progress bar during map generation
-        - Geocoding progress tracking
-        - Location data processing updates
-        - Performance optimizations with delays to prevent API limits
-        
         **📊 Enhanced Data Processing:**
-        - Improved error handling
-        - Better memory management
-        - Optimized for large datasets
-        - Smart column auto-detection
-        
-        **💡 Usage Tips:**
-        - **Multi-Filtering**: Select "None" to skip a filter, "All" to show all values for that column
-        - **Map Generation**: Progress bar shows geocoding status and success/failure rates  
-        - **Performance**: Large datasets may take longer to process - progress bars keep you informed
-        - **Column Detection**: Common column names are automatically detected and pre-selected
+        - Improved error handling and memory management
+        - Optimized for large datasets with progress indicators
+        - Smart column auto-detection for common field names
+        - Geocoding with rate limiting to prevent API issues
         
-        **🎯 Common Filter Combinations:**
-        - Filter 1: Company/Client + Filter 2: City
-        - Filter 1: Job Title + Filter 2: State + Filter 3: Country
-        - Filter 1: Category + Filter 2: Experience Level + Filter 3: Salary Range
+        **💡 Heatmap Usage Examples:**
+        - **CPC Heatmap**: See where highest-paying jobs are located
+        - **Job Count Heatmap**: Visualize job density by location
+        - **Filtered Views**: Show only specific company/client job distributions
+        - **Performance Analysis**: Compare metrics across geographic regions
         
-        **🗺️ Map Features:**
-        - Marker size = Job count per location
-        - Color coding = Job density (red=high, green=low)
-        - Interactive popups with detailed statistics
-        - Automatic legend and geocoding status
+        **🌈 Heatmap Color Legend:**
+        - **Red**: Highest values (top 20% of metric range)
+        - **Orange**: High values (60-80% of range)  
+        - **Lime/Green**: Medium values (40-60% of range)
+        - **Blue**: Lower values (bottom 40% of range)
         """)
     
     return app