Update app.py

app.py

@@ -12,14 +12,36 @@ import os
 import json
 import requests
 import re
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import torch
 import openai
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+import base64
+from io import BytesIO
 
 # Set plot styling
 sns.set(style="whitegrid")
 plt.rcParams["figure.figsize"] = (10, 6)
 
+# Global variables for API keys and AI models
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
+data_assistant = None
+
+def set_openai_key(api_key):
+    """Set the OpenAI API key."""
+    global OPENAI_API_KEY
+    OPENAI_API_KEY = api_key
+    openai.api_key = api_key
+    return "OpenAI API key set successfully!"
+
+def set_hf_token(api_token):
+    """Set the Hugging Face API token."""
+    global HF_API_TOKEN, data_assistant
+    HF_API_TOKEN = api_token
+    os.environ["TRANSFORMERS_TOKEN"] = api_token
+    data_assistant = initialize_ai_models()
+    return "Hugging Face token set successfully!"
+
 # Initialize AI Models
 def initialize_ai_models():
     """Initialize the AI models for data analysis."""
@@ -28,52 +50,86 @@ def initialize_ai_models():
     
     # Initialize Hugging Face model for data recommendations
     try:
-        tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-base")
-        model = AutoModelForCausalLM.from_pretrained("google/flan-t5-base")
+        tokenizer = AutoTokenizer.from_pretrained("distilgpt2")
+        model = AutoModelForCausalLM.from_pretrained("distilgpt2")
         data_assistant = pipeline("text-generation", model=model, tokenizer=tokenizer)
-    except:
+    except Exception as e:
+        print(f"Error loading model: {e}")
         # Fallback to a smaller model if the main one fails to load
-        data_assistant = pipeline("text-generation", model="distilgpt2")
+        try:
+            data_assistant = pipeline("text-generation", model="distilgpt2")
+        except:
+            data_assistant = None
     
     return data_assistant
 
-# Global variables for AI models
-data_assistant = None
-
 def read_file(file):
-    """Read different file formats into a pandas DataFrame."""
+    """Read different file formats into a pandas DataFrame with robust separator detection."""
     if file is None:
         return None
     
     file_name = file.name if hasattr(file, 'name') else ''
+    print(f"Reading file: {file_name}")
     
     try:
         # Handle different file types
         if file_name.endswith('.csv'):
-            # For wine quality dataset which uses semicolons
-            if "winequality" in file_name.lower():
-                return pd.read_csv(file, sep=';')
-            else:
-                # Try standard comma separator first
+            # First try with comma
+            try:
+                df = pd.read_csv(file)
+                
+                # Check if we got only one column but it contains semicolons
+                if len(df.columns) == 1 and ';' in str(df.columns[0]):
+                    print("Detected potential semicolon-separated file")
+                    # Reset file position
+                    file.seek(0)
+                    # Try with semicolon
+                    df = pd.read_csv(file, sep=';')
+                    print(f"Read file with semicolon separator: {df.shape}")
+                else:
+                    print(f"Read file with comma separator: {df.shape}")
+                
+                # Convert columns to appropriate types
+                for col in df.columns:
+                    # Try to convert string columns to numeric
+                    if df[col].dtype == 'object':
+                        df[col] = pd.to_numeric(df[col], errors='ignore')
+                
+                return df
+            except Exception as e:
+                print(f"Error with standard separators: {e}")
+                # Try with semicolon
+                file.seek(0)
                 try:
-                    df = pd.read_csv(file)
-                    # If we got only one column but it contains semicolons, try again with semicolon separator
-                    if len(df.columns) == 1 and ';' in df.columns[0]:
-                        return pd.read_csv(file, sep=';')
+                    df = pd.read_csv(file, sep=';')
+                    print(f"Read file with semicolon separator after error: {df.shape}")
                     return df
                 except:
-                    # Fall back to semicolon if comma fails
-                    return pd.read_csv(file, sep=';')
+                    # Final attempt with Python's csv sniffer
+                    file.seek(0)
+                    return pd.read_csv(file, sep=None, engine='python')
                 
         elif file_name.endswith(('.xls', '.xlsx')):
             return pd.read_excel(file)
         elif file_name.endswith('.json'):
             return pd.read_json(file)
         elif file_name.endswith('.txt'):
