Update src/streamlit_app.py

src/streamlit_app.py

@@ -15,29 +15,12 @@ def main():
     st.title("⚖️ Multi-Criteria Decision Analysis (MCDA) Calculator")
     st.markdown("Compare products and alternatives using weighted criteria analysis")
     
-    # 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.
-        
-        **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
-        
-        **Need Excel functionality?** 
-        Download our companion Excel template generator for offline analysis!
-        """)
-    
-    # Manual interface only for HF Spaces
-    manual_interface()
+    # Sidebar for configuration
+    st.sidebar.header("📋 Configuration")
 
 def manual_interface():
     """Handle manual data entry interface."""
-    st.header("✏️ Interactive Data Entry")
+    st.header("✏️ Manual Data Entry")
     
     # Step 1: Define categories
     st.subheader("1. Define Categories")
@@ -49,7 +32,7 @@ def manual_interface():
             "Enter categories (one per line):",
             value="Performance\nCost\nReliability",
             height=100,
-            help="Enter each category on a new line. Examples: Performance, Cost, Quality, Ease_of_Use"
+            help="Enter each category on a new line"
         )
         categories = [cat.strip() for cat in categories_input.split('\n') if cat.strip()]
     
@@ -125,33 +108,33 @@ def data_entry_interface(categories):
     if 'products' not in st.session_state:
         st.session_state.products = []
     
-    # 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()
+    # 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()
     
     # Display current products with edit/delete options
     if st.session_state.products:
@@ -165,105 +148,124 @@ def data_entry_interface(categories):
         edited_df = st.data_editor(
             df,
             use_container_width=True,
-            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}
-            }
+            num_rows="dynamic",  # This should allow adding/deleting rows
+            key="products_editor"
         )
         
         # Update session state with edited data
         st.session_state.products = edited_df.to_dict('records')
         
-        # Bulk operations
-        col1, col2, col3 = st.columns(3)
+        # Individual product management
+        st.write("**Manage Individual Products:**")
+        
+        col1, col2, col3 = st.columns([2, 1, 1])
         
         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()
+            # 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:
-            # 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"
-            )
+            # Edit button
+            if st.button("✏️ Edit Selected", key="edit_button"):
+                if 'edit_mode' not in st.session_state:
+                    st.session_state.edit_mode = {}
+                st.session_state.edit_mode[selected_product] = True
+                st.rerun()
         
         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)
+            # 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()
+        
+        # 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)
                 st.download_button(
-                    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"
+                    label="📥 Export Products (JSON)",
+                    data=products_json,
+                    file_name="products_backup.json",
+                    mime="application/json"
                 )
         
         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")
@@ -300,9 +302,116 @@ 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()
@@ -314,10 +423,10 @@ def display_results(calc):
     with tab1:
         st.write("**Product Rankings:**")
         
-        # Create medals list with correct length
+        # Fix: Create medals list with correct length
         num_products = len(rankings)
         medals = ["🥇", "🥈", "🥉"] + [""] * max(0, num_products - 3)
-        medals = medals[:num_products]
+        medals = medals[:num_products]  # Trim to exact length needed
         
         ranking_df = pd.DataFrame({
             'Rank': range(1, num_products + 1),
@@ -361,7 +470,7 @@ def display_results(calc):
                 fig_radar = go.Figure()
                 
                 normalized = calc.normalize_scores()
-                for product in top_products[:3]:
+                for product in top_products[:3]:  # Limit to top 3 for clarity
                     values = [normalized[product][cat] for cat in calc.categories]
                     fig_radar.add_trace(go.Scatterpolar(
                         r=values,
@@ -379,10 +488,81 @@ 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()