fix: visualiztion refactor to matplotlib now working as intended

app.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 import gradio as gr
 import pandas as pd
-import plotly.graph_objects as go
+import matplotlib.figure as mpl_fig
 
 from data_processor import (
     DatasetBundle,
@@ -35,7 +35,6 @@ from visualizations import (
     create_distribution_plot,
     create_scatter_plot,
     create_time_series_plot,
-    figure_to_png_bytes,
 )
 
 
@@ -184,7 +183,7 @@ def _populate_column_options(
         dropdown(datetime_cols),  # date filter column
         gr.update(choices=[], value=[], visible=False, interactive=False),  # categorical values reset
         dropdown(categorical),    # categorical filter column
-        dropdown(datetime_cols, defaults.get("datetime")),  # time series date
+        dropdown(all_columns, defaults.get("datetime")),    # time series date
         dropdown(numeric, defaults.get("numeric")),         # time series value
         dropdown(numeric),        # distribution numeric
         dropdown(categorical),    # category column
@@ -328,7 +327,7 @@ def _generate_chart(
     scatter_x: Optional[str],
     scatter_y: Optional[str],
     scatter_color: Optional[str],
-) -> Tuple[Optional[go.Figure], Optional[go.Figure], str]:
+) -> Tuple[Optional[mpl_fig.Figure], Optional[mpl_fig.Figure], str]:
     """Create a visualization based on user selections."""
     state = _ensure_state(state)
     try:
@@ -376,7 +375,7 @@ def _download_filtered(state) -> str:
     return temp.name
 
 
-def _download_chart(fig: Optional[go.Figure]) -> str:
+def _download_chart(fig: Optional[mpl_fig.Figure]) -> str:
     """Export the most recent chart to PNG."""
     if fig is None:
         raise ValueError("Generate a visualization before exporting.")
@@ -521,8 +520,7 @@ def create_dashboard():
 
             generate_chart_button = gr.Button("Generate Visualization", variant="primary")
             chart_output = gr.Plot(label="Visualization")
-            download_chart_button = gr.Button("Download Chart as PNG", variant="secondary")
-            chart_file_output = gr.File(label="Chart PNG", interactive=False)
+
 
         with gr.Tab("Insights"):
             insights_status = gr.Markdown()
@@ -716,12 +714,7 @@ def create_dashboard():
             outputs=[last_figure_state, chart_output, viz_status],
         )
 