-            return pd.read_csv(file, delimiter='\t')
+            # Try tab separator first for text files
+            try:
+                df = pd.read_csv(file, delimiter='\t')
+                if len(df.columns) <= 1:
+                    # If tab doesn't work well, try with separator detection
+                    file.seek(0)
+                    df = pd.read_csv(file, sep=None, engine='python')
+                return df
+            except:
+                # Fall back to separator detection
+                file.seek(0)
+                return pd.read_csv(file, sep=None, engine='python')
         else:
             return "Unsupported file format. Please upload .csv, .xlsx, .xls, .json, or .txt files."
     except Exception as e:
+        print(f"Error reading file: {str(e)}")
         return f"Error reading file: {str(e)}"
 
 def analyze_data(df):
@@ -202,8 +258,11 @@ def detect_outliers(df, numeric_cols):
 def generate_visualizations(df):
     """Generate appropriate visualizations based on the data types."""
     if not isinstance(df, pd.DataFrame):
+        print(f"Not a DataFrame: {type(df)}")
         return df  # Return error message if df is not a DataFrame
     
+    print(f"Starting visualization generation for DataFrame with shape: {df.shape}")
+    
     visualizations = {}
     
     # Identify column types
@@ -212,108 +271,226 @@ def generate_visualizations(df):
     date_cols = [col for col in df.columns if df[col].dtype == 'datetime64[ns]' or 
                 (df[col].dtype == 'object' and pd.to_datetime(df[col], errors='coerce').notna().all())]
     
-    # 1. Distribution plots for numeric columns (first 5)
-    if numeric_cols:
-        for i, col in enumerate(numeric_cols[:5]):  # Limit to first 5 numeric columns
-            fig = px.histogram(df, x=col, marginal="box", title=f"Distribution of {col}")
-            visualizations[f'dist_{col}'] = fig
+    print(f"Found {len(numeric_cols)} numeric columns: {numeric_cols}")
+    print(f"Found {len(categorical_cols)} categorical columns: {categorical_cols}")
+    print(f"Found {len(date_cols)} date columns: {date_cols}")
     
-    # 2. Bar charts for categorical columns (first 5)
-    if categorical_cols:
-        for i, col in enumerate(categorical_cols[:5]):  # Limit to first 5 categorical columns
-            value_counts = df[col].value_counts().nlargest(10)  # Top 10 categories
-            fig = px.bar(x=value_counts.index, y=value_counts.values, 
-                         title=f"Top 10 categories in {col}")
-            fig.update_xaxes(title=col)
-            fig.update_yaxes(title="Count")
-            visualizations[f'bar_{col}'] = fig
-    
-    # 3. Correlation heatmap for numeric columns
-    if len(numeric_cols) > 1:
-        corr_matrix = df[numeric_cols].corr()
-        fig = px.imshow(corr_matrix, text_auto=True, aspect="auto",
-                        title="Correlation Heatmap")
-        visualizations['correlation'] = fig
-    
-    # 4. Scatter plot matrix (first 4 numeric columns)
-    if len(numeric_cols) >= 2:
-        plot_cols = numeric_cols[:4]  # Limit to first 4 numeric columns
-        fig = px.scatter_matrix(df, dimensions=plot_cols, title="Scatter Plot Matrix")
-        visualizations['scatter_matrix'] = fig
-    
-    # 5. Time series plot if date column exists
-    if date_cols and numeric_cols:
-        date_col = date_cols[0]  # Use the first date column
-        # Convert to datetime if not already
-        if df[date_col].dtype != 'datetime64[ns]':
-            df[date_col] = pd.to_datetime(df[date_col], errors='coerce')
-        
-        # Sort by date
-        df_sorted = df.sort_values(by=date_col)
-        
-        # Create time series for first numeric column
-        num_col = numeric_cols[0]
-        fig = px.line(df_sorted, x=date_col, y=num_col, 
-                      title=f"{num_col} over Time")
-        visualizations['time_series'] = fig
-    
-    # 6. PCA visualization if enough numeric columns
-    if len(numeric_cols) >= 3:
-        # Apply PCA to numeric data
-        numeric_data = df[numeric_cols].select_dtypes(include=[np.number])
-        # Fill NaN values with mean for PCA
-        numeric_data = numeric_data.fillna(numeric_data.mean())
-        
-        # Standardize the data
-        scaler = StandardScaler()
-        scaled_data = scaler.fit_transform(numeric_data)
-        
-        # Apply PCA with 2 components
-        pca = PCA(n_components=2)
-        pca_result = pca.fit_transform(scaled_data)
-        
-        # Create a DataFrame with PCA results
-        pca_df = pd.DataFrame(data=pca_result, columns=['PC1', 'PC2'])
-        
-        # If categorical column exists, use it for color
+    try:
+        # Simple test plot to verify Plotly is working
+        if len(df) > 0 and len(df.columns) > 0:
+            col = df.columns[0]
+            try:
+                test_data = df[col].head(100)
+                fig = px.histogram(x=test_data, title=f"Test Plot for {col}")
+                visualizations['test_plot'] = fig
+                print(f"Generated test plot for column: {col}")
+            except Exception as e:
+                print(f"Error creating test plot: {e}")
+        
+        # 1. Distribution plots for numeric columns (first 5)
+        if numeric_cols:
+            for i, col in enumerate(numeric_cols[:5]):  # Limit to first 5 numeric columns
+                try:
+                    fig = px.histogram(df, x=col, marginal="box", title=f"Distribution of {col}")
+                    visualizations[f'dist_{col}'] = fig
+                    print(f"Generated distribution plot for {col}")
+                except Exception as e:
+                    print(f"Error creating histogram for {col}: {e}")
+        
+        # 2. Bar charts for categorical columns (first 5)
         if categorical_cols:
