[FEAT/FIX] tab2: unify method activatability check, fix hidden resource coverage by batch group, move default_constraint to data_utils

tabs/tab2_constraints.py

@@ -3,17 +3,7 @@ import streamlit as st
 
 from config.config import CO2_UNIT, method_groups, method_order, method_tooltips, secondary_resources, hidden_resource_names
 from utils.ui_helpers import show_bar
-from utils.data_utils import strip_unit_suffix, is_other_method, get_other_method_variants, make_variant_name
-
-
-
-def default_constraint():
-    """Return the default constraint dict for a CDR method (active, 100% cap).
-
-    Returns:
-        dict: {"active": True, "cap_type": "percent", "cap_value": 100}.
-    """
-    return {"active": True, "cap_type": "percent", "cap_value": int(100)}
+from utils.data_utils import strip_unit_suffix, is_other_method, get_other_method_variants, make_variant_name, default_constraint
 
 
 def _make_slider_cb(m):
@@ -51,6 +41,37 @@ def get_hidden_resources_for_method(m, method_to_primary_resources, cost_sliders
     return required, optional
 
 
+def get_all_missing_required(m, cost_sliders_norm):
+    """Return all required resources for method m that are not yet available.
+
+    Standard resource: available if resource_caps.get(r, 0.0) > 0.
+    Hidden resource: available if any custom batch with group == r is assigned to m.
+    Secondary resources and resources with median <= 0 are excluded.
+
+    Returns:
+        list[str]: missing required resource names (standard and hidden combined).
+    """
+    resource_caps = st.session_state.get("resource_caps", {})
+    custom_resources = st.session_state.get("custom_resources", [])
+    covered_hidden = {
+        b["group"] for b in custom_resources
+        if m in b.get("methods", {})
+    }
+    missing = []
+    for r, coeff_dict in cost_sliders_norm.get(m, {}).items():
+        if (m, r) in secondary_resources:
+            continue
+        if coeff_dict.get("median", 0.0) <= 0:
+            continue
+        if r in hidden_resource_names:
+            if r not in covered_hidden:
+                missing.append(r)
+        else:
+            if resource_caps.get(r, 0.0) <= 0:
+                missing.append(r)
+    return missing
+
+
 def get_uncovered_hidden_resources(m, cost_sliders_norm):
     """Return (required, optional) hidden resources for method m that leave it unconstrained.
 
@@ -67,7 +88,13 @@ def get_uncovered_hidden_resources(m, cost_sliders_norm):
             Returns ([], []) when nothing is uncovered.
     """
     custom_resources = st.session_state.get("custom_resources", [])
-    covered = {b["name"] for b in custom_resources if m in b.get("methods", {})}
+    # A hidden resource r (e.g. "Other mineral") is covered when any custom batch
+    # whose group == r is assigned to this method — the batch name differs from
+    # the group name (e.g. "Limestone" covers "Other mineral").
+    covered_groups = {
+        b["group"] for b in custom_resources
+        if m in b.get("methods", {})
+    }
 
     required, optional = [], []
     for r, coeff_dict in cost_sliders_norm.get(m, {}).items():
@@ -75,7 +102,7 @@ def get_uncovered_hidden_resources(m, cost_sliders_norm):
             continue
         if coeff_dict.get("median", 0.0) <= 0:
             continue
-        if r in covered:
+        if r in covered_groups:
             continue
         if (m, r) in secondary_resources:
             optional.append(r)
@@ -93,7 +120,11 @@ def _render_resource_status(m, cost_sliders_norm):
     """
     resource_caps   = st.session_state.get("resource_caps", {})
     custom_resources = st.session_state.get("custom_resources", [])
-    covered = {b["name"] for b in custom_resources if m in b.get("methods", {})}
+    # Map hidden resource group → list of batch names covering it for method m.
+    covered_hidden: dict[str, list[str]] = {}
+    for b in custom_resources:
+        if m in b.get("methods", {}):
+            covered_hidden.setdefault(b["group"], []).append(b["name"])
 
     all_res = cost_sliders_norm.get(m, {})
     required_rows = []
@@ -103,14 +134,18 @@ def _render_resource_status(m, cost_sliders_norm):
         if coeff_dict.get("median", 0.0) <= 0:
             continue
         if r in hidden_resource_names:
-            available = r in covered
+            batch_names = covered_hidden.get(r)
+            available = bool(batch_names)
+            # Show actual batch name(s) instead of the generic "Other X" group
+            display_r = ", ".join(batch_names) if batch_names else r
             source = "Add as new resource in Resource inputs"
         else:
             available = resource_caps.get(r, 0.0) > 0
+            display_r = r
             source = "Set quantity in Resource inputs"
 
         icon = "✅" if available else "❌"
-        row = (icon, r, "" if available else source)
+        row = (icon, display_r, "" if available else source)
 
         if (m, r) in secondary_resources:
             optional_rows.append(row)
@@ -134,9 +169,10 @@ def _render_resource_status(m, cost_sliders_norm):
                 if hint:
                     label += f' <span style="color:#888;font-style:italic;font-weight:400">: {hint}</span>'
                 st.markdown(label, unsafe_allow_html=True)
+            st.caption("Optional resources can be added in the **Resource coefficients** tab (tab 3).")
 
 
-def render_method(m, cols, i, method_to_primary_resources, cost_sliders_norm):
+def render_method(m, cols, i, cost_sliders_norm):
     """Render the constraint widget group (toggle + cap slider/input) for one method.
 
     Writes the result into st.session_state.constraints[m].
@@ -160,14 +196,13 @@ def render_method(m, cols, i, method_to_primary_resources, cost_sliders_norm):
         toggle_key = f"toggle_{m}"
         cap_type_key = f"cap_type_{m}"
 
-        # Check for missing hidden resources. This runs before the regular
-        # st.toggle so we never touch toggle_{m} at all for blocked methods —
-        # the pre-render sync already set that key and Streamlit would raise
-        # "cannot be modified after widget is instantiated" if we touched it again.
-        # Instead we force the constraint to inactive in the data layer and show
-        # a static label + info box without any widget that uses toggle_{m}.
-        uncovered_required, _ = get_uncovered_hidden_resources(m, cost_sliders_norm)
-        if uncovered_required:
+        # Block the method if any required resource is missing (standard at 0 or
+        # hidden resource not covered by a custom batch).  Run this before the
+        # regular st.toggle so we never touch toggle_{m} for blocked methods —
+        # the pre-render sync already set it and Streamlit would raise
+        # "cannot be modified after widget is instantiated" otherwise.
+        missing_required = get_all_missing_required(m, cost_sliders_norm)
+        if missing_required:
             st.session_state.constraints[m]["active"] = False
             st.session_state.pop(toggle_key, None)
             st.toggle(m, value=False, key=toggle_key, disabled=True, help=tooltip)
@@ -196,7 +231,8 @@ def render_method(m, cols, i, method_to_primary_resources, cost_sliders_norm):
         if constraint.get("_cap_type_invalid") or constraint.get("cap_type") not in ("percent", "absolute"):
             st.warning(
                 f"Invalid **cap_type** value (`{constraint.get('cap_type')}`) loaded from file. "
-                "Select a constraint type below to fix it."
+                "Select a constraint type below to fix it.", 
+                icon=":material/warning:"
             )
             constraint["cap_type"] = "percent"
             constraint["cap_value"] = 100
@@ -210,16 +246,6 @@ def render_method(m, cols, i, method_to_primary_resources, cost_sliders_norm):
         # directly from the constraint — no stale session-state value possible.
         st.session_state.setdefault(cap_type_key, constraint["cap_type"])
 
-        required, optional = get_hidden_resources_for_method(m, method_to_primary_resources, cost_sliders_norm)
-        if required is not None:
-            req_list = "\n".join(f"- **{r}** *(required)*" for r in required)
-            opt_list = "\n".join(f"- **{r}** *(optional)*" for r in optional) if optional else ""
-            body = f"To use this method, add a new resource in the **Resource inputs** tab:\n\n{req_list}"
-            if opt_list:
-                body += f"\n{opt_list}"
-            st.info(body, icon=":material/info:")
-            return
-
         # Capture the cap_type that was active in the previous render so we can
         # detect a mode switch (absolute → percent) below.
         old_cap_type = constraint.get("cap_type", "percent")
@@ -248,7 +274,7 @@ def render_method(m, cols, i, method_to_primary_resources, cost_sliders_norm):
 
         if cap_type == "absolute" and old_cap_type == "percent":
             constraint["cap_value"] = 0.0
-            st.session_state[f"manual_{m}"] = 0.0
+            st.session_state.pop(f"manual_{m}", None)
             st.session_state.pop(f"slider_{m}", None)
 
         if cap_type == "percent":
@@ -272,12 +298,13 @@ def render_method(m, cols, i, method_to_primary_resources, cost_sliders_norm):
 
         else:
 
-            if f"manual_{m}" not in st.session_state:
-                st.session_state[f"manual_{m}"] = float(constraint["cap_value"]) if constraint["cap_value"] else 0.0
+            if f"manual_{m}" not in st.session_state and constraint.get("cap_value"):
+                st.session_state[f"manual_{m}"] = float(constraint["cap_value"])
 
             value = st.number_input(
                 f"Max cap ({CO2_UNIT}/yr)",
                 min_value=0.0,
+                value=None,
                 format="%.2f",
                 key=f"manual_{m}",
                 placeholder="0.00",
@@ -339,41 +366,27 @@ def build_summary_df():
 
 
 
-def render_tab(cost_sliders):
-    """Render the Method Constraints tab.
+def _sync_constraint_widgets(cost_sliders_norm):
+    """Drive all constraint widget keys from the constraint dict before any widget is drawn.
+
+    Two modes:
+    - force mode: after a file/scenario load (constraints_just_loaded flag) or for
+      freshly activated methods (just_activated_methods). All keys are set
+      unconditionally from the constraint.
+    - normal mode: setdefault only; never overrides a value the user already set.
 
     Args:
-        cost_sliders (dict): full cost slider config {method: {resource: {min, median, max}}}.
+        cost_sliders_norm (dict): {method: {resource: {min, median, max}}} with unit suffixes stripped.
 
     Returns:
         None
     """
-    cost_sliders_norm = {
-        m: {strip_unit_suffix(name): conf for name, conf in resources.items()}
-        for m, resources in cost_sliders.items()
-    }
-    method_to_primary_resources = {
-        m: [r for r in resources if (m, r) not in secondary_resources]
-        for m, resources in cost_sliders_norm.items()
-    }
-
-    # Pre-render sync: drive alzzl widget keys from the constraint dict before
-    # any widget is drawn.
-    #
-    # Two modes:
-    #   force mode  – after a file/scenario load (constraints_just_loaded flag)
-    #                 or for freshly activated methods (just_activated_methods).
-    #                 All keys are set unconditionally from the constraint.
-    #   normal mode – setdefault only; never overrides a value the user already
-    #                 set by interacting with the widget this session.
     just_loaded = st.session_state.pop("constraints_just_loaded", False)
     just_activated = st.session_state.pop("just_activated_methods", set())
+    auto_disabled = st.session_state.get("auto_disabled_methods", set())
 
     for m, c in st.session_state.constraints.items():
-        # Methods with uncovered hidden resources are always forced inactive —
-        # skip the normal active-branch so the toggle key is never set to True.
-        uncov_req, _ = get_uncovered_hidden_resources(m, cost_sliders_norm)
-        if uncov_req:
+        if get_all_missing_required(m, cost_sliders_norm):
             st.session_state.constraints[m]["active"] = False
             st.session_state.pop(f"toggle_{m}", None)
             st.session_state.pop(f"cap_type_{m}", None)
@@ -381,6 +394,11 @@ def render_tab(cost_sliders):
             st.session_state.pop(f"manual_{m}", None)
             continue
 
+        if m in auto_disabled:
+            st.session_state.constraints[m]["active"] = True
+            auto_disabled.discard(m)
+            just_activated.add(m)
+
         force = just_loaded or (m in just_activated)
         if c["active"]:
             cap_type = c.get("cap_type", "percent")
@@ -391,7 +409,11 @@ def render_tab(cost_sliders):
                     st.session_state[f"slider_{m}"] = int(c.get("cap_value", 100))
                     st.session_state.pop(f"manual_{m}", None)
                 else:
-                    st.session_state[f"manual_{m}"] = float(c.get("cap_value", 0.0))
+                    cap_val = c.get("cap_value", 0.0)
+                    if cap_val:
+                        st.session_state[f"manual_{m}"] = float(cap_val)
+                    else:
+                        st.session_state.pop(f"manual_{m}", None)
                     st.session_state.pop(f"slider_{m}", None)
             else:
                 st.session_state.setdefault(f"toggle_{m}", True)
@@ -400,7 +422,9 @@ def render_tab(cost_sliders):
                     st.session_state.setdefault(f"slider_{m}", int(c.get("cap_value", 100)))
                     st.session_state.pop(f"manual_{m}", None)
                 else:
-                    st.session_state.setdefault(f"manual_{m}", float(c.get("cap_value", 0.0)))
+                    cap_val = c.get("cap_value", 0.0)
+                    if cap_val and f"manual_{m}" not in st.session_state:
+                        st.session_state[f"manual_{m}"] = float(cap_val)
                     st.session_state.pop(f"slider_{m}", None)
         else:
             if force:
@@ -411,6 +435,54 @@ def render_tab(cost_sliders):
             st.session_state.pop(f"slider_{m}", None)
             st.session_state.pop(f"manual_{m}", None)
 
+    st.session_state["auto_disabled_methods"] = auto_disabled
+
+
+def render_constraints_summary():
+    """Render the summary dataframe of active methods and their caps.
+
+    Returns:
+        None
+    """
+    st.markdown("""
+        <p class="crra-sub-heading">Summary of Active methods and caps</p>""",
+        unsafe_allow_html=True,
+    )
+    df = build_summary_df()
+    if df is not None:
+        df_display = df.reset_index().rename(columns={"index": "CDR Method"})
+        df_display = df_display[["CDR Method", "Cap value"]]
+        num_rows = len(df_display)
+        st.dataframe(
+            df_display,
+            width='stretch',
+            hide_index=True,
+            height=(num_rows * 36 + 36),
+            column_config={
+                "CDR Method": st.column_config.TextColumn("CDR Method", width="large"),
+                "Cap value": st.column_config.TextColumn("Cap value"),
+            },
+            row_height=36,
+        )
+    else:
+        st.warning("No active methods selected.", icon=":material/warning:")
+
+
+def render_tab(cost_sliders):
+    """Render the Method Constraints tab.
+
+    Args:
+        cost_sliders (dict): full cost slider config {method: {resource: {min, median, max}}}.
+
+    Returns:
+        None
+    """
+    cost_sliders_norm = {
+        m: {strip_unit_suffix(name): conf for name, conf in resources.items()}
+        for m, resources in cost_sliders.items()
+    }
+    _sync_constraint_widgets(cost_sliders_norm)
+
     st.markdown('<h1 class="crra-heading">Method constraints</h1>', unsafe_allow_html=True)
     show_bar()
     
@@ -435,6 +507,11 @@ def render_tab(cost_sliders):
         unsafe_allow_html=True,
     )
 
+    st.markdown('<p class="crra-sub-heading">Controls</p>', unsafe_allow_html=True)
+
+    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
+        reset_all_constraints()
+
     custom_resources = st.session_state.get("custom_resources", [])
 
     # Build the full list of display names (variants replace "Other" methods with batches)
@@ -445,16 +522,11 @@ def render_tab(cost_sliders):
         for display_m, _ in all_display
     )
     # Activatable: variants are always activatable; standard methods only if they
-    # have at least one visible (non-hidden) primary resource AND no uncovered
-    # hidden resource that would block them.
+    # A method is activatable when all its required resources are available.
     activatable = []
     for display_m, orig_m in all_display:
-        if display_m != orig_m:  # it's a variant → batch provides the resource
+        if not get_all_missing_required(orig_m, cost_sliders_norm):
             activatable.append(display_m)
-        elif get_hidden_resources_for_method(orig_m, method_to_primary_resources, cost_sliders_norm)[0] is None:
-            uncov_req, _ = get_uncovered_hidden_resources(orig_m, cost_sliders_norm)
-            if not uncov_req:
-                activatable.append(orig_m)
 
     if any_active:
         if st.button("Deactivate all", icon=":material/remove_done:", key="btn-deactivate-all"):
@@ -482,35 +554,10 @@ def render_tab(cost_sliders):
                 if variants:
                     for batch in variants:
                         vname = make_variant_name(m, batch["name"])
-                        render_method(vname, cols, col_idx, method_to_primary_resources, cost_sliders_norm)
+                        render_method(vname, cols, col_idx, cost_sliders_norm)
                         col_idx += 1
                 else:
-                    render_method(m, cols, col_idx, method_to_primary_resources, cost_sliders_norm)
+                    render_method(m, cols, col_idx, cost_sliders_norm)
                     col_idx += 1
 
-    st.divider()
-    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
-        reset_all_constraints()
-
-    st.markdown("""
-        <p class="crra-sub-heading">Summary of Active methods and caps</p>""",
-        unsafe_allow_html=True,
-    )
-    df = build_summary_df()
-    if df is not None:
-        df_display = df.reset_index().rename(columns={"index": "CDR Method"})
-        df_display = df_display[["CDR Method", "Cap value"]]
-        num_rows = len(df_display)
-        st.dataframe(
-            df_display,
-            width='stretch',
-            hide_index=True,
-            height=(num_rows * 36 + 36),
-            column_config={
-                "CDR Method": st.column_config.TextColumn("CDR Method", width="large"),
-                "Cap value": st.column_config.TextColumn("Cap value"),
-            },
-            row_height=36
-        )
-    else:
-        st.warning("No active methods selected.")
+    render_constraints_summary()