-        download_chart_button.click(
-            fn=_download_chart,
-            inputs=[last_figure_state],
-            outputs=[chart_file_output],
-        )
-
+       
         generate_insights_button.click(
             fn=_generate_insights,
             inputs=[

requirements.txt

@@ -1,7 +1,6 @@
 gradio==4.42.0
 pandas>=2.0,<3.0
-plotly>=5.18
-kaleido>=0.2.1
+matplotlib>=3.8.0
 numpy>=1.24
 openpyxl>=3.1
 huggingface_hub<0.25.0

utils.py

@@ -58,7 +58,7 @@ def coerce_datetime_columns(df: pd.DataFrame, threshold: float = 0.6) -> Tuple[p
         non_null_ratio = series.notna().mean()
         if non_null_ratio == 0 or non_null_ratio < threshold:
             continue
-        converted = pd.to_datetime(series, errors="coerce", utc=False, infer_datetime_format=True)
+        converted = pd.to_datetime(series, errors="coerce", utc=False)
         success_ratio = converted.notna().mean()
         if success_ratio >= threshold:
             df[col] = converted

visualizations.py

@@ -6,9 +6,14 @@ from abc import ABC, abstractmethod
 from io import BytesIO
 from typing import Any, Dict, Iterable, Optional
 
+import matplotlib
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
 import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
+import numpy as np
+
+# Use a non-interactive backend to avoid issues in some environments
+matplotlib.use('Agg')
 
 AGGREGATIONS = {
     "sum": "sum",
@@ -22,8 +27,8 @@ class VisualizationStrategy(ABC):
     """Abstract base class for visualization strategies."""
 
     @abstractmethod
-    def generate(self, df: pd.DataFrame, **kwargs: Any) -> go.Figure:
-        """Generate a Plotly figure from the provided dataframe and arguments."""
+    def generate(self, df: pd.DataFrame, **kwargs: Any) -> Figure:
+        """Generate a Matplotlib figure from the provided dataframe and arguments."""
         pass
 
     def validate_columns(self, df: pd.DataFrame, columns: Iterable[str]) -> None:
@@ -32,11 +37,17 @@ class VisualizationStrategy(ABC):
         if missing:
             raise ValueError(f"Column(s) not found in dataset: {', '.join(missing)}")
 
+    def _create_figure(self) -> Figure:
+        """Helper to create a standard figure with tight layout."""
+        fig = Figure(figsize=(10, 6))
+        fig.set_layout_engine("tight")
+        return fig
+
 
 class TimeSeriesStrategy(VisualizationStrategy):
     """Strategy for generating time-series plots."""
 
-    def generate(self, df: pd.DataFrame, **kwargs: Any) -> go.Figure:
+    def generate(self, df: pd.DataFrame, **kwargs: Any) -> Figure:
         date_column = kwargs.get("date_column")
         value_column = kwargs.get("value_column")
         aggregation = kwargs.get("aggregation", "sum")
@@ -53,21 +64,29 @@ class TimeSeriesStrategy(VisualizationStrategy):
         subset = df.loc[date_series.notna(), [date_column, value_column]].copy()
         subset[date_column] = pd.to_datetime(subset[date_column])
         grouped = subset.groupby(subset[date_column].dt.date)[value_column].agg(aggregation).reset_index()
+        
+        # Sort by date to ensure the line plot makes sense
+        grouped = grouped.sort_values(by=date_column)
 
-        fig = px.line(
-            grouped,
-            x=date_column,
-            y=value_column,
-            title=f"{value_column} over time ({aggregation})",
-        )
-        fig.update_layout(xaxis_title=date_column, yaxis_title=value_column)
+        fig = self._create_figure()
+        ax = fig.add_subplot(111)
+        
+        ax.plot(grouped[date_column], grouped[value_column], marker='o', linestyle='-')
+        ax.set_title(f"{value_column} over time ({aggregation})")
+        ax.set_xlabel(date_column)
+        ax.set_ylabel(value_column)
+        ax.grid(True, linestyle='--', alpha=0.7)
+        
+        # Rotate date labels for better readability
+        fig.autofmt_xdate()
+        
         return fig
 
 
 class DistributionStrategy(VisualizationStrategy):
     """Strategy for generating distribution plots (histogram/box)."""
 
-    def generate(self, df: pd.DataFrame, **kwargs: Any) -> go.Figure:
+    def generate(self, df: pd.DataFrame, **kwargs: Any) -> Figure:
         column = kwargs.get("column")
         plot_type = kwargs.get("plot_type", "histogram")
 
@@ -75,26 +94,34 @@ class DistributionStrategy(VisualizationStrategy):
             raise ValueError("Numeric column is required for Distribution plot.")
 
         self.validate_columns(df, [column])
+
+        # Convert column to numeric, dropping non-numeric values
         numeric_series = pd.to_numeric(df[column], errors="coerce").dropna()
         if numeric_series.empty:
             raise ValueError("Selected column does not contain numeric data.")
 
+        fig = self._create_figure()
+        ax = fig.add_subplot(111)
+
         if plot_type == "box":
-            fig = px.box(numeric_series, y=column, points="suspectedoutliers", title=f"Distribution of {column}")
+            ax.boxplot(numeric_series, vert=True, patch_artist=True)
+            ax.set_title(f"Distribution of {column}")
+            ax.set_ylabel(column)
+            ax.set_xticks([]) # Remove x-axis ticks for single boxplot
         else:
-            fig = px.histogram(
-                numeric_series,
-                nbins=30,
-                title=f"Distribution of {column}",
-            )
-            fig.update_layout(xaxis_title=column, yaxis_title="Frequency")
+            ax.hist(numeric_series, bins=30, edgecolor='black', alpha=0.7)
+            ax.set_title(f"Distribution of {column}")
+            ax.set_xlabel(column)
+            ax.set_ylabel("Frequency")
+            ax.grid(axis='y', linestyle='--', alpha=0.7)
+
         return fig
 
 
 class CategoryStrategy(VisualizationStrategy):
     """Strategy for generating categorical charts (bar/pie)."""
 
-    def generate(self, df: pd.DataFrame, **kwargs: Any) -> go.Figure:
+    def generate(self, df: pd.DataFrame, **kwargs: Any) -> Figure:
         category_column = kwargs.get("category_column")
         value_column = kwargs.get("value_column")
         aggregation = kwargs.get("aggregation", "sum")
@@ -114,11 +141,29 @@ class CategoryStrategy(VisualizationStrategy):
             .sort_values(by=value_column, ascending=False)
         )
 
+        fig = self._create_figure()
+        ax = fig.add_subplot(111)
+
         if chart_type == "pie":
-            fig = px.pie(grouped, names=category_column, values=value_column, title=f"{value_column} by {category_column}")
+            # Pie chart
+            wedges, texts, autotexts = ax.pie(
+                grouped[value_column], 
+                labels=grouped[category_column], 
+                autopct='%1.1f%%',
+                startangle=90
+            )
+            ax.set_title(f"{value_column} by {category_column}")
         else:
-            fig = px.bar(grouped, x=category_column, y=value_column, title=f"{value_column} by {category_column}")
-            fig.update_layout(xaxis_title=category_column, yaxis_title=f"{aggregation} of {value_column}")
+            # Bar chart
+            bars = ax.bar(grouped[category_column], grouped[value_column], alpha=0.7, edgecolor='black')
+            ax.set_title(f"{value_column} by {category_column}")
+            ax.set_xlabel(category_column)
+            ax.set_ylabel(f"{aggregation} of {value_column}")
+            ax.grid(axis='y', linestyle='--', alpha=0.7)
+            
+            # Rotate x labels if there are many categories
+            if len(grouped) > 5:
+                plt.setp(ax.get_xticklabels(), rotation=45, ha="right")
 
         return fig
 
@@ -126,7 +171,7 @@ class CategoryStrategy(VisualizationStrategy):
 class ScatterStrategy(VisualizationStrategy):
     """Strategy for generating scatter plots."""
 
-    def generate(self, df: pd.DataFrame, **kwargs: Any) -> go.Figure:
+    def generate(self, df: pd.DataFrame, **kwargs: Any) -> Figure:
         x_column = kwargs.get("x_column")
         y_column = kwargs.get("y_column")
         color_column = kwargs.get("color_column")
@@ -139,46 +184,100 @@ class ScatterStrategy(VisualizationStrategy):
             columns.append(color_column)
         self.validate_columns(df, columns)
 
-        fig = px.scatter(df, x=x_column, y=y_column, color=color_column, title=f"{y_column} vs {x_column}")
-        fig.update_layout(xaxis_title=x_column, yaxis_title=y_column)
+        # Convert X and Y columns to numeric where possible
+        x = pd.to_numeric(df[x_column], errors="coerce")
+        y = pd.to_numeric(df[y_column], errors="coerce")
+
+        valid_mask = ~(x.isna() | y.isna())
+        if valid_mask.sum() == 0:
+            raise ValueError("Scatter plot requires numeric data in both X and Y columns.")
+
+        plot_df = df.loc[valid_mask].copy()
+        plot_df[x_column] = x[valid_mask]
+        plot_df[y_column] = y[valid_mask]
+
+        fig = self._create_figure()
+        ax = fig.add_subplot(111)
+
+        if color_column:
+            # If color column is present, we need to map categories to colors
+            # or use a colormap if numeric
+            c_data = plot_df[color_column]
+            if pd.api.types.is_numeric_dtype(c_data):
+                sc = ax.scatter(plot_df[x_column], plot_df[y_column], c=c_data, cmap='viridis', alpha=0.7)
+                fig.colorbar(sc, ax=ax, label=color_column)
+            else:
+                # Categorical coloring
+                categories = c_data.unique()
+                colors = plt.cm.tab10(np.linspace(0, 1, len(categories)))
+                for cat, color in zip(categories, colors):
+                    mask = c_data == cat
+                    ax.scatter(plot_df.loc[mask, x_column], plot_df.loc[mask, y_column], label=str(cat), color=color, alpha=0.7)
+                ax.legend(title=color_column)
+        else:
+            ax.scatter(plot_df[x_column], plot_df[y_column], alpha=0.7)
+
+        ax.set_title(f"{y_column} vs {x_column}")
+        ax.set_xlabel(x_column)
+        ax.set_ylabel(y_column)
+        ax.grid(True, linestyle='--', alpha=0.7)
+
         return fig
 
 
 class CorrelationHeatmapStrategy(VisualizationStrategy):
     """Strategy for generating correlation heatmaps."""
 
-    def generate(self, df: pd.DataFrame, **kwargs: Any) -> go.Figure:
-        numeric_df = df.select_dtypes(include=["number"])
+    def generate(self, df: pd.DataFrame, **kwargs: Any) -> Figure:
+        numeric_df = df.select_dtypes(include=["number"]).copy()
         if numeric_df.shape[1] < 2:
             raise ValueError("At least two numeric columns are required for a correlation heatmap.")
 
+        # Drop rows that are completely NaN in numeric columns
+        numeric_df = numeric_df.dropna(how="all")
+        if numeric_df.empty:
+            raise ValueError("No valid numeric data available for correlation heatmap.")
+
         corr = numeric_df.corr()
-        fig = px.imshow(
-            corr,
-            text_auto=True,
-            title="Correlation Heatmap",
-            color_continuous_scale="RdBu",
-            aspect="auto",
-        )
+
+        fig = self._create_figure()
+        ax = fig.add_subplot(111)
+        
+        cax = ax.imshow(corr, cmap='RdBu', vmin=-1, vmax=1)
+        fig.colorbar(cax, ax=ax)
+        
+        # Set ticks
+        ax.set_xticks(range(len(corr.columns)))
+        ax.set_yticks(range(len(corr.columns)))
+        ax.set_xticklabels(corr.columns, rotation=45, ha="right")
+        ax.set_yticklabels(corr.columns)
+        
+        # Annotate values
+        for i in range(len(corr.columns)):
+            for j in range(len(corr.columns)):
+                text = ax.text(j, i, f"{corr.iloc[i, j]:.2f}",
+                               ha="center", va="center", color="black")
+                               
+        ax.set_title("Correlation Heatmap")
+
         return fig
 
 
-def figure_to_png_bytes(fig: go.Figure) -> BytesIO:
+def figure_to_png_bytes(fig: Figure) -> BytesIO:
     """Export the figure to an in-memory PNG buffer."""
-    try:
-        image_bytes = fig.to_image(format="png")
-    except ValueError as exc:  # pragma: no cover - fallback for environments without kaleido
-        raise ValueError("PNG export requires the 'kaleido' package. Please install it to enable downloads.") from exc
-    return BytesIO(image_bytes)
+    buf = BytesIO()
+    fig.savefig(buf, format="png")
+    buf.seek(0)
+    return buf
 
 
-def create_time_series_plot(df: pd.DataFrame, date_column: str, value_column: str, aggregation: str = "sum") -> go.Figure:
+def create_time_series_plot(df: pd.DataFrame, date_column: str, value_column: str, aggregation: str = "sum") -> Figure:
     """Generate a time-series plot using the TimeSeriesStrategy."""
     strategy = TimeSeriesStrategy()
     return strategy.generate(df, date_column=date_column, value_column=value_column, aggregation=aggregation)
 
 
-def create_distribution_plot(df: pd.DataFrame, column: str, plot_type: str = "histogram") -> go.Figure:
+def create_distribution_plot(df: pd.DataFrame, column: str, plot_type: str = "histogram") -> Figure:
     """Generate a distribution plot using the DistributionStrategy."""
     strategy = DistributionStrategy()
     return strategy.generate(df, column=column, plot_type=plot_type)
@@ -186,7 +285,7 @@ def create_distribution_plot(df: pd.DataFrame, column: str, plot_type: str = "hi
 
 def create_category_plot(
     df: pd.DataFrame, category_column: str, value_column: str, aggregation: str = "sum", chart_type: str = "bar"
-) -> go.Figure:
+) -> Figure:
     """Generate a category plot using the CategoryStrategy."""
     strategy = CategoryStrategy()
     return strategy.generate(
@@ -196,13 +295,13 @@ def create_category_plot(
 
 def create_scatter_plot(
     df: pd.DataFrame, x_column: str, y_column: str, color_column: Optional[str] = None
-) -> go.Figure:
+) -> Figure:
     """Generate a scatter plot using the ScatterStrategy."""
     strategy = ScatterStrategy()
     return strategy.generate(df, x_column=x_column, y_column=y_column, color_column=color_column)
 
 
-def create_correlation_heatmap(df: pd.DataFrame) -> go.Figure:
+def create_correlation_heatmap(df: pd.DataFrame) -> Figure:
     """Generate a correlation heatmap using the CorrelationHeatmapStrategy."""
     strategy = CorrelationHeatmapStrategy()
     return strategy.generate(df)