[FEAT/FIX] tab1: add load/download standard resources buttons, fix stale costs on edit/delete/reset, increase number precision

assets/styles.css

@@ -242,6 +242,7 @@ h1.custom-title {
 .st-key-btn-reset button p,
 [class*="btn-reset-"] button p,
 .st-key-btn-load button p,
+.st-key-btn-load-resources button p,
 [class*="btn-new-"] button p,
 [class*="st-key-download_button_"] button p,
 [data-testid="stDownloadButton"] button p,
@@ -276,7 +277,8 @@ h1.custom-title {
 }
 
 /* Load — green-dark */
-.st-key-btn-load button {
+.st-key-btn-load button,
+.st-key-btn-load-resources button {
     border: none !important;
     border-radius: 0px;
     color: var(--off-white);
@@ -286,7 +288,8 @@ h1.custom-title {
     clip-path: var(--btn-clip);
     transition: background 0.25s ease;
 }
-.st-key-btn-load button:hover {
+.st-key-btn-load button:hover,
+.st-key-btn-load-resources button:hover {
     background: #01740f;
     color: var(--off-white);
 }
@@ -573,7 +576,8 @@ section[data-testid="stExpander"] summary p {
 }
 
 /* ── 16. Button container layout ────────────────────────────── */
-.st-key-container-btn{
+.st-key-container-btn,
+.st-key-container-btn-resources{
     display: flex;
     flex-direction: row;
     gap: 1.125%;

tabs/tab1_inputs.py

@@ -5,7 +5,8 @@ from config.config import (resource_groups, resource_order, resource_tooltips,
                            resource_unit_map, method_groups, CO2_UNIT, secondary_resources,
                            hidden_resource_names)
 from utils.data_utils import (strip_unit_suffix, get_resource_to_group, get_resource_to_unit,
-                              get_method_group, standard_resource_names, to_excel_bytes, parse_custom_excel)
+                              get_method_group, standard_resource_names, to_excel_bytes, parse_custom_excel,
+                              resource_caps_to_excel_bytes)
 from utils.state_utils import apply_auto_disable_logic, init_custom_resources
 from utils.ui_helpers import show_bar, render_resource_input
 
@@ -111,7 +112,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
     batch_amount = st.number_input(
         label=f"Available amount ({unit}/yr)",
         min_value=0.0,
-        format="%.2f",
+        format="%.10g",
         value=float(existing["amount"]) if existing.get("amount") and existing.get("amount") != 0.0 else None,
         help=f"Total quantity available for 1 year, in {unit}.",
         key=f"label-input-amount-{eix}",
@@ -222,17 +223,20 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
             continue
         with st.expander(f"**{group_name}**", expanded=False):
             for m in available_methods:
+                already_selected = m in existing.get("methods", {})
                 enabled = st.checkbox(
                     f"**{m}**",
+                    value=already_selected,
                     key=f"_dlg_new_chk_{eix}_{m}",
                 )
                 if enabled:
+                    existing_coeff = existing.get("methods", {}).get(m, {})
                     col_min, col_med, col_max = st.columns(3)
                     with col_min:
                         v_min = st.number_input(
                             f"Min ({unit}/{CO2_UNIT})",
                             min_value=0.0,
-                            value=None,
+                            value=float(existing_coeff["min"]) if existing_coeff.get("min") is not None else None,
                             format="%.10g",
                             key=f"_dlg_new_min_{eix}_{m}",
                             placeholder="0.0000",
@@ -241,7 +245,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
                         v_med = st.number_input(
                             f"Median ({unit}/{CO2_UNIT})",
                             min_value=0.0,
-                            value=None,
+                            value=float(existing_coeff["median"]) if existing_coeff.get("median") is not None else None,
                             format="%.10g",
                             key=f"_dlg_new_med_{eix}_{m}",
                             placeholder="0.0000",
@@ -250,7 +254,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
                         v_max = st.number_input(
                             f"Max ({unit}/{CO2_UNIT})",
                             min_value=0.0,
-                            value=None,
+                            value=float(existing_coeff["max"]) if existing_coeff.get("max") is not None else None,
                             format="%.10g",
                             key=f"_dlg_new_max_{eix}_{m}",
                             placeholder="0.0000",
@@ -273,7 +277,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
             errors.append("Resource name is required.")
         elif batch_name.strip().lower() in {n.lower() for n in standard_names}:
             errors.append(f"**{batch_name}** matches a standard resource name. Choose a different name.")
-        elif batch_name.strip() in existing_names:
+        elif batch_name.strip().lower() in {n.lower() for n in existing_names}:
             errors.append(f"**{batch_name}** already exists. Choose a different name.")
         if not batch_amount or batch_amount <= 0:
             errors.append("Available amount must be greater than 0.")
@@ -305,12 +309,55 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
                     "methods": method_configs,
                 }
                 if edit_index is not None:
+                    # Clean up stale costs[method][old_name] entries left behind by
+                    # this edit — otherwise tab4's missing-resource check wrongly
+                    # deactivates that method on the next optimization run. Two
+                    # triggers: (a) a method that was previously assigned is no
+                    # longer checked, or (b) the batch itself was renamed, which
+                    # orphans the old name even for methods still checked (the new
+                    # name gets a fresh entry injected at run time, but the old
+                    # name's entry is never removed on its own).
+                    old_name = existing.get("name", "")
+                    new_name = batch_name.strip()
+                    renamed = bool(old_name) and old_name != new_name
+                    for method_name in existing.get("methods", {}):
+                        if renamed or method_name not in method_configs:
+                            st.session_state.costs.get(method_name, {}).pop(old_name, None)
                     st.session_state.custom_resources[edit_index] = batch
                     st.session_state.pop(f"custom_amount_{edit_index}", None)
                 else:
                     new_idx = len(st.session_state.custom_resources)
                     st.session_state.custom_resources.append(batch)
                     st.session_state.pop(f"custom_amount_{new_idx}", None)
+                # Push the new median into costs for any (method, coefficient)
+                # pair that actually changed in this edit — tab3's own init only
+                # sets a value the first time a key appears (`if r not in
+                # costs[m]`), so without this a coefficient edit made here would
+                # never overwrite the stale value already there. Only touch
+                # pairs whose median actually changed (or that are brand new) so
+                # a deliberate Tab 3 slider adjustment isn't silently reset just
+                # because the user edited something unrelated (e.g. the amount).
+                old_methods = existing.get("methods", {})
+                for method_name, coeff in method_configs.items():
+                    old_coeff = old_methods.get(method_name, {})
+                    if old_coeff.get("median") != coeff["median"]:
+                        st.session_state.costs.setdefault(method_name, {})[batch["name"]] = coeff["median"]
+                    # If min/max changed, tab3's current scenario value (used to
+                    # seed its slider/manual widgets, keyed only by method+resource
+                    # name so it persists across this edit) may now fall outside
+                    # the new range — st.slider raises if its stored value is out
+                    # of [min_value, max_value]. Clamp it into the new bounds
+                    # (rather than resetting to the median) so the user's chosen
+                    # operating point is kept as close as possible, then clear the
+                    # widget keys so tab3 re-initialises from this clamped value.
+                    if old_coeff.get("min") != coeff["min"] or old_coeff.get("max") != coeff["max"]:
+                        current = st.session_state.costs.get(method_name, {}).get(batch["name"])
+                        if current is not None:
+                            clamped = max(coeff["min"], min(coeff["max"], current))
+                            st.session_state.costs.setdefault(method_name, {})[batch["name"]] = clamped
+                        key_suffix = f"{method_name}_{batch['name']}".replace(" ", "_")
+                        for prefix in ("slider_", "manual_", "toggle_"):
+                            st.session_state.pop(f"{prefix}{key_suffix}", None)
                 st.session_state.pop("latest_result", None)
                 st.rerun()
 
@@ -367,6 +414,13 @@ def dialog_load_custom_batch():
             if batch["name"] in existing_names:
                 idx = next(i for i, b in enumerate(st.session_state.custom_resources)
                            if b["name"] == batch["name"])
+                # Purge costs[method][batch_name] for methods dropped by the
+                # re-imported version — harmless today (build_lp_indices gates
+                # on the batch's own primary_methods) but avoids stale data
+                # lingering in session state until the next Tab 3 visit.
+                old_methods = set(st.session_state.custom_resources[idx].get("methods", {}))
+                for method_name in old_methods - set(batch.get("methods", {})):
+                    st.session_state.costs.get(method_name, {}).pop(batch["name"], None)
                 st.session_state.custom_resources[idx] = batch
             else:
                 st.session_state.custom_resources.append(batch)
@@ -376,6 +430,65 @@ def dialog_load_custom_batch():
         st.rerun()
 
 
+@st.dialog("Load standard resource values", width="large")
+def dialog_load_standard_resources():
+    """Dialog for importing standard resource availabilities from an Excel file.
+
+    Reads an .xlsx file with "Resource" and "Available Amount" columns (the
+    same format as the downloadable template / current-values export) and
+    overwrites st.session_state.resource_caps on confirmation.
+
+    Returns:
+        None
+    """
+    st.markdown(
+        '<p class="caption">Upload an Excel file with "Resource" and "Available Amount" '
+        "columns — either the blank template or a previous export of your current values.</p>",
+        unsafe_allow_html=True,
+    )
+
+    uploaded = st.file_uploader("Upload Excel file", type=["xlsx"], key="resource_loader_dialog")
+    if uploaded is None:
+        return
+
+    try:
+        df = pd.read_excel(uploaded)
+        required_cols = {"Resource", "Available Amount"}
+        if not required_cols.issubset(df.columns):
+            raise ValueError(f"Missing columns: {required_cols - set(df.columns)}")
+    except Exception as e:
+        st.error(f"Error reading file: {e}")
+        return
+
+    preview_rows = [
+        {"Resource": row["Resource"], "Available Amount": row["Available Amount"]}
+        for _, row in df.iterrows()
+        if row["Resource"] in st.session_state.resource_caps
+    ]
+    st.dataframe(pd.DataFrame(preview_rows), width='stretch', hide_index=True)
+
+    if st.button("↩️ Import values", type="primary", width='stretch'):
+        for r in st.session_state.resource_caps:
+            st.session_state.resource_caps[r] = 0.0
+            st.session_state[f"cap_{r}"] = 0.0
+        for _, row in df.iterrows():
+            r = row["Resource"]
+            if r not in st.session_state.resource_caps:
+                continue
+            val = row["Available Amount"]
+            try:
+                val = 0.0 if pd.isna(val) else float(val)
+            except (ValueError, TypeError):
+                val = 0.0
+            st.session_state.resource_caps[r] = val
+            st.session_state[f"cap_{r}"] = val
+        st.session_state["resource_last_loaded_file"] = uploaded.name
+        for key in ["excel_loaded_file", "scenario_name_suggestion",
+                    "scenario_loaded_file", "input_file_name_suggestion", "latest_result"]:
+            st.session_state.pop(key, None)
+        st.success("Resource values imported successfully.", icon="✅")
+        st.rerun()
+
 
 def render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
     """Render a single custom batch inside its resource-group expander."""
@@ -392,7 +505,7 @@ def render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
             new_amount = st.number_input(
                 f"{batch['name']}",
                 min_value=0.0,
-                format="%.2f",
+                format="%.10g",
                 key=key_amount,
                 placeholder="0.0",
             )
@@ -421,9 +534,9 @@ def render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
                 key=f"batch_editor_{global_idx}",
                 column_config={
                     "Method": st.column_config.TextColumn(disabled=True),
-                    col_min: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
-                    col_med: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
-                    col_max: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
+                    col_min: st.column_config.NumberColumn(format="%.10g", min_value=0.0),
+                    col_med: st.column_config.NumberColumn(format="%.10g", min_value=0.0),
+                    col_max: st.column_config.NumberColumn(format="%.10g", min_value=0.0),
                 },
             )
         else:
@@ -444,7 +557,14 @@ def render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
         with st.container(key=f"container-button-{global_idx}"):
             if st.button("Delete", key=f"del_batch_{global_idx}",
                             type="primary", icon=":material/delete:"):
-                st.session_state.custom_resources.pop(global_idx)
+                deleted = st.session_state.custom_resources.pop(global_idx)
+                # Clean up any coefficient this batch left in st.session_state.costs
+                # for the methods it was assigned to. Without this, a stale
+                # costs[method][batch_name] entry survives the deletion, and tab4's
+                # "missing resource" check (which only looks at custom_resources,
+                # not costs) wrongly deactivates that method on the next run.
+                for method_name in deleted.get("methods", {}):
+                    st.session_state.costs.get(method_name, {}).pop(deleted["name"], None)
                 st.session_state.pop("latest_result", None)
                 st.rerun()
             if st.button("Edit", key=f"edit_batch_{global_idx}",
@@ -648,17 +768,25 @@ def render_tab(cost_sliders):
     if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
         for r in st.session_state.resource_caps:
             st.session_state.resource_caps[r] = 0.0
+        # Purge costs[method][batch_name] entries left by custom resources before
+        # clearing them below — otherwise tab4's missing-resource check wrongly
+        # deactivates any method that relied on a batch no longer in existence.
+        for batch in st.session_state.custom_resources:
+            for method_name in batch.get("methods", {}):
+                st.session_state.costs.get(method_name, {}).pop(batch["name"], None)
         st.session_state.custom_resources = []
         st.session_state.enabled_methods = {}
         st.success("All resource values reset to 0.")
         st.rerun()
 
     st.markdown('<p class="crra-sub-sub-heading">Import resource values</p>', unsafe_allow_html=True)
-    col_template, col_upload = st.columns([1, 1])
-    with col_template:
-        st.markdown("<div class='caption'><p>Use the template below to fill in your resource "
-                    "availability values and import them directly into the tool.</p></div>",
-                    unsafe_allow_html=True)
+    st.markdown(
+        "<p class='caption'>Load standard resource availabilities from an Excel file, "
+        "or download the current values.</p>",
+        unsafe_allow_html=True,
+    )
+    
+    with st.container(key="container-btn-resources"):
         with open("data/resource_template.xlsx", "rb") as f:
             st.download_button(
                 label="Download Excel Template",
@@ -668,41 +796,10 @@ def render_tab(cost_sliders):
                 icon=":material/download:",
                 key="download_button_resource_template"
             )
-    with col_upload:
-        uploaded_file = st.file_uploader(
-            "Upload your Excel file", type="xlsx",
-            key=f"resource_uploader_{st.session_state.get('resource_uploader_key', 0)}"
-        )
-        if uploaded_file is not None and uploaded_file.name != st.session_state.get("resource_last_loaded_file"):
-            try:
-                df = pd.read_excel(uploaded_file)
-                required_cols = {"Resource", "Available Amount"}
-                if not required_cols.issubset(df.columns):
-                    raise ValueError(f"Missing columns: {required_cols - set(df.columns)}")
-                for r in st.session_state.resource_caps:
-                    st.session_state.resource_caps[r] = 0.0
-                    st.session_state[f"cap_{r}"] = 0.0
-                for _, row in df.iterrows():
-                    r = row["Resource"]
-                    val = row["Available Amount"]
-                    if r not in st.session_state.resource_caps:
-                        continue
-                    try:
-                        val = 0.0 if pd.isna(val) else float(val)
-                    except (ValueError, TypeError):
-                        val = 0.0
-                    st.session_state.resource_caps[r] = val
-                    st.session_state[f"cap_{r}"] = val
-                st.session_state["resource_last_loaded_file"] = uploaded_file.name
-                st.success("Resource values imported successfully.", icon="✅")
-                for key in ["excel_loaded_file", "scenario_name_suggestion",
-                            "scenario_loaded_file", "input_file_name_suggestion", "latest_result"]:
-                    st.session_state.pop(key, None)
-                st.rerun()
-            except Exception as e:
-                st.error(f"Error importing resource values: {e}")
-        elif st.session_state.get("resource_last_loaded_file"):
-            st.success(f"Loaded: **{st.session_state['resource_last_loaded_file']}**", icon="✅")
+        if st.button("Load from Excel", type="tertiary", icon=":material/arrow_upload_progress:", key="btn-load-resources"):
+            dialog_load_standard_resources()
+    if st.session_state.get("resource_last_loaded_file"):
+        st.success(f"Loaded: **{st.session_state['resource_last_loaded_file']}**", icon="✅")
 
     # Standard resource inputs
     st.markdown('<p class="crra-sub-heading">Set available resources for one year</p>', unsafe_allow_html=True)
@@ -766,6 +863,21 @@ def render_tab(cost_sliders):
 
     apply_auto_disable_logic(method_to_primary_resources, secondary_resources)
 
+    # Rendered after all resource inputs above (which write into
+    # resource_caps) so the export always reflects this render's latest
+    # values — placing it earlier would download the previous rerun's values,
+    # since Streamlit executes top-to-bottom and the inputs update the dict
+    # further down in the script.
+    if any(v > 0 for v in st.session_state.resource_caps.values()):
+        st.download_button(
+            label="Download current resources",
+            data=resource_caps_to_excel_bytes(st.session_state.resource_caps),
+            file_name="current_resources.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            icon=":material/download:",
+            key="download_button_current_resources",
+        )
+
     panel_custom_resources_controls(cost_sliders)
 
     render_resource_summary()