Update src/streamlit_app.py

src/streamlit_app.py

@@ -15,245 +15,29 @@ def main():
     st.title("⚖️ Multi-Criteria Decision Analysis (MCDA) Calculator")
     st.markdown("Compare products and alternatives using weighted criteria analysis")
     
-    # Sidebar for configuration
-    st.sidebar.header("📋 Configuration")
-    
-    # Step 1: Choose input method
-    input_method = st.sidebar.radio(
-        "How would you like to input data?",
-        ["Manual Entry", "Upload Excel File"]
-    )
-    
-    if input_method == "Upload Excel File":
-        excel_interface()
-    else:
-        manual_interface()
-
-def excel_interface():
-    """Handle Excel file upload with improved HF Spaces compatibility."""
-    st.header("📁 Excel File Analysis")
-    
-    # Add file upload instructions
-    st.info("💡 Upload an Excel file with 'Config' and 'Data' sheets.")
-    
-    uploaded_file = st.file_uploader(
-        "Upload Excel file with Config and Data sheets",
-        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:
-        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..."):
-                try:
-                    # Reset file pointer
-                    uploaded_file.seek(0)
-                    
-                    # Try different engines for better compatibility
-                    try:
-                        # First try openpyxl (preferred for .xlsx)
-                        config_df = pd.read_excel(uploaded_file, sheet_name='Config', engine='openpyxl')
-                        uploaded_file.seek(0)  # Reset again
-                        data_df = pd.read_excel(uploaded_file, sheet_name='Data', engine='openpyxl')
-                    except Exception as e1:
-                        st.warning(f"openpyxl failed: {e1}. Trying xlrd...")
-                        try:
-                            # Fallback to xlrd (for .xls files)
-                            uploaded_file.seek(0)
-                            config_df = pd.read_excel(uploaded_file, sheet_name='Config', engine='xlrd')
-                            uploaded_file.seek(0)
-                            data_df = pd.read_excel(uploaded_file, sheet_name='Data', engine='xlrd')
-                        except Exception as e2:
-                            st.error(f"Both engines failed. openpyxl: {e1}, xlrd: {e2}")
-                            # Try without specifying engine
-                            uploaded_file.seek(0)
-                            config_df = pd.read_excel(uploaded_file, sheet_name='Config')
-                            uploaded_file.seek(0)
-                            data_df = pd.read_excel(uploaded_file, sheet_name='Data')
-                    
-                    st.success("✅ Successfully read Excel sheets")
-                    
-                    # Validate required columns
-                    if 'category' not in config_df.columns or 'maximize' not in config_df.columns:
-                        st.error("❌ Config sheet must have 'category' and 'maximize' columns")
-                        return
-                    
-                    if 'name' not in data_df.columns:
-                        st.error("❌ Data sheet must have 'name' column")
-                        return
-                    
-                    # 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)
-                    
-                    # Parse categories and maximize settings
-                    categories = config_df['category'].tolist()
-                    maximize_values = config_df['maximize'].tolist()
-                    maximize = dict(zip(categories, maximize_values))
-                    
-                    # Validate that all categories exist in data
-                    missing_categories = [cat for cat in categories if cat not in data_df.columns]
-                    if missing_categories:
-                        st.error(f"❌ Missing categories in Data sheet: {missing_categories}")
-                        return
-                    
-                    # 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 and pd.notna(row[cat])}
-                        
-                        # Check for missing values
-                        if len(scores) != len(categories):
-                            missing = [cat for cat in categories if cat not in scores]
-                            st.warning(f"⚠️ Product '{product_name}' missing values for: {missing}")
-                        
-                        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)
-                            # Check available pandas Excel engines
-                            st.write("**Available pandas engines:**")
-                            try:
-                                import openpyxl
-                                st.write("✅ openpyxl available")
-                            except ImportError:
-                                st.write("❌ openpyxl not available")
-                            
-                            # Try to read sheet names
-                            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')
+    # Add info about Excel functionality
+    with st.expander("📖 About This Tool"):
+        st.write("""
+        **What is MCDA?**
+        Multi-Criteria Decision Analysis helps you make objective decisions when comparing 
+        products, services, or alternatives across multiple criteria.
         
-        st.info(f"📊 Currently analyzing: **{filename}**")
+        **How to use:**
+        1. Define your evaluation categories (Performance, Cost, Quality, etc.)
+        2. Add the products/options you want to compare
+        3. Adjust category weights based on importance
+        4. View rankings and detailed analysis
         
-        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)
+        **Need Excel functionality?** 
+        Download our companion Excel template generator for offline analysis!
+        """)
     
