Update app.py

app.py

@@ -3,7 +3,7 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 import numpy as np
-from datetime import datetime
+import os
 import warnings
 warnings.filterwarnings('ignore')
 
@@ -48,120 +48,65 @@ st.markdown("""
 @st.cache_data
 def load_kaggle_sap_data():
     """
-    Load real SAP dataset from Kaggle using corrected API
+    Load real SAP dataset from Kaggle using proper Kaggle API
     """
     try:
-        # Import kagglehub here to handle version differences
-        import kagglehub
+        # Import kaggle API
+        import kaggle
         
         dataset_name = "mustafakeser4/sap-dataset-bigquery-dataset"
+        download_path = "./kaggle_data"
         
-        # Try the new API first, fall back to old if needed
-        try:
-            # For newer versions of kagglehub with KaggleDatasetAdapter
-            try:
-                from kagglehub import KaggleDatasetAdapter
-                
-                # Load tables using dataset_load method
-                vbak = kagglehub.dataset_load(KaggleDatasetAdapter.PANDAS, dataset_name, "vbak.csv")
-                vbap = kagglehub.dataset_load(KaggleDatasetAdapter.PANDAS, dataset_name, "vbap.csv")
-                kna1 = kagglehub.dataset_load(KaggleDatasetAdapter.PANDAS, dataset_name, "kna1.csv")
-                makt = kagglehub.dataset_load(KaggleDatasetAdapter.PANDAS, dataset_name, "makt.csv")
-                
-            except ImportError:
-                # Fall back to dataset_download method for older versions
-                path = kagglehub.dataset_download(dataset_name)
-                
-                vbak = pd.read_csv(f"{path}/vbak.csv")
-                vbap = pd.read_csv(f"{path}/vbap.csv") 
-                kna1 = pd.read_csv(f"{path}/kna1.csv")
-                makt = pd.read_csv(f"{path}/makt.csv")
-            
-        except Exception as e:
-            st.error(f"Error with kagglehub API: {str(e)}")
-            # Use alternative data loading method
-            return load_alternative_data()
-        
-        # Limit data size for performance
-        tables = {
-            'sales_orders': vbak.head(5000),
-            'sales_items': vbap.head(10000), 
-            'customers': kna1.head(3000),
-            'material_texts': makt[makt.get('spras', makt.get('SPRAS', '')) == 'E'].head(3000)
-        }
+        # Download dataset using kaggle API
+        kaggle.api.authenticate()
+        kaggle.api.dataset_download_files(dataset_name, path=download_path, unzip=True)
+        
+        # Load key SAP tables
+        tables = {}
+        
+        # Sales Order Header (VBAK)
+        vbak_path = f"{download_path}/vbak.csv"
+        if os.path.exists(vbak_path):
+            vbak = pd.read_csv(vbak_path)
+            tables['sales_orders'] = vbak.head(5000)  # Limit for performance
+        
+        # Sales Order Items (VBAP)  
+        vbap_path = f"{download_path}/vbap.csv"
+        if os.path.exists(vbap_path):
+            vbap = pd.read_csv(vbap_path)
+            tables['sales_items'] = vbap.head(10000)
+        
+        # Customer Master (KNA1)
+        kna1_path = f"{download_path}/kna1.csv"
+        if os.path.exists(kna1_path):
+            kna1 = pd.read_csv(kna1_path)
+            tables['customers'] = kna1.head(3000)
+        
+        # Material Descriptions (MAKT)
+        makt_path = f"{download_path}/makt.csv"
+        if os.path.exists(makt_path):
+            makt = pd.read_csv(makt_path)
+            # Filter for English descriptions only
+            makt_en = makt[makt.get('spras', makt.get('SPRAS', '')) == 'E']
+            tables['material_texts'] = makt_en.head(3000)
         
         return tables
         
-    except ImportError:
-        st.error("kagglehub not available. Using alternative data source.")
-        return load_alternative_data()
     except Exception as e:
         st.error(f"Error loading Kaggle dataset: {str(e)}")
-        return load_alternative_data()
-
-def load_alternative_data():
-    """
-    Load sample SAP-like data as fallback when Kaggle is not available
-    """
-    np.random.seed(42)
-    
-    # Generate realistic SAP sales data structure
-    n_orders = 2000
-    n_items = 5000
-    
-    # Sales Order Header (VBAK equivalent)
-    sales_orders = pd.DataFrame({
-        'vbeln': [f'{100000000 + i:010d}' for i in range(n_orders)],
-        'kunnr': [f'{i%500 + 1:010d}' for i in range(n_orders)],
-        'vkorg': np.random.choice(['1000', '2000', '3000'], n_orders),
-        'vtweg': np.random.choice(['10', '20', '30'], n_orders),
-        'spart': np.random.choice(['01', '02', '03'], n_orders),
-        'erdat': pd.date_range('2022-01-01', periods=n_orders, freq='D'),
-        'waerk': 'USD'
-    })
-    
-    # Sales Order Items (VBAP equivalent)
-    sales_items = []
-    for _, order in sales_orders.iterrows():
-        items_count = np.random.randint(1, 6)
-        for j in range(items_count):
-            sales_items.append({
-                'vbeln': order['vbeln'],
-                'posnr': f'{(j+1)*10:06d}',
-                'matnr': f'MAT{np.random.randint(1, 1000):06d}',
-                'kwmeng': np.random.uniform(1, 100),
-                'netwr': np.random.uniform(100, 50000),
-                'werks': np.random.choice(['1000', '2000', '3000'])
-            })
-    
-    sales_items_df = pd.DataFrame(sales_items)
-    
-    # Customer Master (KNA1 equivalent)
-    customers = pd.DataFrame({
-        'kunnr': [f'{i+1:010d}' for i in range(500)],
-        'name1': [f'Customer Company {chr(65 + i%26)}{i:03d}' for i in range(500)],
-        'land1': np.random.choice(['US', 'DE', 'CN', 'IN', 'BR', 'FR', 'UK', 'JP'], 500),
-        'regio': [f'REG{i%10:02d}' for i in range(500)]
-    })
-    
-    # Material Text (MAKT equivalent)
-    materials = pd.DataFrame({
-        'matnr': [f'MAT{i:06d}' for i in range(1, 1001)],
-        'maktx': [f'Product {i:04d} - {np.random.choice(["Software", "Hardware", "Service", "Cloud", "Analytics"])}' for i in range(1, 1001)],
-        'spras': 'E'
-    })
-    
-    return {
-        'sales_orders': sales_orders,
-        'sales_items': sales_items_df,
-        'customers': customers,
-        'material_texts': materials
-    }
+        st.error("Please ensure you have:")
+        st.error("1. Kaggle API installed: `pip install kaggle`")
+        st.error("2. Kaggle credentials configured (kaggle.json file)")
+        st.error("3. Internet connection to download dataset")
+        return None
 
 def create_sales_analytics(tables):
     """
-    Create sales analytics from SAP data
+    Create sales analytics from real SAP data
     """
+    if not tables:
+        return None
+        
     try:
         vbak = tables.get('sales_orders', pd.DataFrame())
         vbap = tables.get('sales_items', pd.DataFrame())
@@ -169,40 +114,56 @@ def create_sales_analytics(tables):
         makt = tables.get('material_texts', pd.DataFrame())
         
         if vbak.empty or vbap.empty:
+            st.error("Required SAP tables (VBAK, VBAP) not found in dataset")
             return None
         
-        # Normalize column names to lowercase
-        vbak.columns = vbak.columns.str.lower()
-        vbap.columns = vbap.columns.str.lower()
+        # Normalize column names
+        vbak.columns = vbak.columns.str.upper()
+        vbap.columns = vbap.columns.str.upper()
         if not kna1.empty:
-            kna1.columns = kna1.columns.str.lower()
+            kna1.columns = kna1.columns.str.upper()
         if not makt.empty:
-            makt.columns = makt.columns.str.lower()
+            makt.columns = makt.columns.str.upper()
         
         # Join sales orders with items
+        required_vbak_cols = ['VBELN', 'KUNNR', 'VKORG', 'VTWEG', 'SPART', 'ERDAT']
+        required_vbap_cols = ['VBELN', 'POSNR', 'MATNR', 'KWMENG', 'NETWR', 'WERKS']
+        
+        # Check if required columns exist
+        missing_vbak = [col for col in required_vbak_cols if col not in vbak.columns]
+        missing_vbap = [col for col in required_vbap_cols if col not in vbap.columns]
+        
+        if missing_vbak:
+            st.error(f"Missing columns in VBAK: {missing_vbak}")
+            return None
+        if missing_vbap:
+            st.error(f"Missing columns in VBAP: {missing_vbap}")
+            return None
+        
+        # Join tables
         sales_data = pd.merge(
-            vbak[['vbeln', 'kunnr', 'vkorg', 'vtweg', 'spart', 'erdat', 'waerk']],
-            vbap[['vbeln', 'posnr', 'matnr', 'kwmeng', 'netwr', 'werks']],
-            on='vbeln',
+            vbak[required_vbak_cols],
+            vbap[required_vbap_cols],
+            on='VBELN',
             how='inner'
         )
         
-        # Add customer info
-        if not kna1.empty and 'name1' in kna1.columns:
-            customer_info = kna1[['kunnr', 'name1', 'land1', 'regio']]
-            sales_data = pd.merge(sales_data, customer_info, on='kunnr', how='left')
+        # Add customer info if available
+        if not kna1.empty and all(col in kna1.columns for col in ['KUNNR', 'NAME1', 'LAND1']):
+            customer_info = kna1[['KUNNR', 'NAME1', 'LAND1', 'REGIO']]
+            sales_data = pd.merge(sales_data, customer_info, on='KUNNR', how='left')
         
-        # Add material descriptions
-        if not makt.empty and 'maktx' in makt.columns:
-            material_info = makt[['matnr', 'maktx']]
-            sales_data = pd.merge(sales_data, material_info, on='matnr', how='left')
+        # Add material descriptions if available
+        if not makt.empty and all(col in makt.columns for col in ['MATNR', 'MAKTX']):
+            material_info = makt[['MATNR', 'MAKTX']]
+            sales_data = pd.merge(sales_data, material_info, on='MATNR', how='left')
         
         # Clean data
-        sales_data['netwr'] = pd.to_numeric(sales_data['netwr'], errors='coerce').fillna(0)
-        sales_data['kwmeng'] = pd.to_numeric(sales_data['kwmeng'], errors='coerce').fillna(0)
+        sales_data['NETWR'] = pd.to_numeric(sales_data['NETWR'], errors='coerce').fillna(0)
+        sales_data['KWMENG'] = pd.to_numeric(sales_data['KWMENG'], errors='coerce').fillna(0)
         
-        if 'erdat' in sales_data.columns:
-            sales_data['erdat'] = pd.to_datetime(sales_data['erdat'], errors='coerce')
+        if 'ERDAT' in sales_data.columns:
+            sales_data['ERDAT'] = pd.to_datetime(sales_data['ERDAT'], errors='coerce')
         
         return sales_data
         
@@ -233,61 +194,78 @@ def main():
     st.markdown("""
     <div style="text-align: center; margin-bottom: 2rem;">
         <p style="font-size: 1.2rem; color: #666;">
-        SAP ERP Sales Data Analytics | Customer • Regional • Channel • Product KPIs
+        Real SAP ERP Sales Data from Kaggle | Customer • Regional • Channel • Product KPIs
         </p>
     </div>
     """, unsafe_allow_html=True)
     
+    # Instructions for setup
+    with st.expander("📋 Setup Instructions", expanded=False):
+        st.markdown("""
+        **To use this dashboard, you need:**
+        
+        1. **Install Kaggle API**: `pip install kaggle`
+        2. **Configure Kaggle credentials**:
+           - Go to Kaggle → Account → API → Create New Token
+           - Download kaggle.json file
+           - Place it in ~/.kaggle/kaggle.json (Linux/Mac) or C:/Users/{username}/.kaggle/kaggle.json (Windows)
+        3. **Set permissions**: `chmod 600 ~/.kaggle/kaggle.json`
+        
+        **Dataset Source**: [mustafakeser4/sap-dataset-bigquery-dataset](https://www.kaggle.com/datasets/mustafakeser4/sap-dataset-bigquery-dataset)
+        """)
+    
     # Load data
-    with st.spinner("Loading SAP dataset..."):
+    with st.spinner("Loading real SAP dataset from Kaggle..."):
         tables = load_kaggle_sap_data()
     
     if not tables:
-        st.error("Failed to load dataset")
+        st.error("❌ Failed to load SAP dataset from Kaggle")
+        st.info("Please check the setup instructions above and ensure your Kaggle API is properly configured.")
         return
     
     # Process sales data
-    with st.spinner("Processing sales analytics..."):
+    with st.spinner("Processing sales analytics from real SAP data..."):
         sales_df = create_sales_analytics(tables)
     
     if sales_df is None or sales_df.empty:
-        st.error("No sales data available for analysis")
+        st.error("❌ No valid sales data available for analysis")
         return
     
-    # Data summary
-    st.success(f"✅ Loaded {len(sales_df):,} sales records")
+    # Success message
+    st.success(f"✅ Successfully loaded {len(sales_df):,} real SAP sales records from Kaggle!")
     
-    # Sidebar
-    st.sidebar.header("📊 Dataset Information")
-    st.sidebar.info(f"""
-    **SAP Tables:**
+    # Sidebar information
+    st.sidebar.header("📊 Real SAP Dataset Information")
+    st.sidebar.success(f"""
+    **Loaded SAP Tables:**
     - VBAK: Sales Orders ({len(tables.get('sales_orders', []))})
     - VBAP: Sales Items ({len(tables.get('sales_items', []))})
     - KNA1: Customers ({len(tables.get('customers', []))})
     - MAKT: Materials ({len(tables.get('material_texts', []))})
     
     **Analysis Records:** {len(sales_df):,}
+    **Data Source:** Kaggle - Real SAP ERP Data
     """)
     
     # Main KPIs
-    st.subheader("🎯 Key Performance Indicators")
+    st.subheader("🎯 Sales KPIs from Real SAP Data")
     
     col1, col2, col3, col4 = st.columns(4)
     
     with col1:
-        total_revenue = sales_df['netwr'].sum()
+        total_revenue = sales_df['NETWR'].sum()
         create_kpi_card("Total Revenue", total_revenue, "currency")
     
     with col2:
-        unique_customers = sales_df['kunnr'].nunique()
+        unique_customers = sales_df['KUNNR'].nunique()
         create_kpi_card("Active Customers", unique_customers, "number")
     
     with col3:
-        avg_order_value = sales_df['netwr'].mean()
+        avg_order_value = sales_df['NETWR'].mean()
         create_kpi_card("Avg Order Value", avg_order_value, "currency")
     
     with col4:
-        total_orders = sales_df['vbeln'].nunique()
+        total_orders = sales_df['VBELN'].nunique()
         create_kpi_card("Sales Orders", total_orders, "number")
     
     # Analytics Tabs
@@ -299,141 +277,169 @@ def main():
     ])
     
     with tab1:
-        st.subheader("👥 Top 10 Customers by Revenue")
+        st.subheader("👥 Top 10 Customers by Revenue (Real SAP Data)")
         
-        if 'name1' in sales_df.columns:
-            customer_sales = sales_df.groupby(['kunnr', 'name1'])['netwr'].sum().reset_index()
+        if 'NAME1' in sales_df.columns:
+            customer_sales = sales_df.groupby(['KUNNR', 'NAME1'])['NETWR'].sum().reset_index()
+            customer_display_col = 'NAME1'
         else:
-            customer_sales = sales_df.groupby('kunnr')['netwr'].sum().reset_index()
-            customer_sales['name1'] = customer_sales['kunnr']
-        
-        top_customers = customer_sales.nlargest(10, 'netwr')
-        
-        fig = px.bar(
-            top_customers,
-            x='netwr',
-            y='name1',
-            orientation='h',
-            title="Top 10 Customers by Revenue",
-            labels={'netwr': 'Revenue ($)', 'name1': 'Customer'},
-            color='netwr',
-            color_continuous_scale='Blues'
-        )
-        fig.update_layout(height=500, yaxis={'categoryorder': 'total ascending'})
-        st.plotly_chart(fig, use_container_width=True)
+            customer_sales = sales_df.groupby('KUNNR')['NETWR'].sum().reset_index()
+            customer_sales['NAME1'] = customer_sales['KUNNR']
+            customer_display_col = 'KUNNR'
+        
+        top_customers = customer_sales.nlargest(10, 'NETWR')
         
-        # Customer table
-        display_customers = top_customers.copy()
-        display_customers['Revenue'] = display_customers['netwr'].apply(lambda x: f"${x:,.0f}")
-        st.dataframe(display_customers[['kunnr', 'name1', 'Revenue']], use_container_width=True)
+        if not top_customers.empty:
+            fig = px.bar(
+                top_customers,
+                x='NETWR',
+                y=customer_display_col,
+                orientation='h',
+                title="Top 10 Customers by Revenue",
+                labels={'NETWR': 'Revenue ($)', customer_display_col: 'Customer'},
+                color='NETWR',
+                color_continuous_scale='Blues'
+            )
+            fig.update_layout(height=500, yaxis={'categoryorder': 'total ascending'})
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Customer table
+            display_customers = top_customers.copy()
+            display_customers['Revenue'] = display_customers['NETWR'].apply(lambda x: f"${x:,.0f}")
+            st.dataframe(display_customers[['KUNNR', customer_display_col, 'Revenue']], use_container_width=True)
+        else:
+            st.warning("No customer data available")
     
     with tab2:
-        st.subheader("🌍 Regional Sales Analysis")
+        st.subheader("🌍 Regional Sales Analysis (Real SAP Data)")
         
-        if 'land1' in sales_df.columns:
-            regional_sales = sales_df.groupby('land1')['netwr'].sum().reset_index()
-            regional_sales = regional_sales.sort_values('netwr', ascending=False).head(10)
-            
-            col1, col2 = st.columns(2)
+        if 'LAND1' in sales_df.columns:
+            regional_sales = sales_df.groupby('LAND1')['NETWR'].sum().reset_index()
+            regional_sales = regional_sales.sort_values('NETWR', ascending=False).head(10)
             
