[FEAT] Objective 3: Export graph data individually and in full + Added data on the amount of resources consumed and remaining

config/config.py

@@ -1,4 +1,5 @@
 import pandas as pd
+import plotly.express as px
 
 CO2_UNIT = "MtCO₂"
 
@@ -117,4 +118,37 @@ method_tooltips = {
     "Moisture swing DACCS": "Direct air carbon capture and storage using moisture swing methods.",
     "pH swing": "Direct ocean carbon capture and storage using pH swing methods.",
     "Mineralization ex-situ": "Ex-situ mineralization methods for carbon capture."
-}
+}
+
+CRRA_COLORS = {
+    "off_white": "#eae9d8",
+    "red": "#ff5f4d",
+    "green_dark": "#298231",
+    "green": "#55c95b",
+    "green_light": "#92ef9b",
+    "yellow": "#d9e210",
+    "white": "#ffffff",
+    "brown_grey": "#665d5b",
+    "grey": "#a0a0a0",
+    "black": "#000000",
+}
+
+CRRA_FONT = "Segoe UI, sans-serif"
+
+PLOTLY_COLOR_SEQUENCE = [
+    CRRA_COLORS["red"],
+    CRRA_COLORS["green"],
+    CRRA_COLORS["yellow"],
+    CRRA_COLORS["green_dark"],
+    CRRA_COLORS["brown_grey"],
+    CRRA_COLORS["green_light"],
+    CRRA_COLORS["grey"],
+]
+
+PLOTLY_HEATMAP_SCALE = [
+    [0.0, CRRA_COLORS["white"]],
+    [0.5, CRRA_COLORS["green_light"]],
+    [1.0, CRRA_COLORS["green_dark"]],
+]
+
+PLOTLY_TEMPLATE = "plotly_white"

optimization/optimization.py