-    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]
-            })
-            
-            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]
-            })
-            
-            # 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)
-            
-            excel_buffer.seek(0)
-            
-            st.download_button(
-                label="📁 Download Sample.xlsx",
-                data=excel_buffer.getvalue(),
-                file_name="MCDA_Sample_Template.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
+    # Manual interface only for HF Spaces
+    manual_interface()
 
 def manual_interface():
     """Handle manual data entry interface."""
-    st.header("✏️ Manual Data Entry")
+    st.header("✏️ Interactive Data Entry")
     
     # Step 1: Define categories
     st.subheader("1. Define Categories")
@@ -265,7 +49,7 @@ def manual_interface():
             "Enter categories (one per line):",
             value="Performance\nCost\nReliability",
             height=100,
-            help="Enter each category on a new line"
+            help="Enter each category on a new line. Examples: Performance, Cost, Quality, Ease_of_Use"
         )
         categories = [cat.strip() for cat in categories_input.split('\n') if cat.strip()]
     
@@ -341,33 +125,33 @@ def data_entry_interface(categories):
     if 'products' not in st.session_state:
         st.session_state.products = []
     
-    # Add new product form
-    with st.expander("➕ Add New Product", expanded=len(st.session_state.products) == 0):
-        with st.form("add_product"):
-            col1, col2 = st.columns([1, 2])
-            
-            with col1:
-                product_name = st.text_input("Product Name", placeholder="e.g., Product A")
-            
-            with col2:
-                scores = {}
-                cols = st.columns(len(categories))
-                for i, cat in enumerate(categories):
-                    with cols[i]:
-                        scores[cat] = st.number_input(f"{cat}", value=0.0, step=1.0)
-            
-            submitted = st.form_submit_button("Add Product")
-            
-            if submitted and product_name:
-                # Check if product name already exists
-                existing_names = [p['name'] for p in st.session_state.products]
-                if product_name in existing_names:
-                    st.error(f"❌ Product '{product_name}' already exists. Please use a different name.")
-                else:
-                    new_product = {'name': product_name, **scores}
-                    st.session_state.products.append(new_product)
-                    st.success(f"✅ Added {product_name}")
-                    st.rerun()
+    # Quick add section
+    st.write("**Quick Add Products:**")
+    with st.form("quick_add_product", clear_on_submit=True):
+        cols = st.columns([2] + [1] * len(categories) + [1])
+        
+        with cols[0]:
+            product_name = st.text_input("Product Name", placeholder="e.g., Product A")
+        
+        scores = {}
+        for i, cat in enumerate(categories, 1):
+            with cols[i]:
+                scores[cat] = st.number_input(f"{cat}", value=0.0, step=1.0, key=f"quick_{cat}")
+        
+        with cols[-1]:
+            st.write(" ")  # Spacer
+            submitted = st.form_submit_button("➕ Add", type="primary")
+        
+        if submitted and product_name:
+            # Check if product name already exists
+            existing_names = [p['name'] for p in st.session_state.products]
+            if product_name in existing_names:
+                st.error(f"❌ Product '{product_name}' already exists. Please use a different name.")
+            else:
+                new_product = {'name': product_name, **scores}
+                st.session_state.products.append(new_product)
+                st.success(f"✅ Added {product_name}")
+                st.rerun()
     
     # Display current products with edit/delete options
     if st.session_state.products:
