Create plate_map_app.py

plate_map_app.py

@@ -0,0 +1,489 @@
+# plate_map_app.py
+# Advanced Plate Map Designer — fixed-width concentration bars + per-well colors + compact legends
+import io
+from typing import List, Optional, Dict
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+import matplotlib.pyplot as plt
+from matplotlib.patches import Circle, Rectangle
+
+ROW_LETTERS = "ABCDEFGHIJKLMNOP"
+
+PLATE_SPECS = {
+    "96-well (8x12)": {"rows": 8, "cols": 12},
+    "24-well (4x6)":  {"rows": 4, "cols": 6},
+}
+
+DEFAULT_COLORMAPS = {"concentration": "magma", "seeding_density": "viridis"}
+
+# ----------------------------- Helpers -----------------------------
+
+def well_id(r: int, c: int) -> str:
+    return f"{ROW_LETTERS[r-1]}{c}"
+
+def parse_well_token(token: str) -> List[str]:
+    token = token.strip().upper()
+    if token in ("ALL", "*"):
+        return ["ALL"]
+    token = token.replace("-", ":")
+    if ":" in token:
+        s, e = token.split(":")
+        srow, scol = s[0], int(s[1:])
+        erow, ecol = e[0], int(e[1:])
+        r0, r1 = ROW_LETTERS.index(srow)+1, ROW_LETTERS.index(erow)+1
+        out = []
+        for r in range(min(r0, r1), max(r0, r1)+1):
+            for c in range(min(scol, ecol), max(scol, ecol)+1):
+                out.append(f"{ROW_LETTERS[r-1]}{c}")
+        return out
+    return [token]
+
+def expand_well_ranges(rng: str) -> List[str]:
+    if not rng: return []
+    out, seen = [], set()
+    for t in [t for t in rng.replace(";", ",").split(",") if t.strip()]:
+        for w in parse_well_token(t):
+            if w not in seen:
+                out.append(w); seen.add(w)
+    return out
+
+def empty_plate_df(rows: int, cols: int) -> pd.DataFrame:
+    rows_list = []
+    for r in range(1, rows+1):
+        for c in range(1, cols+1):
+            rows_list.append({
+                "well": well_id(r, c), "row": ROW_LETTERS[r-1], "col": c,
+                "cell_line": "", "cell_color": "", "seeding_density": np.nan,
+                "compound": "", "compound_color": "",
+                "concentration": np.nan, "conc_units": "",
+                "conc_bar_color": "",   # per-well concentration bar color
+                "vehicle": "", "control_type": "",
+                "timepoint": "", "replicate": "", "group_id": "", "notes": ""
+            })
+    return pd.DataFrame(rows_list)
+
+def serial_values(start: float, factor: float, n: int, direction="decreasing"):
+    vals = [start]
+    for _ in range(n-1):
+        vals.append(vals[-1]/factor if direction=="decreasing" else vals[-1]*factor)
+    return vals
+
+def load_uploaded_csv(uploaded) -> Optional[pd.DataFrame]:
+    try: return pd.read_csv(uploaded)
+    except Exception:
+        uploaded.seek(0)
+        try: return pd.read_excel(uploaded)
+        except Exception: return None
+
+def build_compound_color_map(df: pd.DataFrame) -> Dict[str, str]:
+    comps = [s for s in (str(x).strip() for x in df["compound"].dropna()) if s]
+    comps = list(dict.fromkeys(comps))
+    palette = plt.get_cmap("tab20").colors
+    mapping = {}
+    for _, r in df.iterrows():
+        comp = str(r["compound"]).strip()
+        c = str(r.get("compound_color", "")).strip()
+        if comp and c: mapping[comp] = c
+    import matplotlib as mpl
+    k = 0
+    for comp in comps:
+        if comp not in mapping:
+            mapping[comp] = mpl.colors.to_hex(palette[k % len(palette)]); k += 1
+    return mapping
+
+def build_celltype_color_map(df: pd.DataFrame) -> Dict[str, str]:
+    lines = [s for s in (str(x).strip() for x in df["cell_line"].dropna()) if s]
+    lines = list(dict.fromkeys(lines))
+    palette = plt.get_cmap("tab10").colors
+    mapping = {}
+    for _, r in df.iterrows():
+        line = str(r["cell_line"]).strip()
+        c = str(r.get("cell_color", "")).strip()
+        if line and c and line not in mapping: mapping[line] = c
+    import matplotlib as mpl
+    k = 0
+    for line in lines:
+        if line not in mapping:
+            mapping[line] = mpl.colors.to_hex(palette[k % len(palette)]); k += 1
+    return mapping
+
+# ----------------------------- Drawing -----------------------------
+
+def draw_plate_figure(
+    df: pd.DataFrame,
+    rows: int,
+    cols: int,
+    color_by: str,
+    second_label: str = "concentration",
+    show_legend: bool = True,
+    edge_highlight: bool = True,
+    figsize_scale: float = 1.0,
+    dpi: int = 300,
+    text_fontsize: int = 8,
+    conc_mode: str = "text",                 # "text" (above wells) | "bar" | "none"
+    conc_bar_color_global: str = "#4d4d4d",  # fallback for per-well bar color
+):
+    cmap_name = DEFAULT_COLORMAPS.get(color_by, "viridis")
+    numeric_fields = {"concentration", "seeding_density"}
+
+    fig_w = max(6.0, cols * 0.55) * figsize_scale
+    fig_h = max(5.5, rows * 0.7) * figsize_scale
+    fig, ax = plt.subplots(figsize=(fig_w, fig_h), dpi=dpi)
+    ax.set_aspect("equal"); ax.axis("off")
+
+    panel = Rectangle((0, 0), cols + 2, rows + 2, linewidth=0.6, edgecolor="#444", facecolor="#FAFAFA")
+    ax.add_patch(panel)
+
+    x0, y0 = 1, 1
+    radius = 0.35
+
+    compound_map = build_compound_color_map(df)
+    celltype_map  = build_celltype_color_map(df)
+
+    face_colors, scalar_norm, categorical_palette = {}, None, {}
+
+    series = df[color_by] if color_by in df.columns else pd.Series([""] * len(df))
+    if color_by in numeric_fields:
+        vals = pd.to_numeric(series, errors="coerce")
+        finite = vals.replace([np.inf, -np.inf], np.nan).dropna()
+        vmin = finite.min() if len(finite) else 0.0
+        vmax = finite.max() if len(finite) else 1.0
+        vmin, vmax = (vmin, vmax) if np.isfinite([vmin, vmax]).all() and vmin != vmax else (0.0, 1.0)
+        import matplotlib as mpl
+        cmap = plt.get_cmap(cmap_name)
+        scalar_norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
+        for i, w in df["well"].items():
+            val = pd.to_numeric(df.loc[i, color_by], errors="coerce")
+            face_colors[w] = "#FFFFFF" if pd.isna(val) else mpl.colors.to_hex(cmap(scalar_norm(val)))
+    else:
+        if color_by == "compound":
+            for _, r in df.iterrows():
+                comp = str(r["compound"]).strip(); w = r["well"]
+                face_colors[w] = compound_map.get(comp, "#FFFFFF") if comp else "#FFFFFF"
+            categorical_palette = compound_map.copy()
+        else:
+            categories = sorted([c for c in series.astype(str).unique() if c])
+            if categories:
+                palette = plt.get_cmap("tab20").colors
+                for i, cat in enumerate(categories):
+                    import matplotlib as mpl
+                    categorical_palette[cat] = mpl.colors.to_hex(palette[i % len(palette)])
+            for i, w in df["well"].items():
+                key = str(df.loc[i, color_by]) if color_by in df.columns else ""
+                face_colors[w] = categorical_palette.get(key, "#FFFFFF") if key else "#FFFFFF"
+
+    # Units for concentration labels
+    units = df["conc_units"].dropna()
+    conc_unit = str(units.iloc[0]) if len(units) else ""
+
+    # ---- Draw wells
+    for _, row in df.iterrows():
+        r_idx = ROW_LETTERS.index(row["row"]) + 1
+        c_idx = int(row["col"])
+        cx = x0 + c_idx - 0.5
+        cy = y0 + (rows - r_idx + 1) - 0.5
+        fill = face_colors.get(row["well"], "#FFFFFF")
+
+        edge_color = "#333333"; lw = 1.0
+        if isinstance(row.get("control_type", ""), str) and row["control_type"]:
+            edge_color = "#000000"; lw = 2.0
+
+        if edge_highlight and (r_idx in (1, rows) or c_idx in (1, cols)):
+            ax.add_patch(Circle((cx, cy), radius*1.15, linewidth=0, facecolor="#EFEFEF", alpha=0.6, zorder=0))
+
+        ax.add_patch(Circle((cx, cy), radius=radius, linewidth=lw, edgecolor=edge_color, facecolor=fill, zorder=3))
+
+        # cell type inner dot
+        cell_col = str(row.get("cell_color", "")).strip()
+        if cell_col:
+            ax.add_patch(Circle((cx, cy), radius=radius*0.28, linewidth=0.6, edgecolor="#333333",
+                                facecolor=cell_col, zorder=4))
+
+        # concentration: text (above) OR fixed-width bar (below; no text)
+        if conc_mode == "text":
+            val = row.get("concentration", np.nan)
+            if pd.notna(val):
+                try: txt = f"{float(val):.3g}{conc_unit if conc_unit else ''}"
+                except Exception: txt = str(val)
+                ax.text(cx, cy + radius + 0.14, txt, ha="center", va="bottom",
+                        fontsize=text_fontsize, zorder=6)
+        elif conc_mode == "bar":
+            val = pd.to_numeric(row.get("concentration", np.nan), errors="coerce")
+            if not pd.isna(val):
+                # fixed width bar (same for all wells)
+                bar_w = 0.9
+                bar_h = 0.09
+                x_left = cx - bar_w/2
+                y_bottom = cy - radius - 0.18
+                bw_color = str(row.get("conc_bar_color", "")).strip() or conc_bar_color_global
+                ax.add_patch(Rectangle((x_left, y_bottom), bar_w, bar_h, facecolor=bw_color,
+                                       edgecolor="#333333", linewidth=0.6, zorder=6))
+
+        # other overlay in center if not using concentration text
+        if conc_mode != "text" and second_label and second_label not in ("", "concentration"):
+            val = row.get(second_label, "")
+            if pd.notna(val) and str(val):
+                ax.text(cx, cy, str(val), ha="center", va="center", fontsize=text_fontsize, zorder=5)
+
+    # row/col labels
+    for c in range(1, cols+1):
+        ax.text(x0 + c - 0.5, y0 + rows + 0.22, str(c), ha="center", va="bottom", fontsize=10, color="#333333")
+    for r in range(1, rows+1):
+        ax.text(x0 - 0.2, y0 + (rows - r + 1) - 0.5, ROW_LETTERS[r-1], ha="right", va="center", fontsize=10, color="#333333")
+
+    # ---- Legends (right)
+    if show_legend:
+        # Cell type
+        if celltype_map:
+            ax_c = fig.add_axes([0.86, 0.72, 0.12, 0.22]); ax_c.axis("off")
+            ax_c.text(0.0, 1.05, "Cell type", fontsize=11, fontweight="bold", transform=ax_c.transAxes)
+            y = 0.92; dy = 0.10
+            for line, col in list(celltype_map.items())[:25]:
+                ax_c.add_patch(Circle((0.08, y-0.03), radius=0.03, transform=ax_c.transAxes,
+                                      facecolor=col, edgecolor="#333", linewidth=0.6, clip_on=False))
+                ax_c.text(0.18, y-0.03, line, fontsize=9, va="center", transform=ax_c.transAxes)
+                y -= dy
+
+        # Treatment
+        if compound_map:
+            ax_t = fig.add_axes([0.86, 0.44, 0.12, 0.22]); ax_t.axis("off")
+            ax_t.text(0.0, 1.05, "Treatment", fontsize=11, fontweight="bold", transform=ax_t.transAxes)
+            y = 0.92; dy = 0.10
+            for comp, col in list(compound_map.items())[:20]:
+                ax_t.add_patch(Rectangle((0.0, y-0.05), 0.25, 0.04, transform=ax_t.transAxes,
+                                         facecolor=col, edgecolor="#333", linewidth=0.6, clip_on=False))
+                ax_t.text(0.30, y-0.035, comp, fontsize=9, va="center", transform=ax_t.transAxes)
+                y -= dy
+
+        # Concentration legend — equal-length bars, distinct colors, label to the right
+        if conc_mode == "bar":
+            conc_vals = pd.to_numeric(df["concentration"], errors="coerce").replace([np.inf, -np.inf], np.nan).dropna()
+            if len(conc_vals):
+                uniq_vals = sorted({float(v) for v in conc_vals.tolist()}, reverse=True)[:12]
+                pal = plt.get_cmap("tab20").colors
+                legend_colors: Dict[float, str] = {}
+                idx = 0
+                for v in uniq_vals:
+                    # try to use any per-well bar color used for that exact value
+                    rows_v = df[pd.to_numeric(df["concentration"], errors="coerce")==v]
+                    col = ""
+                    for _, rr in rows_v.iterrows():
+                        cbc = str(rr.get("conc_bar_color","")).strip()
+                        if cbc: col = cbc; break
+                    if not col:
+                        import matplotlib as mpl
+                        col = mpl.colors.to_hex(pal[idx % len(pal)]); idx += 1
+                    legend_colors[v] = col
+
+                ax_b = fig.add_axes([0.86, 0.18, 0.12, 0.22]); ax_b.axis("off")
+                ax_b.text(0.0, 1.05, "Concentration", fontsize=11, fontweight="bold", transform=ax_b.transAxes)
+                y = 0.88; dy = 0.11
+                for v in uniq_vals:
+                    color = legend_colors[v]
+                    bar_w = 0.70  # fixed legend bar width
+                    bar_h = 0.10
+                    ax_b.add_patch(Rectangle((0.0, y-bar_h/2), bar_w, bar_h, transform=ax_b.transAxes,
+                                             facecolor=color, edgecolor="#333", linewidth=0.6))
+                    label = f" – {v:.3g}{conc_unit if conc_unit else ''}"
+                    ax_b.text(0.74, y, label, fontsize=9, va="center", ha="left", transform=ax_b.transAxes)
+                    y -= dy
+
+    ax.set_xlim(0, cols + 2); ax.set_ylim(0, rows + 2)
+    ax.set_title("Plate Map", fontsize=22, pad=14)
+    fig.tight_layout(rect=[0.05, 0.05, 0.84, 0.95])  # extra right margin
+    return fig, ax
+
+# ----------------------------- UI -----------------------------
+st.set_page_config(page_title="Advanced Plate Map Designer", layout="wide")
+st.title("Advanced Plate Map Designer")
+st.caption("Design detailed 24- and 96-well plate maps, encode multiple experimental factors, and export high-quality figures and tables.")
+
+with st.sidebar:
+    st.header("Plate Settings")
+    plate_choice = st.selectbox("Plate type", list(PLATE_SPECS.keys()), index=0)
+    rows = PLATE_SPECS[plate_choice]["rows"]; cols = PLATE_SPECS[plate_choice]["cols"]
+    if "plate_df" not in st.session_state or st.session_state.get("shape", (0,0)) != (rows, cols):
+        st.session_state["plate_df"] = empty_plate_df(rows, cols)
+        st.session_state["shape"] = (rows, cols)
+
+    st.divider(); st.subheader("Global Encodings")
+    color_by = st.selectbox("Color wells by", ["compound","cell_line","control_type","concentration","seeding_density"], 0)
+    second_label = st.selectbox("Text overlay", ["concentration","seeding_density","compound","cell_line","replicate","group_id","notes","none"], 0)
+    if second_label == "none": second_label = ""
+    text_fontsize = st.slider("Text overlay font size", 5, 18, 8)
+    conc_mode = st.selectbox("Concentration display", ["text","bar","none"], 1)
+    conc_bar_color_global = "#4d4d4d"
+    if conc_mode == "bar":
+        conc_bar_color_global = st.color_picker("Default bar color (fallback)", value="#4d4d4d")
+    show_legend = st.checkbox("Show legends", True)
+    edge_highlight = st.checkbox("Highlight edge wells", True)
+
+    st.divider(); st.subheader("Export")
+    export_dpi = st.slider("Figure DPI", 150, 1200, 600, step=50)
+    fig_scale = st.slider("Figure size scale", 0.6, 2.5, 1.0, step=0.1)
+
+col_left, col_right = st.columns([0.55, 0.45])
+
+with col_left:
+    st.subheader("Plate Map")
+    fig, ax = draw_plate_figure(
+        st.session_state["plate_df"], rows, cols,
+        color_by=color_by, second_label=second_label,
+        show_legend=show_legend, edge_highlight=edge_highlight,
+        figsize_scale=fig_scale, dpi=export_dpi,
+        text_fontsize=text_fontsize,
+        conc_mode=conc_mode,
+        conc_bar_color_global=conc_bar_color_global
+    )
+    buf = io.BytesIO(); fig.savefig(buf, format="png", dpi=export_dpi, bbox_inches="tight")
+    st.image(buf.getvalue(), caption="Rendered plate")
+    st.download_button("⬇️ Download PNG", data=buf.getvalue(), file_name="plate_map.png", mime="image/png")
+    buf_svg = io.BytesIO(); fig.savefig(buf_svg, format="svg", bbox_inches="tight")
+    st.download_button("⬇️ Download SVG", data=buf_svg.getvalue(), file_name="plate_map.svg", mime="image/svg+xml")
+
+with col_right:
+    st.subheader("Assignments & Tools")
+
+    # ---------- Quick Assign ----------
+    with st.expander("Quick Assign by Well Range", expanded=True):
+        rng = st.text_input("Well range(s) (e.g., A1:A6, B1:B3, C5)", value="")
+        c1, c2 = st.columns(2)
+        with c1:
+            cell_line = st.text_input("Cell line / type", value="")
+            cell_color = st.color_picker("Cell color (inner dot)", value="#FFFFFF")
+            seeding = st.number_input("Seeding density (cells/well)", min_value=0, value=0, step=100)
+            replicate = st.text_input("Replicate ID", value="")
+        with c2:
+            compound = st.text_input("Compound", value="")
+            comp_color = st.color_picker("Compound color (used when 'color by' = compound)", value="#1f77b4")
+            concentration = st.number_input("Concentration", min_value=0.0, value=0.0, step=0.1, format="%.4f")
+            conc_units = st.text_input("Conc Units (e.g., nM, μM, mg/mL)", value="")
+        c3, c4 = st.columns(2)
+        with c3:
+            control_type = st.selectbox("Control type", ["","Negative","Positive","Vehicle","Blank"], 0)
+            timepoint = st.text_input("Timepoint (e.g., 24h)", value="")
+        with c4:
+            group_id = st.text_input("Group / Condition ID", value="")
+            vehicle = st.text_input("Vehicle (optional, e.g., DMSO)", value="")
+        conc_bar_color_assign = st.color_picker("Concentration bar color (for these wells)", value="#4d4d4d")
+        notes = st.text_area("Notes", value="", height=80)
+
+        if st.button("Apply to selected wells"):
+            wells = expand_well_ranges(rng)
+            df = st.session_state["plate_df"]
+            if "ALL" in wells: wells = df["well"].tolist()
+            updates = {
+                "cell_line": cell_line,
+                "cell_color": cell_color if cell_color != "#FFFFFF" else "",
+                "seeding_density": np.nan if seeding == 0 else seeding,
+                "compound": compound,
+                "compound_color": comp_color if comp_color else "",
+                "concentration": np.nan if concentration == 0 else concentration,
+                "conc_units": conc_units,
+                "conc_bar_color": conc_bar_color_assign if conc_mode=="bar" else "",
+                "control_type": control_type,
+                "timepoint": timepoint,
+                "replicate": replicate,
+                "group_id": group_id,
+                "vehicle": vehicle,
+                "notes": notes,
+            }
+            for w in wells:
+                st.session_state["plate_df"].loc[
+                    st.session_state["plate_df"]["well"] == w, list(updates.keys())
+                ] = list(updates.values())
+            st.success(f"Updated {len(wells)} well(s).")
+
+    # ---------- Serial Dilution ----------
+    with st.expander("Serial Dilution Wizard", expanded=False):
+        start_well = st.text_input("Start well (e.g., B2)", value="")
+        steps = st.number_input("Number of steps", 2, 24, 6)
+        start_conc = st.number_input("Starting concentration", 0.0, value=10.0, step=0.1, format="%.4f")
+        factor = st.number_input("Dilution factor", 1.0, value=2.0, step=0.1, format="%.3f")
+        direction = st.selectbox("Direction", ["across row →", "down column ↓"], 0)
+        units = st.text_input("Units (e.g., μM, mg/mL)", value="μM")
+        compound_name = st.text_input("Compound (optional)", value="")
+        comp_color2 = st.color_picker("Compound color", value="#FF7F0E")
+        conc_bar_color2 = st.color_picker("Concentration bar color (for these steps)", value="#4d4d4d")
+        replicate2 = st.text_input("Replicate ID (optional)", value="")
+        if st.button("Fill serial dilution"):
+            try:
+                sr = ROW_LETTERS.index(start_well[0].upper()) + 1
+                sc = int(start_well[1:])
+                wells = []
+                for k in range(steps):
+                    r = sr if "row" in direction else sr + k if "↓" in direction or "down" in direction else sr
+                    c = sc + k if "→" in direction or "across" in direction else sc
+                    if 1 <= r <= rows and 1 <= c <= cols: wells.append(f"{ROW_LETTERS[r-1]}{c}")
+                vals = serial_values(start_conc, factor, len(wells), "decreasing")
+                for w, val in zip(wells, vals):
+                    st.session_state["plate_df"].loc[
+                        st.session_state["plate_df"]["well"] == w,
+                        ["compound","compound_color","concentration","conc_units","replicate","conc_bar_color"]
+                    ] = [compound_name, comp_color2, val, units, replicate2, conc_bar_color2]
+                st.success(f"Applied serial dilution to {len(wells)} well(s).")
+            except Exception as e:
+                st.error(f"Could not parse start well. Error: {e}")
+
+    # ---------- Seeding Gradient ----------
+    with st.expander("Cell Seeding Gradient", expanded=False):
+        start_well2 = st.text_input("Start well (e.g., C3)", key="seed_start")
+        steps2 = st.number_input("Steps", 2, 24, 8, key="seed_steps")
+        start_cells = st.number_input("Starting cells/well", min_value=0, value=20000, step=500, key="seed_num")
+        factor2 = st.number_input("Multiplicative factor", 0.01, value=0.5, step=0.01, format="%.2f", key="seed_factor")
+        direction2 = st.selectbox("Direction", ["across row →", "down column ↓"], 0, key="seed_dir")
+        cell_line2 = st.text_input("Cell line", value="HepG2", key="seed_cellline")
+        cell_color2 = st.color_picker("Cell color", value="#2ca02c", key="seed_color")
+        if st.button("Fill seeding gradient"):
+            try:
+                sr = ROW_LETTERS.index(start_well2[0].upper()) + 1; sc = int(start_well2[1:])
+                wells = []
+                for k in range(steps2):
+                    r = sr if "row" in direction2 else sr + k if "↓" in direction2 or "down" in direction2 else sr
+                    c = sc + k if "→" in direction2 or "across" in direction2 else sc
+                    if 1 <= r <= rows and 1 <= c <= cols: wells.append(f"{ROW_LETTERS[r-1]}{c}")
+                vals = [int(round(start_cells * (factor2 ** i))) for i in range(len(wells))]
+                for w, cells in zip(wells, vals):
+                    st.session_state["plate_df"].loc[
+                        st.session_state["plate_df"]["well"] == w,
+                        ["cell_line","cell_color","seeding_density"]
+                    ] = [cell_line2, cell_color2, cells]
+                st.success(f"Applied seeding gradient to {len(wells)} well(s).")
+            except Exception as e:
+                st.error(f"Could not parse start well. Error: {e}")
+
+    # ---------- Utilities / I/O ----------
+    with st.expander("🧰 Utilities", expanded=False):
+        edge_type = st.selectbox("Mark edge wells as", ["","Buffer","Blank","Vehicle"], 0)
+        if st.button("Apply to edge wells"):
+            if edge_type:
+                df = st.session_state["plate_df"]
+                mask = (df["row"].isin([ROW_LETTERS[0], ROW_LETTERS[rows-1]])) | (df["col"].isin([1, cols]))
+                st.session_state["plate_df"].loc[mask, "control_type"] = "Blank" if edge_type in ("Blank","Buffer") else "Vehicle"
+                st.success("Edge wells updated.")
+        if st.button("Clear all assignments"):
+            st.session_state["plate_df"] = empty_plate_df(rows, cols); st.success("Cleared.")
+
+    with st.expander("Import / Export Table", expanded=False):
+        uploaded = st.file_uploader("Upload CSV/Excel (must include a 'well' column)", type=["csv","xlsx"])
+        if uploaded is not None:
+            df_up = load_uploaded_csv(uploaded)
+            if df_up is None or "well" not in df_up.columns:
+                st.error("Failed to load file or missing 'well' column.")
+            else:
+                df = st.session_state["plate_df"].set_index("well")
+                for col in df_up.columns:
+                    if col not in df.columns: df[col] = np.nan
+                # align columns present in the upload only
+                df.loc[df_up["well"], df_up.columns] = df_up.set_index("well")
+                st.session_state["plate_df"] = df.reset_index(); st.success(f"Imported {len(df_up)} rows.")
+
+        out_csv = st.session_state["plate_df"].to_csv(index=False).encode("utf-8")
+        st.download_button("⬇️ Download CSV", data=out_csv, file_name="plate_map.csv", mime="text/csv")
+        toexcel = io.BytesIO()
+        with pd.ExcelWriter(toexcel, engine="openpyxl") as writer:
+            st.session_state["plate_df"].to_excel(writer, index=False, sheet_name="plate")
+        st.download_button("⬇️ Download Excel", data=toexcel.getvalue(), file_name="plate_map.xlsx",
+                           mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")