@@ -101,7 +101,37 @@ def run_optimization(resource_caps, method_constraints, method_costs, custom_res
             x = result.x
             total_removed = x.sum()
             method_usage = {m: x[i] for i, m in enumerate(methods) if x[i] > 0}
-            return True, {"total_removed": total_removed, "method_usage": method_usage}
+            resource_usage = {}
+            for i, r in enumerate(resources):
+                resource_usage[r] = {
+                    m: float(A_resource[i, j] * x[j])
+                    for j, m in enumerate(methods) if A_resource[i, j] * x[j] > 0
+                }
+
+            resource_used_total = {r: sum(resource_usage[r].values()) for r in resources}
+            resource_remaining = {r: resource_caps[r] - resource_used_total[r] for r in resources}
+
+            # Potentiel théorique par méthode (si seule, contrainte ressources + son propre cap)
+            method_potential = {}
+            for j, m in enumerate(methods):
+                limits = []
+                for i, r in enumerate(resources):
+                    coef = A_resource[i, j]
+                    if coef > 0:
+                        limits.append(resource_caps[r] / coef)
+                constraint = method_constraints.get(m, {})
+                if constraint.get("cap_type") == "absolute":
+                    limits.append(constraint.get("cap_value", float("inf")))
+                method_potential[m] = float(min(limits)) if limits else 0.0
+
+            return True, {
+                "total_removed": total_removed,
+                "method_usage": method_usage,
+                "method_potential": method_potential,
+                "resource_usage": resource_usage,
+                "resource_used_total": resource_used_total,
+                "resource_remaining": resource_remaining,
+            }
         else:
             return False, {"message": result.message}
     except Exception as e:

tabs/tab4_optimization.py

@@ -6,15 +6,13 @@ import unicodedata
 import zipfile
 import openpyxl
 
-import matplotlib.pyplot as plt
 import pandas as pd
-import seaborn as sns
 import streamlit as st
-import plotly.graph_objects as go
+import plotly.express as px
 
-from config.config import method_order, resource_order, resource_unit_map, resource_groups, secondary_resources, CO2_UNIT
+from config.config import CRRA_COLORS, PLOTLY_COLOR_SEQUENCE, PLOTLY_HEATMAP_SCALE, method_order, resource_order, resource_unit_map, resource_groups, secondary_resources, CO2_UNIT
 from optimization.optimization import run_optimization
-from utils.ui_helpers import format_table_summary, show_bar
+from utils.ui_helpers import apply_chart_style, format_table_summary, register_chart_data, show_bar
 from utils.data_utils import is_valid_scenario, load_inputs_from_excel, strip_unit_suffix
 
 
@@ -62,7 +60,6 @@ def panel_load_from_excel():
         st.session_state.setdefault("input_file_name_suggestion", default_name)
         try:
             resource_caps, constraints, costs, custom_resources = load_inputs_from_excel(uploaded)
-            print(custom_resources)
             st.session_state.resource_caps = resource_caps
             st.session_state.constraints = constraints
             st.session_state.costs = costs
@@ -140,7 +137,7 @@ def parse_zip_scenario(uploaded) -> dict | None:
             custom_resources = []
             if "custom_resources.csv" in names:
                 df_custom = pd.read_csv(io.BytesIO(zf.read("custom_resources.csv")))
-                required_custom = {"name", "group", "amount", "method", "min", "median", "max"}
+                required_custom = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
                 if required_custom.issubset(df_custom.columns):
                     for bname in df_custom["name"].unique():
                         df_b = df_custom[df_custom["name"] == bname]
@@ -241,7 +238,7 @@ def run_and_store_result():
 
     # Check that at least some resource is non-zero (standard OR custom)
     std_total = sum(st.session_state.resource_caps.values())
-    print(custom_resources)
+
     custom_total = sum(float(b["amount"]) for b in custom_resources)
     if std_total <= 0 and custom_total <= 0:
         st.warning("⚠️ All resources are set to 0. Please set resource availability or load a scenario / input data.")
@@ -274,6 +271,10 @@ def run_and_store_result():
     st.session_state.latest_result = {
         "summary": {"total_co2_removed": total_removed, "total_cost": total_cost},
         "allocations": allocations,
+        "method_potential": result["method_potential"],
+        "resource_usage": result["resource_usage"],
+        "resource_used_total": result["resource_used_total"],
+        "resource_remaining": result["resource_remaining"],
         "resource_caps": st.session_state.resource_caps.copy(),
         "method_constraints": st.session_state.constraints,
         "method_costs": st.session_state.costs,
@@ -292,28 +293,66 @@ def show_metrics(latest):
     cols[0].metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.2f} {CO2_UNIT}")
     cols[1].metric("Methods Used", len(latest["allocations"]))
 
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
     # Show which custom batches were included and how much of each was available
     if custom_resources:
         with st.expander(f"✅ {len(custom_resources)} new resource(s) included in this optimisation", expanded=False):
             rows = []
             for batch in custom_resources:
-                unit = batch.get("group", "?")
+                group = resource_to_group.get(batch["group"])
+                unit = resource_unit_map.get(group, '?')
                 rows.append({
                     "Batch name": batch["name"],
                     "Group": batch["group"],
-                    "Amount available": f"{float(batch['amount']):,.2f}",
+                    "Amount available": f"{float(batch['amount']):,.2f} {unit}",
                     "Methods linked": ", ".join(batch["methods"].keys())
                 })
             st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
 
-
-def build_results_df(allocations, method_constraints=None):
+def build_resource_usage_df(resource_usage):
+    """resource_usage = {resource: {method: qty}}"""
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
+    rows = []
+    for r, methods in resource_usage.items():
+        unit = resource_unit_map.get(resource_to_group.get(r))
+        if unit is None:
+            for batch in st.session_state.custom_resources:
+                group = resource_to_group.get(batch["group"])
+                unit = resource_unit_map.get(group, '?')
+
+        for m, qty in methods.items():
+            rows.append({
+                "Resource": f"{r} ({unit})",
+                "Method": m,
+                "Used": qty
+            })
+
+    return pd.DataFrame(rows)
+
+def build_results_df(allocations, method_potential=None, method_constraints=None):
     df = pd.DataFrame.from_dict(allocations, orient="index", columns=[f"{CO2_UNIT} removed"])
-    print(df)
+
     df[f"{CO2_UNIT} removed"] = pd.to_numeric(df[f"{CO2_UNIT} removed"], errors="coerce")
     total = df[f"{CO2_UNIT} removed"].sum()
     if total > 0:
-        df["Share (%)"] = (df[f"{CO2_UNIT} removed"] / total * 100).round(2)
+        df["Total share (%)"] = (df[f"{CO2_UNIT} removed"] / total * 100).round(2)
+
+    if method_potential:
+        df["Potential (" + CO2_UNIT + ")"] = pd.Series(method_potential)
+        # df["Allocated / Potential (%)"] = (
+        #     df[f"{CO2_UNIT} removed"] / df["Potential (" + CO2_UNIT + ")"] * 100
+        # ).round(1)
+        df["Potential (" + CO2_UNIT + ")"] = df[
+            "Potential (" + CO2_UNIT + ")"
+        ].map(lambda x: f"{x:,.2f}" if pd.notna(x) else x)
 
     if method_constraints:
         caps = {}
@@ -330,18 +369,14 @@ def build_results_df(allocations, method_constraints=None):
 
 
 def show_donut(df_result):
-    fig = go.Figure(data=[go.Pie(
-        labels=df_result.index.tolist(),
-        values=df_result[f"{CO2_UNIT} removed"].tolist(),
-        hole=0.4,
-        textinfo="label+percent",
-        textposition="outside",
-        marker=dict(line=dict(color="#000000", width=1)),
-        showlegend=False,
-    )])
-    fig.update_layout(margin=dict(t=10, b=10))
+    df_plot = df_result.reset_index().rename(columns={"index": "Method"})
+    fig = px.pie(df_plot, names="Method", values=f"{CO2_UNIT} removed", hole=0.4,
+                 color_discrete_sequence=PLOTLY_COLOR_SEQUENCE)
+    fig.update_traces(textinfo="label+percent", textposition="outside",
+                   marker=dict(line=dict(color=CRRA_COLORS["white"], width=1)))
+    apply_chart_style(fig)
     st.plotly_chart(fig, use_container_width=True)
-
+    register_chart_data("Method allocation (donut)", df_plot)
 
 def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None):
     # Normalize standard method_costs keys (strip legacy unit suffixes)