-            cat_col = categorical_cols[0]
-            pca_df[cat_col] = df[cat_col].values
-            fig = px.scatter(pca_df, x='PC1', y='PC2', color=cat_col, 
-                             title="PCA Visualization")
-        else:
-            fig = px.scatter(pca_df, x='PC1', y='PC2', 
-                             title="PCA Visualization")
-            
-        variance_ratio = pca.explained_variance_ratio_
-        fig.update_layout(
-            annotations=[
-                dict(
-                    text=f"PC1 explained variance: {variance_ratio[0]:.2f}",
-                    showarrow=False,
-                    x=0.5,
-                    y=1.05,
-                    xref="paper",
-                    yref="paper"
-                ),
-                dict(
-                    text=f"PC2 explained variance: {variance_ratio[1]:.2f}",
-                    showarrow=False,
-                    x=0.5,
-                    y=1.02,
-                    xref="paper",
-                    yref="paper"
-                )
-            ]
-        )
+            for i, col in enumerate(categorical_cols[:5]):  # Limit to first 5 categorical columns
+                try:
+                    # Get value counts and handle potential large number of categories
+                    value_counts = df[col].value_counts().nlargest(10)  # Top 10 categories
+                    
+                    # Convert indices to strings to ensure they can be plotted
+                    value_counts.index = value_counts.index.astype(str)
+                    
+                    fig = px.bar(x=value_counts.index, y=value_counts.values, 
+                                title=f"Top 10 categories in {col}")
+                    fig.update_xaxes(title=col)
+                    fig.update_yaxes(title="Count")
+                    visualizations[f'bar_{col}'] = fig
+                    print(f"Generated bar chart for {col}")
+                except Exception as e:
+                    print(f"Error creating bar chart for {col}: {e}")
+        
+        # 3. Correlation heatmap for numeric columns
+        if len(numeric_cols) > 1:
+            try:
+                corr_matrix = df[numeric_cols].corr()
+                fig = px.imshow(corr_matrix, text_auto=True, aspect="auto",
+                            title="Correlation Heatmap")
+                visualizations['correlation'] = fig
+                print("Generated correlation heatmap")
+            except Exception as e:
+                print(f"Error creating correlation heatmap: {e}")
         