@@ -381,124 +165,105 @@ def data_entry_interface(categories):
         edited_df = st.data_editor(
             df,
             use_container_width=True,
-            num_rows="dynamic",  # This should allow adding/deleting rows
-            key="products_editor"
+            num_rows="dynamic",
+            key="products_editor",
+            column_config={
+                "name": st.column_config.TextColumn("Product Name", help="Name of the product/option"),
+                **{cat: st.column_config.NumberColumn(cat, help=f"Score for {cat}") for cat in categories}
+            }
         )
         
         # Update session state with edited data
         st.session_state.products = edited_df.to_dict('records')
         
-        # Individual product management
-        st.write("**Manage Individual Products:**")
-        
-        col1, col2, col3 = st.columns([2, 1, 1])
+        # Bulk operations
+        col1, col2, col3 = st.columns(3)
         
         with col1:
-            # Select product to edit/delete
-            if st.session_state.products:
-                product_names = [p['name'] for p in st.session_state.products]
-                selected_product = st.selectbox(
-                    "Select product to manage:",
-                    options=product_names,
-                    key="product_selector"
-                )
-        
-        with col2:
-            # Edit button
-            if st.button("✏️ Edit Selected", key="edit_button"):
-                if 'edit_mode' not in st.session_state:
+            if st.button("🗑️ Clear All Products", type="secondary"):
+                st.session_state.products = []
+                if 'edit_mode' in st.session_state:
                     st.session_state.edit_mode = {}
-                st.session_state.edit_mode[selected_product] = True
+                st.success("✅ Cleared all products")
                 st.rerun()
         
-        with col3:
-            # Delete button
-            if st.button("🗑️ Delete Selected", key="delete_button", type="secondary"):
-                st.session_state.products = [p for p in st.session_state.products if p['name'] != selected_product]
-                st.success(f"✅ Deleted {selected_product}")
-                st.rerun()
-        
-        # Edit mode for selected product
-        if 'edit_mode' in st.session_state and selected_product in st.session_state.edit_mode:
-            if st.session_state.edit_mode[selected_product]:
-                
-                st.write(f"**Editing: {selected_product}**")
-                
-                # Find the product to edit
-                product_to_edit = next(p for p in st.session_state.products if p['name'] == selected_product)
-                
-                with st.form(f"edit_product_{selected_product}"):
-                    col1, col2 = st.columns([1, 2])
-                    
-                    with col1:
-                        new_name = st.text_input("Product Name", value=selected_product)
-                    
-                    with col2:
-                        new_scores = {}
-                        cols = st.columns(len(categories))
-                        for i, cat in enumerate(categories):
-                            with cols[i]:
-                                current_value = product_to_edit.get(cat, 0.0)
-                                new_scores[cat] = st.number_input(
-                                    f"{cat}", 
-                                    value=float(current_value), 
-                                    step=1.0,
-                                    key=f"edit_{cat}_{selected_product}"
-                                )
-                    
-                    col_save, col_cancel = st.columns(2)
-                    
-                    with col_save:
-                        save_changes = st.form_submit_button("💾 Save Changes", type="primary")
-                    
-                    with col_cancel:
-                        cancel_edit = st.form_submit_button("❌ Cancel")
-                    
-                    if save_changes:
-                        # Update the product
-                        for i, product in enumerate(st.session_state.products):
-                            if product['name'] == selected_product:
-                                st.session_state.products[i] = {'name': new_name, **new_scores}
-                                break
-                        
-                        # Clear edit mode
-                        st.session_state.edit_mode[selected_product] = False
-                        st.success(f"✅ Updated product: {new_name}")
-                        st.rerun()
-                    
-                    if cancel_edit:
-                        # Clear edit mode
-                        st.session_state.edit_mode[selected_product] = False
-                        st.rerun()
+        with col2:
+            # Export current products to JSON for backup
+            import json
+            products_json = json.dumps(st.session_state.products, indent=2)
+            st.download_button(
+                label="📥 Export Data (JSON)",
+                data=products_json,
+                file_name="mcda_data_backup.json",
+                mime="application/json",
+                help="Download your data for backup or sharing"
+            )
         
-        # Bulk operations
-        if len(st.session_state.products) > 0:
-            st.write("**Bulk Operations:**")
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                if st.button("🗑️ Clear All Products", type="secondary"):
-                    st.session_state.products = []
-                    if 'edit_mode' in st.session_state:
-                        st.session_state.edit_mode = {}
-                    st.success("✅ Cleared all products")
-                    st.rerun()
-            
-            with col2:
-                # Export current products to JSON for backup
-                import json
-                products_json = json.dumps(st.session_state.products, indent=2)
+        with col3:
+            # Generate Excel template based on current setup
+            if st.button("📊 Generate Excel Template"):
+                excel_buffer = create_excel_template(categories, st.session_state.products)
                 st.download_button(
-                    label="📥 Export Products (JSON)",
-                    data=products_json,
-                    file_name="products_backup.json",
-                    mime="application/json"
+                    label="📁 Download Excel Template",
+                    data=excel_buffer,
+                    file_name=f"MCDA_Template_{len(categories)}categories.xlsx",
+                    mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    help="Download Excel file with your current setup"
                 )
         
         return st.session_state.products
+    else:
+        st.info("👆 Add your first product above to get started")
     
     return []
 
+def create_excel_template(categories, products_data):
+    """Create Excel template with current data."""
+    import io
+    
+    # Create Config sheet
+    config_df = pd.DataFrame({
+        'category': categories,
+        'maximize': [True if cat.lower() != 'cost' else False for cat in categories]
+    })
+    
+    # Create Data sheet with current products or templates
+    if products_data:
+        data_df = pd.DataFrame(products_data)
+    else:
+        # Create template with placeholder data
+        template_data = []
+        for i in range(3):
+            row = {'name': f'Product_{chr(65+i)}'}
+            for cat in categories:
+                row[cat] = 0.0
+            template_data.append(row)
+        data_df = pd.DataFrame(template_data)
+    
+    # Create Excel file in memory
+    excel_buffer = io.BytesIO()
+    with pd.ExcelWriter(excel_buffer, engine='openpyxl') as writer:
+        config_df.to_excel(writer, sheet_name='Config', index=False)
+        data_df.to_excel(writer, sheet_name='Data', index=False)
+        
+        # Add instructions sheet
+        instructions = pd.DataFrame([
+            ["MCDA Excel Template", ""],
+            ["", ""],
+            ["Config Sheet:", "Defines categories and optimization direction"],
+            ["Data Sheet:", "Contains your product data"],
+            ["", ""],
+            ["To use:", ""],
+            ["1. Modify data in Data sheet", ""],
+            ["2. Adjust Config sheet if needed", ""],
+            ["3. Use with desktop MCDA tools", ""],
+        ], columns=['Item', 'Description'])
+        instructions.to_excel(writer, sheet_name='Instructions', index=False)
+    
+    excel_buffer.seek(0)
+    return excel_buffer.getvalue()
+
+# Include all your existing functions: adjust_weights, display_results, etc.
 def adjust_weights(calc):
     """Create weight adjustment interface."""
     st.subheader("3. Adjust Category Weights")
@@ -535,116 +300,9 @@ def adjust_weights(calc):
         })
         st.dataframe(weight_df, use_container_width=True)
 
-    # Add aggregation method selection
-    st.write("**Aggregation Method:**")
-    aggregation_method = st.radio(
-        "Choose how to combine category scores:",
-        options=['weighted_sum', 'geometric_mean', 'threshold_penalty'],
-        format_func=lambda x: {
-            'weighted_sum': 'Weighted Sum (No Penalty)',
-            'geometric_mean': 'Geometric Mean (Penalty for Poor Performance)',
-            'threshold_penalty': 'Threshold/Objective Penalty System'
-        }[x],
-        help="Weighted Sum: Full compensation between criteria. Geometric Mean: Penalizes poor performance. Threshold/Objective: Three-zone penalty system with elimination below thresholds."
-    )
-
-    # Update calculator's aggregation method
-    calc.set_aggregation_method(aggregation_method)
-
-    # Add threshold/objective configuration for penalty system
-    if aggregation_method == 'threshold_penalty':
-        st.write("**Configure Thresholds and Objectives:**")
-        st.info("📝 Set minimum acceptable values (thresholds) and target values (objectives) for each category.")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.write("**Thresholds (Minimum Acceptable):**")
-            thresholds = {}
-            for cat in calc.categories:
-                direction = "maximize" if calc.maximize[cat] else "minimize"
-                thresholds[cat] = st.number_input(
-                    f"{cat.title()} threshold",
-                    value=50.0,
-                    step=1.0,
-                    help=f"Minimum acceptable value for {cat} ({direction}). Below this = elimination."
-                )
-        
-        with col2:
-            st.write("**Objectives (Target Values):**")
-            objectives = {}
-            for cat in calc.categories:
-                direction = "maximize" if calc.maximize[cat] else "minimize"
-                objectives[cat] = st.number_input(
-                    f"{cat.title()} objective",
-                    value=80.0,
-                    step=1.0,
-                    help=f"Target value for {cat} ({direction}). At/above this = full score."
-                )
-        
-        # Validate and apply threshold/objective configuration
-        try:
-            calc.set_thresholds(thresholds)
-            calc.set_objectives(objectives)
-            
-            # Validate configuration
-            validation_errors = calc.validate_penalty_configuration()
-            if validation_errors:
-                st.error("❌ Configuration Issues:")
-                for error in validation_errors:
-                    st.error(f"• {error}")
-            else:
-                st.success("✅ Threshold/Objective configuration is valid")
-                
-                # Show penalty zones explanation
-                with st.expander("📖 How the Penalty System Works"):
-                    st.write("""
-                    **Three-Zone System for each category:**
-                    
-                    🔴 **Zone 1 - Elimination**: Below threshold → Score = 0
-                    - Products failing to meet minimum requirements are heavily penalized
-                    
-                    🟡 **Zone 2 - Penalty**: Between threshold and objective → Linear scale (0-50)
-                    - Graduated penalty that decreases as you approach the objective
-                    
-                    🟢 **Zone 3 - Full Reward**: At/above objective → Full normalized score (50-100)
-                    - Products meeting targets compete on standard normalization
-                    
-                    **Example**: Reliability (maximize, threshold=80, objective=95)
-                    - Score 70: Gets 0 (below threshold)
-                    - Score 87: Gets ~23 (between threshold/objective)  
-                    - Score 98: Gets ~90 (above objective, normalized against other qualified products)
-                    """)
-                    
-        except Exception as e:
-            st.error(f"❌ Error configuring penalty system: {str(e)}")
-
-    # Update calculator's aggregation method
-    calc.set_aggregation_method(aggregation_method)
-
 def display_results(calc):
     """Display analysis results."""
     st.subheader("📊 Results")
-
-    # Display current aggregation method
-    method_names = {
-        'weighted_sum': 'Weighted Sum (No Penalty)',
-        'geometric_mean': 'Geometric Mean (Penalty for Poor Performance)', 
-        'threshold_penalty': 'Threshold/Objective Penalty System'
-    }
-    method_name = method_names.get(calc.aggregation_method, calc.aggregation_method)
-    st.info(f"🔧 Using: **{method_name}**")
-
-    # Show penalty configuration if threshold penalty is active
-    if calc.aggregation_method == 'threshold_penalty' and calc.use_penalties:
-        with st.expander("🎯 Current Threshold/Objective Settings"):
-            penalty_config = pd.DataFrame({
-                'Category': calc.categories,
-                'Direction': ['Maximize' if calc.maximize[cat] else 'Minimize' for cat in calc.categories],
-                'Threshold': [calc.thresholds[cat] for cat in calc.categories],
-                'Objective': [calc.objectives[cat] for cat in calc.categories]
-            })
-            st.dataframe(penalty_config, use_container_width=True)
     
     # Get results
     rankings = calc.rank_products()
@@ -656,10 +314,10 @@ def display_results(calc):
     with tab1:
         st.write("**Product Rankings:**")
         
-        # Fix: Create medals list with correct length
+        # Create medals list with correct length
         num_products = len(rankings)
         medals = ["🥇", "🥈", "🥉"] + [""] * max(0, num_products - 3)
-        medals = medals[:num_products]  # Trim to exact length needed
+        medals = medals[:num_products]
         
         ranking_df = pd.DataFrame({
             'Rank': range(1, num_products + 1),
@@ -703,7 +361,7 @@ def display_results(calc):
                 fig_radar = go.Figure()
                 
                 normalized = calc.normalize_scores()
-                for product in top_products[:3]:  # Limit to top 3 for clarity
+                for product in top_products[:3]:
                     values = [normalized[product][cat] for cat in calc.categories]
                     fig_radar.add_trace(go.Scatterpolar(
                         r=values,
@@ -721,81 +379,10 @@ def display_results(calc):
                     showlegend=True,
                     title="Normalized Scores by Category"
                 )
-                                            
-                # Penalty zone visualization for threshold_penalty method
-                if calc.aggregation_method == 'threshold_penalty' and calc.use_penalties:
-                    st.write("**Penalty Zone Analysis:**")
-                    
-                    # Create penalty zone visualization
-                    penalty_fig = go.Figure()
-                    
-                    for i, cat in enumerate(calc.categories):
-                        threshold = calc.thresholds[cat]
-                        objective = calc.objectives[cat]
-                        
-                        # Get all product scores for this category
-                        product_scores = [(name, calc.products[name][cat]) for name in calc.products]
-                        product_scores.sort(key=lambda x: x[1])
-                        
-                        # Create traces for penalty zones
-                        y_pos = [i] * len(product_scores)
-                        scores = [score for _, score in product_scores]
-                        names = [name for name, _ in product_scores]
-                        
-                        # Zone colors based on scores
-                        colors = []
-                        for _, score in product_scores:
-                            if calc.maximize[cat]:
-                                if score < threshold:
-                                    colors.append('red')  # Below threshold
-                                elif score < objective:
-                                    colors.append('orange')  # Between threshold and objective
-                                else:
-                                    colors.append('green')  # Above objective
-                            else:
-                                if score > threshold:
-                                    colors.append('red')  # Above threshold (bad for minimize)
-                                elif score > objective:
-                                    colors.append('orange')  # Between objective and threshold
-                                else:
-                                    colors.append('green')  # Below objective (good for minimize)
-                        
-                        # Add scatter points for products
-                        penalty_fig.add_trace(go.Scatter(
-                            x=scores,
-                            y=y_pos,
-                            mode='markers',
-                            marker=dict(size=12, color=colors),
-                            text=names,
-                            name=f'{cat} scores',
-                            showlegend=False
-                        ))
-                        
-                        # Add threshold and objective lines
-                        penalty_fig.add_vline(x=threshold, line=dict(color='red', dash='dash'), 
-                                            annotation_text=f'{cat} threshold')
-                        penalty_fig.add_vline(x=objective, line=dict(color='green', dash='dash'),
-                                            annotation_text=f'{cat} objective')
-                    
-                    penalty_fig.update_layout(
-                        title="Product Scores vs Thresholds/Objectives",
-                        xaxis_title="Score Value",
-                        yaxis=dict(
-                            tickmode='array',
-                            tickvals=list(range(len(calc.categories))),
-                            ticktext=calc.categories
-                        ),
-                        height=max(300, len(calc.categories) * 60)
-                    )
-                    
-                    # Legend explanation
-                    st.write("🔴 Red: Below threshold (eliminated) | 🟠 Orange: Between threshold/objective (penalized) | 🟢 Green: Above objective (full score)")
-                    
-                    # MOVE THIS LINE INSIDE THE CONDITIONAL BLOCK
-                    st.plotly_chart(penalty_fig, use_container_width=True)
-
-                # ADD THIS LINE FOR THE RADAR CHART (outside the penalty block)
+                
                 st.plotly_chart(fig_radar, use_container_width=True)
+        else:
+            st.info("Add more products to see visualizations")
 
 if __name__ == "__main__":
     main()