Create app.py

app.py

@@ -0,0 +1,212 @@
+# Install required packages
+#!pip install gradio pandas numpy plotly scikit-learn matplotlib seaborn openpyxl
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.preprocessing import StandardScaler
+import io
+
+class DataVisualizationPlatform:
+    def __init__(self):
+        self.df = None
+        self.processed_df = None
+        self.scaler = StandardScaler()
+    
+    def load_and_update_columns(self, file):
+        """Load data and return column choices"""
+        try:
+            if file.name.endswith('.csv'):
+                self.df = pd.read_csv(file.name)
+            else:
+                self.df = pd.read_excel(file.name)
+            
+            columns = list(self.df.columns)
+            # Add "None" option for color column
+            columns_with_none = ["None"] + columns
+            
+            return {
+                "status": f"Data loaded successfully. Shape: {self.df.shape}",
+                "columns": columns,
+                "columns_with_none": columns_with_none
+            }
+        except Exception as e:
+            return {
+                "status": f"Error loading data: {str(e)}",
+                "columns": [],
+                "columns_with_none": ["None"]
+            }
+    
+    def preprocess_data(self):
+        """Preprocess the data"""
+        if self.df is None:
+            return "Please load data first"
+        
+        try:
+            # Handle missing values
+            self.processed_df = self.df.copy()
+            numeric_cols = self.df.select_dtypes(include=['float64', 'int64']).columns
+            self.processed_df[numeric_cols] = self.processed_df[numeric_cols].fillna(self.processed_df[numeric_cols].mean())
+            
+            # Scale numeric features
+            self.processed_df[numeric_cols] = self.scaler.fit_transform(self.processed_df[numeric_cols])
+            
+            return "Data preprocessing completed successfully"
+        except Exception as e:
+            return f"Error during preprocessing: {str(e)}"
+    
+    def generate_summary(self):
+        """Generate basic statistics and info about the dataset"""
+        if self.df is None:
+            return "Please load data first"
+        
+        try:
+            buffer = io.StringIO()
+            self.df.info(buf=buffer)
+            info_str = buffer.getvalue()
+            
+            summary = f"""
+            Dataset Summary:
+            ----------------
+            Shape: {self.df.shape}
+            
+            Data Info:
+            {info_str}
+            
+            Basic Statistics:
+            {self.df.describe().to_string()}
+            """
+            return summary
+        except Exception as e:
+            return f"Error generating summary: {str(e)}"
+    
+    def create_correlation_heatmap(self):
+        """Create correlation heatmap for numeric columns"""
+        if self.df is None:
+            return None
+        
+        try:
+            numeric_cols = self.df.select_dtypes(include=['float64', 'int64']).columns
+            if len(numeric_cols) == 0:
+                return None
+            
+            corr = self.df[numeric_cols].corr()
+            fig = px.imshow(corr,
+                           labels=dict(color="Correlation"),
+                           title="Correlation Heatmap")
+            return fig
+        except Exception as e:
+            print(f"Error creating heatmap: {str(e)}")
+            return None
+    
+    def create_scatter_plot(self, x_col, y_col, color_col):
+        """Create interactive scatter plot"""
+        if self.df is None or not x_col or not y_col:
+            return None
+        
+        try:
+            if color_col == "None":
+                color_col = None
+            
+            fig = px.scatter(self.df, x=x_col, y=y_col, color=color_col,
+                           title=f"Scatter Plot: {x_col} vs {y_col}")
+            return fig
+        except Exception as e:
+            print(f"Error creating scatter plot: {str(e)}")
+            return None
+    
+    def create_time_series(self, date_col, value_col):
+        """Create time series plot"""
+        if self.df is None or not date_col or not value_col:
+            return None
+        
+        try:
+            fig = px.line(self.df, x=date_col, y=value_col,
+                         title=f"Time Series: {value_col} over {date_col}")
+            return fig
+        except Exception as e:
+            print(f"Error creating time series: {str(e)}")
+            return None
+
+def create_visualization_interface():
+    dvp = DataVisualizationPlatform()
+    
+    with gr.Blocks(title="Data Visualization Platform") as interface:
+        gr.Markdown("# Interactive Data Visualization Platform")
+        
+        # Shared state for column choices
+        state = gr.State({
+            "columns": [],
+            "columns_with_none": ["None"]
+        })
+        
+        with gr.Tab("Data Loading & Preprocessing"):
+            file_input = gr.File(label="Upload CSV or Excel file")
+            load_btn = gr.Button("Load Data")
+            load_output = gr.Textbox(label="Loading Status")
+            preprocess_btn = gr.Button("Preprocess Data")
+            preprocess_output = gr.Textbox(label="Preprocessing Status")
+            summary_btn = gr.Button("Generate Summary")
+            summary_output = gr.Textbox(label="Data Summary", lines=10)
+        
+        with gr.Tab("Visualizations"):
+            with gr.Row():
+                with gr.Column():
+                    # Correlation Heatmap
+                    heatmap_btn = gr.Button("Generate Correlation Heatmap")
+                    heatmap_plot = gr.Plot(label="Correlation Heatmap")
+                
+                with gr.Column():
+                    # Scatter Plot
+                    x_col = gr.Dropdown(label="X Column", choices=[])
+                    y_col = gr.Dropdown(label="Y Column", choices=[])
+                    color_col = gr.Dropdown(label="Color Column (optional)", choices=["None"])
+                    scatter_btn = gr.Button("Generate Scatter Plot")
+                    scatter_plot = gr.Plot(label="Scatter Plot")
+            
+            with gr.Row():
+                # Time Series
+                date_col = gr.Dropdown(label="Date Column", choices=[])
+                value_col = gr.Dropdown(label="Value Column", choices=[])
+                timeseries_btn = gr.Button("Generate Time Series")
+                timeseries_plot = gr.Plot(label="Time Series Plot")
+        
+        def update_interface(file):
+            result = dvp.load_and_update_columns(file)
+            return {
+                load_output: result["status"],
+                x_col: gr.Dropdown(choices=result["columns"]),
+                y_col: gr.Dropdown(choices=result["columns"]),
+                color_col: gr.Dropdown(choices=result["columns_with_none"]),
+                date_col: gr.Dropdown(choices=result["columns"]),
+                value_col: gr.Dropdown(choices=result["columns"])
+            }
+        
+        # Event handlers
+        load_btn.click(
+            fn=update_interface,
+            inputs=[file_input],
+            outputs=[load_output, x_col, y_col, color_col, date_col, value_col]
+        )
+        
+        preprocess_btn.click(fn=dvp.preprocess_data, outputs=preprocess_output)
+        summary_btn.click(fn=dvp.generate_summary, outputs=summary_output)
+        heatmap_btn.click(fn=dvp.create_correlation_heatmap, outputs=heatmap_plot)
+        scatter_btn.click(
+            fn=dvp.create_scatter_plot,
+            inputs=[x_col, y_col, color_col],
+            outputs=scatter_plot
+        )
+        timeseries_btn.click(
+            fn=dvp.create_time_series,
+            inputs=[date_col, value_col],
+            outputs=timeseries_plot
+        )
+    
+    return interface
+
+# Launch the interface
+demo = create_visualization_interface()
+demo.launch()