-        visualizations['pca'] = fig
+        # 4. Scatter plot matrix (first 3 numeric columns to keep it manageable)
+        if len(numeric_cols) >= 2:
+            try:
+                plot_cols = numeric_cols[:3]  # Limit to first 3 numeric columns
+                fig = px.scatter_matrix(df, dimensions=plot_cols, title="Scatter Plot Matrix")
+                visualizations['scatter_matrix'] = fig
+                print("Generated scatter plot matrix")
+            except Exception as e:
+                print(f"Error creating scatter matrix: {e}")
+        
+        # 5. Time series plot if date column exists
+        if date_cols and numeric_cols:
+            try:
+                date_col = date_cols[0]  # Use the first date column
+                # Convert to datetime if not already
+                if df[date_col].dtype != 'datetime64[ns]':
+                    df[date_col] = pd.to_datetime(df[date_col], errors='coerce')
+                
+                # Sort by date
+                df_sorted = df.sort_values(by=date_col)
+                
+                # Create time series for first numeric column
+                num_col = numeric_cols[0]
+                fig = px.line(df_sorted, x=date_col, y=num_col, 
+                            title=f"{num_col} over Time")
+                visualizations['time_series'] = fig
+                print("Generated time series plot")
+            except Exception as e:
+                print(f"Error creating time series plot: {e}")
+        
+        # 6. PCA visualization if enough numeric columns
+        if len(numeric_cols) >= 3:
+            try:
+                # Apply PCA to numeric data
+                numeric_data = df[numeric_cols].select_dtypes(include=[np.number])
+                # Fill NaN values with mean for PCA
+                numeric_data = numeric_data.fillna(numeric_data.mean())
+                
+                # Standardize the data
+                scaler = StandardScaler()
+                scaled_data = scaler.fit_transform(numeric_data)
+                
+                # Apply PCA with 2 components
+                pca = PCA(n_components=2)
+                pca_result = pca.fit_transform(scaled_data)
+                
+                # Create a DataFrame with PCA results
+                pca_df = pd.DataFrame(data=pca_result, columns=['PC1', 'PC2'])
+                
+                # If categorical column exists, use it for color
+                if categorical_cols:
+                    cat_col = categorical_cols[0]
+                    pca_df[cat_col] = df[cat_col].values
+                    fig = px.scatter(pca_df, x='PC1', y='PC2', color=cat_col, 
+                                    title="PCA Visualization")
+                else:
+                    fig = px.scatter(pca_df, x='PC1', y='PC2', 
+                                    title="PCA Visualization")
+                    
+                variance_ratio = pca.explained_variance_ratio_
+                fig.update_layout(
+                    annotations=[
+                        dict(
+                            text=f"PC1 explained variance: {variance_ratio[0]:.2f}",
+                            showarrow=False,
+                            x=0.5,
+                            y=1.05,
+                            xref="paper",
+                            yref="paper"
+                        ),
+                        dict(
+                            text=f"PC2 explained variance: {variance_ratio[1]:.2f}",
+                            showarrow=False,
+                            x=0.5,
+                            y=1.02,
+                            xref="paper",
+                            yref="paper"
+                        )
+                    ]
+                )
+                
+                visualizations['pca'] = fig
+                print("Generated PCA visualization")
+            except Exception as e:
+                print(f"Error creating PCA visualization: {e}")
+
+    except Exception as e:
+        print(f"Error in visualization generation: {e}")
+    
+    print(f"Generated {len(visualizations)} visualizations")
+    
+    # If no visualizations were created, add a fallback
+    if not visualizations:
+        visualizations['fallback'] = generate_fallback_visualization(df)
     
     return visualizations
 
+def generate_fallback_visualization(df):
+    """Generate a simple fallback visualization using matplotlib."""
+    try:
+        plt.figure(figsize=(10, 6))
+        
+        # Choose what to plot based on data types
+        numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+        if numeric_cols:
+            # Plot first numeric column
+            col = numeric_cols[0]
+            plt.hist(df[col].dropna(), bins=20)
+            plt.title(f"Distribution of {col}")
+            plt.xlabel(col)
+            plt.ylabel("Count")
+        else:
+            # Plot count of first column values
+            col = df.columns[0]
+            value_counts = df[col].value_counts().nlargest(10)
+            plt.bar(value_counts.index.astype(str), value_counts.values)
+            plt.title(f"Top values for {col}")
+            plt.xticks(rotation=45)
+            plt.ylabel("Count")
+        
+        # Create a plotly figure from matplotlib
+        fig = go.Figure()
+        
+        # Add trace based on the type of plot
+        if numeric_cols:
+            hist, bin_edges = np.histogram(df[numeric_cols[0]].dropna(), bins=20)
+            bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+            fig.add_trace(go.Bar(x=bin_centers, y=hist, name=numeric_cols[0]))
+            fig.update_layout(title=f"Distribution of {numeric_cols[0]}")
+        else:
+            col = df.columns[0]
+            counts = df[col].value_counts().nlargest(10)
+            fig.add_trace(go.Bar(x=counts.index.astype(str), y=counts.values, name=col))
+            fig.update_layout(title=f"Top values for {col}")
+        
+        return fig
+    except Exception as e:
+        print(f"Error generating fallback visualization: {e}")
+        # Create an empty plotly figure as last resort
+        fig = go.Figure()
+        fig.add_annotation(text="Could not generate visualization", showarrow=False)
+        fig.update_layout(title="Visualization Error")
+        return fig
+
 def get_ai_cleaning_recommendations(df):
     """Get AI-powered recommendations for data cleaning using OpenAI."""
     try:
