[FEAT] utils: add run_expanded_optimization (LP pipeline for tab5), add resource_caps_to_excel_bytes, increase number precision in render_resource_input

utils/data_utils.py

@@ -7,7 +7,9 @@ import streamlit as st
 from config.config import (
     resource_unit_map, resource_order, method_order,
     resource_groups, method_groups, secondary_resources, CO2_UNIT,
+    hidden_resource_names,
 )
+from optimization.optimization import run_optimization
 
 def get_resource_to_group() -> dict[str, str]:
     """Map each resource name to its resource group.
@@ -243,6 +245,129 @@ def make_variant_name(method_name: str, batch_name: str) -> str:
     return f"{method_name}: {batch_name}"
 
 
+def run_expanded_optimization(resource_caps, method_constraints, costs, custom_resources, enabled_methods):
+    """Apply the full Tab 4 preprocessing pipeline, then run the LP.
+
+    This is the same pipeline as tab4_optimization.run_and_store_result: apply
+    enabled_methods overrides, inject custom-batch coefficients, neutralise
+    all-zero methods, deactivate methods missing a required resource, and —
+    crucially — expand any "Other"-tagged method into one independent method
+    variant per assigned custom batch (each variant gets the batch as its own
+    standard-style resource, with its own cap, instead of going through the
+    z-variable pooling/substitution mechanism).
+
+    Any caller that needs LP results consistent with what Tab 4 actually shows
+    (e.g. Tab 5's sensitivity sweeps) should use this instead of calling
+    run_optimization() directly with raw session-state costs — otherwise a
+    custom resource attached to an "Other" method would be silently computed
+    through the wrong mechanism and never show up as its own entry.
+
+    Args:
+        resource_caps (dict): {resource: available amount} — may be a perturbed
+            copy of st.session_state.resource_caps.
+        method_constraints (dict): {method: {active, cap_type, cap_value}} — may
+            be a perturbed copy of st.session_state.constraints.
+        costs (dict): {method: {resource: coefficient}}, raw/unexpanded —
+            normally st.session_state.costs.
+        custom_resources (list): custom batch dicts.
+        enabled_methods (dict): {resource: {method: bool}}.
+
+    Returns:
+        tuple[bool, dict]: same shape as optimization.run_optimization()'s
+            return value — (True, result_dict) or (False, {"message": str}).
+    """
+    applied_costs = {m: dict(v) for m, v in costs.items()}
+    for method, method_resources in applied_costs.items():
+        for resource in list(method_resources):
+            if not enabled_methods.get(resource, {}).get(method, True):
+                applied_costs[method][resource] = 0.0
+
+    # Inject custom batch coefficients so neutralize does not wrongly deactivate
+    # a method that only has custom-batch access.
+    for batch in custom_resources:
+        batch_name = batch["name"]
+        for method_name, coefficients in batch.get("methods", {}).items():
+            if method_name in applied_costs and applied_costs[method_name].get(batch_name, 0.0) == 0.0:
+                applied_costs[method_name][batch_name] = coefficients.get("median", 0.0)
+
+    standard_constraints = {
+        m: c for m, c in method_constraints.items()
+        if m in applied_costs
+    }
+    safe_constraints = neutralize_zero_coefficient_methods(applied_costs, standard_constraints)
+
+    # Deactivate any method that requires a resource not provided (standard cap
+    # nor custom batch covers it).
+    custom_batch_names_pre = {b["name"] for b in custom_resources}
+    available_resources = set(resource_caps) | custom_batch_names_pre
+    for m, m_costs in applied_costs.items():
+        if not safe_constraints.get(m, {}).get("active", True):
+            continue
+        missing = [
+            r for r, c in m_costs.items()
+            if c > 0 and r not in available_resources
+        ]
+        if missing:
+            safe_constraints.setdefault(m, default_constraint())
+            safe_constraints[m] = {**safe_constraints[m], "active": False}
+
+    # Expand "Other" methods: replace each with one variant per assigned batch.
+    resource_caps_for_lp = dict(resource_caps)
+    expanded_batch_names: set[str] = set()
+
+    for m in list(applied_costs.keys()):
+        if not is_other_method(m):
+            continue
+        batches_for_m = get_other_method_variants(m, custom_resources)
+        if not batches_for_m:
+            continue
+        all_batch_names_for_m = {b["name"] for b in batches_for_m}
+
+        for batch in batches_for_m:
+            vname = make_variant_name(m, batch["name"])
+            variant_costs = {
+                r: coeff for r, coeff in applied_costs[m].items()
+                if r not in hidden_resource_names and r not in all_batch_names_for_m
+            }
+            variant_costs[batch["name"]] = applied_costs[m].get(
+                batch["name"],
+                batch["methods"][m]["median"],
+            )
+            applied_costs[vname] = variant_costs
+            safe_constraints[vname] = (
+                method_constraints.get(vname) or default_constraint()
+            )
+            resource_caps_for_lp[batch["name"]] = float(batch["amount"])
+            expanded_batch_names.add(batch["name"])
+        del applied_costs[m]
+        del safe_constraints[m]
+
+    custom_resources_for_lp = [b for b in custom_resources if b["name"] not in expanded_batch_names]
+
+    # Non-"Other" methods that share an expanded batch lose their z-variable
+    # once the batch is removed from custom_resources_for_lp — inject it as a
+    # standard resource coefficient so the constraint still applies to them.
+    for batch in custom_resources:
+        if batch["name"] not in expanded_batch_names:
+            continue
+        batch_group = batch.get("group", "")
+        group_cap_is_zero = resource_caps_for_lp.get(batch_group, 0.0) == 0.0
+        for method_name, coeff_dict in batch.get("methods", {}).items():
+            if method_name not in applied_costs:
+                continue
+            applied_costs[method_name][batch["name"]] = coeff_dict.get("median", 0.0)
+            if group_cap_is_zero and batch_group in applied_costs[method_name]:
+                applied_costs[method_name][batch_group] = 0.0
+
+    return run_optimization(
+        resource_caps=resource_caps_for_lp,
+        method_constraints=safe_constraints,
+        method_costs=applied_costs,
+        custom_resources=custom_resources_for_lp,
+        enabled_methods=enabled_methods,
+    )
+
+
 # ---------------------------------------------------------------------------
 # Resource / Excel helpers (moved from tab1)
 
@@ -251,6 +376,34 @@ def standard_resource_names() -> set:
     return {r for rlist in resource_groups.values() for r in rlist}
 
 
+def resource_caps_to_excel_bytes(resource_caps: dict) -> bytes:
+    """Serialise the current standard resource availabilities to an Excel file.
+
+    Same "Resource" / "Unit" / "Available Amount" columns as the blank template
+    (data/resource_template.xlsx), so the exported file can be re-uploaded as-is.
+
+    Args:
+        resource_caps (dict): {resource: available amount}.
+
+    Returns:
+        bytes: raw bytes of the .xlsx workbook.
+    """
+    resource_to_unit = get_resource_to_unit()
+    rows = [
+        {
+            "Resource": r,
+            "Unit": resource_to_unit.get(r, ""),
+            "Available Amount": float(amount),
+        }
+        for r, amount in resource_caps.items()
+        if r in resource_order
+    ]
+    excel_buffer = BytesIO()
+    with pd.ExcelWriter(excel_buffer, engine="openpyxl") as writer:
+        pd.DataFrame(rows).to_excel(writer, index=False, sheet_name="resource_caps")
+    return excel_buffer.getvalue()
+
+
 def to_excel_bytes(batches: list) -> bytes:
     """Serialise all custom resource batches to an Excel file (one row per batch × method).
 

utils/ui_helpers.py

@@ -25,9 +25,9 @@ def render_resource_input(name_clean, r, tooltip=None):
     cap = st.number_input(
         label=name_clean,
         min_value=0.0,
-        format="%.2f",
+        format="%.10g",
         value=None,
-        placeholder="0.00",
+        placeholder="0.0",
         key=widget_key,
         help=tooltip,
     )