Upload app.py

app.py

@@ -0,0 +1,661 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from google import genai
+from google.genai import types
+import json
+import streamlit.components.v1 as components
+from datetime import datetime, date
+import io
+import base64
+
+# ------------------------------
+# Custom JSON Encoder for Timestamps
+# ------------------------------
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, (datetime, date, pd.Timestamp)):
+            return obj.isoformat()
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        if pd.isna(obj):
+            return None
+        return super().default(obj)
+
+# ------------------------------
+# Page Configuration
+# ------------------------------
+st.set_page_config(
+    page_title="AI Excel BI Dashboard",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize session state
+if 'api_configured' not in st.session_state:
+    st.session_state['api_configured'] = False
+if 'dark_mode' not in st.session_state:
+    st.session_state['dark_mode'] = True  # Default to dark mode
+
+# ------------------------------
+# Sidebar: API Key Setup
+# ------------------------------
+with st.sidebar:
+    st.header("⚙️ Configuration")
+    st.markdown("---")
+    
+    api_key = st.text_input(
+        "🔑 Gemini API Key",
+        type="password",
+        help="Enter your Google Gemini API key"
+    )
+    
+    if api_key:
+        try:
+            client = genai.Client(api_key=api_key)
+            st.success("✅ API Key Configured")
+            st.session_state['api_configured'] = True
+        except Exception as e:
+            st.error(f"❌ Invalid API Key: {e}")
+            client = None
+            st.session_state['api_configured'] = False
+    else:
+        client = None
+    
+    st.markdown("---")
+    
+    st.subheader("ℹ️ About")
+    st.info("""
+    This AI-powered dashboard:
+    - Analyzes Excel/CSV data
+    - Generates intelligent visualizations
+    - Creates interactive HTML dashboards
+    - Provides business insights
+    - Detects company/brand data
+    """)
+    
+    st.markdown("---")
+    st.caption("Powered by Google Gemini AI")
+
+# Apply dark mode styling (always on by default)
+st.markdown("""
+    <style>
+    .stApp {
+        background-color: #0e1117;
+        color: #fafafa;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# ------------------------------
+# Main Area: Dashboard
+# ------------------------------
+st.title("📊 AI-Powered Business Intelligence Dashboard")
+st.markdown("Upload your data file and let AI create professional insights!")
+
+# Check if API key is configured
+if not api_key or not client:
+    st.warning("⚠️ Please enter your Gemini API Key in the sidebar to continue.")
+    st.stop()
+
+# ------------------------------
+# File Upload Section
+# ------------------------------
+st.markdown("---")
+uploaded_file = st.file_uploader(
+    "📂 Upload Your Data File",
+    type=["csv", "xlsx"],
+    help="Supports CSV and Excel files"
+)
+
+if uploaded_file:
+    try:
+        # Load dataset
+        with st.spinner("Loading data..."):
+            if uploaded_file.name.endswith(".csv"):
+                df = pd.read_csv(uploaded_file)
+            else:
+                df = pd.read_excel(uploaded_file)
+        
+        st.success(f"✅ File '{uploaded_file.name}' uploaded successfully!")
+        
+        # ------------------------------
+        # Enhanced Data Overview Section
+        # ------------------------------
+        st.markdown("---")
+        st.subheader("📋 Comprehensive Data Overview")
+        
+        # Basic Metrics
+        col1, col2, col3, col4, col5 = st.columns(5)
+        with col1:
+            st.metric("Total Rows", f"{df.shape[0]:,}")
+        with col2:
+            st.metric("Total Columns", df.shape[1])
+        with col3:
+            st.metric("Numeric Columns", len(df.select_dtypes(include=['number']).columns))
+        with col4:
+            st.metric("Categorical Columns", len(df.select_dtypes(include=['object']).columns))
+        with col5:
+            missing_pct = (df.isnull().sum().sum() / (df.shape[0] * df.shape[1]) * 100)
+            st.metric("Missing Data", f"{missing_pct:.1f}%")
+        
+        # Detailed Data Analysis
+        with st.expander("🔍 View Detailed Data Analysis", expanded=True):
+            tab1, tab2, tab3 = st.tabs(["📊 Data Preview", "📈 Statistics", "⚠️ Data Quality"])
+            
+            with tab1:
+                st.dataframe(df.head(15), use_container_width=True)
+            
+            with tab2:
+                # Statistical Summary
+                st.markdown("**Statistical Summary**")
+                numeric_cols = df.select_dtypes(include=['number']).columns
+                if len(numeric_cols) > 0:
+                    stats_df = df[numeric_cols].describe()
+                    st.dataframe(stats_df, use_container_width=True)
+                else:
+                    st.info("No numeric columns found for statistical analysis")
+                
+                # Categorical Summary
+                cat_cols = df.select_dtypes(include=['object']).columns
+                if len(cat_cols) > 0:
+                    st.markdown("**Categorical Summary**")
+                    cat_summary = pd.DataFrame({
+                        'Column': cat_cols,
+                        'Unique Values': [df[col].nunique() for col in cat_cols],
+                        'Most Frequent': [df[col].mode()[0] if len(df[col].mode()) > 0 else 'N/A' for col in cat_cols],
+                        'Frequency': [df[col].value_counts().iloc[0] if len(df[col]) > 0 else 0 for col in cat_cols]
+                    })
+                    st.dataframe(cat_summary, use_container_width=True)
+            
+            with tab3:
+                # Data Quality Metrics
+                quality_data = []
+                for col in df.columns:
+                    missing = df[col].isnull().sum()
+                    missing_pct = (missing / len(df)) * 100
+                    
+                    # Check for blank spaces in string columns
+                    blank_spaces = 0
+                    if df[col].dtype == 'object':
+                        blank_spaces = df[col].astype(str).str.strip().eq('').sum()
+                    
+                    # Standard deviation for numeric columns
+                    std_dev = df[col].std() if df[col].dtype in ['int64', 'float64'] else None
+                    
+                    quality_data.append({
+                        'Column': col,
+                        'Data Type': str(df[col].dtype),
+                        'Missing Values': missing,
+                        'Missing %': f"{missing_pct:.2f}%",
+                        'Blank Spaces': blank_spaces,
+                        'Std Deviation': f"{std_dev:.2f}" if std_dev is not None else 'N/A',
+                        'Unique Values': df[col].nunique()
+                    })
+                
+                quality_df = pd.DataFrame(quality_data)
+                st.dataframe(quality_df, use_container_width=True)
+                
+                # Highlight issues
+                total_missing = df.isnull().sum().sum()
+                if total_missing > 0:
+                    st.warning(f"⚠️ Found {total_missing:,} missing values across the dataset")
+                else:
+                    st.success("✅ No missing values detected")
+        
+        # ------------------------------
+        # AI Analysis Section
+        # ------------------------------
+        st.markdown("---")
+        st.subheader("🤖 AI-Generated Dashboard")
+        
+        col_btn1, col_btn2 = st.columns(2)
+        
+        with col_btn1:
+            generate_charts = st.button("📈 Generate Charts & Insights", type="primary", use_container_width=True)
+        
+        with col_btn2:
+            generate_interactive = st.button("🎨 Generate Interactive HTML Dashboard", type="secondary", use_container_width=True)
+        
+        # Add Presentation Maker Button
+        st.markdown("")
+        generate_presentation = st.button("🎤 Generate AI Presentation (PPT)", use_container_width=True)
+        
+        # ------------------------------
+        # Generate Charts and Insights (Collage View)
+        # ------------------------------
+        if generate_charts:
+            with st.spinner("AI is analyzing your data..."):
+                try:
+                    # Prepare schema with proper serialization
+                    sample_data = df.head(3).copy()
+                    for col in sample_data.columns:
+                        if sample_data[col].dtype == 'datetime64[ns]' or isinstance(sample_data[col].iloc[0], pd.Timestamp):
+                            sample_data[col] = sample_data[col].astype(str)
+                    
+                    schema = {
+                        "columns": {col: str(df[col].dtype) for col in df.columns},
+                        "sample": sample_data.to_dict(),
+                        "shape": {"rows": int(df.shape[0]), "columns": int(df.shape[1])},
+                        "numeric_columns": [col for col in df.select_dtypes(include=['number']).columns.tolist()],
+                        "categorical_columns": [col for col in df.select_dtypes(include=['object']).columns.tolist()]
+                    }
+                    
+                    prompt = f"""
+                    You are a business intelligence and data visualization expert.
+                    
+                    Dataset Information:
+                    {json.dumps(schema, indent=2, cls=CustomJSONEncoder)}
+                    
+                    Analyze this dataset and determine:
+                    1. Is this company/business data? (sales, revenue, employees, products, etc.)
+                    2. What industry or domain does it belong to? (retail, finance, healthcare, entertainment, etc.)
+                    3. What are the key metrics and KPIs?
+                    
+                    Then respond with ONLY a valid JSON object (no markdown, no explanations) with this exact structure:
+                    {{
+                        "domain": "industry name (e.g., retail, finance, entertainment, generic)",
+                        "is_company_data": true/false,
+                        "charts": [
+                            {{"type": "bar", "x": "column_name", "y": "column_name", "title": "Descriptive Chart Title"}},
+                            {{"type": "line", "x": "column_name", "y": "column_name", "title": "Descriptive Chart Title"}},
+                            {{"type": "scatter", "x": "column_name", "y": "column_name", "title": "Descriptive Chart Title"}},
+                            {{"type": "pie", "column": "column_name", "title": "Descriptive Chart Title"}}
+                        ],
+                        "insights": [
+                            "First business insight about the data",
+                            "Second business insight about the data",
+                            "Third business insight about the data"
+                        ]
+                    }}
+                    
+                    Chart types available: bar, line, scatter, histogram, pie
+                    Generate 4-6 charts that would be most insightful for this data domain.
+                    """
+                    
+                    # Call Gemini API
+                    response = client.models.generate_content(
+                        model="gemini-2.0-flash-exp",
+                        contents=[prompt]
+                    )
+                    
+                    # Parse response
+                    response_text = response.text.strip()
+                    if response_text.startswith("```"):
+                        response_text = response_text.split("```")[1]
+                        if response_text.startswith("json"):
+                            response_text = response_text[4:]
+                    
+                    chart_plan = json.loads(response_text)
+                    
+                    # Store in session state
+                    st.session_state['chart_plan'] = chart_plan
+                    st.session_state['df'] = df
+                    
+                except Exception as e:
+                    st.error(f"❌ Error generating dashboard: {e}")
+                    st.exception(e)
+        
+        # ------------------------------
+        # Display Charts in Collage View
+        # ------------------------------
+        if 'chart_plan' in st.session_state:
+            chart_plan = st.session_state['chart_plan']
+            df = st.session_state['df']
+            
+            st.markdown("---")
+            st.markdown("### 📈 Visualizations Collage")
+            st.markdown(f"**Dashboard Title:** {uploaded_file.name.split('.')[0].replace('_', ' ').title()}")
+            st.markdown("**Detailed Charts & Graphs** - Comprehensive visual analysis with proper labels and insights")
+            
+            charts = chart_plan.get("charts", [])
+            
+            # Create matplotlib figure with all charts
+            num_charts = len(charts)
+            cols_per_row = 3
+            rows = (num_charts + cols_per_row - 1) // cols_per_row
+            
+            fig = plt.figure(figsize=(20, 5 * rows))
+            
+            for idx, chart in enumerate(charts, 1):
+                try:
+                    chart_type = chart.get("type")
+                    title = chart.get("title", f"Chart {idx}")
+                    
+                    ax = fig.add_subplot(rows, cols_per_row, idx)
+                    
+                    if chart_type == "bar" and "x" in chart and "y" in chart:
+                        grouped_data = df.groupby(chart["x"])[chart["y"]].sum()
+                        # Limit to top 15 categories for readability
+                        if len(grouped_data) > 15:
+                            grouped_data = grouped_data.nlargest(15)
+                        sns.barplot(x=grouped_data.values, y=grouped_data.index, ax=ax, palette='Blues_d')
+                        ax.set_xlabel(chart["y"], fontsize=10)
+                        ax.set_ylabel(chart["x"], fontsize=10)
+                        
+                    elif chart_type == "line" and "x" in chart and "y" in chart:
+                        # Sample data if too many points
+                        plot_df = df.copy()
+                        if len(plot_df) > 100:
+                            plot_df = plot_df.sample(100).sort_values(by=chart["x"])
+                        sns.lineplot(data=plot_df, x=chart["x"], y=chart["y"], ax=ax, marker='o', color='green', linewidth=2)
+                        ax.set_xlabel(chart["x"], fontsize=10)
+                        ax.set_ylabel(chart["y"], fontsize=10)
+                        plt.setp(ax.xaxis.get_majorticklabels(), rotation=45, ha='right', fontsize=8)
+                        
+                    elif chart_type == "scatter" and "x" in chart and "y" in chart:
+                        sns.scatterplot(data=df, x=chart["x"], y=chart["y"], ax=ax, color='coral', s=50, alpha=0.6)
+                        ax.set_xlabel(chart["x"], fontsize=10)
+                        ax.set_ylabel(chart["y"], fontsize=10)
+                        
+                    elif chart_type == "histogram" and "x" in chart:
+                        sns.histplot(df[chart["x"]].dropna(), bins=20, kde=True, ax=ax, color='purple', alpha=0.7)
+                        ax.set_xlabel(chart["x"], fontsize=10)
+                        ax.set_ylabel("Frequency", fontsize=10)
+                        
+                    elif chart_type == "pie" and "column" in chart:
+                        data = df[chart["column"]].value_counts().head(5)
+                        colors = sns.color_palette("pastel")
+                        ax.pie(data.values, labels=data.index, autopct='%1.1f%%', startangle=90, colors=colors)
+                    
+                    ax.set_title(title, fontsize=11, fontweight='bold', pad=10)
+                    
+                except Exception as chart_error:
+                    ax.text(0.5, 0.5, f'Error: {str(chart_error)}', ha='center', va='center')
+                    ax.set_title(title, fontsize=11)
+            
+            plt.tight_layout()
+            st.pyplot(fig)
+            plt.close()
+            
+            # Display Insights
+            st.markdown("---")
+            st.markdown("### 💡 Business Insights")
+            
+            insights = chart_plan.get("insights", [])
+            for idx, insight in enumerate(insights, 1):
+                st.markdown(f"**{idx}.** {insight}")
+        
+        # ------------------------------
+        # Generate Interactive HTML Dashboard (Professional Power BI Style)
+        # ------------------------------
+        if generate_interactive:
+            with st.spinner("Generating professional interactive dashboard..."):
+                try:
+                    # Detect domain and company info
+                    domain = st.session_state.get('chart_plan', {}).get('domain', 'general')
+                    is_company = st.session_state.get('chart_plan', {}).get('is_company_data', False)
+                    
+                    # Get file name for dashboard title
+                    dashboard_title = uploaded_file.name.split('.')[0].replace('_', ' ').title()
+                    
+                    # Prepare data with proper serialization
+                    sample_data = df.head(20).copy()
+                    for col in sample_data.columns:
+                        if sample_data[col].dtype == 'datetime64[ns]' or isinstance(sample_data[col].iloc[0], pd.Timestamp):
+                            sample_data[col] = sample_data[col].astype(str)
+                    
+                    stats_dict = {}
+                    for col in df.select_dtypes(include=['number']).columns:
+                        stats_dict[col] = {
+                            'mean': float(df[col].mean()),
+                            'median': float(df[col].median()),
+                            'std': float(df[col].std()),
+                            'min': float(df[col].min()),
+                            'max': float(df[col].max())
+                        }
+                    
+                    html_prompt = f"""
+                    Create a COMPLETE, self-contained, professional Power BI-style HTML dashboard.
+                    
+                    Dataset Context:
+                    - Dashboard Title: {dashboard_title}
+                    - Domain: {domain}
+                    - Is Company Data: {is_company}
+                    - Columns: {', '.join(df.columns.tolist())}
+                    - Rows: {df.shape[0]}
+                    - Sample Data: {json.dumps(sample_data.to_dict('records')[:10], cls=CustomJSONEncoder)}
+                    - Statistics: {json.dumps(stats_dict, cls=CustomJSONEncoder)}
+                    
+                    CRITICAL Requirements for Handling Large Data:
+                    1. For bar charts with many categories (>15), show only TOP 15 values and add "...and X more" text
+                    2. For time series/date data, aggregate by week or month, never show individual dates
+                    3. Use responsive chart heights (max 300px per chart)
+                    4. Implement proper overflow handling with max-height and scrolling only if necessary
+                    5. For dates on x-axis: rotate labels 45deg, use abbreviated format (MMM-YY), show every Nth label
+                    
+                    Dashboard Design:
+                    1. Use Chart.js from CDN: https://cdn.jsdelivr.net/npm/chart.js
+                    2. Dynamic color scheme based on domain/data characteristics:
+                       - Finance: Blue (#1e3a8a) to Navy gradient with gold accents
+                       - Retail/Sales: Orange (#ea580c) to Green (#16a34a) gradient
+                       - Healthcare: Teal (#0d9488) to Blue (#0284c7) gradient
+                       - Entertainment/Movies: Purple (#7c3aed) to Magenta (#db2777) gradient
+                       - Technology: Cyan (#06b6d4) to Blue (#3b82f6) gradient
+                       - Generic: Professional Blue (#2563eb) to Gray (#64748b) gradient
+                    3. Layout: Responsive grid with 2-3 columns, cards with shadows
+                    4. Include:
+                       - Top banner with "{dashboard_title}" as main title
+                       - 4-6 KPI cards with key metrics (large numbers, trend indicators)
+                       - 6-8 charts in grid layout (bar, line, pie, doughnut, area charts)
+                       - Each chart in a card with title, proper spacing
+                       - All charts must be USEFUL for Business Intelligence and KPI tracking
+                       - Focus on metrics that show: trends, comparisons, distributions, performance
+                    5. If company data, add company logo placeholder at top
+                    6. Footer: "{datetime.now().strftime('%B %d, %Y')} | {dashboard_title} Analytics Dashboard"
+                    7. Make charts interactive: hover tooltips, legend toggle
+                    8. Use actual data values, aggregate large datasets intelligently
+                    9. Add smooth animations (fade-in, scale effects)
+                    10. Ensure dates are always visible, accurate & readable
+                    
+                    Chart Configuration Best Practices:
+                    - Bar charts: Horizontal for many categories.
+                    - Line charts: Aggregate time data, show trends not noise
+                    - Pie/Doughnut: Limit to top 10 categories, group "Others"
+                    - Use appropriate scales and formatting (K, M, B for large numbers)
+                    
+                    Return ONLY complete HTML code starting with <!DOCTYPE html>
+                    NO markdown, NO explanations, just pure HTML that looks like a professional BI tool.
+                    """
+                    
+                    response = client.models.generate_content(
+                        model="gemini-2.0-flash-exp",
+                        contents=[html_prompt]
+                    )
+                    
+                    html_code = response.text.strip()
+                    
+                    if html_code.startswith("```"):
+                        html_code = html_code.split("```")[1]
+                        if html_code.startswith("html"):
+                            html_code = html_code[4:]
+                        html_code = html_code.strip()
+                    
+                    st.session_state['html_dashboard'] = html_code
+                    st.success("✅ Professional dashboard generated!")
+                    
+                except Exception as e:
+                    st.error(f"❌ Error generating HTML dashboard: {e}")
+                    st.exception(e)
+        
+        # ------------------------------
+        # Display Interactive HTML Dashboard
+        # ------------------------------
+        if 'html_dashboard' in st.session_state:
+            st.markdown("---")
+            st.markdown("### 🎨 Professional Interactive Dashboard")
+            
+            html_code = st.session_state['html_dashboard']
+            
+            # Display the interactive HTML
+            components.html(html_code, height=1000, scrolling=True)
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.download_button(
+                    label="📥 Download HTML Dashboard",
+                    data=html_code,
+                    file_name=f"dashboard_{uploaded_file.name.split('.')[0]}.html",
+                    mime="text/html",
+                    use_container_width=True
+                )
+            
+            with col2:
+                with st.expander("💻 View HTML Source Code"):
+                    st.code(html_code, language="html")
+        
+        # ------------------------------
+        # Generate AI Presentation (PPT-style HTML)
+        # ------------------------------
+        if generate_presentation:
+            with st.spinner("Creating professional presentation..."):
+                try:
+                    # Get insights and domain info
+                    chart_plan = st.session_state.get('chart_plan', {})
+                    domain = chart_plan.get('domain', 'general')
+                    insights = chart_plan.get('insights', [])
+                    
+                    dashboard_title = uploaded_file.name.split('.')[0].replace('_', ' ').title()
+                    
+                    # Prepare data summary
+                    key_metrics = []
+                    for col in df.select_dtypes(include=['number']).columns[:4]:
+                        key_metrics.append({
+                            'metric': col,
+                            'value': float(df[col].sum()),
+                            'avg': float(df[col].mean()),
+                            'trend': 'up' if df[col].mean() > df[col].median() else 'down'
+                        })
+                    
+                    presentation_prompt = f"""
+                    Create a professional HTML presentation (PowerPoint-style) with slide navigation.
+                    
+                    Presentation Context:
+                    - Title: {dashboard_title} - Business Intelligence Analysis
+                    - Domain: {domain}
+                    - Dataset: {df.shape[0]} rows, {df.shape[1]} columns
+                    - Key Insights: {json.dumps(insights, cls=CustomJSONEncoder)}
+                    - Key Metrics: {json.dumps(key_metrics, cls=CustomJSONEncoder)}
+                    
+                    Create EXACTLY 5 slides with this structure:
+                    
+                    SLIDE 1 - Title & Introduction:
+                    - Large title: "{dashboard_title}"
+                    - Subtitle: "Business Intelligence Dashboard Analysis"
+                    - Brief introduction about the data and purpose
+                    - Beautiful gradient background matching {domain} theme
+                    - Company logo placeholder if applicable
+                    
+                    SLIDE 2 - Key Objectives & Questions:
+                    - Title: "Business Objectives"
+                    - List 3-4 core business questions this analysis answers
+                    - Use bullet points with icons
+                    - Examples: "What drives revenue growth?", "Which segments perform best?", etc.
+                    
+                    SLIDE 3 - Data & Analysis:
+                    - Title: "Key Findings & Visualizations"
+                    - Include 2-3 mini chart visualizations using Chart.js
+                    - Show the most important metrics and trends
+                    - Use actual data from the metrics provided
+                    - Keep charts simple and clear
+                    
+                    SLIDE 4 - Insights & Recommendations:
+                    - Title: "Strategic Insights"
+                    - Present the top 3 insights from the data
+                    - Add actionable recommendations for each insight
+                    - Use cards/boxes for visual separation
+                    - Include trend indicators (↑↓→)
+                    
+                    SLIDE 5 - Conclusion & Next Steps:
+                    - Title: "Conclusion & Action Plan"
+                    - Recap key takeaways (3-4 points)
+                    - Suggest 2-3 concrete next steps
+                    - Add a "Questions?" section
+                    - Thank you message
+                    
+                    Technical Requirements:
+                    1. Full-screen slides (100vh height, 100vw width)
+                    2. Slide navigation: Previous/Next buttons + keyboard arrows
+                    3. Slide counter: "Slide X of 5"
+                    4. Smooth transitions between slides (slide/fade effect)
+                    5. Professional design matching {domain} color scheme:
+                       - Finance: Navy blue with gold accents
+                       - Retail: Orange and green tones
+                       - Healthcare: Teal and blue
+                       - Entertainment: Purple and magenta
+                       - Technology: Cyan and blue
+                       - Generic: Professional blue-gray
+                    6. Use Chart.js for any charts (CDN: https://cdn.jsdelivr.net/npm/chart.js)
+                    7. Responsive typography and spacing
+                    8. Each slide should be self-contained and visually appealing
+                    9. Add subtle animations (fade-in effects for content)
+                    10. Footer on each slide with page number and date
+                    
+                    Return ONLY complete HTML code starting with <!DOCTYPE html>
+                    NO markdown, NO explanations.
+                    The presentation should look like a professional PowerPoint/Keynote presentation.
+                    """
+                    
+                    response = client.models.generate_content(
+                        model="gemini-2.0-flash-exp",
+                        contents=[presentation_prompt]
+                    )
+                    
+                    ppt_html = response.text.strip()
+                    
+                    if ppt_html.startswith("```"):
+                        ppt_html = ppt_html.split("```")[1]
+                        if ppt_html.startswith("html"):
+                            ppt_html = ppt_html[4:]
+                        ppt_html = ppt_html.strip()
+                    
+                    st.session_state['presentation'] = ppt_html
+                    st.success("✅ Presentation generated!")
+                    
+                except Exception as e:
+                    st.error(f"❌ Error generating presentation: {e}")
+                    st.exception(e)
+        
+        # ------------------------------
+        # Display Presentation
+        # ------------------------------
+        if 'presentation' in st.session_state:
+            st.markdown("---")
+            st.markdown("### 🎤 AI-Generated Business Presentation")
+            st.info("Use arrow keys or navigation buttons to move between slides")
+            
+            ppt_html = st.session_state['presentation']
+            
+            # Display the presentation
+            components.html(ppt_html, height=700, scrolling=False)
+            
+            st.download_button(
+                label="📥 Download Presentation (HTML)",
+                data=ppt_html,
+                file_name=f"presentation_{uploaded_file.name.split('.')[0]}.html",
+                mime="text/html",
+                use_container_width=True
+            )
+    
+    except Exception as e:
+        st.error(f"❌ Error loading file: {e}")
+        st.exception(e)
+
+else:
+    st.info("👆 Please upload a CSV or Excel file to get started.")
+
+# ------------------------------
+# Footer
+# ------------------------------
+st.markdown("---")
+st.markdown(
+    f"<div style='text-align: center; color: gray;'>Built with Streamlit & Google Gemini AI</div>",
+    unsafe_allow_html=True
+)