-            with col1:
-                fig = px.bar(
-                    regional_sales,
-                    x='netwr',
-                    y='land1',
-                    orientation='h',
-                    title="Revenue by Country",
-                    labels={'netwr': 'Revenue ($)', 'land1': 'Country'},
-                    color='netwr',
-                    color_continuous_scale='Viridis'
-                )
-                fig.update_layout(height=400, yaxis={'categoryorder': 'total ascending'})
-                st.plotly_chart(fig, use_container_width=True)
-            
-            with col2:
-                fig = px.pie(
-                    regional_sales,
-                    values='netwr',
-                    names='land1',
-                    title="Revenue Distribution by Country"
-                )
-                fig.update_layout(height=400)
-                st.plotly_chart(fig, use_container_width=True)
+            if not regional_sales.empty:
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    fig = px.bar(
+                        regional_sales,
+                        x='NETWR',
+                        y='LAND1',
+                        orientation='h',
+                        title="Revenue by Country",
+                        labels={'NETWR': 'Revenue ($)', 'LAND1': 'Country'},
+                        color='NETWR',
+                        color_continuous_scale='Viridis'
+                    )
+                    fig.update_layout(height=400, yaxis={'categoryorder': 'total ascending'})
+                    st.plotly_chart(fig, use_container_width=True)
+                
+                with col2:
+                    fig = px.pie(
+                        regional_sales,
+                        values='NETWR',
+                        names='LAND1',
+                        title="Revenue Distribution by Country"
+                    )
+                    fig.update_layout(height=400)
+                    st.plotly_chart(fig, use_container_width=True)
         else:
-            st.info("Regional data not available")
+            st.warning("Regional data (LAND1) not available in the loaded dataset")
     
     with tab3:
-        st.subheader("📈 Distribution Channel Performance")
+        st.subheader("📈 Distribution Channel Performance (Real SAP Data)")
         
-        if 'vtweg' in sales_df.columns:
-            channel_sales = sales_df.groupby('vtweg')['netwr'].sum().reset_index()
-            channel_sales = channel_sales.sort_values('netwr', ascending=False)
+        if 'VTWEG' in sales_df.columns:
+            channel_sales = sales_df.groupby('VTWEG')['NETWR'].sum().reset_index()
+            channel_sales = channel_sales.sort_values('NETWR', ascending=False)
             
             fig = px.bar(
                 channel_sales,
-                x='vtweg',
-                y='netwr',
+                x='VTWEG',
+                y='NETWR',
                 title="Revenue by Distribution Channel",
-                labels={'netwr': 'Revenue ($)', 'vtweg': 'Channel'},
-                color='netwr',
+                labels={'NETWR': 'Revenue ($)', 'VTWEG': 'Distribution Channel'},
+                color='NETWR',
                 color_continuous_scale='Plasma'
             )
             fig.update_layout(height=400)
             st.plotly_chart(fig, use_container_width=True)
             