@@ -379,20 +414,22 @@ def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None):
         matrix.append(row)
         y_labels.append(method)
 
-    height = max(400, 60 + 30 * len(y_labels))
-
-    fig = go.Figure(data=go.Heatmap(
-        z=matrix, x=available, y=y_labels,
-        colorscale="Blues",
-        hovertemplate="Method: %{y}<br>Resource: %{x}<br>% Used: %{z:.2f}%<extra></extra>",
-    ))
-    fig.update_layout(
-        title="Resource Usage vs. Cap",
-        xaxis_title="Resource", yaxis_title="Method", height=height,
-        xaxis=dict(tickangle=-35),
+    df_heat = pd.DataFrame(matrix, index=y_labels, columns=available)
+
+    fig = px.imshow(
+        df_heat, color_continuous_scale=PLOTLY_HEATMAP_SCALE, text_auto=".1f",
+        labels=dict(x="Resource", y="Method", color="% Used"),
     )
+    apply_chart_style(fig, height=max(400, 60 + 30 * len(df_heat.index)))
     st.plotly_chart(fig, use_container_width=True)
 
+    df_export = df_heat.reset_index().rename(columns={"index": "Method"})
+    
+    with st.expander("📊 View / download chart data"):
+        st.dataframe(df_export, use_container_width=True, hide_index=True)
+
+    register_chart_data("Resource usage heatmap (% of cap)", df_export)
+
 def show_absolute_usage(allocations, method_costs, custom_resources=None):
     # Normalize method_costs keys: strip legacy unit suffixes
     normalized_costs = {
@@ -438,17 +475,70 @@ def show_absolute_usage(allocations, method_costs, custom_resources=None):
         return
 
     df = pd.DataFrame(rows)
-    print(df)
     for unit in df["Unit"].unique():
-        st.markdown(f"#### Resources in {unit}")
         df_unit = df[df["Unit"] == unit]
-        fig, ax = plt.subplots(figsize=(8, 4 + 0.3 * df_unit["Resource"].nunique()))
-        sns.barplot(data=df_unit, x="Resource", y="Used", hue="Method", ax=ax)
-        ax.set_ylabel(f"Used ({unit})")
-        ax.tick_params(axis="x", rotation=45)
-        ax.legend(title="Method", bbox_to_anchor=(1.05, 1), loc="upper left")
-        st.pyplot(fig)
+        fig = px.bar(
+            df_unit, x="Resource", y="Used", color="Method", barmode="group",
+            color_discrete_sequence=PLOTLY_COLOR_SEQUENCE,
+        )
+        apply_chart_style(fig)
+        fig.update_layout(yaxis_title=f"Used ({unit})", xaxis_tickangle=-45)
+        st.plotly_chart(fig, use_container_width=True)
+    with st.expander("📊 View / download chart data"):
+        st.dataframe(df, use_container_width=True, hide_index=True)
+    register_chart_data("Absolute resource usage by method", df)
+
+def show_resource_balance(latest):
+    st.markdown("### Resource balance: used vs available")
+    resource_caps = latest["resource_caps"]
+    used_total = latest["resource_used_total"]
+    remaining = latest["resource_remaining"]
 
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
+        
+    rows = []
+    for r in resource_caps:
+        group = resource_to_group.get(r)
+        unit = f"{resource_unit_map.get(group, '?')}"
+        cap = resource_caps[r]
+        if cap <= 0:
+            continue
+        used = used_total.get(r, 0.0)
+        rows.append({
+            "Resource": f"{r} ({unit})",
+            "Available amount": cap,
+            "Quantity used": used,
+            "Quantity remaining": remaining.get(r, cap),
+            "% used": round(used / cap * 100, 1) if cap > 0 else 0,
+        })
+
+    # inclure aussi les ressources personnalisées
+    for batch in latest.get("custom_resources", []):
+        r = batch["name"]
+        cap = float(batch["amount"])
+        used = used_total.get(r, 0.0)
+        rows.append({
+            "Resource": r, "Available amount": cap, "Quantity used": used,
+            "Quantity remaining": remaining.get(r, cap),
+            "% used": round(used / cap * 100, 1) if cap > 0 else 0,
+        })
+
+    df = pd.DataFrame(rows).sort_values("% used", ascending=False)
+
+    fig = px.bar(
+        df, x="Resource", y=["Quantity used", "Quantity remaining"], barmode="stack",
+        color_discrete_map={"Quantity used": CRRA_COLORS["green"], "Quantity remaining": CRRA_COLORS["off_white"]},
+    )
+    apply_chart_style(fig)
+    fig.update_layout(yaxis_title="Quantity", xaxis_tickangle=-45)
+    st.plotly_chart(fig, use_container_width=True)
+    with st.expander("📊 View / download chart data"):
+        st.dataframe(df, use_container_width=True, hide_index=True)
+    register_chart_data("Resource balance (used vs remaining)", df)
 
 # ─── Save / export / reset ───────────────────────────────────────────────────────────
 
@@ -626,6 +716,68 @@ def export_inputs_only():
             icon=":material/download:"
         )
 
+import zipfile
+
+def export_all_charts():
+    st.markdown("### Export all chart data")
+    st.markdown(
+        '<p class="caption">Download a single file containing the underlying data '
+        'of every chart shown in this session.</p>',
+        unsafe_allow_html=True
+    )
+
+    registry = st.session_state.get("chart_data_registry", {})
+    if not registry:
+        st.info("No charts have been generated yet in this session.")
+        return
+
+    col_name, col_fmt = st.columns([2, 1])
+    with col_name:
+        base_name = st.text_input(
+            "File name",
+            value="charts_data",
+            key="charts_export_name",
+            help="The extension (.xlsx or .zip) is added automatically.",
+        )
+    with col_fmt:
+        fmt = st.radio(
+            "Format", ["Excel (.xlsx, one sheet per chart)", "ZIP (one CSV per chart)"],
+            horizontal=True, key="chart_export_format",
+        )
+
+    safe_name = base_name.strip() or "charts_data"
+
+    if fmt.startswith("Excel"):
+        buf = io.BytesIO()
+        with pd.ExcelWriter(buf, engine="openpyxl") as writer:
+            for name, df in registry.items():
+                sheet_name = name[:31]  # limite Excel
+                df.to_excel(writer, sheet_name=sheet_name, index=False)
+        st.download_button(
+            f"Download {safe_name}.xlsx",
+            data=buf.getvalue(),
+            file_name=f"{safe_name}.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            icon=":material/download:"
+        )
+    else:
+        buf = io.BytesIO()
+        with zipfile.ZipFile(buf, "w") as zf:
+            for name, df in registry.items():
+                # nom de fichier sûr : remplace espaces/caractères spéciaux
+                safe_chart_name = (
+                    name.replace(" ", "_").replace("/", "-").replace("(", "").replace(")", "")
+                )
+                zf.writestr(f"{safe_chart_name}.csv", df.to_csv(index=False))
+
+        st.download_button(
+            f"Download {safe_name}.zip",
+            data=buf.getvalue(),
+            file_name=f"{safe_name}.zip",
+            mime="application/zip",
+            icon=":material/download:"
+        )
+
 def clear_all_data():
     for key in ["resource_caps", "constraints", "costs", "scenarios", 
                 "latest_result", "scenario_loaded_file", "scenario_name", 
@@ -732,6 +884,7 @@ def render_tab():
     show_metrics(latest)
     df_result = build_results_df(
         allocations,
+        method_potential=latest.get("method_potential"),
         method_constraints=latest.get("method_constraints")
     )
 
@@ -742,9 +895,23 @@ def render_tab():
     )
 
     st.subheader("Optimization Summary")
-    st.markdown(
-        format_table_summary(df_display, "cdr-table-res"),
-        unsafe_allow_html=True
+    # st.markdown(
+    #     format_table_summary(df_display, "cdr-table-res"),
+    #     unsafe_allow_html=True
+    # )
+
+    st.dataframe(
+        df_display,
+        column_config={
+            "Potential (MtCO₂)": st.column_config.NumberColumn(
+                "Potential (MtCO₂)",
+                help="Maximum CO₂ this method could remove if limited only by "
+                    "resources and its own cap, without competition from other "
+                    "methods. For % caps, this value ignores the cap.",
+                format="%.0f",
+            ),
+        },
+        use_container_width=True,
     )
 
     st.markdown("### Method allocation breakdown")
@@ -756,8 +923,15 @@ def render_tab():
     st.markdown("### Absolute resource usage by unit")
     show_absolute_usage(allocations, method_costs, custom_resources=latest.get("custom_resources", []))
 
+    show_resource_balance(latest)
+    df_usage = build_resource_usage_df(latest["resource_usage"])
+
+    st.markdown("### Detailed resource usage by method")
+    st.dataframe(df_usage.pivot(index="Resource", columns="Method", values="Used").fillna(0), use_container_width=True)
+
     # ── Save & export & reset ───────────────────────────────────────────────────────
     save_scenario(latest)
     export_scenario()
     export_inputs_only()
+    export_all_charts()
     reset_scenario()

tabs/tab5_sensitivity.py

@@ -2,10 +2,11 @@ import matplotlib.pyplot as plt
 import pandas as pd
 import seaborn as sns
 import streamlit as st
+import plotly.express as px
 
 from config.config import CO2_UNIT, method_order, resource_order
 from optimization.optimization import run_optimization
-from utils.ui_helpers import show_bar
+from utils.ui_helpers import register_chart_data, show_bar
 
 
 def render_tab():
@@ -41,6 +42,10 @@ def render_tab():
     )
     baseline_removed = baseline_result["total_removed"] if baseline_success else 0
 
+    all_resources = resource_order
+
+    print(resource_order)
+    print(st.session_state.get("custom_resources", []))
     tab1, tab2 = st.tabs(["🔁 Resource sensitivity", "🔁 Method sensitivity"])
 
     with tab1:
@@ -78,11 +83,13 @@ def render_tab():
 
             df = pd.DataFrame(all_data)
             st.markdown("#### Sensitivity to resource availability")
-            fig, ax = plt.subplots(figsize=(8, 5))
-            sns.lineplot(data=df, x="% of cap", y=f"CO₂ removed ({CO2_UNIT})", hue="Input", ax=ax)
-            ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
-            ax.legend()
-            st.pyplot(fig)
+            fig = px.line(df, x="% of cap", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True)
+            fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
+                        annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
+            st.plotly_chart(fig, use_container_width=True)
+            with st.expander("📊 View / download chart data"):
+                st.dataframe(df, use_container_width=True, hide_index=True)
+            register_chart_data("Sensitivity to resource availability)", df)
 
     with tab2:
         st.subheader("Impact of max allocation per method")
@@ -119,11 +126,19 @@ def render_tab():
                         })
 
                 df = pd.DataFrame(all_data)
