Update src/streamlit_app.py

src/streamlit_app.py

@@ -30,40 +30,194 @@ def main():
         manual_interface()
 
 def excel_interface():
-    """Handle Excel file upload and analysis."""
+    """Handle Excel file upload with CSV conversion for HF Spaces compatibility."""
     st.header("📁 Excel File Analysis")
     
+    # Add file upload instructions
+    st.info("💡 Upload an Excel file with 'Config' and 'Data' sheets. The file will be converted to CSV format for processing.")
+    
     uploaded_file = st.file_uploader(
         "Upload Excel file with Config and Data sheets",
-        type=['xlsx'],
-        help="Excel file should have 'Config' sheet (category, maximize) and 'Data' sheet (name, category values)"
+        type=['xlsx', 'xls'],
+        help="Excel file should have 'Config' sheet (category, maximize) and 'Data' sheet (name, category values)",
+        key="excel_uploader"
     )
     
     if uploaded_file is not None:
-        try:
-            # Load calculator from Excel
-            calc = UtilityCalculator.from_excel(uploaded_file)
-            
-            st.success(f"✅ Loaded {len(calc.products)} products with {len(calc.categories)} categories")
+        st.success(f"✅ File uploaded: **{uploaded_file.name}**")
+        
+        # Show file details
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("File Size", f"{uploaded_file.size:,} bytes")
+        with col2:
+            st.metric("File Type", uploaded_file.type)
+        with col3:
+            process_button = st.button("🚀 Process File", type="primary", use_container_width=True)
+        
+        if process_button:
+            with st.spinner("🔄 Processing Excel file via CSV conversion..."):
+                try:
+                    # Method 1: HF Spaces compatible approach
+                    # Read Excel file and convert to CSV in memory
+                    uploaded_file.seek(0)
+                    
+                    # Read both sheets from Excel
+                    config_df = pd.read_excel(uploaded_file, sheet_name='Config')
+                    data_df = pd.read_excel(uploaded_file, sheet_name='Data')
+                    
+                    st.success("✅ Successfully read Excel sheets")
+                    
+                    # Show preview of what we read
+                    with st.expander("📋 File Contents Preview", expanded=True):
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.write("**Config Sheet:**")
+                            st.dataframe(config_df, use_container_width=True)
+                        with col2:
+                            st.write("**Data Sheet:**")
+                            st.dataframe(data_df.head(), use_container_width=True)
+                    
+                    # Convert to CSV format (in memory) - this is the key part!
+                    import io
+                    config_csv = io.StringIO()
+                    data_csv = io.StringIO()
+                    
+                    config_df.to_csv(config_csv, index=False)
+                    data_df.to_csv(data_csv, index=False)
+                    
+                    # Reset StringIO positions
+                    config_csv.seek(0)
+                    data_csv.seek(0)
+                    
+                    st.info("🔄 Converted to CSV format for processing...")
+                    
+                    # Now create the MCDA calculator from the CSV data
+                    # Parse categories and maximize settings
+                    categories = config_df['category'].tolist()
+                    maximize_values = config_df['maximize'].tolist()
+                    maximize = dict(zip(categories, maximize_values))
+                    
+                    # Create calculator
+                    calc = UtilityCalculator(categories, maximize)
+                    
+                    # Add products from data
+                    for _, row in data_df.iterrows():
+                        product_name = row['name']
+                        scores = {cat: row[cat] for cat in categories if cat in row}
+                        calc.add_product(product_name, scores)
+                    
+                    st.success(f"✅ Successfully created calculator with {len(calc.products)} products and {len(calc.categories)} categories")
+                    
+                    # Store in session state
+                    st.session_state['excel_calculator'] = calc
+                    st.session_state['excel_filename'] = uploaded_file.name
+                    
+                    # Display configuration
+                    st.subheader("📋 Configuration")
+                    config_display_df = pd.DataFrame({
+                        'Category': calc.categories,
+                        'Optimize': ['Maximize' if calc.maximize[cat] else 'Minimize' for cat in calc.categories],
+                        'Weight': [calc.weights[cat] for cat in calc.categories]
+                    })
+                    st.dataframe(config_display_df, use_container_width=True)
+                    
+                    # Weight adjustment
+                    adjust_weights(calc)
+                    
+                    # Results
+                    display_results(calc)
+                    
+                except Exception as e:
+                    st.error(f"❌ Error processing Excel file: {str(e)}")
+                    
+                    # Enhanced debugging
+                    with st.expander("🐛 Detailed Error Information"):
+                        st.write("**Error Details:**")
+                        st.write(f"- Error type: {type(e).__name__}")
+                        st.write(f"- Error message: {str(e)}")
+                        
+                        # Try to diagnose the issue
+                        try:
+                            uploaded_file.seek(0)
+                            excel_file = pd.ExcelFile(uploaded_file)
+                            st.write(f"- Available sheets: {excel_file.sheet_names}")
+                            
+                            # Check if required sheets exist
+                            if 'Config' not in excel_file.sheet_names:
+                                st.error("❌ 'Config' sheet not found")
+                            if 'Data' not in excel_file.sheet_names:
+                                st.error("❌ 'Data' sheet not found")
+                                
+                        except Exception as diag_error:
+                            st.write(f"- Could not diagnose: {diag_error}")
+                        
+                        import traceback
+                        st.code(traceback.format_exc())
+    
+    # Display results if calculator is in session state (from previous processing)
+    elif 'excel_calculator' in st.session_state:
+        calc = st.session_state['excel_calculator']
+        filename = st.session_state.get('excel_filename', 'Previous file')
+        
+        st.info(f"📊 Currently analyzing: **{filename}**")
+        
+        if st.button("🔄 Clear and Upload New File"):
+            if 'excel_calculator' in st.session_state:
+                del st.session_state['excel_calculator']
+            if 'excel_filename' in st.session_state:
+                del st.session_state['excel_filename']
+            st.rerun()
+        
+        # Display configuration
+        st.subheader("📋 Configuration")
+        config_df = pd.DataFrame({
+            'Category': calc.categories,
+            'Optimize': ['Maximize' if calc.maximize[cat] else 'Minimize' for cat in calc.categories],
+            'Weight': [calc.weights[cat] for cat in calc.categories]
+        })
+        st.dataframe(config_df, use_container_width=True)
+        
+        # Weight adjustment
+        adjust_weights(calc)
+        
+        # Results
+        display_results(calc)
+    
+    else:
+        st.info("📤 Please upload an Excel file and click 'Process File' to begin analysis")
+        
+        # Add sample download option
+        if st.button("📥 Download Sample Excel Template"):
+            # Create sample data
+            sample_config = pd.DataFrame({
+                'category': ['Performance', 'Cost', 'Quality', 'Reliability'],
+                'maximize': [True, False, True, True]
+            })
             
