Update app.py

app.py

@@ -174,30 +174,139 @@ with tab2:
 # --------------------------------------------------
 
 with tab3:
+    import numpy as np
+    import pandas as pd
+    import re
+    from math import ceil
+
     st.header("🧪 Pipetting Command Generator")
     st.markdown("""
     Upload your sample file (Excel, CSV, or TXT) containing binary mutation data.
     The app will:
     - Auto-detect or create `Sample`, `Position#`, `Total edited`, and `Volume per "1"` columns  
-    - Generate pipetting commands dynamically for any number of positions  
-    - Use one source well per source index and reroute to the next source if a well is full  
-    - Display and allow CSV download for both commands and source volume summaries  
+    - Calculate total demand per input and suggest a **uniform layout width** (consecutive wells per input)  
+    - **Preview** the layout on a plate map (with tooltips)  
+    - After confirmation, generate pipetting commands and a source volume summary  
     """)
 
     uploaded = st.file_uploader("📤 Upload data file", type=["xlsx", "csv", "txt"])
-    max_per_well_ul = st.number_input("Maximum volume per source well (µL)", min_value=10.0, max_value=1000.0, value=160.0, step=10.0)
-
+    max_per_well_ul = st.number_input(
+        "Maximum volume per source well (µL)",
+        min_value=10.0, max_value=2000.0, value=160.0, step=10.0
+    )
+
+    # ---------- Helpers (plate geometry & viz) ----------
+    ROWS_96 = ["A", "B", "C", "D", "E", "F", "G", "H"]
+    COLS_96 = list(range(1, 13))
+
+    def well_name(row_letter, col_number):
+        return f"{row_letter}{col_number}"
+
+    def enumerate_plate_wells():
+        """Yield wells A1..A12, B1..B12, ..., H12 for a single plate."""
+        for r in ROWS_96:
+            for c in COLS_96:
+                yield f"{r}{c}"
+
+    def sample_index_to_plate_and_well(sample_idx: int):
+        """Destination mapping: 96-well plates in reading order, extends to multiple plates."""
+        plate_num = ((sample_idx - 1) // 96) + 1
+        within_plate = (sample_idx - 1) % 96
+        row_idx = within_plate // 12
+        col_idx = within_plate % 12
+        return plate_num, well_name(ROWS_96[row_idx], COLS_96[col_idx])
+
+    def build_global_wells_list(n_plates: int):
+        out = []
+        for p in range(1, n_plates + 1):
+            for w in enumerate_plate_wells():
+                out.append((p, w))
+        return out
+
+    def pick_tool(volume_ul: float) -> str:
+        return "TS_10" if volume_ul <= 10.0 else "TS_50"
+
+    # Color palette (cycled if many inputs)
+    PALETTE = [
+        "#4F46E5", "#22C55E", "#F59E0B", "#EF4444", "#06B6D4", "#A855F7", "#84CC16", "#F97316",
+        "#0EA5E9", "#E11D48", "#10B981", "#7C3AED", "#15803D", "#EA580C", "#2563EB", "#DC2626"
+    ]
+
+    def render_plate_map_html(plates_used, well_to_input, max_wells_per_source, inputs_count):
+        """
+        Render HTML plates. well_to_input: dict[(plate, well)] = (input_idx, index_within_input_block)
+        """
+        # Legend HTML
+        legend_spans = []
+        for i in range(1, inputs_count + 1):
+            color = PALETTE[(i-1) % len(PALETTE)]
+            legend_spans.append(
+                f"<span style='display:inline-block;margin-right:12px'>"
+                f"<span style='display:inline-block;width:12px;height:12px;background:{color};border:1px solid #333;margin-right:6px;vertical-align:middle'></span>"
+                f"Input {i}</span>"
+            )
+        legend_html = "<div style='margin:8px 0 16px 0'>" + "".join(legend_spans) + "</div>"
+
+        # CSS for grid + tooltip (title attribute works too; we use both)
+        css = """
+        <style>
+        .plate { margin: 10px 0 24px 0; }
+        .plate-title { font-weight: 600; margin: 4px 0 8px 0; }
+        .grid { display: grid; grid-template-columns: 32px repeat(12, 38px); grid-auto-rows: 32px; gap: 4px; }
+        .cell { width: 38px; height: 32px; border: 1px solid #DDD; display:flex; align-items:center; justify-content:center; font-size:12px; background:#FAFAFA; position:relative; }
+        .head { font-weight:600; background:#F3F4F6; }
+        .cell[data-color] { color:#111; }
+        .cell .tip { visibility:hidden; opacity:0; transition:opacity 0.15s ease; position:absolute; bottom:100%; transform:translateY(-6px); left:50%; transform:translate(-50%, -6px); background:#111; color:#fff; padding:4px 6px; font-size:11px; border-radius:4px; white-space:nowrap; pointer-events:none; }
+        .cell:hover .tip { visibility:visible; opacity:0.95; }
+        </style>
+        """
+
+        body = [css, legend_html]
+        # Build each plate
+        for p in range(1, plates_used + 1):
+            body.append(f"<div class='plate'><div class='plate-title'>Plate {p}</div>")
+            # header row
+            body.append("<div class='grid'>")
+            body.append("<div class='cell head'></div>")
+            for c in COLS_96:
+                body.append(f"<div class='cell head'>{c}</div>")
+            # rows
+            for r in ROWS_96:
+                body.append(f"<div class='cell head'>{r}</div>")
+                for c in COLS_96:
+                    well = f"{r}{c}"
+                    key = (p, well)
+                    if key in well_to_input:
+                        input_idx, within_idx = well_to_input[key]
+                        color = PALETTE[(input_idx-1) % len(PALETTE)]
+                        tip = f"Input {input_idx} • P{p}:{well} • Block well {within_idx}/{max_wells_per_source}"
+                        cell_html = (
+                            f"<div class='cell' data-color style='background:{color};border-color:#555' title='{tip}'>"
+                            f"<span class='tip'>{tip}</span>"
+                            "</div>"
+                        )
+                    else:
+                        cell_html = "<div class='cell'></div>"
+                    body.append(cell_html)
+            body.append("</div></div>")  # grid + plate
+
+        return "".join(body)
+
+    # ---------- Main flow ----------
     if uploaded is not None:
         try:
             # --- Load file ---
             if uploaded.name.endswith(".xlsx"):
-                sheet_names = pd.ExcelFile(uploaded).sheet_names
-                sheet_choice = st.selectbox("Select sheet:", sheet_names)
-                df = pd.read_excel(uploaded, sheet_name=sheet_choice)
+                xls = pd.ExcelFile(uploaded)
+                sheet_choice = st.selectbox("Select sheet:", xls.sheet_names)
+                df = pd.read_excel(xls, sheet_name=sheet_choice)
             elif uploaded.name.endswith(".csv"):
                 df = pd.read_csv(uploaded)
-            else:  # TXT
-                df = pd.read_csv(uploaded, sep="\t")
+            else:  # TXT (tab-delimited fallback)
+                try:
+                    df = pd.read_csv(uploaded, sep="\t")
+                except Exception:
+                    df = pd.read_csv(uploaded)
 
             st.success(f"✅ Loaded file with {len(df)} rows and {len(df.columns)} columns")
 
@@ -220,159 +329,192 @@ with tab3:
                 position_cols = candidate_cols
                 st.info(f"Position columns inferred automatically: {len(position_cols)} detected.")
 
+            # Normalize Position columns to numeric {0,1}
+            df[position_cols] = df[position_cols].apply(pd.to_numeric, errors="coerce").fillna(0).astype(int)
+
             # --- Ensure Total edited ---
             if "Total edited" not in df.columns:
-                df["Total edited"] = df[position_cols].apply(pd.to_numeric, errors="coerce").fillna(0).sum(axis=1).astype(int)
+                df["Total edited"] = df[position_cols].sum(axis=1).astype(int)
                 st.info("`Total edited` column missing — calculated automatically as sum of 1s per row.")
 
             # --- Ensure Volume per "1" ---
             vol_candidates = [c for c in df.columns if "volume per" in c.lower()]
             if not vol_candidates:
                 df['Volume per "1"'] = 64 / df["Total edited"].replace(0, np.nan)
-                df['Volume per "1"'] = df['Volume per "1"'].fillna(0)
+                df['Volume per "1"'] = df['Volume per "1"'].fillna(0)  # rows with 0 edits → 0 µL
                 st.info('`Volume per "1"` column missing — calculated automatically as 64 / Total edited.')
                 volume_col = 'Volume per "1"'
             else:
                 volume_col = vol_candidates[0]
 
-            # --- Constants ---
-            ROWS_96 = ["A", "B", "C", "D", "E", "F", "G", "H"]
-            COLS_96 = list(range(1, 13))
-            num_positions = len(position_cols)
-
-            def well_name(row_letter, col_number):
-                return f"{row_letter}{col_number}"
-
-            def sample_index_to_plate_and_well(sample_idx):
-                plate_num = ((sample_idx - 1) // 96) + 1
-                within_plate = (sample_idx - 1) % 96
-                row_idx = within_plate // 12
-                col_idx = within_plate % 12
-                return plate_num, well_name(ROWS_96[row_idx], COLS_96[col_idx])
-
-            # one well per source index
-            def source_index_to_well(source_idx):
-                plate_num = ((source_idx - 1) // 96) + 1
-                within_plate = (source_idx - 1) % 96
-                row_idx = within_plate // 12
-                col_idx = within_plate % 12
-                return plate_num, well_name(ROWS_96[row_idx], COLS_96[col_idx])
-
-            def pick_tool(volume_ul):
-                return "TS_10" if volume_ul <= 10.0 else "TS_50"
-
-            # --- Core logic ---
-            commands = []
-            source_volume_totals = {}
-            per_source_vol = {i: 0.0 for i in range(1, num_positions + 1)}
-
-            for _, row in df.iterrows():
-                sample_id = int(row["Sample"])
-                vol_per_one = float(row[volume_col])
-                if vol_per_one > max_per_well_ul:
-                    st.warning(f"Volume per '1' ({vol_per_one} µL) exceeds per-well cap of {max_per_well_ul} µL for sample {sample_id}.")
-                dest_plate, dest_well = sample_index_to_plate_and_well(sample_id)
-                tool = pick_tool(vol_per_one)
-
-                for pos_idx, col in enumerate(position_cols, 1):
-                    val = row[col]
-                    try:
-                        is_one = (float(val) == 1.0)
-                    except:
-                        is_one = str(val).strip() == "1"
-                    if not is_one:
+            # Safety: per-transfer must not exceed per-well cap
+            if df[volume_col].max() > max_per_well_ul:
+                st.error(
+                    f"❌ At least one row has `Volume per \"1\"` greater than the per-well cap ({max_per_well_ul} µL). "
+                    "Increase the cap or reduce per-transfer volume."
+                )
+                st.stop()
+
+            # --- Compute total demand per input ---
+            vol_per_one_series = pd.to_numeric(df[volume_col], errors="coerce").fillna(0.0)
+            total_volume_per_input = []
+            for pos in position_cols:
+                mask = df[pos] == 1
+                total_vol = float(vol_per_one_series[mask].sum())
+                total_volume_per_input.append(total_vol)
+
+            wells_needed_per_input = [
+                int(ceil(tv / max_per_well_ul)) if tv > 0 else 0
+                for tv in total_volume_per_input
+            ]
+            num_inputs = len(position_cols)
+            max_wells_per_source = max(wells_needed_per_input) if wells_needed_per_input else 0
+
+            st.markdown("### 👀 Preview: Suggested Uniform Layout")
+            if max_wells_per_source == 0:
+                st.info("No edits detected (all inputs require 0 µL). Nothing to allocate.")
+                st.stop()
+
+            st.write(
+                f"💡 Suggested layout: **{max_wells_per_source} consecutive wells per input** "
+                f"(cap {max_per_well_ul:.0f} µL/well)."
+            )
+
+            # Total wells and plates needed
+            total_wells_needed_uniform = num_inputs * max_wells_per_source
+            plates_needed = int(ceil(total_wells_needed_uniform / 96)) if total_wells_needed_uniform > 0 else 1
+
+            # Global wells list long enough to cover allocation
+            global_wells = build_global_wells_list(plates_needed)  # [(p, 'A1'), ...]
+            global_wells = global_wells[:total_wells_needed_uniform]  # exact length
+
+            # Assign blocks of size max_wells_per_source per input in order
+            assigned_wells_map = {}  # input_idx (1-based) -> list[(plate, well)]
+            well_to_input = {}       # (plate, well) -> (input_idx, within_block_index 1..max_wells_per_source)
+            preview_rows = []
+            for i in range(1, num_inputs + 1):
+                start = (i - 1) * max_wells_per_source
+                end = start + max_wells_per_source
+                block = global_wells[start:end]
+                assigned_wells_map[i] = block
+                for j, (p, w) in enumerate(block, start=1):
+                    well_to_input[(p, w)] = (i, j)
+                # Make a readable block string
+                block_str = ", ".join([f"P{p}:{w}" for (p, w) in block])
+                preview_rows.append({
+                    "Input (Position #)": i,
+                    "Total demand (µL)": round(total_volume_per_input[i-1], 2),
+                    "Wells needed (actual)": wells_needed_per_input[i-1],
+                    "Allocated (uniform)": max_wells_per_source,
+                    "Assigned wells": block_str
+                })
+
+            preview_df = pd.DataFrame(preview_rows)
+            st.dataframe(preview_df, use_container_width=True, height=300)
+
+            # Fancy Plate Map with tooltips
+            st.markdown("#### Plate Map (hover cells for details)")
+            plate_html = render_plate_map_html(plates_needed, well_to_input, max_wells_per_source, num_inputs)
+            st.markdown(plate_html, unsafe_allow_html=True)
+
+            # --- Generate Commands ---
+            st.markdown("### ✅ Generate Pipetting Commands")
+            generate = st.button("Generate using this layout")
+
+            if generate:
+                # Track per-input per-well usage (µL)
+                per_input_well_cum = {i: [0.0] * max_wells_per_source for i in range(1, num_inputs + 1)}
+                commands = []
+                source_volume_totals = {}  # (plate, well) -> total µL drawn
+
+                for _, row in df.iterrows():
+                    sample_id = int(row["Sample"])
+                    vol_per_one = float(row[volume_col])
+                    if vol_per_one <= 0:
                         continue
+                    dest_plate, dest_well = sample_index_to_plate_and_well(sample_id)
+                    tool = pick_tool(vol_per_one)
+
+                    for pos_idx, col in enumerate(position_cols, start=1):
+                        if int(row[col]) != 1:
+                            continue
+
+                        wells_for_input = assigned_wells_map[pos_idx]
+                        cum_list = per_input_well_cum[pos_idx]
 
-                    src_plate, src_well = source_index_to_well(pos_idx)
-                    current_vol = per_source_vol[pos_idx]
-
-                    # reroute if source full
-                    if current_vol + vol_per_one > max_per_well_ul:
-                        rerouted = False
-                        for next_src in range(pos_idx + 1, num_positions + 1):
-                            next_plate, next_well = source_index_to_well(next_src)
-                            if per_source_vol[next_src] + vol_per_one <= max_per_well_ul:
-                                st.warning(f"⚠️ Source {pos_idx} full → rerouted {vol_per_one:.2f} µL to Source {next_src}.")
-                                per_source_vol[next_src] += vol_per_one
-                                source_volume_totals[(next_plate, next_well)] = source_volume_totals.get((next_plate, next_well), 0.0) + vol_per_one
-                                commands.append({
-                                    "SourceIdx": f"{pos_idx}→{next_src}",
-                                    "Source plate": next_plate,
-                                    "Source well": next_well,
-                                    "Destination plate": dest_plate,
-                                    "Destination well": dest_well,
-                                    "Volume": round(vol_per_one, 2),
-                                    "Tool": tool,
-                                    "Note": "Rerouted due to full source"
-                                })
-                                rerouted = True
+                        chosen = None
+                        for j, ((src_plate, src_well), current_vol) in enumerate(zip(wells_for_input, cum_list)):
+                            if current_vol + vol_per_one <= max_per_well_ul:
+                                chosen = (j, src_plate, src_well)
                                 break
-                        if not rerouted:
-                            st.error(f"❌ All sources from {pos_idx} onward full. Cannot add {vol_per_one} µL for Sample {sample_id}.")
+
+                        if chosen is None:
+                            # With uniform pre-allocation this shouldn't happen unless extreme rounding / cap too small
+                            st.error(
+                                f"Allocation exhausted for Input {pos_idx} while creating commands. "
+                                "Increase the max volume per well or review per-transfer volume."
+                            )
                             st.stop()
-                        continue  # skip normal addition
-
-                    # normal case
-                    per_source_vol[pos_idx] += vol_per_one
-                    source_volume_totals[(src_plate, src_well)] = source_volume_totals.get((src_plate, src_well), 0.0) + vol_per_one
-                    commands.append({
-                        "SourceIdx": pos_idx,
-                        "Source plate": src_plate,
-                        "Source well": src_well,
-                        "Destination plate": dest_plate,
-                        "Destination well": dest_well,
-                        "Volume": round(vol_per_one, 2),
-                        "Tool": tool
-                    })
-
-            # --- Compile results ---
-            commands_df = pd.DataFrame(commands)
-            commands_df = commands_df.sort_values(
-                by=["Source plate", "Source well", "Destination plate", "Destination well"],
-                kind="stable"
-            )
 
-            if "Note" in commands_df.columns:
-                commands_df = commands_df[["SourceIdx", "Source plate", "Source well",
-                                            "Destination plate", "Destination well", "Volume", "Tool", "Note"]]
-            else:
+                        j, src_plate, src_well = chosen
+                        cum_list[j] += vol_per_one
+                        per_input_well_cum[pos_idx] = cum_list
+                        source_volume_totals[(src_plate, src_well)] = source_volume_totals.get((src_plate, src_well), 0.0) + vol_per_one
+
+                        commands.append({
+                            "SourceIdx": pos_idx,
+                            "Source plate": src_plate,
+                            "Source well": src_well,
+                            "Destination plate": dest_plate,
+                            "Destination well": dest_well,
+                            "Volume": round(vol_per_one, 2),
+                            "Tool": tool
+                        })
+
+                # Compile results
+                commands_df = pd.DataFrame(commands).sort_values(
+                    by=["Source plate", "Source well", "Destination plate", "Destination well"], kind="stable"
+                )
                 commands_df = commands_df[["SourceIdx", "Source plate", "Source well",
-                                            "Destination plate", "Destination well", "Volume", "Tool"]]
-
-            # --- Source summary ---
-            summary_rows = []
-            for src_idx in range(1, num_positions + 1):
-                src_plate, src_well = source_index_to_well(src_idx)
-                total = source_volume_totals.get((src_plate, src_well), 0.0)
-                summary_rows.append({
-                    "Source": src_idx,
-                    "Source plate": src_plate,
-                    "Source well": src_well,
-                    "Total volume taken (µL)": round(total, 2)
-                })
-            summary_df = pd.DataFrame(summary_rows)
-
-            st.success(f"✅ Generated {len(commands_df)} commands across {num_positions} positions.")
-
-            st.markdown("### 💧 Pipetting Commands")
-            st.dataframe(commands_df, use_container_width=True, height=400)
-            st.download_button(
-                "⬇️ Download Commands CSV",
-                commands_df.to_csv(index=False),
-                "pipetting_commands.csv",
-                mime="text/csv"
-            )
+                                           "Destination plate", "Destination well", "Volume", "Tool"]]
+
+                # Source summary (include allocated capacity per well)
+                summary_rows = []
+                for i in range(1, num_inputs + 1):
+                    for (p, w), used in zip(assigned_wells_map[i], per_input_well_cum[i]):
+                        total = source_volume_totals.get((p, w), 0.0)
+                        summary_rows.append({
+                            "Source": i,
+                            "Source plate": p,
+                            "Source well": w,
+                            "Total volume taken (µL)": round(total, 2),
+                            "Allocated capacity (µL)": round(max_per_well_ul, 2)
+                        })
+                summary_df = pd.DataFrame(summary_rows)
+
+                used_plates = max([p for wells in assigned_wells_map.values() for (p, _) in wells]) if assigned_wells_map else 1
+                st.success(f"✅ Generated {len(commands_df)} commands across {num_inputs} inputs using {used_plates} plate(s).")
+
+                st.markdown("### 💧 Pipetting Commands")
+                st.dataframe(commands_df, use_container_width=True, height=400)
+                st.download_button(
+                    "⬇️ Download Commands CSV",
+                    commands_df.to_csv(index=False),
+                    "pipetting_commands.csv",
+                    mime="text/csv"
+                )
 
-            st.markdown("### 📊 Source Volume Summary")
-            st.dataframe(summary_df, use_container_width=True, height=400)
-            st.download_button(
-                "⬇️ Download Source Summary CSV",
-                summary_df.to_csv(index=False),
-                "source_volume_summary.csv",
-                mime="text/csv"
-            )
+                st.markdown("### 📊 Source Volume Summary")
+                st.dataframe(summary_df, use_container_width=True, height=400)
+                st.download_button(
+                    "⬇️ Download Source Summary CSV",
+                    summary_df.to_csv(index=False),
+                    "source_volume_summary.csv",
+                    mime="text/csv"
+                )
 
         except Exception as e:
             st.error(f"❌ Error processing file: {e}")
     else:
-        st.info("👆 Upload an Excel/CSV/TXT file to start generating pipetting commands.")
+        st.info("👆 Upload an Excel/CSV/TXT file to start.")
+