Update app.py

app.py

@@ -1,489 +1,13 @@
-# 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")
+# app.py — launcher for Streamlit inside a Gradio Space
+import os
+import subprocess
+
+PORT = os.environ.get("PORT", "7860")  # HF Spaces provides PORT
+cmd = [
+    "streamlit", "run", "plate_map_app.py",
+    "--server.port", PORT,
+    "--server.address", "0.0.0.0",
+    "--theme.base", "light",  # optional
+]
+# Run and block; return code will propagate to container logs on failure
+subprocess.run(cmd, check=True)