+        # Check if OpenAI API key is available
+        global OPENAI_API_KEY
+        if not OPENAI_API_KEY:
+            return """
+            ## OpenAI API Key Not Configured
+            
+            Please set your OpenAI API key in the Settings tab to get AI-powered data cleaning recommendations.
+            
+            Without an API key, here are some general recommendations:
+            
+            * Handle missing values by either removing rows or imputing with mean/median/mode
+            * Remove duplicate rows if present
+            * Convert date-like string columns to proper datetime format
+            * Standardize text data by removing extra spaces and converting to lowercase
+            * Check for and handle outliers in numerical columns
+            """
+            
         # Prepare the dataset summary
         summary = {
             "shape": df.shape,
@@ -340,47 +517,49 @@ def get_ai_cleaning_recommendations(df):
         Format your response as markdown and ONLY include the cleaning recommendations.
         """
         
-        # Check if OpenAI API key is available
-        api_key = os.environ.get("OPENAI_API_KEY")
-        if api_key:
-            openai.api_key = api_key
-            response = openai.ChatCompletion.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a data science assistant focused on data cleaning recommendations."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=700
-            )
-            return response.choices[0].message.content
-        else:
-            # Fallback to Hugging Face model if OpenAI key is not available
-            global data_assistant
-            if data_assistant is None:
-                data_assistant = initialize_ai_models()
-                
+        # Use the OpenAI API key
+        openai.api_key = OPENAI_API_KEY
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a data science assistant focused on data cleaning recommendations."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=700
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        # Fallback to Hugging Face model if OpenAI call fails
+        global data_assistant
+        if data_assistant is None:
+            data_assistant = initialize_ai_models()
+            
+        if data_assistant:
             # Shorten the prompt for the smaller model
             short_prompt = f"Data cleaning recommendations for dataset with {df.shape[0]} rows, {df.shape[1]} columns, and columns: {', '.join(df.columns[:5])}..."
             
-            # Generate recommendations
-            recommendations = data_assistant(
-                short_prompt,
-                max_length=500,
-                num_return_sequences=1
-            )[0]['generated_text']
-            
-            return f"""
-            ## Data Cleaning Recommendations
-            
-            * Handle missing values in columns with appropriate imputation techniques
-            * Check for and remove duplicate records
-            * Standardize text fields and correct spelling errors
-            * Convert columns to appropriate data types
-            * Check for and handle outliers in numerical columns
-            
-            Note: These are generic recommendations as AI model access is limited.
-            """
-    except Exception as e:
+            try:
+                # Generate recommendations
+                recommendations = data_assistant(
+                    short_prompt,
+                    max_length=500,
+                    num_return_sequences=1
+                )[0]['generated_text']
+                
+                return f"""
+                ## Data Cleaning Recommendations
+                
+                * Handle missing values in columns with appropriate imputation techniques
+                * Check for and remove duplicate records
+                * Standardize text fields and correct spelling errors
+                * Convert columns to appropriate data types
+                * Check for and handle outliers in numerical columns
+                
+                Note: Using basic AI model as OpenAI API encountered an error: {str(e)}
+                """
+            except:
+                pass
+                
         return f"""
         ## Data Cleaning Recommendations
         
@@ -396,10 +575,43 @@ def get_ai_cleaning_recommendations(df):
 def get_hf_model_insights(df):
     """Get dataset insights using Hugging Face model."""
     try:
-        global data_assistant
+        global data_assistant, HF_API_TOKEN
+        
+        # Check if HF token is set
+        if not HF_API_TOKEN and not data_assistant:
+            return """
+            ## Hugging Face API Token Not Configured
+            
+            Please set your Hugging Face API token in the Settings tab to get AI-powered data analysis insights.
+            
+            Without an API token, here are some general analysis suggestions:
+            
+            1. Examine the distribution of each numeric column
+            2. Analyze correlations between numeric features
+            3. Look for patterns in categorical data
+            4. Consider creating visualizations like histograms and scatter plots
+            5. Explore relationships between different variables
+            """
+            
+        # Initialize the model if not already done
         if data_assistant is None:
             data_assistant = initialize_ai_models()
         
+        if not data_assistant:
+            return """
+            ## AI Model Not Available
+            
+            Could not initialize the Hugging Face model. Please check your API token or try again later.
+            
+            Here are some general analysis suggestions:
+            
+            1. Examine the distribution of each numeric column
+            2. Analyze correlations between numeric features
+            3. Look for patterns in categorical data
+            4. Consider creating pivot tables to understand relationships
+            5. Look for time-based patterns if datetime columns are present
+            """
+        
         # Prepare a brief summary of the dataset
         numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
         categorical_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
@@ -454,7 +666,7 @@ def process_file(file):
     # Read the file
     df = read_file(file)
     
-    if isinstance(df, str):  # If error message
+    if isinstance(df, str):  # Error message
         return df, None, None, None
     
     # Convert date columns to datetime
@@ -638,38 +850,6 @@ def apply_data_cleaning(df, cleaning_options):
     
     return cleaned_df, cleaning_log
 
-def app_ui(file):
-    """Main function for the Gradio interface."""
-    if file is None:
-        return "Please upload a file to begin analysis.", None, None, None
-    
-    # Process the file
-    analysis, visualizations, cleaning_recommendations, analysis_insights = process_file(file)
-    
-    if isinstance(analysis, str):  # If error message
-        return analysis, None, None, None
-    
-    # Format analysis for display
-    analysis_html = display_analysis(analysis)
-    
-    # Prepare visualizations for display
-    viz_html = ""
-    if visualizations and not isinstance(visualizations, str):
-        for viz_name, fig in visualizations.items():
-            # Convert plotly figure to HTML
-            viz_html += f'<div style="margin-bottom: 30px;">{fig.to_html(full_html=False, include_plotlyjs="cdn")}</div>'
-    
-    # Combine analysis and visualizations
-    result_html = f"""
-    <div style="display: flex; flex-direction: column;">
-        <div>{analysis_html}</div>
-        <h2>Data Visualizations</h2>
-        <div>{viz_html}</div>
-    </div>
-    """
-    
-    return result_html, visualizations, cleaning_recommendations, analysis_insights
-
 def apply_cleaning_ui(file, handle_missing, missing_method, remove_duplicates, 
                      handle_outliers, outlier_method, convert_dates, date_columns,
                      normalize_numeric):
@@ -680,7 +860,7 @@ def apply_cleaning_ui(file, handle_missing, missing_method, remove_duplicates,
     # Read the file
     df = read_file(file)
     
-    if isinstance(df, str):  # If error message
+    if isinstance(df, str):  # Error message
         return df, None
     
     # Configure cleaning options
@@ -721,19 +901,87 @@ def apply_cleaning_ui(file, handle_missing, missing_method, remove_duplicates,
     
     return result_summary, buffer
 
+def app_ui(file):
+    """Main function for the Gradio interface."""
+    if file is None:
+        return "Please upload a file to begin analysis.", None, None, None
+    
+    print(f"Processing file in app_ui: {file.name if hasattr(file, 'name') else 'unknown'}")
+    
+    # Process the file
+    analysis, visualizations, cleaning_recommendations, analysis_insights = process_file(file)
+    
+    if isinstance(analysis, str):  # Error message
+        print(f"Error in analysis: {analysis}")
+        return analysis, None, None, None
+    
+    # Format analysis for display
+    analysis_html = display_analysis(analysis)
+    
+    # Prepare visualizations for display
+    viz_html = ""
+    if visualizations and not isinstance(visualizations, str):
+        print(f"Processing {len(visualizations)} visualizations for display")
+        for viz_name, fig in visualizations.items():
+            try:
+                # For debugging, print visualization object info
+                print(f"Visualization {viz_name}: type={type(fig)}")
+                
+                # Convert plotly figure to HTML
+                html_content = fig.to_html(full_html=False, include_plotlyjs="cdn")
+                print(f"Generated HTML for {viz_name}, length: {len(html_content)}")
+                
+                viz_html += f'<div style="margin-bottom: 30px;">{html_content}</div>'
+                print(f"Added visualization: {viz_name}")
+            except Exception as e:
+                print(f"Error rendering visualization {viz_name}: {e}")
+    else:
+        print(f"No visualizations to display: {visualizations}")
+        viz_html = "<p>No visualizations could be generated for this dataset.</p>"
+    
+    # Combine analysis and visualizations
+    result_html = f"""
+    <div style="display: flex; flex-direction: column;">
+        <div>{analysis_html}</div>
+        <h2>Data Visualizations</h2>
+        <div>{viz_html}</div>
+    </div>
+    """
+    
+    return result_html, visualizations, cleaning_recommendations, analysis_insights
+
+def test_visualization():
+    """Create a simple test visualization to verify plotly is working."""
+    import plotly.express as px
+    import numpy as np
+    
+    # Create sample data
+    x = np.random.rand(100)
+    y = np.random.rand(100)
+    
+    # Create a simple scatter plot
+    fig = px.scatter(x=x, y=y, title="Test Plot")
+    
+    # Convert to HTML
+    html = fig.to_html(full_html=False, include_plotlyjs="cdn")
+    
+    return html
+
 # Create Gradio interface
 with gr.Blocks(title="Data Visualization & Cleaning AI") as demo:
     gr.Markdown("# Data Visualization & Cleaning AI")
     gr.Markdown("Upload your data file (CSV, Excel, JSON, or TXT) and get automatic analysis, visualizations, and AI-powered insights.")
     
-    with gr.Row():
-        file_input = gr.File(label="Upload Data File")
-    
-    with gr.Tabs():
+    with gr.Tabs() as tabs:
         with gr.TabItem("Data Analysis"):
             with gr.Row():
+                file_input = gr.File(label="Upload Data File")
                 analyze_button = gr.Button("Analyze Data")
             
+            # Add test visualization to verify Plotly is working
+            test_viz_html = test_visualization()
+            gr.HTML(f"<details><summary>Plotly Test (Click to expand)</summary>{test_viz_html}</details>", visible=True)
+            
             with gr.Tabs():
                 with gr.TabItem("Analysis & Visualizations"):
                     output = gr.HTML(label="Results")
@@ -772,6 +1020,32 @@ with gr.Blocks(title="Data Visualization & Cleaning AI") as demo:
                     clean_button = gr.Button("Clean Data")
                     cleaning_output = gr.HTML(label="Cleaning Results")
                     cleaned_file_output = gr.File(label="Download Cleaned Data")
+        
+        with gr.TabItem("Settings"):
+            gr.Markdown("### API Key Configuration")
+            gr.Markdown("Enter your API keys to enable AI-powered features.")
+            
+            with gr.Group():
+                gr.Markdown("#### OpenAI API Key")
+                gr.Markdown("Required for advanced data cleaning recommendations.")
+                openai_key_input = gr.Textbox(
+                    label="OpenAI API Key",
+                    placeholder="sk-...",
+                    type="password"
+                )
+                openai_key_button = gr.Button("Save OpenAI API Key")
+                openai_key_status = gr.Markdown("Status: Not configured")
+            
+            with gr.Group():
+                gr.Markdown("#### Hugging Face API Token")
+                gr.Markdown("Required for AI-powered data analysis insights.")
+                hf_token_input = gr.Textbox(
+                    label="Hugging Face API Token",
+                    placeholder="hf_...",
+                    type="password"
+                )
+                hf_token_button = gr.Button("Save Hugging Face Token")
+                hf_token_status = gr.Markdown("Status: Not configured")
     
     # Connect the buttons to functions
     analyze_button.click(
@@ -789,6 +1063,18 @@ with gr.Blocks(title="Data Visualization & Cleaning AI") as demo:
         ],
         outputs=[cleaning_output, cleaned_file_output]
     )
+    
+    openai_key_button.click(
+        fn=set_openai_key,
+        inputs=[openai_key_input],
+        outputs=[openai_key_status]
+    )
+    
+    hf_token_button.click(
+        fn=set_hf_token,
+        inputs=[hf_token_input],
+        outputs=[hf_token_status]
+    )
 
 # Initialize AI models
 try: