Update app.py

app.py

@@ -1,26 +1,298 @@
-from dash import Dash, html, dcc, callback, Output, Input
+import gradio as gr
 import plotly.express as px
 import pandas as pd
-import os
-
-df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder_unfiltered.csv')
-app = Dash(__name__)
-server = app.server  # Important for deployment
-
-app.layout = [
-    html.H1(children='Title of Dash App', style={'textAlign':'center'}),
-    dcc.Dropdown(df.country.unique(), 'Canada', id='dropdown-selection'),
-    dcc.Graph(id='graph-content')
-]
-
-@callback(
-    Output('graph-content', 'figure'),
-    Input('dropdown-selection', 'value')
-)
-def update_graph(value):
-    dff = df[df.country==value]
-    return px.line(dff, x='year', y='pop')
-
-if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port, debug=False)
+import io
+
+# Store datasets in a dictionary (acts as our "database")
+datasets = {}
+
+# Load default dataset
+default_df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder_unfiltered.csv')
+datasets['Gapminder'] = default_df
+
+# Function to load different built-in datasets
+def load_builtin_dataset(dataset_name):
+    """Load various built-in datasets"""
+    try:
+        if dataset_name == "Gapminder":
+            df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder_unfiltered.csv')
+            datasets[dataset_name] = df
+            return df, f"✅ Loaded {dataset_name} dataset: {len(df)} rows, {len(df.columns)} columns"
+        
+        elif dataset_name == "Iris":
+            df = px.data.iris()
+            datasets[dataset_name] = df
+            return df, f"✅ Loaded {dataset_name} dataset: {len(df)} rows, {len(df.columns)} columns"
+        
+        elif dataset_name == "Tips":
+            df = px.data.tips()
+            datasets[dataset_name] = df
+            return df, f"✅ Loaded {dataset_name} dataset: {len(df)} rows, {len(df.columns)} columns"
+        
+        elif dataset_name == "Stock Data":
+            df = px.data.stocks()
+            # Reshape from wide to long format for better analysis
+            df = df.melt(id_vars='date', var_name='company', value_name='stock_price')
+            df['date'] = pd.to_datetime(df['date'])
+            datasets[dataset_name] = df
+            return df, f"✅ Loaded {dataset_name} dataset: {len(df)} rows, {len(df.columns)} columns"
+        
+        elif dataset_name == "Wind Data":
+            df = px.data.wind()
+            datasets[dataset_name] = df
+            return df, f"✅ Loaded {dataset_name} dataset: {len(df)} rows, {len(df.columns)} columns"
+            
+    except Exception as e:
+        return None, f"❌ Error loading {dataset_name}: {str(e)}"
+
+# Function to handle file uploads
+def upload_dataset(file, custom_name):
+    """Handle CSV/Excel file uploads"""
+    if file is None:
+        return None, "Please upload a file", gr.update(choices=list(datasets.keys()))
+    
+    try:
+        # Determine file type and read accordingly
+        if file.name.endswith('.csv'):
+            df = pd.read_csv(file.name)
+        elif file.name.endswith(('.xlsx', '.xls')):
+            df = pd.read_excel(file.name)
+        else:
+            return None, "❌ Unsupported file format. Please upload CSV or Excel.", gr.update()
+        
+        # Store with custom name or filename
+        dataset_name = custom_name if custom_name else file.name.split('/')[-1].split('.')[0]
+        datasets[dataset_name] = df
+        
+        return df, f"✅ Uploaded {dataset_name}: {len(df)} rows, {len(df.columns)} columns", gr.update(choices=list(datasets.keys()), value=dataset_name)
+        
+    except Exception as e:
+        return None, f"❌ Error reading file: {str(e)}", gr.update()
+
+# Function to switch between datasets
+def switch_dataset(dataset_name):
+    """Switch to a different dataset"""
+    if dataset_name in datasets:
+        df = datasets[dataset_name]
+        # Get column info
+        numeric_cols = df.select_dtypes(include=['number']).columns.tolist()
+        categorical_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
+        all_cols = df.columns.tolist()
+        
+        info = f"""
+        ### Dataset: {dataset_name}
+        - **Rows**: {len(df)}
+        - **Columns**: {len(df.columns)}
+        - **Numeric columns**: {', '.join(numeric_cols[:5])}{'...' if len(numeric_cols) > 5 else ''}
+        - **Categorical columns**: {', '.join(categorical_cols[:5])}{'...' if len(categorical_cols) > 5 else ''}
+        """
+        
+        return (
+            df.head(10),  # Preview
+            info,  # Info
+            gr.update(choices=all_cols, value=all_cols[0] if all_cols else None),  # X-axis
+            gr.update(choices=numeric_cols, value=numeric_cols[0] if numeric_cols else None),  # Y-axis
+            gr.update(choices=[""] + categorical_cols, value=""),  # Color
+            gr.update(choices=[""] + numeric_cols, value=""),  # Size
+            df  # Store current df
+        )
+    else:
+        return None, "Dataset not found", gr.update(), gr.update(), gr.update(), gr.update(), None
+
+# Dynamic plotting function
+def create_plot(df, plot_type, x_col, y_col, color_col, size_col):
+    """Create different plot types based on current dataset and selections"""
+    if df is None or x_col is None:
+        return None
+    
+    try:
+        # Handle empty string selections
+        color_col = None if color_col == "" else color_col
+        size_col = None if size_col == "" else size_col
+        
+        # Create different plot types
+        if plot_type == "Scatter":
+            fig = px.scatter(df, x=x_col, y=y_col, color=color_col, size=size_col,
+                           title=f"Scatter: {x_col} vs {y_col}")
+            
+        elif plot_type == "Line":
+            fig = px.line(df, x=x_col, y=y_col, color=color_col,
+                         title=f"Line: {x_col} vs {y_col}")
+            
+        elif plot_type == "Bar":
+            # For bar charts, aggregate if necessary
+            if color_col:
+                fig = px.bar(df, x=x_col, y=y_col, color=color_col,
+                           title=f"Bar: {x_col} vs {y_col}")
+            else:
+                fig = px.bar(df, x=x_col, y=y_col,
+                           title=f"Bar: {x_col} vs {y_col}")
+                
+        elif plot_type == "Histogram":
+            fig = px.histogram(df, x=x_col, color=color_col,
+                             title=f"Histogram of {x_col}")
+            
+        elif plot_type == "Box":
+            fig = px.box(df, x=x_col, y=y_col, color=color_col,
+                        title=f"Box plot: {x_col} vs {y_col}")
+            
+        elif plot_type == "Heatmap":
+            # Create correlation matrix for numeric columns
+            numeric_df = df.select_dtypes(include=['number'])
+            if len(numeric_df.columns) > 1:
+                corr = numeric_df.corr()
+                fig = px.imshow(corr, text_auto=True, title="Correlation Heatmap")
+            else:
+                return None
+        
+        fig.update_layout(height=500)
+        return fig
+        
+    except Exception as e:
+        print(f"Plot error: {e}")
+        return None
+
+# Create the Gradio interface
+with gr.Blocks(title="Dynamic Dataset Explorer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 📊 Dynamic Dataset Explorer
+    Upload your own data or explore built-in datasets with automatic visualization
+    """)
+    
+    # Hidden state to store current dataframe
+    current_df = gr.State(value=default_df)
+    
+    with gr.Tabs():
+        # Tab 1: Dataset Management
+        with gr.TabItem("📁 Dataset Management"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Load Built-in Dataset")
+                    builtin_choice = gr.Dropdown(
+                        choices=["Gapminder", "Iris", "Tips", "Stock Data", "Wind Data"],
+                        value="Gapminder",
+                        label="Select Dataset"
+                    )
+                    load_builtin_btn = gr.Button("Load Dataset", variant="primary")
+                    
+                    gr.Markdown("### Upload Custom Dataset")
+                    file_upload = gr.File(label="Upload CSV or Excel", file_types=[".csv", ".xlsx", ".xls"])
+                    custom_name = gr.Textbox(label="Dataset Name (optional)", placeholder="My Dataset")
+                    upload_btn = gr.Button("Upload", variant="primary")
+                    
+                    gr.Markdown("### Active Datasets")
+                    dataset_selector = gr.Dropdown(
+                        choices=list(datasets.keys()),
+                        value="Gapminder",
+                        label="Switch Dataset"
+                    )
+                
+                with gr.Column(scale=2):
+                    status_msg = gr.Markdown("Ready to load data")
+                    data_info = gr.Markdown()
+                    data_preview = gr.Dataframe(label="Data Preview (first 10 rows)")
+        
+        # Tab 2: Dynamic Visualization
+        with gr.TabItem("📈 Visualization"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    plot_type = gr.Radio(
+                        choices=["Scatter", "Line", "Bar", "Histogram", "Box", "Heatmap"],
+                        value="Scatter",
+                        label="Plot Type"
+                    )
+                    
+                    x_axis = gr.Dropdown(label="X Axis", choices=[], interactive=True)
+                    y_axis = gr.Dropdown(label="Y Axis", choices=[], interactive=True)
+                    color_by = gr.Dropdown(label="Color By (optional)", choices=[], interactive=True)
+                    size_by = gr.Dropdown(label="Size By (optional)", choices=[], interactive=True)
+                    
+                    plot_btn = gr.Button("Create Plot", variant="primary")
+                
+                with gr.Column(scale=2):
+                    plot_output = gr.Plot(label="Visualization")
+        
+        # Tab 3: Data Analysis
+        with gr.TabItem("🔍 Data Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    analysis_type = gr.Radio(
+                        choices=["Summary Statistics", "Missing Values", "Data Types", "Unique Values"],
+                        value="Summary Statistics",
+                        label="Analysis Type"
+                    )
+                    analyze_btn = gr.Button("Analyze", variant="primary")
+                
+                with gr.Column():
+                    analysis_output = gr.Markdown()
+            
+            def analyze_data(df, analysis_type):
+                """Perform different types of data analysis"""
+                if df is None:
+                    return "No dataset loaded"
+                
+                if analysis_type == "Summary Statistics":
+                    return f"```\n{df.describe().to_string()}\n```"
+                elif analysis_type == "Missing Values":
+                    missing = df.isnull().sum()
+                    return f"```\n{missing[missing > 0].to_string()}\n```" if missing.any() else "No missing values!"
+                elif analysis_type == "Data Types":
+                    return f"```\n{df.dtypes.to_string()}\n```"
+                elif analysis_type == "Unique Values":
+                    unique_counts = df.nunique()
+                    return f"```\n{unique_counts.to_string()}\n```"
+    
+    # Event handlers
+    load_builtin_btn.click(
+        load_builtin_dataset,
+        inputs=[builtin_choice],
+        outputs=[data_preview, status_msg]
+    ).then(
+        lambda: gr.update(choices=list(datasets.keys())),
+        outputs=[dataset_selector]
+    )
+    
+    upload_btn.click(
+        upload_dataset,
+        inputs=[file_upload, custom_name],
+        outputs=[data_preview, status_msg, dataset_selector]
+    )
+    
+    # When dataset is switched, update everything
+    dataset_selector.change(
+        switch_dataset,
+        inputs=[dataset_selector],
+        outputs=[data_preview, data_info, x_axis, y_axis, color_by, size_by, current_df]
+    )
+    
+    # Create plot based on selections
+    plot_btn.click(
+        create_plot,
+        inputs=[current_df, plot_type, x_axis, y_axis, color_by, size_by],
+        outputs=[plot_output]
+    )
+    
+    # Auto-update plot when parameters change
+    for component in [plot_type, x_axis, y_axis, color_by, size_by]:
+        component.change(
+            create_plot,
+            inputs=[current_df, plot_type, x_axis, y_axis, color_by, size_by],
+            outputs=[plot_output]
+        )
+    
+    # Analysis
+    analyze_btn.click(
+        analyze_data,
+        inputs=[current_df, analysis_type],
+        outputs=[analysis_output]
+    )
+    
+    # Load initial dataset
+    demo.load(
+        switch_dataset,
+        inputs=[dataset_selector],
+        outputs=[data_preview, data_info, x_axis, y_axis, color_by, size_by, current_df]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=False, debug=True)