-                fig, ax = plt.subplots(figsize=(8, 5))
-                sns.lineplot(data=df, x="% max allocation", y=f"CO₂ removed ({CO2_UNIT})", hue="Input", ax=ax)
-                ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
-                ax.legend()
-                st.pyplot(fig)
+                # fig, ax = plt.subplots(figsize=(8, 5))
+                # sns.lineplot(data=df, x="% max allocation", y=f"CO₂ removed ({CO2_UNIT})", hue="Input", ax=ax)
+                # ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
+                # ax.legend()
+                # st.pyplot(fig)
+
+                fig = px.line(df, x="% max allocation", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True)
+                fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
+                            annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
+                st.plotly_chart(fig, use_container_width=True)
+                with st.expander("📊 View / download chart data"):
+                    st.dataframe(df, use_container_width=True, hide_index=True)
+                register_chart_data("Sensitivity to % cap", df)
 
             if absolute_methods:
                 st.markdown(f"#### Sensitivity to absolute cap ({CO2_UNIT}/yr)")
@@ -158,8 +173,10 @@ def render_tab():
 
                 if all_data:
                     df = pd.DataFrame(all_data)
-                    fig, ax = plt.subplots(figsize=(8, 5))
-                    sns.lineplot(data=df, x=f"Cap ({CO2_UNIT}/yr)", y=f"CO₂ removed ({CO2_UNIT})", hue="Input", ax=ax)
-                    ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
-                    ax.legend()
-                    st.pyplot(fig)
+                    fig = px.line(df, x="Cap ({CO2_UNIT}/yr)", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True)
+                    fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
+                                annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
+                    st.plotly_chart(fig, use_container_width=True)
+                    with st.expander("📊 View / download chart data"):
+                        st.dataframe(df, use_container_width=True, hide_index=True)
+                    register_chart_data("Sensitivity to absolute cap", df)