-            # Organization analysis
-            if 'vkorg' in sales_df.columns:
-                org_sales = sales_df.groupby('vkorg')['netwr'].sum().reset_index()
-                org_sales = org_sales.sort_values('netwr', ascending=False)
+            # Sales organization analysis
+            if 'VKORG' in sales_df.columns:
+                org_sales = sales_df.groupby('VKORG')['NETWR'].sum().reset_index()
+                org_sales = org_sales.sort_values('NETWR', ascending=False)
                 
                 st.subheader("📊 Sales Organization Performance")
                 fig = px.bar(
                     org_sales,
-                    x='vkorg',
-                    y='netwr',
+                    x='VKORG',
+                    y='NETWR',
                     title="Revenue by Sales Organization",
-                    labels={'netwr': 'Revenue ($)', 'vkorg': 'Sales Org'},
-                    color='netwr',
+                    labels={'NETWR': 'Revenue ($)', 'VKORG': 'Sales Organization'},
+                    color='NETWR',
                     color_continuous_scale='Cividis'
                 )
                 fig.update_layout(height=400)
                 st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.warning("Distribution channel data (VTWEG) not available")
     
     with tab4:
-        st.subheader("🛍️ Top 10 Products by Revenue")
+        st.subheader("🛍️ Top 10 Products by Revenue (Real SAP Data)")
         
-        if 'maktx' in sales_df.columns:
-            product_sales = sales_df.groupby(['matnr', 'maktx'])['netwr'].sum().reset_index()
+        if 'MAKTX' in sales_df.columns:
+            product_sales = sales_df.groupby(['MATNR', 'MAKTX'])['NETWR'].sum().reset_index()
+            product_display_col = 'MAKTX'
         else:
-            product_sales = sales_df.groupby('matnr')['netwr'].sum().reset_index()
-            product_sales['maktx'] = product_sales['matnr']
-        
-        top_products = product_sales.nlargest(10, 'netwr')
-        
-        fig = px.bar(
-            top_products,
-            x='netwr',
-            y='maktx',
-            orientation='h',
-            title="Top 10 Products by Revenue",
-            labels={'netwr': 'Revenue ($)', 'maktx': 'Product'},
-            color='netwr',
-            color_continuous_scale='Set3'
-        )
-        fig.update_layout(height=500, yaxis={'categoryorder': 'total ascending'})
-        st.plotly_chart(fig, use_container_width=True)
+            product_sales = sales_df.groupby('MATNR')['NETWR'].sum().reset_index()
+            product_sales['MAKTX'] = product_sales['MATNR']  
+            product_display_col = 'MATNR'
         
-        # Product table
-        display_products = top_products.copy()
-        display_products['Revenue'] = display_products['netwr'].apply(lambda x: f"${x:,.0f}")
-        st.dataframe(display_products[['matnr', 'maktx', 'Revenue']], use_container_width=True)
+        top_products = product_sales.nlargest(10, 'NETWR')
+        
+        if not top_products.empty:
+            fig = px.bar(
+                top_products,
+                x='NETWR',
+                y=product_display_col,
+                orientation='h',
+                title="Top 10 Products by Revenue",
+                labels={'NETWR': 'Revenue ($)', product_display_col: 'Product'},
+                color='NETWR',
+                color_continuous_scale='Set3'
+            )
+            fig.update_layout(height=500, yaxis={'categoryorder': 'total ascending'})
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Product table
+            display_products = top_products.copy()
+            display_products['Revenue'] = display_products['NETWR'].apply(lambda x: f"${x:,.0f}")
+            st.dataframe(display_products[['MATNR', product_display_col, 'Revenue']], use_container_width=True)
+        else:
+            st.warning("No product data available")
+    
+    # Raw data viewer
+    with st.expander("🔍 View Raw SAP Data", expanded=False):
+        st.subheader("Raw Sales Data Sample")
+        st.dataframe(sales_df.head(100), use_container_width=True)
+        
+        # Download option
+        csv = sales_df.to_csv(index=False)
+        st.download_button(
+            label="📥 Download Real SAP Sales Data (CSV)",
+            data=csv,
+            file_name="real_sap_sales_data.csv",
+            mime="text/csv"
+        )
     
     # Footer
     st.markdown("---")
     st.markdown("""
     <div style="text-align: center; color: #666; margin-top: 2rem;">
-        <p><strong>SAP Sales Analytics Dashboard</strong></p>
-        <p>Built with Streamlit • Data Source: Kaggle SAP Dataset</p>
+        <p><strong>Real SAP Sales Analytics Dashboard</strong></p>
+        <p>Data Source: <a href="https://www.kaggle.com/datasets/mustafakeser4/sap-dataset-bigquery-dataset" target="_blank">Kaggle SAP Dataset</a></p>
+        <p>Built with Streamlit • No Synthetic Data • 100% Real SAP ERP Data</p>
     </div>
     """, unsafe_allow_html=True)