-            # Display configuration
-            st.subheader("Configuration")
-            config_df = pd.DataFrame({
-                'Category': calc.categories,
-                'Optimize': ['Maximize' if calc.maximize[cat] else 'Minimize' for cat in calc.categories],
-                'Weight': [calc.weights[cat] for cat in calc.categories]
+            sample_data = pd.DataFrame({
+                'name': ['Product_A', 'Product_B', 'Product_C', 'Product_D'],
+                'Performance': [85, 70, 90, 75],
+                'Cost': [120, 100, 140, 110],
+                'Quality': [90, 85, 95, 80],
+                'Reliability': [88, 92, 85, 90]
             })
-            st.dataframe(config_df, use_container_width=True)
             
-            # Weight adjustment
-            adjust_weights(calc)
+            # Create Excel file in memory
+            import io
+            excel_buffer = io.BytesIO()
+            with pd.ExcelWriter(excel_buffer, engine='openpyxl') as writer:
+                sample_config.to_excel(writer, sheet_name='Config', index=False)
+                sample_data.to_excel(writer, sheet_name='Data', index=False)
             
-            # Results
-            display_results(calc)
+            excel_buffer.seek(0)
             
-        except Exception as e:
-            st.error(f"❌ Error loading Excel file: {str(e)}")
-            st.info("Make sure your Excel file has 'Config' and 'Data' sheets with the correct format.")
+            st.download_button(
+                label="📁 Download Sample.xlsx",
+                data=excel_buffer.getvalue(),
+                file_name="MCDA_Sample_Template.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
 
 def manual_interface():
     """Handle manual data entry interface."""