tabs/tab6_scenarios.py

@@ -102,6 +102,8 @@ def _show_method_allocations(df):
     plt.xticks(rotation=45, ha="right")
     st.pyplot(fig)
 
+    
+
 
 def _show_resource_usage(df):
     if df.empty:

utils/ui_helpers.py

@@ -1,11 +1,34 @@
 import numpy as np
 import pandas as pd
 import streamlit as st
-from config.config import CO2_UNIT
+from config.config import CO2_UNIT, CRRA_COLORS, CRRA_FONT
+import plotly.express as px
+from config.config import PLOTLY_TEMPLATE, PLOTLY_COLOR_SEQUENCE
 
 # params
 background_color = "#3d86e9"
 
+def apply_chart_style(fig, height=None):
+    """Style cohérent CRRA pour tous les graphiques Plotly."""
+    fig.update_layout(
+        template=PLOTLY_TEMPLATE,
+        font=dict(family=CRRA_FONT, size=12, color=CRRA_COLORS["black"]),
+        margin=dict(t=40, b=40, l=40, r=20),
+        legend=dict(
+            orientation="v",
+            yanchor="middle", y=0.5,
+            xanchor="left", x=1.02,
+        ),
+    )
+    if height:
+        fig.update_layout(height=height)
+    return fig
+
+def register_chart_data(name: str, df: pd.DataFrame):
+    """Enregistre les données d'un graphique pour l'export consolidé final."""
+    st.session_state.setdefault("chart_data_registry", {})
+    st.session_state["chart_data_registry"][name] = df.copy()
+
 def show_bar():
     st.markdown(
         """
@@ -222,3 +245,4 @@ def clean_labels(labels):
     Cleans labels to remove zero-allocation items or clutter.
     """
     return [label for label in labels if label and label.strip() != ""]
+